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