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