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