4 * Copyright (c) 2011 Anatoliy Wasserman
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * Apple ProRes encoder (Anatoliy Wasserman version)
26 * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy)
32 #include "bytestream.h"
35 #define DEFAULT_SLICE_MB_WIDTH 8
37 #define FF_PROFILE_PRORES_PROXY 0
38 #define FF_PROFILE_PRORES_LT 1
39 #define FF_PROFILE_PRORES_STANDARD 2
40 #define FF_PROFILE_PRORES_HQ 3
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_UNKNOWN }
50 static const int qp_start_table[4] = { 4, 1, 1, 1 };
51 static const int qp_end_table[4] = { 8, 9, 6, 6 };
52 static const int bitrate_table[5] = { 1000, 2100, 3500, 5400 };
54 static const uint8_t progressive_scan[64] = {
55 0, 1, 8, 9, 2, 3, 10, 11,
56 16, 17, 24, 25, 18, 19, 26, 27,
57 4, 5, 12, 20, 13, 6, 7, 14,
58 21, 28, 29, 22, 15, 23, 30, 31,
59 32, 33, 40, 48, 41, 34, 35, 42,
60 49, 56, 57, 50, 43, 36, 37, 44,
61 51, 58, 59, 52, 45, 38, 39, 46,
62 53, 60, 61, 54, 47, 55, 62, 63
65 static const uint8_t QMAT_LUMA[4][64] = {
67 4, 7, 9, 11, 13, 14, 15, 63,
68 7, 7, 11, 12, 14, 15, 63, 63,
69 9, 11, 13, 14, 15, 63, 63, 63,
70 11, 11, 13, 14, 63, 63, 63, 63,
71 11, 13, 14, 63, 63, 63, 63, 63,
72 13, 14, 63, 63, 63, 63, 63, 63,
73 13, 63, 63, 63, 63, 63, 63, 63,
74 63, 63, 63, 63, 63, 63, 63, 63
76 4, 5, 6, 7, 9, 11, 13, 15,
77 5, 5, 7, 8, 11, 13, 15, 17,
78 6, 7, 9, 11, 13, 15, 15, 17,
79 7, 7, 9, 11, 13, 15, 17, 19,
80 7, 9, 11, 13, 14, 16, 19, 23,
81 9, 11, 13, 14, 16, 19, 23, 29,
82 9, 11, 13, 15, 17, 21, 28, 35,
83 11, 13, 16, 17, 21, 28, 35, 41
85 4, 4, 5, 5, 6, 7, 7, 9,
86 4, 4, 5, 6, 7, 7, 9, 9,
87 5, 5, 6, 7, 7, 9, 9, 10,
88 5, 5, 6, 7, 7, 9, 9, 10,
89 5, 6, 7, 7, 8, 9, 10, 12,
90 6, 7, 7, 8, 9, 10, 12, 15,
91 6, 7, 7, 9, 10, 11, 14, 17,
92 7, 7, 9, 10, 11, 14, 17, 21
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, 4,
97 4, 4, 4, 4, 4, 4, 4, 5,
98 4, 4, 4, 4, 4, 4, 5, 5,
99 4, 4, 4, 4, 4, 5, 5, 6,
100 4, 4, 4, 4, 5, 5, 6, 7,
101 4, 4, 4, 4, 5, 6, 7, 7
105 static const uint8_t QMAT_CHROMA[4][64] = {
107 4, 7, 9, 11, 13, 14, 63, 63,
108 7, 7, 11, 12, 14, 63, 63, 63,
109 9, 11, 13, 14, 63, 63, 63, 63,
110 11, 11, 13, 14, 63, 63, 63, 63,
111 11, 13, 14, 63, 63, 63, 63, 63,
112 13, 14, 63, 63, 63, 63, 63, 63,
113 13, 63, 63, 63, 63, 63, 63, 63,
114 63, 63, 63, 63, 63, 63, 63, 63
116 4, 5, 6, 7, 9, 11, 13, 15,
117 5, 5, 7, 8, 11, 13, 15, 17,
118 6, 7, 9, 11, 13, 15, 15, 17,
119 7, 7, 9, 11, 13, 15, 17, 19,
120 7, 9, 11, 13, 14, 16, 19, 23,
121 9, 11, 13, 14, 16, 19, 23, 29,
122 9, 11, 13, 15, 17, 21, 28, 35,
123 11, 13, 16, 17, 21, 28, 35, 41
125 4, 4, 5, 5, 6, 7, 7, 9,
126 4, 4, 5, 6, 7, 7, 9, 9,
127 5, 5, 6, 7, 7, 9, 9, 10,
128 5, 5, 6, 7, 7, 9, 9, 10,
129 5, 6, 7, 7, 8, 9, 10, 12,
130 6, 7, 7, 8, 9, 10, 12, 15,
131 6, 7, 7, 9, 10, 11, 14, 17,
132 7, 7, 9, 10, 11, 14, 17, 21
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, 4,
137 4, 4, 4, 4, 4, 4, 4, 5,
138 4, 4, 4, 4, 4, 4, 5, 5,
139 4, 4, 4, 4, 4, 5, 5, 6,
140 4, 4, 4, 4, 5, 5, 6, 7,
141 4, 4, 4, 4, 5, 6, 7, 7
151 int qmat_luma[16][64];
152 int qmat_chroma[16][64];
155 static void encode_codeword(PutBitContext *pb, int val, int codebook)
157 unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros,
160 /* number of bits to switch between rice and exp golomb */
161 switch_bits = codebook & 3;
162 rice_order = codebook >> 5;
163 exp_order = (codebook >> 2) & 7;
165 first_exp = ((switch_bits + 1) << rice_order);
167 if (val >= first_exp) { /* exp golomb */
169 val += (1 << exp_order);
171 zeros = exp - exp_order + switch_bits + 1;
172 put_bits(pb, zeros, 0);
173 put_bits(pb, exp + 1, val);
174 } else if (rice_order) {
175 mask = (1 << rice_order) - 1;
176 put_bits(pb, (val >> rice_order), 0);
178 put_bits(pb, rice_order, val & mask);
180 put_bits(pb, val, 0);
185 #define QSCALE(qmat,ind,val) ((val) / (qmat[ind]))
186 #define TO_GOLOMB(val) ((val << 1) ^ (val >> 31))
187 #define DIFF_SIGN(val, sign) ((val >> 31) ^ sign)
188 #define IS_NEGATIVE(val) (((val >> 31) ^ -1) + 1)
189 #define TO_GOLOMB2(val,sign) (val==0 ? 0 : (val << 1) + sign)
191 static av_always_inline int get_level(int val)
193 int sign = (val >> 31);
194 return (val ^ sign) - sign;
197 #define FIRST_DC_CB 0xB8
199 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
201 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
202 int blocks_per_slice, int *qmat)
206 int new_dc, delta, diff_sign, new_code;
208 prev_dc = QSCALE(qmat, 0, in[0] - 16384);
209 code = TO_GOLOMB(prev_dc);
210 encode_codeword(pb, code, FIRST_DC_CB);
212 code = 5; sign = 0; idx = 64;
213 for (i = 1; i < blocks_per_slice; i++, idx += 64) {
214 new_dc = QSCALE(qmat, 0, in[idx] - 16384);
215 delta = new_dc - prev_dc;
216 diff_sign = DIFF_SIGN(delta, sign);
217 new_code = TO_GOLOMB2(get_level(delta), diff_sign);
219 encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
227 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
228 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
229 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
230 0x28, 0x28, 0x28, 0x4C };
232 static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb,
233 int16_t *in, int blocks_per_slice, int *qmat)
238 int run = 0, level, code, i, j;
239 for (i = 1; i < 64; i++) {
240 int indp = progressive_scan[i];
241 for (j = 0; j < blocks_per_slice; j++) {
242 int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
244 encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
248 level = get_level(val);
251 encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
255 put_bits(pb, 1, IS_NEGATIVE(val));
263 static void get(uint8_t *pixels, int stride, int16_t* block)
265 int16_t *p = (int16_t*)pixels;
269 for (i = 0; i < 8; i++) {
270 for (j = 0; j < 8; j++) {
278 static void fdct_get(uint8_t *pixels, int stride, int16_t* block)
280 get(pixels, stride, block);
281 ff_jpeg_fdct_islow_10(block);
284 static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
285 uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
286 int *qmat, int chroma)
288 DECLARE_ALIGNED(16, int16_t, blocks)[DEFAULT_SLICE_MB_WIDTH << 8], *block;
289 int i, blocks_per_slice;
293 for (i = 0; i < mb_count; i++) {
294 fdct_get(src, src_stride, block + (0 << 6));
295 fdct_get(src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
297 fdct_get(src + 16, src_stride, block + (1 << 6));
298 fdct_get(src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
301 block += (256 >> chroma);
302 src += (32 >> chroma);
305 blocks_per_slice = mb_count << (2 - chroma);
306 init_put_bits(&pb, buf, buf_size << 3);
308 encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
309 encode_ac_coeffs(avctx, &pb, blocks, blocks_per_slice, qmat);
312 return put_bits_ptr(&pb) - pb.buf;
315 static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
316 uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride,
317 int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size,
318 unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
321 ProresContext* ctx = avctx->priv_data;
323 *y_data_size = encode_slice_plane(avctx, mb_count, dest_y, luma_stride,
324 buf, data_size, ctx->qmat_luma[qp - 1], 0);
326 if (!(avctx->flags & CODEC_FLAG_GRAY)) {
327 *u_data_size = encode_slice_plane(avctx, mb_count, dest_u,
328 chroma_stride, buf + *y_data_size, data_size - *y_data_size,
329 ctx->qmat_chroma[qp - 1], 1);
331 *v_data_size = encode_slice_plane(avctx, mb_count, dest_v,
332 chroma_stride, buf + *y_data_size + *u_data_size,
333 data_size - *y_data_size - *u_data_size,
334 ctx->qmat_chroma[qp - 1], 1);
337 return *y_data_size + *u_data_size + *v_data_size;
340 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
341 unsigned stride, unsigned width, unsigned height, uint16_t *dst,
342 unsigned dst_width, unsigned dst_height)
345 int box_width = FFMIN(width - x, dst_width);
346 int box_height = FFMIN(height - y, dst_height);
347 int i, j, src_stride = stride >> 1;
348 uint16_t last_pix, *last_line;
350 src += y * src_stride + x;
351 for (i = 0; i < box_height; ++i) {
352 for (j = 0; j < box_width; ++j) {
355 last_pix = dst[j - 1];
356 for (; j < dst_width; j++)
361 last_line = dst - dst_width;
362 for (; i < dst_height; i++) {
363 for (j = 0; j < dst_width; ++j) {
364 dst[j] = last_line[j];
370 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
371 int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
374 int luma_stride, chroma_stride;
375 int hdr_size = 6, slice_size;
376 uint8_t *dest_y, *dest_u, *dest_v;
377 unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0;
378 ProresContext* ctx = avctx->priv_data;
379 int tgt_bits = (mb_count * bitrate_table[avctx->profile]) >> 2;
380 int low_bytes = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
381 int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
383 luma_stride = pic->linesize[0];
384 chroma_stride = pic->linesize[1];
386 dest_y = pic->data[0] + (mb_y << 4) * luma_stride + (mb_x << 5);
387 dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << 4);
388 dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << 4);
392 subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
393 luma_stride, avctx->width, avctx->height,
394 (uint16_t *) ctx->fill_y, mb_count << 4, 16);
395 subimage_with_fill((uint16_t *) pic->data[1], mb_x << 3, mb_y << 4,
396 chroma_stride, avctx->width >> 1, avctx->height,
397 (uint16_t *) ctx->fill_u, mb_count << 3, 16);
398 subimage_with_fill((uint16_t *) pic->data[2], mb_x << 3, mb_y << 4,
399 chroma_stride, avctx->width >> 1, avctx->height,
400 (uint16_t *) ctx->fill_v, mb_count << 3, 16);
402 encode_slice_data(avctx, ctx->fill_y, ctx->fill_u, ctx->fill_v,
403 mb_count << 5, mb_count << 4, mb_count, buf + hdr_size,
404 data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
407 slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
408 luma_stride, chroma_stride, mb_count, buf + hdr_size,
409 data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
412 if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
415 slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
416 luma_stride, chroma_stride, mb_count, buf + hdr_size,
417 data_size - hdr_size, &y_data_size, &u_data_size,
419 } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
420 } else if (slice_size < low_bytes && *qp
421 > qp_start_table[avctx->profile]) {
424 slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
425 luma_stride, chroma_stride, mb_count, buf + hdr_size,
426 data_size - hdr_size, &y_data_size, &u_data_size,
428 } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
432 buf[0] = hdr_size << 3;
434 AV_WB16(buf + 2, y_data_size);
435 AV_WB16(buf + 4, u_data_size);
437 return hdr_size + y_data_size + u_data_size + v_data_size;
440 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
441 uint8_t *buf, const int buf_size)
443 int mb_width = (avctx->width + 15) >> 4;
444 int mb_height = (avctx->height + 15) >> 4;
445 int hdr_size, sl_size, i;
446 int mb_y, sl_data_size, qp;
447 int unsafe_bot, unsafe_right;
448 uint8_t *sl_data, *sl_data_sizes;
449 int slice_per_line = 0, rem = mb_width;
451 for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
452 slice_per_line += rem >> i;
456 qp = qp_start_table[avctx->profile];
457 hdr_size = 8; sl_data_size = buf_size - hdr_size;
458 sl_data_sizes = buf + hdr_size;
459 sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
460 for (mb_y = 0; mb_y < mb_height; mb_y++) {
462 int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
463 while (mb_x < mb_width) {
464 while (mb_width - mb_x < slice_mb_count)
465 slice_mb_count >>= 1;
467 unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
468 unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
470 sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
471 sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp);
473 bytestream_put_be16(&sl_data_sizes, sl_size);
475 sl_data_size -= sl_size;
476 mb_x += slice_mb_count;
480 buf[0] = hdr_size << 3;
481 AV_WB32(buf + 1, sl_data - buf);
482 AV_WB16(buf + 5, slice_per_line * mb_height);
483 buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4;
485 return sl_data - buf;
488 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
489 const AVFrame *pict, int *got_packet)
491 int header_size = 148;
494 int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + FF_MIN_BUFFER_SIZE; //FIXME choose tighter limit
497 if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + FF_MIN_BUFFER_SIZE)) < 0)
501 pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
502 pkt->size - header_size - 8);
504 bytestream_put_be32(&buf, pic_size + 8 + header_size);
505 bytestream_put_buffer(&buf, "icpf", 4);
507 bytestream_put_be16(&buf, header_size);
508 bytestream_put_be16(&buf, 0);
509 bytestream_put_buffer(&buf, "fmpg", 4);
510 bytestream_put_be16(&buf, avctx->width);
511 bytestream_put_be16(&buf, avctx->height);
512 *buf++ = 0x83; // {10}(422){00}{00}(frame){11}
521 bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile], 64);
522 bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
524 pkt->flags |= AV_PKT_FLAG_KEY;
525 pkt->size = pic_size + 8 + header_size;
531 static void scale_mat(const uint8_t* src, int* dst, int scale)
534 for (i = 0; i < 64; i++)
535 dst[i] = src[i] * scale;
538 static av_cold int prores_encode_init(AVCodecContext *avctx)
541 ProresContext* ctx = avctx->priv_data;
543 if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
544 av_log(avctx, AV_LOG_ERROR, "need YUV422P10\n");
547 if (avctx->width & 0x1) {
548 av_log(avctx, AV_LOG_ERROR,
549 "frame width needs to be multiple of 2\n");
553 if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
554 ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
556 return AVERROR(ENOMEM);
557 ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
558 ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
561 if (avctx->profile == FF_PROFILE_UNKNOWN) {
562 avctx->profile = FF_PROFILE_PRORES_STANDARD;
563 av_log(avctx, AV_LOG_INFO,
564 "encoding with ProRes standard (apcn) profile\n");
566 } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
567 || avctx->profile > FF_PROFILE_PRORES_HQ) {
571 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
576 avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
578 for (i = 1; i <= 16; i++) {
579 scale_mat(QMAT_LUMA[avctx->profile] , ctx->qmat_luma[i - 1] , i);
580 scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
583 avctx->coded_frame = avcodec_alloc_frame();
584 avctx->coded_frame->key_frame = 1;
585 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
590 static av_cold int prores_encode_close(AVCodecContext *avctx)
592 ProresContext* ctx = avctx->priv_data;
593 av_freep(&avctx->coded_frame);
594 av_freep(&ctx->fill_y);
599 AVCodec ff_prores_anatoliy_encoder = {
600 .name = "prores_anatoliy",
601 .type = AVMEDIA_TYPE_VIDEO,
602 .id = AV_CODEC_ID_PRORES,
603 .priv_data_size = sizeof(ProresContext),
604 .init = prores_encode_init,
605 .close = prores_encode_close,
606 .encode2 = prores_encode_frame,
607 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
608 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
609 .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
613 AVCodec ff_prores_encoder = {
615 .type = AVMEDIA_TYPE_VIDEO,
616 .id = AV_CODEC_ID_PRORES,
617 .priv_data_size = sizeof(ProresContext),
618 .init = prores_encode_init,
619 .close = prores_encode_close,
620 .encode2 = prores_encode_frame,
621 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
622 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
623 .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,