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