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 "encode.h"
31 #include "fdctdsp.h"
32 #include "put_bits.h"
33 #include "profiles.h"
34 #include "bytestream.h"
35 #include "internal.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 #define NUM_MB_LIMITS 4
139 static const int prores_mb_limits[NUM_MB_LIMITS] = {
140  1620, // up to 720x576
141  2700, // up to 960x720
142  6075, // up to 1440x1080
143  9216, // up to 2048x1152
144 };
145 
146 static const struct prores_profile {
147  const char *full_name;
148  uint32_t tag;
152  int quant;
154 } prores_profile_info[6] = {
155  {
156  .full_name = "proxy",
157  .tag = MKTAG('a', 'p', 'c', 'o'),
158  .min_quant = 4,
159  .max_quant = 8,
160  .br_tab = { 300, 242, 220, 194 },
161  .quant = QUANT_MAT_PROXY,
162  .quant_chroma = QUANT_MAT_PROXY_CHROMA,
163  },
164  {
165  .full_name = "LT",
166  .tag = MKTAG('a', 'p', 'c', 's'),
167  .min_quant = 1,
168  .max_quant = 9,
169  .br_tab = { 720, 560, 490, 440 },
170  .quant = QUANT_MAT_LT,
171  .quant_chroma = QUANT_MAT_LT,
172  },
173  {
174  .full_name = "standard",
175  .tag = MKTAG('a', 'p', 'c', 'n'),
176  .min_quant = 1,
177  .max_quant = 6,
178  .br_tab = { 1050, 808, 710, 632 },
179  .quant = QUANT_MAT_STANDARD,
180  .quant_chroma = QUANT_MAT_STANDARD,
181  },
182  {
183  .full_name = "high quality",
184  .tag = MKTAG('a', 'p', 'c', 'h'),
185  .min_quant = 1,
186  .max_quant = 6,
187  .br_tab = { 1566, 1216, 1070, 950 },
188  .quant = QUANT_MAT_HQ,
189  .quant_chroma = QUANT_MAT_HQ,
190  },
191  {
192  .full_name = "4444",
193  .tag = MKTAG('a', 'p', '4', 'h'),
194  .min_quant = 1,
195  .max_quant = 6,
196  .br_tab = { 2350, 1828, 1600, 1425 },
197  .quant = QUANT_MAT_HQ,
198  .quant_chroma = QUANT_MAT_HQ,
199  },
200  {
201  .full_name = "4444XQ",
202  .tag = MKTAG('a', 'p', '4', 'x'),
203  .min_quant = 1,
204  .max_quant = 6,
205  .br_tab = { 3525, 2742, 2400, 2137 },
206  .quant = QUANT_MAT_HQ, /* Fix me : use QUANT_MAT_XQ_LUMA */
207  .quant_chroma = QUANT_MAT_HQ,
208  }
209 };
210 
211 #define TRELLIS_WIDTH 16
212 #define SCORE_LIMIT INT_MAX / 2
213 
214 struct TrellisNode {
216  int quant;
217  int bits;
218  int score;
219 };
220 
221 #define MAX_STORED_Q 16
222 
223 typedef struct ProresThreadData {
225  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
226  int16_t custom_q[64];
227  int16_t custom_chroma_q[64];
230 
231 typedef struct ProresContext {
232  AVClass *class;
234  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
235  int16_t quants[MAX_STORED_Q][64];
237  int16_t custom_q[64];
238  int16_t custom_chroma_q[64];
239  const uint8_t *quant_mat;
240  const uint8_t *quant_chroma_mat;
241  const uint8_t *scantable;
242 
243  void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
244  ptrdiff_t linesize, int16_t *block);
246 
247  const AVFrame *pic;
253  int pictures_per_frame; // 1 for progressive, 2 for interlaced
259  int warn;
260 
261  char *vendor;
263 
265 
266  int profile;
268 
269  int *slice_q;
270 
272 } ProresContext;
273 
274 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
275  ptrdiff_t linesize, int x, int y, int w, int h,
276  int16_t *blocks, uint16_t *emu_buf,
277  int mbs_per_slice, int blocks_per_mb, int is_chroma)
278 {
279  const uint16_t *esrc;
280  const int mb_width = 4 * blocks_per_mb;
281  ptrdiff_t elinesize;
282  int i, j, k;
283 
284  for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
285  if (x >= w) {
286  memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
287  * sizeof(*blocks));
288  return;
289  }
290  if (x + mb_width <= w && y + 16 <= h) {
291  esrc = src;
292  elinesize = linesize;
293  } else {
294  int bw, bh, pix;
295 
296  esrc = emu_buf;
297  elinesize = 16 * sizeof(*emu_buf);
298 
299  bw = FFMIN(w - x, mb_width);
300  bh = FFMIN(h - y, 16);
301 
302  for (j = 0; j < bh; j++) {
303  memcpy(emu_buf + j * 16,
304  (const uint8_t*)src + j * linesize,
305  bw * sizeof(*src));
306  pix = emu_buf[j * 16 + bw - 1];
307  for (k = bw; k < mb_width; k++)
308  emu_buf[j * 16 + k] = pix;
309  }
310  for (; j < 16; j++)
311  memcpy(emu_buf + j * 16,
312  emu_buf + (bh - 1) * 16,
313  mb_width * sizeof(*emu_buf));
314  }
315  if (!is_chroma) {
316  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
317  blocks += 64;
318  if (blocks_per_mb > 2) {
319  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
320  blocks += 64;
321  }
322  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
323  blocks += 64;
324  if (blocks_per_mb > 2) {
325  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
326  blocks += 64;
327  }
328  } else {
329  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
330  blocks += 64;
331  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
332  blocks += 64;
333  if (blocks_per_mb > 2) {
334  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
335  blocks += 64;
336  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
337  blocks += 64;
338  }
339  }
340 
341  x += mb_width;
342  }
343 }
344 
345 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
346  ptrdiff_t linesize, int x, int y, int w, int h,
347  int16_t *blocks, int mbs_per_slice, int abits)
348 {
349  const int slice_width = 16 * mbs_per_slice;
350  int i, j, copy_w, copy_h;
351 
352  copy_w = FFMIN(w - x, slice_width);
353  copy_h = FFMIN(h - y, 16);
354  for (i = 0; i < copy_h; i++) {
355  memcpy(blocks, src, copy_w * sizeof(*src));
356  if (abits == 8)
357  for (j = 0; j < copy_w; j++)
358  blocks[j] >>= 2;
359  else
360  for (j = 0; j < copy_w; j++)
361  blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
362  for (j = copy_w; j < slice_width; j++)
363  blocks[j] = blocks[copy_w - 1];
364  blocks += slice_width;
365  src += linesize >> 1;
366  }
367  for (; i < 16; i++) {
368  memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
369  blocks += slice_width;
370  }
371 }
372 
373 /**
374  * Write an unsigned rice/exp golomb codeword.
375  */
376 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
377 {
378  unsigned int rice_order, exp_order, switch_bits, switch_val;
379  int exponent;
380 
381  /* number of prefix bits to switch between Rice and expGolomb */
382  switch_bits = (codebook & 3) + 1;
383  rice_order = codebook >> 5; /* rice code order */
384  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
385 
386  switch_val = switch_bits << rice_order;
387 
388  if (val >= switch_val) {
389  val -= switch_val - (1 << exp_order);
390  exponent = av_log2(val);
391 
392  put_bits(pb, exponent - exp_order + switch_bits, 0);
393  put_bits(pb, exponent + 1, val);
394  } else {
395  exponent = val >> rice_order;
396 
397  if (exponent)
398  put_bits(pb, exponent, 0);
399  put_bits(pb, 1, 1);
400  if (rice_order)
401  put_sbits(pb, rice_order, val);
402  }
403 }
404 
405 #define GET_SIGN(x) ((x) >> 31)
406 #define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
407 
408 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
409  int blocks_per_slice, int scale)
410 {
411  int i;
412  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
413 
414  prev_dc = (blocks[0] - 0x4000) / scale;
416  sign = 0;
417  codebook = 3;
418  blocks += 64;
419 
420  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
421  dc = (blocks[0] - 0x4000) / scale;
422  delta = dc - prev_dc;
423  new_sign = GET_SIGN(delta);
424  delta = (delta ^ sign) - sign;
425  code = MAKE_CODE(delta);
427  codebook = (code + (code & 1)) >> 1;
428  codebook = FFMIN(codebook, 3);
429  sign = new_sign;
430  prev_dc = dc;
431  }
432 }
433 
434 static void encode_acs(PutBitContext *pb, int16_t *blocks,
435  int blocks_per_slice,
436  int plane_size_factor,
437  const uint8_t *scan, const int16_t *qmat)
438 {
439  int idx, i;
440  int run, level, run_cb, lev_cb;
441  int max_coeffs, abs_level;
442 
443  max_coeffs = blocks_per_slice << 6;
444  run_cb = ff_prores_run_to_cb_index[4];
445  lev_cb = ff_prores_lev_to_cb_index[2];
446  run = 0;
447 
448  for (i = 1; i < 64; i++) {
449  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
450  level = blocks[idx] / qmat[scan[i]];
451  if (level) {
452  abs_level = FFABS(level);
455  abs_level - 1);
456  put_sbits(pb, 1, GET_SIGN(level));
457 
458  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
459  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
460  run = 0;
461  } else {
462  run++;
463  }
464  }
465  }
466 }
467 
469  const uint16_t *src, ptrdiff_t linesize,
470  int mbs_per_slice, int16_t *blocks,
471  int blocks_per_mb, int plane_size_factor,
472  const int16_t *qmat)
473 {
474  int blocks_per_slice = mbs_per_slice * blocks_per_mb;
475 
476  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
477  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
478  ctx->scantable, qmat);
479 }
480 
481 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
482 {
483  const int dbits = (abits == 8) ? 4 : 7;
484  const int dsize = 1 << dbits - 1;
485  int diff = cur - prev;
486 
487  diff = av_mod_uintp2(diff, abits);
488  if (diff >= (1 << abits) - dsize)
489  diff -= 1 << abits;
490  if (diff < -dsize || diff > dsize || !diff) {
491  put_bits(pb, 1, 1);
492  put_bits(pb, abits, diff);
493  } else {
494  put_bits(pb, 1, 0);
495  put_bits(pb, dbits - 1, FFABS(diff) - 1);
496  put_bits(pb, 1, diff < 0);
497  }
498 }
499 
500 static void put_alpha_run(PutBitContext *pb, int run)
501 {
502  if (run) {
503  put_bits(pb, 1, 0);
504  if (run < 0x10)
505  put_bits(pb, 4, run);
506  else
507  put_bits(pb, 15, run);
508  } else {
509  put_bits(pb, 1, 1);
510  }
511 }
512 
513 // todo alpha quantisation for high quants
515  int mbs_per_slice, uint16_t *blocks,
516  int quant)
517 {
518  const int abits = ctx->alpha_bits;
519  const int mask = (1 << abits) - 1;
520  const int num_coeffs = mbs_per_slice * 256;
521  int prev = mask, cur;
522  int idx = 0;
523  int run = 0;
524 
525  cur = blocks[idx++];
526  put_alpha_diff(pb, cur, prev, abits);
527  prev = cur;
528  do {
529  cur = blocks[idx++];
530  if (cur != prev) {
531  put_alpha_run (pb, run);
532  put_alpha_diff(pb, cur, prev, abits);
533  prev = cur;
534  run = 0;
535  } else {
536  run++;
537  }
538  } while (idx < num_coeffs);
539  if (run)
540  put_alpha_run(pb, run);
541 }
542 
543 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
544  PutBitContext *pb,
545  int sizes[4], int x, int y, int quant,
546  int mbs_per_slice)
547 {
548  ProresContext *ctx = avctx->priv_data;
549  int i, xp, yp;
550  int total_size = 0;
551  const uint16_t *src;
552  int slice_width_factor = av_log2(mbs_per_slice);
553  int num_cblocks, pwidth, line_add;
554  ptrdiff_t linesize;
555  int plane_factor, is_chroma;
556  uint16_t *qmat;
557  uint16_t *qmat_chroma;
558 
559  if (ctx->pictures_per_frame == 1)
560  line_add = 0;
561  else
562  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
563 
564  if (ctx->force_quant) {
565  qmat = ctx->quants[0];
566  qmat_chroma = ctx->quants_chroma[0];
567  } else if (quant < MAX_STORED_Q) {
568  qmat = ctx->quants[quant];
569  qmat_chroma = ctx->quants_chroma[quant];
570  } else {
571  qmat = ctx->custom_q;
572  qmat_chroma = ctx->custom_chroma_q;
573  for (i = 0; i < 64; i++) {
574  qmat[i] = ctx->quant_mat[i] * quant;
575  qmat_chroma[i] = ctx->quant_chroma_mat[i] * quant;
576  }
577  }
578 
579  for (i = 0; i < ctx->num_planes; i++) {
580  is_chroma = (i == 1 || i == 2);
581  plane_factor = slice_width_factor + 2;
582  if (is_chroma)
583  plane_factor += ctx->chroma_factor - 3;
584  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
585  xp = x << 4;
586  yp = y << 4;
587  num_cblocks = 4;
588  pwidth = avctx->width;
589  } else {
590  xp = x << 3;
591  yp = y << 4;
592  num_cblocks = 2;
593  pwidth = avctx->width >> 1;
594  }
595 
596  linesize = pic->linesize[i] * ctx->pictures_per_frame;
597  src = (const uint16_t*)(pic->data[i] + yp * linesize +
598  line_add * pic->linesize[i]) + xp;
599 
600  if (i < 3) {
601  get_slice_data(ctx, src, linesize, xp, yp,
602  pwidth, avctx->height / ctx->pictures_per_frame,
603  ctx->blocks[0], ctx->emu_buf,
604  mbs_per_slice, num_cblocks, is_chroma);
605  if (!is_chroma) {/* luma quant */
606  encode_slice_plane(ctx, pb, src, linesize,
607  mbs_per_slice, ctx->blocks[0],
608  num_cblocks, plane_factor, qmat);
609  } else { /* chroma plane */
610  encode_slice_plane(ctx, pb, src, linesize,
611  mbs_per_slice, ctx->blocks[0],
612  num_cblocks, plane_factor, qmat_chroma);
613  }
614  } else {
615  get_alpha_data(ctx, src, linesize, xp, yp,
616  pwidth, avctx->height / ctx->pictures_per_frame,
617  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
618  encode_alpha_plane(ctx, pb, mbs_per_slice, ctx->blocks[0], quant);
619  }
620  flush_put_bits(pb);
621  sizes[i] = put_bytes_output(pb) - total_size;
622  total_size = put_bytes_output(pb);
623  }
624  return total_size;
625 }
626 
627 static inline int estimate_vlc(unsigned codebook, int val)
628 {
629  unsigned int rice_order, exp_order, switch_bits, switch_val;
630  int exponent;
631 
632  /* number of prefix bits to switch between Rice and expGolomb */
633  switch_bits = (codebook & 3) + 1;
634  rice_order = codebook >> 5; /* rice code order */
635  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
636 
637  switch_val = switch_bits << rice_order;
638 
639  if (val >= switch_val) {
640  val -= switch_val - (1 << exp_order);
641  exponent = av_log2(val);
642 
643  return exponent * 2 - exp_order + switch_bits + 1;
644  } else {
645  return (val >> rice_order) + rice_order + 1;
646  }
647 }
648 
649 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
650  int scale)
651 {
652  int i;
653  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
654  int bits;
655 
656  prev_dc = (blocks[0] - 0x4000) / scale;
657  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
658  sign = 0;
659  codebook = 3;
660  blocks += 64;
661  *error += FFABS(blocks[0] - 0x4000) % scale;
662 
663  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
664  dc = (blocks[0] - 0x4000) / scale;
665  *error += FFABS(blocks[0] - 0x4000) % scale;
666  delta = dc - prev_dc;
667  new_sign = GET_SIGN(delta);
668  delta = (delta ^ sign) - sign;
669  code = MAKE_CODE(delta);
671  codebook = (code + (code & 1)) >> 1;
672  codebook = FFMIN(codebook, 3);
673  sign = new_sign;
674  prev_dc = dc;
675  }
676 
677  return bits;
678 }
679 
680 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
681  int plane_size_factor,
682  const uint8_t *scan, const int16_t *qmat)
683 {
684  int idx, i;
685  int run, level, run_cb, lev_cb;
686  int max_coeffs, abs_level;
687  int bits = 0;
688 
689  max_coeffs = blocks_per_slice << 6;
690  run_cb = ff_prores_run_to_cb_index[4];
691  lev_cb = ff_prores_lev_to_cb_index[2];
692  run = 0;
693 
694  for (i = 1; i < 64; i++) {
695  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
696  level = blocks[idx] / qmat[scan[i]];
697  *error += FFABS(blocks[idx]) % qmat[scan[i]];
698  if (level) {
699  abs_level = FFABS(level);
702  abs_level - 1) + 1;
703 
704  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
705  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
706  run = 0;
707  } else {
708  run++;
709  }
710  }
711  }
712 
713  return bits;
714 }
715 
716 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
717  const uint16_t *src, ptrdiff_t linesize,
718  int mbs_per_slice,
719  int blocks_per_mb, int plane_size_factor,
720  const int16_t *qmat, ProresThreadData *td)
721 {
722  int blocks_per_slice;
723  int bits;
724 
725  blocks_per_slice = mbs_per_slice * blocks_per_mb;
726 
727  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
728  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
729  plane_size_factor, ctx->scantable, qmat);
730 
731  return FFALIGN(bits, 8);
732 }
733 
734 static int est_alpha_diff(int cur, int prev, int abits)
735 {
736  const int dbits = (abits == 8) ? 4 : 7;
737  const int dsize = 1 << dbits - 1;
738  int diff = cur - prev;
739 
740  diff = av_mod_uintp2(diff, abits);
741  if (diff >= (1 << abits) - dsize)
742  diff -= 1 << abits;
743  if (diff < -dsize || diff > dsize || !diff)
744  return abits + 1;
745  else
746  return dbits + 1;
747 }
748 
750  const uint16_t *src, ptrdiff_t linesize,
751  int mbs_per_slice, int16_t *blocks)
752 {
753  const int abits = ctx->alpha_bits;
754  const int mask = (1 << abits) - 1;
755  const int num_coeffs = mbs_per_slice * 256;
756  int prev = mask, cur;
757  int idx = 0;
758  int run = 0;
759  int bits;
760 
761  cur = blocks[idx++];
762  bits = est_alpha_diff(cur, prev, abits);
763  prev = cur;
764  do {
765  cur = blocks[idx++];
766  if (cur != prev) {
767  if (!run)
768  bits++;
769  else if (run < 0x10)
770  bits += 4;
771  else
772  bits += 15;
773  bits += est_alpha_diff(cur, prev, abits);
774  prev = cur;
775  run = 0;
776  } else {
777  run++;
778  }
779  } while (idx < num_coeffs);
780 
781  if (run) {
782  if (run < 0x10)
783  bits += 4;
784  else
785  bits += 15;
786  }
787 
788  return bits;
789 }
790 
792  int trellis_node, int x, int y, int mbs_per_slice,
794 {
795  ProresContext *ctx = avctx->priv_data;
796  int i, q, pq, xp, yp;
797  const uint16_t *src;
798  int slice_width_factor = av_log2(mbs_per_slice);
799  int num_cblocks[MAX_PLANES], pwidth;
800  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
801  const int min_quant = ctx->profile_info->min_quant;
802  const int max_quant = ctx->profile_info->max_quant;
803  int error, bits, bits_limit;
804  int mbs, prev, cur, new_score;
805  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
806  int overquant;
807  uint16_t *qmat;
808  uint16_t *qmat_chroma;
809  int linesize[4], line_add;
810  int alpha_bits = 0;
811 
812  if (ctx->pictures_per_frame == 1)
813  line_add = 0;
814  else
815  line_add = ctx->cur_picture_idx ^ !ctx->pic->top_field_first;
816  mbs = x + mbs_per_slice;
817 
818  for (i = 0; i < ctx->num_planes; i++) {
819  is_chroma[i] = (i == 1 || i == 2);
820  plane_factor[i] = slice_width_factor + 2;
821  if (is_chroma[i])
822  plane_factor[i] += ctx->chroma_factor - 3;
823  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
824  xp = x << 4;
825  yp = y << 4;
826  num_cblocks[i] = 4;
827  pwidth = avctx->width;
828  } else {
829  xp = x << 3;
830  yp = y << 4;
831  num_cblocks[i] = 2;
832  pwidth = avctx->width >> 1;
833  }
834 
835  linesize[i] = ctx->pic->linesize[i] * ctx->pictures_per_frame;
836  src = (const uint16_t *)(ctx->pic->data[i] + yp * linesize[i] +
837  line_add * ctx->pic->linesize[i]) + xp;
838 
839  if (i < 3) {
840  get_slice_data(ctx, src, linesize[i], xp, yp,
841  pwidth, avctx->height / ctx->pictures_per_frame,
842  td->blocks[i], td->emu_buf,
843  mbs_per_slice, num_cblocks[i], is_chroma[i]);
844  } else {
845  get_alpha_data(ctx, src, linesize[i], xp, yp,
846  pwidth, avctx->height / ctx->pictures_per_frame,
847  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
848  }
849  }
850 
851  for (q = min_quant; q < max_quant + 2; q++) {
852  td->nodes[trellis_node + q].prev_node = -1;
853  td->nodes[trellis_node + q].quant = q;
854  }
855 
856  if (ctx->alpha_bits)
857  alpha_bits = estimate_alpha_plane(ctx, src, linesize[3],
858  mbs_per_slice, td->blocks[3]);
859  // todo: maybe perform coarser quantising to fit into frame size when needed
860  for (q = min_quant; q <= max_quant; q++) {
861  bits = alpha_bits;
862  error = 0;
864  src, linesize[0],
865  mbs_per_slice,
866  num_cblocks[0], plane_factor[0],
867  ctx->quants[q], td); /* estimate luma plane */
868  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
870  src, linesize[i],
871  mbs_per_slice,
872  num_cblocks[i], plane_factor[i],
873  ctx->quants_chroma[q], td);
874  }
875  if (bits > 65000 * 8)
876  error = SCORE_LIMIT;
877 
878  slice_bits[q] = bits;
879  slice_score[q] = error;
880  }
881  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
882  slice_bits[max_quant + 1] = slice_bits[max_quant];
883  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
884  overquant = max_quant;
885  } else {
886  for (q = max_quant + 1; q < 128; q++) {
887  bits = alpha_bits;
888  error = 0;
889  if (q < MAX_STORED_Q) {
890  qmat = ctx->quants[q];
891  qmat_chroma = ctx->quants_chroma[q];
892  } else {
893  qmat = td->custom_q;
894  qmat_chroma = td->custom_chroma_q;
895  for (i = 0; i < 64; i++) {
896  qmat[i] = ctx->quant_mat[i] * q;
897  qmat_chroma[i] = ctx->quant_chroma_mat[i] * q;
898  }
899  }
901  src, linesize[0],
902  mbs_per_slice,
903  num_cblocks[0], plane_factor[0],
904  qmat, td);/* estimate luma plane */
905  for (i = 1; i < ctx->num_planes - !!ctx->alpha_bits; i++) { /* estimate chroma plane */
907  src, linesize[i],
908  mbs_per_slice,
909  num_cblocks[i], plane_factor[i],
910  qmat_chroma, td);
911  }
912  if (bits <= ctx->bits_per_mb * mbs_per_slice)
913  break;
914  }
915 
916  slice_bits[max_quant + 1] = bits;
917  slice_score[max_quant + 1] = error;
918  overquant = q;
919  }
920  td->nodes[trellis_node + max_quant + 1].quant = overquant;
921 
922  bits_limit = mbs * ctx->bits_per_mb;
923  for (pq = min_quant; pq < max_quant + 2; pq++) {
924  prev = trellis_node - TRELLIS_WIDTH + pq;
925 
926  for (q = min_quant; q < max_quant + 2; q++) {
927  cur = trellis_node + q;
928 
929  bits = td->nodes[prev].bits + slice_bits[q];
930  error = slice_score[q];
931  if (bits > bits_limit)
932  error = SCORE_LIMIT;
933 
934  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
935  new_score = td->nodes[prev].score + error;
936  else
937  new_score = SCORE_LIMIT;
938  if (td->nodes[cur].prev_node == -1 ||
939  td->nodes[cur].score >= new_score) {
940 
941  td->nodes[cur].bits = bits;
942  td->nodes[cur].score = new_score;
943  td->nodes[cur].prev_node = prev;
944  }
945  }
946  }
947 
948  error = td->nodes[trellis_node + min_quant].score;
949  pq = trellis_node + min_quant;
950  for (q = min_quant + 1; q < max_quant + 2; q++) {
951  if (td->nodes[trellis_node + q].score <= error) {
952  error = td->nodes[trellis_node + q].score;
953  pq = trellis_node + q;
954  }
955  }
956 
957  return pq;
958 }
959 
960 static int find_quant_thread(AVCodecContext *avctx, void *arg,
961  int jobnr, int threadnr)
962 {
963  ProresContext *ctx = avctx->priv_data;
964  ProresThreadData *td = ctx->tdata + threadnr;
965  int mbs_per_slice = ctx->mbs_per_slice;
966  int x, y = jobnr, mb, q = 0;
967 
968  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
969  while (ctx->mb_width - x < mbs_per_slice)
970  mbs_per_slice >>= 1;
971  q = find_slice_quant(avctx,
972  (mb + 1) * TRELLIS_WIDTH, x, y,
973  mbs_per_slice, td);
974  }
975 
976  for (x = ctx->slices_width - 1; x >= 0; x--) {
977  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
978  q = td->nodes[q].prev_node;
979  }
980 
981  return 0;
982 }
983 
985  const AVFrame *pic, int *got_packet)
986 {
987  ProresContext *ctx = avctx->priv_data;
988  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
989  uint8_t *picture_size_pos;
990  PutBitContext pb;
991  int x, y, i, mb, q = 0;
992  int sizes[4] = { 0 };
993  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
994  int frame_size, picture_size, slice_size;
995  int pkt_size, ret;
996  int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
997  uint8_t frame_flags;
998 
999  ctx->pic = pic;
1000  pkt_size = ctx->frame_size_upper_bound;
1001 
1002  if ((ret = ff_alloc_packet(avctx, pkt, pkt_size + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1003  return ret;
1004 
1005  orig_buf = pkt->data;
1006 
1007  // frame atom
1008  orig_buf += 4; // frame size
1009  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
1010  buf = orig_buf;
1011 
1012  // frame header
1013  tmp = buf;
1014  buf += 2; // frame header size will be stored here
1015  bytestream_put_be16 (&buf, 0); // version 1
1016  bytestream_put_buffer(&buf, ctx->vendor, 4);
1017  bytestream_put_be16 (&buf, avctx->width);
1018  bytestream_put_be16 (&buf, avctx->height);
1019 
1020  frame_flags = ctx->chroma_factor << 6;
1021  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT)
1022  frame_flags |= pic->top_field_first ? 0x04 : 0x08;
1023  bytestream_put_byte (&buf, frame_flags);
1024 
1025  bytestream_put_byte (&buf, 0); // reserved
1026  bytestream_put_byte (&buf, pic->color_primaries);
1027  bytestream_put_byte (&buf, pic->color_trc);
1028  bytestream_put_byte (&buf, pic->colorspace);
1029  bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
1030  bytestream_put_byte (&buf, 0); // reserved
1031  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
1032  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
1033  // luma quantisation matrix
1034  for (i = 0; i < 64; i++)
1035  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1036  // chroma quantisation matrix
1037  for (i = 0; i < 64; i++)
1038  bytestream_put_byte(&buf, ctx->quant_mat[i]);
1039  } else {
1040  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
1041  }
1042  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
1043 
1044  for (ctx->cur_picture_idx = 0;
1045  ctx->cur_picture_idx < ctx->pictures_per_frame;
1046  ctx->cur_picture_idx++) {
1047  // picture header
1048  picture_size_pos = buf + 1;
1049  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
1050  buf += 4; // picture data size will be stored here
1051  bytestream_put_be16 (&buf, ctx->slices_per_picture);
1052  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1053 
1054  // seek table - will be filled during slice encoding
1055  slice_sizes = buf;
1056  buf += ctx->slices_per_picture * 2;
1057 
1058  // slices
1059  if (!ctx->force_quant) {
1060  ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1061  ctx->mb_height);
1062  if (ret)
1063  return ret;
1064  }
1065 
1066  for (y = 0; y < ctx->mb_height; y++) {
1067  int mbs_per_slice = ctx->mbs_per_slice;
1068  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1069  q = ctx->force_quant ? ctx->force_quant
1070  : ctx->slice_q[mb + y * ctx->slices_width];
1071 
1072  while (ctx->mb_width - x < mbs_per_slice)
1073  mbs_per_slice >>= 1;
1074 
1075  bytestream_put_byte(&buf, slice_hdr_size << 3);
1076  slice_hdr = buf;
1077  buf += slice_hdr_size - 1;
1078  if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1079  uint8_t *start = pkt->data;
1080  // Recompute new size according to max_slice_size
1081  // and deduce delta
1082  int delta = 200 + (ctx->pictures_per_frame *
1083  ctx->slices_per_picture + 1) *
1084  max_slice_size - pkt_size;
1085 
1086  delta = FFMAX(delta, 2 * max_slice_size);
1087  ctx->frame_size_upper_bound += delta;
1088 
1089  if (!ctx->warn) {
1090  avpriv_request_sample(avctx,
1091  "Packet too small: is %i,"
1092  " needs %i (slice: %i). "
1093  "Correct allocation",
1094  pkt_size, delta, max_slice_size);
1095  ctx->warn = 1;
1096  }
1097 
1099  if (ret < 0)
1100  return ret;
1101 
1102  pkt_size += delta;
1103  // restore pointers
1104  orig_buf = pkt->data + (orig_buf - start);
1105  buf = pkt->data + (buf - start);
1106  picture_size_pos = pkt->data + (picture_size_pos - start);
1107  slice_sizes = pkt->data + (slice_sizes - start);
1108  slice_hdr = pkt->data + (slice_hdr - start);
1109  tmp = pkt->data + (tmp - start);
1110  }
1111  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1112  ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1113  mbs_per_slice);
1114  if (ret < 0)
1115  return ret;
1116 
1117  bytestream_put_byte(&slice_hdr, q);
1118  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1119  for (i = 0; i < ctx->num_planes - 1; i++) {
1120  bytestream_put_be16(&slice_hdr, sizes[i]);
1121  slice_size += sizes[i];
1122  }
1123  bytestream_put_be16(&slice_sizes, slice_size);
1124  buf += slice_size - slice_hdr_size;
1125  if (max_slice_size < slice_size)
1126  max_slice_size = slice_size;
1127  }
1128  }
1129 
1130  picture_size = buf - (picture_size_pos - 1);
1131  bytestream_put_be32(&picture_size_pos, picture_size);
1132  }
1133 
1134  orig_buf -= 8;
1135  frame_size = buf - orig_buf;
1136  bytestream_put_be32(&orig_buf, frame_size);
1137 
1138  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:31
ProresContext::force_quant
int force_quant
Definition: proresenc_kostya.c:257
ProresContext::quant_chroma_mat
const uint8_t * quant_chroma_mat
Definition: proresenc_kostya.c:240
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:534
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:42
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:649
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
encode_dcs
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
Definition: proresenc_kostya.c:408
ProresContext::fdsp
FDCTDSPContext fdsp
Definition: proresenc_anatoliy.c:184
mem_internal.h
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
GET_SIGN
#define GET_SIGN(x)
Definition: proresenc_kostya.c:405
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet)
Definition: proresenc_kostya.c:984
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:2564
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:122
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
QUANT_MAT_PROXY
@ QUANT_MAT_PROXY
Definition: proresenc_kostya.c:56
ProresContext::quants_chroma
int16_t quants_chroma[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:236
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:123
ProresContext::vendor
char * vendor
Definition: proresenc_anatoliy.c:198
profile
mfxU16 profile
Definition: qsvenc.c:45
QUANT_MAT_DEFAULT
@ QUANT_MAT_DEFAULT
Definition: proresenc_kostya.c:62
prores_profile::tag
uint32_t tag
Definition: proresenc_kostya.c:148
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:26
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
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:514
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
PRORES_PROFILE_LT
@ PRORES_PROFILE_LT
Definition: proresenc_kostya.c:48
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:247
ProresContext::slices_width
int slices_width
Definition: proresenc_kostya.c:251
encode.h
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdata.h:33
ProresContext::alpha_bits
int alpha_bits
Definition: proresenc_kostya.c:258
ProresContext
Definition: proresdec.h:38
ff_prores_dc_codebook
const uint8_t ff_prores_dc_codebook[4]
Definition: proresdata.c:48
QUANT_MAT_PROXY_CHROMA
@ QUANT_MAT_PROXY_CHROMA
Definition: proresenc_kostya.c:57
ProresContext::num_planes
int num_planes
Definition: proresenc_kostya.c:255
ProresContext::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:234
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ProresThreadData::emu_buf
uint16_t emu_buf[16 *16]
Definition: proresenc_kostya.c:225
av_popcount
#define av_popcount
Definition: common.h:150
SCORE_LIMIT
#define SCORE_LIMIT
Definition: proresenc_kostya.c:212
PRORES_PROFILE_PROXY
@ PRORES_PROFILE_PROXY
Definition: proresenc_kostya.c:47
put_alpha_run
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc_kostya.c:500
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:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
QUANT_MAT_STANDARD
@ QUANT_MAT_STANDARD
Definition: proresenc_kostya.c:59
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:267
FDCTDSPContext
Definition: fdctdsp.h:26
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
ProresContext::slice_q
int * slice_q
Definition: proresenc_kostya.c:269
ProresContext::mbs_per_slice
int mbs_per_slice
Definition: proresenc_kostya.c:249
TrellisNode
Definition: adpcmenc.c:58
prores_mb_limits
static const int prores_mb_limits[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:139
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
ProresContext::custom_chroma_q
int16_t custom_chroma_q[64]
Definition: proresenc_kostya.c:238
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:481
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:1377
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:749
ProresThreadData::nodes
struct TrellisNode * nodes
Definition: proresenc_kostya.c:228
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:260
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:394
prores_profile::max_quant
int max_quant
Definition: proresenc_kostya.c:150
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_fdctdsp_init
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c: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:227
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:449
frame_size
int frame_size
Definition: mxfenc.c:2205
PRORES_PROFILE_HQ
@ PRORES_PROFILE_HQ
Definition: proresenc_kostya.c:50
ProresThreadData::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:226
bits
uint8_t bits
Definition: vp3data.h:141
PRORES_PROFILE_AUTO
@ PRORES_PROFILE_AUTO
Definition: proresenc_kostya.c:46
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
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:256
ProresContext::quants
int16_t quants[MAX_STORED_Q][64]
Definition: proresenc_kostya.c:235
ProresContext::profile
int profile
Definition: proresenc_kostya.c:266
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
QUANT_MAT_XQ_LUMA
@ QUANT_MAT_XQ_LUMA
Definition: proresenc_kostya.c:61
TrellisNode::prev_node
int prev_node
Definition: proresenc_kostya.c:215
prores_profile::min_quant
int min_quant
Definition: proresenc_kostya.c:149
prores_profile::full_name
const char * full_name
Definition: proresenc_kostya.c:147
TrellisNode::quant
int quant
Definition: proresenc_kostya.c:216
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:960
PutBitContext
Definition: put_bits.h:49
ProresContext::mb_width
int mb_width
Definition: proresenc_kostya.c:248
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:65
ProresContext::pictures_per_frame
int pictures_per_frame
Definition: proresenc_kostya.c:253
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:53
ProresContext::pic
const AVFrame * pic
Definition: proresenc_kostya.c:247
MAX_STORED_Q
#define MAX_STORED_Q
Definition: proresenc_kostya.c:221
run
uint8_t run
Definition: svq3.c:203
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: proresenc_kostya.c:1173
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:791
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:392
ProresContext::tdata
ProresThreadData * tdata
Definition: proresenc_kostya.c:271
ProresContext::quant_sel
int quant_sel
Definition: proresenc_kostya.c:262
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:233
prores_profile::br_tab
int br_tab[NUM_MB_LIMITS]
Definition: proresenc_kostya.c:151
ff_prores_ks_encoder
const AVCodec ff_prores_ks_encoder
Definition: proresenc_kostya.c:1402
CFACTOR_Y444
#define CFACTOR_Y444
Definition: proresenc_kostya.c:39
ProresContext::chroma_factor
int chroma_factor
Definition: proresenc_kostya.c:250
AVPacket::size
int size
Definition: packet.h:374
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:192
ProresContext::custom_q
int16_t custom_q[64]
Definition: proresenc_kostya.c:237
QUANT_MAT_LT
@ QUANT_MAT_LT
Definition: proresenc_kostya.c:58
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:716
TrellisNode::bits
int bits
Definition: proresenc_kostya.c:217
proresdata.h
MAKE_CODE
#define MAKE_CODE(x)
Definition: proresenc_kostya.c:406
ff_prores_lev_to_cb_index
const uint8_t ff_prores_lev_to_cb_index[10]
Definition: proresdata.c:72
PRORES_PROFILE_4444
@ PRORES_PROFILE_4444
Definition: proresenc_kostya.c:51
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:430
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:1349
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:1418
options
static const AVOption options[]
Definition: proresenc_kostya.c:1352
interlaced
uint8_t interlaced
Definition: mxfenc.c:2207
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:345
prores_profile
Definition: proresenc_kostya.c:146
TRELLIS_WIDTH
#define TRELLIS_WIDTH
Definition: proresenc_kostya.c:211
QUANT_MAT_HQ
@ QUANT_MAT_HQ
Definition: proresenc_kostya.c:60
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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
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:274
ProresContext::frame_size_upper_bound
int frame_size_upper_bound
Definition: proresenc_kostya.c:264
ProresThreadData::blocks
int16_t blocks[MAX_PLANES][64 *4 *MAX_MBS_PER_SLICE]
Definition: proresenc_kostya.c:224
PRORES_PROFILE_4444XQ
@ PRORES_PROFILE_4444XQ
Definition: proresenc_kostya.c:52
delta
float delta
Definition: vorbis_enc_data.h:430
ProresContext::num_chroma_blocks
int num_chroma_blocks
Definition: proresenc_kostya.c:250
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:734
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:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
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:680
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:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
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:71
prores_profile::quant
int quant
Definition: proresenc_kostya.c:152
ProresContext::quant_mat
const uint8_t * quant_mat
Definition: proresenc_kostya.c:239
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:468
prores_profile::quant_chroma
int quant_chroma
Definition: proresenc_kostya.c:153
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ProresContext::slices_per_picture
int slices_per_picture
Definition: proresenc_kostya.c:252
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
TrellisNode::score
int score
Definition: proresenc_kostya.c:218
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:434
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:138
FDCTDSPContext::fdct
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
estimate_vlc
static int estimate_vlc(unsigned codebook, int val)
Definition: proresenc_kostya.c:627
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: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:543
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:408
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
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:376
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:556
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:223
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:61
ProresContext::fdct
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, ptrdiff_t linesize, int16_t *block)
Definition: proresenc_kostya.c:243
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ProresContext::cur_picture_idx
int cur_picture_idx
Definition: proresenc_kostya.c:254
h
h
Definition: vp9dsp_template.c:2038
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
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:259
PRORES_PROFILE_STANDARD
@ PRORES_PROFILE_STANDARD
Definition: proresenc_kostya.c:49
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
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:1511
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:34
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:198
ProresContext::mb_height
unsigned mb_height
height of the current picture in mb
Definition: proresdec.h:48