avcodec/prores_aw : add vendor option
[ffmpeg.git] / libavcodec / proresenc_anatoliy.c
1 /*
2  * Apple ProRes encoder
3  *
4  * Copyright (c) 2011 Anatoliy Wasserman
5  * Copyright (c) 2012 Konstantin Shishkov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * Apple ProRes encoder (Anatoliy Wasserman version)
27  * Known FOURCCs: 'ap4h' (444), 'apch' (HQ), 'apcn' (422), 'apcs' (LT), 'acpo' (Proxy)
28  */
29
30 #include "libavutil/opt.h"
31 #include "avcodec.h"
32 #include "dct.h"
33 #include "internal.h"
34 #include "profiles.h"
35 #include "proresdata.h"
36 #include "put_bits.h"
37 #include "bytestream.h"
38 #include "fdctdsp.h"
39
40 #define DEFAULT_SLICE_MB_WIDTH 8
41
42 static const AVProfile profiles[] = {
43     { FF_PROFILE_PRORES_PROXY,    "apco"},
44     { FF_PROFILE_PRORES_LT,       "apcs"},
45     { FF_PROFILE_PRORES_STANDARD, "apcn"},
46     { FF_PROFILE_PRORES_HQ,       "apch"},
47     { FF_PROFILE_PRORES_4444,     "ap4h"},
48     { FF_PROFILE_UNKNOWN }
49 };
50
51 static const int qp_start_table[5] = {  8, 3, 2, 1, 1};
52 static const int qp_end_table[5]   = { 13, 9, 6, 6, 5};
53 static const int bitrate_table[5]  = { 1000, 2100, 3500, 5400, 7000};
54
55 static const uint8_t QMAT_LUMA[5][64] = {
56     {
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          4,  5,  6,  7,  9, 11, 13, 15,
67          5,  5,  7,  8, 11, 13, 15, 17,
68          6,  7,  9, 11, 13, 15, 15, 17,
69          7,  7,  9, 11, 13, 15, 17, 19,
70          7,  9, 11, 13, 14, 16, 19, 23,
71          9, 11, 13, 14, 16, 19, 23, 29,
72          9, 11, 13, 15, 17, 21, 28, 35,
73         11, 13, 16, 17, 21, 28, 35, 41
74     }, {
75          4,  4,  5,  5,  6,  7,  7,  9,
76          4,  4,  5,  6,  7,  7,  9,  9,
77          5,  5,  6,  7,  7,  9,  9, 10,
78          5,  5,  6,  7,  7,  9,  9, 10,
79          5,  6,  7,  7,  8,  9, 10, 12,
80          6,  7,  7,  8,  9, 10, 12, 15,
81          6,  7,  7,  9, 10, 11, 14, 17,
82          7,  7,  9, 10, 11, 14, 17, 21
83     }, {
84          4,  4,  4,  4,  4,  4,  4,  4,
85          4,  4,  4,  4,  4,  4,  4,  4,
86          4,  4,  4,  4,  4,  4,  4,  4,
87          4,  4,  4,  4,  4,  4,  4,  5,
88          4,  4,  4,  4,  4,  4,  5,  5,
89          4,  4,  4,  4,  4,  5,  5,  6,
90          4,  4,  4,  4,  5,  5,  6,  7,
91          4,  4,  4,  4,  5,  6,  7,  7
92     }, { /* 444 */
93         4,  4,  4,  4,  4,  4,  4,  4,
94         4,  4,  4,  4,  4,  4,  4,  4,
95         4,  4,  4,  4,  4,  4,  4,  4,
96         4,  4,  4,  4,  4,  4,  4,  5,
97         4,  4,  4,  4,  4,  4,  5,  5,
98         4,  4,  4,  4,  4,  5,  5,  6,
99         4,  4,  4,  4,  5,  5,  6,  7,
100         4,  4,  4,  4,  5,  6,  7,  7
101     }
102 };
103
104 static const uint8_t QMAT_CHROMA[5][64] = {
105     {
106          4,  7,  9, 11, 13, 14, 63, 63,
107          7,  7, 11, 12, 14, 63, 63, 63,
108          9, 11, 13, 14, 63, 63, 63, 63,
109         11, 11, 13, 14, 63, 63, 63, 63,
110         11, 13, 14, 63, 63, 63, 63, 63,
111         13, 14, 63, 63, 63, 63, 63, 63,
112         13, 63, 63, 63, 63, 63, 63, 63,
113         63, 63, 63, 63, 63, 63, 63, 63
114     }, {
115          4,  5,  6,  7,  9, 11, 13, 15,
116          5,  5,  7,  8, 11, 13, 15, 17,
117          6,  7,  9, 11, 13, 15, 15, 17,
118          7,  7,  9, 11, 13, 15, 17, 19,
119          7,  9, 11, 13, 14, 16, 19, 23,
120          9, 11, 13, 14, 16, 19, 23, 29,
121          9, 11, 13, 15, 17, 21, 28, 35,
122         11, 13, 16, 17, 21, 28, 35, 41
123     }, {
124          4,  4,  5,  5,  6,  7,  7,  9,
125          4,  4,  5,  6,  7,  7,  9,  9,
126          5,  5,  6,  7,  7,  9,  9, 10,
127          5,  5,  6,  7,  7,  9,  9, 10,
128          5,  6,  7,  7,  8,  9, 10, 12,
129          6,  7,  7,  8,  9, 10, 12, 15,
130          6,  7,  7,  9, 10, 11, 14, 17,
131          7,  7,  9, 10, 11, 14, 17, 21
132     }, {
133          4,  4,  4,  4,  4,  4,  4,  4,
134          4,  4,  4,  4,  4,  4,  4,  4,
135          4,  4,  4,  4,  4,  4,  4,  4,
136          4,  4,  4,  4,  4,  4,  4,  5,
137          4,  4,  4,  4,  4,  4,  5,  5,
138          4,  4,  4,  4,  4,  5,  5,  6,
139          4,  4,  4,  4,  5,  5,  6,  7,
140          4,  4,  4,  4,  5,  6,  7,  7
141     }, { /* 444 */
142         4,  4,  4,  4,  4,  4,  4,  4,
143         4,  4,  4,  4,  4,  4,  4,  4,
144         4,  4,  4,  4,  4,  4,  4,  4,
145         4,  4,  4,  4,  4,  4,  4,  5,
146         4,  4,  4,  4,  4,  4,  5,  5,
147         4,  4,  4,  4,  4,  5,  5,  6,
148         4,  4,  4,  4,  5,  5,  6,  7,
149         4,  4,  4,  4,  5,  6,  7,  7
150     }
151 };
152
153
154 typedef struct {
155     AVClass *class;
156     FDCTDSPContext fdsp;
157     uint8_t* fill_y;
158     uint8_t* fill_u;
159     uint8_t* fill_v;
160     uint8_t* fill_a;
161
162     int qmat_luma[16][64];
163     int qmat_chroma[16][64];
164
165     int is_422;
166     int need_alpha;
167
168     char *vendor;
169 } ProresContext;
170
171 static void encode_codeword(PutBitContext *pb, int val, int codebook)
172 {
173     unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros;
174
175     /* number of bits to switch between rice and exp golomb */
176     switch_bits = codebook & 3;
177     rice_order  = codebook >> 5;
178     exp_order   = (codebook >> 2) & 7;
179
180     first_exp = ((switch_bits + 1) << rice_order);
181
182     if (val >= first_exp) { /* exp golomb */
183         val -= first_exp;
184         val += (1 << exp_order);
185         exp = av_log2(val);
186         zeros = exp - exp_order + switch_bits + 1;
187         put_bits(pb, zeros, 0);
188         put_bits(pb, exp + 1, val);
189     } else if (rice_order) {
190         put_bits(pb, (val >> rice_order), 0);
191         put_bits(pb, 1, 1);
192         put_sbits(pb, rice_order, val);
193     } else {
194         put_bits(pb, val, 0);
195         put_bits(pb, 1, 1);
196     }
197 }
198
199 #define QSCALE(qmat,ind,val) ((val) / ((qmat)[ind]))
200 #define TO_GOLOMB(val) (((val) << 1) ^ ((val) >> 31))
201 #define DIFF_SIGN(val, sign) (((val) >> 31) ^ (sign))
202 #define IS_NEGATIVE(val) ((((val) >> 31) ^ -1) + 1)
203 #define TO_GOLOMB2(val,sign) ((val)==0 ? 0 : ((val) << 1) + (sign))
204
205 static av_always_inline int get_level(int val)
206 {
207     int sign = (val >> 31);
208     return (val ^ sign) - sign;
209 }
210
211 #define FIRST_DC_CB 0xB8
212
213 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
214
215 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
216         int blocks_per_slice, int *qmat)
217 {
218     int prev_dc, code;
219     int i, sign, idx;
220     int new_dc, delta, diff_sign, new_code;
221
222     prev_dc = QSCALE(qmat, 0, in[0] - 16384);
223     code = TO_GOLOMB(prev_dc);
224     encode_codeword(pb, code, FIRST_DC_CB);
225
226     code = 5; sign = 0; idx = 64;
227     for (i = 1; i < blocks_per_slice; i++, idx += 64) {
228         new_dc    = QSCALE(qmat, 0, in[idx] - 16384);
229         delta     = new_dc - prev_dc;
230         diff_sign = DIFF_SIGN(delta, sign);
231         new_code  = TO_GOLOMB2(get_level(delta), diff_sign);
232
233         encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
234
235         code      = new_code;
236         sign      = delta >> 31;
237         prev_dc   = new_dc;
238     }
239 }
240
241 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
242         0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
243 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
244         0x28, 0x28, 0x28, 0x4C };
245
246 static void encode_ac_coeffs(PutBitContext *pb,
247         int16_t *in, int blocks_per_slice, int *qmat)
248 {
249     int prev_run = 4;
250     int prev_level = 2;
251
252     int run = 0, level, code, i, j;
253     for (i = 1; i < 64; i++) {
254         int indp = ff_prores_progressive_scan[i];
255         for (j = 0; j < blocks_per_slice; j++) {
256             int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
257             if (val) {
258                 encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
259
260                 prev_run   = run;
261                 run        = 0;
262                 level      = get_level(val);
263                 code       = level - 1;
264
265                 encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
266
267                 prev_level = level;
268
269                 put_bits(pb, 1, IS_NEGATIVE(val));
270             } else {
271                 ++run;
272             }
273         }
274     }
275 }
276
277 static void get(uint8_t *pixels, int stride, int16_t* block)
278 {
279     int i;
280
281     for (i = 0; i < 8; i++) {
282         AV_WN64(block, AV_RN64(pixels));
283         AV_WN64(block+4, AV_RN64(pixels+8));
284         pixels += stride;
285         block += 8;
286     }
287 }
288
289 static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
290 {
291     get(pixels, stride, block);
292     fdsp->fdct(block);
293 }
294
295 static void calc_plane_dct(FDCTDSPContext *fdsp, uint8_t *src, int16_t * blocks, int src_stride, int mb_count, int chroma, int is_422)
296 {
297     int16_t *block;
298     int i;
299
300     block = blocks;
301
302     if (!chroma) { /* Luma plane */
303         for (i = 0; i < mb_count; i++) {
304             fdct_get(fdsp, src,                       src_stride, block + (0 << 6));
305             fdct_get(fdsp, src + 16,                  src_stride, block + (1 << 6));
306             fdct_get(fdsp, src +      8 * src_stride, src_stride, block + (2 << 6));
307             fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
308
309             block += 256;
310             src   += 32;
311         }
312     } else if (chroma && is_422){ /* chroma plane 422 */
313         for (i = 0; i < mb_count; i++) {
314             fdct_get(fdsp, src,                  src_stride, block + (0 << 6));
315             fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (1 << 6));
316             block += (256 >> 1);
317             src   += (32  >> 1);
318         }
319     } else { /* chroma plane 444 */
320         for (i = 0; i < mb_count; i++) {
321             fdct_get(fdsp, src,                       src_stride, block + (0 << 6));
322             fdct_get(fdsp, src +      8 * src_stride, src_stride, block + (1 << 6));
323             fdct_get(fdsp, src + 16,                  src_stride, block + (2 << 6));
324             fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
325
326             block += 256;
327             src   += 32;
328         }
329     }
330 }
331
332 static int encode_slice_plane(int16_t *blocks, int mb_count, uint8_t *buf, unsigned buf_size, int *qmat, int sub_sample_chroma)
333 {
334     int blocks_per_slice;
335     PutBitContext pb;
336
337     blocks_per_slice = mb_count << (2 - sub_sample_chroma);
338     init_put_bits(&pb, buf, buf_size);
339
340     encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
341     encode_ac_coeffs(&pb, blocks, blocks_per_slice, qmat);
342
343     flush_put_bits(&pb);
344     return put_bits_ptr(&pb) - pb.buf;
345 }
346
347 static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
348                                                    int16_t * blocks_y, int16_t * blocks_u, int16_t * blocks_v,
349                                                    unsigned mb_count, uint8_t *buf, unsigned data_size,
350                                                    unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
351                                                    int qp)
352 {
353     ProresContext* ctx = avctx->priv_data;
354
355     *y_data_size = encode_slice_plane(blocks_y, mb_count,
356                                       buf, data_size, ctx->qmat_luma[qp - 1], 0);
357
358     if (!(avctx->flags & AV_CODEC_FLAG_GRAY)) {
359         *u_data_size = encode_slice_plane(blocks_u, mb_count, buf + *y_data_size, data_size - *y_data_size,
360                                           ctx->qmat_chroma[qp - 1], ctx->is_422);
361
362         *v_data_size = encode_slice_plane(blocks_v, mb_count, buf + *y_data_size + *u_data_size,
363                                           data_size - *y_data_size - *u_data_size,
364                                           ctx->qmat_chroma[qp - 1], ctx->is_422);
365     }
366
367     return *y_data_size + *u_data_size + *v_data_size;
368 }
369
370 static void put_alpha_diff(PutBitContext *pb, int cur, int prev)
371 {
372     const int abits = 16;
373     const int dbits = 7;
374     const int dsize = 1 << dbits - 1;
375     int diff = cur - prev;
376
377     diff = av_mod_uintp2(diff, abits);
378     if (diff >= (1 << abits) - dsize)
379         diff -= 1 << abits;
380     if (diff < -dsize || diff > dsize || !diff) {
381         put_bits(pb, 1, 1);
382         put_bits(pb, abits, diff);
383     } else {
384         put_bits(pb, 1, 0);
385         put_bits(pb, dbits - 1, FFABS(diff) - 1);
386         put_bits(pb, 1, diff < 0);
387     }
388 }
389
390 static inline void put_alpha_run(PutBitContext *pb, int run)
391 {
392     if (run) {
393         put_bits(pb, 1, 0);
394         if (run < 0x10)
395             put_bits(pb, 4, run);
396         else
397             put_bits(pb, 15, run);
398     } else {
399         put_bits(pb, 1, 1);
400     }
401 }
402
403 static av_always_inline int encode_alpha_slice_data(AVCodecContext *avctx, int8_t * src_a,
404                                                    unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned* a_data_size)
405 {
406     const int abits = 16;
407     const int mask  = (1 << abits) - 1;
408     const int num_coeffs = mb_count * 256;
409     int prev = mask, cur;
410     int idx = 0;
411     int run = 0;
412     int16_t * blocks = (int16_t *)src_a;
413     PutBitContext pb;
414     init_put_bits(&pb, buf, data_size);
415
416     cur = blocks[idx++];
417     put_alpha_diff(&pb, cur, prev);
418     prev = cur;
419     do {
420         cur = blocks[idx++];
421         if (cur != prev) {
422             put_alpha_run (&pb, run);
423             put_alpha_diff(&pb, cur, prev);
424             prev = cur;
425             run  = 0;
426         } else {
427             run++;
428         }
429     } while (idx < num_coeffs);
430     if (run)
431         put_alpha_run(&pb, run);
432     flush_put_bits(&pb);
433     *a_data_size = put_bits_count(&pb) >> 3;
434
435     if (put_bits_left(&pb) < 0) {
436         av_log(avctx, AV_LOG_ERROR,
437                "Underestimated required buffer size.\n");
438         return AVERROR_BUG;
439     } else {
440         return 0;
441     }
442 }
443
444 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
445         unsigned stride, unsigned width, unsigned height, uint16_t *dst,
446         unsigned dst_width, unsigned dst_height)
447 {
448
449     int box_width = FFMIN(width - x, dst_width);
450     int box_height = FFMIN(height - y, dst_height);
451     int i, j, src_stride = stride >> 1;
452     uint16_t last_pix, *last_line;
453
454     src += y * src_stride + x;
455     for (i = 0; i < box_height; ++i) {
456         for (j = 0; j < box_width; ++j) {
457             dst[j] = src[j];
458         }
459         last_pix = dst[j - 1];
460         for (; j < dst_width; j++)
461             dst[j] = last_pix;
462         src += src_stride;
463         dst += dst_width;
464     }
465     last_line = dst - dst_width;
466     for (; i < dst_height; i++) {
467         for (j = 0; j < dst_width; ++j) {
468             dst[j] = last_line[j];
469         }
470         dst += dst_width;
471     }
472 }
473
474 /* reorganize alpha data and convert 10b -> 16b */
475 static void subimage_alpha_with_fill(uint16_t *src, unsigned x, unsigned y,
476                                unsigned stride, unsigned width, unsigned height, uint16_t *dst,
477                                unsigned dst_width, unsigned dst_height)
478 {
479     int box_width = FFMIN(width - x, dst_width);
480     int box_height = FFMIN(height - y, dst_height);
481     int i, j, src_stride = stride >> 1;
482     uint16_t last_pix, *last_line;
483
484     src += y * src_stride + x;
485     for (i = 0; i < box_height; ++i) {
486         for (j = 0; j < box_width; ++j) {
487             dst[j] = src[j] << 6; /* 10b to 16b */
488         }
489         last_pix = dst[j - 1] << 6; /* 10b to 16b */
490         for (; j < dst_width; j++)
491             dst[j] = last_pix;
492         src += src_stride;
493         dst += dst_width;
494     }
495     last_line = dst - dst_width;
496     for (; i < dst_height; i++) {
497         for (j = 0; j < dst_width; ++j) {
498             dst[j] = last_line[j];
499         }
500         dst += dst_width;
501     }
502 }
503
504 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
505         int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
506         int unsafe, int *qp)
507 {
508     int luma_stride, chroma_stride, alpha_stride = 0;
509     ProresContext* ctx = avctx->priv_data;
510     int hdr_size = 6 + (ctx->need_alpha * 2); /* v data size is write when there is alpha */
511     int ret = 0, slice_size;
512     uint8_t *dest_y, *dest_u, *dest_v;
513     unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0, a_data_size = 0;
514     FDCTDSPContext *fdsp = &ctx->fdsp;
515     int tgt_bits   = (mb_count * bitrate_table[avctx->profile]) >> 2;
516     int low_bytes  = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
517     int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
518
519     LOCAL_ALIGNED(16, int16_t, blocks_y, [DEFAULT_SLICE_MB_WIDTH << 8]);
520     LOCAL_ALIGNED(16, int16_t, blocks_u, [DEFAULT_SLICE_MB_WIDTH << 8]);
521     LOCAL_ALIGNED(16, int16_t, blocks_v, [DEFAULT_SLICE_MB_WIDTH << 8]);
522
523     luma_stride   = pic->linesize[0];
524     chroma_stride = pic->linesize[1];
525
526     if (ctx->need_alpha)
527         alpha_stride = pic->linesize[3];
528
529     dest_y = pic->data[0] + (mb_y << 4) * luma_stride   + (mb_x << 5);
530     dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
531     dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
532
533     if (unsafe) {
534         subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
535                 luma_stride, avctx->width, avctx->height,
536                 (uint16_t *) ctx->fill_y, mb_count << 4, 16);
537         subimage_with_fill((uint16_t *) pic->data[1], mb_x << (4 - ctx->is_422), mb_y << 4,
538                            chroma_stride, avctx->width >> ctx->is_422, avctx->height,
539                            (uint16_t *) ctx->fill_u, mb_count << (4 - ctx->is_422), 16);
540         subimage_with_fill((uint16_t *) pic->data[2], mb_x << (4 - ctx->is_422), mb_y << 4,
541                            chroma_stride, avctx->width >> ctx->is_422, avctx->height,
542                            (uint16_t *) ctx->fill_v, mb_count << (4 - ctx->is_422), 16);
543
544         calc_plane_dct(fdsp, ctx->fill_y, blocks_y, mb_count <<  5,                mb_count, 0, 0);
545         calc_plane_dct(fdsp, ctx->fill_u, blocks_u, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
546         calc_plane_dct(fdsp, ctx->fill_v, blocks_v, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
547
548         slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
549                           mb_count, buf + hdr_size, data_size - hdr_size,
550                           &y_data_size, &u_data_size, &v_data_size,
551                           *qp);
552     } else {
553         calc_plane_dct(fdsp, dest_y, blocks_y, luma_stride, mb_count, 0, 0);
554         calc_plane_dct(fdsp, dest_u, blocks_u, chroma_stride, mb_count, 1, ctx->is_422);
555         calc_plane_dct(fdsp, dest_v, blocks_v, chroma_stride, mb_count, 1, ctx->is_422);
556
557         slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
558                           mb_count, buf + hdr_size, data_size - hdr_size,
559                           &y_data_size, &u_data_size, &v_data_size,
560                           *qp);
561
562         if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
563             do {
564                 *qp += 1;
565                 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
566                                                mb_count, buf + hdr_size, data_size - hdr_size,
567                                                &y_data_size, &u_data_size, &v_data_size,
568                                                *qp);
569             } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
570         } else if (slice_size < low_bytes && *qp
571                 > qp_start_table[avctx->profile]) {
572             do {
573                 *qp -= 1;
574                 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
575                                                mb_count, buf + hdr_size, data_size - hdr_size,
576                                                &y_data_size, &u_data_size, &v_data_size,
577                                                *qp);
578             } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
579         }
580     }
581
582     buf[0] = hdr_size << 3;
583     buf[1] = *qp;
584     AV_WB16(buf + 2, y_data_size);
585     AV_WB16(buf + 4, u_data_size);
586
587     if (ctx->need_alpha) {
588         AV_WB16(buf + 6, v_data_size); /* write v data size only if there is alpha */
589
590         subimage_alpha_with_fill((uint16_t *) pic->data[3], mb_x << 4, mb_y << 4,
591                            alpha_stride, avctx->width, avctx->height,
592                            (uint16_t *) ctx->fill_a, mb_count << 4, 16);
593         ret = encode_alpha_slice_data(avctx, ctx->fill_a, mb_count,
594                                       buf + hdr_size + slice_size,
595                                       data_size - hdr_size - slice_size, &a_data_size);
596     }
597
598     if (ret != 0) {
599         return ret;
600     }
601     return hdr_size + y_data_size + u_data_size + v_data_size + a_data_size;
602 }
603
604 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
605         uint8_t *buf, const int buf_size)
606 {
607     int mb_width = (avctx->width + 15) >> 4;
608     int mb_height = (avctx->height + 15) >> 4;
609     int hdr_size, sl_size, i;
610     int mb_y, sl_data_size, qp;
611     int unsafe_bot, unsafe_right;
612     uint8_t *sl_data, *sl_data_sizes;
613     int slice_per_line = 0, rem = mb_width;
614
615     for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
616         slice_per_line += rem >> i;
617         rem &= (1 << i) - 1;
618     }
619
620     qp = qp_start_table[avctx->profile];
621     hdr_size = 8; sl_data_size = buf_size - hdr_size;
622     sl_data_sizes = buf + hdr_size;
623     sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
624     for (mb_y = 0; mb_y < mb_height; mb_y++) {
625         int mb_x = 0;
626         int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
627         while (mb_x < mb_width) {
628             while (mb_width - mb_x < slice_mb_count)
629                 slice_mb_count >>= 1;
630
631             unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
632             unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
633
634             sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
635                     sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp);
636             if (sl_size < 0){
637                 return sl_size;
638             }
639
640             bytestream_put_be16(&sl_data_sizes, sl_size);
641             sl_data           += sl_size;
642             sl_data_size      -= sl_size;
643             mb_x              += slice_mb_count;
644         }
645     }
646
647     buf[0] = hdr_size << 3;
648     AV_WB32(buf + 1, sl_data - buf);
649     AV_WB16(buf + 5, slice_per_line * mb_height);
650     buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4;
651
652     return sl_data - buf;
653 }
654
655 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
656                                const AVFrame *pict, int *got_packet)
657 {
658     ProresContext *ctx = avctx->priv_data;
659     int header_size = 148;
660     uint8_t *buf;
661     int pic_size, ret;
662     int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + AV_INPUT_BUFFER_MIN_SIZE; //FIXME choose tighter limit
663
664
665     if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
666         return ret;
667
668     buf = pkt->data;
669     pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
670             pkt->size - header_size - 8);
671     if (pic_size < 0) {
672         return pic_size;
673     }
674
675     bytestream_put_be32(&buf, pic_size + 8 + header_size);
676     bytestream_put_buffer(&buf, "icpf", 4);
677
678     bytestream_put_be16(&buf, header_size);
679     bytestream_put_be16(&buf, 0); /* version */
680     bytestream_put_buffer(&buf, ctx->vendor, 4);
681     bytestream_put_be16(&buf, avctx->width);
682     bytestream_put_be16(&buf, avctx->height);
683     if (avctx->profile == FF_PROFILE_PRORES_4444) {
684         *buf++ = 0xC2; // 444, not interlaced
685     } else {
686         *buf++ = 0x82; // 422, not interlaced
687     }
688     *buf++ = 0; /* reserved */
689     *buf++ = pict->color_primaries;
690     *buf++ = pict->color_trc;
691     *buf++ = pict->colorspace;
692     if (avctx->profile >= FF_PROFILE_PRORES_4444) {
693         if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
694             *buf++ = 0xA0;/* src b64a and no alpha */
695         } else {
696             *buf++ = 0xA2;/* src b64a and 16b alpha */
697         }
698     } else {
699         *buf++ = 32;/* src v210 and no alpha */
700     }
701     *buf++ = 0; /* reserved */
702     *buf++ = 3; /* luma and chroma matrix present */
703
704     bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile],   64);
705     bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
706
707     pkt->flags |= AV_PKT_FLAG_KEY;
708     pkt->size = pic_size + 8 + header_size;
709     *got_packet = 1;
710
711     return 0;
712 }
713
714 static void scale_mat(const uint8_t* src, int* dst, int scale)
715 {
716     int i;
717     for (i = 0; i < 64; i++)
718         dst[i] = src[i] * scale;
719 }
720
721 static av_cold int prores_encode_init(AVCodecContext *avctx)
722 {
723     int i;
724     ProresContext* ctx = avctx->priv_data;
725
726     avctx->bits_per_raw_sample = 10;
727     ctx->need_alpha = 0;
728
729     if (avctx->width & 0x1) {
730         av_log(avctx, AV_LOG_ERROR,
731                 "frame width needs to be multiple of 2\n");
732         return AVERROR(EINVAL);
733     }
734
735     if (avctx->width > 65534 || avctx->height > 65535) {
736         av_log(avctx, AV_LOG_ERROR,
737                 "The maximum dimensions are 65534x65535\n");
738         return AVERROR(EINVAL);
739     }
740
741     if (strlen(ctx->vendor) != 4) {
742         av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
743         return AVERROR(EINVAL);
744     }
745
746     if (avctx->profile == FF_PROFILE_UNKNOWN) {
747         if (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
748             avctx->profile = FF_PROFILE_PRORES_STANDARD;
749             av_log(avctx, AV_LOG_INFO,
750                 "encoding with ProRes standard (apcn) profile\n");
751         } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
752             avctx->profile = FF_PROFILE_PRORES_4444;
753             av_log(avctx, AV_LOG_INFO,
754                    "encoding with ProRes 4444 (ap4h) profile\n");
755         } else if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
756             avctx->profile = FF_PROFILE_PRORES_4444;
757             av_log(avctx, AV_LOG_INFO,
758                    "encoding with ProRes 4444+ (ap4h) profile\n");
759         } else {
760             av_log(avctx, AV_LOG_ERROR, "Unknown pixel format\n");
761             return AVERROR(EINVAL);
762         }
763     } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
764             || avctx->profile > FF_PROFILE_PRORES_4444) {
765         av_log(
766                 avctx,
767                 AV_LOG_ERROR,
768                 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch, 4 - ap4h]\n",
769                 avctx->profile);
770         return AVERROR(EINVAL);
771     } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P10) && (avctx->profile > FF_PROFILE_PRORES_HQ)){
772         av_log(avctx, AV_LOG_ERROR,
773                "encoding with ProRes 444 (ap4h) profile, need YUV444P10 input\n");
774         return AVERROR(EINVAL);
775     }  else if ((avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10)
776                 && (avctx->profile < FF_PROFILE_PRORES_4444)){
777         av_log(avctx, AV_LOG_ERROR,
778                "encoding with ProRes Proxy/LT/422/422 HQ (apco, apcs, apcn, ap4h) profile, need YUV422P10 input\n");
779         return AVERROR(EINVAL);
780     }
781
782     if (avctx->profile < FF_PROFILE_PRORES_4444) { /* 422 versions */
783         ctx->is_422 = 1;
784         if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
785             ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
786             if (!ctx->fill_y)
787                 return AVERROR(ENOMEM);
788             ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
789             ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
790         }
791     } else { /* 444 */
792         ctx->is_422 = 0;
793         if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
794             ctx->fill_y = av_malloc(3 * (DEFAULT_SLICE_MB_WIDTH << 9));
795             if (!ctx->fill_y)
796                 return AVERROR(ENOMEM);
797             ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
798             ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 9);
799         }
800         if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
801             ctx->need_alpha = 1;
802             ctx->fill_a = av_malloc(DEFAULT_SLICE_MB_WIDTH << 9); /* 8 blocks x 16px x 16px x sizeof (uint16) */
803             if (!ctx->fill_a)
804                 return AVERROR(ENOMEM);
805         }
806     }
807
808     ff_fdctdsp_init(&ctx->fdsp, avctx);
809
810     avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
811
812     for (i = 1; i <= 16; i++) {
813         scale_mat(QMAT_LUMA[avctx->profile]  , ctx->qmat_luma[i - 1]  , i);
814         scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
815     }
816
817     return 0;
818 }
819
820 static av_cold int prores_encode_close(AVCodecContext *avctx)
821 {
822     ProresContext* ctx = avctx->priv_data;
823     av_freep(&ctx->fill_y);
824     av_freep(&ctx->fill_a);
825
826     return 0;
827 }
828
829 #define OFFSET(x) offsetof(ProresContext, x)
830 #define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
831
832 static const AVOption options[] = {
833     { "vendor", "vendor ID", OFFSET(vendor), AV_OPT_TYPE_STRING, { .str = "fmpg" }, CHAR_MIN, CHAR_MAX, VE },
834     { NULL }
835 };
836
837 static const AVClass proresaw_enc_class = {
838     .class_name = "ProResAw encoder",
839     .item_name  = av_default_item_name,
840     .option     = options,
841     .version    = LIBAVUTIL_VERSION_INT,
842 };
843
844 static const AVClass prores_enc_class = {
845     .class_name = "ProRes encoder",
846     .item_name  = av_default_item_name,
847     .option     = options,
848     .version    = LIBAVUTIL_VERSION_INT,
849 };
850
851 AVCodec ff_prores_aw_encoder = {
852     .name           = "prores_aw",
853     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
854     .type           = AVMEDIA_TYPE_VIDEO,
855     .id             = AV_CODEC_ID_PRORES,
856     .priv_data_size = sizeof(ProresContext),
857     .init           = prores_encode_init,
858     .close          = prores_encode_close,
859     .encode2        = prores_encode_frame,
860     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
861     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
862     .priv_class     = &proresaw_enc_class,
863     .profiles       = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
864 };
865
866 AVCodec ff_prores_encoder = {
867     .name           = "prores",
868     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
869     .type           = AVMEDIA_TYPE_VIDEO,
870     .id             = AV_CODEC_ID_PRORES,
871     .priv_data_size = sizeof(ProresContext),
872     .init           = prores_encode_init,
873     .close          = prores_encode_close,
874     .encode2        = prores_encode_frame,
875     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
876     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
877     .priv_class     = &prores_enc_class,
878     .profiles       = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
879 };