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