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