FFmpeg
proresenc_kostya.c
Go to the documentation of this file.
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2012 Konstantin Shishkov
5  *
6  * This encoder appears to be based on Anatoliy Wassermans considering
7  * similarities in the bugs.
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/mem_internal.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "avcodec.h"
30 #include "codec_internal.h"
31 #include "encode.h"
32 #include "fdctdsp.h"
33 #include "put_bits.h"
34 #include "profiles.h"
35 #include "bytestream.h"
36 #include "proresdata.h"
37 
38 #define CFACTOR_Y422 2
39 #define CFACTOR_Y444 3
40 
41 #define MAX_MBS_PER_SLICE 8
42 
43 #define MAX_PLANES 4
44 
45 enum {
53 };
54 
55 enum {
63 };
64 
65 static const uint8_t prores_quant_matrices[][64] = {
66  { // proxy
67  4, 7, 9, 11, 13, 14, 15, 63,
68  7, 7, 11, 12, 14, 15, 63, 63,
69  9, 11, 13, 14, 15, 63, 63, 63,
70  11, 11, 13, 14, 63, 63, 63, 63,
71  11, 13, 14, 63, 63, 63, 63, 63,
72  13, 14, 63, 63, 63, 63, 63, 63,
73  13, 63, 63, 63, 63, 63, 63, 63,
74  63, 63, 63, 63, 63, 63, 63, 63,
75  },
76  { // proxy chromas
77  4, 7, 9, 11, 13, 14, 63, 63,
78  7, 7, 11, 12, 14, 63, 63, 63,
79  9, 11, 13, 14, 63, 63, 63, 63,
80  11, 11, 13, 14, 63, 63, 63, 63,
81  11, 13, 14, 63, 63, 63, 63, 63,
82  13, 14, 63, 63, 63, 63, 63, 63,
83  13, 63, 63, 63, 63, 63, 63, 63,
84  63, 63, 63, 63, 63, 63, 63, 63
85  },
86  { // LT
87  4, 5, 6, 7, 9, 11, 13, 15,
88  5, 5, 7, 8, 11, 13, 15, 17,
89  6, 7, 9, 11, 13, 15, 15, 17,
90  7, 7, 9, 11, 13, 15, 17, 19,
91  7, 9, 11, 13, 14, 16, 19, 23,
92  9, 11, 13, 14, 16, 19, 23, 29,
93  9, 11, 13, 15, 17, 21, 28, 35,
94  11, 13, 16, 17, 21, 28, 35, 41,
95  },
96  { // standard
97  4, 4, 5, 5, 6, 7, 7, 9,
98  4, 4, 5, 6, 7, 7, 9, 9,
99  5, 5, 6, 7, 7, 9, 9, 10,
100  5, 5, 6, 7, 7, 9, 9, 10,
101  5, 6, 7, 7, 8, 9, 10, 12,
102  6, 7, 7, 8, 9, 10, 12, 15,
103  6, 7, 7, 9, 10, 11, 14, 17,
104  7, 7, 9, 10, 11, 14, 17, 21,
105  },
106  { // high quality
107  4, 4, 4, 4, 4, 4, 4, 4,
108  4, 4, 4, 4, 4, 4, 4, 4,
109  4, 4, 4, 4, 4, 4, 4, 4,
110  4, 4, 4, 4, 4, 4, 4, 5,
111  4, 4, 4, 4, 4, 4, 5, 5,
112  4, 4, 4, 4, 4, 5, 5, 6,
113  4, 4, 4, 4, 5, 5, 6, 7,
114  4, 4, 4, 4, 5, 6, 7, 7,
115  },
116  { // XQ luma
117  2, 2, 2, 2, 2, 2, 2, 2,
118  2, 2, 2, 2, 2, 2, 2, 2,
119  2, 2, 2, 2, 2, 2, 2, 2,
120  2, 2, 2, 2, 2, 2, 2, 3,
121  2, 2, 2, 2, 2, 2, 3, 3,
122  2, 2, 2, 2, 2, 3, 3, 3,
123  2, 2, 2, 2, 3, 3, 3, 4,
124  2, 2, 2, 2, 3, 3, 4, 4,
125  },
126  { // codec default
127  4, 4, 4, 4, 4, 4, 4, 4,
128  4, 4, 4, 4, 4, 4, 4, 4,
129  4, 4, 4, 4, 4, 4, 4, 4,
130  4, 4, 4, 4, 4, 4, 4, 4,
131  4, 4, 4, 4, 4, 4, 4, 4,
132  4, 4, 4, 4, 4, 4, 4, 4,
133  4, 4, 4, 4, 4, 4, 4, 4,
134  4, 4, 4, 4, 4, 4, 4, 4,
135  },
136 };
137 
138 static const uint8_t prores_dc_codebook[4] = {
139  0x04, // rice_order = 0, exp_golomb_order = 1, switch_bits = 0
140  0x28, // rice_order = 1, exp_golomb_order = 2, switch_bits = 0
141  0x4D, // rice_order = 2, exp_golomb_order = 3, switch_bits = 1
142  0x70 // rice_order = 3, exp_golomb_order = 4, switch_bits = 0
143 };
144 
145 static const uint8_t prores_ac_codebook[7] = {
146  0x04, // rice_order = 0, exp_golomb_order = 1, switch_bits = 0
147  0x28, // rice_order = 1, exp_golomb_order = 2, switch_bits = 0
148  0x4C, // rice_order = 2, exp_golomb_order = 3, switch_bits = 0
149  0x05, // rice_order = 0, exp_golomb_order = 1, switch_bits = 1
150  0x29, // rice_order = 1, exp_golomb_order = 2, switch_bits = 1
151  0x06, // rice_order = 0, exp_golomb_order = 1, switch_bits = 2
152  0x0A, // rice_order = 0, exp_golomb_order = 2, switch_bits = 2
153 };
154 
155 /**
156  * Lookup tables for adaptive switching between codebooks
157  * according with previous run/level value.
158  */
159 static const uint8_t prores_run_to_cb_index[16] =
160  { 5, 5, 3, 3, 0, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 2 };
161 
162 static const uint8_t prores_lev_to_cb_index[10] = { 0, 6, 3, 5, 0, 1, 1, 1, 1, 2 };
163 
164 #define NUM_MB_LIMITS 4
165 static const int prores_mb_limits[NUM_MB_LIMITS] = {
166  1620, // up to 720x576
167  2700, // up to 960x720
168  6075, // up to 1440x1080
169  9216, // up to 2048x1152
170 };
171 
172 static const struct prores_profile {
173  const char *full_name;
174  uint32_t tag;
178  int quant;
180 } prores_profile_info[6] = {
181  {
182  .full_name = "proxy",
183  .tag = MKTAG('a', 'p', 'c', 'o'),
184  .min_quant = 4,
185  .max_quant = 8,
186  .br_tab = { 300, 242, 220, 194 },
187  .quant = QUANT_MAT_PROXY,
188  .quant_chroma = QUANT_MAT_PROXY_CHROMA,
189  },
190  {
191  .full_name = "LT",
192  .tag = MKTAG('a', 'p', 'c', 's'),
193  .min_quant = 1,
194  .max_quant = 9,
195  .br_tab = { 720, 560, 490, 440 },
196  .quant = QUANT_MAT_LT,
197  .quant_chroma = QUANT_MAT_LT,
198  },
199  {
200  .full_name = "standard",
201  .tag = MKTAG('a', 'p', 'c', 'n'),
202  .min_quant = 1,
203  .max_quant = 6,
204  .br_tab = { 1050, 808, 710, 632 },
205  .quant = QUANT_MAT_STANDARD,
206  .quant_chroma = QUANT_MAT_STANDARD,
207  },
208  {
209  .full_name = "high quality",
210  .tag = MKTAG('a', 'p', 'c', 'h'),
211  .min_quant = 1,
212  .max_quant = 6,
213  .br_tab = { 1566, 1216, 1070, 950 },
214  .quant = QUANT_MAT_HQ,
215  .quant_chroma = QUANT_MAT_HQ,
216  },
217  {
218  .full_name = "4444",
219  .tag = MKTAG('a', 'p', '4', 'h'),
220  .min_quant = 1,
221  .max_quant = 6,
222  .br_tab = { 2350, 1828, 1600, 1425 },
223  .quant = QUANT_MAT_HQ,
224  .quant_chroma = QUANT_MAT_HQ,
225  },
226  {
227  .full_name = "4444XQ",
228  .tag = MKTAG('a', 'p', '4', 'x'),
229  .min_quant = 1,
230  .max_quant = 6,
231  .br_tab = { 3525, 2742, 2400, 2137 },
232  .quant = QUANT_MAT_HQ, /* Fix me : use QUANT_MAT_XQ_LUMA */
233  .quant_chroma = QUANT_MAT_HQ,
234  }
235 };
236 
237 #define TRELLIS_WIDTH 16
238 #define SCORE_LIMIT INT_MAX / 2
239 
240 struct TrellisNode {
242  int quant;
243  int bits;
244  int score;
245 };
246 
247 #define MAX_STORED_Q 16
248 
249 typedef struct ProresThreadData {
251  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
252  int16_t custom_q[64];
253  int16_t custom_chroma_q[64];
256 
257 typedef struct ProresContext {
258  AVClass *class;
260  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
261  int16_t quants[MAX_STORED_Q][64];
263  int16_t custom_q[64];
264  int16_t custom_chroma_q[64];
265  const uint8_t *quant_mat;
266  const uint8_t *quant_chroma_mat;
267  const uint8_t *scantable;
268 
269  void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
270  ptrdiff_t linesize, int16_t *block);
272 
273  const AVFrame *pic;
279  int pictures_per_frame; // 1 for progressive, 2 for interlaced
285  int warn;
286 
287  char *vendor;
289 
291 
292  int profile;
294 
295  int *slice_q;
296 
298 } ProresContext;
299 
300 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
301  ptrdiff_t linesize, int x, int y, int w, int h,
302  int16_t *blocks, uint16_t *emu_buf,
303  int mbs_per_slice, int blocks_per_mb, int is_chroma)
304 {
305  const uint16_t *esrc;
306  const int mb_width = 4 * blocks_per_mb;
307  ptrdiff_t elinesize;
308  int i, j, k;
309 
310  for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
311  if (x >= w) {
312  memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
313  * sizeof(*blocks));
314  return;
315  }
316  if (x + mb_width <= w && y + 16 <= h) {
317  esrc = src;
318  elinesize = linesize;
319  } else {
320  int bw, bh, pix;
321 
322  esrc = emu_buf;
323  elinesize = 16 * sizeof(*emu_buf);
324 
325  bw = FFMIN(w - x, mb_width);
326  bh = FFMIN(h - y, 16);
327 
328  for (j = 0; j < bh; j++) {
329  memcpy(emu_buf + j * 16,
330  (const uint8_t*)src + j * linesize,
331  bw * sizeof(*src));
332  pix = emu_buf[j * 16 + bw - 1];
333  for (k = bw; k < mb_width; k++)
334  emu_buf[j * 16 + k] = pix;
335  }
336  for (; j < 16; j++)
337  memcpy(emu_buf + j * 16,
338  emu_buf + (bh - 1) * 16,
339  mb_width * sizeof(*emu_buf));
340  }
341  if (!is_chroma) {
342  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
343  blocks += 64;
344  if (blocks_per_mb > 2) {
345  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
346  blocks += 64;
347  }
348  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
349  blocks += 64;
350  if (blocks_per_mb > 2) {
351  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
352  blocks += 64;
353  }
354  } else {
355  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
356  blocks += 64;
357  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
358  blocks += 64;
359  if (blocks_per_mb > 2) {
360  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
361  blocks += 64;
362  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
363  blocks += 64;
364  }
365  }
366 
367  x += mb_width;
368  }
369 }
370 
371 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
372  ptrdiff_t linesize, int x, int y, int w, int h,
373  int16_t *blocks, int mbs_per_slice, int abits)
374 {
375  const int slice_width = 16 * mbs_per_slice;
376  int i, j, copy_w, copy_h;
377 
378  copy_w = FFMIN(w - x, slice_width);
379  copy_h = FFMIN(h - y, 16);
380  for (i = 0; i < copy_h; i++) {
381  memcpy(blocks, src, copy_w * sizeof(*src));
382  if (abits == 8)
383  for (j = 0; j < copy_w; j++)
384  blocks[j] >>= 2;
385  else
386  for (j = 0; j < copy_w; j++)
387  blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
388  for (j = copy_w; j < slice_width; j++)
389  blocks[j] = blocks[copy_w - 1];
390  blocks += slice_width;
391  src += linesize >> 1;
392  }
393  for (; i < 16; i++) {
394  memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
395  blocks += slice_width;
396  }
397 }
398 
399 /**
400  * Write an unsigned rice/exp golomb codeword.
401  */
402 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
403 {
404  unsigned int rice_order, exp_order, switch_bits, switch_val;
405  int exponent;
406 
407  /* number of prefix bits to switch between Rice and expGolomb */
408  switch_bits = (codebook & 3) + 1;
409  rice_order = codebook >> 5; /* rice code order */
410  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
411 
412  switch_val = switch_bits << rice_order;
413 
414  if (val >= switch_val) {
415  val -= switch_val - (1 << exp_order);
416  exponent = av_log2(val);
417 
418  put_bits(pb, exponent - exp_order + switch_bits, 0);
419  put_bits(pb, exponent + 1, val);
420  } else {
421  exponent = val >> rice_order;
422 
423  if (exponent)
424  put_bits(pb, exponent, 0);
425  put_bits(pb, 1, 1);
426  if (rice_order)
427  put_sbits(pb, rice_order, val);
428  }
429 }
430 
431 #define GET_SIGN(x) ((x) >> 31)
432 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
433 
434 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
435  int blocks_per_slice, int scale)
436 {
437  int i;
438  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
439 
440  prev_dc = (blocks[0] - 0x4000) / scale;
442  sign = 0;
443  codebook = 3;
444  blocks += 64;
445 
446  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
447  dc = (blocks[0] - 0x4000) / scale;
448  delta = dc - prev_dc;
449  new_sign = GET_SIGN(delta);
450  delta = (delta ^ sign) - sign;
451  code = MAKE_CODE(delta);
453  codebook = (code + (code & 1)) >> 1;
454  codebook = FFMIN(codebook, 3);
455  sign = new_sign;
456  prev_dc = dc;
457  }
458 }
459 
460 static void encode_acs(PutBitContext *pb, int16_t *blocks,
461  int blocks_per_slice,
462  int plane_size_factor,
463  const uint8_t *scan, const int16_t *qmat)
464 {
465  int idx, i;
466  int run, level, run_cb, lev_cb;
467  int max_coeffs, abs_level;
468 
469  max_coeffs = blocks_per_slice << 6;
470  run_cb = prores_run_to_cb_index[4];
471  lev_cb = prores_lev_to_cb_index[2];
472  run = 0;
473 
474  for (i = 1; i < 64; i++) {
475  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
476  level = blocks[idx] / qmat[scan[i]];
477  if (level) {
478  abs_level = FFABS(level);
481  abs_level - 1);
482  put_sbits(pb, 1, GET_SIGN(level));
483 
484  run_cb = prores_run_to_cb_index[FFMIN(run, 15)];
485  lev_cb = prores_lev_to_cb_index[FFMIN(abs_level, 9)];
486  run = 0;
487  } else {
488  run++;
489  }
490  }
491  }
492 }
493 
495  const uint16_t *src, ptrdiff_t linesize,
496  int mbs_per_slice, int16_t *blocks,
497  int blocks_per_mb, int plane_size_factor,
498  const int16_t *qmat)
499 {
500  int blocks_per_slice = mbs_per_slice * blocks_per_mb;
501 
502  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
503  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
504  ctx->scantable, qmat);
505 }
506 
507 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
508 {
509  const int dbits = (abits == 8) ? 4 : 7;
510  const int dsize = 1 << dbits - 1;
511  int diff = cur - prev;
512 
513  diff = av_mod_uintp2(diff, abits);
514  if (diff >= (1 << abits) - dsize)
515  diff -= 1 << abits;
516  if (diff < -dsize || diff > dsize || !diff) {
517  put_bits(pb, 1, 1);
518  put_bits(pb, abits, diff);
519  } else {
520  put_bits(pb, 1, 0);
521  put_bits(pb, dbits - 1, FFABS(diff) - 1);
522  put_bits(pb, 1, diff < 0);
523  }
524 }
525 
526 static void put_alpha_run(PutBitContext *pb, int run)
527 {
528  if (run) {
529  put_bits(pb, 1, 0);
530  if (run < 0x10)
531  put_bits(pb, 4, run);
532  else
533  put_bits(pb, 15, run);
534  } else {
535  put_bits(pb, 1, 1);
536  }
537 }
538 
539 // todo alpha quantisation for high quants
541  int mbs_per_slice, uint16_t *blocks,
542  int quant)
543 {
544  const int abits = ctx->alpha_bits;
545  const int mask = (1 << abits) - 1;
546  const int num_coeffs = mbs_per_slice * 256;
547  int prev = mask, cur;
548  int idx = 0;
549  int run = 0;
550 
551  cur = blocks[idx++];
552  put_alpha_diff(pb, cur, prev, abits);
553  prev = cur;
554  do {
555  cur = blocks[idx++];
556  if (cur != prev) {
557  put_alpha_run (pb, run);
558  put_alpha_diff(pb, cur, prev, abits);
559  prev = cur;
560  run = 0;
561  } else {
562  run++;
563  }
564  } while (idx < num_coeffs);
565  if (run)
566  put_alpha_run(pb, run);
567 }
568 
569 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
570  PutBitContext *pb,
571  int sizes[4], int x, int y, int quant,
572  int mbs_per_slice)
573 {
574  ProresContext *ctx = avctx->priv_data;
575  int i, xp, yp;
576  int total_size = 0;
577  const uint16_t *src;
578  int slice_width_factor = av_log2(mbs_per_slice);
579  int num_cblocks, pwidth, line_add;
580  ptrdiff_t linesize;
581  int plane_factor, is_chroma;
582  uint16_t *qmat;
583  uint16_t *qmat_chroma;
584 
585  if (ctx->pictures_per_frame == 1)
586  line_add = 0;
587  else
588  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
589 
590  if (ctx->force_quant) {
591  qmat = ctx->quants[0];
592  qmat_chroma = ctx->quants_chroma[0];
593  } else if (quant < MAX_STORED_Q) {
594  qmat = ctx->quants[quant];
595  qmat_chroma = ctx->quants_chroma[quant];
596  } else {
597  qmat = ctx->custom_q;
598  qmat_chroma = ctx->custom_chroma_q;
599  for (i = 0; i < 64; i++) {
600  qmat[i] = ctx->quant_mat[i] * quant;
601  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
602  }
603  }
604 
605  for (i = 0; i < ctx->num_planes; i++) {
606  is_chroma = (i == 1 || i == 2);
607  plane_factor = slice_width_factor + 2;
608  if (is_chroma)
609  plane_factor += ctx->chroma_factor - 3;
610  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
611  xp = x << 4;
612  yp = y << 4;
613  num_cblocks = 4;
614  pwidth = avctx->width;
615  } else {
616  xp = x << 3;
617  yp = y << 4;
618  num_cblocks = 2;
619  pwidth = avctx->width >> 1;
620  }
621 
622  linesize = pic->linesize[i] * ctx->pictures_per_frame;
623  src = (const uint16_t*)(pic->data[i] + yp * linesize +
624  line_add * pic->linesize[i]) + xp;
625 
626  if (i < 3) {
627  get_slice_data(ctx, src, linesize, xp, yp,
628  pwidth, avctx->height / ctx->pictures_per_frame,
629  ctx->blocks[0], ctx->emu_buf,
630  mbs_per_slice, num_cblocks, is_chroma);
631  if (!is_chroma) {/* luma quant */
632  encode_slice_plane(ctx, pb, src, linesize,
633  mbs_per_slice, ctx->blocks[0],
634  num_cblocks, plane_factor, qmat);
635  } else { /* chroma plane */
636  encode_slice_plane(ctx, pb, src, linesize,
637  mbs_per_slice, ctx->blocks[0],
638  num_cblocks, plane_factor, qmat_chroma);
639  }
640  } else {
641  get_alpha_data(ctx, src, linesize, xp, yp,
642  pwidth, avctx->height / ctx->pictures_per_frame,
643  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
644  encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
645  }
646  flush_put_bits(pb);
647  sizes[i] = put_bytes_output(pb) - total_size;
648  total_size = put_bytes_output(pb);
649  }
650  return total_size;
651 }
652 
653 static inline int estimate_vlc(unsigned codebook, int val)
654 {
655  unsigned int rice_order, exp_order, switch_bits, switch_val;
656  int exponent;
657 
658  /* number of prefix bits to switch between Rice and expGolomb */
659  switch_bits = (codebook & 3) + 1;
660  rice_order = codebook >> 5; /* rice code order */
661  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
662 
663  switch_val = switch_bits << rice_order;
664 
665  if (val >= switch_val) {
666  val -= switch_val - (1 << exp_order);
667  exponent = av_log2(val);
668 
669  return exponent * 2 - exp_order + switch_bits + 1;
670  } else {
671  return (val >> rice_order) + rice_order + 1;
672  }
673 }
674 
675 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
676  int scale)
677 {
678  int i;
679  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
680  int bits;
681 
682  prev_dc = (blocks[0] - 0x4000) / scale;
683  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
684  sign = 0;
685  codebook = 3;
686  blocks += 64;
687  *error += FFABS(blocks[0] - 0x4000) % scale;
688 
689  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
690  dc = (blocks[0] - 0x4000) / scale;
691  *error += FFABS(blocks[0] - 0x4000) % scale;
692  delta = dc - prev_dc;
693  new_sign = GET_SIGN(delta);
694  delta = (delta ^ sign) - sign;
695  code = MAKE_CODE(delta);
697  codebook = (code + (code & 1)) >> 1;
698  codebook = FFMIN(codebook, 3);
699  sign = new_sign;
700  prev_dc = dc;
701  }
702 
703  return bits;
704 }
705 
706 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
707  int plane_size_factor,
708  const uint8_t *scan, const int16_t *qmat)
709 {
710  int idx, i;
711  int run, level, run_cb, lev_cb;
712  int max_coeffs, abs_level;
713  int bits = 0;
714 
715  max_coeffs = blocks_per_slice << 6;
716  run_cb = prores_run_to_cb_index[4];
717  lev_cb = prores_lev_to_cb_index[2];
718  run = 0;
719 
720  for (i = 1; i < 64; i++) {
721  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
722  level = blocks[idx] / qmat[scan[i]];
723  *error += FFABS(blocks[idx]) % qmat[scan[i]];
724  if (level) {
725  abs_level = FFABS(level);
728  abs_level - 1) + 1;
729 
730  run_cb = prores_run_to_cb_index[FFMIN(run, 15)];
731  lev_cb = prores_lev_to_cb_index[FFMIN(abs_level, 9)];
732  run = 0;
733  } else {
734  run++;
735  }
736  }
737  }
738 
739  return bits;
740 }
741 
742 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
743  const uint16_t *src, ptrdiff_t linesize,
744  int mbs_per_slice,
745  int blocks_per_mb, int plane_size_factor,
746  const int16_t *qmat, ProresThreadData *td)
747 {
748  int blocks_per_slice;
749  int bits;
750 
751  blocks_per_slice = mbs_per_slice * blocks_per_mb;
752 
753  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
754  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
755  plane_size_factor, ctx->scantable, qmat);
756 
757  return FFALIGN(bits, 8);
758 }
759 
760 static int est_alpha_diff(int cur, int prev, int abits)
761 {
762  const int dbits = (abits == 8) ? 4 : 7;
763  const int dsize = 1 << dbits - 1;
764  int diff = cur - prev;
765 
766  diff = av_mod_uintp2(diff, abits);
767  if (diff >= (1 << abits) - dsize)
768  diff -= 1 << abits;
769  if (diff < -dsize || diff > dsize || !diff)
770  return abits + 1;
771  else
772  return dbits + 1;
773 }
774 
776  const uint16_t *src, ptrdiff_t linesize,
777  int mbs_per_slice, int16_t *blocks)
778 {
779  const int abits = ctx->alpha_bits;
780  const int mask = (1 << abits) - 1;
781  const int num_coeffs = mbs_per_slice * 256;
782  int prev = mask, cur;
783  int idx = 0;
784  int run = 0;
785  int bits;
786 
787  cur = blocks[idx++];
788  bits = est_alpha_diff(cur, prev, abits);
789  prev = cur;
790  do {
791  cur = blocks[idx++];
792  if (cur != prev) {
793  if (!run)
794  bits++;
795  else if (run < 0x10)
796  bits += 4;
797  else
798  bits += 15;
799  bits += est_alpha_diff(cur, prev, abits);
800  prev = cur;
801  run = 0;
802  } else {
803  run++;
804  }
805  } while (idx < num_coeffs);
806 
807  if (run) {
808  if (run < 0x10)
809  bits += 4;
810  else
811  bits += 15;
812  }
813 
814  return bits;
815 }
816 
818  int trellis_node, int x, int y, int mbs_per_slice,
820 {
821  ProresContext *ctx = avctx->priv_data;
822  int i, q, pq, xp, yp;
823  const uint16_t *src;
824  int slice_width_factor = av_log2(mbs_per_slice);
825  int num_cblocks[MAX_PLANES], pwidth;
826  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
827  const int min_quant = ctx->profile_info->min_quant;
828  const int max_quant = ctx->profile_info->max_quant;
829  int error, bits, bits_limit;
830  int mbs, prev, cur, new_score;
831  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
832  int overquant;
833  uint16_t *qmat;
834  uint16_t *qmat_chroma;
835  int linesize[4], line_add;
836  int alpha_bits = 0;
837 
838  if (ctx->pictures_per_frame == 1)
839  line_add = 0;
840  else
841  line_add = ctx->cur_picture_idx ^ !ctx->pic->top_field_first;
842  mbs = x + mbs_per_slice;
843 
844  for (i = 0; i < ctx->num_planes; i++) {
845  is_chroma[i] = (i == 1 || i == 2);
846  plane_factor[i] = slice_width_factor + 2;
847  if (is_chroma[i])
848  plane_factor[i] += ctx->chroma_factor - 3;
849  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
850  xp = x << 4;
851  yp = y << 4;
852  num_cblocks[i] = 4;
853  pwidth = avctx->width;
854  } else {
855  xp = x << 3;
856  yp = y << 4;
857  num_cblocks[i] = 2;
858  pwidth = avctx->width >> 1;
859  }
860 
861  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
862  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
863  line_add * ctx->pic->linesize[i]) + xp;
864 
865  if (i < 3) {
866  get_slice_data(ctx, src, linesize[i], xp, yp,
867  pwidth, avctx->height / ctx->pictures_per_frame,
868  td->blocks[i], td->emu_buf,
869  mbs_per_slice, num_cblocks[i], is_chroma[i]);
870  } else {
871  get_alpha_data(ctx, src, linesize[i], xp, yp,
872  pwidth, avctx->height / ctx->pictures_per_frame,
873  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
874  }
875  }
876 
877  for (q = min_quant; q < max_quant + 2; q++) {
878  td->nodes[trellis_node + q].prev_node = -1;
879  td->nodes[trellis_node + q].quant = q;
880  }
881 
882  if (ctx->alpha_bits)
883  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
884  mbs_per_slice, td->blocks[3]);
885  // todo: maybe perform coarser quantising to fit into frame size when needed
886  for (q = min_quant; q <= max_quant; q++) {
887  bits = alpha_bits;
888  error = 0;
890  src, linesize[0],
891  mbs_per_slice,
892  num_cblocks[0], plane_factor[0],
893  ctx->quants[q], td); /* estimate luma plane */
894  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
896  src, linesize[i],
897  mbs_per_slice,
898  num_cblocks[i], plane_factor[i],
899  ctx->quants_chroma[q], td);
900  }
901  if (bits > 65000 * 8)
902  error = SCORE_LIMIT;
903 
904  slice_bits[q] = bits;
905  slice_score[q] = error;
906  }
907  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
908  slice_bits[max_quant + 1] = slice_bits[max_quant];
909  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
910  overquant = max_quant;
911  } else {
912  for (q = max_quant + 1; q < 128; q++) {
913  bits = alpha_bits;
914  error = 0;
915  if (q < MAX_STORED_Q) {
916  qmat = ctx->quants[q];
917  qmat_chroma = ctx->quants_chroma[q];
918  } else {
919  qmat = td->custom_q;
920  qmat_chroma = td->custom_chroma_q;
921  for (i = 0; i < 64; i++) {
922  qmat[i] = ctx->quant_mat[i] * q;
923  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
924  }
925  }
927  src, linesize[0],
928  mbs_per_slice,
929  num_cblocks[0], plane_factor[0],
930  qmat, td);/* estimate luma plane */
931  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
933  src, linesize[i],
934  mbs_per_slice,
935  num_cblocks[i], plane_factor[i],
936  qmat_chroma, td);
937  }
938  if (bits <= ctx->bits_per_mb * mbs_per_slice)
939  break;
940  }
941 
942  slice_bits[max_quant + 1] = bits;
943  slice_score[max_quant + 1] = error;
944  overquant = q;
945  }
946  td->nodes[trellis_node + max_quant + 1].quant = overquant;
947 
948  bits_limit = mbs * ctx->bits_per_mb;
949  for (pq = min_quant; pq < max_quant + 2; pq++) {
950  prev = trellis_node - TRELLIS_WIDTH + pq;
951 
952  for (q = min_quant; q < max_quant + 2; q++) {
953  cur = trellis_node + q;
954 
955  bits = td->nodes[prev].bits + slice_bits[q];
956  error = slice_score[q];
957  if (bits > bits_limit)
958  error = SCORE_LIMIT;
959 
960  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
961  new_score = td->nodes[prev].score + error;
962  else
963  new_score = SCORE_LIMIT;
964  if (td->nodes[cur].prev_node == -1 ||
965  td->nodes[cur].score >= new_score) {
966 
967  td->nodes[cur].bits = bits;
968  td->nodes[cur].score = new_score;
969  td->nodes[cur].prev_node = prev;
970  }
971  }
972  }
973 
974  error = td->nodes[trellis_node + min_quant].score;
975  pq = trellis_node + min_quant;
976  for (q = min_quant + 1; q < max_quant + 2; q++) {
977  if (td->nodes[trellis_node + q].score <= error) {
978  error = td->nodes[trellis_node + q].score;
979  pq = trellis_node + q;
980  }
981  }
982 
983  return pq;
984 }
985 
986 static int find_quant_thread(AVCodecContext *avctx, void *arg,
987  int jobnr, int threadnr)
988 {
989  ProresContext *ctx = avctx->priv_data;
990  ProresThreadData *td = ctx->tdata + threadnr;
991  int mbs_per_slice = ctx->mbs_per_slice;
992  int x, y = jobnr, mb, q = 0;
993 
994  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
995  while (ctx->mb_width - x < mbs_per_slice)
996  mbs_per_slice >>= 1;
997  q = find_slice_quant(avctx,
998  (mb + 1) * TRELLIS_WIDTH, x, y,
999  mbs_per_slice, td);
1000  }
1001 
1002  for (x = ctx->slices_width - 1; x >= 0; x--) {
1003  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
1004  q = td->nodes[q].prev_node;
1005  }
1006 
1007  return 0;
1008 }
1009 
1011  const AVFrame *pic, int *got_packet)
1012 {
1013  ProresContext *ctx = avctx->priv_data;
1014  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
1015  uint8_t *picture_size_pos;
1016  PutBitContext pb;
1017  int x, y, i, mb, q = 0;
1018  int sizes[4] = { 0 };
1019  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
1020  int frame_size, picture_size, slice_size;
1021  int pkt_size, ret;
1022  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
1023  uint8_t frame_flags;
1024 
1025  ctx->pic = pic;
1026  pkt_size = ctx->frame_size_upper_bound;
1027 
1028  if ((ret = ff_alloc_packet(avctx, pkt, pkt_size + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1029  return ret;
1030 
1031  orig_buf = pkt->data;
1032 
1033  // frame atom
1034  orig_buf += 4; // frame size
1035  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
1036  buf = orig_buf;
1037 
1038  // frame header
1039  tmp = buf;
1040  buf += 2; // frame header size will be stored here
1041  bytestream_put_be16 (&buf, 0); // version 1
1042  bytestream_put_buffer(&buf, ctx->vendor, 4);
1043  bytestream_put_be16 (&buf, avctx->width);
1044  bytestream_put_be16 (&buf, avctx->height);
1045 
1046  frame_flags = ctx->chroma_factor << 6;
1047  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1048  frame_flags |= pic->top_field_first ? 0x04 : 0x08;
1049  bytestream_put_byte (&buf, frame_flags);
1050 
1051  bytestream_put_byte (&buf, 0); // reserved
1052  bytestream_put_byte (&buf, pic->color_primaries);
1053  bytestream_put_byte (&buf, pic->color_trc);
1054  bytestream_put_byte (&buf, pic->colorspace);
1055  bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
1056  bytestream_put_byte (&buf, 0); // reserved
1057  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1058  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1059  // luma quantisation matrix
1060  for (i = 0; i < 64; i++)
1061  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1062  // chroma quantisation matrix
1063  for (i = 0; i < 64; i++)
1064  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1065  } else {
1066  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1067  }
1068  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1069 
1070  for (ctx->cur_picture_idx = 0;
1071  ctx->cur_picture_idx < ctx->pictures_per_frame;
1072  ctx->cur_picture_idx++) {
1073  // picture header
1074  picture_size_pos = buf + 1;
1075  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1076  buf += 4; // picture data size will be stored here
1077  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1078  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1079 
1080  // seek table - will be filled during slice encoding
1081  slice_sizes = buf;
1082  buf += ctx->slices_per_picture * 2;
1083 
1084  // slices
1085  if (!ctx->force_quant) {
1086  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1087  ctx->mb_height);
1088  if (ret)
1089  return ret;
1090  }
1091 
1092  for (y = 0; y < ctx->mb_height; y++) {
1093  int mbs_per_slice = ctx->mbs_per_slice;
1094  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1095  q = ctx->force_quant ? ctx->force_quant
1096  : ctx->slice_q[mb + y * ctx->slices_width];
1097 
1098  while (ctx->mb_width - x < mbs_per_slice)
1099  mbs_per_slice >>= 1;
1100 
1101  bytestream_put_byte(&buf, slice_hdr_size << 3);
1102  slice_hdr = buf;
1103  buf += slice_hdr_size - 1;
1104  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1105  uint8_t *start = pkt->data;
1106  // Recompute new size according to max_slice_size
1107  // and deduce delta
1108  int delta = 200 + (ctx->pictures_per_frame *
1109  ctx->slices_per_picture + 1) *
1110  max_slice_size - pkt_size;
1111 
1112  delta = FFMAX(delta, 2 * max_slice_size);
1113  ctx->frame_size_upper_bound += delta;
1114 
1115  if (!ctx->warn) {
1116  avpriv_request_sample(avctx,
1117  "Packet too small: is %i,"
1118  " needs %i (slice: %i). "
1119  "Correct allocation",
1120  pkt_size, delta, max_slice_size);
1121  ctx->warn = 1;
1122  }
1123 
1125  if (ret < 0)
1126  return ret;
1127 
1128  pkt_size += delta;
1129  // restore pointers
1130  orig_buf = pkt->data + (orig_buf - start);
1131  buf = pkt->data + (buf - start);
1132  picture_size_pos = pkt->data + (picture_size_pos - start);
1133  slice_sizes = pkt->data + (slice_sizes - start);
1134  slice_hdr = pkt->data + (slice_hdr - start);
1135  tmp = pkt->data + (tmp - start);
1136  }
1137  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1138  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1139  mbs_per_slice);
1140  if (ret < 0)
1141  return ret;
1142 
1143  bytestream_put_byte(&slice_hdr, q);
1144  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1145  for (i = 0; i < ctx->num_planes - 1; i++) {
1146  bytestream_put_be16(&slice_hdr, sizes[i]);
1147  slice_size += sizes[i];
1148  }
1149  bytestream_put_be16(&slice_sizes, slice_size);
1150  buf += slice_size - slice_hdr_size;
1151  if (max_slice_size < slice_size)
1152  max_slice_size = slice_size;
1153  }
1154  }
1155 
1156  picture_size = buf - (picture_size_pos - 1);
1157  bytestream_put_be32(&picture_size_pos, picture_size);
1158  }
1159 
1160  orig_buf -= 8;
1161  frame_size = buf - orig_buf;
1162  bytestream_put_be32(&orig_buf, frame_size);
1163 
1164  pkt->size = frame_size;
1165  *got_packet = 1;
1166 
1167  return 0;
1168 }
1169 
1171 {
1172  ProresContext *ctx = avctx->priv_data;
1173  int i;
1174 
1175  if (ctx->tdata) {
1176  for (i = 0; i < avctx->thread_count; i++)
1177  av_freep(&ctx->tdata[i].nodes);
1178  }
1179  av_freep(&ctx->tdata);
1180  av_freep(&ctx->slice_q);
1181 
1182  return 0;
1183 }
1184 
1185 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1186  ptrdiff_t linesize, int16_t *block)
1187 {
1188  int x, y;
1189  const uint16_t *tsrc = src;
1190 
1191  for (y = 0; y < 8; y++) {
1192  for (x = 0; x < 8; x++)
1193  block[y * 8 + x] = tsrc[x];
1194  tsrc += linesize >> 1;
1195  }
1196  fdsp->fdct(block);
1197 }
1198 
1200 {
1201  ProresContext *ctx = avctx->priv_data;
1202  int mps;
1203  int i, j;
1204  int min_quant, max_quant;
1205  int interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
1206 
1207  avctx->bits_per_raw_sample = 10;
1208 
1209  ctx->fdct = prores_fdct;
1212  ff_fdctdsp_init(&ctx->fdsp, avctx);
1213 
1214  mps = ctx->mbs_per_slice;
1215  if (mps & (mps - 1)) {
1216  av_log(avctx, AV_LOG_ERROR,
1217  "there should be an integer power of two MBs per slice\n");
1218  return AVERROR(EINVAL);
1219  }
1220  if (ctx->profile == PRORES_PROFILE_AUTO) {
1222  ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1223  !(desc->log2_chroma_w + desc->log2_chroma_h))
1225  av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1226  "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1227  ? "4:4:4:4 profile because of the used input colorspace"
1228  : "HQ profile to keep best quality");
1229  }
1231  if (ctx->profile != PRORES_PROFILE_4444 &&
1232  ctx->profile != PRORES_PROFILE_4444XQ) {
1233  // force alpha and warn
1234  av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1235  "encode alpha. Override with -profile if needed.\n");
1236  ctx->alpha_bits = 0;
1237  }
1238  if (ctx->alpha_bits & 7) {
1239  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1240  return AVERROR(EINVAL);
1241  }
1242  avctx->bits_per_coded_sample = 32;
1243  } else {
1244  ctx->alpha_bits = 0;
1245  }
1246 
1247  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1248  ? CFACTOR_Y422
1249  : CFACTOR_Y444;
1250  ctx->profile_info = prores_profile_info + ctx->profile;
1251  ctx->num_planes = 3 + !!ctx->alpha_bits;
1252 
1253  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1254 
1255  if (interlaced)
1256  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1257  else
1258  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1259 
1260  ctx->slices_width = ctx->mb_width / mps;
1261  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1262  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1263  ctx->pictures_per_frame = 1 + interlaced;
1264 
1265  if (ctx->quant_sel == -1) {
1266  ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1267  ctx->quant_chroma_mat = prores_quant_matrices[ctx->profile_info->quant_chroma];
1268  } else {
1269  ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1270  ctx->quant_chroma_mat = prores_quant_matrices[ctx->quant_sel];
1271  }
1272 
1273  if (strlen(ctx->vendor) != 4) {
1274  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1275  return AVERROR_INVALIDDATA;
1276  }
1277 
1278  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1279  if (!ctx->force_quant) {
1280  if (!ctx->bits_per_mb) {
1281  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1282  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1283  ctx->pictures_per_frame)
1284  break;
1285  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1286  if (ctx->alpha_bits)
1287  ctx->bits_per_mb *= 20;
1288  } else if (ctx->bits_per_mb < 128) {
1289  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1290  return AVERROR_INVALIDDATA;
1291  }
1292 
1293  min_quant = ctx->profile_info->min_quant;
1294  max_quant = ctx->profile_info->max_quant;
1295  for (i = min_quant; i < MAX_STORED_Q; i++) {
1296  for (j = 0; j < 64; j++) {
1297  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1298  ctx->quants_chroma[i][j] = ctx->quant_chroma_mat[j] * i;
1299  }
1300  }
1301 
1302  ctx->slice_q = av_malloc_array(ctx->slices_per_picture, sizeof(*ctx->slice_q));
1303  if (!ctx->slice_q)
1304  return AVERROR(ENOMEM);
1305 
1306  ctx->tdata = av_calloc(avctx->thread_count, sizeof(*ctx->tdata));
1307  if (!ctx->tdata)
1308  return AVERROR(ENOMEM);
1309 
1310  for (j = 0; j < avctx->thread_count; j++) {
1311  ctx->tdata[j].nodes = av_malloc_array(ctx->slices_width + 1,
1313  * sizeof(*ctx->tdata->nodes));
1314  if (!ctx->tdata[j].nodes)
1315  return AVERROR(ENOMEM);
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 },
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" }, 0, 0, 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 
1423  .p.name = "prores_ks",
1424  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
1425  .p.type = AVMEDIA_TYPE_VIDEO,
1426  .p.id = AV_CODEC_ID_PRORES,
1427  .priv_data_size = sizeof(ProresContext),
1428  .init = encode_init,
1429  .close = encode_close,
1432  .p.pix_fmts = (const enum AVPixelFormat[]) {
1435  },
1436  .p.priv_class = &proresenc_class,
1438  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1439 };
PRORES_PROFILE_PROXY
@ PRORES_PROFILE_PROXY
Definition: proresenc_kostya.c:47
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
ProresContext::force_quant
int force_quant
Definition: proresenc_kostya.c:283
ProresContext::quant_chroma_mat
const uint8_t * quant_chroma_mat
Definition: proresenc_kostya.c:266
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:582
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:675
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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
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:434
ProresContext::fdsp
FDCTDSPContext fdsp
Definition: proresenc_anatoliy.c:184
mem_internal.h
PRORES_PROFILE_AUTO
@ PRORES_PROFILE_AUTO
Definition: proresenc_kostya.c:46
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:431
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: proresenc_kostya.c:1010
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:159
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2858
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:120
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:580
ProresContext::quants_chroma
int16_t quants_chroma[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:262
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:122
ProresContext::vendor
char * vendor
Definition: proresenc_anatoliy.c:198
prores_profile::tag
uint32_t tag
Definition: proresenc_kostya.c:174
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:589
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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:221
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:540
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_prores_ks_encoder
const FFCodec ff_prores_ks_encoder
Definition: proresenc_kostya.c:1422
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:482
AVOption
AVOption.
Definition: opt.h:251
ProresContext::slices_width
int slices_width
Definition: proresenc_kostya.c:277
encode.h
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdata.h:33
ProresContext::alpha_bits
int alpha_bits
Definition: proresenc_kostya.c:284
ProresContext
Definition: proresdec.h:38
FFCodec
Definition: codec_internal.h:119
PRORES_PROFILE_HQ
@ PRORES_PROFILE_HQ
Definition: proresenc_kostya.c:50
ProresContext::num_planes
int num_planes
Definition: proresenc_kostya.c:281
ProresContext::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:260
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ProresThreadData::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:251
av_popcount
#define av_popcount
Definition: common.h:149
SCORE_LIMIT
#define SCORE_LIMIT
Definition: proresenc_kostya.c:238
put_alpha_run
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc_kostya.c:526
ff_prores_progressive_scan
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
prores_quant_matrices
static const uint8_t prores_quant_matrices[][64]
Definition: proresenc_kostya.c:65
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
prores_fdct
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
Definition: proresenc_kostya.c:1185
ProresContext::profile_info
const struct prores_profile * profile_info
Definition: proresenc_kostya.c:293
FDCTDSPContext
Definition: fdctdsp.h:26
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
QUANT_MAT_HQ
@ QUANT_MAT_HQ
Definition: proresenc_kostya.c:60
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1466
ProresContext::slice_q
int * slice_q
Definition: proresenc_kostya.c:295
ProresContext::mbs_per_slice
int mbs_per_slice
Definition: proresenc_kostya.c:275
TrellisNode
Definition: adpcmenc.c:60
prores_mb_limits
static const int prores_mb_limits[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:165
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
ProresContext::custom_chroma_q
int16_t custom_chroma_q[64]
Definition: proresenc_kostya.c:264
val
static double val(void *priv, double ch)
Definition: aeval.c:77
put_alpha_diff
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
Definition: proresenc_kostya.c:507
CFACTOR_Y422
#define CFACTOR_Y422
Definition: proresenc_kostya.c:38
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:775
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:307
ProresThreadData::nodes
struct TrellisNode * nodes
Definition: proresenc_kostya.c:254
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:276
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:462
prores_profile::max_quant
int max_quant
Definition: proresenc_kostya.c:176
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
prores_dc_codebook
static const uint8_t prores_dc_codebook[4]
Definition: proresenc_kostya.c:138
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
QUANT_MAT_PROXY_CHROMA
@ QUANT_MAT_PROXY_CHROMA
Definition: proresenc_kostya.c:57
ProresThreadData::custom_chroma_q
int16_t custom_chroma_q[64]
Definition: proresenc_kostya.c:253
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:464
frame_size
int frame_size
Definition: mxfenc.c:2202
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
ProresThreadData::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:252
QUANT_MAT_STANDARD
@ QUANT_MAT_STANDARD
Definition: proresenc_kostya.c:59
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:1451
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:282
ProresContext::quants
int16_t quants[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:261
ProresContext::profile
int profile
Definition: proresenc_kostya.c:292
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:191
TrellisNode::prev_node
int prev_node
Definition: proresenc_kostya.c:241
prores_profile::min_quant
int min_quant
Definition: proresenc_kostya.c:175
prores_profile::full_name
const char * full_name
Definition: proresenc_kostya.c:173
TrellisNode::quant
int quant
Definition: proresenc_kostya.c:242
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:986
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
ProresContext::mb_width
int mb_width
Definition: proresenc_kostya.c:274
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:64
ProresContext::pictures_per_frame
int pictures_per_frame
Definition: proresenc_kostya.c:279
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
MAX_MBS_PER_SLICE
#define MAX_MBS_PER_SLICE
Definition: proresenc_kostya.c:41
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:57
ProresContext::pic
const AVFrame * pic
Definition: proresenc_kostya.c:273
MAX_STORED_Q
#define MAX_STORED_Q
Definition: proresenc_kostya.c:247
run
uint8_t run
Definition: svq3.c:203
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1199
QUANT_MAT_XQ_LUMA
@ QUANT_MAT_XQ_LUMA
Definition: proresenc_kostya.c:61
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:817
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
ProresContext::tdata
ProresThreadData * tdata
Definition: proresenc_kostya.c:297
ProresContext::quant_sel
int quant_sel
Definition: proresenc_kostya.c:288
PRORES_PROFILE_STANDARD
@ PRORES_PROFILE_STANDARD
Definition: proresenc_kostya.c:49
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:259
PRORES_PROFILE_LT
@ PRORES_PROFILE_LT
Definition: proresenc_kostya.c:48
prores_profile::br_tab
int br_tab[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:177
CFACTOR_Y444
#define CFACTOR_Y444
Definition: proresenc_kostya.c:39
PRORES_PROFILE_4444XQ
@ PRORES_PROFILE_4444XQ
Definition: proresenc_kostya.c:52
ProresContext::chroma_factor
int chroma_factor
Definition: proresenc_kostya.c:276
AVPacket::size
int size
Definition: packet.h:375
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:115
ProresContext::scantable
const uint8_t * scantable
Definition: proresenc_anatoliy.c:192
ProresContext::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:263
codec_internal.h
prores_lev_to_cb_index
static const uint8_t prores_lev_to_cb_index[10]
Definition: proresenc_kostya.c:162
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:742
TrellisNode::bits
int bits
Definition: proresenc_kostya.c:243
proresdata.h
MAKE_CODE
#define MAKE_CODE(x)
Definition: proresenc_kostya.c:432
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:498
QUANT_MAT_LT
@ QUANT_MAT_LT
Definition: proresenc_kostya.c:58
mb
#define mb
Definition: vf_colormatrix.c:101
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
OFFSET
#define OFFSET(x)
Definition: proresenc_kostya.c:1369
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1444
options
static const AVOption options[]
Definition: proresenc_kostya.c:1372
interlaced
uint8_t interlaced
Definition: mxfenc.c:2043
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
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:371
prores_profile
Definition: proresenc_kostya.c:172
TRELLIS_WIDTH
#define TRELLIS_WIDTH
Definition: proresenc_kostya.c:237
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
MAX_PLANES
#define MAX_PLANES
Definition: proresenc_kostya.c:43
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
prores_ac_codebook
static const uint8_t prores_ac_codebook[7]
Definition: proresenc_kostya.c:145
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:300
ProresContext::frame_size_upper_bound
int frame_size_upper_bound
Definition: proresenc_kostya.c:290
ProresThreadData::blocks
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
Definition: proresenc_kostya.c:250
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:276
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:760
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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:706
profile
int profile
Definition: mxfenc.c:2006
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
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:71
prores_profile::quant
int quant
Definition: proresenc_kostya.c:178
ProresContext::quant_mat
const uint8_t * quant_mat
Definition: proresenc_kostya.c:265
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, int plane_size_factor, const int16_t *qmat)
Definition: proresenc_kostya.c:494
prores_profile::quant_chroma
int quant_chroma
Definition: proresenc_kostya.c:179
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ProresContext::slices_per_picture
int slices_per_picture
Definition: proresenc_kostya.c:278
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
TrellisNode::score
int score
Definition: proresenc_kostya.c:244
QUANT_MAT_DEFAULT
@ QUANT_MAT_DEFAULT
Definition: proresenc_kostya.c:62
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:460
desc
const char * desc
Definition: libsvtav1.c:83
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:164
FDCTDSPContext::fdct
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
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:653
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
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
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:569
PRORES_PROFILE_4444
@ PRORES_PROFILE_4444
Definition: proresenc_kostya.c:51
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:402
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:1370
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
ProresThreadData
Definition: proresenc_kostya.c:249
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
QUANT_MAT_PROXY
@ QUANT_MAT_PROXY
Definition: proresenc_kostya.c:56
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:269
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ProresContext::cur_picture_idx
int cur_picture_idx
Definition: proresenc_kostya.c:280
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
put_bits.h
ProresContext::warn
int warn
Definition: proresenc_kostya.c:285
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
prores_run_to_cb_index
static const uint8_t prores_run_to_cb_index[16]
Lookup tables for adaptive switching between codebooks according with previous run/level value.
Definition: proresenc_kostya.c:159
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:1536
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:35
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1170
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:48