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 "fdctdsp.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     FDCTDSPContext fdsp;
 149     uint8_t* fill_y;
 150     uint8_t* fill_u;
 151     uint8_t* fill_v;
 152
 153     int qmat_luma[16][64];
 154     int qmat_chroma[16][64];
 155 } ProresContext;
 156
 157 static void encode_codeword(PutBitContext *pb, int val, int codebook)
 158 {
 159     unsigned int rice_order, exp_order, switch_bits, first_exp, exp, zeros;
 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         put_bits(pb, (val >> rice_order), 0);
 177         put_bits(pb, 1, 1);
 178         put_sbits(pb, rice_order, val);
 179     } else {
 180         put_bits(pb, val, 0);
 181         put_bits(pb, 1, 1);
 182     }
 183 }
 184
 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))
 190
 191 static av_always_inline int get_level(int val)
 192 {
 193     int sign = (val >> 31);
 194     return (val ^ sign) - sign;
 195 }
 196
 197 #define FIRST_DC_CB 0xB8
 198
 199 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
 200
 201 static void encode_dc_coeffs(PutBitContext *pb, int16_t *in,
 202         int blocks_per_slice, int *qmat)
 203 {
 204     int prev_dc, code;
 205     int i, sign, idx;
 206     int new_dc, delta, diff_sign, new_code;
 207
 208     prev_dc = QSCALE(qmat, 0, in[0] - 16384);
 209     code = TO_GOLOMB(prev_dc);
 210     encode_codeword(pb, code, FIRST_DC_CB);
 211
 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);
 218
 219         encode_codeword(pb, new_code, dc_codebook[FFMIN(code, 6)]);
 220
 221         code      = new_code;
 222         sign      = delta >> 31;
 223         prev_dc   = new_dc;
 224     }
 225 }
 226
 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 };
 231
 232 static void encode_ac_coeffs(AVCodecContext *avctx, PutBitContext *pb,
 233         int16_t *in, int blocks_per_slice, int *qmat)
 234 {
 235     int prev_run = 4;
 236     int prev_level = 2;
 237
 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]);
 243             if (val) {
 244                 encode_codeword(pb, run, run_to_cb[FFMIN(prev_run, 15)]);
 245
 246                 prev_run   = run;
 247                 run        = 0;
 248                 level      = get_level(val);
 249                 code       = level - 1;
 250
 251                 encode_codeword(pb, code, lev_to_cb[FFMIN(prev_level, 9)]);
 252
 253                 prev_level = level;
 254
 255                 put_bits(pb, 1, IS_NEGATIVE(val));
 256             } else {
 257                 ++run;
 258             }
 259         }
 260     }
 261 }
 262
 263 static void get(uint8_t *pixels, int stride, int16_t* block)
 264 {
 265     int i;
 266
 267     for (i = 0; i < 8; i++) {
 268         AV_WN64(block, AV_RN64(pixels));
 269         AV_WN64(block+4, AV_RN64(pixels+8));
 270         pixels += stride;
 271         block += 8;
 272     }
 273 }
 274
 275 static void fdct_get(FDCTDSPContext *fdsp, uint8_t *pixels, int stride, int16_t* block)
 276 {
 277     get(pixels, stride, block);
 278     fdsp->fdct(block);
 279 }
 280
 281 static int encode_slice_plane(AVCodecContext *avctx, int mb_count,
 282         uint8_t *src, int src_stride, uint8_t *buf, unsigned buf_size,
 283         int *qmat, int chroma)
 284 {
 285     ProresContext* ctx = avctx->priv_data;
 286     FDCTDSPContext *fdsp = &ctx->fdsp;
 287     LOCAL_ALIGNED(16, int16_t, blocks, [DEFAULT_SLICE_MB_WIDTH << 8]);
 288     int16_t *block;
 289     int i, blocks_per_slice;
 290     PutBitContext pb;
 291
 292     block = blocks;
 293     for (i = 0; i < mb_count; i++) {
 294         fdct_get(fdsp, src,                  src_stride, block + (0 << 6));
 295         fdct_get(fdsp, src + 8 * src_stride, src_stride, block + ((2 - chroma) << 6));
 296         if (!chroma) {
 297             fdct_get(fdsp, src + 16,                  src_stride, block + (1 << 6));
 298             fdct_get(fdsp, src + 16 + 8 * src_stride, src_stride, block + (3 << 6));
 299         }
 300
 301         block += (256 >> chroma);
 302         src   += (32  >> chroma);
 303     }
 304
 305     blocks_per_slice = mb_count << (2 - chroma);
 306     init_put_bits(&pb, buf, buf_size);
 307
 308     encode_dc_coeffs(&pb, blocks, blocks_per_slice, qmat);
 309     encode_ac_coeffs(avctx, &pb, blocks, blocks_per_slice, qmat);
 310
 311     flush_put_bits(&pb);
 312     return put_bits_ptr(&pb) - pb.buf;
 313 }
 314
 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,
 319         int qp)
 320 {
 321     ProresContext* ctx = avctx->priv_data;
 322
 323     *y_data_size = encode_slice_plane(avctx, mb_count, dest_y, luma_stride,
 324             buf, data_size, ctx->qmat_luma[qp - 1], 0);
 325
 326     if (!(avctx->flags & AV_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);
 330
 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);
 335     }
 336
 337     return *y_data_size + *u_data_size + *v_data_size;
 338 }
 339
 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)
 343 {
 344
 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;
 349
 350     src += y * src_stride + x;
 351     for (i = 0; i < box_height; ++i) {
 352         for (j = 0; j < box_width; ++j) {
 353             dst[j] = src[j];
 354         }
 355         last_pix = dst[j - 1];
 356         for (; j < dst_width; j++)
 357             dst[j] = last_pix;
 358         src += src_stride;
 359         dst += dst_width;
 360     }
 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];
 365         }
 366         dst += dst_width;
 367     }
 368 }
 369
 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,
 372         int unsafe, int *qp)
 373 {
 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;
 382
 383     luma_stride   = pic->linesize[0];
 384     chroma_stride = pic->linesize[1];
 385
 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);
 389
 390     if (unsafe) {
 391
 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);
 401
 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,
 405                 *qp);
 406     } else {
 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,
 410                 *qp);
 411
 412         if (slice_size > high_bytes && *qp < qp_end_table[avctx->profile]) {
 413             do {
 414                 *qp += 1;
 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,
 418                         &v_data_size, *qp);
 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]) {
 422             do {
 423                 *qp -= 1;
 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,
 427                         &v_data_size, *qp);
 428             } while (slice_size < low_bytes && *qp > qp_start_table[avctx->profile]);
 429         }
 430     }
 431
 432     buf[0] = hdr_size << 3;
 433     buf[1] = *qp;
 434     AV_WB16(buf + 2, y_data_size);
 435     AV_WB16(buf + 4, u_data_size);
 436
 437     return hdr_size + y_data_size + u_data_size + v_data_size;
 438 }
 439
 440 static int prores_encode_picture(AVCodecContext *avctx, const AVFrame *pic,
 441         uint8_t *buf, const int buf_size)
 442 {
 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;
 450
 451     for (i = av_log2(DEFAULT_SLICE_MB_WIDTH); i >= 0; --i) {
 452         slice_per_line += rem >> i;
 453         rem &= (1 << i) - 1;
 454     }
 455
 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++) {
 461         int mb_x = 0;
 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;
 466
 467             unsafe_bot = (avctx->height & 0xf) && (mb_y == mb_height - 1);
 468             unsafe_right = (avctx->width & 0xf) && (mb_x + slice_mb_count == mb_width);
 469
 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);
 472
 473             bytestream_put_be16(&sl_data_sizes, sl_size);
 474             sl_data           += sl_size;
 475             sl_data_size      -= sl_size;
 476             mb_x              += slice_mb_count;
 477         }
 478     }
 479
 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;
 484
 485     return sl_data - buf;
 486 }
 487
 488 static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 489                                const AVFrame *pict, int *got_packet)
 490 {
 491     int header_size = 148;
 492     uint8_t *buf;
 493     int pic_size, ret;
 494     int frame_size = FFALIGN(avctx->width, 16) * FFALIGN(avctx->height, 16)*16 + 500 + AV_INPUT_BUFFER_MIN_SIZE; //FIXME choose tighter limit
 495
 496
 497     if ((ret = ff_alloc_packet2(avctx, pkt, frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
 498         return ret;
 499
 500     buf = pkt->data;
 501     pic_size = prores_encode_picture(avctx, pict, buf + header_size + 8,
 502             pkt->size - header_size - 8);
 503
 504     bytestream_put_be32(&buf, pic_size + 8 + header_size);
 505     bytestream_put_buffer(&buf, "icpf", 4);
 506
 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}
 513     *buf++ = 0;
 514     *buf++ = 2;
 515     *buf++ = 2;
 516     *buf++ = 6;
 517     *buf++ = 32;
 518     *buf++ = 0;
 519     *buf++ = 3;
 520
 521     bytestream_put_buffer(&buf, QMAT_LUMA[avctx->profile],   64);
 522     bytestream_put_buffer(&buf, QMAT_CHROMA[avctx->profile], 64);
 523
 524     pkt->flags |= AV_PKT_FLAG_KEY;
 525     pkt->size = pic_size + 8 + header_size;
 526     *got_packet = 1;
 527
 528     return 0;
 529 }
 530
 531 static void scale_mat(const uint8_t* src, int* dst, int scale)
 532 {
 533     int i;
 534     for (i = 0; i < 64; i++)
 535         dst[i] = src[i] * scale;
 536 }
 537
 538 static av_cold int prores_encode_init(AVCodecContext *avctx)
 539 {
 540     int i;
 541     ProresContext* ctx = avctx->priv_data;
 542
 543     if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
 544         av_log(avctx, AV_LOG_ERROR, "need YUV422P10\n");
 545         return AVERROR_PATCHWELCOME;
 546     }
 547     avctx->bits_per_raw_sample = 10;
 548
 549     if (avctx->width & 0x1) {
 550         av_log(avctx, AV_LOG_ERROR,
 551                 "frame width needs to be multiple of 2\n");
 552         return AVERROR(EINVAL);
 553     }
 554
 555     if (avctx->width > 65534 || avctx->height > 65535) {
 556         av_log(avctx, AV_LOG_ERROR,
 557                 "The maximum dimensions are 65534x65535\n");
 558         return AVERROR(EINVAL);
 559     }
 560
 561     if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
 562         ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
 563         if (!ctx->fill_y)
 564             return AVERROR(ENOMEM);
 565         ctx->fill_u = ctx->fill_y + (DEFAULT_SLICE_MB_WIDTH << 9);
 566         ctx->fill_v = ctx->fill_u + (DEFAULT_SLICE_MB_WIDTH << 8);
 567     }
 568
 569     if (avctx->profile == FF_PROFILE_UNKNOWN) {
 570         avctx->profile = FF_PROFILE_PRORES_STANDARD;
 571         av_log(avctx, AV_LOG_INFO,
 572                 "encoding with ProRes standard (apcn) profile\n");
 573
 574     } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
 575             || avctx->profile > FF_PROFILE_PRORES_HQ) {
 576         av_log(
 577                 avctx,
 578                 AV_LOG_ERROR,
 579                 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch]\n",
 580                 avctx->profile);
 581         return AVERROR(EINVAL);
 582     }
 583
 584     ff_fdctdsp_init(&ctx->fdsp, avctx);
 585
 586     avctx->codec_tag = AV_RL32((const uint8_t*)profiles[avctx->profile].name);
 587
 588     for (i = 1; i <= 16; i++) {
 589         scale_mat(QMAT_LUMA[avctx->profile]  , ctx->qmat_luma[i - 1]  , i);
 590         scale_mat(QMAT_CHROMA[avctx->profile], ctx->qmat_chroma[i - 1], i);
 591     }
 592
 593     return 0;
 594 }
 595
 596 static av_cold int prores_encode_close(AVCodecContext *avctx)
 597 {
 598     ProresContext* ctx = avctx->priv_data;
 599     av_freep(&ctx->fill_y);
 600
 601     return 0;
 602 }
 603
 604 AVCodec ff_prores_aw_encoder = {
 605     .name           = "prores_aw",
 606     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
 607     .type           = AVMEDIA_TYPE_VIDEO,
 608     .id             = AV_CODEC_ID_PRORES,
 609     .priv_data_size = sizeof(ProresContext),
 610     .init           = prores_encode_init,
 611     .close          = prores_encode_close,
 612     .encode2        = prores_encode_frame,
 613     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
 614     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
 615     .profiles       = profiles
 616 };
 617
 618 AVCodec ff_prores_encoder = {
 619     .name           = "prores",
 620     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),
 621     .type           = AVMEDIA_TYPE_VIDEO,
 622     .id             = AV_CODEC_ID_PRORES,
 623     .priv_data_size = sizeof(ProresContext),
 624     .init           = prores_encode_init,
 625     .close          = prores_encode_close,
 626     .encode2        = prores_encode_frame,
 627     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
 628     .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
 629     .profiles       = profiles
 630 };