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_internal.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixdesc.h"
27 #include "avcodec.h"
28 #include "codec_internal.h"
29 #include "encode.h"
30 #include "fdctdsp.h"
31 #include "put_bits.h"
32 #include "profiles.h"
33 #include "bytestream.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  uint16_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 = 5, 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  blocks += 64;
416 
417  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
418  dc = (blocks[0] - 0x4000) / scale;
419  delta = dc - prev_dc;
420  new_sign = GET_SIGN(delta);
421  delta = (delta ^ sign) - sign;
422  code = MAKE_CODE(delta);
423  encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
424  codebook = FFMIN(code, 6);
425  sign = new_sign;
426  prev_dc = dc;
427  }
428 }
429 
430 static void encode_acs(PutBitContext *pb, int16_t *blocks,
431  int blocks_per_slice,
432  const uint8_t *scan, const int16_t *qmat)
433 {
434  int idx, i;
435  int prev_run = 4;
436  int prev_level = 2;
437  int run = 0, level;
438  int max_coeffs, abs_level;
439 
440  max_coeffs = blocks_per_slice << 6;
441 
442  for (i = 1; i < 64; i++) {
443  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
444  level = blocks[idx] / qmat[scan[i]];
445  if (level) {
446  abs_level = FFABS(level);
447  encode_vlc_codeword(pb, ff_prores_run_to_cb[prev_run], run);
448  encode_vlc_codeword(pb, ff_prores_level_to_cb[prev_level], abs_level - 1);
449  put_sbits(pb, 1, GET_SIGN(level));
450 
451  prev_run = FFMIN(run, 15);
452  prev_level = FFMIN(abs_level, 9);
453  run = 0;
454  } else {
455  run++;
456  }
457  }
458  }
459 }
460 
461 static void encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
462  const uint16_t *src, ptrdiff_t linesize,
463  int mbs_per_slice, int16_t *blocks,
464  int blocks_per_mb,
465  const int16_t *qmat)
466 {
467  int blocks_per_slice = mbs_per_slice * blocks_per_mb;
468 
469  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
470  encode_acs(pb, blocks, blocks_per_slice, ctx->scantable, qmat);
471 }
472 
473 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
474 {
475  const int dbits = (abits == 8) ? 4 : 7;
476  const int dsize = 1 << dbits - 1;
477  int diff = cur - prev;
478 
479  diff = av_mod_uintp2(diff, abits);
480  if (diff >= (1 << abits) - dsize)
481  diff -= 1 << abits;
482  if (diff < -dsize || diff > dsize || !diff) {
483  put_bits(pb, 1, 1);
484  put_bits(pb, abits, diff);
485  } else {
486  put_bits(pb, 1, 0);
487  put_bits(pb, dbits - 1, FFABS(diff) - 1);
488  put_bits(pb, 1, diff < 0);
489  }
490 }
491 
492 static void put_alpha_run(PutBitContext *pb, int run)
493 {
494  if (run) {
495  put_bits(pb, 1, 0);
496  if (run < 0x10)
497  put_bits(pb, 4, run);
498  else
499  put_bits(pb, 15, run);
500  } else {
501  put_bits(pb, 1, 1);
502  }
503 }
504 
505 // todo alpha quantisation for high quants
506 static void encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
507  int mbs_per_slice, uint16_t *blocks,
508  int quant)
509 {
510  const int abits = ctx->alpha_bits;
511  const int mask = (1 << abits) - 1;
512  const int num_coeffs = mbs_per_slice * 256;
513  int prev = mask, cur;
514  int idx = 0;
515  int run = 0;
516 
517  cur = blocks[idx++];
518  put_alpha_diff(pb, cur, prev, abits);
519  prev = cur;
520  do {
521  cur = blocks[idx++];
522  if (cur != prev) {
523  put_alpha_run (pb, run);
524  put_alpha_diff(pb, cur, prev, abits);
525  prev = cur;
526  run = 0;
527  } else {
528  run++;
529  }
530  } while (idx < num_coeffs);
531  put_alpha_run(pb, run);
532 }
533 
534 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
535  PutBitContext *pb,
536  int sizes[4], int x, int y, int quant,
537  int mbs_per_slice)
538 {
539  ProresContext *ctx = avctx->priv_data;
540  int i, xp, yp;
541  int total_size = 0;
542  const uint16_t *src;
543  int num_cblocks, pwidth, line_add;
544  ptrdiff_t linesize;
545  int is_chroma;
546  uint16_t *qmat;
547  uint16_t *qmat_chroma;
548 
549  if (ctx->pictures_per_frame == 1)
550  line_add = 0;
551  else
552  line_add = ctx->cur_picture_idx ^ !(pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
553 
554  if (ctx->force_quant) {
555  qmat = ctx->quants[0];
556  qmat_chroma = ctx->quants_chroma[0];
557  } else if (quant < MAX_STORED_Q) {
558  qmat = ctx->quants[quant];
559  qmat_chroma = ctx->quants_chroma[quant];
560  } else {
561  qmat = ctx->custom_q;
562  qmat_chroma = ctx->custom_chroma_q;
563  for (i = 0; i < 64; i++) {
564  qmat[i] = ctx->quant_mat[i] * quant;
565  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
566  }
567  }
568 
569  for (i = 0; i < ctx->num_planes; i++) {
570  is_chroma = (i == 1 || i == 2);
571  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
572  xp = x << 4;
573  yp = y << 4;
574  num_cblocks = 4;
575  pwidth = avctx->width;
576  } else {
577  xp = x << 3;
578  yp = y << 4;
579  num_cblocks = 2;
580  pwidth = avctx->width >> 1;
581  }
582 
583  linesize = pic->linesize[i] * ctx->pictures_per_frame;
584  src = (const uint16_t*)(pic->data[i] + yp * linesize +
585  line_add * pic->linesize[i]) + xp;
586 
587  if (i < 3) {
588  get_slice_data(ctx, src, linesize, xp, yp,
589  pwidth, avctx->height / ctx->pictures_per_frame,
590  ctx->blocks[0], ctx->emu_buf,
591  mbs_per_slice, num_cblocks, is_chroma);
592  if (!is_chroma) {/* luma quant */
593  encode_slice_plane(ctx, pb, src, linesize,
594  mbs_per_slice, ctx->blocks[0],
595  num_cblocks, qmat);
596  } else { /* chroma plane */
597  encode_slice_plane(ctx, pb, src, linesize,
598  mbs_per_slice, ctx->blocks[0],
599  num_cblocks, qmat_chroma);
600  }
601  } else {
602  get_alpha_data(ctx, src, linesize, xp, yp,
603  pwidth, avctx->height / ctx->pictures_per_frame,
604  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
605  encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
606  }
607  flush_put_bits(pb);
608  sizes[i] = put_bytes_output(pb) - total_size;
609  total_size = put_bytes_output(pb);
610  }
611  return total_size;
612 }
613 
614 static inline int estimate_vlc(unsigned codebook, int val)
615 {
616  unsigned int rice_order, exp_order, switch_bits, switch_val;
617  int exponent;
618 
619  /* number of prefix bits to switch between Rice and expGolomb */
620  switch_bits = (codebook & 3) + 1;
621  rice_order = codebook >> 5; /* rice code order */
622  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
623 
624  switch_val = switch_bits << rice_order;
625 
626  if (val >= switch_val) {
627  val -= switch_val - (1 << exp_order);
628  exponent = av_log2(val);
629 
630  return exponent * 2 - exp_order + switch_bits + 1;
631  } else {
632  return (val >> rice_order) + rice_order + 1;
633  }
634 }
635 
636 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
637  int scale)
638 {
639  int i;
640  int codebook = 5, code, dc, prev_dc, delta, sign, new_sign;
641  int bits;
642 
643  prev_dc = (blocks[0] - 0x4000) / scale;
644  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
645  sign = 0;
646  blocks += 64;
647  *error += FFABS(blocks[0] - 0x4000) % scale;
648 
649  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
650  dc = (blocks[0] - 0x4000) / scale;
651  *error += FFABS(blocks[0] - 0x4000) % scale;
652  delta = dc - prev_dc;
653  new_sign = GET_SIGN(delta);
654  delta = (delta ^ sign) - sign;
655  code = MAKE_CODE(delta);
656  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
657  codebook = FFMIN(code, 6);
658  sign = new_sign;
659  prev_dc = dc;
660  }
661 
662  return bits;
663 }
664 
665 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
666  const uint8_t *scan, const int16_t *qmat)
667 {
668  int idx, i;
669  int prev_run = 4;
670  int prev_level = 2;
671  int run, level;
672  int max_coeffs, abs_level;
673  int bits = 0;
674 
675  max_coeffs = blocks_per_slice << 6;
676  run = 0;
677 
678  for (i = 1; i < 64; i++) {
679  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
680  level = blocks[idx] / qmat[scan[i]];
681  *error += FFABS(blocks[idx]) % qmat[scan[i]];
682  if (level) {
683  abs_level = FFABS(level);
684  bits += estimate_vlc(ff_prores_run_to_cb[prev_run], run);
685  bits += estimate_vlc(ff_prores_level_to_cb[prev_level],
686  abs_level - 1) + 1;
687 
688  prev_run = FFMIN(run, 15);
689  prev_level = FFMIN(abs_level, 9);
690  run = 0;
691  } else {
692  run++;
693  }
694  }
695  }
696 
697  return bits;
698 }
699 
700 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
701  const uint16_t *src, ptrdiff_t linesize,
702  int mbs_per_slice,
703  int blocks_per_mb,
704  const int16_t *qmat, ProresThreadData *td)
705 {
706  int blocks_per_slice;
707  int bits;
708 
709  blocks_per_slice = mbs_per_slice * blocks_per_mb;
710 
711  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
712  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice, ctx->scantable, qmat);
713 
714  return FFALIGN(bits, 8);
715 }
716 
717 static int est_alpha_diff(int cur, int prev, int abits)
718 {
719  const int dbits = (abits == 8) ? 4 : 7;
720  const int dsize = 1 << dbits - 1;
721  int diff = cur - prev;
722 
723  diff = av_mod_uintp2(diff, abits);
724  if (diff >= (1 << abits) - dsize)
725  diff -= 1 << abits;
726  if (diff < -dsize || diff > dsize || !diff)
727  return abits + 1;
728  else
729  return dbits + 1;
730 }
731 
732 static int estimate_alpha_plane(ProresContext *ctx,
733  const uint16_t *src, ptrdiff_t linesize,
734  int mbs_per_slice, int16_t *blocks)
735 {
736  const int abits = ctx->alpha_bits;
737  const int mask = (1 << abits) - 1;
738  const int num_coeffs = mbs_per_slice * 256;
739  int prev = mask, cur;
740  int idx = 0;
741  int run = 0;
742  int bits;
743 
744  cur = blocks[idx++];
745  bits = est_alpha_diff(cur, prev, abits);
746  prev = cur;
747  do {
748  cur = blocks[idx++];
749  if (cur != prev) {
750  if (!run)
751  bits++;
752  else if (run < 0x10)
753  bits += 4;
754  else
755  bits += 15;
756  bits += est_alpha_diff(cur, prev, abits);
757  prev = cur;
758  run = 0;
759  } else {
760  run++;
761  }
762  } while (idx < num_coeffs);
763 
764  if (run) {
765  if (run < 0x10)
766  bits += 4;
767  else
768  bits += 15;
769  }
770 
771  return bits;
772 }
773 
774 static int find_slice_quant(AVCodecContext *avctx,
775  int trellis_node, int x, int y, int mbs_per_slice,
776  ProresThreadData *td)
777 {
778  ProresContext *ctx = avctx->priv_data;
779  int i, q, pq, xp, yp;
780  const uint16_t *src;
781  int num_cblocks[MAX_PLANES], pwidth;
782  int is_chroma[MAX_PLANES];
783  const int min_quant = ctx->profile_info->min_quant;
784  const int max_quant = ctx->profile_info->max_quant;
785  int error, bits, bits_limit;
786  int mbs, prev, cur, new_score;
787  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
788  int overquant;
789  uint16_t *qmat;
790  uint16_t *qmat_chroma;
791  int linesize[4], line_add;
792  int alpha_bits = 0;
793 
794  if (ctx->pictures_per_frame == 1)
795  line_add = 0;
796  else
797  line_add = ctx->cur_picture_idx ^ !(ctx->pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
798  mbs = x + mbs_per_slice;
799 
800  for (i = 0; i < ctx->num_planes; i++) {
801  is_chroma[i] = (i == 1 || i == 2);
802  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
803  xp = x << 4;
804  yp = y << 4;
805  num_cblocks[i] = 4;
806  pwidth = avctx->width;
807  } else {
808  xp = x << 3;
809  yp = y << 4;
810  num_cblocks[i] = 2;
811  pwidth = avctx->width >> 1;
812  }
813 
814  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
815  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
816  line_add * ctx->pic->linesize[i]) + xp;
817 
818  if (i < 3) {
819  get_slice_data(ctx, src, linesize[i], xp, yp,
820  pwidth, avctx->height / ctx->pictures_per_frame,
821  td->blocks[i], td->emu_buf,
822  mbs_per_slice, num_cblocks[i], is_chroma[i]);
823  } else {
824  get_alpha_data(ctx, src, linesize[i], xp, yp,
825  pwidth, avctx->height / ctx->pictures_per_frame,
826  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
827  }
828  }
829 
830  for (q = min_quant; q < max_quant + 2; q++) {
831  td->nodes[trellis_node + q].prev_node = -1;
832  td->nodes[trellis_node + q].quant = q;
833  }
834 
835  if (ctx->alpha_bits)
836  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
837  mbs_per_slice, td->blocks[3]);
838  // todo: maybe perform coarser quantising to fit into frame size when needed
839  for (q = min_quant; q <= max_quant; q++) {
840  bits = alpha_bits;
841  error = 0;
842  bits += estimate_slice_plane(ctx, &error, 0,
843  src, linesize[0],
844  mbs_per_slice,
845  num_cblocks[0],
846  ctx->quants[q], td); /* estimate luma plane */
847  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
848  bits += estimate_slice_plane(ctx, &error, i,
849  src, linesize[i],
850  mbs_per_slice,
851  num_cblocks[i],
852  ctx->quants_chroma[q], td);
853  }
854  if (bits > 65000 * 8)
855  error = SCORE_LIMIT;
856 
857  slice_bits[q] = bits;
858  slice_score[q] = error;
859  }
860  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
861  slice_bits[max_quant + 1] = slice_bits[max_quant];
862  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
863  overquant = max_quant;
864  } else {
865  for (q = max_quant + 1; q < 128; q++) {
866  bits = alpha_bits;
867  error = 0;
868  if (q < MAX_STORED_Q) {
869  qmat = ctx->quants[q];
870  qmat_chroma = ctx->quants_chroma[q];
871  } else {
872  qmat = td->custom_q;
873  qmat_chroma = td->custom_chroma_q;
874  for (i = 0; i < 64; i++) {
875  qmat[i] = ctx->quant_mat[i] * q;
876  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
877  }
878  }
879  bits += estimate_slice_plane(ctx, &error, 0,
880  src, linesize[0],
881  mbs_per_slice,
882  num_cblocks[0],
883  qmat, td);/* estimate luma plane */
884  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
885  bits += estimate_slice_plane(ctx, &error, i,
886  src, linesize[i],
887  mbs_per_slice,
888  num_cblocks[i],
889  qmat_chroma, td);
890  }
891  if (bits <= ctx->bits_per_mb * mbs_per_slice)
892  break;
893  }
894 
895  slice_bits[max_quant + 1] = bits;
896  slice_score[max_quant + 1] = error;
897  overquant = q;
898  }
899  td->nodes[trellis_node + max_quant + 1].quant = overquant;
900 
901  bits_limit = mbs * ctx->bits_per_mb;
902  for (pq = min_quant; pq < max_quant + 2; pq++) {
903  prev = trellis_node - TRELLIS_WIDTH + pq;
904 
905  for (q = min_quant; q < max_quant + 2; q++) {
906  cur = trellis_node + q;
907 
908  bits = td->nodes[prev].bits + slice_bits[q];
909  error = slice_score[q];
910  if (bits > bits_limit)
911  error = SCORE_LIMIT;
912 
913  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
914  new_score = td->nodes[prev].score + error;
915  else
916  new_score = SCORE_LIMIT;
917  if (td->nodes[cur].prev_node == -1 ||
918  td->nodes[cur].score >= new_score) {
919 
920  td->nodes[cur].bits = bits;
921  td->nodes[cur].score = new_score;
922  td->nodes[cur].prev_node = prev;
923  }
924  }
925  }
926 
927  error = td->nodes[trellis_node + min_quant].score;
928  pq = trellis_node + min_quant;
929  for (q = min_quant + 1; q < max_quant + 2; q++) {
930  if (td->nodes[trellis_node + q].score <= error) {
931  error = td->nodes[trellis_node + q].score;
932  pq = trellis_node + q;
933  }
934  }
935 
936  return pq;
937 }
938 
939 static int find_quant_thread(AVCodecContext *avctx, void *arg,
940  int jobnr, int threadnr)
941 {
942  ProresContext *ctx = avctx->priv_data;
943  ProresThreadData *td = ctx->tdata + threadnr;
944  int mbs_per_slice = ctx->mbs_per_slice;
945  int x, y = jobnr, mb, q = 0;
946 
947  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
948  while (ctx->mb_width - x < mbs_per_slice)
949  mbs_per_slice >>= 1;
950  q = find_slice_quant(avctx,
951  (mb + 1) * TRELLIS_WIDTH, x, y,
952  mbs_per_slice, td);
953  }
954 
955  for (x = ctx->slices_width - 1; x >= 0; x--) {
956  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
957  q = td->nodes[q].prev_node;
958  }
959 
960  return 0;
961 }
962 
963 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
964  const AVFrame *pic, int *got_packet)
965 {
966  ProresContext *ctx = avctx->priv_data;
967  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
968  uint8_t *picture_size_pos;
969  PutBitContext pb;
970  int x, y, i, mb, q = 0;
971  int sizes[4] = { 0 };
972  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
973  int frame_size, picture_size, slice_size;
974  int pkt_size, ret;
975  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
976  uint8_t frame_flags;
977 
978  ctx->pic = pic;
979  pkt_size = ctx->frame_size_upper_bound;
980 
981  if ((ret = ff_alloc_packet(avctx, pkt, pkt_size + FF_INPUT_BUFFER_MIN_SIZE)) < 0)
982  return ret;
983 
984  orig_buf = pkt->data;
985 
986  // frame atom
987  orig_buf += 4; // frame size
988  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
989  buf = orig_buf;
990 
991  // frame header
992  tmp = buf;
993  buf += 2; // frame header size will be stored here
994  bytestream_put_be16 (&buf, ctx->chroma_factor != CFACTOR_Y422 || ctx->alpha_bits ? 1 : 0);
995  bytestream_put_buffer(&buf, ctx->vendor, 4);
996  bytestream_put_be16 (&buf, avctx->width);
997  bytestream_put_be16 (&buf, avctx->height);
998 
999  frame_flags = ctx->chroma_factor << 6;
1000  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1001  frame_flags |= (pic->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? 0x04 : 0x08;
1002  bytestream_put_byte (&buf, frame_flags);
1003 
1004  bytestream_put_byte (&buf, 0); // reserved
1005  bytestream_put_byte (&buf, pic->color_primaries);
1006  bytestream_put_byte (&buf, pic->color_trc);
1007  bytestream_put_byte (&buf, pic->colorspace);
1008  bytestream_put_byte (&buf, ctx->alpha_bits >> 3);
1009  bytestream_put_byte (&buf, 0); // reserved
1010  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1011  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1012  bytestream_put_buffer(&buf, ctx->quant_mat, 64); // luma quantisation matrix
1013  bytestream_put_buffer(&buf, ctx->quant_chroma_mat, 64); // chroma quantisation matrix
1014  } else {
1015  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1016  }
1017  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1018 
1019  for (ctx->cur_picture_idx = 0;
1020  ctx->cur_picture_idx < ctx->pictures_per_frame;
1021  ctx->cur_picture_idx++) {
1022  // picture header
1023  picture_size_pos = buf + 1;
1024  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1025  buf += 4; // picture data size will be stored here
1026  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1027  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1028 
1029  // seek table - will be filled during slice encoding
1030  slice_sizes = buf;
1031  buf += ctx->slices_per_picture * 2;
1032 
1033  // slices
1034  if (!ctx->force_quant) {
1035  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1036  ctx->mb_height);
1037  if (ret)
1038  return ret;
1039  }
1040 
1041  for (y = 0; y < ctx->mb_height; y++) {
1042  int mbs_per_slice = ctx->mbs_per_slice;
1043  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1044  q = ctx->force_quant ? ctx->force_quant
1045  : ctx->slice_q[mb + y * ctx->slices_width];
1046 
1047  while (ctx->mb_width - x < mbs_per_slice)
1048  mbs_per_slice >>= 1;
1049 
1050  bytestream_put_byte(&buf, slice_hdr_size << 3);
1051  slice_hdr = buf;
1052  buf += slice_hdr_size - 1;
1053  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1054  uint8_t *start = pkt->data;
1055  // Recompute new size according to max_slice_size
1056  // and deduce delta
1057  int delta = 200 + (ctx->pictures_per_frame *
1058  ctx->slices_per_picture + 1) *
1059  max_slice_size - pkt_size;
1060 
1061  delta = FFMAX(delta, 2 * max_slice_size);
1062  ctx->frame_size_upper_bound += delta;
1063 
1064  if (!ctx->warn) {
1065  avpriv_request_sample(avctx,
1066  "Packet too small: is %i,"
1067  " needs %i (slice: %i). "
1068  "Correct allocation",
1069  pkt_size, delta, max_slice_size);
1070  ctx->warn = 1;
1071  }
1072 
1073  ret = av_grow_packet(pkt, delta);
1074  if (ret < 0)
1075  return ret;
1076 
1077  pkt_size += delta;
1078  // restore pointers
1079  orig_buf = pkt->data + (orig_buf - start);
1080  buf = pkt->data + (buf - start);
1081  picture_size_pos = pkt->data + (picture_size_pos - start);
1082  slice_sizes = pkt->data + (slice_sizes - start);
1083  slice_hdr = pkt->data + (slice_hdr - start);
1084  tmp = pkt->data + (tmp - start);
1085  }
1086  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1087  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1088  mbs_per_slice);
1089  if (ret < 0)
1090  return ret;
1091 
1092  bytestream_put_byte(&slice_hdr, q);
1093  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1094  for (i = 0; i < ctx->num_planes - 1; i++) {
1095  bytestream_put_be16(&slice_hdr, sizes[i]);
1096  slice_size += sizes[i];
1097  }
1098  bytestream_put_be16(&slice_sizes, slice_size);
1099  buf += slice_size - slice_hdr_size;
1100  if (max_slice_size < slice_size)
1101  max_slice_size = slice_size;
1102  }
1103  }
1104 
1105  picture_size = buf - (picture_size_pos - 1);
1106  bytestream_put_be32(&picture_size_pos, picture_size);
1107  }
1108 
1109  orig_buf -= 8;
1110  frame_size = buf - orig_buf;
1111  bytestream_put_be32(&orig_buf, frame_size);
1112 
1113  pkt->size = frame_size;
1114  *got_packet = 1;
1115 
1116  return 0;
1117 }
1118 
1119 static av_cold int encode_close(AVCodecContext *avctx)
1120 {
1121  ProresContext *ctx = avctx->priv_data;
1122  int i;
1123 
1124  if (ctx->tdata) {
1125  for (i = 0; i < avctx->thread_count; i++)
1126  av_freep(&ctx->tdata[i].nodes);
1127  }
1128  av_freep(&ctx->tdata);
1129  av_freep(&ctx->slice_q);
1130 
1131  return 0;
1132 }
1133 
1134 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1135  ptrdiff_t linesize, int16_t *block)
1136 {
1137  int x, y;
1138  const uint16_t *tsrc = src;
1139 
1140  for (y = 0; y < 8; y++) {
1141  for (x = 0; x < 8; x++)
1142  block[y * 8 + x] = tsrc[x];
1143  tsrc += linesize >> 1;
1144  }
1145  fdsp->fdct(block);
1146 }
1147 
1148 static av_cold int encode_init(AVCodecContext *avctx)
1149 {
1150  ProresContext *ctx = avctx->priv_data;
1151  int mps;
1152  int i, j;
1153  int min_quant, max_quant;
1154  int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1155 
1156  avctx->bits_per_raw_sample = 10;
1157 
1158  ctx->fdct = prores_fdct;
1159  ctx->scantable = interlaced ? ff_prores_interlaced_scan
1160  : ff_prores_progressive_scan;
1161  ff_fdctdsp_init(&ctx->fdsp, avctx);
1162 
1163  mps = ctx->mbs_per_slice;
1164  if (mps & (mps - 1)) {
1165  av_log(avctx, AV_LOG_ERROR,
1166  "there should be an integer power of two MBs per slice\n");
1167  return AVERROR(EINVAL);
1168  }
1169  if (ctx->profile == PRORES_PROFILE_AUTO) {
1170  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1171  ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1172  !(desc->log2_chroma_w + desc->log2_chroma_h))
1173  ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;
1174  av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1175  "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1176  ? "4:4:4:4 profile because of the used input colorspace"
1177  : "HQ profile to keep best quality");
1178  }
1179  if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1180  if (ctx->profile != PRORES_PROFILE_4444 &&
1181  ctx->profile != PRORES_PROFILE_4444XQ) {
1182  // force alpha and warn
1183  av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1184  "encode alpha. Override with -profile if needed.\n");
1185  ctx->alpha_bits = 0;
1186  }
1187  if (ctx->alpha_bits & 7) {
1188  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1189  return AVERROR(EINVAL);
1190  }
1191  avctx->bits_per_coded_sample = 32;
1192  } else {
1193  ctx->alpha_bits = 0;
1194  }
1195 
1196  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1197  ? CFACTOR_Y422
1198  : CFACTOR_Y444;
1199  ctx->profile_info = prores_profile_info + ctx->profile;
1200  ctx->num_planes = 3 + !!ctx->alpha_bits;
1201 
1202  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1203 
1204  if (interlaced)
1205  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1206  else
1207  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1208 
1209  ctx->slices_width = ctx->mb_width / mps;
1210  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1211  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1212  ctx->pictures_per_frame = 1 + interlaced;
1213 
1214  if (ctx->quant_sel == -1) {
1215  ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1216  ctx->quant_chroma_mat = prores_quant_matrices[ctx->profile_info->quant_chroma];
1217  } else {
1218  ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1219  ctx->quant_chroma_mat = prores_quant_matrices[ctx->quant_sel];
1220  }
1221 
1222  if (strlen(ctx->vendor) != 4) {
1223  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1224  return AVERROR_INVALIDDATA;
1225  }
1226 
1227  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1228  if (!ctx->force_quant) {
1229  if (!ctx->bits_per_mb) {
1230  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1231  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1232  ctx->pictures_per_frame)
1233  break;
1234  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1235  if (ctx->alpha_bits)
1236  ctx->bits_per_mb *= 20;
1237  } else if (ctx->bits_per_mb < 128) {
1238  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1239  return AVERROR_INVALIDDATA;
1240  }
1241 
1242  min_quant = ctx->profile_info->min_quant;
1243  max_quant = ctx->profile_info->max_quant;
1244  for (i = min_quant; i < MAX_STORED_Q; i++) {
1245  for (j = 0; j < 64; j++) {
1246  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1247  ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1248  }
1249  }
1250 
1251  ctx->slice_q = av_malloc_array(ctx->slices_per_picture, sizeof(*ctx->slice_q));
1252  if (!ctx->slice_q)
1253  return AVERROR(ENOMEM);
1254 
1255  ctx->tdata = av_calloc(avctx->thread_count, sizeof(*ctx->tdata));
1256  if (!ctx->tdata)
1257  return AVERROR(ENOMEM);
1258 
1259  for (j = 0; j < avctx->thread_count; j++) {
1260  ctx->tdata[j].nodes = av_malloc_array(ctx->slices_width + 1,
1261  TRELLIS_WIDTH
1262  * sizeof(*ctx->tdata->nodes));
1263  if (!ctx->tdata[j].nodes)
1264  return AVERROR(ENOMEM);
1265  for (i = min_quant; i < max_quant + 2; i++) {
1266  ctx->tdata[j].nodes[i].prev_node = -1;
1267  ctx->tdata[j].nodes[i].bits = 0;
1268  ctx->tdata[j].nodes[i].score = 0;
1269  }
1270  }
1271  } else {
1272  int ls = 0;
1273  int ls_chroma = 0;
1274 
1275  if (ctx->force_quant > 64) {
1276  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1277  return AVERROR_INVALIDDATA;
1278  }
1279 
1280  for (j = 0; j < 64; j++) {
1281  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1282  ctx->quants_chroma[0][j] = ctx->quant_chroma_mat[j] * ctx->force_quant;
1283  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1284  ls_chroma += av_log2((1 << 11) / ctx->quants_chroma[0][j]) * 2 + 1;
1285  }
1286 
1287  ctx->bits_per_mb = ls * 4 + ls_chroma * 4;
1288  if (ctx->chroma_factor == CFACTOR_Y444)
1289  ctx->bits_per_mb += ls_chroma * 4;
1290  }
1291 
1292  ctx->frame_size_upper_bound = (ctx->pictures_per_frame *
1293  ctx->slices_per_picture + 1) *
1294  (2 + 2 * ctx->num_planes +
1295  (mps * ctx->bits_per_mb) / 8)
1296  + 200;
1297 
1298  if (ctx->alpha_bits) {
1299  // The alpha plane is run-coded and might exceed the bit budget.
1300  ctx->frame_size_upper_bound += (ctx->pictures_per_frame *
1301  ctx->slices_per_picture + 1) *
1302  /* num pixels per slice */ (ctx->mbs_per_slice * 256 *
1303  /* bits per pixel */ (1 + ctx->alpha_bits + 1) + 7 >> 3);
1304  }
1305 
1306  avctx->codec_tag = ctx->profile_info->tag;
1307  avctx->profile = ctx->profile;
1308 
1309  av_log(avctx, AV_LOG_DEBUG,
1310  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1311  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1312  interlaced ? "yes" : "no", ctx->bits_per_mb);
1313  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1314  ctx->frame_size_upper_bound);
1315 
1316  return 0;
1317 }
1318 
1319 #define OFFSET(x) offsetof(ProresContext, x)
1320 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1321 
1322 static const AVOption options[] = {
1323  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1324  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1325  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1326  { .i64 = PRORES_PROFILE_AUTO },
1327  PRORES_PROFILE_AUTO, PRORES_PROFILE_4444XQ, VE, .unit = "profile" },
1328  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1329  0, 0, VE, .unit = "profile" },
1330  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1331  0, 0, VE, .unit = "profile" },
1332  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1333  0, 0, VE, .unit = "profile" },
1334  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1335  0, 0, VE, .unit = "profile" },
1336  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1337  0, 0, VE, .unit = "profile" },
1338  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1339  0, 0, VE, .unit = "profile" },
1340  { "4444xq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
1341  0, 0, VE, .unit = "profile" },
1342  { "vendor", "vendor ID", OFFSET(vendor),
1343  AV_OPT_TYPE_STRING, { .str = "Lavc" }, 0, 0, VE },
1344  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1345  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1346  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1347  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, .unit = "quant_mat" },
1348  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1349  0, 0, VE, .unit = "quant_mat" },
1350  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1351  0, 0, VE, .unit = "quant_mat" },
1352  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1353  0, 0, VE, .unit = "quant_mat" },
1354  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1355  0, 0, VE, .unit = "quant_mat" },
1356  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1357  0, 0, VE, .unit = "quant_mat" },
1358  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1359  0, 0, VE, .unit = "quant_mat" },
1360  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1361  { .i64 = 16 }, 0, 16, VE },
1362  { NULL }
1363 };
1364 
1365 static const AVClass proresenc_class = {
1366  .class_name = "ProRes encoder",
1367  .item_name = av_default_item_name,
1368  .option = options,
1369  .version = LIBAVUTIL_VERSION_INT,
1370 };
1371 
1372 const FFCodec ff_prores_ks_encoder = {
1373  .p.name = "prores_ks",
1374  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
1375  .p.type = AVMEDIA_TYPE_VIDEO,
1376  .p.id = AV_CODEC_ID_PRORES,
1377  .priv_data_size = sizeof(ProresContext),
1378  .init = encode_init,
1379  .close = encode_close,
1380  FF_CODEC_ENCODE_CB(encode_frame),
1381  .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |
1382  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1383  .p.pix_fmts = (const enum AVPixelFormat[]) {
1384  AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1385  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1386  },
1387  .p.priv_class = &proresenc_class,
1388  .p.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
1389  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1390 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
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:627
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:636
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:204
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
PRORES_PROFILE_AUTO
@ PRORES_PROFILE_AUTO
Definition: proresenc_kostya.c:44
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:183
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:403
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: proresenc_kostya.c:963
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:172
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
PRORES_PROFILE_4444XQ
@ PRORES_PROFILE_4444XQ
Definition: proresenc_kostya.c:50
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.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:625
ProresContext::quants_chroma
int16_t quants_chroma[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:234
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:125
ProresContext::vendor
char * vendor
Definition: proresenc_anatoliy.c:197
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:700
prores_profile::tag
uint32_t tag
Definition: proresenc_kostya.c:146
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:634
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
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:222
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:506
PRORES_PROFILE_HQ
@ PRORES_PROFILE_HQ
Definition: proresenc_kostya.c:48
AVPacket::data
uint8_t * data
Definition: packet.h:522
ff_prores_ks_encoder
const FFCodec ff_prores_ks_encoder
Definition: proresenc_kostya.c:1372
AVOption
AVOption.
Definition: opt.h:346
ProresContext::slices_width
int slices_width
Definition: proresenc_kostya.c:249
encode.h
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdata.h:36
ProresContext::alpha_bits
int alpha_bits
Definition: proresenc_kostya.c:256
ProresContext
Definition: proresdec.h:43
FFCodec
Definition: codec_internal.h:127
ProresContext::num_planes
int num_planes
Definition: proresenc_kostya.c:253
ProresContext::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:232
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:616
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ProresThreadData::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:223
av_popcount
#define av_popcount
Definition: common.h:152
QUANT_MAT_HQ
@ QUANT_MAT_HQ
Definition: proresenc_kostya.c:58
QUANT_MAT_XQ_LUMA
@ QUANT_MAT_XQ_LUMA
Definition: proresenc_kostya.c:59
SCORE_LIMIT
#define SCORE_LIMIT
Definition: proresenc_kostya.c:210
put_alpha_run
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc_kostya.c:492
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:63
PRORES_PROFILE_4444
@ PRORES_PROFILE_4444
Definition: proresenc_kostya.c:49
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:365
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:608
prores_fdct
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
Definition: proresenc_kostya.c:1134
ProresContext::profile_info
const struct prores_profile * profile_info
Definition: proresenc_kostya.c:265
FDCTDSPContext
Definition: fdctdsp.h:28
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:267
ProresContext::mbs_per_slice
int mbs_per_slice
Definition: proresenc_kostya.c:247
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, uint16_t *blocks, int mbs_per_slice, int abits)
Definition: proresenc_kostya.c:343
TrellisNode
Definition: adpcmenc.c:60
prores_mb_limits
static const int prores_mb_limits[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:137
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:236
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:473
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:732
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
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: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:461
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
prores_profile::max_quant
int max_quant
Definition: proresenc_kostya.c:148
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
pkt
AVPacket * pkt
Definition: movenc.c:59
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:225
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:2422
ProresThreadData::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:224
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: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
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:939
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
ProresContext::mb_width
int mb_width
Definition: proresenc_kostya.c:246
QUANT_MAT_STANDARD
@ QUANT_MAT_STANDARD
Definition: proresenc_kostya.c:57
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: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: codec.h:110
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: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:60
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:203
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1148
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:774
PRORES_PROFILE_STANDARD
@ PRORES_PROFILE_STANDARD
Definition: proresenc_kostya.c:47
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
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:94
ProresContext::blocks
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
Definition: proresenc_kostya.c:231
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_LT
@ PRORES_PROFILE_LT
Definition: proresenc_kostya.c:46
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
ProresContext::chroma_factor
int chroma_factor
Definition: proresenc_kostya.c:248
AVPacket::size
int size
Definition: packet.h:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
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:106
ProresContext::scantable
const uint8_t * scantable
Definition: proresenc_anatoliy.c:191
ProresContext::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:235
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
TrellisNode::bits
int bits
Definition: proresenc_kostya.c:215
proresdata.h
MAKE_CODE
#define MAKE_CODE(x)
Definition: proresenc_kostya.c:404
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:164
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:665
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:1319
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:1322
interlaced
uint8_t interlaced
Definition: mxfenc.c:2263
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
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:255
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
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
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:248
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:430
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:717
QUANT_MAT_DEFAULT
@ QUANT_MAT_DEFAULT
Definition: proresenc_kostya.c:60
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
profile
int profile
Definition: mxfenc.c:2226
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:262
avcodec.h
proresenc_class
static const AVClass proresenc_class
Definition: proresenc_kostya.c:1365
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:71
prores_profile::quant
int quant
Definition: proresenc_kostya.c:150
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
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:250
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:216
desc
const char * desc
Definition: libsvtav1.c:75
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: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:614
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:534
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:499
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:374
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:1320
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
QUANT_MAT_PROXY_CHROMA
@ QUANT_MAT_PROXY_CHROMA
Definition: proresenc_kostya.c:55
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:389
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: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:241
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ProresContext::cur_picture_idx
int cur_picture_idx
Definition: proresenc_kostya.c:252
h
h
Definition: vp9dsp_template.c:2038
PRORES_PROFILE_PROXY
@ PRORES_PROFILE_PROXY
Definition: proresenc_kostya.c:45
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
QUANT_MAT_LT
@ QUANT_MAT_LT
Definition: proresenc_kostya.c:56
put_bits.h
ProresContext::warn
int warn
Definition: proresenc_kostya.c:257
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:61
QUANT_MAT_PROXY
@ QUANT_MAT_PROXY
Definition: proresenc_kostya.c:54
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1119
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
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 Thu Sep 26 2024 23:15:16 for FFmpeg by   doxygen 1.8.17