4 * Copyright (c) 2011 Anatoliy Wasserman
5 * Copyright (c) 2012 Konstantin Shishkov
7 * This file is part of FFmpeg.
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.
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.
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
26 * Apple ProRes encoder (Anatoliy Wasserman version)
27 * Known FOURCCs: 'ap4h' (444), 'apch' (HQ), 'apcn' (422), 'apcs' (LT), 'acpo' (Proxy)
30 #include "libavutil/mem_internal.h"
31 #include "libavutil/opt.h"
36 #include "proresdata.h"
38 #include "bytestream.h"
41 #define DEFAULT_SLICE_MB_WIDTH 8
43 static const AVProfile profiles[] = {
44 { FF_PROFILE_PRORES_PROXY, "apco"},
45 { FF_PROFILE_PRORES_LT, "apcs"},
46 { FF_PROFILE_PRORES_STANDARD, "apcn"},
47 { FF_PROFILE_PRORES_HQ, "apch"},
48 { FF_PROFILE_PRORES_4444, "ap4h"},
49 { FF_PROFILE_PRORES_XQ, "ap4x"},
50 { FF_PROFILE_UNKNOWN }
53 static const int qp_start_table[] = { 8, 3, 2, 1, 1, 1};
54 static const int qp_end_table[] = { 13, 9, 6, 6, 5, 4};
55 static const int bitrate_table[] = { 1000, 2100, 3500, 5400, 7000, 10000};
57 static const int valid_primaries[] = { AVCOL_PRI_RESERVED0, AVCOL_PRI_BT709, AVCOL_PRI_UNSPECIFIED, AVCOL_PRI_BT470BG,
58 AVCOL_PRI_SMPTE170M, AVCOL_PRI_BT2020, AVCOL_PRI_SMPTE431, AVCOL_PRI_SMPTE432, INT_MAX };
59 static const int valid_trc[] = { AVCOL_TRC_RESERVED0, AVCOL_TRC_BT709, AVCOL_TRC_UNSPECIFIED, AVCOL_TRC_SMPTE2084,
60 AVCOL_TRC_ARIB_STD_B67, INT_MAX };
61 static const int valid_colorspace[] = { AVCOL_SPC_BT709, AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_SMPTE170M,
62 AVCOL_SPC_BT2020_NCL, INT_MAX };
64 static const uint8_t QMAT_LUMA[6][64] = {
66 4, 7, 9, 11, 13, 14, 15, 63,
67 7, 7, 11, 12, 14, 15, 63, 63,
68 9, 11, 13, 14, 15, 63, 63, 63,
69 11, 11, 13, 14, 63, 63, 63, 63,
70 11, 13, 14, 63, 63, 63, 63, 63,
71 13, 14, 63, 63, 63, 63, 63, 63,
72 13, 63, 63, 63, 63, 63, 63, 63,
73 63, 63, 63, 63, 63, 63, 63, 63
75 4, 5, 6, 7, 9, 11, 13, 15,
76 5, 5, 7, 8, 11, 13, 15, 17,
77 6, 7, 9, 11, 13, 15, 15, 17,
78 7, 7, 9, 11, 13, 15, 17, 19,
79 7, 9, 11, 13, 14, 16, 19, 23,
80 9, 11, 13, 14, 16, 19, 23, 29,
81 9, 11, 13, 15, 17, 21, 28, 35,
82 11, 13, 16, 17, 21, 28, 35, 41
84 4, 4, 5, 5, 6, 7, 7, 9,
85 4, 4, 5, 6, 7, 7, 9, 9,
86 5, 5, 6, 7, 7, 9, 9, 10,
87 5, 5, 6, 7, 7, 9, 9, 10,
88 5, 6, 7, 7, 8, 9, 10, 12,
89 6, 7, 7, 8, 9, 10, 12, 15,
90 6, 7, 7, 9, 10, 11, 14, 17,
91 7, 7, 9, 10, 11, 14, 17, 21
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
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, 5,
106 4, 4, 4, 4, 4, 4, 5, 5,
107 4, 4, 4, 4, 4, 5, 5, 6,
108 4, 4, 4, 4, 5, 5, 6, 7,
109 4, 4, 4, 4, 5, 6, 7, 7
111 2, 2, 2, 2, 2, 2, 2, 2,
112 2, 2, 2, 2, 2, 2, 2, 2,
113 2, 2, 2, 2, 2, 2, 2, 2,
114 2, 2, 2, 2, 2, 2, 2, 3,
115 2, 2, 2, 2, 2, 2, 3, 3,
116 2, 2, 2, 2, 2, 3, 3, 3,
117 2, 2, 2, 2, 3, 3, 3, 4,
118 2, 2, 2, 2, 3, 3, 4, 4,
122 static const uint8_t QMAT_CHROMA[6][64] = {
124 4, 7, 9, 11, 13, 14, 63, 63,
125 7, 7, 11, 12, 14, 63, 63, 63,
126 9, 11, 13, 14, 63, 63, 63, 63,
127 11, 11, 13, 14, 63, 63, 63, 63,
128 11, 13, 14, 63, 63, 63, 63, 63,
129 13, 14, 63, 63, 63, 63, 63, 63,
130 13, 63, 63, 63, 63, 63, 63, 63,
131 63, 63, 63, 63, 63, 63, 63, 63
133 4, 5, 6, 7, 9, 11, 13, 15,
134 5, 5, 7, 8, 11, 13, 15, 17,
135 6, 7, 9, 11, 13, 15, 15, 17,
136 7, 7, 9, 11, 13, 15, 17, 19,
137 7, 9, 11, 13, 14, 16, 19, 23,
138 9, 11, 13, 14, 16, 19, 23, 29,
139 9, 11, 13, 15, 17, 21, 28, 35,
140 11, 13, 16, 17, 21, 28, 35, 41
142 4, 4, 5, 5, 6, 7, 7, 9,
143 4, 4, 5, 6, 7, 7, 9, 9,
144 5, 5, 6, 7, 7, 9, 9, 10,
145 5, 5, 6, 7, 7, 9, 9, 10,
146 5, 6, 7, 7, 8, 9, 10, 12,
147 6, 7, 7, 8, 9, 10, 12, 15,
148 6, 7, 7, 9, 10, 11, 14, 17,
149 7, 7, 9, 10, 11, 14, 17, 21
151 4, 4, 4, 4, 4, 4, 4, 4,
152 4, 4, 4, 4, 4, 4, 4, 4,
153 4, 4, 4, 4, 4, 4, 4, 4,
154 4, 4, 4, 4, 4, 4, 4, 5,
155 4, 4, 4, 4, 4, 4, 5, 5,
156 4, 4, 4, 4, 4, 5, 5, 6,
157 4, 4, 4, 4, 5, 5, 6, 7,
158 4, 4, 4, 4, 5, 6, 7, 7
160 4, 4, 4, 4, 4, 4, 4, 4,
161 4, 4, 4, 4, 4, 4, 4, 4,
162 4, 4, 4, 4, 4, 4, 4, 4,
163 4, 4, 4, 4, 4, 4, 4, 5,
164 4, 4, 4, 4, 4, 4, 5, 5,
165 4, 4, 4, 4, 4, 5, 5, 6,
166 4, 4, 4, 4, 5, 5, 6, 7,
167 4, 4, 4, 4, 5, 6, 7, 7
169 4, 4, 4, 4, 4, 4, 4, 4,
170 4, 4, 4, 4, 4, 4, 4, 4,
171 4, 4, 4, 4, 4, 4, 4, 4,
172 4, 4, 4, 4, 4, 4, 4, 5,
173 4, 4, 4, 4, 4, 4, 5, 5,
174 4, 4, 4, 4, 4, 5, 5, 6,
175 4, 4, 4, 4, 5, 5, 6, 7,
176 4, 4, 4, 4, 5, 6, 7, 7
189 int qmat_luma[16][64];
190 int qmat_chroma[16][64];
191 const uint8_t *scantable;
200 static void encode_codeword(PutBitContext *pb, int val, int codebook)
202 unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros;
204 /* number of bits to switch between rice and exp golomb */
205 switch_bits = codebook & 3;
206 rice_order = codebook >> 5;
207 exp_order = (codebook >> 2) & 7;
209 first_exp = ((switch_bits + 1) << rice_order);
211 if (val >= first_exp) { /* exp golomb */
213 val += (1 << exp_order);
215 zeros = exp - exp_order + switch_bits + 1;
216 put_bits(pb, zeros, 0);
217 put_bits(pb, exp + 1, val);
218 } else if (rice_order) {
219 put_bits(pb, (val >> rice_order), 0);
221 put_sbits(pb, rice_order, val);
223 put_bits(pb, val, 0);
228 #define QSCALE(qmat,ind,val) ((val) / ((qmat)[ind]))
229 #define TO_GOLOMB(val) (((val) * 2) ^ ((val) >> 31))
230 #define DIFF_SIGN(val, sign) (((val) >> 31) ^ (sign))
231 #define IS_NEGATIVE(val) ((((val) >> 31) ^ -1) + 1)
232 #define TO_GOLOMB2(val,sign) ((val)==0 ? 0 : ((val) << 1) + (sign))
234 static av_always_inline int get_level(int val)
236 int sign = (val >> 31);
237 return (val ^ sign) - sign;
240 #define FIRST_DC_CB 0xB8
242 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
244 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
245 int blocks_per_slice, int *qmat)
249 int new_dc, delta, diff_sign, new_code;
251 prev_dc = QSCALE(qmat, 0, in[0] - 16384);
252 code = TO_GOLOMB(prev_dc);
253 encode_codeword(pb, code, FIRST_DC_CB);
255 code = 5; sign = 0; idx = 64;
256 for (i = 1; i < blocks_per_slice; i++, idx += 64) {
257 new_dc = QSCALE(qmat, 0, in[idx] - 16384);
258 delta = new_dc - prev_dc;
259 diff_sign = DIFF_SIGN(delta, sign);
260 new_code = TO_GOLOMB2(get_level(delta), diff_sign);
262 encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
270 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
271 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
272 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
273 0x28, 0x28, 0x28, 0x4C };
275 static void encode_ac_coeffs(PutBitContext *pb,
276 int16_t *in, int blocks_per_slice, int *qmat, const uint8_t ff_prores_scan[64])
281 int run = 0, level, code, i, j;
282 for (i = 1; i < 64; i++) {
283 int indp = ff_prores_scan[i];
284 for (j = 0; j < blocks_per_slice; j++) {
285 int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
287 encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
291 level = get_level(val);
294 encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
298 put_bits(pb, 1, IS_NEGATIVE(val));
306 static void get(uint8_t *pixels, int stride, int16_t* block)
310 for (i = 0; i < 8; i++) {
311 AV_WN64(block, AV_RN64(pixels));
312 AV_WN64(block+4, AV_RN64(pixels+8));
318 static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
320 get(pixels, stride, block);
324 static void calc_plane_dct(FDCTDSPContext *fdsp, uint8_t *src, int16_t * blocks, int src_stride, int mb_count, int chroma, int is_422)
331 if (!chroma) { /* Luma plane */
332 for (i = 0; i < mb_count; i++) {
333 fdct_get(fdsp, src, src_stride, block + (0 << 6));
334 fdct_get(fdsp, src + 16, src_stride, block + (1 << 6));
335 fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (2 << 6));
336 fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
341 } else if (chroma && is_422){ /* chroma plane 422 */
342 for (i = 0; i < mb_count; i++) {
343 fdct_get(fdsp, src, src_stride, block + (0 << 6));
344 fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (1 << 6));
348 } else { /* chroma plane 444 */
349 for (i = 0; i < mb_count; i++) {
350 fdct_get(fdsp, src, src_stride, block + (0 << 6));
351 fdct_get(fdsp, src + 8 * src_stride, src_stride, block + (1 << 6));
352 fdct_get(fdsp, src + 16, src_stride, block + (2 << 6));
353 fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
361 static int encode_slice_plane(int16_t *blocks, int mb_count, uint8_t *buf, unsigned buf_size, int *qmat, int sub_sample_chroma,
362 const uint8_t ff_prores_scan[64])
364 int blocks_per_slice;
367 blocks_per_slice = mb_count << (2 - sub_sample_chroma);
368 init_put_bits(&pb, buf, buf_size);
370 encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
371 encode_ac_coeffs(&pb, blocks, blocks_per_slice, qmat, ff_prores_scan);
374 return put_bits_ptr(&pb) - pb.buf;
377 static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
378 int16_t * blocks_y, int16_t * blocks_u, int16_t * blocks_v,
379 unsigned mb_count, uint8_t *buf, unsigned data_size,
380 unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
383 ProresContext* ctx = avctx->priv_data;
385 *y_data_size = encode_slice_plane(blocks_y, mb_count,
386 buf, data_size, ctx->qmat_luma[qp - 1], 0, ctx->scantable);
388 if (!(avctx->flags & AV_CODEC_FLAG_GRAY)) {
389 *u_data_size = encode_slice_plane(blocks_u, mb_count, buf + *y_data_size, data_size - *y_data_size,
390 ctx->qmat_chroma[qp - 1], ctx->is_422, ctx->scantable);
392 *v_data_size = encode_slice_plane(blocks_v, mb_count, buf + *y_data_size + *u_data_size,
393 data_size - *y_data_size - *u_data_size,
394 ctx->qmat_chroma[qp - 1], ctx->is_422, ctx->scantable);
397 return *y_data_size + *u_data_size + *v_data_size;
400 static void put_alpha_diff(PutBitContext *pb, int cur, int prev)
402 const int abits = 16;
404 const int dsize = 1 << dbits - 1;
405 int diff = cur - prev;
407 diff = av_mod_uintp2(diff, abits);
408 if (diff >= (1 << abits) - dsize)
410 if (diff < -dsize || diff > dsize || !diff) {
412 put_bits(pb, abits, diff);
415 put_bits(pb, dbits - 1, FFABS(diff) - 1);
416 put_bits(pb, 1, diff < 0);
420 static inline void put_alpha_run(PutBitContext *pb, int run)
425 put_bits(pb, 4, run);
427 put_bits(pb, 15, run);
433 static av_always_inline int encode_alpha_slice_data(AVCodecContext *avctx, int8_t * src_a,
434 unsigned mb_count, uint8_t *buf, unsigned data_size, unsigned* a_data_size)
436 const int abits = 16;
437 const int mask = (1 << abits) - 1;
438 const int num_coeffs = mb_count * 256;
439 int prev = mask, cur;
442 int16_t * blocks = (int16_t *)src_a;
444 init_put_bits(&pb, buf, data_size);
447 put_alpha_diff(&pb, cur, prev);
452 put_alpha_run (&pb, run);
453 put_alpha_diff(&pb, cur, prev);
459 } while (idx < num_coeffs);
461 put_alpha_run(&pb, run);
463 *a_data_size = put_bytes_output(&pb);
465 if (put_bits_left(&pb) < 0) {
466 av_log(avctx, AV_LOG_ERROR,
467 "Underestimated required buffer size.\n");
474 static inline void subimage_with_fill_template(uint16_t *src, unsigned x, unsigned y,
475 unsigned stride, unsigned width, unsigned height, uint16_t *dst,
476 unsigned dst_width, unsigned dst_height, int is_alpha_plane,
477 int is_interlaced, int is_top_field)
479 int box_width = FFMIN(width - x, dst_width);
480 int i, j, src_stride, box_height;
481 uint16_t last_pix, *last_line;
483 if (!is_interlaced) {
484 src_stride = stride >> 1;
485 src += y * src_stride + x;
486 box_height = FFMIN(height - y, dst_height);
488 src_stride = stride; /* 2 lines stride */
489 src += y * src_stride + x;
490 box_height = FFMIN(height/2 - y, dst_height);
495 for (i = 0; i < box_height; ++i) {
496 for (j = 0; j < box_width; ++j) {
497 if (!is_alpha_plane) {
500 dst[j] = src[j] << 6; /* alpha 10b to 16b */
503 if (!is_alpha_plane) {
504 last_pix = dst[j - 1];
506 last_pix = dst[j - 1] << 6; /* alpha 10b to 16b */
508 for (; j < dst_width; j++)
513 last_line = dst - dst_width;
514 for (; i < dst_height; i++) {
515 for (j = 0; j < dst_width; ++j) {
516 dst[j] = last_line[j];
522 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
523 unsigned stride, unsigned width, unsigned height, uint16_t *dst,
524 unsigned dst_width, unsigned dst_height, int is_interlaced, int is_top_field)
526 subimage_with_fill_template(src, x, y, stride, width, height, dst, dst_width, dst_height, 0, is_interlaced, is_top_field);
529 /* reorganize alpha data and convert 10b -> 16b */
530 static void subimage_alpha_with_fill(uint16_t *src, unsigned x, unsigned y,
531 unsigned stride, unsigned width, unsigned height, uint16_t *dst,
532 unsigned dst_width, unsigned dst_height, int is_interlaced, int is_top_field)
534 subimage_with_fill_template(src, x, y, stride, width, height, dst, dst_width, dst_height, 1, is_interlaced, is_top_field);
537 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
538 int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
539 int unsafe, int *qp, int is_interlaced, int is_top_field)
541 int luma_stride, chroma_stride, alpha_stride = 0;
542 ProresContext* ctx = avctx->priv_data;
543 int hdr_size = 6 + (ctx->need_alpha * 2); /* v data size is write when there is alpha */
544 int ret = 0, slice_size;
545 uint8_t *dest_y, *dest_u, *dest_v;
546 unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0, a_data_size = 0;
547 FDCTDSPContext *fdsp = &ctx->fdsp;
548 int tgt_bits = (mb_count * bitrate_table[avctx->profile]) >> 2;
549 int low_bytes = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
550 int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
552 LOCAL_ALIGNED(16, int16_t, blocks_y, [DEFAULT_SLICE_MB_WIDTH << 8]);
553 LOCAL_ALIGNED(16, int16_t, blocks_u, [DEFAULT_SLICE_MB_WIDTH << 8]);
554 LOCAL_ALIGNED(16, int16_t, blocks_v, [DEFAULT_SLICE_MB_WIDTH << 8]);
556 luma_stride = pic->linesize[0];
557 chroma_stride = pic->linesize[1];
560 alpha_stride = pic->linesize[3];
562 if (!is_interlaced) {
563 dest_y = pic->data[0] + (mb_y << 4) * luma_stride + (mb_x << 5);
564 dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
565 dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << (5 - ctx->is_422));
567 dest_y = pic->data[0] + (mb_y << 4) * luma_stride * 2 + (mb_x << 5);
568 dest_u = pic->data[1] + (mb_y << 4) * chroma_stride * 2 + (mb_x << (5 - ctx->is_422));
569 dest_v = pic->data[2] + (mb_y << 4) * chroma_stride * 2 + (mb_x << (5 - ctx->is_422));
570 if (!is_top_field){ /* bottom field, offset dest */
571 dest_y += luma_stride;
572 dest_u += chroma_stride;
573 dest_v += chroma_stride;
578 subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
579 luma_stride, avctx->width, avctx->height,
580 (uint16_t *) ctx->fill_y, mb_count << 4, 16, is_interlaced, is_top_field);
581 subimage_with_fill((uint16_t *) pic->data[1], mb_x << (4 - ctx->is_422), mb_y << 4,
582 chroma_stride, avctx->width >> ctx->is_422, avctx->height,
583 (uint16_t *) ctx->fill_u, mb_count << (4 - ctx->is_422), 16, is_interlaced, is_top_field);
584 subimage_with_fill((uint16_t *) pic->data[2], mb_x << (4 - ctx->is_422), mb_y << 4,
585 chroma_stride, avctx->width >> ctx->is_422, avctx->height,
586 (uint16_t *) ctx->fill_v, mb_count << (4 - ctx->is_422), 16, is_interlaced, is_top_field);
588 /* no need for interlaced special case, data already reorganized in subimage_with_fill */
589 calc_plane_dct(fdsp, ctx->fill_y, blocks_y, mb_count << 5, mb_count, 0, 0);
590 calc_plane_dct(fdsp, ctx->fill_u, blocks_u, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
591 calc_plane_dct(fdsp, ctx->fill_v, blocks_v, mb_count << (5 - ctx->is_422), mb_count, 1, ctx->is_422);
593 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
594 mb_count, buf + hdr_size, data_size - hdr_size,
595 &y_data_size, &u_data_size, &v_data_size,
598 if (!is_interlaced) {
599 calc_plane_dct(fdsp, dest_y, blocks_y, luma_stride, mb_count, 0, 0);
600 calc_plane_dct(fdsp, dest_u, blocks_u, chroma_stride, mb_count, 1, ctx->is_422);
601 calc_plane_dct(fdsp, dest_v, blocks_v, chroma_stride, mb_count, 1, ctx->is_422);
603 calc_plane_dct(fdsp, dest_y, blocks_y, luma_stride * 2, mb_count, 0, 0);
604 calc_plane_dct(fdsp, dest_u, blocks_u, chroma_stride * 2, mb_count, 1, ctx->is_422);
605 calc_plane_dct(fdsp, dest_v, blocks_v, chroma_stride * 2, mb_count, 1, ctx->is_422);
608 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
609 mb_count, buf + hdr_size, data_size - hdr_size,
610 &y_data_size, &u_data_size, &v_data_size,
613 if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
616 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
617 mb_count, buf + hdr_size, data_size - hdr_size,
618 &y_data_size, &u_data_size, &v_data_size,
620 } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
621 } else if (slice_size < low_bytes && *qp
622 > qp_start_table[avctx->profile]) {
625 slice_size = encode_slice_data(avctx, blocks_y, blocks_u, blocks_v,
626 mb_count, buf + hdr_size, data_size - hdr_size,
627 &y_data_size, &u_data_size, &v_data_size,
629 } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
633 buf[0] = hdr_size << 3;
635 AV_WB16(buf + 2, y_data_size);
636 AV_WB16(buf + 4, u_data_size);
638 if (ctx->need_alpha) {
639 AV_WB16(buf + 6, v_data_size); /* write v data size only if there is alpha */
641 subimage_alpha_with_fill((uint16_t *) pic->data[3], mb_x << 4, mb_y << 4,
642 alpha_stride, avctx->width, avctx->height,
643 (uint16_t *) ctx->fill_a, mb_count << 4, 16, is_interlaced, is_top_field);
644 ret = encode_alpha_slice_data(avctx, ctx->fill_a, mb_count,
645 buf + hdr_size + slice_size,
646 data_size - hdr_size - slice_size, &a_data_size);
652 return hdr_size + y_data_size + u_data_size + v_data_size + a_data_size;
655 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
656 uint8_t *buf, const int buf_size, const int picture_index, const int is_top_field)
658 ProresContext *ctx = avctx->priv_data;
659 int mb_width = (avctx->width + 15) >> 4;
660 int hdr_size, sl_size, i;
661 int mb_y, sl_data_size, qp, mb_height, picture_height, unsafe_mb_height_limit;
662 int unsafe_bot, unsafe_right;
663 uint8_t *sl_data, *sl_data_sizes;
664 int slice_per_line = 0, rem = mb_width;
666 if (!ctx->is_interlaced) { /* progressive encoding */
667 mb_height = (avctx->height + 15) >> 4;
668 unsafe_mb_height_limit = mb_height;
671 picture_height = (avctx->height + 1) / 2;
673 picture_height = avctx->height / 2;
675 mb_height = (picture_height + 15) >> 4;
676 unsafe_mb_height_limit = mb_height;
679 for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
680 slice_per_line += rem >> i;
684 qp = qp_start_table[avctx->profile];
685 hdr_size = 8; sl_data_size = buf_size - hdr_size;
686 sl_data_sizes = buf + hdr_size;
687 sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
688 for (mb_y = 0; mb_y < mb_height; mb_y++) {
690 int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
691 while (mb_x < mb_width) {
692 while (mb_width - mb_x < slice_mb_count)
693 slice_mb_count >>= 1;
695 unsafe_bot = (avctx->height & 0xf) && (mb_y == unsafe_mb_height_limit - 1);
696 unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
698 sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
699 sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp, ctx->is_interlaced, is_top_field);
704 bytestream_put_be16(&sl_data_sizes, sl_size);
706 sl_data_size -= sl_size;
707 mb_x += slice_mb_count;
711 buf[0] = hdr_size << 3;
712 AV_WB32(buf + 1, sl_data - buf);
713 AV_WB16(buf + 5, slice_per_line * mb_height); /* picture size */
714 buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4; /* number of slices */
716 return sl_data - buf;
719 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
720 const AVFrame *pict, int *got_packet)
722 ProresContext *ctx = avctx->priv_data;
723 int header_size = 148;
725 int compress_frame_size, pic_size, ret, is_top_field_first = 0;
727 int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + AV_INPUT_BUFFER_MIN_SIZE; //FIXME choose tighter limit
730 if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
734 compress_frame_size = 8 + header_size;
736 bytestream_put_be32(&buf, compress_frame_size);/* frame size will be update after picture(s) encoding */
737 bytestream_put_buffer(&buf, "icpf", 4);
739 bytestream_put_be16(&buf, header_size);
740 bytestream_put_be16(&buf, 0); /* version */
741 bytestream_put_buffer(&buf, ctx->vendor, 4);
742 bytestream_put_be16(&buf, avctx->width);
743 bytestream_put_be16(&buf, avctx->height);
744 frame_flags = 0x82; /* 422 not interlaced */
745 if (avctx->profile >= FF_PROFILE_PRORES_4444) /* 4444 or 4444 Xq */
746 frame_flags |= 0x40; /* 444 chroma */
747 if (ctx->is_interlaced) {
748 if (pict->top_field_first || !pict->interlaced_frame) { /* tff frame or progressive frame interpret as tff */
749 av_log(avctx, AV_LOG_DEBUG, "use interlaced encoding, top field first\n");
750 frame_flags |= 0x04; /* interlaced tff */
751 is_top_field_first = 1;
753 av_log(avctx, AV_LOG_DEBUG, "use interlaced encoding, bottom field first\n");
754 frame_flags |= 0x08; /* interlaced bff */
757 av_log(avctx, AV_LOG_DEBUG, "use progressive encoding\n");
759 *buf++ = frame_flags;
760 *buf++ = 0; /* reserved */
761 /* only write color properties, if valid value. set to unspecified otherwise */
762 *buf++ = ff_int_from_list_or_default(avctx, "frame color primaries", pict->color_primaries, valid_primaries, 0);
763 *buf++ = ff_int_from_list_or_default(avctx, "frame color trc", pict->color_trc, valid_trc, 0);
764 *buf++ = ff_int_from_list_or_default(avctx, "frame colorspace", pict->colorspace, valid_colorspace, 0);
765 if (avctx->profile >= FF_PROFILE_PRORES_4444) {
766 if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
767 *buf++ = 0xA0;/* src b64a and no alpha */
769 *buf++ = 0xA2;/* src b64a and 16b alpha */
772 *buf++ = 32;/* src v210 and no alpha */
774 *buf++ = 0; /* reserved */
775 *buf++ = 3; /* luma and chroma matrix present */
777 bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile], 64);
778 bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
780 pic_size = prores_encode_picture(avctx, pict, buf,
781 pkt->size - compress_frame_size, 0, is_top_field_first);/* encode progressive or first field */
785 compress_frame_size += pic_size;
787 if (ctx->is_interlaced) { /* encode second field */
788 pic_size = prores_encode_picture(avctx, pict, pkt->data + compress_frame_size,
789 pkt->size - compress_frame_size, 1, !is_top_field_first);
793 compress_frame_size += pic_size;
796 AV_WB32(pkt->data, compress_frame_size);/* update frame size */
797 pkt->flags |= AV_PKT_FLAG_KEY;
798 pkt->size = compress_frame_size;
804 static void scale_mat(const uint8_t* src, int* dst, int scale)
807 for (i = 0; i < 64; i++)
808 dst[i] = src[i] * scale;
811 static av_cold int prores_encode_init(AVCodecContext *avctx)
814 ProresContext* ctx = avctx->priv_data;
816 avctx->bits_per_raw_sample = 10;
818 ctx->is_interlaced = !!(avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT);
819 if (ctx->is_interlaced) {
820 ctx->scantable = ff_prores_interlaced_scan;
822 ctx->scantable = ff_prores_progressive_scan;
825 if (avctx->width & 0x1) {
826 av_log(avctx, AV_LOG_ERROR,
827 "frame width needs to be multiple of 2\n");
828 return AVERROR(EINVAL);
831 if (avctx->width > 65534 || avctx->height > 65535) {
832 av_log(avctx, AV_LOG_ERROR,
833 "The maximum dimensions are 65534x65535\n");
834 return AVERROR(EINVAL);
837 if (strlen(ctx->vendor) != 4) {
838 av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
839 return AVERROR(EINVAL);
842 if (avctx->profile == FF_PROFILE_UNKNOWN) {
843 if (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
844 avctx->profile = FF_PROFILE_PRORES_STANDARD;
845 av_log(avctx, AV_LOG_INFO,
846 "encoding with ProRes standard (apcn) profile\n");
847 } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
848 avctx->profile = FF_PROFILE_PRORES_4444;
849 av_log(avctx, AV_LOG_INFO,
850 "encoding with ProRes 4444 (ap4h) profile\n");
851 } else if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
852 avctx->profile = FF_PROFILE_PRORES_4444;
853 av_log(avctx, AV_LOG_INFO,
854 "encoding with ProRes 4444+ (ap4h) profile\n");
856 av_log(avctx, AV_LOG_ERROR, "Unknown pixel format\n");
857 return AVERROR(EINVAL);
859 } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
860 || avctx->profile > FF_PROFILE_PRORES_XQ) {
864 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch, 4 - ap4h, 5 - ap4x]\n",
866 return AVERROR(EINVAL);
867 } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P10) && (avctx->profile > FF_PROFILE_PRORES_HQ)){
868 av_log(avctx, AV_LOG_ERROR,
869 "encoding with ProRes 444/Xq (ap4h/ap4x) profile, need YUV444P10 input\n");
870 return AVERROR(EINVAL);
871 } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10)
872 && (avctx->profile < FF_PROFILE_PRORES_4444)){
873 av_log(avctx, AV_LOG_ERROR,
874 "encoding with ProRes Proxy/LT/422/422 HQ (apco, apcs, apcn, ap4h) profile, need YUV422P10 input\n");
875 return AVERROR(EINVAL);
878 if (avctx->profile < FF_PROFILE_PRORES_4444) { /* 422 versions */
880 if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
881 ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
883 return AVERROR(ENOMEM);
884 ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
885 ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
889 if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
890 ctx->fill_y = av_malloc(3 * (DEFAULT_SLICE_MB_WIDTH << 9));
892 return AVERROR(ENOMEM);
893 ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
894 ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 9);
896 if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
898 ctx->fill_a = av_malloc(DEFAULT_SLICE_MB_WIDTH << 9); /* 8 blocks x 16px x 16px x sizeof (uint16) */
900 return AVERROR(ENOMEM);
904 ff_fdctdsp_init(&ctx->fdsp, avctx);
906 avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
908 for (i = 1; i <= 16; i++) {
909 scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
910 scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
916 static av_cold int prores_encode_close(AVCodecContext *avctx)
918 ProresContext* ctx = avctx->priv_data;
919 av_freep(&ctx->fill_y);
920 av_freep(&ctx->fill_a);
925 #define OFFSET(x) offsetof(ProresContext, x)
926 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
928 static const AVOption options[] = {
929 { "vendor", "vendor ID", OFFSET(vendor), AV_OPT_TYPE_STRING, { .str = "fmpg" }, 0, 0, VE },
933 static const AVClass proresaw_enc_class = {
934 .class_name = "ProResAw encoder",
935 .item_name = av_default_item_name,
937 .version = LIBAVUTIL_VERSION_INT,
940 static const AVClass prores_enc_class = {
941 .class_name = "ProRes encoder",
942 .item_name = av_default_item_name,
944 .version = LIBAVUTIL_VERSION_INT,
947 const AVCodec ff_prores_aw_encoder = {
949 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
950 .type = AVMEDIA_TYPE_VIDEO,
951 .id = AV_CODEC_ID_PRORES,
952 .priv_data_size = sizeof(ProresContext),
953 .init = prores_encode_init,
954 .close = prores_encode_close,
955 .encode2 = prores_encode_frame,
956 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
957 .capabilities = AV_CODEC_CAP_FRAME_THREADS,
958 .priv_class = &proresaw_enc_class,
959 .profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
960 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
963 const AVCodec ff_prores_encoder = {
965 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
966 .type = AVMEDIA_TYPE_VIDEO,
967 .id = AV_CODEC_ID_PRORES,
968 .priv_data_size = sizeof(ProresContext),
969 .init = prores_encode_init,
970 .close = prores_encode_close,
971 .encode2 = prores_encode_frame,
972 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE},
973 .capabilities = AV_CODEC_CAP_FRAME_THREADS,
974 .priv_class = &prores_enc_class,
975 .profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
976 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,