git.sesse.net Git - ffmpeg/blob - libavcodec/proresenc_anatoliy.c

   1 /*
   2  * Apple ProRes encoder
   3  *
   4  * Copyright (c) 2011 Anatoliy Wasserman
   5  *
   6  * This file is part of FFmpeg.
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 /**
  24  * @file
  25  * Apple ProRes encoder (Anatoliy Wasserman version)
  26  * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy)
  27  */
  28
  29 #include "avcodec.h"
  30 #include "dct.h"
  31 #include "internal.h"
  32 #include "put_bits.h"
  33 #include "bytestream.h"
  34 #include "dsputil.h"
  35
  36 #define DEFAULT_SLICE_MB_WIDTH 8
  37
  38 #define FF_PROFILE_PRORES_PROXY     0
  39 #define FF_PROFILE_PRORES_LT        1
  40 #define FF_PROFILE_PRORES_STANDARD  2
  41 #define FF_PROFILE_PRORES_HQ        3
  42
  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_UNKNOWN }
  49 };
  50
  51 static const int qp_start_table[4] = { 4, 1, 1, 1 };
  52 static const int qp_end_table[4]   = { 8, 9, 6, 6 };
  53 static const int bitrate_table[5]  = { 1000, 2100, 3500, 5400 };
  54
  55 static const uint8_t progressive_scan[64] = {
  56      0,  1,  8,  9,  2,  3, 10, 11,
  57     16, 17, 24, 25, 18, 19, 26, 27,
  58      4,  5, 12, 20, 13,  6,  7, 14,
  59     21, 28, 29, 22, 15, 23, 30, 31,
  60     32, 33, 40, 48, 41, 34, 35, 42,
  61     49, 56, 57, 50, 43, 36, 37, 44,
  62     51, 58, 59, 52, 45, 38, 39, 46,
  63     53, 60, 61, 54, 47, 55, 62, 63
  64 };
  65
  66 static const uint8_t QMAT_LUMA[4][64] = {
  67     {
  68          4,  7,  9, 11, 13, 14, 15, 63,
  69          7,  7, 11, 12, 14, 15, 63, 63,
  70          9, 11, 13, 14, 15, 63, 63, 63,
  71         11, 11, 13, 14, 63, 63, 63, 63,
  72         11, 13, 14, 63, 63, 63, 63, 63,
  73         13, 14, 63, 63, 63, 63, 63, 63,
  74         13, 63, 63, 63, 63, 63, 63, 63,
  75         63, 63, 63, 63, 63, 63, 63, 63
  76     }, {
  77          4,  5,  6,  7,  9, 11, 13, 15,
  78          5,  5,  7,  8, 11, 13, 15, 17,
  79          6,  7,  9, 11, 13, 15, 15, 17,
  80          7,  7,  9, 11, 13, 15, 17, 19,
  81          7,  9, 11, 13, 14, 16, 19, 23,
  82          9, 11, 13, 14, 16, 19, 23, 29,
  83          9, 11, 13, 15, 17, 21, 28, 35,
  84         11, 13, 16, 17, 21, 28, 35, 41
  85     }, {
  86          4,  4,  5,  5,  6,  7,  7,  9,
  87          4,  4,  5,  6,  7,  7,  9,  9,
  88          5,  5,  6,  7,  7,  9,  9, 10,
  89          5,  5,  6,  7,  7,  9,  9, 10,
  90          5,  6,  7,  7,  8,  9, 10, 12,
  91          6,  7,  7,  8,  9, 10, 12, 15,
  92          6,  7,  7,  9, 10, 11, 14, 17,
  93          7,  7,  9, 10, 11, 14, 17, 21
  94     }, {
  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,  4,
  98          4,  4,  4,  4,  4,  4,  4,  5,
  99          4,  4,  4,  4,  4,  4,  5,  5,
 100          4,  4,  4,  4,  4,  5,  5,  6,
 101          4,  4,  4,  4,  5,  5,  6,  7,
 102          4,  4,  4,  4,  5,  6,  7,  7
 103     }
 104 };
 105
 106 static const uint8_t QMAT_CHROMA[4][64] = {
 107     {
 108          4,  7,  9, 11, 13, 14, 63, 63,
 109          7,  7, 11, 12, 14, 63, 63, 63,
 110          9, 11, 13, 14, 63, 63, 63, 63,
 111         11, 11, 13, 14, 63, 63, 63, 63,
 112         11, 13, 14, 63, 63, 63, 63, 63,
 113         13, 14, 63, 63, 63, 63, 63, 63,
 114         13, 63, 63, 63, 63, 63, 63, 63,
 115         63, 63, 63, 63, 63, 63, 63, 63
 116     }, {
 117          4,  5,  6,  7,  9, 11, 13, 15,
 118          5,  5,  7,  8, 11, 13, 15, 17,
 119          6,  7,  9, 11, 13, 15, 15, 17,
 120          7,  7,  9, 11, 13, 15, 17, 19,
 121          7,  9, 11, 13, 14, 16, 19, 23,
 122          9, 11, 13, 14, 16, 19, 23, 29,
 123          9, 11, 13, 15, 17, 21, 28, 35,
 124         11, 13, 16, 17, 21, 28, 35, 41
 125     }, {
 126          4,  4,  5,  5,  6,  7,  7,  9,
 127          4,  4,  5,  6,  7,  7,  9,  9,
 128          5,  5,  6,  7,  7,  9,  9, 10,
 129          5,  5,  6,  7,  7,  9,  9, 10,
 130          5,  6,  7,  7,  8,  9, 10, 12,
 131          6,  7,  7,  8,  9, 10, 12, 15,
 132          6,  7,  7,  9, 10, 11, 14, 17,
 133          7,  7,  9, 10, 11, 14, 17, 21
 134     }, {
 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,  4,
 138          4,  4,  4,  4,  4,  4,  4,  5,
 139          4,  4,  4,  4,  4,  4,  5,  5,
 140          4,  4,  4,  4,  4,  5,  5,  6,
 141          4,  4,  4,  4,  5,  5,  6,  7,
 142          4,  4,  4,  4,  5,  6,  7,  7
 143     }
 144 };
 145
 146
 147 typedef struct {
 148     uint8_t* fill_y;
 149     uint8_t* fill_u;
 150     uint8_t* fill_v;
 151
 152     int qmat_luma[16][64];
 153     int qmat_chroma[16][64];
 154 } ProresContext;
 155
 156 static void encode_codeword(PutBitContext *pb, int val, int codebook)
 157 {
 158     unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros,
 159             mask;
 160
 161     /* number of bits to switch between rice and exp golomb */
 162     switch_bits = codebook & 3;
 163     rice_order  = codebook >> 5;
 164     exp_order   = (codebook >> 2) & 7;
 165
 166     first_exp = ((switch_bits + 1) << rice_order);
 167
 168     if (val >= first_exp) { /* exp golomb */
 169         val -= first_exp;
 170         val += (1 << exp_order);
 171         exp = av_log2(val);
 172         zeros = exp - exp_order + switch_bits + 1;
 173         put_bits(pb, zeros, 0);
 174         put_bits(pb, exp + 1, val);
 175     } else if (rice_order) {
 176         mask = (1 << rice_order) - 1;
 177         put_bits(pb, (val >> rice_order), 0);
 178         put_bits(pb, 1, 1);
 179         put_bits(pb, rice_order, val & mask);
 180     } else {
 181         put_bits(pb, val, 0);
 182         put_bits(pb, 1, 1);
 183     }
 184 }
 185
 186 #define QSCALE(qmat,ind,val) ((val) / (qmat[ind]))
 187 #define TO_GOLOMB(val) ((val << 1) ^ (val >> 31))
 188 #define DIFF_SIGN(val, sign) ((val >> 31) ^ sign)
 189 #define IS_NEGATIVE(val) (((val >> 31) ^ -1) + 1)
 190 #define TO_GOLOMB2(val,sign) (val==0 ? 0 : (val << 1) + sign)
 191
 192 static av_always_inline int get_level(int val)
 193 {
 194     int sign = (val >> 31);
 195     return (val ^ sign) - sign;
 196 }
 197
 198 #define FIRST_DC_CB 0xB8
 199
 200 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
 201
 202 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
 203         int blocks_per_slice, int *qmat)
 204 {
 205     int prev_dc, code;
 206     int i, sign, idx;
 207     int new_dc, delta, diff_sign, new_code;
 208
 209     prev_dc = QSCALE(qmat, 0, in[0] - 16384);
 210     code = TO_GOLOMB(prev_dc);
 211     encode_codeword(pb, code, FIRST_DC_CB);
 212
 213     code = 5; sign = 0; idx = 64;
 214     for (i = 1; i < blocks_per_slice; i++, idx += 64) {
 215         new_dc    = QSCALE(qmat, 0, in[idx] - 16384);
 216         delta     = new_dc - prev_dc;
 217         diff_sign = DIFF_SIGN(delta, sign);
 218         new_code  = TO_GOLOMB2(get_level(delta), diff_sign);
 219
 220         encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
 221
 222         code      = new_code;
 223         sign      = delta >> 31;
 224         prev_dc   = new_dc;
 225     }
 226 }
 227
 228 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29,
 229         0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
 230 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28,
 231         0x28, 0x28, 0x28, 0x4C };
 232
 233 static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb,
 234         int16_t *in, int blocks_per_slice, int *qmat)
 235 {
 236     int prev_run = 4;
 237     int prev_level = 2;
 238
 239     int run = 0, level, code, i, j;
 240     for (i = 1; i < 64; i++) {
 241         int indp = progressive_scan[i];
 242         for (j = 0; j < blocks_per_slice; j++) {
 243             int val = QSCALE(qmat, indp, in[(j << 6) + indp]);
 244             if (val) {
 245                 encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
 246
 247                 prev_run   = run;
 248                 run        = 0;
 249                 level      = get_level(val);
 250                 code       = level - 1;
 251
 252                 encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
 253
 254                 prev_level = level;
 255
 256                 put_bits(pb, 1, IS_NEGATIVE(val));
 257             } else {
 258                 ++run;
 259             }
 260         }
 261     }
 262 }
 263
 264 static void get(uint8_t *pixels, int stride, int16_t* block)
 265 {
 266     int16_t *p = (int16_t*)pixels;
 267     int i, j;
 268
 269     stride >>= 1;
 270     for (i = 0; i < 8; i++) {
 271         for (j = 0; j < 8; j++) {
 272             block[j] = p[j];
 273         }
 274         p += stride;
 275         block += 8;
 276     }
 277 }
 278
 279 static void fdct_get(uint8_t *pixels, int stride, int16_t* block)
 280 {
 281     get(pixels, stride, block);
 282     ff_jpeg_fdct_islow_10(block);
 283 }
 284
 285 static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
 286         uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
 287         int *qmat, int chroma)
 288 {
 289     DECLARE_ALIGNED(16, int16_t, blocks)[DEFAULT_SLICE_MB_WIDTH << 8], *block;
 290     int i, blocks_per_slice;
 291     PutBitContext pb;
 292
 293     block = blocks;
 294     for (i = 0; i < mb_count; i++) {
 295         fdct_get(src,                  src_stride, block + (0 << 6));
 296         fdct_get(src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
 297         if (!chroma) {
 298             fdct_get(src + 16,                  src_stride, block + (1 << 6));
 299             fdct_get(src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
 300         }
 301
 302         block += (256 >> chroma);
 303         src   += (32  >> chroma);
 304     }
 305
 306     blocks_per_slice = mb_count << (2 - chroma);
 307     init_put_bits(&pb, buf, buf_size << 3);
 308
 309     encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
 310     encode_ac_coeffs(avctx, &pb, blocks, blocks_per_slice, qmat);
 311
 312     flush_put_bits(&pb);
 313     return put_bits_ptr(&pb) - pb.buf;
 314 }
 315
 316 static av_always_inline unsigned encode_slice_data(AVCodecContext *avctx,
 317         uint8_t *dest_y, uint8_t *dest_u, uint8_t *dest_v, int luma_stride,
 318         int chroma_stride, unsigned mb_count, uint8_t *buf, unsigned data_size,
 319         unsigned* y_data_size, unsigned* u_data_size, unsigned* v_data_size,
 320         int qp)
 321 {
 322     ProresContext* ctx = avctx->priv_data;
 323
 324     *y_data_size = encode_slice_plane(avctx, mb_count, dest_y, luma_stride,
 325             buf, data_size, ctx->qmat_luma[qp - 1], 0);
 326
 327     if (!(avctx->flags & CODEC_FLAG_GRAY)) {
 328         *u_data_size = encode_slice_plane(avctx, mb_count, dest_u,
 329                 chroma_stride, buf + *y_data_size, data_size - *y_data_size,
 330                 ctx->qmat_chroma[qp - 1], 1);
 331
 332         *v_data_size = encode_slice_plane(avctx, mb_count, dest_v,
 333                 chroma_stride, buf + *y_data_size + *u_data_size,
 334                 data_size - *y_data_size - *u_data_size,
 335                 ctx->qmat_chroma[qp - 1], 1);
 336     }
 337
 338     return *y_data_size + *u_data_size + *v_data_size;
 339 }
 340
 341 static void subimage_with_fill(uint16_t *src, unsigned x, unsigned y,
 342         unsigned stride, unsigned width, unsigned height, uint16_t *dst,
 343         unsigned dst_width, unsigned dst_height)
 344 {
 345
 346     int box_width = FFMIN(width - x, dst_width);
 347     int box_height = FFMIN(height - y, dst_height);
 348     int i, j, src_stride = stride >> 1;
 349     uint16_t last_pix, *last_line;
 350
 351     src += y * src_stride + x;
 352     for (i = 0; i < box_height; ++i) {
 353         for (j = 0; j < box_width; ++j) {
 354             dst[j] = src[j];
 355         }
 356         last_pix = dst[j - 1];
 357         for (; j < dst_width; j++)
 358             dst[j] = last_pix;
 359         src += src_stride;
 360         dst += dst_width;
 361     }
 362     last_line = dst - dst_width;
 363     for (; i < dst_height; i++) {
 364         for (j = 0; j < dst_width; ++j) {
 365             dst[j] = last_line[j];
 366         }
 367         dst += dst_width;
 368     }
 369 }
 370
 371 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, int mb_x,
 372         int mb_y, unsigned mb_count, uint8_t *buf, unsigned data_size,
 373         int unsafe, int *qp)
 374 {
 375     int luma_stride, chroma_stride;
 376     int hdr_size = 6, slice_size;
 377     uint8_t *dest_y, *dest_u, *dest_v;
 378     unsigned y_data_size = 0, u_data_size = 0, v_data_size = 0;
 379     ProresContext* ctx = avctx->priv_data;
 380     int tgt_bits   = (mb_count * bitrate_table[avctx->profile]) >> 2;
 381     int low_bytes  = (tgt_bits - (tgt_bits >> 3)) >> 3; // 12% bitrate fluctuation
 382     int high_bytes = (tgt_bits + (tgt_bits >> 3)) >> 3;
 383
 384     luma_stride   = pic->linesize[0];
 385     chroma_stride = pic->linesize[1];
 386
 387     dest_y = pic->data[0] + (mb_y << 4) * luma_stride   + (mb_x << 5);
 388     dest_u = pic->data[1] + (mb_y << 4) * chroma_stride + (mb_x << 4);
 389     dest_v = pic->data[2] + (mb_y << 4) * chroma_stride + (mb_x << 4);
 390
 391     if (unsafe) {
 392
 393         subimage_with_fill((uint16_t *) pic->data[0], mb_x << 4, mb_y << 4,
 394                 luma_stride, avctx->width, avctx->height,
 395                 (uint16_t *) ctx->fill_y, mb_count << 4, 16);
 396         subimage_with_fill((uint16_t *) pic->data[1], mb_x << 3, mb_y << 4,
 397                 chroma_stride, avctx->width >> 1, avctx->height,
 398                 (uint16_t *) ctx->fill_u, mb_count << 3, 16);
 399         subimage_with_fill((uint16_t *) pic->data[2], mb_x << 3, mb_y << 4,
 400                 chroma_stride, avctx->width >> 1, avctx->height,
 401                 (uint16_t *) ctx->fill_v, mb_count << 3, 16);
 402
 403         encode_slice_data(avctx, ctx->fill_y, ctx->fill_u, ctx->fill_v,
 404                 mb_count << 5, mb_count << 4, mb_count, buf + hdr_size,
 405                 data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
 406                 *qp);
 407     } else {
 408         slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
 409                 luma_stride, chroma_stride, mb_count, buf + hdr_size,
 410                 data_size - hdr_size, &y_data_size, &u_data_size, &v_data_size,
 411                 *qp);
 412
 413         if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
 414             do {
 415                 *qp += 1;
 416                 slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
 417                         luma_stride, chroma_stride, mb_count, buf + hdr_size,
 418                         data_size - hdr_size, &y_data_size, &u_data_size,
 419                         &v_data_size, *qp);
 420             } while (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]);
 421         } else if (slice_size < low_bytes && *qp
 422                 > qp_start_table[avctx->profile]) {
 423             do {
 424                 *qp -= 1;
 425                 slice_size = encode_slice_data(avctx, dest_y, dest_u, dest_v,
 426                         luma_stride, chroma_stride, mb_count, buf + hdr_size,
 427                         data_size - hdr_size, &y_data_size, &u_data_size,
 428                         &v_data_size, *qp);
 429             } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
 430         }
 431     }
 432
 433     buf[0] = hdr_size << 3;
 434     buf[1] = *qp;
 435     AV_WB16(buf + 2, y_data_size);
 436     AV_WB16(buf + 4, u_data_size);
 437
 438     return hdr_size + y_data_size + u_data_size + v_data_size;
 439 }
 440
 441 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
 442         uint8_t *buf, const int buf_size)
 443 {
 444     int mb_width = (avctx->width + 15) >> 4;
 445     int mb_height = (avctx->height + 15) >> 4;
 446     int hdr_size, sl_size, i;
 447     int mb_y, sl_data_size, qp;
 448     int unsafe_bot, unsafe_right;
 449     uint8_t *sl_data, *sl_data_sizes;
 450     int slice_per_line = 0, rem = mb_width;
 451
 452     for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
 453         slice_per_line += rem >> i;
 454         rem &= (1 << i) - 1;
 455     }
 456
 457     qp = qp_start_table[avctx->profile];
 458     hdr_size = 8; sl_data_size = buf_size - hdr_size;
 459     sl_data_sizes = buf + hdr_size;
 460     sl_data = sl_data_sizes + (slice_per_line * mb_height * 2);
 461     for (mb_y = 0; mb_y < mb_height; mb_y++) {
 462         int mb_x = 0;
 463         int slice_mb_count = DEFAULT_SLICE_MB_WIDTH;
 464         while (mb_x < mb_width) {
 465             while (mb_width - mb_x < slice_mb_count)
 466                 slice_mb_count >>= 1;
 467
 468             unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
 469             unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
 470
 471             sl_size = encode_slice(avctx, pic, mb_x, mb_y, slice_mb_count,
 472                     sl_data, sl_data_size, unsafe_bot || unsafe_right, &qp);
 473
 474             bytestream_put_be16(&sl_data_sizes, sl_size);
 475             sl_data           += sl_size;
 476             sl_data_size      -= sl_size;
 477             mb_x              += slice_mb_count;
 478         }
 479     }
 480
 481     buf[0] = hdr_size << 3;
 482     AV_WB32(buf + 1, sl_data - buf);
 483     AV_WB16(buf + 5, slice_per_line * mb_height);
 484     buf[7] = av_log2(DEFAULT_SLICE_MB_WIDTH) << 4;
 485
 486     return sl_data - buf;
 487 }
 488
 489 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 490                                const AVFrame *pict, int *got_packet)
 491 {
 492     int header_size = 148;
 493     uint8_t *buf;
 494     int pic_size, ret;
 495     int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + FF_MIN_BUFFER_SIZE; //FIXME choose tighter limit
 496
 497
 498     if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + FF_MIN_BUFFER_SIZE)) < 0)
 499         return ret;
 500
 501     buf = pkt->data;
 502     pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
 503             pkt->size - header_size - 8);
 504
 505     bytestream_put_be32(&buf, pic_size + 8 + header_size);
 506     bytestream_put_buffer(&buf, "icpf", 4);
 507
 508     bytestream_put_be16(&buf, header_size);
 509     bytestream_put_be16(&buf, 0);
 510     bytestream_put_buffer(&buf, "fmpg", 4);
 511     bytestream_put_be16(&buf, avctx->width);
 512     bytestream_put_be16(&buf, avctx->height);
 513     *buf++ = 0x83; // {10}(422){00}{00}(frame){11}
 514     *buf++ = 0;
 515     *buf++ = 2;
 516     *buf++ = 2;
 517     *buf++ = 6;
 518     *buf++ = 32;
 519     *buf++ = 0;
 520     *buf++ = 3;
 521
 522     bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile],   64);
 523     bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
 524
 525     pkt->flags |= AV_PKT_FLAG_KEY;
 526     pkt->size = pic_size + 8 + header_size;
 527     *got_packet = 1;
 528
 529     return 0;
 530 }
 531
 532 static void scale_mat(const uint8_t* src, int* dst, int scale)
 533 {
 534     int i;
 535     for (i = 0; i < 64; i++)
 536         dst[i] = src[i] * scale;
 537 }
 538
 539 static av_cold int prores_encode_init(AVCodecContext *avctx)
 540 {
 541     int i;
 542     ProresContext* ctx = avctx->priv_data;
 543
 544     if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
 545         av_log(avctx, AV_LOG_ERROR, "need YUV422P10\n");
 546         return -1;
 547     }
 548     if (avctx->width & 0x1) {
 549         av_log(avctx, AV_LOG_ERROR,
 550                 "frame width needs to be multiple of 2\n");
 551         return -1;
 552     }
 553
 554     if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
 555         ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
 556         if (!ctx->fill_y)
 557             return AVERROR(ENOMEM);
 558         ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
 559         ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
 560     }
 561
 562     if (avctx->profile == FF_PROFILE_UNKNOWN) {
 563         avctx->profile = FF_PROFILE_PRORES_STANDARD;
 564         av_log(avctx, AV_LOG_INFO,
 565                 "encoding with ProRes standard (apcn) profile\n");
 566
 567     } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
 568             || avctx->profile > FF_PROFILE_PRORES_HQ) {
 569         av_log(
 570                 avctx,
 571                 AV_LOG_ERROR,
 572                 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
 573                 avctx->profile);
 574         return -1;
 575     }
 576
 577     avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
 578
 579     for (i = 1; i <= 16; i++) {
 580         scale_mat(QMAT_LUMA[avctx->profile]  , ctx->qmat_luma[i - 1]  , i);
 581         scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
 582     }
 583
 584     avctx->coded_frame = av_frame_alloc();
 585     avctx->coded_frame->key_frame = 1;
 586     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 587
 588     return 0;
 589 }
 590
 591 static av_cold int prores_encode_close(AVCodecContext *avctx)
 592 {
 593     ProresContext* ctx = avctx->priv_data;
 594     av_freep(&avctx->coded_frame);
 595     av_freep(&ctx->fill_y);
 596
 597     return 0;
 598 }
 599
 600 AVCodec ff_prores_aw_encoder = {
 601     .name           = "prores_aw",
 602     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
 603     .type           = AVMEDIA_TYPE_VIDEO,
 604     .id             = AV_CODEC_ID_PRORES,
 605     .priv_data_size = sizeof(ProresContext),
 606     .init           = prores_encode_init,
 607     .close          = prores_encode_close,
 608     .encode2        = prores_encode_frame,
 609     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
 610     .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 611     .profiles       = profiles
 612 };
 613
 614 AVCodec ff_prores_encoder = {
 615     .name           = "prores",
 616     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
 617     .type           = AVMEDIA_TYPE_VIDEO,
 618     .id             = AV_CODEC_ID_PRORES,
 619     .priv_data_size = sizeof(ProresContext),
 620     .init           = prores_encode_init,
 621     .close          = prores_encode_close,
 622     .encode2        = prores_encode_frame,
 623     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
 624     .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 625     .profiles       = profiles
 626 };