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 "dsputil.h"
30 #include "put_bits.h"
31 #include "bytestream.h"
32 #include "internal.h"
33 #include "proresdsp.h"
34 #include "proresdata.h"
35 
36 #define CFACTOR_Y422 2
37 #define CFACTOR_Y444 3
38 
39 #define MAX_MBS_PER_SLICE 8
40 
41 #define MAX_PLANES 4
42 
43 enum {
44  PRORES_PROFILE_PROXY = 0,
45  PRORES_PROFILE_LT,
46  PRORES_PROFILE_STANDARD,
47  PRORES_PROFILE_HQ,
48  PRORES_PROFILE_4444,
49 };
50 
51 enum {
52  QUANT_MAT_PROXY = 0,
53  QUANT_MAT_LT,
54  QUANT_MAT_STANDARD,
55  QUANT_MAT_HQ,
56  QUANT_MAT_DEFAULT,
57 };
58 
59 static const uint8_t prores_quant_matrices[][64] = {
60  { // proxy
61  4, 7, 9, 11, 13, 14, 15, 63,
62  7, 7, 11, 12, 14, 15, 63, 63,
63  9, 11, 13, 14, 15, 63, 63, 63,
64  11, 11, 13, 14, 63, 63, 63, 63,
65  11, 13, 14, 63, 63, 63, 63, 63,
66  13, 14, 63, 63, 63, 63, 63, 63,
67  13, 63, 63, 63, 63, 63, 63, 63,
68  63, 63, 63, 63, 63, 63, 63, 63,
69  },
70  { // LT
71  4, 5, 6, 7, 9, 11, 13, 15,
72  5, 5, 7, 8, 11, 13, 15, 17,
73  6, 7, 9, 11, 13, 15, 15, 17,
74  7, 7, 9, 11, 13, 15, 17, 19,
75  7, 9, 11, 13, 14, 16, 19, 23,
76  9, 11, 13, 14, 16, 19, 23, 29,
77  9, 11, 13, 15, 17, 21, 28, 35,
78  11, 13, 16, 17, 21, 28, 35, 41,
79  },
80  { // standard
81  4, 4, 5, 5, 6, 7, 7, 9,
82  4, 4, 5, 6, 7, 7, 9, 9,
83  5, 5, 6, 7, 7, 9, 9, 10,
84  5, 5, 6, 7, 7, 9, 9, 10,
85  5, 6, 7, 7, 8, 9, 10, 12,
86  6, 7, 7, 8, 9, 10, 12, 15,
87  6, 7, 7, 9, 10, 11, 14, 17,
88  7, 7, 9, 10, 11, 14, 17, 21,
89  },
90  { // high quality
91  4, 4, 4, 4, 4, 4, 4, 4,
92  4, 4, 4, 4, 4, 4, 4, 4,
93  4, 4, 4, 4, 4, 4, 4, 4,
94  4, 4, 4, 4, 4, 4, 4, 5,
95  4, 4, 4, 4, 4, 4, 5, 5,
96  4, 4, 4, 4, 4, 5, 5, 6,
97  4, 4, 4, 4, 5, 5, 6, 7,
98  4, 4, 4, 4, 5, 6, 7, 7,
99  },
100  { // codec default
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  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, 4,
108  4, 4, 4, 4, 4, 4, 4, 4,
109  },
110 };
111 
112 #define NUM_MB_LIMITS 4
113 static const int prores_mb_limits[NUM_MB_LIMITS] = {
114  1620, // up to 720x576
115  2700, // up to 960x720
116  6075, // up to 1440x1080
117  9216, // up to 2048x1152
118 };
119 
120 static const struct prores_profile {
121  const char *full_name;
122  uint32_t tag;
123  int min_quant;
124  int max_quant;
125  int br_tab[NUM_MB_LIMITS];
126  int quant;
127 } prores_profile_info[5] = {
128  {
129  .full_name = "proxy",
130  .tag = MKTAG('a', 'p', 'c', 'o'),
131  .min_quant = 4,
132  .max_quant = 8,
133  .br_tab = { 300, 242, 220, 194 },
134  .quant = QUANT_MAT_PROXY,
135  },
136  {
137  .full_name = "LT",
138  .tag = MKTAG('a', 'p', 'c', 's'),
139  .min_quant = 1,
140  .max_quant = 9,
141  .br_tab = { 720, 560, 490, 440 },
142  .quant = QUANT_MAT_LT,
143  },
144  {
145  .full_name = "standard",
146  .tag = MKTAG('a', 'p', 'c', 'n'),
147  .min_quant = 1,
148  .max_quant = 6,
149  .br_tab = { 1050, 808, 710, 632 },
150  .quant = QUANT_MAT_STANDARD,
151  },
152  {
153  .full_name = "high quality",
154  .tag = MKTAG('a', 'p', 'c', 'h'),
155  .min_quant = 1,
156  .max_quant = 6,
157  .br_tab = { 1566, 1216, 1070, 950 },
158  .quant = QUANT_MAT_HQ,
159  },
160  {
161  .full_name = "4444",
162  .tag = MKTAG('a', 'p', '4', 'h'),
163  .min_quant = 1,
164  .max_quant = 6,
165  .br_tab = { 2350, 1828, 1600, 1425 },
166  .quant = QUANT_MAT_HQ,
167  }
168 };
169 
170 #define TRELLIS_WIDTH 16
171 #define SCORE_LIMIT INT_MAX / 2
172 
173 struct TrellisNode {
174  int prev_node;
175  int quant;
176  int bits;
177  int score;
178 };
179 
180 #define MAX_STORED_Q 16
181 
182 typedef struct ProresThreadData {
183  DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
184  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
185  int16_t custom_q[64];
186  struct TrellisNode *nodes;
187 } ProresThreadData;
188 
189 typedef struct ProresContext {
190  AVClass *class;
191  DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
192  DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
193  int16_t quants[MAX_STORED_Q][64];
194  int16_t custom_q[64];
195  const uint8_t *quant_mat;
196 
197  ProresDSPContext dsp;
198  ScanTable scantable;
199 
200  int mb_width, mb_height;
201  int mbs_per_slice;
202  int num_chroma_blocks, chroma_factor;
203  int slices_width;
204  int slices_per_picture;
205  int pictures_per_frame; // 1 for progressive, 2 for interlaced
206  int cur_picture_idx;
207  int num_planes;
208  int bits_per_mb;
209  int force_quant;
210  int alpha_bits;
211 
212  char *vendor;
213  int quant_sel;
214 
215  int frame_size_upper_bound;
216 
217  int profile;
218  const struct prores_profile *profile_info;
219 
220  int *slice_q;
221 
222  ProresThreadData *tdata;
223 } ProresContext;
224 
225 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
226  int linesize, int x, int y, int w, int h,
227  int16_t *blocks, uint16_t *emu_buf,
228  int mbs_per_slice, int blocks_per_mb, int is_chroma)
229 {
230  const uint16_t *esrc;
231  const int mb_width = 4 * blocks_per_mb;
232  int elinesize;
233  int i, j, k;
234 
235  for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
236  if (x >= w) {
237  memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
238  * sizeof(*blocks));
239  return;
240  }
241  if (x + mb_width <= w && y + 16 <= h) {
242  esrc = src;
243  elinesize = linesize;
244  } else {
245  int bw, bh, pix;
246 
247  esrc = emu_buf;
248  elinesize = 16 * sizeof(*emu_buf);
249 
250  bw = FFMIN(w - x, mb_width);
251  bh = FFMIN(h - y, 16);
252 
253  for (j = 0; j < bh; j++) {
254  memcpy(emu_buf + j * 16,
255  (const uint8_t*)src + j * linesize,
256  bw * sizeof(*src));
257  pix = emu_buf[j * 16 + bw - 1];
258  for (k = bw; k < mb_width; k++)
259  emu_buf[j * 16 + k] = pix;
260  }
261  for (; j < 16; j++)
262  memcpy(emu_buf + j * 16,
263  emu_buf + (bh - 1) * 16,
264  mb_width * sizeof(*emu_buf));
265  }
266  if (!is_chroma) {
267  ctx->dsp.fdct(esrc, elinesize, blocks);
268  blocks += 64;
269  if (blocks_per_mb > 2) {
270  ctx->dsp.fdct(esrc + 8, elinesize, blocks);
271  blocks += 64;
272  }
273  ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
274  blocks += 64;
275  if (blocks_per_mb > 2) {
276  ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
277  blocks += 64;
278  }
279  } else {
280  ctx->dsp.fdct(esrc, elinesize, blocks);
281  blocks += 64;
282  ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
283  blocks += 64;
284  if (blocks_per_mb > 2) {
285  ctx->dsp.fdct(esrc + 8, elinesize, blocks);
286  blocks += 64;
287  ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
288  blocks += 64;
289  }
290  }
291 
292  x += mb_width;
293  }
294 }
295 
296 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
297  int linesize, int x, int y, int w, int h,
298  int16_t *blocks, int mbs_per_slice, int abits)
299 {
300  const int slice_width = 16 * mbs_per_slice;
301  int i, j, copy_w, copy_h;
302 
303  copy_w = FFMIN(w - x, slice_width);
304  copy_h = FFMIN(h - y, 16);
305  for (i = 0; i < copy_h; i++) {
306  memcpy(blocks, src, copy_w * sizeof(*src));
307  if (abits == 8)
308  for (j = 0; j < copy_w; j++)
309  blocks[j] >>= 2;
310  else
311  for (j = 0; j < copy_w; j++)
312  blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
313  for (j = copy_w; j < slice_width; j++)
314  blocks[j] = blocks[copy_w - 1];
315  blocks += slice_width;
316  src += linesize >> 1;
317  }
318  for (; i < 16; i++) {
319  memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
320  blocks += slice_width;
321  }
322 }
323 
324 /**
325  * Write an unsigned rice/exp golomb codeword.
326  */
327 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
328 {
329  unsigned int rice_order, exp_order, switch_bits, switch_val;
330  int exponent;
331 
332  /* number of prefix bits to switch between Rice and expGolomb */
333  switch_bits = (codebook & 3) + 1;
334  rice_order = codebook >> 5; /* rice code order */
335  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
336 
337  switch_val = switch_bits << rice_order;
338 
339  if (val >= switch_val) {
340  val -= switch_val - (1 << exp_order);
341  exponent = av_log2(val);
342 
343  put_bits(pb, exponent - exp_order + switch_bits, 0);
344  put_bits(pb, exponent + 1, val);
345  } else {
346  exponent = val >> rice_order;
347 
348  if (exponent)
349  put_bits(pb, exponent, 0);
350  put_bits(pb, 1, 1);
351  if (rice_order)
352  put_sbits(pb, rice_order, val);
353  }
354 }
355 
356 #define GET_SIGN(x) ((x) >> 31)
357 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
358 
359 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
360  int blocks_per_slice, int scale)
361 {
362  int i;
363  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
364 
365  prev_dc = (blocks[0] - 0x4000) / scale;
366  encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
367  sign = 0;
368  codebook = 3;
369  blocks += 64;
370 
371  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
372  dc = (blocks[0] - 0x4000) / scale;
373  delta = dc - prev_dc;
374  new_sign = GET_SIGN(delta);
375  delta = (delta ^ sign) - sign;
376  code = MAKE_CODE(delta);
377  encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
378  codebook = (code + (code & 1)) >> 1;
379  codebook = FFMIN(codebook, 3);
380  sign = new_sign;
381  prev_dc = dc;
382  }
383 }
384 
385 static void encode_acs(PutBitContext *pb, int16_t *blocks,
386  int blocks_per_slice,
387  int plane_size_factor,
388  const uint8_t *scan, const int16_t *qmat)
389 {
390  int idx, i;
391  int run, level, run_cb, lev_cb;
392  int max_coeffs, abs_level;
393 
394  max_coeffs = blocks_per_slice << 6;
395  run_cb = ff_prores_run_to_cb_index[4];
396  lev_cb = ff_prores_lev_to_cb_index[2];
397  run = 0;
398 
399  for (i = 1; i < 64; i++) {
400  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
401  level = blocks[idx] / qmat[scan[i]];
402  if (level) {
403  abs_level = FFABS(level);
404  encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
405  encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],
406  abs_level - 1);
407  put_sbits(pb, 1, GET_SIGN(level));
408 
409  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
410  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
411  run = 0;
412  } else {
413  run++;
414  }
415  }
416  }
417 }
418 
419 static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
420  const uint16_t *src, int linesize,
421  int mbs_per_slice, int16_t *blocks,
422  int blocks_per_mb, int plane_size_factor,
423  const int16_t *qmat)
424 {
425  int blocks_per_slice, saved_pos;
426 
427  saved_pos = put_bits_count(pb);
428  blocks_per_slice = mbs_per_slice * blocks_per_mb;
429 
430  encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
431  encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
432  ctx->scantable.permutated, qmat);
433  flush_put_bits(pb);
434 
435  return (put_bits_count(pb) - saved_pos) >> 3;
436 }
437 
438 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
439 {
440  const int mask = (1 << abits) - 1;
441  const int dbits = (abits == 8) ? 4 : 7;
442  const int dsize = 1 << dbits - 1;
443  int diff = cur - prev;
444 
445  diff &= mask;
446  if (diff >= (1 << abits) - dsize)
447  diff -= 1 << abits;
448  if (diff < -dsize || diff > dsize || !diff) {
449  put_bits(pb, 1, 1);
450  put_bits(pb, abits, diff);
451  } else {
452  put_bits(pb, 1, 0);
453  put_bits(pb, dbits - 1, FFABS(diff) - 1);
454  put_bits(pb, 1, diff < 0);
455  }
456 }
457 
458 static void put_alpha_run(PutBitContext *pb, int run)
459 {
460  if (run) {
461  put_bits(pb, 1, 0);
462  if (run < 0x10)
463  put_bits(pb, 4, run);
464  else
465  put_bits(pb, 15, run);
466  } else {
467  put_bits(pb, 1, 1);
468  }
469 }
470 
471 // todo alpha quantisation for high quants
472 static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
473  const uint16_t *src, int linesize,
474  int mbs_per_slice, uint16_t *blocks,
475  int quant)
476 {
477  const int abits = ctx->alpha_bits;
478  const int mask = (1 << abits) - 1;
479  const int num_coeffs = mbs_per_slice * 256;
480  int saved_pos = put_bits_count(pb);
481  int prev = mask, cur;
482  int idx = 0;
483  int run = 0;
484 
485  cur = blocks[idx++];
486  put_alpha_diff(pb, cur, prev, abits);
487  prev = cur;
488  do {
489  cur = blocks[idx++];
490  if (cur != prev) {
491  put_alpha_run (pb, run);
492  put_alpha_diff(pb, cur, prev, abits);
493  prev = cur;
494  run = 0;
495  } else {
496  run++;
497  }
498  } while (idx < num_coeffs);
499  if (run)
500  put_alpha_run(pb, run);
501  flush_put_bits(pb);
502  return (put_bits_count(pb) - saved_pos) >> 3;
503 }
504 
505 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
506  PutBitContext *pb,
507  int sizes[4], int x, int y, int quant,
508  int mbs_per_slice)
509 {
510  ProresContext *ctx = avctx->priv_data;
511  int i, xp, yp;
512  int total_size = 0;
513  const uint16_t *src;
514  int slice_width_factor = av_log2(mbs_per_slice);
515  int num_cblocks, pwidth, linesize, line_add;
516  int plane_factor, is_chroma;
517  uint16_t *qmat;
518 
519  if (ctx->pictures_per_frame == 1)
520  line_add = 0;
521  else
522  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
523 
524  if (ctx->force_quant) {
525  qmat = ctx->quants[0];
526  } else if (quant < MAX_STORED_Q) {
527  qmat = ctx->quants[quant];
528  } else {
529  qmat = ctx->custom_q;
530  for (i = 0; i < 64; i++)
531  qmat[i] = ctx->quant_mat[i] * quant;
532  }
533 
534  for (i = 0; i < ctx->num_planes; i++) {
535  is_chroma = (i == 1 || i == 2);
536  plane_factor = slice_width_factor + 2;
537  if (is_chroma)
538  plane_factor += ctx->chroma_factor - 3;
539  if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
540  xp = x << 4;
541  yp = y << 4;
542  num_cblocks = 4;
543  pwidth = avctx->width;
544  } else {
545  xp = x << 3;
546  yp = y << 4;
547  num_cblocks = 2;
548  pwidth = avctx->width >> 1;
549  }
550 
551  linesize = pic->linesize[i] * ctx->pictures_per_frame;
552  src = (const uint16_t*)(pic->data[i] + yp * linesize +
553  line_add * pic->linesize[i]) + xp;
554 
555  if (i < 3) {
556  get_slice_data(ctx, src, linesize, xp, yp,
557  pwidth, avctx->height / ctx->pictures_per_frame,
558  ctx->blocks[0], ctx->emu_buf,
559  mbs_per_slice, num_cblocks, is_chroma);
560  sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
561  mbs_per_slice, ctx->blocks[0],
562  num_cblocks, plane_factor,
563  qmat);
564  } else {
565  get_alpha_data(ctx, src, linesize, xp, yp,
566  pwidth, avctx->height / ctx->pictures_per_frame,
567  ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
568  sizes[i] = encode_alpha_plane(ctx, pb, src, linesize,
569  mbs_per_slice, ctx->blocks[0],
570  quant);
571  }
572  total_size += sizes[i];
573  }
574  return total_size;
575 }
576 
577 static inline int estimate_vlc(unsigned codebook, int val)
578 {
579  unsigned int rice_order, exp_order, switch_bits, switch_val;
580  int exponent;
581 
582  /* number of prefix bits to switch between Rice and expGolomb */
583  switch_bits = (codebook & 3) + 1;
584  rice_order = codebook >> 5; /* rice code order */
585  exp_order = (codebook >> 2) & 7; /* exp golomb code order */
586 
587  switch_val = switch_bits << rice_order;
588 
589  if (val >= switch_val) {
590  val -= switch_val - (1 << exp_order);
591  exponent = av_log2(val);
592 
593  return exponent * 2 - exp_order + switch_bits + 1;
594  } else {
595  return (val >> rice_order) + rice_order + 1;
596  }
597 }
598 
599 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
600  int scale)
601 {
602  int i;
603  int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
604  int bits;
605 
606  prev_dc = (blocks[0] - 0x4000) / scale;
607  bits = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
608  sign = 0;
609  codebook = 3;
610  blocks += 64;
611  *error += FFABS(blocks[0] - 0x4000) % scale;
612 
613  for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
614  dc = (blocks[0] - 0x4000) / scale;
615  *error += FFABS(blocks[0] - 0x4000) % scale;
616  delta = dc - prev_dc;
617  new_sign = GET_SIGN(delta);
618  delta = (delta ^ sign) - sign;
619  code = MAKE_CODE(delta);
620  bits += estimate_vlc(ff_prores_dc_codebook[codebook], code);
621  codebook = (code + (code & 1)) >> 1;
622  codebook = FFMIN(codebook, 3);
623  sign = new_sign;
624  prev_dc = dc;
625  }
626 
627  return bits;
628 }
629 
630 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
631  int plane_size_factor,
632  const uint8_t *scan, const int16_t *qmat)
633 {
634  int idx, i;
635  int run, level, run_cb, lev_cb;
636  int max_coeffs, abs_level;
637  int bits = 0;
638 
639  max_coeffs = blocks_per_slice << 6;
640  run_cb = ff_prores_run_to_cb_index[4];
641  lev_cb = ff_prores_lev_to_cb_index[2];
642  run = 0;
643 
644  for (i = 1; i < 64; i++) {
645  for (idx = scan[i]; idx < max_coeffs; idx += 64) {
646  level = blocks[idx] / qmat[scan[i]];
647  *error += FFABS(blocks[idx]) % qmat[scan[i]];
648  if (level) {
649  abs_level = FFABS(level);
650  bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
651  bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
652  abs_level - 1) + 1;
653 
654  run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
655  lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
656  run = 0;
657  } else {
658  run++;
659  }
660  }
661  }
662 
663  return bits;
664 }
665 
666 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
667  const uint16_t *src, int linesize,
668  int mbs_per_slice,
669  int blocks_per_mb, int plane_size_factor,
670  const int16_t *qmat, ProresThreadData *td)
671 {
672  int blocks_per_slice;
673  int bits;
674 
675  blocks_per_slice = mbs_per_slice * blocks_per_mb;
676 
677  bits = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
678  bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
679  plane_size_factor, ctx->scantable.permutated, qmat);
680 
681  return FFALIGN(bits, 8);
682 }
683 
684 static int est_alpha_diff(int cur, int prev, int abits)
685 {
686  const int mask = (1 << abits) - 1;
687  const int dbits = (abits == 8) ? 4 : 7;
688  const int dsize = 1 << dbits - 1;
689  int diff = cur - prev;
690 
691  diff &= mask;
692  if (diff >= (1 << abits) - dsize)
693  diff -= 1 << abits;
694  if (diff < -dsize || diff > dsize || !diff)
695  return abits + 1;
696  else
697  return dbits + 1;
698 }
699 
700 static int estimate_alpha_plane(ProresContext *ctx, int *error,
701  const uint16_t *src, int linesize,
702  int mbs_per_slice, int quant,
703  int16_t *blocks)
704 {
705  const int abits = ctx->alpha_bits;
706  const int mask = (1 << abits) - 1;
707  const int num_coeffs = mbs_per_slice * 256;
708  int prev = mask, cur;
709  int idx = 0;
710  int run = 0;
711  int bits;
712 
713  *error = 0;
714  cur = blocks[idx++];
715  bits = est_alpha_diff(cur, prev, abits);
716  prev = cur;
717  do {
718  cur = blocks[idx++];
719  if (cur != prev) {
720  if (!run)
721  bits++;
722  else if (run < 0x10)
723  bits += 4;
724  else
725  bits += 15;
726  bits += est_alpha_diff(cur, prev, abits);
727  prev = cur;
728  run = 0;
729  } else {
730  run++;
731  }
732  } while (idx < num_coeffs);
733 
734  if (run) {
735  if (run < 0x10)
736  bits += 4;
737  else
738  bits += 15;
739  }
740 
741  return bits;
742 }
743 
744 static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
745  int trellis_node, int x, int y, int mbs_per_slice,
746  ProresThreadData *td)
747 {
748  ProresContext *ctx = avctx->priv_data;
749  int i, q, pq, xp, yp;
750  const uint16_t *src;
751  int slice_width_factor = av_log2(mbs_per_slice);
752  int num_cblocks[MAX_PLANES], pwidth;
753  int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
754  const int min_quant = ctx->profile_info->min_quant;
755  const int max_quant = ctx->profile_info->max_quant;
756  int error, bits, bits_limit;
757  int mbs, prev, cur, new_score;
758  int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
759  int overquant;
760  uint16_t *qmat;
761  int linesize[4], line_add;
762 
763  if (ctx->pictures_per_frame == 1)
764  line_add = 0;
765  else
766  line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
767  mbs = x + mbs_per_slice;
768 
769  for (i = 0; i < ctx->num_planes; i++) {
770  is_chroma[i] = (i == 1 || i == 2);
771  plane_factor[i] = slice_width_factor + 2;
772  if (is_chroma[i])
773  plane_factor[i] += ctx->chroma_factor - 3;
774  if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
775  xp = x << 4;
776  yp = y << 4;
777  num_cblocks[i] = 4;
778  pwidth = avctx->width;
779  } else {
780  xp = x << 3;
781  yp = y << 4;
782  num_cblocks[i] = 2;
783  pwidth = avctx->width >> 1;
784  }
785 
786  linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;
787  src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +
788  line_add * pic->linesize[i]) + xp;
789 
790  if (i < 3) {
791  get_slice_data(ctx, src, linesize[i], xp, yp,
792  pwidth, avctx->height / ctx->pictures_per_frame,
793  td->blocks[i], td->emu_buf,
794  mbs_per_slice, num_cblocks[i], is_chroma[i]);
795  } else {
796  get_alpha_data(ctx, src, linesize[i], xp, yp,
797  pwidth, avctx->height / ctx->pictures_per_frame,
798  td->blocks[i], mbs_per_slice, ctx->alpha_bits);
799  }
800  }
801 
802  for (q = min_quant; q < max_quant + 2; q++) {
803  td->nodes[trellis_node + q].prev_node = -1;
804  td->nodes[trellis_node + q].quant = q;
805  }
806 
807  // todo: maybe perform coarser quantising to fit into frame size when needed
808  for (q = min_quant; q <= max_quant; q++) {
809  bits = 0;
810  error = 0;
811  for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
812  bits += estimate_slice_plane(ctx, &error, i,
813  src, linesize[i],
814  mbs_per_slice,
815  num_cblocks[i], plane_factor[i],
816  ctx->quants[q], td);
817  }
818  if (ctx->alpha_bits)
819  bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
820  mbs_per_slice, q, td->blocks[3]);
821  if (bits > 65000 * 8) {
822  error = SCORE_LIMIT;
823  break;
824  }
825  slice_bits[q] = bits;
826  slice_score[q] = error;
827  }
828  if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
829  slice_bits[max_quant + 1] = slice_bits[max_quant];
830  slice_score[max_quant + 1] = slice_score[max_quant] + 1;
831  overquant = max_quant;
832  } else {
833  for (q = max_quant + 1; q < 128; q++) {
834  bits = 0;
835  error = 0;
836  if (q < MAX_STORED_Q) {
837  qmat = ctx->quants[q];
838  } else {
839  qmat = td->custom_q;
840  for (i = 0; i < 64; i++)
841  qmat[i] = ctx->quant_mat[i] * q;
842  }
843  for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
844  bits += estimate_slice_plane(ctx, &error, i,
845  src, linesize[i],
846  mbs_per_slice,
847  num_cblocks[i], plane_factor[i],
848  qmat, td);
849  }
850  if (ctx->alpha_bits)
851  bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
852  mbs_per_slice, q, td->blocks[3]);
853  if (bits <= ctx->bits_per_mb * mbs_per_slice)
854  break;
855  }
856 
857  slice_bits[max_quant + 1] = bits;
858  slice_score[max_quant + 1] = error;
859  overquant = q;
860  }
861  td->nodes[trellis_node + max_quant + 1].quant = overquant;
862 
863  bits_limit = mbs * ctx->bits_per_mb;
864  for (pq = min_quant; pq < max_quant + 2; pq++) {
865  prev = trellis_node - TRELLIS_WIDTH + pq;
866 
867  for (q = min_quant; q < max_quant + 2; q++) {
868  cur = trellis_node + q;
869 
870  bits = td->nodes[prev].bits + slice_bits[q];
871  error = slice_score[q];
872  if (bits > bits_limit)
873  error = SCORE_LIMIT;
874 
875  if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
876  new_score = td->nodes[prev].score + error;
877  else
878  new_score = SCORE_LIMIT;
879  if (td->nodes[cur].prev_node == -1 ||
880  td->nodes[cur].score >= new_score) {
881 
882  td->nodes[cur].bits = bits;
883  td->nodes[cur].score = new_score;
884  td->nodes[cur].prev_node = prev;
885  }
886  }
887  }
888 
889  error = td->nodes[trellis_node + min_quant].score;
890  pq = trellis_node + min_quant;
891  for (q = min_quant + 1; q < max_quant + 2; q++) {
892  if (td->nodes[trellis_node + q].score <= error) {
893  error = td->nodes[trellis_node + q].score;
894  pq = trellis_node + q;
895  }
896  }
897 
898  return pq;
899 }
900 
901 static int find_quant_thread(AVCodecContext *avctx, void *arg,
902  int jobnr, int threadnr)
903 {
904  ProresContext *ctx = avctx->priv_data;
905  ProresThreadData *td = ctx->tdata + threadnr;
906  int mbs_per_slice = ctx->mbs_per_slice;
907  int x, y = jobnr, mb, q = 0;
908 
909  for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
910  while (ctx->mb_width - x < mbs_per_slice)
911  mbs_per_slice >>= 1;
912  q = find_slice_quant(avctx, avctx->coded_frame,
913  (mb + 1) * TRELLIS_WIDTH, x, y,
914  mbs_per_slice, td);
915  }
916 
917  for (x = ctx->slices_width - 1; x >= 0; x--) {
918  ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
919  q = td->nodes[q].prev_node;
920  }
921 
922  return 0;
923 }
924 
925 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
926  const AVFrame *pic, int *got_packet)
927 {
928  ProresContext *ctx = avctx->priv_data;
929  uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
930  uint8_t *picture_size_pos;
931  PutBitContext pb;
932  int x, y, i, mb, q = 0;
933  int sizes[4] = { 0 };
934  int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
935  int frame_size, picture_size, slice_size;
936  int pkt_size, ret;
937  uint8_t frame_flags;
938 
939  *avctx->coded_frame = *pic;
940  avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
941  avctx->coded_frame->key_frame = 1;
942 
943  pkt_size = ctx->frame_size_upper_bound + FF_MIN_BUFFER_SIZE;
944 
945  if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size)) < 0)
946  return ret;
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;
988  ctx->cur_picture_idx < ctx->pictures_per_frame;
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  picture_size = buf - (picture_size_pos - 1);
1036  bytestream_put_be32(&picture_size_pos, picture_size);
1037  }
1038 
1039  orig_buf -= 8;
1040  frame_size = buf - orig_buf;
1041  bytestream_put_be32(&orig_buf, frame_size);
1042 
1043  pkt->size = frame_size;
1044  pkt->flags |= AV_PKT_FLAG_KEY;
1045  *got_packet = 1;
1046 
1047  return 0;
1048 }
1049 
1050 static av_cold int encode_close(AVCodecContext *avctx)
1051 {
1052  ProresContext *ctx = avctx->priv_data;
1053  int i;
1054 
1055  av_freep(&avctx->coded_frame);
1056 
1057  if (ctx->tdata) {
1058  for (i = 0; i < avctx->thread_count; i++)
1059  av_free(ctx->tdata[i].nodes);
1060  }
1061  av_freep(&ctx->tdata);
1062  av_freep(&ctx->slice_q);
1063 
1064  return 0;
1065 }
1066 
1067 static av_cold int encode_init(AVCodecContext *avctx)
1068 {
1069  ProresContext *ctx = avctx->priv_data;
1070  int mps;
1071  int i, j;
1072  int min_quant, max_quant;
1073  int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
1074 
1075  avctx->bits_per_raw_sample = 10;
1076  avctx->coded_frame = avcodec_alloc_frame();
1077  if (!avctx->coded_frame)
1078  return AVERROR(ENOMEM);
1079 
1080  ff_proresdsp_init(&ctx->dsp, avctx);
1081  ff_init_scantable(ctx->dsp.dct_permutation, &ctx->scantable,
1082  interlaced ? ff_prores_interlaced_scan
1083  : ff_prores_progressive_scan);
1084 
1085  mps = ctx->mbs_per_slice;
1086  if (mps & (mps - 1)) {
1087  av_log(avctx, AV_LOG_ERROR,
1088  "there should be an integer power of two MBs per slice\n");
1089  return AVERROR(EINVAL);
1090  }
1091  if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1092  if (ctx->alpha_bits & 7) {
1093  av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1094  return AVERROR(EINVAL);
1095  }
1096  } else {
1097  ctx->alpha_bits = 0;
1098  }
1099 
1100  ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1101  ? CFACTOR_Y422
1102  : CFACTOR_Y444;
1103  ctx->profile_info = prores_profile_info + ctx->profile;
1104  ctx->num_planes = 3 + !!ctx->alpha_bits;
1105 
1106  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
1107 
1108  if (interlaced)
1109  ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1110  else
1111  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1112 
1113  ctx->slices_width = ctx->mb_width / mps;
1114  ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1115  ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1116  ctx->pictures_per_frame = 1 + interlaced;
1117 
1118  if (ctx->quant_sel == -1)
1119  ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1120  else
1121  ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1122 
1123  if (strlen(ctx->vendor) != 4) {
1124  av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1125  return AVERROR_INVALIDDATA;
1126  }
1127 
1128  ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1129  if (!ctx->force_quant) {
1130  if (!ctx->bits_per_mb) {
1131  for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1132  if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1133  ctx->pictures_per_frame)
1134  break;
1135  ctx->bits_per_mb = ctx->profile_info->br_tab[i];
1136  } else if (ctx->bits_per_mb < 128) {
1137  av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1138  return AVERROR_INVALIDDATA;
1139  }
1140 
1141  min_quant = ctx->profile_info->min_quant;
1142  max_quant = ctx->profile_info->max_quant;
1143  for (i = min_quant; i < MAX_STORED_Q; i++) {
1144  for (j = 0; j < 64; j++)
1145  ctx->quants[i][j] = ctx->quant_mat[j] * i;
1146  }
1147 
1148  ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1149  if (!ctx->slice_q) {
1150  encode_close(avctx);
1151  return AVERROR(ENOMEM);
1152  }
1153 
1154  ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1155  if (!ctx->tdata) {
1156  encode_close(avctx);
1157  return AVERROR(ENOMEM);
1158  }
1159 
1160  for (j = 0; j < avctx->thread_count; j++) {
1161  ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1162  * TRELLIS_WIDTH
1163  * sizeof(*ctx->tdata->nodes));
1164  if (!ctx->tdata[j].nodes) {
1165  encode_close(avctx);
1166  return AVERROR(ENOMEM);
1167  }
1168  for (i = min_quant; i < max_quant + 2; i++) {
1169  ctx->tdata[j].nodes[i].prev_node = -1;
1170  ctx->tdata[j].nodes[i].bits = 0;
1171  ctx->tdata[j].nodes[i].score = 0;
1172  }
1173  }
1174  } else {
1175  int ls = 0;
1176 
1177  if (ctx->force_quant > 64) {
1178  av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1179  return AVERROR_INVALIDDATA;
1180  }
1181 
1182  for (j = 0; j < 64; j++) {
1183  ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1184  ls += av_log2((1 << 11) / ctx->quants[0][j]) * 2 + 1;
1185  }
1186 
1187  ctx->bits_per_mb = ls * 8;
1188  if (ctx->chroma_factor == CFACTOR_Y444)
1189  ctx->bits_per_mb += ls * 4;
1190  if (ctx->num_planes == 4)
1191  ctx->bits_per_mb += ls * 4;
1192  }
1193 
1194  ctx->frame_size_upper_bound = ctx->pictures_per_frame *
1195  ctx->slices_per_picture *
1196  (2 + 2 * ctx->num_planes +
1197  (mps * ctx->bits_per_mb) / 8)
1198  + 200;
1199 
1200  avctx->codec_tag = ctx->profile_info->tag;
1201 
1202  av_log(avctx, AV_LOG_DEBUG,
1203  "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1204  ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1205  interlaced ? "yes" : "no", ctx->bits_per_mb);
1206  av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1207  ctx->frame_size_upper_bound);
1208 
1209  return 0;
1210 }
1211 
1212 #define OFFSET(x) offsetof(ProresContext, x)
1213 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1214 
1215 static const AVOption options[] = {
1216  { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1217  AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1218  { "profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1219  { .i64 = PRORES_PROFILE_STANDARD },
1220  PRORES_PROFILE_PROXY, PRORES_PROFILE_4444, VE, "profile" },
1221  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1222  0, 0, VE, "profile" },
1223  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1224  0, 0, VE, "profile" },
1225  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1226  0, 0, VE, "profile" },
1227  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1228  0, 0, VE, "profile" },
1229  { "4444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1230  0, 0, VE, "profile" },
1231  { "vendor", "vendor ID", OFFSET(vendor),
1232  AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
1233  { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1234  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1235  { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1236  { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1237  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1238  0, 0, VE, "quant_mat" },
1239  { "proxy", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1240  0, 0, VE, "quant_mat" },
1241  { "lt", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1242  0, 0, VE, "quant_mat" },
1243  { "standard", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1244  0, 0, VE, "quant_mat" },
1245  { "hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1246  0, 0, VE, "quant_mat" },
1247  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1248  0, 0, VE, "quant_mat" },
1249  { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1250  { .i64 = 16 }, 0, 16, VE },
1251  { NULL }
1252 };
1253 
1254 static const AVClass proresenc_class = {
1255  .class_name = "ProRes encoder",
1256  .item_name = av_default_item_name,
1257  .option = options,
1258  .version = LIBAVUTIL_VERSION_INT,
1259 };
1260 
1261 AVCodec ff_prores_ks_encoder = {
1262  .name = "prores_ks",
1263  .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1264  .type = AVMEDIA_TYPE_VIDEO,
1265  .id = AV_CODEC_ID_PRORES,
1266  .priv_data_size = sizeof(ProresContext),
1267  .init = encode_init,
1268  .close = encode_close,
1269  .encode2 = encode_frame,
1270  .capabilities = CODEC_CAP_SLICE_THREADS,
1271  .pix_fmts = (const enum AVPixelFormat[]) {
1272  AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1273  AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1274  },
1275  .priv_class = &proresenc_class,
1276 };
Generated on Sat Jan 25 2014 19:51:53 for FFmpeg by   doxygen 1.8.2