FFmpeg  2.6.3
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
proresenc_anatoliy.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2011 Anatoliy Wasserman
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Apple ProRes encoder (Anatoliy Wasserman version)
26  * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy)
27  */
28 
29 #include "avcodec.h"
30 #include "dct.h"
31 #include "internal.h"
32 #include "put_bits.h"
33 #include "bytestream.h"
34 #include "fdctdsp.h"
35 
36 #define DEFAULT_SLICE_MB_WIDTH 8
37 
38 #define FF_PROFILE_PRORES_PROXY 0
39 #define FF_PROFILE_PRORES_LT 1
40 #define FF_PROFILE_PRORES_STANDARD 2
41 #define FF_PROFILE_PRORES_HQ 3
42 
43 static const AVProfile profiles[] = {
44  { FF_PROFILE_PRORES_PROXY, "apco"},
45  { FF_PROFILE_PRORES_LT, "apcs"},
46  { FF_PROFILE_PRORES_STANDARD, "apcn"},
47  { FF_PROFILE_PRORES_HQ, "apch"},
49 };
50 
51 static const int qp_start_table[4] = { 4, 1, 1, 1 };
52 static const int qp_end_table[4] = { 8, 9, 6, 6 };
53 static const int bitrate_table[5] = { 1000, 2100, 3500, 5400 };
54 
55 static const uint8_t progressive_scan[64] = {
56  0, 1, 8, 9, 2, 3, 10, 11,
57  16, 17, 24, 25, 18, 19, 26, 27,
58  4, 5, 12, 20, 13, 6, 7, 14,
59  21, 28, 29, 22, 15, 23, 30, 31,
60  32, 33, 40, 48, 41, 34, 35, 42,
61  49, 56, 57, 50, 43, 36, 37, 44,
62  51, 58, 59, 52, 45, 38, 39, 46,
63  53, 60, 61, 54, 47, 55, 62, 63
64 };
65 
66 static const uint8_t QMAT_LUMA[4][64] = {
67  {
68  4, 7, 9, 11, 13, 14, 15, 63,
69  7, 7, 11, 12, 14, 15, 63, 63,
70  9, 11, 13, 14, 15, 63, 63, 63,
71  11, 11, 13, 14, 63, 63, 63, 63,
72  11, 13, 14, 63, 63, 63, 63, 63,
73  13, 14, 63, 63, 63, 63, 63, 63,
74  13, 63, 63, 63, 63, 63, 63, 63,
75  63, 63, 63, 63, 63, 63, 63, 63
76  }, {
77  4, 5, 6, 7, 9, 11, 13, 15,
78  5, 5, 7, 8, 11, 13, 15, 17,
79  6, 7, 9, 11, 13, 15, 15, 17,
80  7, 7, 9, 11, 13, 15, 17, 19,
81  7, 9, 11, 13, 14, 16, 19, 23,
82  9, 11, 13, 14, 16, 19, 23, 29,
83  9, 11, 13, 15, 17, 21, 28, 35,
84  11, 13, 16, 17, 21, 28, 35, 41
85  }, {
86  4, 4, 5, 5, 6, 7, 7, 9,
87  4, 4, 5, 6, 7, 7, 9, 9,
88  5, 5, 6, 7, 7, 9, 9, 10,
89  5, 5, 6, 7, 7, 9, 9, 10,
90  5, 6, 7, 7, 8, 9, 10, 12,
91  6, 7, 7, 8, 9, 10, 12, 15,
92  6, 7, 7, 9, 10, 11, 14, 17,
93  7, 7, 9, 10, 11, 14, 17, 21
94  }, {
95  4, 4, 4, 4, 4, 4, 4, 4,
96  4, 4, 4, 4, 4, 4, 4, 4,
97  4, 4, 4, 4, 4, 4, 4, 4,
98  4, 4, 4, 4, 4, 4, 4, 5,
99  4, 4, 4, 4, 4, 4, 5, 5,
100  4, 4, 4, 4, 4, 5, 5, 6,
101  4, 4, 4, 4, 5, 5, 6, 7,
102  4, 4, 4, 4, 5, 6, 7, 7
103  }
104 };
105 
106 static const uint8_t QMAT_CHROMA[4][64] = {
107  {
108  4, 7, 9, 11, 13, 14, 63, 63,
109  7, 7, 11, 12, 14, 63, 63, 63,
110  9, 11, 13, 14, 63, 63, 63, 63,
111  11, 11, 13, 14, 63, 63, 63, 63,
112  11, 13, 14, 63, 63, 63, 63, 63,
113  13, 14, 63, 63, 63, 63, 63, 63,
114  13, 63, 63, 63, 63, 63, 63, 63,
115  63, 63, 63, 63, 63, 63, 63, 63
116  }, {
117  4, 5, 6, 7, 9, 11, 13, 15,
118  5, 5, 7, 8, 11, 13, 15, 17,
119  6, 7, 9, 11, 13, 15, 15, 17,
120  7, 7, 9, 11, 13, 15, 17, 19,
121  7, 9, 11, 13, 14, 16, 19, 23,
122  9, 11, 13, 14, 16, 19, 23, 29,
123  9, 11, 13, 15, 17, 21, 28, 35,
124  11, 13, 16, 17, 21, 28, 35, 41
125  }, {
126  4, 4, 5, 5, 6, 7, 7, 9,
127  4, 4, 5, 6, 7, 7, 9, 9,
128  5, 5, 6, 7, 7, 9, 9, 10,
129  5, 5, 6, 7, 7, 9, 9, 10,
130  5, 6, 7, 7, 8, 9, 10, 12,
131  6, 7, 7, 8, 9, 10, 12, 15,
132  6, 7, 7, 9, 10, 11, 14, 17,
133  7, 7, 9, 10, 11, 14, 17, 21
134  }, {
135  4, 4, 4, 4, 4, 4, 4, 4,
136  4, 4, 4, 4, 4, 4, 4, 4,
137  4, 4, 4, 4, 4, 4, 4, 4,
138  4, 4, 4, 4, 4, 4, 4, 5,
139  4, 4, 4, 4, 4, 4, 5, 5,
140  4, 4, 4, 4, 4, 5, 5, 6,
141  4, 4, 4, 4, 5, 5, 6, 7,
142  4, 4, 4, 4, 5, 6, 7, 7
143  }
144 };
145 
146 
147 typedef struct {
152 
153  int qmat_luma[16][64];
154  int qmat_chroma[16][64];
155 } ProresContext;
156 
157 static void encode_codeword(PutBitContext *pb, int val, int codebook)
158 {
159  unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros,
160  mask;
161 
162  /* number of bits to switch between rice and exp golomb */
163  switch_bits = codebook & 3;
164  rice_order = codebook >> 5;
165  exp_order = (codebook >> 2) & 7;
166 
167  first_exp = ((switch_bits + 1) << rice_order);
168 
169  if (val >= first_exp) { /* exp golomb */
170  val -= first_exp;
171  val += (1 << exp_order);
172  exp = av_log2(val);
173  zeros = exp - exp_order + switch_bits + 1;
174  put_bits(pb, zeros, 0);
175  put_bits(pb, exp + 1, val);
176  } else if (rice_order) {
177  mask = (1 << rice_order) - 1;
178  put_bits(pb, (val >> rice_order), 0);
179  put_bits(pb, 1, 1);
180  put_bits(pb, rice_order, val & mask);
181  } else {
182  put_bits(pb, val, 0);
183  put_bits(pb, 1, 1);
184  }
185 }
186 
187 #define QSCALE(qmat,ind,val) ((val) / ((qmat)[ind]))
188 #define TO_GOLOMB(val) (((val) << 1) ^ ((val) >> 31))
189 #define DIFF_SIGN(val, sign) (((val) >> 31) ^ (sign))
190 #define IS_NEGATIVE(val) ((((val) >> 31) ^ -1) + 1)
191 #define TO_GOLOMB2(val,sign) ((val)==0 ? 0 : ((val) << 1) + (sign))
192 
194 {
195  int sign = (val >> 31);
196  return (val ^ sign) - sign;
197 }
198 
199 #define FIRST_DC_CB 0xB8
200 
201 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
202 
203 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
204  int blocks_per_slice, int *qmat)
205 {
206  int prev_dc, code;
207  int i, sign, idx;
208  int new_dc, delta, diff_sign, new_code;
209 
210  prev_dc = QSCALE(qmat, 0, in[0] - 16384);
211  code = TO_GOLOMB(prev_dc);
212  encode_codeword(pb, code, FIRST_DC_CB);
213 
214  code = 5; sign = 0; idx = 64;
215  for (i = 1; i < blocks_per_slice; i++, idx += 64) {
216  new_dc = QSCALE(qmat, 0, in[idx] - 16384);
217  delta = new_dc - prev_dc;
218  diff_sign = DIFF_SIGN(delta, sign);
219  new_code = TO_GOLOMB2(get_level(delta), diff_sign);
220 
221  encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
222 
223  code = new_code;
224  sign = delta >> 31;
225  prev_dc = new_dc;
226  }
227 }
228 
229 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
230  0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
231 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
232  0x28, 0x28, 0x28, 0x4C };
233 
235  int16_t *in, int blocks_per_slice, int *qmat)
236 {
237  int prev_run = 4;
238  int prev_level = 2;
239 
240  int run = 0, level, code, i, j;
241  for (i = 1; i < 64; i++) {
242  int indp = progressive_scan[i];
243  for (j = 0; j < blocks_per_slice; j++) {
244  int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
245  if (val) {
246  encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
247 
248  prev_run = run;
249  run = 0;
250  level = get_level(val);
251  code = level - 1;
252 
253  encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
254 
255  prev_level = level;
256 
257  put_bits(pb, 1, IS_NEGATIVE(val));
258  } else {
259  ++run;
260  }
261  }
262  }
263 }
264 
265 static void get(uint8_t *pixels, int stride, int16_t* block)
266 {
267  int i;
268 
269  for (i = 0; i < 8; i++) {
270  AV_WN64(block, AV_RN64(pixels));
271  AV_WN64(block+4, AV_RN64(pixels+8));
272  pixels += stride;
273  block += 8;
274  }
275 }
276 
277 static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
278 {
279  get(pixels, stride, block);
280  fdsp->fdct(block);
281 }
282 
283 static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
284  uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
285  int *qmat, int chroma)
286 {
287  ProresContext* ctx = avctx->priv_data;
288  FDCTDSPContext *fdsp = &ctx->fdsp;
289  DECLARE_ALIGNED(16, int16_t, blocks)[DEFAULT_SLICE_MB_WIDTH << 8], *block;
290  int i, blocks_per_slice;
291  PutBitContext pb;
292 
293  block = blocks;
294  for (i = 0; i < mb_count; i++) {
295  fdct_get(fdsp, src, src_stride, block + (0 << 6));
296  fdct_get(fdsp, src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
297  if (!chroma) {
298  fdct_get(fdsp, src + 16, src_stride, block + (1 << 6));
299  fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
300  }
301 
302  block += (256 >> chroma);
303  src += (32 >> chroma);
304  }
305 
306  blocks_per_slice = mb_count << (2 - chroma);
307  init_put_bits(&pb, buf, buf_size);
308 
309  encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
310  encode_ac_coeffs(avctx, &pb, blocks, blocks_per_slice, qmat);
311 
312  flush_put_bits(&pb);
313  return put_bits_ptr(&pb) - pb.buf;
314 }
315 
317  uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride,
318  int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size,
319  unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
320  int qp)
321 {
322  ProresContext* ctx = avctx->priv_data;
323 
324  *y_data_size = encode_slice_plane(avctx, mb_count, dest_y, luma_stride,
325  buf, data_size, ctx->qmat_luma[qp - 1], 0);
326 
327  if (!(avctx->flags & CODEC_FLAG_GRAY)) {
328  *u_data_size = encode_slice_plane(avctx, mb_count, dest_u,
329  chroma_stride, buf + *y_data_size, data_size - *y_data_size,
330  ctx->qmat_chroma[qp - 1], 1);
331 
332  *v_data_size = encode_slice_plane(avctx, mb_count, dest_v,
333  chroma_stride, buf + *y_data_size + *u_data_size,
334  data_size - *y_data_size - *u_data_size,
335  ctx->qmat_chroma[qp - 1], 1);
336  }
337 
338  return *y_data_size + *u_data_size + *v_data_size;
339 }
340 
341 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
342  unsigned stride, unsigned width, unsigned height, uint16_t *dst,
343  unsigned dst_width, unsigned dst_height)
344 {
345 
346  int box_width = FFMIN(width - x, dst_width);
347  int box_height = FFMIN(height - y, dst_height);
348  int i, j, src_stride = stride >> 1;
349  uint16_t last_pix, *last_line;
350 
351  src += y * src_stride + x;
352  for (i = 0; i < box_height; ++i) {
353  for (j = 0; j < box_width; ++j) {
354  dst[j] = src[j];
355  }
356  last_pix = dst[j - 1];
357  for (; j < dst_width; j++)
358  dst[j] = last_pix;
359  src += src_stride;
360  dst += dst_width;
361  }
362  last_line = dst - dst_width;
363  for (; i < dst_height; i++) {
364  for (j = 0; j < dst_width; ++j) {
365  dst[j] = last_line[j];
366  }
367  dst += dst_width;
368  }
369 }
370 
371 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
372  int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
373  int unsafe, int *qp)
374 {
375  int luma_stride, chroma_stride;
376  int hdr_size = 6, slice_size;
377  uint8_t *dest_y, *dest_u, *dest_v;
378  unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0;
379  ProresContext* ctx = avctx->priv_data;
380  int tgt_bits = (mb_count * bitrate_table[avctx->profile]) >> 2;
381  int low_bytes = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
382  int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
383 
384  luma_stride = pic->linesize[0];
385  chroma_stride = pic->linesize[1];
386 
387  dest_y = pic->data[0] + (mb_y << 4) * luma_stride + (mb_x << 5);
388  dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << 4);
389  dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << 4);
390 
391  if (unsafe) {
392 
393  subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
394  luma_stride, avctx->width, avctx->height,
395  (uint16_t *) ctx->fill_y, mb_count << 4, 16);
396  subimage_with_fill((uint16_t *) pic->data[1], mb_x << 3, mb_y << 4,
397  chroma_stride, avctx->width >> 1, avctx->height,
398  (uint16_t *) ctx->fill_u, mb_count << 3, 16);
399  subimage_with_fill((uint16_t *) pic->data[2], mb_x << 3, mb_y << 4,
400  chroma_stride, avctx->width >> 1, avctx->height,
401  (uint16_t *) ctx->fill_v, mb_count << 3, 16);
402 
403  encode_slice_data(avctx, ctx->fill_y, ctx->fill_u, ctx->fill_v,
404  mb_count << 5, mb_count << 4, mb_count, buf + hdr_size,
405  data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
406  *qp);
407  } else {
408  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
409  luma_stride, chroma_stride, mb_count, buf + hdr_size,
410  data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
411  *qp);
412 
413  if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
414  do {
415  *qp += 1;
416  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
417  luma_stride, chroma_stride, mb_count, buf + hdr_size,
418  data_size - hdr_size, &y_data_size, &u_data_size,
419  &v_data_size, *qp);
420  } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
421  } else if (slice_size < low_bytes && *qp
422  > qp_start_table[avctx->profile]) {
423  do {
424  *qp -= 1;
425  slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
426  luma_stride, chroma_stride, mb_count, buf + hdr_size,
427  data_size - hdr_size, &y_data_size, &u_data_size,
428  &v_data_size, *qp);
429  } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
430  }
431  }
432 
433  buf[0] = hdr_size << 3;
434  buf[1] = *qp;
435  AV_WB16(buf + 2, y_data_size);
436  AV_WB16(buf + 4, u_data_size);
437 
438  return hdr_size + y_data_size + u_data_size + v_data_size;
439 }
440 
441 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
442  uint8_t *buf, const int buf_size)
443 {
444  int mb_width = (avctx->width + 15) >> 4;
445  int mb_height = (avctx->height + 15) >> 4;
446  int hdr_size, sl_size, i;
447  int mb_y, sl_data_size, qp;
448  int unsafe_bot, unsafe_right;
449  uint8_t *sl_data, *sl_data_sizes;
450  int slice_per_line = 0, rem = mb_width;
451 
452  for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
453  slice_per_line += rem >> i;
454  rem &= (1 << i) - 1;
455  }
456 
457  qp = qp_start_table[avctx->profile];
458  hdr_size = 8; sl_data_size = buf_size - hdr_size;
459  sl_data_sizes = buf + hdr_size;
460  sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
461  for (mb_y = 0; mb_y < mb_height; mb_y++) {
462  int mb_x = 0;
463  int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
464  while (mb_x < mb_width) {
465  while (mb_width - mb_x < slice_mb_count)
466  slice_mb_count >>= 1;
467 
468  unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
469  unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
470 
471  sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
472  sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp);
473 
474  bytestream_put_be16(&sl_data_sizes, sl_size);
475  sl_data += sl_size;
476  sl_data_size -= sl_size;
477  mb_x += slice_mb_count;
478  }
479  }
480 
481  buf[0] = hdr_size << 3;
482  AV_WB32(buf + 1, sl_data - buf);
483  AV_WB16(buf + 5, slice_per_line * mb_height);
484  buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4;
485 
486  return sl_data - buf;
487 }
488 
490  const AVFrame *pict, int *got_packet)
491 {
492  int header_size = 148;
493  uint8_t *buf;
494  int pic_size, ret;
495  int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + FF_MIN_BUFFER_SIZE; //FIXME choose tighter limit
496 
497 
498  if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + FF_MIN_BUFFER_SIZE)) < 0)
499  return ret;
500 
501  buf = pkt->data;
502  pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
503  pkt->size - header_size - 8);
504 
505  bytestream_put_be32(&buf, pic_size + 8 + header_size);
506  bytestream_put_buffer(&buf, "icpf", 4);
507 
508  bytestream_put_be16(&buf, header_size);
509  bytestream_put_be16(&buf, 0);
510  bytestream_put_buffer(&buf, "fmpg", 4);
511  bytestream_put_be16(&buf, avctx->width);
512  bytestream_put_be16(&buf, avctx->height);
513  *buf++ = 0x83; // {10}(422){00}{00}(frame){11}
514  *buf++ = 0;
515  *buf++ = 2;
516  *buf++ = 2;
517  *buf++ = 6;
518  *buf++ = 32;
519  *buf++ = 0;
520  *buf++ = 3;
521 
522  bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile], 64);
523  bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
524 
525  pkt->flags |= AV_PKT_FLAG_KEY;
526  pkt->size = pic_size + 8 + header_size;
527  *got_packet = 1;
528 
529  return 0;
530 }
531 
532 static void scale_mat(const uint8_t* src, int* dst, int scale)
533 {
534  int i;
535  for (i = 0; i < 64; i++)
536  dst[i] = src[i] * scale;
537 }
538 
540 {
541  int i;
542  ProresContext* ctx = avctx->priv_data;
543 
544  if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
545  av_log(avctx, AV_LOG_ERROR, "need YUV422P10\n");
546  return -1;
547  }
548  avctx->bits_per_raw_sample = 10;
549 
550  if (avctx->width & 0x1) {
551  av_log(avctx, AV_LOG_ERROR,
552  "frame width needs to be multiple of 2\n");
553  return -1;
554  }
555 
556  if (avctx->width > 65534 || avctx->height > 65535) {
557  av_log(avctx, AV_LOG_ERROR,
558  "The maximum dimensions are 65534x65535\n");
559  return AVERROR(EINVAL);
560  }
561 
562  if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
563  ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
564  if (!ctx->fill_y)
565  return AVERROR(ENOMEM);
566  ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
567  ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
568  }
569 
570  if (avctx->profile == FF_PROFILE_UNKNOWN) {
572  av_log(avctx, AV_LOG_INFO,
573  "encoding with ProRes standard (apcn) profile\n");
574 
575  } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
576  || avctx->profile > FF_PROFILE_PRORES_HQ) {
577  av_log(
578  avctx,
579  AV_LOG_ERROR,
580  "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
581  avctx->profile);
582  return -1;
583  }
584 
585  ff_fdctdsp_init(&ctx->fdsp, avctx);
586 
587  avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
588 
589  for (i = 1; i <= 16; i++) {
590  scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
591  scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
592  }
593 
594  avctx->coded_frame = av_frame_alloc();
595  avctx->coded_frame->key_frame = 1;
597 
598  return 0;
599 }
600 
602 {
603  ProresContext* ctx = avctx->priv_data;
604  av_frame_free(&avctx->coded_frame);
605  av_freep(&ctx->fill_y);
606 
607  return 0;
608 }
609 
611  .name = "prores_aw",
612  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
613  .type = AVMEDIA_TYPE_VIDEO,
614  .id = AV_CODEC_ID_PRORES,
615  .priv_data_size = sizeof(ProresContext),
617  .close = prores_encode_close,
618  .encode2 = prores_encode_frame,
619  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
621  .profiles = profiles
622 };
623 
625  .name = "prores",
626  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
627  .type = AVMEDIA_TYPE_VIDEO,
628  .id = AV_CODEC_ID_PRORES,
629  .priv_data_size = sizeof(ProresContext),
631  .close = prores_encode_close,
632  .encode2 = prores_encode_frame,
633  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
635  .profiles = profiles
636 };
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1720
const char const char void * val
Definition: avisynth_c.h:672
This structure describes decoded (raw) audio or video data.
Definition: frame.h:163
static const uint8_t QMAT_LUMA[4][64]
static const int bitrate_table[5]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
#define TO_GOLOMB2(val, sign)
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2743
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx, uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride, int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned *y_data_size, unsigned *u_data_size, unsigned *v_data_size, int qp)
int size
Definition: avcodec.h:1161
uint8_t qmat_chroma[64]
dequantization matrix for chroma
Definition: proresdec.h:43
static av_cold int prores_encode_init(AVCodecContext *avctx)
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1442
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x, int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size, int unsafe, int *qp)
#define FF_PROFILE_PRORES_PROXY
uint8_t run
Definition: svq3.c:149
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2725
#define FIRST_DC_CB
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
int profile
profile
Definition: avcodec.h:2833
AVCodec.
Definition: avcodec.h:3173
#define FFALIGN(x, a)
Definition: common.h:71
static int encode_slice_plane(AVCodecContext *avctx, int mb_count, uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size, int *qmat, int chroma)
static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic, uint8_t *buf, const int buf_size)
uint8_t
#define av_cold
Definition: attributes.h:74
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
float delta
#define CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:884
static void encode_dc_coeffs(PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat)
static const uint8_t QMAT_CHROMA[4][64]
static const uint8_t progressive_scan[64]
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2834
uint8_t * data
Definition: avcodec.h:1160
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1206
static const uint8_t lev_to_cb[10]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:219
static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static const uint16_t mask[17]
Definition: lzw.c:38
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:180
static av_cold int prores_encode_close(AVCodecContext *avctx)
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1333
uint8_t * buf
Definition: put_bits.h:38
const char * name
Name of the codec implementation.
Definition: avcodec.h:3180
#define IS_NEGATIVE(val)
Libavcodec external API header.
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1166
static av_always_inline int get_level(int val)
#define TO_GOLOMB(val)
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:234
#define FFMIN(a, b)
Definition: common.h:66
static void scale_mat(const uint8_t *src, int *dst, int scale)
float y
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:635
static const AVProfile profiles[]
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1412
#define FF_PROFILE_PRORES_STANDARD
#define DEFAULT_SLICE_MB_WIDTH
#define AV_RL32
Definition: intreadwrite.h:146
AVCodec ff_prores_encoder
#define AV_LOG_INFO
Standard information.
Definition: log.h:186
int frame_size
Definition: mxfenc.c:1618
AVS_Value src
Definition: avisynth_c.h:524
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:191
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
main external API structure.
Definition: avcodec.h:1239
FDCTDSPContext fdsp
static const uint8_t dc_codebook[7]
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1271
void * buf
Definition: avisynth_c.h:595
BYTE int const BYTE int int int height
Definition: avisynth_c.h:714
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
const char * name
short name for the profile
Definition: avcodec.h:3163
#define QSCALE(qmat, ind, val)
static void encode_codeword(PutBitContext *pb, int val, int codebook)
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:359
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:174
uint8_t level
Definition: svq3.c:150
static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t *block)
static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y, unsigned stride, unsigned width, unsigned height, uint16_t *dst, unsigned dst_width, unsigned dst_height)
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
AVCodec ff_prores_aw_encoder
static const int qp_start_table[4]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:864
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:736
AVProfile.
Definition: avcodec.h:3161
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:366
void * priv_data
Definition: avcodec.h:1281
#define av_log2
Definition: intmath.h:105
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:229
#define AV_RN64(p)
Definition: intreadwrite.h:368
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:37
uint8_t qmat_luma[64]
dequantization matrix for luma
Definition: proresdec.h:42
#define stride
#define FF_PROFILE_PRORES_HQ
#define DIFF_SIGN(val, sign)
static const uint8_t run_to_cb[16]
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
#define FF_PROFILE_PRORES_LT
This structure stores compressed data.
Definition: avcodec.h:1137
static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat)
static const int qp_end_table[4]
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
static int width
bitstream writer API
static int16_t block[64]
Definition: dct-test.c:110