FFmpeg
proresenc_anatoliy.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2011 Anatoliy Wasserman
5  * Copyright (c) 2012 Konstantin Shishkov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * Apple ProRes encoder (Anatoliy Wasserman version)
27  * Known FOURCCs: 'ap4h' (444), 'apch' (HQ), 'apcn' (422), 'apcs' (LT), 'acpo' (Proxy)
28  */
29 
30 #include "libavutil/mem_internal.h"
31 #include "libavutil/opt.h"
32 #include "avcodec.h"
33 #include "dct.h"
34 #include "internal.h"
35 #include "profiles.h"
36 #include "proresdata.h"
37 #include "put_bits.h"
38 #include "bytestream.h"
39 #include "fdctdsp.h"
40 
41 #define DEFAULT_SLICE_MB_WIDTH 8
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"},
48  { FF_PROFILE_PRORES_4444, "ap4h"},
49  { FF_PROFILE_PRORES_XQ, "ap4x"},
50  { FF_PROFILE_UNKNOWN }
51 };
52 
53 static const int qp_start_table[] = { 8, 3, 2, 1, 1, 1};
54 static const int qp_end_table[] = { 13, 9, 6, 6, 5, 4};
55 static const int bitrate_table[] = { 1000, 2100, 3500, 5400, 7000, 10000};
56 
57 static const int valid_primaries[] = { AVCOL_PRI_RESERVED0, AVCOL_PRI_BT709, AVCOL_PRI_UNSPECIFIED, AVCOL_PRI_BT470BG,
58  AVCOL_PRI_SMPTE170M, AVCOL_PRI_BT2020, AVCOL_PRI_SMPTE431, AVCOL_PRI_SMPTE432, INT_MAX };
59 static const int valid_trc[] = { AVCOL_TRC_RESERVED0, AVCOL_TRC_BT709, AVCOL_TRC_UNSPECIFIED, AVCOL_TRC_SMPTE2084,
60  AVCOL_TRC_ARIB_STD_B67, INT_MAX };
61 static const int valid_colorspace[] = { AVCOL_SPC_BT709, AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_SMPTE170M,
62  AVCOL_SPC_BT2020_NCL, INT_MAX };
63 
64 static const uint8_t QMAT_LUMA[6][64] = {
65  {
66  4, 7, 9, 11, 13, 14, 15, 63,
67  7, 7, 11, 12, 14, 15, 63, 63,
68  9, 11, 13, 14, 15, 63, 63, 63,
69  11, 11, 13, 14, 63, 63, 63, 63,
70  11, 13, 14, 63, 63, 63, 63, 63,
71  13, 14, 63, 63, 63, 63, 63, 63,
72  13, 63, 63, 63, 63, 63, 63, 63,
73  63, 63, 63, 63, 63, 63, 63, 63
74  }, {
75  4, 5, 6, 7, 9, 11, 13, 15,
76  5, 5, 7, 8, 11, 13, 15, 17,
77  6, 7, 9, 11, 13, 15, 15, 17,
78  7, 7, 9, 11, 13, 15, 17, 19,
79  7, 9, 11, 13, 14, 16, 19, 23,
80  9, 11, 13, 14, 16, 19, 23, 29,
81  9, 11, 13, 15, 17, 21, 28, 35,
82  11, 13, 16, 17, 21, 28, 35, 41
83  }, {
84  4, 4, 5, 5, 6, 7, 7, 9,
85  4, 4, 5, 6, 7, 7, 9, 9,
86  5, 5, 6, 7, 7, 9, 9, 10,
87  5, 5, 6, 7, 7, 9, 9, 10,
88  5, 6, 7, 7, 8, 9, 10, 12,
89  6, 7, 7, 8, 9, 10, 12, 15,
90  6, 7, 7, 9, 10, 11, 14, 17,
91  7, 7, 9, 10, 11, 14, 17, 21
92  }, {
93  4, 4, 4, 4, 4, 4, 4, 4,
94  4, 4, 4, 4, 4, 4, 4, 4,
95  4, 4, 4, 4, 4, 4, 4, 4,
96  4, 4, 4, 4, 4, 4, 4, 5,
97  4, 4, 4, 4, 4, 4, 5, 5,
98  4, 4, 4, 4, 4, 5, 5, 6,
99  4, 4, 4, 4, 5, 5, 6, 7,
100  4, 4, 4, 4, 5, 6, 7, 7
101  }, { /* 444 */
102  4, 4, 4, 4, 4, 4, 4, 4,
103  4, 4, 4, 4, 4, 4, 4, 4,
104  4, 4, 4, 4, 4, 4, 4, 4,
105  4, 4, 4, 4, 4, 4, 4, 5,
106  4, 4, 4, 4, 4, 4, 5, 5,
107  4, 4, 4, 4, 4, 5, 5, 6,
108  4, 4, 4, 4, 5, 5, 6, 7,
109  4, 4, 4, 4, 5, 6, 7, 7
110  }, { /* 444 XQ */
111  2, 2, 2, 2, 2, 2, 2, 2,
112  2, 2, 2, 2, 2, 2, 2, 2,
113  2, 2, 2, 2, 2, 2, 2, 2,
114  2, 2, 2, 2, 2, 2, 2, 3,
115  2, 2, 2, 2, 2, 2, 3, 3,
116  2, 2, 2, 2, 2, 3, 3, 3,
117  2, 2, 2, 2, 3, 3, 3, 4,
118  2, 2, 2, 2, 3, 3, 4, 4,
119  }
120 };
121 
122 static const uint8_t QMAT_CHROMA[6][64] = {
123  {
124  4, 7, 9, 11, 13, 14, 63, 63,
125  7, 7, 11, 12, 14, 63, 63, 63,
126  9, 11, 13, 14, 63, 63, 63, 63,
127  11, 11, 13, 14, 63, 63, 63, 63,
128  11, 13, 14, 63, 63, 63, 63, 63,
129  13, 14, 63, 63, 63, 63, 63, 63,
130  13, 63, 63, 63, 63, 63, 63, 63,
131  63, 63, 63, 63, 63, 63, 63, 63
132  }, {
133  4, 5, 6, 7, 9, 11, 13, 15,
134  5, 5, 7, 8, 11, 13, 15, 17,
135  6, 7, 9, 11, 13, 15, 15, 17,
136  7, 7, 9, 11, 13, 15, 17, 19,
137  7, 9, 11, 13, 14, 16, 19, 23,
138  9, 11, 13, 14, 16, 19, 23, 29,
139  9, 11, 13, 15, 17, 21, 28, 35,
140  11, 13, 16, 17, 21, 28, 35, 41
141  }, {
142  4, 4, 5, 5, 6, 7, 7, 9,
143  4, 4, 5, 6, 7, 7, 9, 9,
144  5, 5, 6, 7, 7, 9, 9, 10,
145  5, 5, 6, 7, 7, 9, 9, 10,
146  5, 6, 7, 7, 8, 9, 10, 12,
147  6, 7, 7, 8, 9, 10, 12, 15,
148  6, 7, 7, 9, 10, 11, 14, 17,
149  7, 7, 9, 10, 11, 14, 17, 21
150  }, {
151  4, 4, 4, 4, 4, 4, 4, 4,
152  4, 4, 4, 4, 4, 4, 4, 4,
153  4, 4, 4, 4, 4, 4, 4, 4,
154  4, 4, 4, 4, 4, 4, 4, 5,
155  4, 4, 4, 4, 4, 4, 5, 5,
156  4, 4, 4, 4, 4, 5, 5, 6,
157  4, 4, 4, 4, 5, 5, 6, 7,
158  4, 4, 4, 4, 5, 6, 7, 7
159  }, { /* 444 */
160  4, 4, 4, 4, 4, 4, 4, 4,
161  4, 4, 4, 4, 4, 4, 4, 4,
162  4, 4, 4, 4, 4, 4, 4, 4,
163  4, 4, 4, 4, 4, 4, 4, 5,
164  4, 4, 4, 4, 4, 4, 5, 5,
165  4, 4, 4, 4, 4, 5, 5, 6,
166  4, 4, 4, 4, 5, 5, 6, 7,
167  4, 4, 4, 4, 5, 6, 7, 7
168  }, { /* 444 xq */
169  4, 4, 4, 4, 4, 4, 4, 4,
170  4, 4, 4, 4, 4, 4, 4, 4,
171  4, 4, 4, 4, 4, 4, 4, 4,
172  4, 4, 4, 4, 4, 4, 4, 5,
173  4, 4, 4, 4, 4, 4, 5, 5,
174  4, 4, 4, 4, 4, 5, 5, 6,
175  4, 4, 4, 4, 5, 5, 6, 7,
176  4, 4, 4, 4, 5, 6, 7, 7
177  }
178 };
179 
180 
181 typedef struct {
182  AVClass *class;
183  FDCTDSPContext fdsp;
184  uint8_t* fill_y;
185  uint8_t* fill_u;
186  uint8_t* fill_v;
187  uint8_t* fill_a;
188 
189  int qmat_luma[16][64];
190  int qmat_chroma[16][64];
191  const uint8_t *scantable;
192 
193  int is_422;
194  int need_alpha;
195  int is_interlaced;
196 
197  char *vendor;
198 } ProresContext;
199 
200 static void encode_codeword(PutBitContext *pb, int val, int codebook)
201 {
202  unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros;
203 
204  /* number of bits to switch between rice and exp golomb */
205  switch_bits = codebook & 3;
206  rice_order = codebook >> 5;
207  exp_order = (codebook >> 2) & 7;
208 
209  first_exp = ((switch_bits + 1) << rice_order);
210 
211  if (val >= first_exp) { /* exp golomb */
212  val -= first_exp;
213  val += (1 << exp_order);
214  exp = av_log2(val);
215  zeros = exp - exp_order + switch_bits + 1;
216  put_bits(pb, zeros, 0);
217  put_bits(pb, exp + 1, val);
218  } else if (rice_order) {
219  put_bits(pb, (val >> rice_order), 0);
220  put_bits(pb, 1, 1);
221  put_sbits(pb, rice_order, val);
222  } else {
223  put_bits(pb, val, 0);
224  put_bits(pb, 1, 1);
225  }
226 }
227 
228 #define QSCALE(qmat,ind,val) ((val) / ((qmat)[ind]))
229 #define TO_GOLOMB(val) (((val) * 2) ^ ((val) >> 31))
230 #define DIFF_SIGN(val, sign) (((val) >> 31) ^ (sign))
231 #define IS_NEGATIVE(val) ((((val) >> 31) ^ -1) + 1)
232 #define TO_GOLOMB2(val,sign) ((val)==0 ? 0 : ((val) << 1) + (sign))
233 
234 static av_always_inline int get_level(int val)
235 {
236  int sign = (val >> 31);
237  return (val ^ sign) - sign;
238 }
239 
240 #define FIRST_DC_CB 0xB8
241 
242 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
243 
244 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
245  int blocks_per_slice, int *qmat)
246 {
247  int prev_dc, code;
248  int i, sign, idx;
249  int new_dc, delta, diff_sign, new_code;
250 
251  prev_dc = QSCALE(qmat, 0, in[0] - 16384);
252  code = TO_GOLOMB(prev_dc);
253  encode_codeword(pb, code, FIRST_DC_CB);
254 
255  code = 5; sign = 0; idx = 64;
256  for (i = 1; i < blocks_per_slice; i++, idx += 64) {
257  new_dc = QSCALE(qmat, 0, in[idx] - 16384);
258  delta = new_dc - prev_dc;
259  diff_sign = DIFF_SIGN(delta, sign);
260  new_code = TO_GOLOMB2(get_level(delta), diff_sign);
261 
262  encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
263 
264  code = new_code;
265  sign = delta >> 31;
266  prev_dc = new_dc;
267  }
268 }
269 
270 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
271  0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
272 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
273  0x28, 0x28, 0x28, 0x4C };
274 
275 static void encode_ac_coeffs(PutBitContext *pb,
276  int16_t *in, int blocks_per_slice, int *qmat, const uint8_t ff_prores_scan[64])
277 {
278  int prev_run = 4;
279  int prev_level = 2;
280 
281  int run = 0, level, code, i, j;
282  for (i = 1; i < 64; i++) {
283  int indp = ff_prores_scan[i];
284  for (j = 0; j < blocks_per_slice; j++) {
285  int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
286  if (val) {
287  encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
288 
289  prev_run = run;
290  run = 0;
291  level = get_level(val);
292  code = level - 1;
293 
294  encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
295 
296  prev_level = level;
297 
298  put_bits(pb, 1, IS_NEGATIVE(val));
299  } else {
300  ++run;
301  }
302  }
303  }
304 }
305 
306 static void get(uint8_t *pixels, int stride, int16_t* block)
307 {
308  int i;
309 
310  for (i = 0; i < 8; i++) {
311  AV_WN64(block, AV_RN64(pixels));
312  AV_WN64(block+4, AV_RN64(pixels+8));
313  pixels += stride;
314  block += 8;
315  }
316 }
317 
318 static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
319 {
320  get(pixels, stride, block);
321  fdsp->fdct(block);
322 }
323 
324 static void calc_plane_dct(FDCTDSPContext *fdsp, uint8_t *src, int16_t * blocks, int src_stride, int mb_count, int chroma, int is_422)
325 {
326  int16_t *block;
327  int i;
328 
329  block = blocks;
330 
331  if (!chroma) { /* Luma plane */
332  for (i = 0; i < mb_count; i++) {
333  fdct_get(fdsp, src, src_stride, block + (0 << 6));
334  fdct_get(fdsp, src + 16, src_stride, block + (1 << 6));
335  fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (2 << 6));
336  fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
337 
338  block += 256;
339  src += 32;
340  }
341  } else if (chroma && is_422){ /* chroma plane 422 */
342  for (i = 0; i < mb_count; i++) {
343  fdct_get(fdsp, src, src_stride, block + (0 << 6));
344  fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (1 << 6));
345  block += (256 >> 1);
346  src += (32 >> 1);
347  }
348  } else { /* chroma plane 444 */
349  for (i = 0; i < mb_count; i++) {
350  fdct_get(fdsp, src, src_stride, block + (0 << 6));
351  fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (1 << 6));
352  fdct_get(fdsp, src + 16, src_stride, block + (2 << 6));
353  fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
354 
355  block += 256;
356  src += 32;
357  }
358  }
359 }
360 
361 static int encode_slice_plane(int16_t *blocks, int mb_count, uint8_t *buf, unsigned buf_size, int *qmat, int sub_sample_chroma,
362  const uint8_t ff_prores_scan[64])
363 {
364  int blocks_per_slice;
365  PutBitContext pb;
366 
367  blocks_per_slice = mb_count << (2 - sub_sample_chroma);
368  init_put_bits(&pb, buf, buf_size);
369 
370  encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
371  encode_ac_coeffs(&pb, blocks, blocks_per_slice, qmat, ff_prores_scan);
372 
373  flush_put_bits(&pb);
374  return put_bits_ptr(&pb) - pb.buf;
375 }
376 
377 static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
378  int16_t * blocks_y, int16_t * blocks_u, int16_t * blocks_v,
379  unsigned mb_count, uint8_t *buf, unsigned data_size,
380  unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
381  int qp)
382 {
383  ProresContext* ctx = avctx->priv_data;
384 
385  *y_data_size = encode_slice_plane(blocks_y, mb_count,
386  buf, data_size, ctx->qmat_luma[qp - 1], 0, ctx->scantable);
387 
388  if (!(avctx->flags & AV_CODEC_FLAG_GRAY)) {
389  *u_data_size = encode_slice_plane(blocks_u, mb_count, buf + *y_data_size, data_size - *y_data_size,
390  ctx->qmat_chroma[qp - 1], ctx->is_422, ctx->scantable);
391 
392  *v_data_size = encode_slice_plane(blocks_v, mb_count, buf + *y_data_size + *u_data_size,
393  data_size - *y_data_size - *u_data_size,
394  ctx->qmat_chroma[qp - 1], ctx->is_422, ctx->scantable);
395  }
396 
397  return *y_data_size + *u_data_size + *v_data_size;
398 }
399 
400 static void put_alpha_diff(PutBitContext *pb, int cur, int prev)
401 {
402  const int abits = 16;
403  const int dbits = 7;
404  const int dsize = 1 << dbits - 1;
405  int diff = cur - prev;
406 
407  diff = av_mod_uintp2(diff, abits);
408  if (diff >= (1 << abits) - dsize)
409  diff -= 1 << abits;
410  if (diff < -dsize || diff > dsize || !diff) {
411  put_bits(pb, 1, 1);
412  put_bits(pb, abits, diff);
413  } else {
414  put_bits(pb, 1, 0);
415  put_bits(pb, dbits - 1, FFABS(diff) - 1);
416  put_bits(pb, 1, diff < 0);
417  }
418 }
419 
420 static inline void put_alpha_run(PutBitContext *pb, int run)
421 {
422  if (run) {
423  put_bits(pb, 1, 0);
424  if (run < 0x10)
425  put_bits(pb, 4, run);
426  else
427  put_bits(pb, 15, run);
428  } else {
429  put_bits(pb, 1, 1);
430  }
431 }
432 
433 static av_always_inline int encode_alpha_slice_data(AVCodecContext *avctx, int8_t * src_a,
434  unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned* a_data_size)
435 {
436  const int abits = 16;
437  const int mask = (1 << abits) - 1;
438  const int num_coeffs = mb_count * 256;
439  int prev = mask, cur;
440  int idx = 0;
441  int run = 0;
442  int16_t * blocks = (int16_t *)src_a;
443  PutBitContext pb;
444  init_put_bits(&pb, buf, data_size);
445 
446  cur = blocks[idx++];
447  put_alpha_diff(&pb, cur, prev);
448  prev = cur;
449  do {
450  cur = blocks[idx++];
451  if (cur != prev) {
452  put_alpha_run (&pb, run);
453  put_alpha_diff(&pb, cur, prev);
454  prev = cur;
455  run = 0;
456  } else {
457  run++;
458  }
459  } while (idx < num_coeffs);
460  if (run)
461  put_alpha_run(&pb, run);
462  flush_put_bits(&pb);
463  *a_data_size = put_bits_count(&pb) >> 3;
464 
465  if (put_bits_left(&pb) < 0) {
466  av_log(avctx, AV_LOG_ERROR,
467  "Underestimated required buffer size.\n");
468  return AVERROR_BUG;
469  } else {
470  return 0;
471  }
472 }
473 
474 static inline void subimage_with_fill_template(uint16_t *src, unsigned x, unsigned y,
475  unsigned stride, unsigned width, unsigned height, uint16_t *dst,
476  unsigned dst_width, unsigned dst_height, int is_alpha_plane,
477  int is_interlaced, int is_top_field)
478 {
479  int box_width = FFMIN(width - x, dst_width);
480  int i, j, src_stride, box_height;
481  uint16_t last_pix, *last_line;
482 
483  if (!is_interlaced) {
484  src_stride = stride >> 1;
485  src += y * src_stride + x;
486  box_height = FFMIN(height - y, dst_height);
487  } else {
488  src_stride = stride; /* 2 lines stride */
489  src += y * src_stride + x;
490  box_height = FFMIN(height/2 - y, dst_height);
491  if (!is_top_field)
492  src += stride >> 1;
493  }
494 
495  for (i = 0; i < box_height; ++i) {
496  for (j = 0; j < box_width; ++j) {
497  if (!is_alpha_plane) {
498  dst[j] = src[j];
499  } else {
500  dst[j] = src[j] << 6; /* alpha 10b to 16b */
501  }
502  }
503  if (!is_alpha_plane) {
504  last_pix = dst[j - 1];
505  } else {
506  last_pix = dst[j - 1] << 6; /* alpha 10b to 16b */
507  }
508  for (; j < dst_width; j++)
509  dst[j] = last_pix;
510  src += src_stride;
511  dst += dst_width;
512  }
513  last_line = dst - dst_width;
514  for (; i < dst_height; i++) {
515  for (j = 0; j < dst_width; ++j) {
516  dst[j] = last_line[j];
517  }
518  dst += dst_width;
519  }
520 }
521 
522 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
523  unsigned stride, unsigned width, unsigned height, uint16_t *dst,
524  unsigned dst_width, unsigned dst_height, int is_interlaced, int is_top_field)
525 {
526  subimage_with_fill_template(src, x, y, stride, width, height, dst, dst_width, dst_height, 0, is_interlaced, is_top_field);
527 }
528 
529 /* reorganize alpha data and convert 10b -> 16b */
530 static void subimage_alpha_with_fill(uint16_t *src, unsigned x, unsigned y,
531  unsigned stride, unsigned width, unsigned height, uint16_t *dst,
532  unsigned dst_width, unsigned dst_height, int is_interlaced, int is_top_field)
533 {
534  subimage_with_fill_template(src, x, y, stride, width, height, dst, dst_width, dst_height, 1, is_interlaced, is_top_field);
535 }
536 
537 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
538  int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
539  int unsafe, int *qp, int is_interlaced, int is_top_field)
540 {
541  int luma_stride, chroma_stride, alpha_stride = 0;
542  ProresContext* ctx = avctx->priv_data;
543  int hdr_size = 6 + (ctx->need_alpha * 2); /* v data size is write when there is alpha */
544  int ret = 0, slice_size;
545  uint8_t *dest_y, *dest_u, *dest_v;
546  unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0, a_data_size = 0;
547  FDCTDSPContext *fdsp = &ctx->fdsp;
548  int tgt_bits = (mb_count * bitrate_table[avctx->profile]) >> 2;
549  int low_bytes = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
550  int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
551 
552  LOCAL_ALIGNED(16, int16_t, blocks_y, [DEFAULT_SLICE_MB_WIDTH << 8]);
553  LOCAL_ALIGNED(16, int16_t, blocks_u, [DEFAULT_SLICE_MB_WIDTH << 8]);
554  LOCAL_ALIGNED(16, int16_t, blocks_v, [DEFAULT_SLICE_MB_WIDTH << 8]);
555 
556  luma_stride = pic->linesize[0];
557  chroma_stride = pic->linesize[1];
558 
559  if (ctx->need_alpha)
560  alpha_stride = pic->linesize[3];
561 
562  if (!is_interlaced) {
563  dest_y = pic->data[0] + (mb_y << 4) * luma_stride + (mb_x << 5);
564  dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
565  dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
566  } else {
567  dest_y = pic->data[0] + (mb_y << 4) * luma_stride * 2 + (mb_x << 5);
568  dest_u = pic->data[1] + (mb_y << 4) * chroma_stride * 2 + (mb_x << (5 - ctx->is_422));
569  dest_v = pic->data[2] + (mb_y << 4) * chroma_stride * 2 + (mb_x << (5 - ctx->is_422));
570  if (!is_top_field){ /* bottom field, offset dest */
571  dest_y += luma_stride;
572  dest_u += chroma_stride;
573  dest_v += chroma_stride;
574  }
575  }
576 
577  if (unsafe) {
578  subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
579  luma_stride, avctx->width, avctx->height,
580  (uint16_t *) ctx->fill_y, mb_count << 4, 16, is_interlaced, is_top_field);
581  subimage_with_fill((uint16_t *) pic->data[1], mb_x << (4 - ctx->is_422), mb_y << 4,
582  chroma_stride, avctx->width >> ctx->is_422, avctx->height,
583  (uint16_t *) ctx->fill_u, mb_count << (4 - ctx->is_422), 16, is_interlaced, is_top_field);
584  subimage_with_fill((uint16_t *) pic->data[2], mb_x << (4 - ctx->is_422), mb_y << 4,
585  chroma_stride, avctx->width >> ctx->is_422, avctx->height,
586  (uint16_t *) ctx->fill_v, mb_count << (4 - ctx->is_422), 16, is_interlaced, is_top_field);
587 
588  /* no need for interlaced special case, data already reorganized in subimage_with_fill */
589  calc_plane_dct(fdsp, ctx->fill_y, blocks_y, mb_count << 5, mb_count, 0, 0);
590  calc_plane_dct(fdsp, ctx->fill_u, blocks_u, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
591  calc_plane_dct(fdsp, ctx->fill_v, blocks_v, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
592 
593  slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
594  mb_count, buf + hdr_size, data_size - hdr_size,
595  &y_data_size, &u_data_size, &v_data_size,
596  *qp);
597  } else {
598  if (!is_interlaced) {
599  calc_plane_dct(fdsp, dest_y, blocks_y, luma_stride, mb_count, 0, 0);
600  calc_plane_dct(fdsp, dest_u, blocks_u, chroma_stride, mb_count, 1, ctx->is_422);
601  calc_plane_dct(fdsp, dest_v, blocks_v, chroma_stride, mb_count, 1, ctx->is_422);
602  } else {
603  calc_plane_dct(fdsp, dest_y, blocks_y, luma_stride * 2, mb_count, 0, 0);
604  calc_plane_dct(fdsp, dest_u, blocks_u, chroma_stride * 2, mb_count, 1, ctx->is_422);
605  calc_plane_dct(fdsp, dest_v, blocks_v, chroma_stride * 2, mb_count, 1, ctx->is_422);
606  }
607 
608  slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
609  mb_count, buf + hdr_size, data_size - hdr_size,
610  &y_data_size, &u_data_size, &v_data_size,
611  *qp);
612 
613  if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
614  do {
615  *qp += 1;
616  slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
617  mb_count, buf + hdr_size, data_size - hdr_size,
618  &y_data_size, &u_data_size, &v_data_size,
619  *qp);
620  } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
621  } else if (slice_size < low_bytes && *qp
622  > qp_start_table[avctx->profile]) {
623  do {
624  *qp -= 1;
625  slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
626  mb_count, buf + hdr_size, data_size - hdr_size,
627  &y_data_size, &u_data_size, &v_data_size,
628  *qp);
629  } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
630  }
631  }
632 
633  buf[0] = hdr_size << 3;
634  buf[1] = *qp;
635  AV_WB16(buf + 2, y_data_size);
636  AV_WB16(buf + 4, u_data_size);
637 
638  if (ctx->need_alpha) {
639  AV_WB16(buf + 6, v_data_size); /* write v data size only if there is alpha */
640 
641  subimage_alpha_with_fill((uint16_t *) pic->data[3], mb_x << 4, mb_y << 4,
642  alpha_stride, avctx->width, avctx->height,
643  (uint16_t *) ctx->fill_a, mb_count << 4, 16, is_interlaced, is_top_field);
644  ret = encode_alpha_slice_data(avctx, ctx->fill_a, mb_count,
645  buf + hdr_size + slice_size,
646  data_size - hdr_size - slice_size, &a_data_size);
647  }
648 
649  if (ret != 0) {
650  return ret;
651  }
652  return hdr_size + y_data_size + u_data_size + v_data_size + a_data_size;
653 }
654 
655 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
656  uint8_t *buf, const int buf_size, const int picture_index, const int is_top_field)
657 {
658  ProresContext *ctx = avctx->priv_data;
659  int mb_width = (avctx->width + 15) >> 4;
660  int hdr_size, sl_size, i;
661  int mb_y, sl_data_size, qp, mb_height, picture_height, unsafe_mb_height_limit;
662  int unsafe_bot, unsafe_right;
663  uint8_t *sl_data, *sl_data_sizes;
664  int slice_per_line = 0, rem = mb_width;
665 
666  if (!ctx->is_interlaced) { /* progressive encoding */
667  mb_height = (avctx->height + 15) >> 4;
668  unsafe_mb_height_limit = mb_height;
669  } else {
670  if (is_top_field) {
671  picture_height = (avctx->height + 1) / 2;
672  } else {
673  picture_height = avctx->height / 2;
674  }
675  mb_height = (picture_height + 15) >> 4;
676  unsafe_mb_height_limit = mb_height;
677  }
678 
679  for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
680  slice_per_line += rem >> i;
681  rem &= (1 << i) - 1;
682  }
683 
684  qp = qp_start_table[avctx->profile];
685  hdr_size = 8; sl_data_size = buf_size - hdr_size;
686  sl_data_sizes = buf + hdr_size;
687  sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
688  for (mb_y = 0; mb_y < mb_height; mb_y++) {
689  int mb_x = 0;
690  int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
691  while (mb_x < mb_width) {
692  while (mb_width - mb_x < slice_mb_count)
693  slice_mb_count >>= 1;
694 
695  unsafe_bot = (avctx->height & 0xf) && (mb_y == unsafe_mb_height_limit - 1);
696  unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
697 
698  sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
699  sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp, ctx->is_interlaced, is_top_field);
700  if (sl_size < 0){
701  return sl_size;
702  }
703 
704  bytestream_put_be16(&sl_data_sizes, sl_size);
705  sl_data += sl_size;
706  sl_data_size -= sl_size;
707  mb_x += slice_mb_count;
708  }
709  }
710 
711  buf[0] = hdr_size << 3;
712  AV_WB32(buf + 1, sl_data - buf);
713  AV_WB16(buf + 5, slice_per_line * mb_height); /* picture size */
714  buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4; /* number of slices */
715 
716  return sl_data - buf;
717 }
718 
719 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
720  const AVFrame *pict, int *got_packet)
721 {
722  ProresContext *ctx = avctx->priv_data;
723  int header_size = 148;
724  uint8_t *buf;
725  int compress_frame_size, pic_size, ret, is_top_field_first = 0;
726  uint8_t frame_flags;
727  int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + AV_INPUT_BUFFER_MIN_SIZE; //FIXME choose tighter limit
728 
729 
730  if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
731  return ret;
732 
733  buf = pkt->data;
734  compress_frame_size = 8 + header_size;
735 
736  bytestream_put_be32(&buf, compress_frame_size);/* frame size will be update after picture(s) encoding */
737  bytestream_put_buffer(&buf, "icpf", 4);
738 
739  bytestream_put_be16(&buf, header_size);
740  bytestream_put_be16(&buf, 0); /* version */
741  bytestream_put_buffer(&buf, ctx->vendor, 4);
742  bytestream_put_be16(&buf, avctx->width);
743  bytestream_put_be16(&buf, avctx->height);
744  frame_flags = 0x82; /* 422 not interlaced */
745  if (avctx->profile >= FF_PROFILE_PRORES_4444) /* 4444 or 4444 Xq */
746  frame_flags |= 0x40; /* 444 chroma */
747  if (ctx->is_interlaced) {
748  if (pict->top_field_first || !pict->interlaced_frame) { /* tff frame or progressive frame interpret as tff */
749  av_log(avctx, AV_LOG_DEBUG, "use interlaced encoding, top field first\n");
750  frame_flags |= 0x04; /* interlaced tff */
751  is_top_field_first = 1;
752  } else {
753  av_log(avctx, AV_LOG_DEBUG, "use interlaced encoding, bottom field first\n");
754  frame_flags |= 0x08; /* interlaced bff */
755  }
756  } else {
757  av_log(avctx, AV_LOG_DEBUG, "use progressive encoding\n");
758  }
759  *buf++ = frame_flags;
760  *buf++ = 0; /* reserved */
761  /* only write color properties, if valid value. set to unspecified otherwise */
762  *buf++ = ff_int_from_list_or_default(avctx, "frame color primaries", pict->color_primaries, valid_primaries, 0);
763  *buf++ = ff_int_from_list_or_default(avctx, "frame color trc", pict->color_trc, valid_trc, 0);
764  *buf++ = ff_int_from_list_or_default(avctx, "frame colorspace", pict->colorspace, valid_colorspace, 0);
765  if (avctx->profile >= FF_PROFILE_PRORES_4444) {
766  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
767  *buf++ = 0xA0;/* src b64a and no alpha */
768  } else {
769  *buf++ = 0xA2;/* src b64a and 16b alpha */
770  }
771  } else {
772  *buf++ = 32;/* src v210 and no alpha */
773  }
774  *buf++ = 0; /* reserved */
775  *buf++ = 3; /* luma and chroma matrix present */
776 
777  bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile], 64);
778  bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
779 
780  pic_size = prores_encode_picture(avctx, pict, buf,
781  pkt->size - compress_frame_size, 0, is_top_field_first);/* encode progressive or first field */
782  if (pic_size < 0) {
783  return pic_size;
784  }
785  compress_frame_size += pic_size;
786 
787  if (ctx->is_interlaced) { /* encode second field */
788  pic_size = prores_encode_picture(avctx, pict, pkt->data + compress_frame_size,
789  pkt->size - compress_frame_size, 1, !is_top_field_first);
790  if (pic_size < 0) {
791  return pic_size;
792  }
793  compress_frame_size += pic_size;
794  }
795 
796  AV_WB32(pkt->data, compress_frame_size);/* update frame size */
797  pkt->flags |= AV_PKT_FLAG_KEY;
798  pkt->size = compress_frame_size;
799  *got_packet = 1;
800 
801  return 0;
802 }
803 
804 static void scale_mat(const uint8_t* src, int* dst, int scale)
805 {
806  int i;
807  for (i = 0; i < 64; i++)
808  dst[i] = src[i] * scale;
809 }
810 
811 static av_cold int prores_encode_init(AVCodecContext *avctx)
812 {
813  int i;
814  ProresContext* ctx = avctx->priv_data;
815 
816  avctx->bits_per_raw_sample = 10;
817  ctx->need_alpha = 0;
818  ctx->is_interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
819  if (ctx->is_interlaced) {
820  ctx->scantable = ff_prores_interlaced_scan;
821  } else {
822  ctx->scantable = ff_prores_progressive_scan;
823  }
824 
825  if (avctx->width & 0x1) {
826  av_log(avctx, AV_LOG_ERROR,
827  "frame width needs to be multiple of 2\n");
828  return AVERROR(EINVAL);
829  }
830 
831  if (avctx->width > 65534 || avctx->height > 65535) {
832  av_log(avctx, AV_LOG_ERROR,
833  "The maximum dimensions are 65534x65535\n");
834  return AVERROR(EINVAL);
835  }
836 
837  if (strlen(ctx->vendor) != 4) {
838  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
839  return AVERROR(EINVAL);
840  }
841 
842  if (avctx->profile == FF_PROFILE_UNKNOWN) {
843  if (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
844  avctx->profile = FF_PROFILE_PRORES_STANDARD;
845  av_log(avctx, AV_LOG_INFO,
846  "encoding with ProRes standard (apcn) profile\n");
847  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
848  avctx->profile = FF_PROFILE_PRORES_4444;
849  av_log(avctx, AV_LOG_INFO,
850  "encoding with ProRes 4444 (ap4h) profile\n");
851  } else if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
852  avctx->profile = FF_PROFILE_PRORES_4444;
853  av_log(avctx, AV_LOG_INFO,
854  "encoding with ProRes 4444+ (ap4h) profile\n");
855  } else {
856  av_log(avctx, AV_LOG_ERROR, "Unknown pixel format\n");
857  return AVERROR(EINVAL);
858  }
859  } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
860  || avctx->profile > FF_PROFILE_PRORES_XQ) {
861  av_log(
862  avctx,
863  AV_LOG_ERROR,
864  "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch, 4 - ap4h, 5 - ap4x]\n",
865  avctx->profile);
866  return AVERROR(EINVAL);
867  } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P10) && (avctx->profile > FF_PROFILE_PRORES_HQ)){
868  av_log(avctx, AV_LOG_ERROR,
869  "encoding with ProRes 444/Xq (ap4h/ap4x) profile, need YUV444P10 input\n");
870  return AVERROR(EINVAL);
871  } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10)
872  && (avctx->profile < FF_PROFILE_PRORES_4444)){
873  av_log(avctx, AV_LOG_ERROR,
874  "encoding with ProRes Proxy/LT/422/422 HQ (apco, apcs, apcn, ap4h) profile, need YUV422P10 input\n");
875  return AVERROR(EINVAL);
876  }
877 
878  if (avctx->profile < FF_PROFILE_PRORES_4444) { /* 422 versions */
879  ctx->is_422 = 1;
880  if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
881  ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
882  if (!ctx->fill_y)
883  return AVERROR(ENOMEM);
884  ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
885  ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
886  }
887  } else { /* 444 */
888  ctx->is_422 = 0;
889  if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
890  ctx->fill_y = av_malloc(3 * (DEFAULT_SLICE_MB_WIDTH << 9));
891  if (!ctx->fill_y)
892  return AVERROR(ENOMEM);
893  ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
894  ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 9);
895  }
896  if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
897  ctx->need_alpha = 1;
898  ctx->fill_a = av_malloc(DEFAULT_SLICE_MB_WIDTH << 9); /* 8 blocks x 16px x 16px x sizeof (uint16) */
899  if (!ctx->fill_a)
900  return AVERROR(ENOMEM);
901  }
902  }
903 
904  ff_fdctdsp_init(&ctx->fdsp, avctx);
905 
906  avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
907 
908  for (i = 1; i <= 16; i++) {
909  scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
910  scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
911  }
912 
913  return 0;
914 }
915 
916 static av_cold int prores_encode_close(AVCodecContext *avctx)
917 {
918  ProresContext* ctx = avctx->priv_data;
919  av_freep(&ctx->fill_y);
920  av_freep(&ctx->fill_a);
921 
922  return 0;
923 }
924 
925 #define OFFSET(x) offsetof(ProresContext, x)
926 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
927 
928 static const AVOption options[] = {
929  { "vendor", "vendor ID", OFFSET(vendor), AV_OPT_TYPE_STRING, { .str = "fmpg" }, 0, 0, VE },
930  { NULL }
931 };
932 
933 static const AVClass proresaw_enc_class = {
934  .class_name = "ProResAw encoder",
935  .item_name = av_default_item_name,
936  .option = options,
937  .version = LIBAVUTIL_VERSION_INT,
938 };
939 
940 static const AVClass prores_enc_class = {
941  .class_name = "ProRes encoder",
942  .item_name = av_default_item_name,
943  .option = options,
944  .version = LIBAVUTIL_VERSION_INT,
945 };
946 
947 AVCodec ff_prores_aw_encoder = {
948  .name = "prores_aw",
949  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
950  .type = AVMEDIA_TYPE_VIDEO,
951  .id = AV_CODEC_ID_PRORES,
952  .priv_data_size = sizeof(ProresContext),
953  .init = prores_encode_init,
954  .close = prores_encode_close,
955  .encode2 = prores_encode_frame,
956  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
957  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
958  .priv_class = &proresaw_enc_class,
959  .profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
960 };
961 
962 AVCodec ff_prores_encoder = {
963  .name = "prores",
964  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
965  .type = AVMEDIA_TYPE_VIDEO,
966  .id = AV_CODEC_ID_PRORES,
967  .priv_data_size = sizeof(ProresContext),
968  .init = prores_encode_init,
969  .close = prores_encode_close,
970  .encode2 = prores_encode_frame,
971  .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
972  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
973  .priv_class = &prores_enc_class,
974  .profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
975 };
AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
NULL
#define NULL
Definition: coverity.c:32
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
prores_enc_class
static const AVClass prores_enc_class
Definition: proresenc_anatoliy.c:940
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
AVOption
AVOption.
Definition: opt.h:248
encode_slice
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, int is_interlaced, int is_top_field)
Definition: proresenc_anatoliy.c:537
prores_encode_picture
static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic, uint8_t *buf, const int buf_size, const int picture_index, const int is_top_field)
Definition: proresenc_anatoliy.c:655
ProresContext::qmat_luma
uint8_t qmat_luma[64]
Definition: proresdec.h:43
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:260
ret
ret
Definition: filter_design.txt:187
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
TO_GOLOMB2
#define TO_GOLOMB2(val, sign)
Definition: proresenc_anatoliy.c:232
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:473
LOCAL_ALIGNED
#define LOCAL_ALIGNED(a, t, v,...)
Definition: mem_internal.h:113
AVPacket::size
int size
Definition: packet.h:364
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
encode_ac_coeffs
static void encode_ac_coeffs(PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat, const uint8_t ff_prores_scan[64])
Definition: proresenc_anatoliy.c:275
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
prores_encode_init
static av_cold int prores_encode_init(AVCodecContext *avctx)
Definition: proresenc_anatoliy.c:811
AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:519
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
options
static const AVOption options[]
Definition: proresenc_anatoliy.c:928
FF_PROFILE_PRORES_LT
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:1960
AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:472
AV_CODEC_ID_PRORES
Definition: codec_id.h:197
calc_plane_dct
static void calc_plane_dct(FDCTDSPContext *fdsp, uint8_t *src, int16_t *blocks, int src_stride, int mb_count, int chroma, int is_422)
Definition: proresenc_anatoliy.c:324
run
uint8_t run
Definition: svq3.c:205
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1742
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresenc_anatoliy.c:240
ff_fdctdsp_init
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1851
AVCodec
AVCodec.
Definition: codec.h:190
QMAT_CHROMA
static const uint8_t QMAT_CHROMA[6][64]
Definition: proresenc_anatoliy.c:122
FF_PROFILE_PRORES_XQ
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:1964
encode_alpha_slice_data
static av_always_inline int encode_alpha_slice_data(AVCodecContext *avctx, int8_t *src_a, unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned *a_data_size)
Definition: proresenc_anatoliy.c:433
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
VE
#define VE
Definition: proresenc_anatoliy.c:926
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:88
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
delta
float delta
Definition: vorbis_enc_data.h:457
opt.h
AVOptions.
encode_dc_coeffs
static void encode_dc_coeffs(PutBitContext *pb, int16_t *in, int blocks_per_slice, int *qmat)
Definition: proresenc_anatoliy.c:244
height
#define height
AV_OPT_TYPE_STRING
Definition: opt.h:229
AVPacket::data
uint8_t * data
Definition: packet.h:363
qp_start_table
static const int qp_start_table[]
Definition: proresenc_anatoliy.c:53
ProresContext::scantable
const uint8_t * scantable
Definition: proresenc_anatoliy.c:191
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:461
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:159
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
bitrate_table
static const int bitrate_table[]
Definition: proresenc_anatoliy.c:55
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
lev_to_cb
static const uint8_t lev_to_cb[10]
Definition: proresenc_anatoliy.c:272
src
#define src
Definition: vp8dsp.c:255
valid_primaries
static const int valid_primaries[]
Definition: proresenc_anatoliy.c:57
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
put_bits_ptr
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:349
prores_encode_frame
static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: proresenc_anatoliy.c:719
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:109
mask
static const uint16_t mask[17]
Definition: lzw.c:38
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1624
put_alpha_run
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc_anatoliy.c:420
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
prores_encode_close
static av_cold int prores_encode_close(AVCodecContext *avctx)
Definition: proresenc_anatoliy.c:916
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:569
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:54
AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:460
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
IS_NEGATIVE
#define IS_NEGATIVE(val)
Definition: proresenc_anatoliy.c:231
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
valid_trc
static const int valid_trc[]
Definition: proresenc_anatoliy.c:59
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
exp
int8_t exp
Definition: eval.c:72
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:83
get_level
static av_always_inline int get_level(int val)
Definition: proresenc_anatoliy.c:234
TO_GOLOMB
#define TO_GOLOMB(val)
Definition: proresenc_anatoliy.c:229
AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:500
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
scale_mat
static void scale_mat(const uint8_t *src, int *dst, int scale)
Definition: proresenc_anatoliy.c:804
put_alpha_diff
static void put_alpha_diff(PutBitContext *pb, int cur, int prev)
Definition: proresenc_anatoliy.c:400
profiles
static const AVProfile profiles[]
Definition: proresenc_anatoliy.c:43
width
#define width
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:704
FF_PROFILE_PRORES_STANDARD
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:1961
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1852
AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:523
AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:465
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
DEFAULT_SLICE_MB_WIDTH
#define DEFAULT_SLICE_MB_WIDTH
Definition: proresenc_anatoliy.c:41
FDCTDSPContext::fdct
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
ff_prores_encoder
AVCodec ff_prores_encoder
Definition: proresenc_anatoliy.c:962
FF_PROFILE_PRORES_4444
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:1963
AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:485
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
frame_size
int frame_size
Definition: mxfenc.c:2165
avcodec.h
Libavcodec external API header.
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
encode_slice_plane
static int encode_slice_plane(int16_t *blocks, int mb_count, uint8_t *buf, unsigned buf_size, int *qmat, int sub_sample_chroma, const uint8_t ff_prores_scan[64])
Definition: proresenc_anatoliy.c:361
AVCodecContext
main external API structure.
Definition: avcodec.h:531
ProresContext::fdsp
FDCTDSPContext fdsp
Definition: proresenc_anatoliy.c:183
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresenc_anatoliy.c:242
ff_prores_progressive_scan
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
qp_end_table
static const int qp_end_table[]
Definition: proresenc_anatoliy.c:54
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:556
OFFSET
#define OFFSET(x)
Definition: proresenc_anatoliy.c:925
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;}return ac;}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;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:194
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:178
encode_slice_data
static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx, int16_t *blocks_y, int16_t *blocks_u, int16_t *blocks_v, unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned *y_data_size, unsigned *u_data_size, unsigned *v_data_size, int qp)
Definition: proresenc_anatoliy.c:377
FF_PROFILE_PRORES_HQ
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:1962
QSCALE
#define QSCALE(qmat, ind, val)
Definition: proresenc_anatoliy.c:228
proresaw_enc_class
static const AVClass proresaw_enc_class
Definition: proresenc_anatoliy.c:933
encode_codeword
static void encode_codeword(PutBitContext *pb, int val, int codebook)
Definition: proresenc_anatoliy.c:200
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
subimage_alpha_with_fill
static void subimage_alpha_with_fill(uint16_t *src, unsigned x, unsigned y, unsigned stride, unsigned width, unsigned height, uint16_t *dst, unsigned dst_width, unsigned dst_height, int is_interlaced, int is_top_field)
Definition: proresenc_anatoliy.c:530
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:172
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
level
uint8_t level
Definition: svq3.c:206
fdct_get
static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t *block)
Definition: proresenc_anatoliy.c:318
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
ff_prores_aw_encoder
AVCodec ff_prores_aw_encoder
Definition: proresenc_anatoliy.c:947
QMAT_LUMA
static const uint8_t QMAT_LUMA[6][64]
Definition: proresenc_anatoliy.c:64
internal.h
common internal api header.
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:117
AVProfile
AVProfile.
Definition: codec.h:176
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:504
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:558
subimage_with_fill_template
static void subimage_with_fill_template(uint16_t *src, unsigned x, unsigned y, unsigned stride, unsigned width, unsigned height, uint16_t *dst, unsigned dst_width, unsigned dst_height, int is_alpha_plane, int is_interlaced, int is_top_field)
Definition: proresenc_anatoliy.c:474
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
ProresContext::qmat_chroma
uint8_t qmat_chroma[64]
Definition: proresdec.h:44
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:466
AV_RN64
#define AV_RN64(p)
Definition: intreadwrite.h:368
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:560
AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:466
AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:469
FF_PROFILE_PRORES_PROXY
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:1959
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:562
av_always_inline
#define av_always_inline
Definition: attributes.h:45
valid_colorspace
static const int valid_colorspace[]
Definition: proresenc_anatoliy.c:61
ff_int_from_list_or_default
int ff_int_from_list_or_default(void *ctx, const char *val_name, int val, const int *array_valid_values, int default_value)
Check if a value is in the list.
Definition: utils.c:2338
stride
#define stride
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
DIFF_SIGN
#define DIFF_SIGN(val, sign)
Definition: proresenc_anatoliy.c:230
run_to_cb
static const uint8_t run_to_cb[16]
Definition: proresenc_anatoliy.c:270
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AVPacket
This structure stores compressed data.
Definition: packet.h:340
mem_internal.h
i
int i
Definition: input.c:407
AV_WN64
#define AV_WN64(p, v)
Definition: intreadwrite.h:380
subimage_with_fill
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, int is_interlaced, int is_top_field)
Definition: proresenc_anatoliy.c:522
put_bits.h
bitstream writer API
Generated on Tue Jan 26 2021 19:21:52 for FFmpeg by   doxygen 1.8.11