FFmpeg
proresenc_kostya.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2011 Anatoliy Wasserman
5  * Copyright (c) 2012 Konstantin Shishkov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/mem.h"
25 #include "libavutil/mem_internal.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/pixdesc.h"
28 #include "avcodec.h"
29 #include "codec_internal.h"
30 #include "encode.h"
31 #include "fdctdsp.h"
32 #include "put_bits.h"
33 #include "profiles.h"
34 #include "bytestream.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 {
45  PRORES_PROFILE_AUTO = -1,
46  PRORES_PROFILE_PROXY = 0,
47  PRORES_PROFILE_LT,
48  PRORES_PROFILE_STANDARD,
49  PRORES_PROFILE_HQ,
50  PRORES_PROFILE_4444,
51  PRORES_PROFILE_4444XQ,
52 };
53 
54 enum {
55  QUANT_MAT_PROXY = 0,
56  QUANT_MAT_PROXY_CHROMA,
57  QUANT_MAT_LT,
58  QUANT_MAT_STANDARD,
59  QUANT_MAT_HQ,
60  QUANT_MAT_XQ_LUMA,
61  QUANT_MAT_DEFAULT,
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;
148  int min_quant;
149  int max_quant;
150  int br_tab[NUM_MB_LIMITS];
151  int quant;
152  int quant_chroma;
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 {
214  int prev_node;
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];
227  struct TrellisNode *nodes;
228 } ProresThreadData;
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];
238  const uint8_t *quant_mat;
239  const uint8_t *quant_chroma_mat;
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;
248  int mbs_per_slice;
249  int num_chroma_blocks, chroma_factor;
250  int slices_width;
251  int slices_per_picture;
252  int pictures_per_frame; // 1 for progressive, 2 for interlaced
253  int cur_picture_idx;
254  int num_planes;
255  int bits_per_mb;
256  int force_quant;
257  int alpha_bits;
258  int warn;
259 
260  char *vendor;
261  int quant_sel;
262 
263  int frame_size_upper_bound;
264 
265  int profile;
266  const struct prores_profile *profile_info;
267 
268  int *slice_q;
269 
270  ProresThreadData *tdata;
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 = 5, code, dc, prev_dc, delta, sign, new_sign;
412 
413  prev_dc = (blocks[0] - 0x4000) / scale;
414  encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
415  sign = 0;
416  blocks += 64;
417 
418  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
419  dc = (blocks[0] - 0x4000) / scale;
420  delta = dc - prev_dc;
421  new_sign = GET_SIGN(delta);
422  delta = (delta ^ sign) - sign;
423  code = MAKE_CODE(delta);
424  encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
425  codebook = FFMIN(code, 6);
426  sign = new_sign;
427  prev_dc = dc;
428  }
429 }
430 
431 static void encode_acs(PutBitContext *pb, int16_t *blocks,
432  int blocks_per_slice,
433  const uint8_t *scan, const int16_t *qmat)
434 {
435  int idx, i;
436  int prev_run = 4;
437  int prev_level = 2;
438  int run = 0, level;
439  int max_coeffs, abs_level;
440 
441  max_coeffs = blocks_per_slice << 6;
442 
443  for (i = 1; i < 64; i++) {
444  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
445  level = blocks[idx] / qmat[scan[i]];
446  if (level) {
447  abs_level = FFABS(level);
448  encode_vlc_codeword(pb, ff_prores_run_to_cb[prev_run], run);
449  encode_vlc_codeword(pb, ff_prores_level_to_cb[prev_level], abs_level - 1);
450  put_sbits(pb, 1, GET_SIGN(level));
451 
452  prev_run = FFMIN(run, 15);
453  prev_level = FFMIN(abs_level, 9);
454  run = 0;
455  } else {
456  run++;
457  }
458  }
459  }
460 }
461 
462 static void encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
463  const uint16_t *src, ptrdiff_t linesize,
464  int mbs_per_slice, int16_t *blocks,
465  int blocks_per_mb,
466  const int16_t *qmat)
467 {
468  int blocks_per_slice = mbs_per_slice * blocks_per_mb;
469 
470  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
471  encode_acs(pb, blocks, blocks_per_slice, ctx->scantable, qmat);
472 }
473 
474 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
475 {
476  const int dbits = (abits == 8) ? 4 : 7;
477  const int dsize = 1 << dbits - 1;
478  int diff = cur - prev;
479 
480  diff = av_mod_uintp2(diff, abits);
481  if (diff >= (1 << abits) - dsize)
482  diff -= 1 << abits;
483  if (diff < -dsize || diff > dsize || !diff) {
484  put_bits(pb, 1, 1);
485  put_bits(pb, abits, diff);
486  } else {
487  put_bits(pb, 1, 0);
488  put_bits(pb, dbits - 1, FFABS(diff) - 1);
489  put_bits(pb, 1, diff < 0);
490  }
491 }
492 
493 static void put_alpha_run(PutBitContext *pb, int run)
494 {
495  if (run) {
496  put_bits(pb, 1, 0);
497  if (run < 0x10)
498  put_bits(pb, 4, run);
499  else
500  put_bits(pb, 15, run);
501  } else {
502  put_bits(pb, 1, 1);
503  }
504 }
505 
506 // todo alpha quantisation for high quants
507 static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
508  int mbs_per_slice, uint16_t *blocks,
509  int quant)
510 {
511  const int abits = ctx->alpha_bits;
512  const int mask = (1 << abits) - 1;
513  const int num_coeffs = mbs_per_slice * 256;
514  int prev = mask, cur;
515  int idx = 0;
516  int run = 0;
517 
518  cur = blocks[idx++];
519  put_alpha_diff(pb, cur, prev, abits);
520  prev = cur;
521  do {
522  cur = blocks[idx++];
523  if (cur != prev) {
524  put_alpha_run (pb, run);
525  put_alpha_diff(pb, cur, prev, abits);
526  prev = cur;
527  run = 0;
528  } else {
529  run++;
530  }
531  } while (idx < num_coeffs);
532  put_alpha_run(pb, run);
533 }
534 
535 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
536  PutBitContext *pb,
537  int sizes[4], int x, int y, int quant,
538  int mbs_per_slice)
539 {
540  ProresContext *ctx = avctx->priv_data;
541  int i, xp, yp;
542  int total_size = 0;
543  const uint16_t *src;
544  int num_cblocks, pwidth, line_add;
545  ptrdiff_t linesize;
546  int is_chroma;
547  uint16_t *qmat;
548  uint16_t *qmat_chroma;
549 
550  if (ctx->pictures_per_frame == 1)
551  line_add = 0;
552  else
553  line_add = ctx->cur_picture_idx ^ !(pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
554 
555  if (ctx->force_quant) {
556  qmat = ctx->quants[0];
557  qmat_chroma = ctx->quants_chroma[0];
558  } else if (quant < MAX_STORED_Q) {
559  qmat = ctx->quants[quant];
560  qmat_chroma = ctx->quants_chroma[quant];
561  } else {
562  qmat = ctx->custom_q;
563  qmat_chroma = ctx->custom_chroma_q;
564  for (i = 0; i < 64; i++) {
565  qmat[i] = ctx->quant_mat[i] * quant;
566  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
567  }
568  }
569 
570  for (i = 0; i < ctx->num_planes; i++) {
571  is_chroma = (i == 1 || i == 2);
572  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
573  xp = x << 4;
574  yp = y << 4;
575  num_cblocks = 4;
576  pwidth = avctx->width;
577  } else {
578  xp = x << 3;
579  yp = y << 4;
580  num_cblocks = 2;
581  pwidth = avctx->width >> 1;
582  }
583 
584  linesize = pic->linesize[i] * ctx->pictures_per_frame;
585  src = (const uint16_t*)(pic->data[i] + yp * linesize +
586  line_add * pic->linesize[i]) + xp;
587 
588  if (i < 3) {
589  get_slice_data(ctx, src, linesize, xp, yp,
590  pwidth, avctx->height / ctx->pictures_per_frame,
591  ctx->blocks[0], ctx->emu_buf,
592  mbs_per_slice, num_cblocks, is_chroma);
593  if (!is_chroma) {/* luma quant */
594  encode_slice_plane(ctx, pb, src, linesize,
595  mbs_per_slice, ctx->blocks[0],
596  num_cblocks, qmat);
597  } else { /* chroma plane */
598  encode_slice_plane(ctx, pb, src, linesize,
599  mbs_per_slice, ctx->blocks[0],
600  num_cblocks, qmat_chroma);
601  }
602  } else {
603  get_alpha_data(ctx, src, linesize, xp, yp,
604  pwidth, avctx->height / ctx->pictures_per_frame,
605  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
606  encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
607  }
608  flush_put_bits(pb);
609  sizes[i] = put_bytes_output(pb) - total_size;
610  total_size = put_bytes_output(pb);
611  }
612  return total_size;
613 }
614 
615 static inline int estimate_vlc(unsigned codebook, int val)
616 {
617  unsigned int rice_order, exp_order, switch_bits, switch_val;
618  int exponent;
619 
620  /* number of prefix bits to switch between Rice and expGolomb */
621  switch_bits = (codebook & 3) + 1;
622  rice_order = codebook >> 5; /* rice code order */
623  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
624 
625  switch_val = switch_bits << rice_order;
626 
627  if (val >= switch_val) {
628  val -= switch_val - (1 << exp_order);
629  exponent = av_log2(val);
630 
631  return exponent * 2 - exp_order + switch_bits + 1;
632  } else {
633  return (val >> rice_order) + rice_order + 1;
634  }
635 }
636 
637 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
638  int scale)
639 {
640  int i;
641  int codebook = 5, code, dc, prev_dc, delta, sign, new_sign;
642  int bits;
643 
644  prev_dc = (blocks[0] - 0x4000) / scale;
645  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
646  sign = 0;
647  blocks += 64;
648  *error += FFABS(blocks[0] - 0x4000) % scale;
649 
650  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
651  dc = (blocks[0] - 0x4000) / scale;
652  *error += FFABS(blocks[0] - 0x4000) % scale;
653  delta = dc - prev_dc;
654  new_sign = GET_SIGN(delta);
655  delta = (delta ^ sign) - sign;
656  code = MAKE_CODE(delta);
657  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
658  codebook = FFMIN(code, 6);
659  sign = new_sign;
660  prev_dc = dc;
661  }
662 
663  return bits;
664 }
665 
666 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
667  const uint8_t *scan, const int16_t *qmat)
668 {
669  int idx, i;
670  int prev_run = 4;
671  int prev_level = 2;
672  int run, level;
673  int max_coeffs, abs_level;
674  int bits = 0;
675 
676  max_coeffs = blocks_per_slice << 6;
677  run = 0;
678 
679  for (i = 1; i < 64; i++) {
680  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
681  level = blocks[idx] / qmat[scan[i]];
682  *error += FFABS(blocks[idx]) % qmat[scan[i]];
683  if (level) {
684  abs_level = FFABS(level);
685  bits += estimate_vlc(ff_prores_run_to_cb[prev_run], run);
686  bits += estimate_vlc(ff_prores_level_to_cb[prev_level],
687  abs_level - 1) + 1;
688 
689  prev_run = FFMIN(run, 15);
690  prev_level = FFMIN(abs_level, 9);
691  run = 0;
692  } else {
693  run++;
694  }
695  }
696  }
697 
698  return bits;
699 }
700 
701 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
702  const uint16_t *src, ptrdiff_t linesize,
703  int mbs_per_slice,
704  int blocks_per_mb,
705  const int16_t *qmat, ProresThreadData *td)
706 {
707  int blocks_per_slice;
708  int bits;
709 
710  blocks_per_slice = mbs_per_slice * blocks_per_mb;
711 
712  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
713  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice, ctx->scantable, qmat);
714 
715  return FFALIGN(bits, 8);
716 }
717 
718 static int est_alpha_diff(int cur, int prev, int abits)
719 {
720  const int dbits = (abits == 8) ? 4 : 7;
721  const int dsize = 1 << dbits - 1;
722  int diff = cur - prev;
723 
724  diff = av_mod_uintp2(diff, abits);
725  if (diff >= (1 << abits) - dsize)
726  diff -= 1 << abits;
727  if (diff < -dsize || diff > dsize || !diff)
728  return abits + 1;
729  else
730  return dbits + 1;
731 }
732 
733 static int estimate_alpha_plane(ProresContext *ctx,
734  const uint16_t *src, ptrdiff_t linesize,
735  int mbs_per_slice, int16_t *blocks)
736 {
737  const int abits = ctx->alpha_bits;
738  const int mask = (1 << abits) - 1;
739  const int num_coeffs = mbs_per_slice * 256;
740  int prev = mask, cur;
741  int idx = 0;
742  int run = 0;
743  int bits;
744 
745  cur = blocks[idx++];
746  bits = est_alpha_diff(cur, prev, abits);
747  prev = cur;
748  do {
749  cur = blocks[idx++];
750  if (cur != prev) {
751  if (!run)
752  bits++;
753  else if (run < 0x10)
754  bits += 4;
755  else
756  bits += 15;
757  bits += est_alpha_diff(cur, prev, abits);
758  prev = cur;
759  run = 0;
760  } else {
761  run++;
762  }
763  } while (idx < num_coeffs);
764 
765  if (run) {
766  if (run < 0x10)
767  bits += 4;
768  else
769  bits += 15;
770  }
771 
772  return bits;
773 }
774 
775 static int find_slice_quant(AVCodecContext *avctx,
776  int trellis_node, int x, int y, int mbs_per_slice,
777  ProresThreadData *td)
778 {
779  ProresContext *ctx = avctx->priv_data;
780  int i, q, pq, xp, yp;
781  const uint16_t *src;
782  int num_cblocks[MAX_PLANES], pwidth;
783  int is_chroma[MAX_PLANES];
784  const int min_quant = ctx->profile_info->min_quant;
785  const int max_quant = ctx->profile_info->max_quant;
786  int error, bits, bits_limit;
787  int mbs, prev, cur, new_score;
788  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
789  int overquant;
790  uint16_t *qmat;
791  uint16_t *qmat_chroma;
792  int linesize[4], line_add;
793  int alpha_bits = 0;
794 
795  if (ctx->pictures_per_frame == 1)
796  line_add = 0;
797  else
798  line_add = ctx->cur_picture_idx ^ !(ctx->pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
799  mbs = x + mbs_per_slice;
800 
801  for (i = 0; i < ctx->num_planes; i++) {
802  is_chroma[i] = (i == 1 || i == 2);
803  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
804  xp = x << 4;
805  yp = y << 4;
806  num_cblocks[i] = 4;
807  pwidth = avctx->width;
808  } else {
809  xp = x << 3;
810  yp = y << 4;
811  num_cblocks[i] = 2;
812  pwidth = avctx->width >> 1;
813  }
814 
815  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
816  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
817  line_add * ctx->pic->linesize[i]) + xp;
818 
819  if (i < 3) {
820  get_slice_data(ctx, src, linesize[i], xp, yp,
821  pwidth, avctx->height / ctx->pictures_per_frame,
822  td->blocks[i], td->emu_buf,
823  mbs_per_slice, num_cblocks[i], is_chroma[i]);
824  } else {
825  get_alpha_data(ctx, src, linesize[i], xp, yp,
826  pwidth, avctx->height / ctx->pictures_per_frame,
827  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
828  }
829  }
830 
831  for (q = min_quant; q < max_quant + 2; q++) {
832  td->nodes[trellis_node + q].prev_node = -1;
833  td->nodes[trellis_node + q].quant = q;
834  }
835 
836  if (ctx->alpha_bits)
837  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
838  mbs_per_slice, td->blocks[3]);
839  // todo: maybe perform coarser quantising to fit into frame size when needed
840  for (q = min_quant; q <= max_quant; q++) {
841  bits = alpha_bits;
842  error = 0;
843  bits += estimate_slice_plane(ctx, &error, 0,
844  src, linesize[0],
845  mbs_per_slice,
846  num_cblocks[0],
847  ctx->quants[q], td); /* estimate luma plane */
848  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
849  bits += estimate_slice_plane(ctx, &error, i,
850  src, linesize[i],
851  mbs_per_slice,
852  num_cblocks[i],
853  ctx->quants_chroma[q], td);
854  }
855  if (bits > 65000 * 8)
856  error = SCORE_LIMIT;
857 
858  slice_bits[q] = bits;
859  slice_score[q] = error;
860  }
861  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
862  slice_bits[max_quant + 1] = slice_bits[max_quant];
863  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
864  overquant = max_quant;
865  } else {
866  for (q = max_quant + 1; q < 128; q++) {
867  bits = alpha_bits;
868  error = 0;
869  if (q < MAX_STORED_Q) {
870  qmat = ctx->quants[q];
871  qmat_chroma = ctx->quants_chroma[q];
872  } else {
873  qmat = td->custom_q;
874  qmat_chroma = td->custom_chroma_q;
875  for (i = 0; i < 64; i++) {
876  qmat[i] = ctx->quant_mat[i] * q;
877  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
878  }
879  }
880  bits += estimate_slice_plane(ctx, &error, 0,
881  src, linesize[0],
882  mbs_per_slice,
883  num_cblocks[0],
884  qmat, td);/* estimate luma plane */
885  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
886  bits += estimate_slice_plane(ctx, &error, i,
887  src, linesize[i],
888  mbs_per_slice,
889  num_cblocks[i],
890  qmat_chroma, td);
891  }
892  if (bits <= ctx->bits_per_mb * mbs_per_slice)
893  break;
894  }
895 
896  slice_bits[max_quant + 1] = bits;
897  slice_score[max_quant + 1] = error;
898  overquant = q;
899  }
900  td->nodes[trellis_node + max_quant + 1].quant = overquant;
901 
902  bits_limit = mbs * ctx->bits_per_mb;
903  for (pq = min_quant; pq < max_quant + 2; pq++) {
904  prev = trellis_node - TRELLIS_WIDTH + pq;
905 
906  for (q = min_quant; q < max_quant + 2; q++) {
907  cur = trellis_node + q;
908 
909  bits = td->nodes[prev].bits + slice_bits[q];
910  error = slice_score[q];
911  if (bits > bits_limit)
912  error = SCORE_LIMIT;
913 
914  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
915  new_score = td->nodes[prev].score + error;
916  else
917  new_score = SCORE_LIMIT;
918  if (td->nodes[cur].prev_node == -1 ||
919  td->nodes[cur].score >= new_score) {
920 
921  td->nodes[cur].bits = bits;
922  td->nodes[cur].score = new_score;
923  td->nodes[cur].prev_node = prev;
924  }
925  }
926  }
927 
928  error = td->nodes[trellis_node + min_quant].score;
929  pq = trellis_node + min_quant;
930  for (q = min_quant + 1; q < max_quant + 2; q++) {
931  if (td->nodes[trellis_node + q].score <= error) {
932  error = td->nodes[trellis_node + q].score;
933  pq = trellis_node + q;
934  }
935  }
936 
937  return pq;
938 }
939 
940 static int find_quant_thread(AVCodecContext *avctx, void *arg,
941  int jobnr, int threadnr)
942 {
943  ProresContext *ctx = avctx->priv_data;
944  ProresThreadData *td = ctx->tdata + threadnr;
945  int mbs_per_slice = ctx->mbs_per_slice;
946  int x, y = jobnr, mb, q = 0;
947 
948  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
949  while (ctx->mb_width - x < mbs_per_slice)
950  mbs_per_slice >>= 1;
951  q = find_slice_quant(avctx,
952  (mb + 1) * TRELLIS_WIDTH, x, y,
953  mbs_per_slice, td);
954  }
955 
956  for (x = ctx->slices_width - 1; x >= 0; x--) {
957  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
958  q = td->nodes[q].prev_node;
959  }
960 
961  return 0;
962 }
963 
964 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
965  const AVFrame *pic, int *got_packet)
966 {
967  ProresContext *ctx = avctx->priv_data;
968  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
969  uint8_t *picture_size_pos;
970  PutBitContext pb;
971  int x, y, i, mb, q = 0;
972  int sizes[4] = { 0 };
973  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
974  int frame_size, picture_size, slice_size;
975  int pkt_size, ret;
976  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
977  uint8_t frame_flags;
978 
979  ctx->pic = pic;
980  pkt_size = ctx->frame_size_upper_bound;
981 
982  if ((ret = ff_alloc_packet(avctx, pkt, pkt_size + FF_INPUT_BUFFER_MIN_SIZE)) < 0)
983  return ret;
984 
985  orig_buf = pkt->data;
986 
987  // frame atom
988  orig_buf += 4; // frame size
989  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
990  buf = orig_buf;
991 
992  // frame header
993  tmp = buf;
994  buf += 2; // frame header size will be stored here
995  bytestream_put_be16 (&buf, ctx->chroma_factor != CFACTOR_Y422 || ctx->alpha_bits ? 1 : 0);
996  bytestream_put_buffer(&buf, ctx->vendor, 4);
997  bytestream_put_be16 (&buf, avctx->width);
998  bytestream_put_be16 (&buf, avctx->height);
999 
1000  frame_flags = ctx->chroma_factor << 6;
1001  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1002  frame_flags |= (pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 0x04 : 0x08;
1003  bytestream_put_byte (&buf, frame_flags);
1004 
1005  bytestream_put_byte (&buf, 0); // reserved
1006  bytestream_put_byte (&buf, pic->color_primaries);
1007  bytestream_put_byte (&buf, pic->color_trc);
1008  bytestream_put_byte (&buf, pic->colorspace);
1009  bytestream_put_byte (&buf, ctx->alpha_bits >> 3);
1010  bytestream_put_byte (&buf, 0); // reserved
1011  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1012  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1013  bytestream_put_buffer(&buf, ctx->quant_mat, 64); // luma quantisation matrix
1014  bytestream_put_buffer(&buf, ctx->quant_chroma_mat, 64); // chroma quantisation matrix
1015  } else {
1016  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1017  }
1018  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1019 
1020  for (ctx->cur_picture_idx = 0;
1021  ctx->cur_picture_idx < ctx->pictures_per_frame;
1022  ctx->cur_picture_idx++) {
1023  // picture header
1024  picture_size_pos = buf + 1;
1025  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1026  buf += 4; // picture data size will be stored here
1027  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1028  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1029 
1030  // seek table - will be filled during slice encoding
1031  slice_sizes = buf;
1032  buf += ctx->slices_per_picture * 2;
1033 
1034  // slices
1035  if (!ctx->force_quant) {
1036  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1037  ctx->mb_height);
1038  if (ret)
1039  return ret;
1040  }
1041 
1042  for (y = 0; y < ctx->mb_height; y++) {
1043  int mbs_per_slice = ctx->mbs_per_slice;
1044  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1045  q = ctx->force_quant ? ctx->force_quant
1046  : ctx->slice_q[mb + y * ctx->slices_width];
1047 
1048  while (ctx->mb_width - x < mbs_per_slice)
1049  mbs_per_slice >>= 1;
1050 
1051  bytestream_put_byte(&buf, slice_hdr_size << 3);
1052  slice_hdr = buf;
1053  buf += slice_hdr_size - 1;
1054  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1055  uint8_t *start = pkt->data;
1056  // Recompute new size according to max_slice_size
1057  // and deduce delta
1058  int delta = 200 + (ctx->pictures_per_frame *
1059  ctx->slices_per_picture + 1) *
1060  max_slice_size - pkt_size;
1061 
1062  delta = FFMAX(delta, 2 * max_slice_size);
1063  ctx->frame_size_upper_bound += delta;
1064 
1065  if (!ctx->warn) {
1066  avpriv_request_sample(avctx,
1067  "Packet too small: is %i,"
1068  " needs %i (slice: %i). "
1069  "Correct allocation",
1070  pkt_size, delta, max_slice_size);
1071  ctx->warn = 1;
1072  }
1073 
1074  ret = av_grow_packet(pkt, delta);
1075  if (ret < 0)
1076  return ret;
1077 
1078  pkt_size += delta;
1079  // restore pointers
1080  orig_buf = pkt->data + (orig_buf - start);
1081  buf = pkt->data + (buf - start);
1082  picture_size_pos = pkt->data + (picture_size_pos - start);
1083  slice_sizes = pkt->data + (slice_sizes - start);
1084  slice_hdr = pkt->data + (slice_hdr - start);
1085  tmp = pkt->data + (tmp - start);
1086  }
1087  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1088  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1089  mbs_per_slice);
1090  if (ret < 0)
1091  return ret;
1092 
1093  bytestream_put_byte(&slice_hdr, q);
1094  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1095  for (i = 0; i < ctx->num_planes - 1; i++) {
1096  bytestream_put_be16(&slice_hdr, sizes[i]);
1097  slice_size += sizes[i];
1098  }
1099  bytestream_put_be16(&slice_sizes, slice_size);
1100  buf += slice_size - slice_hdr_size;
1101  if (max_slice_size < slice_size)
1102  max_slice_size = slice_size;
1103  }
1104  }
1105 
1106  picture_size = buf - (picture_size_pos - 1);
1107  bytestream_put_be32(&picture_size_pos, picture_size);
1108  }
1109 
1110  orig_buf -= 8;
1111  frame_size = buf - orig_buf;
1112  bytestream_put_be32(&orig_buf, frame_size);
1113 
1114  pkt->size = frame_size;
1115  *got_packet = 1;
1116 
1117  return 0;
1118 }
1119 
1120 static av_cold int encode_close(AVCodecContext *avctx)
1121 {
1122  ProresContext *ctx = avctx->priv_data;
1123  int i;
1124 
1125  if (ctx->tdata) {
1126  for (i = 0; i < avctx->thread_count; i++)
1127  av_freep(&ctx->tdata[i].nodes);
1128  }
1129  av_freep(&ctx->tdata);
1130  av_freep(&ctx->slice_q);
1131 
1132  return 0;
1133 }
1134 
1135 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1136  ptrdiff_t linesize, int16_t *block)
1137 {
1138  int x, y;
1139  const uint16_t *tsrc = src;
1140 
1141  for (y = 0; y < 8; y++) {
1142  for (x = 0; x < 8; x++)
1143  block[y * 8 + x] = tsrc[x];
1144  tsrc += linesize >> 1;
1145  }
1146  fdsp->fdct(block);
1147 }
1148 
1149 static av_cold int encode_init(AVCodecContext *avctx)
1150 {
1151  ProresContext *ctx = avctx->priv_data;
1152  int mps;
1153  int i, j;
1154  int min_quant, max_quant;
1155  int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1156 
1157  avctx->bits_per_raw_sample = 10;
1158 
1159  ctx->fdct = prores_fdct;
1160  ctx->scantable = interlaced ? ff_prores_interlaced_scan
1161  : ff_prores_progressive_scan;
1162  ff_fdctdsp_init(&ctx->fdsp, avctx);
1163 
1164  mps = ctx->mbs_per_slice;
1165  if (mps & (mps - 1)) {
1166  av_log(avctx, AV_LOG_ERROR,
1167  "there should be an integer power of two MBs per slice\n");
1168  return AVERROR(EINVAL);
1169  }
1170  if (ctx->profile == PRORES_PROFILE_AUTO) {
1171  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1172  ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1173  !(desc->log2_chroma_w + desc->log2_chroma_h))
1174  ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;
1175  av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1176  "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1177  ? "4:4:4:4 profile because of the used input colorspace"
1178  : "HQ profile to keep best quality");
1179  }
1180  if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1181  if (ctx->profile != PRORES_PROFILE_4444 &&
1182  ctx->profile != PRORES_PROFILE_4444XQ) {
1183  // force alpha and warn
1184  av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1185  "encode alpha. Override with -profile if needed.\n");
1186  ctx->alpha_bits = 0;
1187  }
1188  if (ctx->alpha_bits & 7) {
1189  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1190  return AVERROR(EINVAL);
1191  }
1192  avctx->bits_per_coded_sample = 32;
1193  } else {
1194  ctx->alpha_bits = 0;
1195  }
1196 
1197  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1198  ? CFACTOR_Y422
1199  : CFACTOR_Y444;
1200  ctx->profile_info = prores_profile_info + ctx->profile;
1201  ctx->num_planes = 3 + !!ctx->alpha_bits;
1202 
1203  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1204 
1205  if (interlaced)
1206  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1207  else
1208  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1209 
1210  ctx->slices_width = ctx->mb_width / mps;
1211  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1212  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1213  ctx->pictures_per_frame = 1 + interlaced;
1214 
1215  if (ctx->quant_sel == -1) {
1216  ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1217  ctx->quant_chroma_mat = prores_quant_matrices[ctx->profile_info->quant_chroma];
1218  } else {
1219  ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1220  ctx->quant_chroma_mat = prores_quant_matrices[ctx->quant_sel];
1221  }
1222 
1223  if (strlen(ctx->vendor) != 4) {
1224  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1225  return AVERROR_INVALIDDATA;
1226  }
1227 
1228  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1229  if (!ctx->force_quant) {
1230  if (!ctx->bits_per_mb) {
1231  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1232  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1233  ctx->pictures_per_frame)
1234  break;
1235  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1236  if (ctx->alpha_bits)
1237  ctx->bits_per_mb *= 20;
1238  } else if (ctx->bits_per_mb < 128) {
1239  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1240  return AVERROR_INVALIDDATA;
1241  }
1242 
1243  min_quant = ctx->profile_info->min_quant;
1244  max_quant = ctx->profile_info->max_quant;
1245  for (i = min_quant; i < MAX_STORED_Q; i++) {
1246  for (j = 0; j < 64; j++) {
1247  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1248  ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1249  }
1250  }
1251 
1252  ctx->slice_q = av_malloc_array(ctx->slices_per_picture, sizeof(*ctx->slice_q));
1253  if (!ctx->slice_q)
1254  return AVERROR(ENOMEM);
1255 
1256  ctx->tdata = av_calloc(avctx->thread_count, sizeof(*ctx->tdata));
1257  if (!ctx->tdata)
1258  return AVERROR(ENOMEM);
1259 
1260  for (j = 0; j < avctx->thread_count; j++) {
1261  ctx->tdata[j].nodes = av_malloc_array(ctx->slices_width + 1,
1262  TRELLIS_WIDTH
1263  * sizeof(*ctx->tdata->nodes));
1264  if (!ctx->tdata[j].nodes)
1265  return AVERROR(ENOMEM);
1266  for (i = min_quant; i < max_quant + 2; i++) {
1267  ctx->tdata[j].nodes[i].prev_node = -1;
1268  ctx->tdata[j].nodes[i].bits = 0;
1269  ctx->tdata[j].nodes[i].score = 0;
1270  }
1271  }
1272  } else {
1273  int ls = 0;
1274  int ls_chroma = 0;
1275 
1276  if (ctx->force_quant > 64) {
1277  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1278  return AVERROR_INVALIDDATA;
1279  }
1280 
1281  for (j = 0; j < 64; j++) {
1282  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1283  ctx->quants_chroma[0][j] = ctx->quant_chroma_mat[j] * ctx->force_quant;
1284  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1285  ls_chroma += av_log2((1 << 11) / ctx->quants_chroma[0][j]) * 2 + 1;
1286  }
1287 
1288  ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1289  if (ctx->chroma_factor == CFACTOR_Y444)
1290  ctx->bits_per_mb += ls_chroma * 4;
1291  }
1292 
1293  ctx->frame_size_upper_bound = (ctx->pictures_per_frame *
1294  ctx->slices_per_picture + 1) *
1295  (2 + 2 * ctx->num_planes +
1296  (mps * ctx->bits_per_mb) / 8)
1297  + 200;
1298 
1299  if (ctx->alpha_bits) {
1300  // The alpha plane is run-coded and might exceed the bit budget.
1301  ctx->frame_size_upper_bound += (ctx->pictures_per_frame *
1302  ctx->slices_per_picture + 1) *
1303  /* num pixels per slice */ (ctx->mbs_per_slice * 256 *
1304  /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);
1305  }
1306 
1307  avctx->codec_tag = ctx->profile_info->tag;
1308  avctx->profile = ctx->profile;
1309 
1310  av_log(avctx, AV_LOG_DEBUG,
1311  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1312  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1313  interlaced ? "yes" : "no", ctx->bits_per_mb);
1314  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1315  ctx->frame_size_upper_bound);
1316 
1317  return 0;
1318 }
1319 
1320 #define OFFSET(x) offsetof(ProresContext, x)
1321 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1322 
1323 static const AVOption options[] = {
1324  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1325  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1326  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1327  { .i64 = PRORES_PROFILE_AUTO },
1328  PRORES_PROFILE_AUTO, PRORES_PROFILE_4444XQ, VE, .unit = "profile" },
1329  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1330  0, 0, VE, .unit = "profile" },
1331  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1332  0, 0, VE, .unit = "profile" },
1333  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1334  0, 0, VE, .unit = "profile" },
1335  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1336  0, 0, VE, .unit = "profile" },
1337  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1338  0, 0, VE, .unit = "profile" },
1339  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1340  0, 0, VE, .unit = "profile" },
1341  { "4444xq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
1342  0, 0, VE, .unit = "profile" },
1343  { "vendor", "vendor ID", OFFSET(vendor),
1344  AV_OPT_TYPE_STRING, { .str = "Lavc" }, 0, 0, VE },
1345  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1346  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1347  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1348  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, .unit = "quant_mat" },
1349  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1350  0, 0, VE, .unit = "quant_mat" },
1351  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1352  0, 0, VE, .unit = "quant_mat" },
1353  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1354  0, 0, VE, .unit = "quant_mat" },
1355  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1356  0, 0, VE, .unit = "quant_mat" },
1357  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1358  0, 0, VE, .unit = "quant_mat" },
1359  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1360  0, 0, VE, .unit = "quant_mat" },
1361  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1362  { .i64 = 16 }, 0, 16, VE },
1363  { NULL }
1364 };
1365 
1366 static const AVClass proresenc_class = {
1367  .class_name = "ProRes encoder",
1368  .item_name = av_default_item_name,
1369  .option = options,
1370  .version = LIBAVUTIL_VERSION_INT,
1371 };
1372 
1373 const FFCodec ff_prores_ks_encoder = {
1374  .p.name = "prores_ks",
1375  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
1376  .p.type = AVMEDIA_TYPE_VIDEO,
1377  .p.id = AV_CODEC_ID_PRORES,
1378  .priv_data_size = sizeof(ProresContext),
1379  .init = encode_init,
1380  .close = encode_close,
1381  FF_CODEC_ENCODE_CB(encode_frame),
1382  .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |
1383  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1384  .p.pix_fmts = (const enum AVPixelFormat[]) {
1385  AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1386  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1387  },
1388  .p.priv_class = &proresenc_class,
1389  .p.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
1390  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1391 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
ProresContext::force_quant
int force_quant
Definition: proresenc_kostya.c:256
ProresContext::quant_chroma_mat
const uint8_t * quant_chroma_mat
Definition: proresenc_kostya.c:239
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:657
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
td
#define td
Definition: regdef.h:70
estimate_dcs
static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice, int scale)
Definition: proresenc_kostya.c:637
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
encode_dcs
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
Definition: proresenc_kostya.c:407
ProresContext::fdsp
FDCTDSPContext fdsp
Definition: proresenc_anatoliy.c:184
mem_internal.h
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
GET_SIGN
#define GET_SIGN(x)
Definition: proresenc_kostya.c:404
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: proresenc_kostya.c:964
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:173
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: packet.c:121
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:655
ProresContext::quants_chroma
int16_t quants_chroma[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:235
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:126
ProresContext::vendor
char * vendor
Definition: proresenc_anatoliy.c:198
estimate_slice_plane
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, const int16_t *qmat, ProresThreadData *td)
Definition: proresenc_kostya.c:701
prores_profile::tag
uint32_t tag
Definition: proresenc_kostya.c:147
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:664
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
encode_alpha_plane
static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, int mbs_per_slice, uint16_t *blocks, int quant)
Definition: proresenc_kostya.c:507
AVPacket::data
uint8_t * data
Definition: packet.h:524
ff_prores_ks_encoder
const FFCodec ff_prores_ks_encoder
Definition: proresenc_kostya.c:1373
PRORES_PROFILE_HQ
@ PRORES_PROFILE_HQ
Definition: proresenc_kostya.c:49
AVOption
AVOption.
Definition: opt.h:346
ProresContext::slices_width
int slices_width
Definition: proresenc_kostya.c:250
encode.h
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdata.h:36
ProresContext::alpha_bits
int alpha_bits
Definition: proresenc_kostya.c:257
ProresContext
Definition: proresdec.h:43
FFCodec
Definition: codec_internal.h:126
QUANT_MAT_STANDARD
@ QUANT_MAT_STANDARD
Definition: proresenc_kostya.c:58
ProresContext::num_planes
int num_planes
Definition: proresenc_kostya.c:254
QUANT_MAT_PROXY
@ QUANT_MAT_PROXY
Definition: proresenc_kostya.c:55
ProresContext::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:233
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ProresThreadData::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:224
av_popcount
#define av_popcount
Definition: common.h:153
SCORE_LIMIT
#define SCORE_LIMIT
Definition: proresenc_kostya.c:211
PRORES_PROFILE_4444
@ PRORES_PROFILE_4444
Definition: proresenc_kostya.c:50
put_alpha_run
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc_kostya.c:493
ff_prores_progressive_scan
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
ff_prores_level_to_cb
const uint8_t ff_prores_level_to_cb[10]
Definition: proresdata.c:52
prores_quant_matrices
static const uint8_t prores_quant_matrices[][64]
Definition: proresenc_kostya.c:64
FF_INPUT_BUFFER_MIN_SIZE
#define FF_INPUT_BUFFER_MIN_SIZE
Used by some encoders as upper bound for the length of headers.
Definition: encode.h:33
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
PRORES_PROFILE_STANDARD
@ PRORES_PROFILE_STANDARD
Definition: proresenc_kostya.c:48
prores_fdct
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
Definition: proresenc_kostya.c:1135
ProresContext::profile_info
const struct prores_profile * profile_info
Definition: proresenc_kostya.c:266
FDCTDSPContext
Definition: fdctdsp.h:28
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
PRORES_PROFILE_LT
@ PRORES_PROFILE_LT
Definition: proresenc_kostya.c:47
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
ProresContext::slice_q
int * slice_q
Definition: proresenc_kostya.c:268
ProresContext::mbs_per_slice
int mbs_per_slice
Definition: proresenc_kostya.c:248
TrellisNode
Definition: adpcmenc.c:61
prores_mb_limits
static const int prores_mb_limits[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:138
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
ProresContext::custom_chroma_q
int16_t custom_chroma_q[64]
Definition: proresenc_kostya.c:237
val
static double val(void *priv, double ch)
Definition: aeval.c:78
put_alpha_diff
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
Definition: proresenc_kostya.c:474
CFACTOR_Y422
#define CFACTOR_Y422
Definition: proresenc_kostya.c:37
estimate_alpha_plane
static int estimate_alpha_plane(ProresContext *ctx, const uint16_t *src, ptrdiff_t linesize, int mbs_per_slice, int16_t *blocks)
Definition: proresenc_kostya.c:733
QUANT_MAT_LT
@ QUANT_MAT_LT
Definition: proresenc_kostya.c:57
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
ProresThreadData::nodes
struct TrellisNode * nodes
Definition: proresenc_kostya.c:227
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:330
encode_slice_plane
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, const int16_t *qmat)
Definition: proresenc_kostya.c:462
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
prores_profile::max_quant
int max_quant
Definition: proresenc_kostya.c:149
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_fdctdsp_init
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:25
prores_profile_info
static const struct prores_profile prores_profile_info[6]
mask
static const uint16_t mask[17]
Definition: lzw.c:38
ProresThreadData::custom_chroma_q
int16_t custom_chroma_q[64]
Definition: proresenc_kostya.c:226
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
frame_size
int frame_size
Definition: mxfenc.c:2423
ProresThreadData::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:225
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
bits
uint8_t bits
Definition: vp3data.h:128
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ProresContext::bits_per_mb
int bits_per_mb
Definition: proresenc_kostya.c:255
ProresContext::quants
int16_t quants[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:234
ProresContext::profile
int profile
Definition: proresenc_kostya.c:265
TrellisNode::prev_node
int prev_node
Definition: proresenc_kostya.c:214
prores_profile::min_quant
int min_quant
Definition: proresenc_kostya.c:148
prores_profile::full_name
const char * full_name
Definition: proresenc_kostya.c:146
TrellisNode::quant
int quant
Definition: proresenc_kostya.c:215
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
find_quant_thread
static int find_quant_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresenc_kostya.c:940
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
ProresContext::mb_width
int mb_width
Definition: proresenc_kostya.c:247
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
ProresContext::pictures_per_frame
int pictures_per_frame
Definition: proresenc_kostya.c:252
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
MAX_MBS_PER_SLICE
#define MAX_MBS_PER_SLICE
Definition: proresenc_kostya.c:40
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
QUANT_MAT_PROXY_CHROMA
@ QUANT_MAT_PROXY_CHROMA
Definition: proresenc_kostya.c:56
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_prores_run_to_cb
const uint8_t ff_prores_run_to_cb[16]
Definition: proresdata.c:49
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:59
ProresContext::pic
const AVFrame * pic
Definition: proresenc_kostya.c:246
MAX_STORED_Q
#define MAX_STORED_Q
Definition: proresenc_kostya.c:220
run
uint8_t run
Definition: svq3.c:204
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1149
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
find_slice_quant
static int find_slice_quant(AVCodecContext *avctx, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
Definition: proresenc_kostya.c:775
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
ProresContext::tdata
ProresThreadData * tdata
Definition: proresenc_kostya.c:270
ProresContext::quant_sel
int quant_sel
Definition: proresenc_kostya.c:261
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
ProresContext::blocks
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
Definition: proresenc_kostya.c:232
prores_profile::br_tab
int br_tab[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:150
CFACTOR_Y444
#define CFACTOR_Y444
Definition: proresenc_kostya.c:38
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
ProresContext::chroma_factor
int chroma_factor
Definition: proresenc_kostya.c:249
AVPacket::size
int size
Definition: packet.h:525
dc
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ProresContext::scantable
const uint8_t * scantable
Definition: proresenc_anatoliy.c:192
ProresContext::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:236
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
QUANT_MAT_DEFAULT
@ QUANT_MAT_DEFAULT
Definition: proresenc_kostya.c:61
TrellisNode::bits
int bits
Definition: proresenc_kostya.c:216
proresdata.h
MAKE_CODE
#define MAKE_CODE(x)
Definition: proresenc_kostya.c:405
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
estimate_acs
static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice, const uint8_t *scan, const int16_t *qmat)
Definition: proresenc_kostya.c:666
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:518
ff_prores_dc_codebook
const uint8_t ff_prores_dc_codebook[7]
Definition: proresdata.c:47
mb
#define mb
Definition: vf_colormatrix.c:99
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
OFFSET
#define OFFSET(x)
Definition: proresenc_kostya.c:1320
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1567
options
static const AVOption options[]
Definition: proresenc_kostya.c:1323
interlaced
uint8_t interlaced
Definition: mxfenc.c:2264
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
QUANT_MAT_XQ_LUMA
@ QUANT_MAT_XQ_LUMA
Definition: proresenc_kostya.c:60
get_alpha_data
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)
Definition: proresenc_kostya.c:344
prores_profile
Definition: proresenc_kostya.c:145
TRELLIS_WIDTH
#define TRELLIS_WIDTH
Definition: proresenc_kostya.c:210
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
MAX_PLANES
#define MAX_PLANES
Definition: proresenc_kostya.c:42
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
get_slice_data
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)
Definition: proresenc_kostya.c:273
ProresContext::frame_size_upper_bound
int frame_size_upper_bound
Definition: proresenc_kostya.c:263
ProresThreadData::blocks
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
Definition: proresenc_kostya.c:223
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
delta
float delta
Definition: vorbis_enc_data.h:430
ProresContext::num_chroma_blocks
int num_chroma_blocks
Definition: proresenc_kostya.c:249
encode_acs
static void encode_acs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, const uint8_t *scan, const int16_t *qmat)
Definition: proresenc_kostya.c:431
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
fdctdsp.h
est_alpha_diff
static int est_alpha_diff(int cur, int prev, int abits)
Definition: proresenc_kostya.c:718
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
PRORES_PROFILE_PROXY
@ PRORES_PROFILE_PROXY
Definition: proresenc_kostya.c:46
profile
int profile
Definition: mxfenc.c:2227
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
proresenc_class
static const AVClass proresenc_class
Definition: proresenc_kostya.c:1366
ret
ret
Definition: filter_design.txt:187
QUANT_MAT_HQ
@ QUANT_MAT_HQ
Definition: proresenc_kostya.c:59
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
prores_profile::quant
int quant
Definition: proresenc_kostya.c:151
PRORES_PROFILE_4444XQ
@ PRORES_PROFILE_4444XQ
Definition: proresenc_kostya.c:51
ProresContext::quant_mat
const uint8_t * quant_mat
Definition: proresenc_kostya.c:238
prores_profile::quant_chroma
int quant_chroma
Definition: proresenc_kostya.c:152
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ProresContext::slices_per_picture
int slices_per_picture
Definition: proresenc_kostya.c:251
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
TrellisNode::score
int score
Definition: proresenc_kostya.c:217
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FRAME_ID
#define FRAME_ID
Definition: proresdata.h:28
NUM_MB_LIMITS
#define NUM_MB_LIMITS
Definition: proresenc_kostya.c:137
FDCTDSPContext::fdct
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:29
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
estimate_vlc
static int estimate_vlc(unsigned codebook, int val)
Definition: proresenc_kostya.c:615
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
encode_slice
static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice)
Definition: proresenc_kostya.c:535
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
encode_vlc_codeword
static void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Write an unsigned rice/exp golomb codeword.
Definition: proresenc_kostya.c:375
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
VE
#define VE
Definition: proresenc_kostya.c:1321
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
ProresThreadData
Definition: proresenc_kostya.c:222
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ProresContext::fdct
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
Definition: proresenc_kostya.c:242
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ProresContext::cur_picture_idx
int cur_picture_idx
Definition: proresenc_kostya.c:253
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
put_bits.h
ProresContext::warn
int warn
Definition: proresenc_kostya.c:258
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
AVCodecContext::execute2
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:1631
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1120
PRORES_PROFILE_AUTO
@ PRORES_PROFILE_AUTO
Definition: proresenc_kostya.c:45
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
ProresContext::mb_height
unsigned mb_height
height of the current picture in mb
Definition: proresdec.h:53
Generated on Fri Apr 19 2024 19:22:03 for FFmpeg by   doxygen 1.8.17