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;
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  int linesize, int16_t *block);
197 
203  int pictures_per_frame; // 1 for progressive, 2 for interlaced
209 
210  char *vendor;
212 
214 
215  int profile;
217 
218  int *slice_q;
219 
221 } ProresContext;
222 
223 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
224  int linesize, int x, int y, int w, int h,
225  int16_t *blocks, uint16_t *emu_buf,
226  int mbs_per_slice, int blocks_per_mb, int is_chroma)
227 {
228  const uint16_t *esrc;
229  const int mb_width = 4 * blocks_per_mb;
230  int elinesize;
231  int i, j, k;
232 
233  for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
234  if (x >= w) {
235  memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
236  * sizeof(*blocks));
237  return;
238  }
239  if (x + mb_width <= w && y + 16 <= h) {
240  esrc = src;
241  elinesize = linesize;
242  } else {
243  int bw, bh, pix;
244 
245  esrc = emu_buf;
246  elinesize = 16 * sizeof(*emu_buf);
247 
248  bw = FFMIN(w - x, mb_width);
249  bh = FFMIN(h - y, 16);
250 
251  for (j = 0; j < bh; j++) {
252  memcpy(emu_buf + j * 16,
253  (const uint8_t*)src + j * linesize,
254  bw * sizeof(*src));
255  pix = emu_buf[j * 16 + bw - 1];
256  for (k = bw; k < mb_width; k++)
257  emu_buf[j * 16 + k] = pix;
258  }
259  for (; j < 16; j++)
260  memcpy(emu_buf + j * 16,
261  emu_buf + (bh - 1) * 16,
262  mb_width * sizeof(*emu_buf));
263  }
264  if (!is_chroma) {
265  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
266  blocks += 64;
267  if (blocks_per_mb > 2) {
268  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
269  blocks += 64;
270  }
271  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
272  blocks += 64;
273  if (blocks_per_mb > 2) {
274  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
275  blocks += 64;
276  }
277  } else {
278  ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
279  blocks += 64;
280  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
281  blocks += 64;
282  if (blocks_per_mb > 2) {
283  ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
284  blocks += 64;
285  ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
286  blocks += 64;
287  }
288  }
289 
290  x += mb_width;
291  }
292 }
293 
294 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
295  int linesize, int x, int y, int w, int h,
296  int16_t *blocks, int mbs_per_slice, int abits)
297 {
298  const int slice_width = 16 * mbs_per_slice;
299  int i, j, copy_w, copy_h;
300 
301  copy_w = FFMIN(w - x, slice_width);
302  copy_h = FFMIN(h - y, 16);
303  for (i = 0; i < copy_h; i++) {
304  memcpy(blocks, src, copy_w * sizeof(*src));
305  if (abits == 8)
306  for (j = 0; j < copy_w; j++)
307  blocks[j] >>= 2;
308  else
309  for (j = 0; j < copy_w; j++)
310  blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
311  for (j = copy_w; j < slice_width; j++)
312  blocks[j] = blocks[copy_w - 1];
313  blocks += slice_width;
314  src += linesize >> 1;
315  }
316  for (; i < 16; i++) {
317  memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
318  blocks += slice_width;
319  }
320 }
321 
325 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
326 {
327  unsigned int rice_order, exp_order, switch_bits, switch_val;
328  int exponent;
329 
330  /* number of prefix bits to switch between Rice and expGolomb */
331  switch_bits = (codebook & 3) + 1;
332  rice_order = codebook >> 5; /* rice code order */
333  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
334 
335  switch_val = switch_bits << rice_order;
336 
337  if (val >= switch_val) {
338  val -= switch_val - (1 << exp_order);
339  exponent = av_log2(val);
340 
341  put_bits(pb, exponent - exp_order + switch_bits, 0);
342  put_bits(pb, exponent + 1, val);
343  } else {
344  exponent = val >> rice_order;
345 
346  if (exponent)
347  put_bits(pb, exponent, 0);
348  put_bits(pb, 1, 1);
349  if (rice_order)
350  put_sbits(pb, rice_order, val);
351  }
352 }
353 
354 #define GET_SIGN(x) ((x) >> 31)
355 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
356 
357 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
358  int blocks_per_slice, int scale)
359 {
360  int i;
361  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
362 
363  prev_dc = (blocks[0] - 0x4000) / scale;
365  sign = 0;
366  codebook = 3;
367  blocks += 64;
368 
369  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
370  dc = (blocks[0] - 0x4000) / scale;
371  delta = dc - prev_dc;
372  new_sign = GET_SIGN(delta);
373  delta = (delta ^ sign) - sign;
374  code = MAKE_CODE(delta);
375  encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
376  codebook = (code + (code & 1)) >> 1;
377  codebook = FFMIN(codebook, 3);
378  sign = new_sign;
379  prev_dc = dc;
380  }
381 }
382 
383 static void encode_acs(PutBitContext *pb, int16_t *blocks,
384  int blocks_per_slice,
385  int plane_size_factor,
386  const uint8_t *scan, const int16_t *qmat)
387 {
388  int idx, i;
389  int run, level, run_cb, lev_cb;
390  int max_coeffs, abs_level;
391 
392  max_coeffs = blocks_per_slice << 6;
393  run_cb = ff_prores_run_to_cb_index[4];
394  lev_cb = ff_prores_lev_to_cb_index[2];
395  run = 0;
396 
397  for (i = 1; i < 64; i++) {
398  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
399  level = blocks[idx] / qmat[scan[i]];
400  if (level) {
401  abs_level = FFABS(level);
402  encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
404  abs_level - 1);
405  put_sbits(pb, 1, GET_SIGN(level));
406 
407  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
408  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
409  run = 0;
410  } else {
411  run++;
412  }
413  }
414  }
415 }
416 
418  const uint16_t *src, int linesize,
419  int mbs_per_slice, int16_t *blocks,
420  int blocks_per_mb, int plane_size_factor,
421  const int16_t *qmat)
422 {
423  int blocks_per_slice, saved_pos;
424 
425  saved_pos = put_bits_count(pb);
426  blocks_per_slice = mbs_per_slice * blocks_per_mb;
427 
428  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
429  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
430  ctx->scantable, qmat);
431  flush_put_bits(pb);
432 
433  return (put_bits_count(pb) - saved_pos) >> 3;
434 }
435 
436 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
437 {
438  const int mask = (1 << abits) - 1;
439  const int dbits = (abits == 8) ? 4 : 7;
440  const int dsize = 1 << dbits - 1;
441  int diff = cur - prev;
442 
443  diff &= mask;
444  if (diff >= (1 << abits) - dsize)
445  diff -= 1 << abits;
446  if (diff < -dsize || diff > dsize || !diff) {
447  put_bits(pb, 1, 1);
448  put_bits(pb, abits, diff);
449  } else {
450  put_bits(pb, 1, 0);
451  put_bits(pb, dbits - 1, FFABS(diff) - 1);
452  put_bits(pb, 1, diff < 0);
453  }
454 }
455 
456 static void put_alpha_run(PutBitContext *pb, int run)
457 {
458  if (run) {
459  put_bits(pb, 1, 0);
460  if (run < 0x10)
461  put_bits(pb, 4, run);
462  else
463  put_bits(pb, 15, run);
464  } else {
465  put_bits(pb, 1, 1);
466  }
467 }
468 
469 // todo alpha quantisation for high quants
471  const uint16_t *src, int linesize,
472  int mbs_per_slice, uint16_t *blocks,
473  int quant)
474 {
475  const int abits = ctx->alpha_bits;
476  const int mask = (1 << abits) - 1;
477  const int num_coeffs = mbs_per_slice * 256;
478  int saved_pos = put_bits_count(pb);
479  int prev = mask, cur;
480  int idx = 0;
481  int run = 0;
482 
483  cur = blocks[idx++];
484  put_alpha_diff(pb, cur, prev, abits);
485  prev = cur;
486  do {
487  cur = blocks[idx++];
488  if (cur != prev) {
489  put_alpha_run (pb, run);
490  put_alpha_diff(pb, cur, prev, abits);
491  prev = cur;
492  run = 0;
493  } else {
494  run++;
495  }
496  } while (idx < num_coeffs);
497  if (run)
498  put_alpha_run(pb, run);
499  flush_put_bits(pb);
500  return (put_bits_count(pb) - saved_pos) >> 3;
501 }
502 
503 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
504  PutBitContext *pb,
505  int sizes[4], int x, int y, int quant,
506  int mbs_per_slice)
507 {
508  ProresContext *ctx = avctx->priv_data;
509  int i, xp, yp;
510  int total_size = 0;
511  const uint16_t *src;
512  int slice_width_factor = av_log2(mbs_per_slice);
513  int num_cblocks, pwidth, linesize, line_add;
514  int plane_factor, is_chroma;
515  uint16_t *qmat;
516 
517  if (ctx->pictures_per_frame == 1)
518  line_add = 0;
519  else
520  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
521 
522  if (ctx->force_quant) {
523  qmat = ctx->quants[0];
524  } else if (quant < MAX_STORED_Q) {
525  qmat = ctx->quants[quant];
526  } else {
527  qmat = ctx->custom_q;
528  for (i = 0; i < 64; i++)
529  qmat[i] = ctx->quant_mat[i] * quant;
530  }
531 
532  for (i = 0; i < ctx->num_planes; i++) {
533  is_chroma = (i == 1 || i == 2);
534  plane_factor = slice_width_factor + 2;
535  if (is_chroma)
536  plane_factor += ctx->chroma_factor - 3;
537  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
538  xp = x << 4;
539  yp = y << 4;
540  num_cblocks = 4;
541  pwidth = avctx->width;
542  } else {
543  xp = x << 3;
544  yp = y << 4;
545  num_cblocks = 2;
546  pwidth = avctx->width >> 1;
547  }
548 
549  linesize = pic->linesize[i] * ctx->pictures_per_frame;
550  src = (const uint16_t*)(pic->data[i] + yp * linesize +
551  line_add * pic->linesize[i]) + xp;
552 
553  if (i < 3) {
554  get_slice_data(ctx, src, linesize, xp, yp,
555  pwidth, avctx->height / ctx->pictures_per_frame,
556  ctx->blocks[0], ctx->emu_buf,
557  mbs_per_slice, num_cblocks, is_chroma);
558  sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
559  mbs_per_slice, ctx->blocks[0],
560  num_cblocks, plane_factor,
561  qmat);
562  } else {
563  get_alpha_data(ctx, src, linesize, xp, yp,
564  pwidth, avctx->height / ctx->pictures_per_frame,
565  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
566  sizes[i] = encode_alpha_plane(ctx, pb, src, linesize,
567  mbs_per_slice, ctx->blocks[0],
568  quant);
569  }
570  total_size += sizes[i];
571  }
572  return total_size;
573 }
574 
575 static inline int estimate_vlc(unsigned codebook, int val)
576 {
577  unsigned int rice_order, exp_order, switch_bits, switch_val;
578  int exponent;
579 
580  /* number of prefix bits to switch between Rice and expGolomb */
581  switch_bits = (codebook & 3) + 1;
582  rice_order = codebook >> 5; /* rice code order */
583  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
584 
585  switch_val = switch_bits << rice_order;
586 
587  if (val >= switch_val) {
588  val -= switch_val - (1 << exp_order);
589  exponent = av_log2(val);
590 
591  return exponent * 2 - exp_order + switch_bits + 1;
592  } else {
593  return (val >> rice_order) + rice_order + 1;
594  }
595 }
596 
597 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
598  int scale)
599 {
600  int i;
601  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
602  int bits;
603 
604  prev_dc = (blocks[0] - 0x4000) / scale;
605  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
606  sign = 0;
607  codebook = 3;
608  blocks += 64;
609  *error += FFABS(blocks[0] - 0x4000) % scale;
610 
611  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
612  dc = (blocks[0] - 0x4000) / scale;
613  *error += FFABS(blocks[0] - 0x4000) % scale;
614  delta = dc - prev_dc;
615  new_sign = GET_SIGN(delta);
616  delta = (delta ^ sign) - sign;
617  code = MAKE_CODE(delta);
618  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
619  codebook = (code + (code & 1)) >> 1;
620  codebook = FFMIN(codebook, 3);
621  sign = new_sign;
622  prev_dc = dc;
623  }
624 
625  return bits;
626 }
627 
628 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
629  int plane_size_factor,
630  const uint8_t *scan, const int16_t *qmat)
631 {
632  int idx, i;
633  int run, level, run_cb, lev_cb;
634  int max_coeffs, abs_level;
635  int bits = 0;
636 
637  max_coeffs = blocks_per_slice << 6;
638  run_cb = ff_prores_run_to_cb_index[4];
639  lev_cb = ff_prores_lev_to_cb_index[2];
640  run = 0;
641 
642  for (i = 1; i < 64; i++) {
643  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
644  level = blocks[idx] / qmat[scan[i]];
645  *error += FFABS(blocks[idx]) % qmat[scan[i]];
646  if (level) {
647  abs_level = FFABS(level);
648  bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
649  bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
650  abs_level - 1) + 1;
651 
652  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
653  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
654  run = 0;
655  } else {
656  run++;
657  }
658  }
659  }
660 
661  return bits;
662 }
663 
664 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
665  const uint16_t *src, int linesize,
666  int mbs_per_slice,
667  int blocks_per_mb, int plane_size_factor,
668  const int16_t *qmat, ProresThreadData *td)
669 {
670  int blocks_per_slice;
671  int bits;
672 
673  blocks_per_slice = mbs_per_slice * blocks_per_mb;
674 
675  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
676  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
677  plane_size_factor, ctx->scantable, qmat);
678 
679  return FFALIGN(bits, 8);
680 }
681 
682 static int est_alpha_diff(int cur, int prev, int abits)
683 {
684  const int mask = (1 << abits) - 1;
685  const int dbits = (abits == 8) ? 4 : 7;
686  const int dsize = 1 << dbits - 1;
687  int diff = cur - prev;
688 
689  diff &= mask;
690  if (diff >= (1 << abits) - dsize)
691  diff -= 1 << abits;
692  if (diff < -dsize || diff > dsize || !diff)
693  return abits + 1;
694  else
695  return dbits + 1;
696 }
697 
698 static int estimate_alpha_plane(ProresContext *ctx, int *error,
699  const uint16_t *src, int linesize,
700  int mbs_per_slice, int quant,
701  int16_t *blocks)
702 {
703  const int abits = ctx->alpha_bits;
704  const int mask = (1 << abits) - 1;
705  const int num_coeffs = mbs_per_slice * 256;
706  int prev = mask, cur;
707  int idx = 0;
708  int run = 0;
709  int bits;
710 
711  *error = 0;
712  cur = blocks[idx++];
713  bits = est_alpha_diff(cur, prev, abits);
714  prev = cur;
715  do {
716  cur = blocks[idx++];
717  if (cur != prev) {
718  if (!run)
719  bits++;
720  else if (run < 0x10)
721  bits += 4;
722  else
723  bits += 15;
724  bits += est_alpha_diff(cur, prev, abits);
725  prev = cur;
726  run = 0;
727  } else {
728  run++;
729  }
730  } while (idx < num_coeffs);
731 
732  if (run) {
733  if (run < 0x10)
734  bits += 4;
735  else
736  bits += 15;
737  }
738 
739  return bits;
740 }
741 
742 static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
743  int trellis_node, int x, int y, int mbs_per_slice,
744  ProresThreadData *td)
745 {
746  ProresContext *ctx = avctx->priv_data;
747  int i, q, pq, xp, yp;
748  const uint16_t *src;
749  int slice_width_factor = av_log2(mbs_per_slice);
750  int num_cblocks[MAX_PLANES], pwidth;
751  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
752  const int min_quant = ctx->profile_info->min_quant;
753  const int max_quant = ctx->profile_info->max_quant;
754  int error, bits, bits_limit;
755  int mbs, prev, cur, new_score;
756  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
757  int overquant;
758  uint16_t *qmat;
759  int linesize[4], line_add;
760 
761  if (ctx->pictures_per_frame == 1)
762  line_add = 0;
763  else
764  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
765  mbs = x + mbs_per_slice;
766 
767  for (i = 0; i < ctx->num_planes; i++) {
768  is_chroma[i] = (i == 1 || i == 2);
769  plane_factor[i] = slice_width_factor + 2;
770  if (is_chroma[i])
771  plane_factor[i] += ctx->chroma_factor - 3;
772  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
773  xp = x << 4;
774  yp = y << 4;
775  num_cblocks[i] = 4;
776  pwidth = avctx->width;
777  } else {
778  xp = x << 3;
779  yp = y << 4;
780  num_cblocks[i] = 2;
781  pwidth = avctx->width >> 1;
782  }
783 
784  linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;
785  src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +
786  line_add * pic->linesize[i]) + xp;
787 
788  if (i < 3) {
789  get_slice_data(ctx, src, linesize[i], xp, yp,
790  pwidth, avctx->height / ctx->pictures_per_frame,
791  td->blocks[i], td->emu_buf,
792  mbs_per_slice, num_cblocks[i], is_chroma[i]);
793  } else {
794  get_alpha_data(ctx, src, linesize[i], xp, yp,
795  pwidth, avctx->height / ctx->pictures_per_frame,
796  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
797  }
798  }
799 
800  for (q = min_quant; q < max_quant + 2; q++) {
801  td->nodes[trellis_node + q].prev_node = -1;
802  td->nodes[trellis_node + q].quant = q;
803  }
804 
805  // todo: maybe perform coarser quantising to fit into frame size when needed
806  for (q = min_quant; q <= max_quant; q++) {
807  bits = 0;
808  error = 0;
809  for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
810  bits += estimate_slice_plane(ctx, &error, i,
811  src, linesize[i],
812  mbs_per_slice,
813  num_cblocks[i], plane_factor[i],
814  ctx->quants[q], td);
815  }
816  if (ctx->alpha_bits)
817  bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
818  mbs_per_slice, q, td->blocks[3]);
819  if (bits > 65000 * 8) {
820  error = SCORE_LIMIT;
821  break;
822  }
823  slice_bits[q] = bits;
824  slice_score[q] = error;
825  }
826  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
827  slice_bits[max_quant + 1] = slice_bits[max_quant];
828  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
829  overquant = max_quant;
830  } else {
831  for (q = max_quant + 1; q < 128; q++) {
832  bits = 0;
833  error = 0;
834  if (q < MAX_STORED_Q) {
835  qmat = ctx->quants[q];
836  } else {
837  qmat = td->custom_q;
838  for (i = 0; i < 64; i++)
839  qmat[i] = ctx->quant_mat[i] * q;
840  }
841  for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
842  bits += estimate_slice_plane(ctx, &error, i,
843  src, linesize[i],
844  mbs_per_slice,
845  num_cblocks[i], plane_factor[i],
846  qmat, td);
847  }
848  if (ctx->alpha_bits)
849  bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
850  mbs_per_slice, q, td->blocks[3]);
851  if (bits <= ctx->bits_per_mb * mbs_per_slice)
852  break;
853  }
854 
855  slice_bits[max_quant + 1] = bits;
856  slice_score[max_quant + 1] = error;
857  overquant = q;
858  }
859  td->nodes[trellis_node + max_quant + 1].quant = overquant;
860 
861  bits_limit = mbs * ctx->bits_per_mb;
862  for (pq = min_quant; pq < max_quant + 2; pq++) {
863  prev = trellis_node - TRELLIS_WIDTH + pq;
864 
865  for (q = min_quant; q < max_quant + 2; q++) {
866  cur = trellis_node + q;
867 
868  bits = td->nodes[prev].bits + slice_bits[q];
869  error = slice_score[q];
870  if (bits > bits_limit)
871  error = SCORE_LIMIT;
872 
873  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
874  new_score = td->nodes[prev].score + error;
875  else
876  new_score = SCORE_LIMIT;
877  if (td->nodes[cur].prev_node == -1 ||
878  td->nodes[cur].score >= new_score) {
879 
880  td->nodes[cur].bits = bits;
881  td->nodes[cur].score = new_score;
882  td->nodes[cur].prev_node = prev;
883  }
884  }
885  }
886 
887  error = td->nodes[trellis_node + min_quant].score;
888  pq = trellis_node + min_quant;
889  for (q = min_quant + 1; q < max_quant + 2; q++) {
890  if (td->nodes[trellis_node + q].score <= error) {
891  error = td->nodes[trellis_node + q].score;
892  pq = trellis_node + q;
893  }
894  }
895 
896  return pq;
897 }
898 
899 static int find_quant_thread(AVCodecContext *avctx, void *arg,
900  int jobnr, int threadnr)
901 {
902  ProresContext *ctx = avctx->priv_data;
903  ProresThreadData *td = ctx->tdata + threadnr;
904  int mbs_per_slice = ctx->mbs_per_slice;
905  int x, y = jobnr, mb, q = 0;
906 
907  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
908  while (ctx->mb_width - x < mbs_per_slice)
909  mbs_per_slice >>= 1;
910  q = find_slice_quant(avctx, avctx->coded_frame,
911  (mb + 1) * TRELLIS_WIDTH, x, y,
912  mbs_per_slice, td);
913  }
914 
915  for (x = ctx->slices_width - 1; x >= 0; x--) {
916  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
917  q = td->nodes[q].prev_node;
918  }
919 
920  return 0;
921 }
922 
923 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
924  const AVFrame *pic, int *got_packet)
925 {
926  ProresContext *ctx = avctx->priv_data;
927  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
928  uint8_t *picture_size_pos;
929  PutBitContext pb;
930  int x, y, i, mb, q = 0;
931  int sizes[4] = { 0 };
932  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
933  int frame_size, picture_size, slice_size;
934  int pkt_size, ret;
935  uint8_t frame_flags;
936 
937  *avctx->coded_frame = *pic;
939  avctx->coded_frame->key_frame = 1;
940 
941  pkt_size = ctx->frame_size_upper_bound + FF_MIN_BUFFER_SIZE;
942 
943  if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) {
944  av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
945  return ret;
946  }
947 
948  orig_buf = pkt->data;
949 
950  // frame atom
951  orig_buf += 4; // frame size
952  bytestream_put_be32 (&orig_buf, FRAME_ID); // frame container ID
953  buf = orig_buf;
954 
955  // frame header
956  tmp = buf;
957  buf += 2; // frame header size will be stored here
958  bytestream_put_be16 (&buf, 0); // version 1
959  bytestream_put_buffer(&buf, ctx->vendor, 4);
960  bytestream_put_be16 (&buf, avctx->width);
961  bytestream_put_be16 (&buf, avctx->height);
962 
963  frame_flags = ctx->chroma_factor << 6;
964  if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)
965  frame_flags |= pic->top_field_first ? 0x04 : 0x08;
966  bytestream_put_byte (&buf, frame_flags);
967 
968  bytestream_put_byte (&buf, 0); // reserved
969  bytestream_put_byte (&buf, avctx->color_primaries);
970  bytestream_put_byte (&buf, avctx->color_trc);
971  bytestream_put_byte (&buf, avctx->colorspace);
972  bytestream_put_byte (&buf, 0x40 | (ctx->alpha_bits >> 3));
973  bytestream_put_byte (&buf, 0); // reserved
974  if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
975  bytestream_put_byte (&buf, 0x03); // matrix flags - both matrices are present
976  // luma quantisation matrix
977  for (i = 0; i < 64; i++)
978  bytestream_put_byte(&buf, ctx->quant_mat[i]);
979  // chroma quantisation matrix
980  for (i = 0; i < 64; i++)
981  bytestream_put_byte(&buf, ctx->quant_mat[i]);
982  } else {
983  bytestream_put_byte (&buf, 0x00); // matrix flags - default matrices are used
984  }
985  bytestream_put_be16 (&tmp, buf - orig_buf); // write back frame header size
986 
987  for (ctx->cur_picture_idx = 0;
989  ctx->cur_picture_idx++) {
990  // picture header
991  picture_size_pos = buf + 1;
992  bytestream_put_byte (&buf, 0x40); // picture header size (in bits)
993  buf += 4; // picture data size will be stored here
994  bytestream_put_be16 (&buf, ctx->slices_per_picture);
995  bytestream_put_byte (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
996 
997  // seek table - will be filled during slice encoding
998  slice_sizes = buf;
999  buf += ctx->slices_per_picture * 2;
1000 
1001  // slices
1002  if (!ctx->force_quant) {
1003  ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
1004  ctx->mb_height);
1005  if (ret)
1006  return ret;
1007  }
1008 
1009  for (y = 0; y < ctx->mb_height; y++) {
1010  int mbs_per_slice = ctx->mbs_per_slice;
1011  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1012  q = ctx->force_quant ? ctx->force_quant
1013  : ctx->slice_q[mb + y * ctx->slices_width];
1014 
1015  while (ctx->mb_width - x < mbs_per_slice)
1016  mbs_per_slice >>= 1;
1017 
1018  bytestream_put_byte(&buf, slice_hdr_size << 3);
1019  slice_hdr = buf;
1020  buf += slice_hdr_size - 1;
1021  init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)) * 8);
1022  encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
1023 
1024  bytestream_put_byte(&slice_hdr, q);
1025  slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1026  for (i = 0; i < ctx->num_planes - 1; i++) {
1027  bytestream_put_be16(&slice_hdr, sizes[i]);
1028  slice_size += sizes[i];
1029  }
1030  bytestream_put_be16(&slice_sizes, slice_size);
1031  buf += slice_size - slice_hdr_size;
1032  }
1033  }
1034 
1035  if (ctx->pictures_per_frame == 1)
1036  picture_size = buf - picture_size_pos - 6;
1037  else
1038  picture_size = buf - picture_size_pos + 1;
1039  bytestream_put_be32(&picture_size_pos, picture_size);
1040  }
1041 
1042  orig_buf -= 8;
1043  frame_size = buf - orig_buf;
1044  bytestream_put_be32(&orig_buf, frame_size);
1045 
1046  pkt->size = frame_size;
1047  pkt->flags |= AV_PKT_FLAG_KEY;
1048  *got_packet = 1;
1049 
1050  return 0;
1051 }
1052 
1054 {
1055  ProresContext *ctx = avctx->priv_data;
1056  int i;
1057 
1058  av_freep(&avctx->coded_frame);
1059 
1060  if (ctx->tdata) {
1061  for (i = 0; i < avctx->thread_count; i++)
1062  av_free(ctx->tdata[i].nodes);
1063  }
1064  av_freep(&ctx->tdata);
1065  av_freep(&ctx->slice_q);
1066 
1067  return 0;
1068 }
1069 
1070 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1071  int linesize, int16_t *block)
1072 {
1073  int x, y;
1074  const uint16_t *tsrc = src;
1075 
1076  for (y = 0; y < 8; y++) {
1077  for (x = 0; x < 8; x++)
1078  block[y * 8 + x] = tsrc[x];
1079  tsrc += linesize >> 1;
1080  }
1081  fdsp->fdct(block);
1082 }
1083 
1085 {
1086  ProresContext *ctx = avctx->priv_data;
1087  int mps;
1088  int i, j;
1089  int min_quant, max_quant;
1090  int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
1091 
1092  avctx->bits_per_raw_sample = 10;
1093  avctx->coded_frame = av_frame_alloc();
1094  if (!avctx->coded_frame)
1095  return AVERROR(ENOMEM);
1096 
1097  ctx->fdct = prores_fdct;
1098  ctx->scantable = interlaced ? ff_prores_interlaced_scan
1100  ff_fdctdsp_init(&ctx->fdsp, avctx);
1101 
1102  mps = ctx->mbs_per_slice;
1103  if (mps & (mps - 1)) {
1104  av_log(avctx, AV_LOG_ERROR,
1105  "there should be an integer power of two MBs per slice\n");
1106  return AVERROR(EINVAL);
1107  }
1109  if (ctx->alpha_bits & 7) {
1110  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1111  return AVERROR(EINVAL);
1112  }
1113  } else {
1114  ctx->alpha_bits = 0;
1115  }
1116 
1117  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1118  ? CFACTOR_Y422
1119  : CFACTOR_Y444;
1121  ctx->num_planes = 3 + !!ctx->alpha_bits;
1122 
1123  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1124 
1125  if (interlaced)
1126  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1127  else
1128  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1129 
1130  ctx->slices_width = ctx->mb_width / mps;
1131  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1132  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1133  ctx->pictures_per_frame = 1 + interlaced;
1134 
1135  if (ctx->quant_sel == -1)
1137  else
1139 
1140  if (strlen(ctx->vendor) != 4) {
1141  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1142  return AVERROR_INVALIDDATA;
1143  }
1144 
1145  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1146  if (!ctx->force_quant) {
1147  if (!ctx->bits_per_mb) {
1148  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1149  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1150  ctx->pictures_per_frame)
1151  break;
1152  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1153  } else if (ctx->bits_per_mb < 128) {
1154  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1155  return AVERROR_INVALIDDATA;
1156  }
1157 
1158  min_quant = ctx->profile_info->min_quant;
1159  max_quant = ctx->profile_info->max_quant;
1160  for (i = min_quant; i < MAX_STORED_Q; i++) {
1161  for (j = 0; j < 64; j++)
1162  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1163  }
1164 
1165  ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1166  if (!ctx->slice_q) {
1167  encode_close(avctx);
1168  return AVERROR(ENOMEM);
1169  }
1170 
1171  ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1172  if (!ctx->tdata) {
1173  encode_close(avctx);
1174  return AVERROR(ENOMEM);
1175  }
1176 
1177  for (j = 0; j < avctx->thread_count; j++) {
1178  ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1179  * TRELLIS_WIDTH
1180  * sizeof(*ctx->tdata->nodes));
1181  if (!ctx->tdata[j].nodes) {
1182  encode_close(avctx);
1183  return AVERROR(ENOMEM);
1184  }
1185  for (i = min_quant; i < max_quant + 2; i++) {
1186  ctx->tdata[j].nodes[i].prev_node = -1;
1187  ctx->tdata[j].nodes[i].bits = 0;
1188  ctx->tdata[j].nodes[i].score = 0;
1189  }
1190  }
1191  } else {
1192  int ls = 0;
1193 
1194  if (ctx->force_quant > 64) {
1195  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1196  return AVERROR_INVALIDDATA;
1197  }
1198 
1199  for (j = 0; j < 64; j++) {
1200  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1201  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1202  }
1203 
1204  ctx->bits_per_mb = ls * 8;
1205  if (ctx->chroma_factor == CFACTOR_Y444)
1206  ctx->bits_per_mb += ls * 4;
1207  if (ctx->num_planes == 4)
1208  ctx->bits_per_mb += ls * 4;
1209  }
1210 
1212  ctx->slices_per_picture *
1213  (2 + 2 * ctx->num_planes +
1214  (mps * ctx->bits_per_mb) / 8)
1215  + 200;
1216 
1217  avctx->codec_tag = ctx->profile_info->tag;
1218 
1219  av_log(avctx, AV_LOG_DEBUG,
1220  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1221  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1222  interlaced ? "yes" : "no", ctx->bits_per_mb);
1223  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1224  ctx->frame_size_upper_bound);
1225 
1226  return 0;
1227 }
1228 
1229 #define OFFSET(x) offsetof(ProresContext, x)
1230 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1231 
1232 static const AVOption options[] = {
1233  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1234  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1235  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1236  { .i64 = PRORES_PROFILE_STANDARD },
1238  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1239  0, 0, VE, "profile" },
1240  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1241  0, 0, VE, "profile" },
1242  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1243  0, 0, VE, "profile" },
1244  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1245  0, 0, VE, "profile" },
1246  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1247  0, 0, VE, "profile" },
1248  { "vendor", "vendor ID", OFFSET(vendor),
1249  AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
1250  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1251  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1252  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1253  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1254  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1255  0, 0, VE, "quant_mat" },
1256  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1257  0, 0, VE, "quant_mat" },
1258  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1259  0, 0, VE, "quant_mat" },
1260  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1261  0, 0, VE, "quant_mat" },
1262  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1263  0, 0, VE, "quant_mat" },
1264  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1265  0, 0, VE, "quant_mat" },
1266  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1267  { .i64 = 16 }, 0, 16, VE },
1268  { NULL }
1269 };
1270 
1271 static const AVClass proresenc_class = {
1272  .class_name = "ProRes encoder",
1273  .item_name = av_default_item_name,
1274  .option = options,
1275  .version = LIBAVUTIL_VERSION_INT,
1276 };
1277 
1279  .name = "prores",
1280  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1281  .type = AVMEDIA_TYPE_VIDEO,
1282  .id = AV_CODEC_ID_PRORES,
1283  .priv_data_size = sizeof(ProresContext),
1284  .init = encode_init,
1285  .close = encode_close,
1286  .encode2 = encode_frame,
1287  .capabilities = CODEC_CAP_SLICE_THREADS,
1288  .pix_fmts = (const enum AVPixelFormat[]) {
1291  },
1292  .priv_class = &proresenc_class,
1293 };
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:597
void(* fdct)(FDCTDSPContext *fdsp, const uint16_t *src, int linesize, int16_t *block)
Definition: proresenc.c:194
#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:1599
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
AVOption.
Definition: opt.h:234
#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:1278
const uint8_t ff_prores_ac_codebook[7]
Definition: proresdata.c:55
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2526
static int estimate_vlc(unsigned codebook, int val)
Definition: proresenc.c:575
int mbs_per_slice
Definition: proresenc.c:199
int prev_node
Definition: proresenc.c:170
int size
Definition: avcodec.h:968
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1248
int pictures_per_frame
Definition: proresenc.c:203
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:899
#define GET_SIGN(x)
Definition: proresenc.c:354
const uint8_t * scantable
Definition: proresenc.c:192
uint8_t run
Definition: svq3.c:146
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2508
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
AVCodec.
Definition: avcodec.h:2790
static int estimate_slice_plane(ProresContext *ctx, int *error, int plane, const uint16_t *src, int linesize, int mbs_per_slice, int blocks_per_mb, int plane_size_factor, const int16_t *qmat, ProresThreadData *td)
Definition: proresenc.c:664
#define OFFSET(x)
Definition: proresenc.c:1229
int16_t quants[MAX_STORED_Q][64]
Definition: proresenc.c:189
#define FFALIGN(x, a)
Definition: common.h:62
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:198
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:38
char * vendor
Definition: proresenc.c:210
const char * full_name
Definition: proresenc.c:117
uint8_t bits
Definition: crc.c:251
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:138
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:57
float delta
AVOptions.
static const int prores_mb_limits[NUM_MB_LIMITS]
Definition: proresenc.c:109
#define SCORE_LIMIT
Definition: proresenc.c:167
uint8_t * data
Definition: avcodec.h:967
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
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1013
static const uint8_t frame_size[4]
Definition: g723_1_data.h:47
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:503
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:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
static const struct prores_profile prores_profile_info[5]
static const uint16_t mask[17]
Definition: lzw.c:38
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:325
static const uint8_t prores_quant_matrices[][64]
Definition: proresenc.c:55
static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic, int trellis_node, int x, int y, int mbs_per_slice, ProresThreadData *td)
Definition: proresenc.c:742
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:150
int16_t custom_q[64]
Definition: proresenc.c:181
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
#define MAX_STORED_Q
Definition: proresenc.c:176
const struct prores_profile * profile_info
Definition: proresenc.c:216
uint16_t emu_buf[16 *16]
Definition: proresenc.c:188
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1138
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:168
#define TRELLIS_WIDTH
Definition: proresenc.c:166
const char * name
Name of the codec implementation.
Definition: avcodec.h:2797
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:245
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:923
ProresThreadData * tdata
Definition: proresenc.c:220
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:973
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:1271
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:383
static void get_slice_data(ProresContext *ctx, const uint16_t *src, int 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:223
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:196
#define FFMIN(a, b)
Definition: common.h:57
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:538
int num_chroma_blocks
number of chrominance blocks in a macroblock
Definition: proresdec.c:70
int width
picture width / height.
Definition: avcodec.h:1218
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:1739
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:628
#define FFABS(a)
Definition: common.h:52
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: utils.c:1236
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:655
uint32_t tag
Definition: proresenc.c:118
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:259
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:2534
#define MAKE_CODE(x)
Definition: proresenc.c:355
static av_cold int encode_init(AVCodecContext *avctx)
Definition: proresenc.c:1084
#define FIRST_DC_CB
Definition: proresdata.h:33
static const AVOption options[]
Definition: proresenc.c:1232
NULL
Definition: eval.c:55
int chroma_factor
Definition: proresdec.c:68
int slices_per_picture
Definition: proresenc.c:202
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, int linesize, int mbs_per_slice, uint16_t *blocks, int quant)
Definition: proresenc.c:470
Libavcodec external API header.
ScanTable scantable
Definition: proresdec.c:57
int * slice_q
Definition: proresenc.c:218
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
av_default_item_name
Definition: dnxhdenc.c:52
uint8_t flags
Definition: pixdesc.h:90
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
main external API structure.
Definition: avcodec.h:1044
FDCTDSPContext fdsp
Definition: proresenc.c:196
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1076
#define CFACTOR_Y422
Definition: proresenc.c:32
Describe the class of an AVClass context structure.
Definition: log.h:33
#define VE
Definition: proresenc.c:1230
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1753
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1746
int16_t custom_q[64]
Definition: proresenc.c:190
static void get_alpha_data(ProresContext *ctx, const uint16_t *src, int linesize, int x, int y, int w, int h, int16_t *blocks, int mbs_per_slice, int abits)
Definition: proresenc.c:294
const uint8_t * quant
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1124
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:244
static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
Definition: proresenc.c:436
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
uint8_t level
Definition: svq3.c:147
static int est_alpha_diff(int cur, int prev, int abits)
Definition: proresenc.c:682
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define NUM_MB_LIMITS
Definition: proresenc.c:108
int br_tab[NUM_MB_LIMITS]
Definition: proresenc.c:121
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:759
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
static int estimate_alpha_plane(ProresContext *ctx, int *error, const uint16_t *src, int linesize, int mbs_per_slice, int quant, int16_t *blocks)
Definition: proresenc.c:698
#define CFACTOR_Y444
Definition: proresenc.c:33
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:499
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:363
void * priv_data
Definition: avcodec.h:1086
int cur_picture_idx
Definition: proresenc.c:204
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:325
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:2594
#define av_log2
Definition: intmath.h:85
static void put_alpha_run(PutBitContext *pb, int run)
Definition: proresenc.c:456
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:191
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:207
#define MAX_PLANES
Definition: proresenc.c:37
static void encode_dcs(PutBitContext *pb, int16_t *blocks, int blocks_per_slice, int scale)
Definition: proresenc.c:357
static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src, int linesize, int16_t *block)
Definition: proresenc.c:1070
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:238
int frame_size_upper_bound
Definition: proresenc.c:213
static av_cold int encode_close(AVCodecContext *avctx)
Definition: proresenc.c:1053
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:944
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:205
static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb, const uint16_t *src, int linesize, int mbs_per_slice, int16_t *blocks, int blocks_per_mb, int plane_size_factor, const int16_t *qmat)
Definition: proresenc.c:417
int slices_width
Definition: proresenc.c:201
int16_t blocks[8 *4 *64]
Definition: proresdec.c:49
bitstream writer API
static int16_t block[64]
Definition: dct-test.c:88