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