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