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