FFmpeg
proresenc_kostya.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2012 Konstantin Shishkov
5  *
6  * This encoder appears to be based on Anatoliy Wassermans considering
7  * similarities in the bugs.
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/mem_internal.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "avcodec.h"
30 #include "fdctdsp.h"
31 #include "put_bits.h"
32 #include "profiles.h"
33 #include "bytestream.h"
34 #include "internal.h"
35 #include "proresdata.h"
36 
37 #define CFACTOR_Y422 2
38 #define CFACTOR_Y444 3
39 
40 #define MAX_MBS_PER_SLICE 8
41 
42 #define MAX_PLANES 4
43 
44 enum {
52 };
53 
54 enum {
62 };
63 
64 static const uint8_t prores_quant_matrices[][64] = {
65  { // proxy
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  { // proxy chromas
76  4, 7, 9, 11, 13, 14, 63, 63,
77  7, 7, 11, 12, 14, 63, 63, 63,
78  9, 11, 13, 14, 63, 63, 63, 63,
79  11, 11, 13, 14, 63, 63, 63, 63,
80  11, 13, 14, 63, 63, 63, 63, 63,
81  13, 14, 63, 63, 63, 63, 63, 63,
82  13, 63, 63, 63, 63, 63, 63, 63,
83  63, 63, 63, 63, 63, 63, 63, 63
84  },
85  { // LT
86  4, 5, 6, 7, 9, 11, 13, 15,
87  5, 5, 7, 8, 11, 13, 15, 17,
88  6, 7, 9, 11, 13, 15, 15, 17,
89  7, 7, 9, 11, 13, 15, 17, 19,
90  7, 9, 11, 13, 14, 16, 19, 23,
91  9, 11, 13, 14, 16, 19, 23, 29,
92  9, 11, 13, 15, 17, 21, 28, 35,
93  11, 13, 16, 17, 21, 28, 35, 41,
94  },
95  { // standard
96  4, 4, 5, 5, 6, 7, 7, 9,
97  4, 4, 5, 6, 7, 7, 9, 9,
98  5, 5, 6, 7, 7, 9, 9, 10,
99  5, 5, 6, 7, 7, 9, 9, 10,
100  5, 6, 7, 7, 8, 9, 10, 12,
101  6, 7, 7, 8, 9, 10, 12, 15,
102  6, 7, 7, 9, 10, 11, 14, 17,
103  7, 7, 9, 10, 11, 14, 17, 21,
104  },
105  { // high quality
106  4, 4, 4, 4, 4, 4, 4, 4,
107  4, 4, 4, 4, 4, 4, 4, 4,
108  4, 4, 4, 4, 4, 4, 4, 4,
109  4, 4, 4, 4, 4, 4, 4, 5,
110  4, 4, 4, 4, 4, 4, 5, 5,
111  4, 4, 4, 4, 4, 5, 5, 6,
112  4, 4, 4, 4, 5, 5, 6, 7,
113  4, 4, 4, 4, 5, 6, 7, 7,
114  },
115  { // XQ luma
116  2, 2, 2, 2, 2, 2, 2, 2,
117  2, 2, 2, 2, 2, 2, 2, 2,
118  2, 2, 2, 2, 2, 2, 2, 2,
119  2, 2, 2, 2, 2, 2, 2, 3,
120  2, 2, 2, 2, 2, 2, 3, 3,
121  2, 2, 2, 2, 2, 3, 3, 3,
122  2, 2, 2, 2, 3, 3, 3, 4,
123  2, 2, 2, 2, 3, 3, 4, 4,
124  },
125  { // codec default
126  4, 4, 4, 4, 4, 4, 4, 4,
127  4, 4, 4, 4, 4, 4, 4, 4,
128  4, 4, 4, 4, 4, 4, 4, 4,
129  4, 4, 4, 4, 4, 4, 4, 4,
130  4, 4, 4, 4, 4, 4, 4, 4,
131  4, 4, 4, 4, 4, 4, 4, 4,
132  4, 4, 4, 4, 4, 4, 4, 4,
133  4, 4, 4, 4, 4, 4, 4, 4,
134  },
135 };
136 
137 #define NUM_MB_LIMITS 4
138 static const int prores_mb_limits[NUM_MB_LIMITS] = {
139  1620, // up to 720x576
140  2700, // up to 960x720
141  6075, // up to 1440x1080
142  9216, // up to 2048x1152
143 };
144 
145 static const struct prores_profile {
146  const char *full_name;
147  uint32_t tag;
151  int quant;
153 } prores_profile_info[6] = {
154  {
155  .full_name = "proxy",
156  .tag = MKTAG('a', 'p', 'c', 'o'),
157  .min_quant = 4,
158  .max_quant = 8,
159  .br_tab = { 300, 242, 220, 194 },
160  .quant = QUANT_MAT_PROXY,
161  .quant_chroma = QUANT_MAT_PROXY_CHROMA,
162  },
163  {
164  .full_name = "LT",
165  .tag = MKTAG('a', 'p', 'c', 's'),
166  .min_quant = 1,
167  .max_quant = 9,
168  .br_tab = { 720, 560, 490, 440 },
169  .quant = QUANT_MAT_LT,
170  .quant_chroma = QUANT_MAT_LT,
171  },
172  {
173  .full_name = "standard",
174  .tag = MKTAG('a', 'p', 'c', 'n'),
175  .min_quant = 1,
176  .max_quant = 6,
177  .br_tab = { 1050, 808, 710, 632 },
178  .quant = QUANT_MAT_STANDARD,
179  .quant_chroma = QUANT_MAT_STANDARD,
180  },
181  {
182  .full_name = "high quality",
183  .tag = MKTAG('a', 'p', 'c', 'h'),
184  .min_quant = 1,
185  .max_quant = 6,
186  .br_tab = { 1566, 1216, 1070, 950 },
187  .quant = QUANT_MAT_HQ,
188  .quant_chroma = QUANT_MAT_HQ,
189  },
190  {
191  .full_name = "4444",
192  .tag = MKTAG('a', 'p', '4', 'h'),
193  .min_quant = 1,
194  .max_quant = 6,
195  .br_tab = { 2350, 1828, 1600, 1425 },
196  .quant = QUANT_MAT_HQ,
197  .quant_chroma = QUANT_MAT_HQ,
198  },
199  {
200  .full_name = "4444XQ",
201  .tag = MKTAG('a', 'p', '4', 'x'),
202  .min_quant = 1,
203  .max_quant = 6,
204  .br_tab = { 3525, 2742, 2400, 2137 },
205  .quant = QUANT_MAT_HQ, /* Fix me : use QUANT_MAT_XQ_LUMA */
206  .quant_chroma = QUANT_MAT_HQ,
207  }
208 };
209 
210 #define TRELLIS_WIDTH 16
211 #define SCORE_LIMIT INT_MAX / 2
212 
213 struct TrellisNode {
215  int quant;
216  int bits;
217  int score;
218 };
219 
220 #define MAX_STORED_Q 16
221 
222 typedef struct ProresThreadData {
223  DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
224  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
225  int16_t custom_q[64];
226  int16_t custom_chroma_q[64];
229 
230 typedef struct ProresContext {
231  AVClass *class;
232  DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
233  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
234  int16_t quants[MAX_STORED_Q][64];
235  int16_t quants_chroma[MAX_STORED_Q][64];
236  int16_t custom_q[64];
237  int16_t custom_chroma_q[64];
240  const uint8_t *scantable;
241 
242  void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
243  ptrdiff_t linesize, int16_t *block);
244  FDCTDSPContext fdsp;
245 
246  const AVFrame *pic;
247  int mb_width, mb_height;
249  int num_chroma_blocks, chroma_factor;
252  int pictures_per_frame; // 1 for progressive, 2 for interlaced
258  int warn;
259 
260  char *vendor;
262 
264 
265  int profile;
267 
268  int *slice_q;
269 
271 } ProresContext;
272 
273 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
274  ptrdiff_t linesize, int x, int y, int w, int h,
275  int16_t *blocks, uint16_t *emu_buf,
276  int mbs_per_slice, int blocks_per_mb, int is_chroma)
277 {
278  const uint16_t *esrc;
279  const int mb_width = 4 * blocks_per_mb;
280  ptrdiff_t elinesize;
281  int i, j, k;
282 
283  for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
284  if (x >= w) {
285  memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
286  * sizeof(*blocks));
287  return;
288  }
289  if (x + mb_width <= w && y + 16 <= h) {
290  esrc = src;
291  elinesize = linesize;
292  } else {
293  int bw, bh, pix;
294 
295  esrc = emu_buf;
296  elinesize = 16 * sizeof(*emu_buf);
297 
298  bw = FFMIN(w - x, mb_width);
299  bh = FFMIN(h - y, 16);
300 
301  for (j = 0; j < bh; j++) {
302  memcpy(emu_buf + j * 16,
303  (const uint8_t*)src + j * linesize,
304  bw * sizeof(*src));
305  pix = emu_buf[j * 16 + bw - 1];
306  for (k = bw; k < mb_width; k++)
307  emu_buf[j * 16 + k] = pix;
308  }
309  for (; j < 16; j++)
310  memcpy(emu_buf + j * 16,
311  emu_buf + (bh - 1) * 16,
312  mb_width * sizeof(*emu_buf));
313  }
314  if (!is_chroma) {
315  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
316  blocks += 64;
317  if (blocks_per_mb > 2) {
318  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
319  blocks += 64;
320  }
321  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
322  blocks += 64;
323  if (blocks_per_mb > 2) {
324  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
325  blocks += 64;
326  }
327  } else {
328  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
329  blocks += 64;
330  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
331  blocks += 64;
332  if (blocks_per_mb > 2) {
333  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
334  blocks += 64;
335  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
336  blocks += 64;
337  }
338  }
339 
340  x += mb_width;
341  }
342 }
343 
344 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
345  ptrdiff_t linesize, int x, int y, int w, int h,
346  int16_t *blocks, int mbs_per_slice, int abits)
347 {
348  const int slice_width = 16 * mbs_per_slice;
349  int i, j, copy_w, copy_h;
350 
351  copy_w = FFMIN(w - x, slice_width);
352  copy_h = FFMIN(h - y, 16);
353  for (i = 0; i < copy_h; i++) {
354  memcpy(blocks, src, copy_w * sizeof(*src));
355  if (abits == 8)
356  for (j = 0; j < copy_w; j++)
357  blocks[j] >>= 2;
358  else
359  for (j = 0; j < copy_w; j++)
360  blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
361  for (j = copy_w; j < slice_width; j++)
362  blocks[j] = blocks[copy_w - 1];
363  blocks += slice_width;
364  src += linesize >> 1;
365  }
366  for (; i < 16; i++) {
367  memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
368  blocks += slice_width;
369  }
370 }
371 
372 /**
373  * Write an unsigned rice/exp golomb codeword.
374  */
375 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
376 {
377  unsigned int rice_order, exp_order, switch_bits, switch_val;
378  int exponent;
379 
380  /* number of prefix bits to switch between Rice and expGolomb */
381  switch_bits = (codebook & 3) + 1;
382  rice_order = codebook >> 5; /* rice code order */
383  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
384 
385  switch_val = switch_bits << rice_order;
386 
387  if (val >= switch_val) {
388  val -= switch_val - (1 << exp_order);
389  exponent = av_log2(val);
390 
391  put_bits(pb, exponent - exp_order + switch_bits, 0);
392  put_bits(pb, exponent + 1, val);
393  } else {
394  exponent = val >> rice_order;
395 
396  if (exponent)
397  put_bits(pb, exponent, 0);
398  put_bits(pb, 1, 1);
399  if (rice_order)
400  put_sbits(pb, rice_order, val);
401  }
402 }
403 
404 #define GET_SIGN(x) ((x) >> 31)
405 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
406 
407 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
408  int blocks_per_slice, int scale)
409 {
410  int i;
411  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
412 
413  prev_dc = (blocks[0] - 0x4000) / scale;
415  sign = 0;
416  codebook = 3;
417  blocks += 64;
418 
419  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
420  dc = (blocks[0] - 0x4000) / scale;
421  delta = dc - prev_dc;
422  new_sign = GET_SIGN(delta);
423  delta = (delta ^ sign) - sign;
424  code = MAKE_CODE(delta);
426  codebook = (code + (code & 1)) >> 1;
427  codebook = FFMIN(codebook, 3);
428  sign = new_sign;
429  prev_dc = dc;
430  }
431 }
432 
433 static void encode_acs(PutBitContext *pb, int16_t *blocks,
434  int blocks_per_slice,
435  int plane_size_factor,
436  const uint8_t *scan, const int16_t *qmat)
437 {
438  int idx, i;
439  int run, level, run_cb, lev_cb;
440  int max_coeffs, abs_level;
441 
442  max_coeffs = blocks_per_slice << 6;
443  run_cb = ff_prores_run_to_cb_index[4];
444  lev_cb = ff_prores_lev_to_cb_index[2];
445  run = 0;
446 
447  for (i = 1; i < 64; i++) {
448  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
449  level = blocks[idx] / qmat[scan[i]];
450  if (level) {
451  abs_level = FFABS(level);
452  encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
454  abs_level - 1);
455  put_sbits(pb, 1, GET_SIGN(level));
456 
457  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
458  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
459  run = 0;
460  } else {
461  run++;
462  }
463  }
464  }
465 }
466 
468  const uint16_t *src, ptrdiff_t linesize,
469  int mbs_per_slice, int16_t *blocks,
470  int blocks_per_mb, int plane_size_factor,
471  const int16_t *qmat)
472 {
473  int blocks_per_slice, saved_pos;
474 
475  saved_pos = put_bits_count(pb);
476  blocks_per_slice = mbs_per_slice * blocks_per_mb;
477 
478  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
479  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
480  ctx->scantable, qmat);
481  flush_put_bits(pb);
482 
483  return (put_bits_count(pb) - saved_pos) >> 3;
484 }
485 
486 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
487 {
488  const int dbits = (abits == 8) ? 4 : 7;
489  const int dsize = 1 << dbits - 1;
490  int diff = cur - prev;
491 
492  diff = av_mod_uintp2(diff, abits);
493  if (diff >= (1 << abits) - dsize)
494  diff -= 1 << abits;
495  if (diff < -dsize || diff > dsize || !diff) {
496  put_bits(pb, 1, 1);
497  put_bits(pb, abits, diff);
498  } else {
499  put_bits(pb, 1, 0);
500  put_bits(pb, dbits - 1, FFABS(diff) - 1);
501  put_bits(pb, 1, diff < 0);
502  }
503 }
504 
505 static void put_alpha_run(PutBitContext *pb, int run)
506 {
507  if (run) {
508  put_bits(pb, 1, 0);
509  if (run < 0x10)
510  put_bits(pb, 4, run);
511  else
512  put_bits(pb, 15, run);
513  } else {
514  put_bits(pb, 1, 1);
515  }
516 }
517 
518 // todo alpha quantisation for high quants
520  int mbs_per_slice, uint16_t *blocks,
521  int quant)
522 {
523  const int abits = ctx->alpha_bits;
524  const int mask = (1 << abits) - 1;
525  const int num_coeffs = mbs_per_slice * 256;
526  int saved_pos = put_bits_count(pb);
527  int prev = mask, cur;
528  int idx = 0;
529  int run = 0;
530 
531  cur = blocks[idx++];
532  put_alpha_diff(pb, cur, prev, abits);
533  prev = cur;
534  do {
535  cur = blocks[idx++];
536  if (cur != prev) {
537  put_alpha_run (pb, run);
538  put_alpha_diff(pb, cur, prev, abits);
539  prev = cur;
540  run = 0;
541  } else {
542  run++;
543  }
544  } while (idx < num_coeffs);
545  if (run)
546  put_alpha_run(pb, run);
547  flush_put_bits(pb);
548  return (put_bits_count(pb) - saved_pos) >> 3;
549 }
550 
551 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
552  PutBitContext *pb,
553  int sizes[4], int x, int y, int quant,
554  int mbs_per_slice)
555 {
556  ProresContext *ctx = avctx->priv_data;
557  int i, xp, yp;
558  int total_size = 0;
559  const uint16_t *src;
560  int slice_width_factor = av_log2(mbs_per_slice);
561  int num_cblocks, pwidth, line_add;
562  ptrdiff_t linesize;
563  int plane_factor, is_chroma;
564  uint16_t *qmat;
565  uint16_t *qmat_chroma;
566 
567  if (ctx->pictures_per_frame == 1)
568  line_add = 0;
569  else
570  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
571 
572  if (ctx->force_quant) {
573  qmat = ctx->quants[0];
574  qmat_chroma = ctx->quants_chroma[0];
575  } else if (quant < MAX_STORED_Q) {
576  qmat = ctx->quants[quant];
577  qmat_chroma = ctx->quants_chroma[quant];
578  } else {
579  qmat = ctx->custom_q;
580  qmat_chroma = ctx->custom_chroma_q;
581  for (i = 0; i < 64; i++) {
582  qmat[i] = ctx->quant_mat[i] * quant;
583  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
584  }
585  }
586 
587  for (i = 0; i < ctx->num_planes; i++) {
588  is_chroma = (i == 1 || i == 2);
589  plane_factor = slice_width_factor + 2;
590  if (is_chroma)
591  plane_factor += ctx->chroma_factor - 3;
592  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
593  xp = x << 4;
594  yp = y << 4;
595  num_cblocks = 4;
596  pwidth = avctx->width;
597  } else {
598  xp = x << 3;
599  yp = y << 4;
600  num_cblocks = 2;
601  pwidth = avctx->width >> 1;
602  }
603 
604  linesize = pic->linesize[i] * ctx->pictures_per_frame;
605  src = (const uint16_t*)(pic->data[i] + yp * linesize +
606  line_add * pic->linesize[i]) + xp;
607 
608  if (i < 3) {
609  get_slice_data(ctx, src, linesize, xp, yp,
610  pwidth, avctx->height / ctx->pictures_per_frame,
611  ctx->blocks[0], ctx->emu_buf,
612  mbs_per_slice, num_cblocks, is_chroma);
613  if (!is_chroma) {/* luma quant */
614  sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
615  mbs_per_slice, ctx->blocks[0],
616  num_cblocks, plane_factor,
617  qmat);
618  } else { /* chroma plane */
619  sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
620  mbs_per_slice, ctx->blocks[0],
621  num_cblocks, plane_factor,
622  qmat_chroma);
623  }
624  } else {
625  get_alpha_data(ctx, src, linesize, xp, yp,
626  pwidth, avctx->height / ctx->pictures_per_frame,
627  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
628  sizes[i] = encode_alpha_plane(ctx, pb, mbs_per_slice,
629  ctx->blocks[0], quant);
630  }
631  total_size += sizes[i];
632  if (put_bits_left(pb) < 0) {
633  av_log(avctx, AV_LOG_ERROR,
634  "Underestimated required buffer size.\n");
635  return AVERROR_BUG;
636  }
637  }
638  return total_size;
639 }
640 
641 static inline int estimate_vlc(unsigned codebook, int val)
642 {
643  unsigned int rice_order, exp_order, switch_bits, switch_val;
644  int exponent;
645 
646  /* number of prefix bits to switch between Rice and expGolomb */
647  switch_bits = (codebook & 3) + 1;
648  rice_order = codebook >> 5; /* rice code order */
649  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
650 
651  switch_val = switch_bits << rice_order;
652 
653  if (val >= switch_val) {
654  val -= switch_val - (1 << exp_order);
655  exponent = av_log2(val);
656 
657  return exponent * 2 - exp_order + switch_bits + 1;
658  } else {
659  return (val >> rice_order) + rice_order + 1;
660  }
661 }
662 
663 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
664  int scale)
665 {
666  int i;
667  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
668  int bits;
669 
670  prev_dc = (blocks[0] - 0x4000) / scale;
671  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
672  sign = 0;
673  codebook = 3;
674  blocks += 64;
675  *error += FFABS(blocks[0] - 0x4000) % scale;
676 
677  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
678  dc = (blocks[0] - 0x4000) / scale;
679  *error += FFABS(blocks[0] - 0x4000) % scale;
680  delta = dc - prev_dc;
681  new_sign = GET_SIGN(delta);
682  delta = (delta ^ sign) - sign;
683  code = MAKE_CODE(delta);
684  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
685  codebook = (code + (code & 1)) >> 1;
686  codebook = FFMIN(codebook, 3);
687  sign = new_sign;
688  prev_dc = dc;
689  }
690 
691  return bits;
692 }
693 
694 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
695  int plane_size_factor,
696  const uint8_t *scan, const int16_t *qmat)
697 {
698  int idx, i;
699  int run, level, run_cb, lev_cb;
700  int max_coeffs, abs_level;
701  int bits = 0;
702 
703  max_coeffs = blocks_per_slice << 6;
704  run_cb = ff_prores_run_to_cb_index[4];
705  lev_cb = ff_prores_lev_to_cb_index[2];
706  run = 0;
707 
708  for (i = 1; i < 64; i++) {
709  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
710  level = blocks[idx] / qmat[scan[i]];
711  *error += FFABS(blocks[idx]) % qmat[scan[i]];
712  if (level) {
713  abs_level = FFABS(level);
714  bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
715  bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
716  abs_level - 1) + 1;
717 
718  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
719  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
720  run = 0;
721  } else {
722  run++;
723  }
724  }
725  }
726 
727  return bits;
728 }
729 
730 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
731  const uint16_t *src, ptrdiff_t linesize,
732  int mbs_per_slice,
733  int blocks_per_mb, int plane_size_factor,
734  const int16_t *qmat, ProresThreadData *td)
735 {
736  int blocks_per_slice;
737  int bits;
738 
739  blocks_per_slice = mbs_per_slice * blocks_per_mb;
740 
741  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
742  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
743  plane_size_factor, ctx->scantable, qmat);
744 
745  return FFALIGN(bits, 8);
746 }
747 
748 static int est_alpha_diff(int cur, int prev, int abits)
749 {
750  const int dbits = (abits == 8) ? 4 : 7;
751  const int dsize = 1 << dbits - 1;
752  int diff = cur - prev;
753 
754  diff = av_mod_uintp2(diff, abits);
755  if (diff >= (1 << abits) - dsize)
756  diff -= 1 << abits;
757  if (diff < -dsize || diff > dsize || !diff)
758  return abits + 1;
759  else
760  return dbits + 1;
761 }
762 
764  const uint16_t *src, ptrdiff_t linesize,
765  int mbs_per_slice, int16_t *blocks)
766 {
767  const int abits = ctx->alpha_bits;
768  const int mask = (1 << abits) - 1;
769  const int num_coeffs = mbs_per_slice * 256;
770  int prev = mask, cur;
771  int idx = 0;
772  int run = 0;
773  int bits;
774 
775  cur = blocks[idx++];
776  bits = est_alpha_diff(cur, prev, abits);
777  prev = cur;
778  do {
779  cur = blocks[idx++];
780  if (cur != prev) {
781  if (!run)
782  bits++;
783  else if (run < 0x10)
784  bits += 4;
785  else
786  bits += 15;
787  bits += est_alpha_diff(cur, prev, abits);
788  prev = cur;
789  run = 0;
790  } else {
791  run++;
792  }
793  } while (idx < num_coeffs);
794 
795  if (run) {
796  if (run < 0x10)
797  bits += 4;
798  else
799  bits += 15;
800  }
801 
802  return bits;
803 }
804 
806  int trellis_node, int x, int y, int mbs_per_slice,
808 {
809  ProresContext *ctx = avctx->priv_data;
810  int i, q, pq, xp, yp;
811  const uint16_t *src;
812  int slice_width_factor = av_log2(mbs_per_slice);
813  int num_cblocks[MAX_PLANES], pwidth;
814  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
815  const int min_quant = ctx->profile_info->min_quant;
816  const int max_quant = ctx->profile_info->max_quant;
817  int error, bits, bits_limit;
818  int mbs, prev, cur, new_score;
819  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
820  int overquant;
821  uint16_t *qmat;
822  uint16_t *qmat_chroma;
823  int linesize[4], line_add;
824  int alpha_bits = 0;
825 
826  if (ctx->pictures_per_frame == 1)
827  line_add = 0;
828  else
829  line_add = ctx->cur_picture_idx ^ !ctx->pic->top_field_first;
830  mbs = x + mbs_per_slice;
831 
832  for (i = 0; i < ctx->num_planes; i++) {
833  is_chroma[i] = (i == 1 || i == 2);
834  plane_factor[i] = slice_width_factor + 2;
835  if (is_chroma[i])
836  plane_factor[i] += ctx->chroma_factor - 3;
837  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
838  xp = x << 4;
839  yp = y << 4;
840  num_cblocks[i] = 4;
841  pwidth = avctx->width;
842  } else {
843  xp = x << 3;
844  yp = y << 4;
845  num_cblocks[i] = 2;
846  pwidth = avctx->width >> 1;
847  }
848 
849  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
850  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
851  line_add * ctx->pic->linesize[i]) + xp;
852 
853  if (i < 3) {
854  get_slice_data(ctx, src, linesize[i], xp, yp,
855  pwidth, avctx->height / ctx->pictures_per_frame,
856  td->blocks[i], td->emu_buf,
857  mbs_per_slice, num_cblocks[i], is_chroma[i]);
858  } else {
859  get_alpha_data(ctx, src, linesize[i], xp, yp,
860  pwidth, avctx->height / ctx->pictures_per_frame,
861  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
862  }
863  }
864 
865  for (q = min_quant; q < max_quant + 2; q++) {
866  td->nodes[trellis_node + q].prev_node = -1;
867  td->nodes[trellis_node + q].quant = q;
868  }
869 
870  if (ctx->alpha_bits)
871  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
872  mbs_per_slice, td->blocks[3]);
873  // todo: maybe perform coarser quantising to fit into frame size when needed
874  for (q = min_quant; q <= max_quant; q++) {
875  bits = alpha_bits;
876  error = 0;
877  bits += estimate_slice_plane(ctx, &error, 0,
878  src, linesize[0],
879  mbs_per_slice,
880  num_cblocks[0], plane_factor[0],
881  ctx->quants[q], td); /* estimate luma plane */
882  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
883  bits += estimate_slice_plane(ctx, &error, i,
884  src, linesize[i],
885  mbs_per_slice,
886  num_cblocks[i], plane_factor[i],
887  ctx->quants_chroma[q], td);
888  }
889  if (bits > 65000 * 8)
890  error = SCORE_LIMIT;
891 
892  slice_bits[q] = bits;
893  slice_score[q] = error;
894  }
895  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
896  slice_bits[max_quant + 1] = slice_bits[max_quant];
897  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
898  overquant = max_quant;
899  } else {
900  for (q = max_quant + 1; q < 128; q++) {
901  bits = alpha_bits;
902  error = 0;
903  if (q < MAX_STORED_Q) {
904  qmat = ctx->quants[q];
905  qmat_chroma = ctx->quants_chroma[q];
906  } else {
907  qmat = td->custom_q;
908  qmat_chroma = td->custom_chroma_q;
909  for (i = 0; i < 64; i++) {
910  qmat[i] = ctx->quant_mat[i] * q;
911  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
912  }
913  }
914  bits += estimate_slice_plane(ctx, &error, 0,
915  src, linesize[0],
916  mbs_per_slice,
917  num_cblocks[0], plane_factor[0],
918  qmat, td);/* estimate luma plane */
919  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
920  bits += estimate_slice_plane(ctx, &error, i,
921  src, linesize[i],
922  mbs_per_slice,
923  num_cblocks[i], plane_factor[i],
924  qmat_chroma, td);
925  }
926  if (bits <= ctx->bits_per_mb * mbs_per_slice)
927  break;
928  }
929 
930  slice_bits[max_quant + 1] = bits;
931  slice_score[max_quant + 1] = error;
932  overquant = q;
933  }
934  td->nodes[trellis_node + max_quant + 1].quant = overquant;
935 
936  bits_limit = mbs * ctx->bits_per_mb;
937  for (pq = min_quant; pq < max_quant + 2; pq++) {
938  prev = trellis_node - TRELLIS_WIDTH + pq;
939 
940  for (q = min_quant; q < max_quant + 2; q++) {
941  cur = trellis_node + q;
942 
943  bits = td->nodes[prev].bits + slice_bits[q];
944  error = slice_score[q];
945  if (bits > bits_limit)
946  error = SCORE_LIMIT;
947 
948  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
949  new_score = td->nodes[prev].score + error;
950  else
951  new_score = SCORE_LIMIT;
952  if (td->nodes[cur].prev_node == -1 ||
953  td->nodes[cur].score >= new_score) {
954 
955  td->nodes[cur].bits = bits;
956  td->nodes[cur].score = new_score;
957  td->nodes[cur].prev_node = prev;
958  }
959  }
960  }
961 
962  error = td->nodes[trellis_node + min_quant].score;
963  pq = trellis_node + min_quant;
964  for (q = min_quant + 1; q < max_quant + 2; q++) {
965  if (td->nodes[trellis_node + q].score <= error) {
966  error = td->nodes[trellis_node + q].score;
967  pq = trellis_node + q;
968  }
969  }
970 
971  return pq;
972 }
973 
974 static int find_quant_thread(AVCodecContext *avctx, void *arg,
975  int jobnr, int threadnr)
976 {
977  ProresContext *ctx = avctx->priv_data;
978  ProresThreadData *td = ctx->tdata + threadnr;
979  int mbs_per_slice = ctx->mbs_per_slice;
980  int x, y = jobnr, mb, q = 0;
981 
982  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
983  while (ctx->mb_width - x < mbs_per_slice)
984  mbs_per_slice >>= 1;
985  q = find_slice_quant(avctx,
986  (mb + 1) * TRELLIS_WIDTH, x, y,
987  mbs_per_slice, td);
988  }
989 
990  for (x = ctx->slices_width - 1; x >= 0; x--) {
991  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
992  q = td->nodes[q].prev_node;
993  }
994 
995  return 0;
996 }
997 
999  const AVFrame *pic, int *got_packet)
1000 {
1001  ProresContext *ctx = avctx->priv_data;
1002  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
1003  uint8_t *picture_size_pos;
1004  PutBitContext pb;
1005  int x, y, i, mb, q = 0;
1006  int sizes[4] = { 0 };
1007  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
1008  int frame_size, picture_size, slice_size;
1009  int pkt_size, ret;
1010  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
1011  uint8_t frame_flags;
1012 
1013  ctx->pic = pic;
1014  pkt_size = ctx->frame_size_upper_bound;
1015 
1016  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
1017  return ret;
1018 
1019  orig_buf = pkt->data;
1020 
1021  // frame atom
1022  orig_buf += 4; // frame size
1023  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
1024  buf = orig_buf;
1025 
1026  // frame header
1027  tmp = buf;
1028  buf += 2; // frame header size will be stored here
1029  bytestream_put_be16 (&buf, 0); // version 1
1030  bytestream_put_buffer(&buf, ctx->vendor, 4);
1031  bytestream_put_be16 (&buf, avctx->width);
1032  bytestream_put_be16 (&buf, avctx->height);
1033 
1034  frame_flags = ctx->chroma_factor << 6;
1035  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1036  frame_flags |= pic->top_field_first ? 0x04 : 0x08;
1037  bytestream_put_byte (&buf, frame_flags);
1038 
1039  bytestream_put_byte (&buf, 0); // reserved
1040  bytestream_put_byte (&buf, pic->color_primaries);
1041  bytestream_put_byte (&buf, pic->color_trc);
1042  bytestream_put_byte (&buf, pic->colorspace);
1043  bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
1044  bytestream_put_byte (&buf, 0); // reserved
1045  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1046  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1047  // luma quantisation matrix
1048  for (i = 0; i < 64; i++)
1049  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1050  // chroma quantisation matrix
1051  for (i = 0; i < 64; i++)
1052  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1053  } else {
1054  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1055  }
1056  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1057 
1058  for (ctx->cur_picture_idx = 0;
1059  ctx->cur_picture_idx < ctx->pictures_per_frame;
1060  ctx->cur_picture_idx++) {
1061  // picture header
1062  picture_size_pos = buf + 1;
1063  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1064  buf += 4; // picture data size will be stored here
1065  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1066  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1067 
1068  // seek table - will be filled during slice encoding
1069  slice_sizes = buf;
1070  buf += ctx->slices_per_picture * 2;
1071 
1072  // slices
1073  if (!ctx->force_quant) {
1074  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1075  ctx->mb_height);
1076  if (ret)
1077  return ret;
1078  }
1079 
1080  for (y = 0; y < ctx->mb_height; y++) {
1081  int mbs_per_slice = ctx->mbs_per_slice;
1082  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1083  q = ctx->force_quant ? ctx->force_quant
1084  : ctx->slice_q[mb + y * ctx->slices_width];
1085 
1086  while (ctx->mb_width - x < mbs_per_slice)
1087  mbs_per_slice >>= 1;
1088 
1089  bytestream_put_byte(&buf, slice_hdr_size << 3);
1090  slice_hdr = buf;
1091  buf += slice_hdr_size - 1;
1092  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1093  uint8_t *start = pkt->data;
1094  // Recompute new size according to max_slice_size
1095  // and deduce delta
1096  int delta = 200 + (ctx->pictures_per_frame *
1097  ctx->slices_per_picture + 1) *
1098  max_slice_size - pkt_size;
1099 
1100  delta = FFMAX(delta, 2 * max_slice_size);
1101  ctx->frame_size_upper_bound += delta;
1102 
1103  if (!ctx->warn) {
1104  avpriv_request_sample(avctx,
1105  "Packet too small: is %i,"
1106  " needs %i (slice: %i). "
1107  "Correct allocation",
1108  pkt_size, delta, max_slice_size);
1109  ctx->warn = 1;
1110  }
1111 
1112  ret = av_grow_packet(pkt, delta);
1113  if (ret < 0)
1114  return ret;
1115 
1116  pkt_size += delta;
1117  // restore pointers
1118  orig_buf = pkt->data + (orig_buf - start);
1119  buf = pkt->data + (buf - start);
1120  picture_size_pos = pkt->data + (picture_size_pos - start);
1121  slice_sizes = pkt->data + (slice_sizes - start);
1122  slice_hdr = pkt->data + (slice_hdr - start);
1123  tmp = pkt->data + (tmp - start);
1124  }
1125  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1126  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1127  mbs_per_slice);
1128  if (ret < 0)
1129  return ret;
1130 
1131  bytestream_put_byte(&slice_hdr, q);
1132  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1133  for (i = 0; i < ctx->num_planes - 1; i++) {
1134  bytestream_put_be16(&slice_hdr, sizes[i]);
1135  slice_size += sizes[i];
1136  }
1137  bytestream_put_be16(&slice_sizes, slice_size);
1138  buf += slice_size - slice_hdr_size;
1139  if (max_slice_size < slice_size)
1140  max_slice_size = slice_size;
1141  }
1142  }
1143 
1144  picture_size = buf - (picture_size_pos - 1);
1145  bytestream_put_be32(&picture_size_pos, picture_size);
1146  }
1147 
1148  orig_buf -= 8;
1149  frame_size = buf - orig_buf;
1150  bytestream_put_be32(&orig_buf, frame_size);
1151 
1152  pkt->size = frame_size;
1153  pkt->flags |= AV_PKT_FLAG_KEY;
1154  *got_packet = 1;
1155 
1156  return 0;
1157 }
1158 
1160 {
1161  ProresContext *ctx = avctx->priv_data;
1162  int i;
1163 
1164  if (ctx->tdata) {
1165  for (i = 0; i < avctx->thread_count; i++)
1166  av_freep(&ctx->tdata[i].nodes);
1167  }
1168  av_freep(&ctx->tdata);
1169  av_freep(&ctx->slice_q);
1170 
1171  return 0;
1172 }
1173 
1174 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1175  ptrdiff_t linesize, int16_t *block)
1176 {
1177  int x, y;
1178  const uint16_t *tsrc = src;
1179 
1180  for (y = 0; y < 8; y++) {
1181  for (x = 0; x < 8; x++)
1182  block[y * 8 + x] = tsrc[x];
1183  tsrc += linesize >> 1;
1184  }
1185  fdsp->fdct(block);
1186 }
1187 
1189 {
1190  ProresContext *ctx = avctx->priv_data;
1191  int mps;
1192  int i, j;
1193  int min_quant, max_quant;
1194  int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1195 
1196  avctx->bits_per_raw_sample = 10;
1197 #if FF_API_CODED_FRAME
1200  avctx->coded_frame->key_frame = 1;
1202 #endif
1203 
1204  ctx->fdct = prores_fdct;
1205  ctx->scantable = interlaced ? ff_prores_interlaced_scan
1207  ff_fdctdsp_init(&ctx->fdsp, avctx);
1208 
1209  mps = ctx->mbs_per_slice;
1210  if (mps & (mps - 1)) {
1211  av_log(avctx, AV_LOG_ERROR,
1212  "there should be an integer power of two MBs per slice\n");
1213  return AVERROR(EINVAL);
1214  }
1215  if (ctx->profile == PRORES_PROFILE_AUTO) {
1217  ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1218  !(desc->log2_chroma_w + desc->log2_chroma_h))
1220  av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1221  "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1222  ? "4:4:4:4 profile because of the used input colorspace"
1223  : "HQ profile to keep best quality");
1224  }
1226  if (ctx->profile != PRORES_PROFILE_4444 &&
1227  ctx->profile != PRORES_PROFILE_4444XQ) {
1228  // force alpha and warn
1229  av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1230  "encode alpha. Override with -profile if needed.\n");
1231  ctx->alpha_bits = 0;
1232  }
1233  if (ctx->alpha_bits & 7) {
1234  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1235  return AVERROR(EINVAL);
1236  }
1237  avctx->bits_per_coded_sample = 32;
1238  } else {
1239  ctx->alpha_bits = 0;
1240  }
1241 
1242  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1243  ? CFACTOR_Y422
1244  : CFACTOR_Y444;
1246  ctx->num_planes = 3 + !!ctx->alpha_bits;
1247 
1248  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1249 
1250  if (interlaced)
1251  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1252  else
1253  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1254 
1255  ctx->slices_width = ctx->mb_width / mps;
1256  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1257  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1258  ctx->pictures_per_frame = 1 + interlaced;
1259 
1260  if (ctx->quant_sel == -1) {
1263  } else {
1266  }
1267 
1268  if (strlen(ctx->vendor) != 4) {
1269  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1270  return AVERROR_INVALIDDATA;
1271  }
1272 
1273  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1274  if (!ctx->force_quant) {
1275  if (!ctx->bits_per_mb) {
1276  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1277  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1278  ctx->pictures_per_frame)
1279  break;
1280  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1281  if (ctx->alpha_bits)
1282  ctx->bits_per_mb *= 20;
1283  } else if (ctx->bits_per_mb < 128) {
1284  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1285  return AVERROR_INVALIDDATA;
1286  }
1287 
1288  min_quant = ctx->profile_info->min_quant;
1289  max_quant = ctx->profile_info->max_quant;
1290  for (i = min_quant; i < MAX_STORED_Q; i++) {
1291  for (j = 0; j < 64; j++) {
1292  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1293  ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1294  }
1295  }
1296 
1297  ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1298  if (!ctx->slice_q) {
1299  encode_close(avctx);
1300  return AVERROR(ENOMEM);
1301  }
1302 
1303  ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1304  if (!ctx->tdata) {
1305  encode_close(avctx);
1306  return AVERROR(ENOMEM);
1307  }
1308 
1309  for (j = 0; j < avctx->thread_count; j++) {
1310  ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1311  * TRELLIS_WIDTH
1312  * sizeof(*ctx->tdata->nodes));
1313  if (!ctx->tdata[j].nodes) {
1314  encode_close(avctx);
1315  return AVERROR(ENOMEM);
1316  }
1317  for (i = min_quant; i < max_quant + 2; i++) {
1318  ctx->tdata[j].nodes[i].prev_node = -1;
1319  ctx->tdata[j].nodes[i].bits = 0;
1320  ctx->tdata[j].nodes[i].score = 0;
1321  }
1322  }
1323  } else {
1324  int ls = 0;
1325  int ls_chroma = 0;
1326 
1327  if (ctx->force_quant > 64) {
1328  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1329  return AVERROR_INVALIDDATA;
1330  }
1331 
1332  for (j = 0; j < 64; j++) {
1333  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1334  ctx->quants_chroma[0][j] = ctx->quant_chroma_mat[j] * ctx->force_quant;
1335  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1336  ls_chroma += av_log2((1 << 11) / ctx->quants_chroma[0][j]) * 2 + 1;
1337  }
1338 
1339  ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1340  if (ctx->chroma_factor == CFACTOR_Y444)
1341  ctx->bits_per_mb += ls_chroma * 4;
1342  }
1343 
1345  ctx->slices_per_picture + 1) *
1346  (2 + 2 * ctx->num_planes +
1347  (mps * ctx->bits_per_mb) / 8)
1348  + 200;
1349 
1350  if (ctx->alpha_bits) {
1351  // The alpha plane is run-coded and might exceed the bit budget.
1353  ctx->slices_per_picture + 1) *
1354  /* num pixels per slice */ (ctx->mbs_per_slice * 256 *
1355  /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);
1356  }
1357 
1358  avctx->codec_tag = ctx->profile_info->tag;
1359 
1360  av_log(avctx, AV_LOG_DEBUG,
1361  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1362  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1363  interlaced ? "yes" : "no", ctx->bits_per_mb);
1364  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1365  ctx->frame_size_upper_bound);
1366 
1367  return 0;
1368 }
1369 
1370 #define OFFSET(x) offsetof(ProresContext, x)
1371 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1372 
1373 static const AVOption options[] = {
1374  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1375  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1376  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1377  { .i64 = PRORES_PROFILE_AUTO },
1379  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1380  0, 0, VE, "profile" },
1381  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1382  0, 0, VE, "profile" },
1383  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1384  0, 0, VE, "profile" },
1385  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1386  0, 0, VE, "profile" },
1387  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1388  0, 0, VE, "profile" },
1389  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1390  0, 0, VE, "profile" },
1391  { "4444xq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
1392  0, 0, VE, "profile" },
1393  { "vendor", "vendor ID", OFFSET(vendor),
1394  AV_OPT_TYPE_STRING, { .str = "Lavc" }, 0, 0, VE },
1395  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1396  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1397  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1398  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1399  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1400  0, 0, VE, "quant_mat" },
1401  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1402  0, 0, VE, "quant_mat" },
1403  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1404  0, 0, VE, "quant_mat" },
1405  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1406  0, 0, VE, "quant_mat" },
1407  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1408  0, 0, VE, "quant_mat" },
1409  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1410  0, 0, VE, "quant_mat" },
1411  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1412  { .i64 = 16 }, 0, 16, VE },
1413  { NULL }
1414 };
1415 
1416 static const AVClass proresenc_class = {
1417  .class_name = "ProRes encoder",
1418  .item_name = av_default_item_name,
1419  .option = options,
1420  .version = LIBAVUTIL_VERSION_INT,
1421 };
1422 
1424  .name = "prores_ks",
1425  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1426  .type = AVMEDIA_TYPE_VIDEO,
1427  .id = AV_CODEC_ID_PRORES,
1428  .priv_data_size = sizeof(ProresContext),
1429  .init = encode_init,
1430  .close = encode_close,
1431  .encode2 = encode_frame,
1433  .pix_fmts = (const enum AVPixelFormat[]) {
1436  },
1437  .priv_class = &proresenc_class,
1439 };
static const AVClass proresenc_class
#define MAX_MBS_PER_SLICE
#define NULL
Definition: coverity.c:32
#define CFACTOR_Y444
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
int16_t quants_chroma[MAX_STORED_Q][64]
AVOption.
Definition: opt.h:248
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:260
static av_cold int encode_init(AVCodecContext *avctx)
const char * desc
Definition: libsvtav1.c:79
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
const uint8_t ff_prores_ac_codebook[7]
Definition: proresdata.c:55
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define avpriv_request_sample(...)
static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice, int plane_size_factor, const uint8_t *scan, const int16_t *qmat)
int16_t custom_chroma_q[64]
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_log2(unsigned v)
Definition: intmath.c:26
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
uint16_t emu_buf[16 *16]
unsigned mb_height
height of the current picture in mb
Definition: proresdec.h:48
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static const AVOption options[]
uint8_t run
Definition: svq3.c:205
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1742
static av_cold int encode_close(AVCodecContext *avctx)
static void error(const char *err)
const uint8_t * quant_chroma_mat
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
static void get_slice_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, uint16_t *emu_buf, int mbs_per_slice, int blocks_per_mb, int is_chroma)
AVCodec.
Definition: codec.h:190
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int16_t quants[MAX_STORED_Q][64]
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
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
const char * full_name
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:179
#define av_malloc(s)
#define mb
float delta
AVOptions.
static int estimate_vlc(unsigned codebook, int val)
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:363
const uint8_t ff_prores_run_to_cb_index[16]
Lookup tables for adaptive switching between codebooks according with previous run/level value...
Definition: proresdata.c:69
const uint8_t ff_prores_lev_to_cb_index[10]
Definition: proresdata.c:72
const uint8_t * scantable
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1735
static void encode_acs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int plane_size_factor, const uint8_t *scan, const int16_t *qmat)
static int estimate_alpha_plane(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks)
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
#define FFALIGN(x, a)
Definition: macros.h:48
const AVProfile ff_prores_profiles[]
Definition: profiles.c:159
#define av_log(a,...)
static int est_alpha_diff(int cur, int prev, int abits)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define src
Definition: vp8dsp.c:255
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
unsigned mb_width
width of the current picture in mb
Definition: proresdec.h:47
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define td
Definition: regdef.h:70
int16_t custom_chroma_q[64]
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:109
static const uint16_t mask[17]
Definition: lzw.c:38
static const int sizes[][2]
Definition: img2dec.c:53
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
int16_t custom_q[64]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
const struct prores_profile * profile_info
uint16_t emu_buf[16 *16]
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:569
static const struct prores_profile prores_profile_info[6]
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
uint8_t bits
Definition: vp3data.h:141
static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int blocks_per_mb, int plane_size_factor, const int16_t *qmat, ProresThreadData *td)
ProresThreadData * tdata
#define FFMAX(a, b)
Definition: common.h:103
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
static const int prores_mb_limits[NUM_MB_LIMITS]
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
struct TrellisNode * nodes
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:83
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
#define NUM_MB_LIMITS
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
#define FFMIN(a, b)
Definition: common.h:105
const AVFrame * pic
uint8_t interlaced
Definition: mxfenc.c:2207
int width
picture width / height.
Definition: avcodec.h:704
uint8_t w
Definition: llviddspenc.c:39
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
#define VE
static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks, int blocks_per_mb, int plane_size_factor, const int16_t *qmat)
AVFormatContext * ctx
Definition: movenc.c:48
#define av_popcount
Definition: common.h:176
const uint8_t ff_prores_dc_codebook[4]
Definition: proresdata.c:48
#define MAX_STORED_Q
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
#define SCORE_LIMIT
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1768
#define FIRST_DC_CB
Definition: proresdata.h:33
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1835
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
int frame_size
Definition: mxfenc.c:2205
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:531
FDCTDSPContext fdsp
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
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
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
Describe the class of an AVClass context structure.
Definition: log.h:67
int16_t custom_q[64]
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
mfxU16 profile
Definition: qsvenc.c:45
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:597
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
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
static int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t level
Definition: svq3.c:206
#define GET_SIGN(x)
#define CFACTOR_Y422
int br_tab[NUM_MB_LIMITS]
static void put_alpha_run(PutBitContext *pb, int run)
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define OFFSET(x)
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
static const uint8_t prores_quant_matrices[][64]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:117
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1759
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:111
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
void * priv_data
Definition: avcodec.h:558
#define TRELLIS_WIDTH
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:466
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
#define MAKE_CODE(x)
enum AVColorPrimaries color_primaries
Definition: frame.h:560
#define av_freep(p)
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:562
AVCodec ff_prores_ks_encoder
const uint8_t * quant_mat
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
#define FRAME_ID
Definition: proresdata.h:28
#define MKTAG(a, b, c, d)
Definition: common.h:478
static void get_alpha_data(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int x, int y, int w, int h, int16_t *blocks, int mbs_per_slice, int abits)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
#define MAX_PLANES
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
int i
Definition: input.c:407
#define av_mod_uintp2
Definition: common.h:149
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
bitstream writer API