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 = mbs_per_slice * blocks_per_mb;
474 
475  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
476  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
477  ctx->scantable, qmat);
478 }
479 
480 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
481 {
482  const int dbits = (abits == 8) ? 4 : 7;
483  const int dsize = 1 << dbits - 1;
484  int diff = cur - prev;
485 
486  diff = av_mod_uintp2(diff, abits);
487  if (diff >= (1 << abits) - dsize)
488  diff -= 1 << abits;
489  if (diff < -dsize || diff > dsize || !diff) {
490  put_bits(pb, 1, 1);
491  put_bits(pb, abits, diff);
492  } else {
493  put_bits(pb, 1, 0);
494  put_bits(pb, dbits - 1, FFABS(diff) - 1);
495  put_bits(pb, 1, diff < 0);
496  }
497 }
498 
499 static void put_alpha_run(PutBitContext *pb, int run)
500 {
501  if (run) {
502  put_bits(pb, 1, 0);
503  if (run < 0x10)
504  put_bits(pb, 4, run);
505  else
506  put_bits(pb, 15, run);
507  } else {
508  put_bits(pb, 1, 1);
509  }
510 }
511 
512 // todo alpha quantisation for high quants
514  int mbs_per_slice, uint16_t *blocks,
515  int quant)
516 {
517  const int abits = ctx->alpha_bits;
518  const int mask = (1 << abits) - 1;
519  const int num_coeffs = mbs_per_slice * 256;
520  int prev = mask, cur;
521  int idx = 0;
522  int run = 0;
523 
524  cur = blocks[idx++];
525  put_alpha_diff(pb, cur, prev, abits);
526  prev = cur;
527  do {
528  cur = blocks[idx++];
529  if (cur != prev) {
530  put_alpha_run (pb, run);
531  put_alpha_diff(pb, cur, prev, abits);
532  prev = cur;
533  run = 0;
534  } else {
535  run++;
536  }
537  } while (idx < num_coeffs);
538  if (run)
539  put_alpha_run(pb, run);
540 }
541 
542 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
543  PutBitContext *pb,
544  int sizes[4], int x, int y, int quant,
545  int mbs_per_slice)
546 {
547  ProresContext *ctx = avctx->priv_data;
548  int i, xp, yp;
549  int total_size = 0;
550  const uint16_t *src;
551  int slice_width_factor = av_log2(mbs_per_slice);
552  int num_cblocks, pwidth, line_add;
553  ptrdiff_t linesize;
554  int plane_factor, is_chroma;
555  uint16_t *qmat;
556  uint16_t *qmat_chroma;
557 
558  if (ctx->pictures_per_frame == 1)
559  line_add = 0;
560  else
561  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
562 
563  if (ctx->force_quant) {
564  qmat = ctx->quants[0];
565  qmat_chroma = ctx->quants_chroma[0];
566  } else if (quant < MAX_STORED_Q) {
567  qmat = ctx->quants[quant];
568  qmat_chroma = ctx->quants_chroma[quant];
569  } else {
570  qmat = ctx->custom_q;
571  qmat_chroma = ctx->custom_chroma_q;
572  for (i = 0; i < 64; i++) {
573  qmat[i] = ctx->quant_mat[i] * quant;
574  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
575  }
576  }
577 
578  for (i = 0; i < ctx->num_planes; i++) {
579  is_chroma = (i == 1 || i == 2);
580  plane_factor = slice_width_factor + 2;
581  if (is_chroma)
582  plane_factor += ctx->chroma_factor - 3;
583  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
584  xp = x << 4;
585  yp = y << 4;
586  num_cblocks = 4;
587  pwidth = avctx->width;
588  } else {
589  xp = x << 3;
590  yp = y << 4;
591  num_cblocks = 2;
592  pwidth = avctx->width >> 1;
593  }
594 
595  linesize = pic->linesize[i] * ctx->pictures_per_frame;
596  src = (const uint16_t*)(pic->data[i] + yp * linesize +
597  line_add * pic->linesize[i]) + xp;
598 
599  if (i < 3) {
600  get_slice_data(ctx, src, linesize, xp, yp,
601  pwidth, avctx->height / ctx->pictures_per_frame,
602  ctx->blocks[0], ctx->emu_buf,
603  mbs_per_slice, num_cblocks, is_chroma);
604  if (!is_chroma) {/* luma quant */
605  encode_slice_plane(ctx, pb, src, linesize,
606  mbs_per_slice, ctx->blocks[0],
607  num_cblocks, plane_factor, qmat);
608  } else { /* chroma plane */
609  encode_slice_plane(ctx, pb, src, linesize,
610  mbs_per_slice, ctx->blocks[0],
611  num_cblocks, plane_factor, qmat_chroma);
612  }
613  } else {
614  get_alpha_data(ctx, src, linesize, xp, yp,
615  pwidth, avctx->height / ctx->pictures_per_frame,
616  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
617  encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
618  }
619  flush_put_bits(pb);
620  sizes[i] = put_bytes_output(pb) - total_size;
621  total_size = put_bytes_output(pb);
622  }
623  return total_size;
624 }
625 
626 static inline int estimate_vlc(unsigned codebook, int val)
627 {
628  unsigned int rice_order, exp_order, switch_bits, switch_val;
629  int exponent;
630 
631  /* number of prefix bits to switch between Rice and expGolomb */
632  switch_bits = (codebook & 3) + 1;
633  rice_order = codebook >> 5; /* rice code order */
634  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
635 
636  switch_val = switch_bits << rice_order;
637 
638  if (val >= switch_val) {
639  val -= switch_val - (1 << exp_order);
640  exponent = av_log2(val);
641 
642  return exponent * 2 - exp_order + switch_bits + 1;
643  } else {
644  return (val >> rice_order) + rice_order + 1;
645  }
646 }
647 
648 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
649  int scale)
650 {
651  int i;
652  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
653  int bits;
654 
655  prev_dc = (blocks[0] - 0x4000) / scale;
656  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
657  sign = 0;
658  codebook = 3;
659  blocks += 64;
660  *error += FFABS(blocks[0] - 0x4000) % scale;
661 
662  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
663  dc = (blocks[0] - 0x4000) / scale;
664  *error += FFABS(blocks[0] - 0x4000) % scale;
665  delta = dc - prev_dc;
666  new_sign = GET_SIGN(delta);
667  delta = (delta ^ sign) - sign;
668  code = MAKE_CODE(delta);
669  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
670  codebook = (code + (code & 1)) >> 1;
671  codebook = FFMIN(codebook, 3);
672  sign = new_sign;
673  prev_dc = dc;
674  }
675 
676  return bits;
677 }
678 
679 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
680  int plane_size_factor,
681  const uint8_t *scan, const int16_t *qmat)
682 {
683  int idx, i;
684  int run, level, run_cb, lev_cb;
685  int max_coeffs, abs_level;
686  int bits = 0;
687 
688  max_coeffs = blocks_per_slice << 6;
689  run_cb = ff_prores_run_to_cb_index[4];
690  lev_cb = ff_prores_lev_to_cb_index[2];
691  run = 0;
692 
693  for (i = 1; i < 64; i++) {
694  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
695  level = blocks[idx] / qmat[scan[i]];
696  *error += FFABS(blocks[idx]) % qmat[scan[i]];
697  if (level) {
698  abs_level = FFABS(level);
699  bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
700  bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
701  abs_level - 1) + 1;
702 
703  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
704  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
705  run = 0;
706  } else {
707  run++;
708  }
709  }
710  }
711 
712  return bits;
713 }
714 
715 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
716  const uint16_t *src, ptrdiff_t linesize,
717  int mbs_per_slice,
718  int blocks_per_mb, int plane_size_factor,
719  const int16_t *qmat, ProresThreadData *td)
720 {
721  int blocks_per_slice;
722  int bits;
723 
724  blocks_per_slice = mbs_per_slice * blocks_per_mb;
725 
726  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
727  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
728  plane_size_factor, ctx->scantable, qmat);
729 
730  return FFALIGN(bits, 8);
731 }
732 
733 static int est_alpha_diff(int cur, int prev, int abits)
734 {
735  const int dbits = (abits == 8) ? 4 : 7;
736  const int dsize = 1 << dbits - 1;
737  int diff = cur - prev;
738 
739  diff = av_mod_uintp2(diff, abits);
740  if (diff >= (1 << abits) - dsize)
741  diff -= 1 << abits;
742  if (diff < -dsize || diff > dsize || !diff)
743  return abits + 1;
744  else
745  return dbits + 1;
746 }
747 
749  const uint16_t *src, ptrdiff_t linesize,
750  int mbs_per_slice, int16_t *blocks)
751 {
752  const int abits = ctx->alpha_bits;
753  const int mask = (1 << abits) - 1;
754  const int num_coeffs = mbs_per_slice * 256;
755  int prev = mask, cur;
756  int idx = 0;
757  int run = 0;
758  int bits;
759 
760  cur = blocks[idx++];
761  bits = est_alpha_diff(cur, prev, abits);
762  prev = cur;
763  do {
764  cur = blocks[idx++];
765  if (cur != prev) {
766  if (!run)
767  bits++;
768  else if (run < 0x10)
769  bits += 4;
770  else
771  bits += 15;
772  bits += est_alpha_diff(cur, prev, abits);
773  prev = cur;
774  run = 0;
775  } else {
776  run++;
777  }
778  } while (idx < num_coeffs);
779 
780  if (run) {
781  if (run < 0x10)
782  bits += 4;
783  else
784  bits += 15;
785  }
786 
787  return bits;
788 }
789 
791  int trellis_node, int x, int y, int mbs_per_slice,
793 {
794  ProresContext *ctx = avctx->priv_data;
795  int i, q, pq, xp, yp;
796  const uint16_t *src;
797  int slice_width_factor = av_log2(mbs_per_slice);
798  int num_cblocks[MAX_PLANES], pwidth;
799  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
800  const int min_quant = ctx->profile_info->min_quant;
801  const int max_quant = ctx->profile_info->max_quant;
802  int error, bits, bits_limit;
803  int mbs, prev, cur, new_score;
804  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
805  int overquant;
806  uint16_t *qmat;
807  uint16_t *qmat_chroma;
808  int linesize[4], line_add;
809  int alpha_bits = 0;
810 
811  if (ctx->pictures_per_frame == 1)
812  line_add = 0;
813  else
814  line_add = ctx->cur_picture_idx ^ !ctx->pic->top_field_first;
815  mbs = x + mbs_per_slice;
816 
817  for (i = 0; i < ctx->num_planes; i++) {
818  is_chroma[i] = (i == 1 || i == 2);
819  plane_factor[i] = slice_width_factor + 2;
820  if (is_chroma[i])
821  plane_factor[i] += ctx->chroma_factor - 3;
822  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
823  xp = x << 4;
824  yp = y << 4;
825  num_cblocks[i] = 4;
826  pwidth = avctx->width;
827  } else {
828  xp = x << 3;
829  yp = y << 4;
830  num_cblocks[i] = 2;
831  pwidth = avctx->width >> 1;
832  }
833 
834  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
835  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
836  line_add * ctx->pic->linesize[i]) + xp;
837 
838  if (i < 3) {
839  get_slice_data(ctx, src, linesize[i], xp, yp,
840  pwidth, avctx->height / ctx->pictures_per_frame,
841  td->blocks[i], td->emu_buf,
842  mbs_per_slice, num_cblocks[i], is_chroma[i]);
843  } else {
844  get_alpha_data(ctx, src, linesize[i], xp, yp,
845  pwidth, avctx->height / ctx->pictures_per_frame,
846  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
847  }
848  }
849 
850  for (q = min_quant; q < max_quant + 2; q++) {
851  td->nodes[trellis_node + q].prev_node = -1;
852  td->nodes[trellis_node + q].quant = q;
853  }
854 
855  if (ctx->alpha_bits)
856  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
857  mbs_per_slice, td->blocks[3]);
858  // todo: maybe perform coarser quantising to fit into frame size when needed
859  for (q = min_quant; q <= max_quant; q++) {
860  bits = alpha_bits;
861  error = 0;
862  bits += estimate_slice_plane(ctx, &error, 0,
863  src, linesize[0],
864  mbs_per_slice,
865  num_cblocks[0], plane_factor[0],
866  ctx->quants[q], td); /* estimate luma plane */
867  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
868  bits += estimate_slice_plane(ctx, &error, i,
869  src, linesize[i],
870  mbs_per_slice,
871  num_cblocks[i], plane_factor[i],
872  ctx->quants_chroma[q], td);
873  }
874  if (bits > 65000 * 8)
875  error = SCORE_LIMIT;
876 
877  slice_bits[q] = bits;
878  slice_score[q] = error;
879  }
880  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
881  slice_bits[max_quant + 1] = slice_bits[max_quant];
882  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
883  overquant = max_quant;
884  } else {
885  for (q = max_quant + 1; q < 128; q++) {
886  bits = alpha_bits;
887  error = 0;
888  if (q < MAX_STORED_Q) {
889  qmat = ctx->quants[q];
890  qmat_chroma = ctx->quants_chroma[q];
891  } else {
892  qmat = td->custom_q;
893  qmat_chroma = td->custom_chroma_q;
894  for (i = 0; i < 64; i++) {
895  qmat[i] = ctx->quant_mat[i] * q;
896  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
897  }
898  }
899  bits += estimate_slice_plane(ctx, &error, 0,
900  src, linesize[0],
901  mbs_per_slice,
902  num_cblocks[0], plane_factor[0],
903  qmat, td);/* estimate luma plane */
904  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
905  bits += estimate_slice_plane(ctx, &error, i,
906  src, linesize[i],
907  mbs_per_slice,
908  num_cblocks[i], plane_factor[i],
909  qmat_chroma, td);
910  }
911  if (bits <= ctx->bits_per_mb * mbs_per_slice)
912  break;
913  }
914 
915  slice_bits[max_quant + 1] = bits;
916  slice_score[max_quant + 1] = error;
917  overquant = q;
918  }
919  td->nodes[trellis_node + max_quant + 1].quant = overquant;
920 
921  bits_limit = mbs * ctx->bits_per_mb;
922  for (pq = min_quant; pq < max_quant + 2; pq++) {
923  prev = trellis_node - TRELLIS_WIDTH + pq;
924 
925  for (q = min_quant; q < max_quant + 2; q++) {
926  cur = trellis_node + q;
927 
928  bits = td->nodes[prev].bits + slice_bits[q];
929  error = slice_score[q];
930  if (bits > bits_limit)
931  error = SCORE_LIMIT;
932 
933  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
934  new_score = td->nodes[prev].score + error;
935  else
936  new_score = SCORE_LIMIT;
937  if (td->nodes[cur].prev_node == -1 ||
938  td->nodes[cur].score >= new_score) {
939 
940  td->nodes[cur].bits = bits;
941  td->nodes[cur].score = new_score;
942  td->nodes[cur].prev_node = prev;
943  }
944  }
945  }
946 
947  error = td->nodes[trellis_node + min_quant].score;
948  pq = trellis_node + min_quant;
949  for (q = min_quant + 1; q < max_quant + 2; q++) {
950  if (td->nodes[trellis_node + q].score <= error) {
951  error = td->nodes[trellis_node + q].score;
952  pq = trellis_node + q;
953  }
954  }
955 
956  return pq;
957 }
958 
959 static int find_quant_thread(AVCodecContext *avctx, void *arg,
960  int jobnr, int threadnr)
961 {
962  ProresContext *ctx = avctx->priv_data;
963  ProresThreadData *td = ctx->tdata + threadnr;
964  int mbs_per_slice = ctx->mbs_per_slice;
965  int x, y = jobnr, mb, q = 0;
966 
967  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
968  while (ctx->mb_width - x < mbs_per_slice)
969  mbs_per_slice >>= 1;
970  q = find_slice_quant(avctx,
971  (mb + 1) * TRELLIS_WIDTH, x, y,
972  mbs_per_slice, td);
973  }
974 
975  for (x = ctx->slices_width - 1; x >= 0; x--) {
976  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
977  q = td->nodes[q].prev_node;
978  }
979 
980  return 0;
981 }
982 
984  const AVFrame *pic, int *got_packet)
985 {
986  ProresContext *ctx = avctx->priv_data;
987  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
988  uint8_t *picture_size_pos;
989  PutBitContext pb;
990  int x, y, i, mb, q = 0;
991  int sizes[4] = { 0 };
992  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
993  int frame_size, picture_size, slice_size;
994  int pkt_size, ret;
995  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
996  uint8_t frame_flags;
997 
998  ctx->pic = pic;
999  pkt_size = ctx->frame_size_upper_bound;
1000 
1001  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
1002  return ret;
1003 
1004  orig_buf = pkt->data;
1005 
1006  // frame atom
1007  orig_buf += 4; // frame size
1008  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
1009  buf = orig_buf;
1010 
1011  // frame header
1012  tmp = buf;
1013  buf += 2; // frame header size will be stored here
1014  bytestream_put_be16 (&buf, 0); // version 1
1015  bytestream_put_buffer(&buf, ctx->vendor, 4);
1016  bytestream_put_be16 (&buf, avctx->width);
1017  bytestream_put_be16 (&buf, avctx->height);
1018 
1019  frame_flags = ctx->chroma_factor << 6;
1020  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1021  frame_flags |= pic->top_field_first ? 0x04 : 0x08;
1022  bytestream_put_byte (&buf, frame_flags);
1023 
1024  bytestream_put_byte (&buf, 0); // reserved
1025  bytestream_put_byte (&buf, pic->color_primaries);
1026  bytestream_put_byte (&buf, pic->color_trc);
1027  bytestream_put_byte (&buf, pic->colorspace);
1028  bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
1029  bytestream_put_byte (&buf, 0); // reserved
1030  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1031  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1032  // luma quantisation matrix
1033  for (i = 0; i < 64; i++)
1034  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1035  // chroma quantisation matrix
1036  for (i = 0; i < 64; i++)
1037  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1038  } else {
1039  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1040  }
1041  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1042 
1043  for (ctx->cur_picture_idx = 0;
1044  ctx->cur_picture_idx < ctx->pictures_per_frame;
1045  ctx->cur_picture_idx++) {
1046  // picture header
1047  picture_size_pos = buf + 1;
1048  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1049  buf += 4; // picture data size will be stored here
1050  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1051  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1052 
1053  // seek table - will be filled during slice encoding
1054  slice_sizes = buf;
1055  buf += ctx->slices_per_picture * 2;
1056 
1057  // slices
1058  if (!ctx->force_quant) {
1059  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1060  ctx->mb_height);
1061  if (ret)
1062  return ret;
1063  }
1064 
1065  for (y = 0; y < ctx->mb_height; y++) {
1066  int mbs_per_slice = ctx->mbs_per_slice;
1067  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1068  q = ctx->force_quant ? ctx->force_quant
1069  : ctx->slice_q[mb + y * ctx->slices_width];
1070 
1071  while (ctx->mb_width - x < mbs_per_slice)
1072  mbs_per_slice >>= 1;
1073 
1074  bytestream_put_byte(&buf, slice_hdr_size << 3);
1075  slice_hdr = buf;
1076  buf += slice_hdr_size - 1;
1077  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1078  uint8_t *start = pkt->data;
1079  // Recompute new size according to max_slice_size
1080  // and deduce delta
1081  int delta = 200 + (ctx->pictures_per_frame *
1082  ctx->slices_per_picture + 1) *
1083  max_slice_size - pkt_size;
1084 
1085  delta = FFMAX(delta, 2 * max_slice_size);
1086  ctx->frame_size_upper_bound += delta;
1087 
1088  if (!ctx->warn) {
1089  avpriv_request_sample(avctx,
1090  "Packet too small: is %i,"
1091  " needs %i (slice: %i). "
1092  "Correct allocation",
1093  pkt_size, delta, max_slice_size);
1094  ctx->warn = 1;
1095  }
1096 
1097  ret = av_grow_packet(pkt, delta);
1098  if (ret < 0)
1099  return ret;
1100 
1101  pkt_size += delta;
1102  // restore pointers
1103  orig_buf = pkt->data + (orig_buf - start);
1104  buf = pkt->data + (buf - start);
1105  picture_size_pos = pkt->data + (picture_size_pos - start);
1106  slice_sizes = pkt->data + (slice_sizes - start);
1107  slice_hdr = pkt->data + (slice_hdr - start);
1108  tmp = pkt->data + (tmp - start);
1109  }
1110  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1111  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1112  mbs_per_slice);
1113  if (ret < 0)
1114  return ret;
1115 
1116  bytestream_put_byte(&slice_hdr, q);
1117  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1118  for (i = 0; i < ctx->num_planes - 1; i++) {
1119  bytestream_put_be16(&slice_hdr, sizes[i]);
1120  slice_size += sizes[i];
1121  }
1122  bytestream_put_be16(&slice_sizes, slice_size);
1123  buf += slice_size - slice_hdr_size;
1124  if (max_slice_size < slice_size)
1125  max_slice_size = slice_size;
1126  }
1127  }
1128 
1129  picture_size = buf - (picture_size_pos - 1);
1130  bytestream_put_be32(&picture_size_pos, picture_size);
1131  }
1132 
1133  orig_buf -= 8;
1134  frame_size = buf - orig_buf;
1135  bytestream_put_be32(&orig_buf, frame_size);
1136 
1137  pkt->size = frame_size;
1138  pkt->flags |= AV_PKT_FLAG_KEY;
1139  *got_packet = 1;
1140 
1141  return 0;
1142 }
1143 
1145 {
1146  ProresContext *ctx = avctx->priv_data;
1147  int i;
1148 
1149  if (ctx->tdata) {
1150  for (i = 0; i < avctx->thread_count; i++)
1151  av_freep(&ctx->tdata[i].nodes);
1152  }
1153  av_freep(&ctx->tdata);
1154  av_freep(&ctx->slice_q);
1155 
1156  return 0;
1157 }
1158 
1159 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1160  ptrdiff_t linesize, int16_t *block)
1161 {
1162  int x, y;
1163  const uint16_t *tsrc = src;
1164 
1165  for (y = 0; y < 8; y++) {
1166  for (x = 0; x < 8; x++)
1167  block[y * 8 + x] = tsrc[x];
1168  tsrc += linesize >> 1;
1169  }
1170  fdsp->fdct(block);
1171 }
1172 
1174 {
1175  ProresContext *ctx = avctx->priv_data;
1176  int mps;
1177  int i, j;
1178  int min_quant, max_quant;
1179  int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1180 
1181  avctx->bits_per_raw_sample = 10;
1182 #if FF_API_CODED_FRAME
1185  avctx->coded_frame->key_frame = 1;
1187 #endif
1188 
1189  ctx->fdct = prores_fdct;
1190  ctx->scantable = interlaced ? ff_prores_interlaced_scan
1192  ff_fdctdsp_init(&ctx->fdsp, avctx);
1193 
1194  mps = ctx->mbs_per_slice;
1195  if (mps & (mps - 1)) {
1196  av_log(avctx, AV_LOG_ERROR,
1197  "there should be an integer power of two MBs per slice\n");
1198  return AVERROR(EINVAL);
1199  }
1200  if (ctx->profile == PRORES_PROFILE_AUTO) {
1202  ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1203  !(desc->log2_chroma_w + desc->log2_chroma_h))
1205  av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1206  "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1207  ? "4:4:4:4 profile because of the used input colorspace"
1208  : "HQ profile to keep best quality");
1209  }
1211  if (ctx->profile != PRORES_PROFILE_4444 &&
1212  ctx->profile != PRORES_PROFILE_4444XQ) {
1213  // force alpha and warn
1214  av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1215  "encode alpha. Override with -profile if needed.\n");
1216  ctx->alpha_bits = 0;
1217  }
1218  if (ctx->alpha_bits & 7) {
1219  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1220  return AVERROR(EINVAL);
1221  }
1222  avctx->bits_per_coded_sample = 32;
1223  } else {
1224  ctx->alpha_bits = 0;
1225  }
1226 
1227  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1228  ? CFACTOR_Y422
1229  : CFACTOR_Y444;
1231  ctx->num_planes = 3 + !!ctx->alpha_bits;
1232 
1233  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1234 
1235  if (interlaced)
1236  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1237  else
1238  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1239 
1240  ctx->slices_width = ctx->mb_width / mps;
1241  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1242  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1243  ctx->pictures_per_frame = 1 + interlaced;
1244 
1245  if (ctx->quant_sel == -1) {
1248  } else {
1251  }
1252 
1253  if (strlen(ctx->vendor) != 4) {
1254  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1255  return AVERROR_INVALIDDATA;
1256  }
1257 
1258  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1259  if (!ctx->force_quant) {
1260  if (!ctx->bits_per_mb) {
1261  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1262  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1263  ctx->pictures_per_frame)
1264  break;
1265  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1266  if (ctx->alpha_bits)
1267  ctx->bits_per_mb *= 20;
1268  } else if (ctx->bits_per_mb < 128) {
1269  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1270  return AVERROR_INVALIDDATA;
1271  }
1272 
1273  min_quant = ctx->profile_info->min_quant;
1274  max_quant = ctx->profile_info->max_quant;
1275  for (i = min_quant; i < MAX_STORED_Q; i++) {
1276  for (j = 0; j < 64; j++) {
1277  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1278  ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1279  }
1280  }
1281 
1282  ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1283  if (!ctx->slice_q) {
1284  encode_close(avctx);
1285  return AVERROR(ENOMEM);
1286  }
1287 
1288  ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1289  if (!ctx->tdata) {
1290  encode_close(avctx);
1291  return AVERROR(ENOMEM);
1292  }
1293 
1294  for (j = 0; j < avctx->thread_count; j++) {
1295  ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1296  * TRELLIS_WIDTH
1297  * sizeof(*ctx->tdata->nodes));
1298  if (!ctx->tdata[j].nodes) {
1299  encode_close(avctx);
1300  return AVERROR(ENOMEM);
1301  }
1302  for (i = min_quant; i < max_quant + 2; i++) {
1303  ctx->tdata[j].nodes[i].prev_node = -1;
1304  ctx->tdata[j].nodes[i].bits = 0;
1305  ctx->tdata[j].nodes[i].score = 0;
1306  }
1307  }
1308  } else {
1309  int ls = 0;
1310  int ls_chroma = 0;
1311 
1312  if (ctx->force_quant > 64) {
1313  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1314  return AVERROR_INVALIDDATA;
1315  }
1316 
1317  for (j = 0; j < 64; j++) {
1318  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1319  ctx->quants_chroma[0][j] = ctx->quant_chroma_mat[j] * ctx->force_quant;
1320  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1321  ls_chroma += av_log2((1 << 11) / ctx->quants_chroma[0][j]) * 2 + 1;
1322  }
1323 
1324  ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1325  if (ctx->chroma_factor == CFACTOR_Y444)
1326  ctx->bits_per_mb += ls_chroma * 4;
1327  }
1328 
1330  ctx->slices_per_picture + 1) *
1331  (2 + 2 * ctx->num_planes +
1332  (mps * ctx->bits_per_mb) / 8)
1333  + 200;
1334 
1335  if (ctx->alpha_bits) {
1336  // The alpha plane is run-coded and might exceed the bit budget.
1338  ctx->slices_per_picture + 1) *
1339  /* num pixels per slice */ (ctx->mbs_per_slice * 256 *
1340  /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);
1341  }
1342 
1343  avctx->codec_tag = ctx->profile_info->tag;
1344 
1345  av_log(avctx, AV_LOG_DEBUG,
1346  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1347  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1348  interlaced ? "yes" : "no", ctx->bits_per_mb);
1349  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1350  ctx->frame_size_upper_bound);
1351 
1352  return 0;
1353 }
1354 
1355 #define OFFSET(x) offsetof(ProresContext, x)
1356 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1357 
1358 static const AVOption options[] = {
1359  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1360  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1361  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1362  { .i64 = PRORES_PROFILE_AUTO },
1364  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1365  0, 0, VE, "profile" },
1366  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1367  0, 0, VE, "profile" },
1368  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1369  0, 0, VE, "profile" },
1370  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1371  0, 0, VE, "profile" },
1372  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1373  0, 0, VE, "profile" },
1374  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1375  0, 0, VE, "profile" },
1376  { "4444xq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
1377  0, 0, VE, "profile" },
1378  { "vendor", "vendor ID", OFFSET(vendor),
1379  AV_OPT_TYPE_STRING, { .str = "Lavc" }, 0, 0, VE },
1380  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1381  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1382  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1383  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1384  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1385  0, 0, VE, "quant_mat" },
1386  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1387  0, 0, VE, "quant_mat" },
1388  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1389  0, 0, VE, "quant_mat" },
1390  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1391  0, 0, VE, "quant_mat" },
1392  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1393  0, 0, VE, "quant_mat" },
1394  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1395  0, 0, VE, "quant_mat" },
1396  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1397  { .i64 = 16 }, 0, 16, VE },
1398  { NULL }
1399 };
1400 
1401 static const AVClass proresenc_class = {
1402  .class_name = "ProRes encoder",
1403  .item_name = av_default_item_name,
1404  .option = options,
1405  .version = LIBAVUTIL_VERSION_INT,
1406 };
1407 
1409  .name = "prores_ks",
1410  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1411  .type = AVMEDIA_TYPE_VIDEO,
1412  .id = AV_CODEC_ID_PRORES,
1413  .priv_data_size = sizeof(ProresContext),
1414  .init = encode_init,
1415  .close = encode_close,
1416  .encode2 = encode_frame,
1418  .pix_fmts = (const enum AVPixelFormat[]) {
1421  },
1422  .priv_class = &proresenc_class,
1424 };
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:318
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:290
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:370
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:746
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:203
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
static av_cold int encode_close(AVCodecContext *avctx)
AVPacket * pkt
Definition: movenc.c:59
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:197
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)
static void 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)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:369
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:1740
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:410
#define src
Definition: vp8dsp.c:255
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
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 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:117
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:616
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:573
static const struct prores_profile prores_profile_info[6]
const char * name
Name of the codec implementation.
Definition: codec.h:204
#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:108
static const int prores_mb_limits[NUM_MB_LIMITS]
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
struct TrellisNode * nodes
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:401
#define FFMIN(a, b)
Definition: common.h:105
const AVFrame * pic
uint8_t interlaced
Definition: mxfenc.c:2208
int width
picture width / height.
Definition: avcodec.h:709
uint8_t w
Definition: llviddspenc.c:39
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
#define VE
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)
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:93
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1773
#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:112
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:1844
#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:2206
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
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:536
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:561
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
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:602
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:332
uint8_t level
Definition: svq3.c:204
#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 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:147
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:1764
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:122
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:66
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:563
#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:470
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
#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:564
#define av_freep(p)
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:566
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:346
#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