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

   1 /*
   2  * Apple ProRes encoder
   3  *
   4  * Copyright (c) 2012 Konstantin Shishkov
   5  *
   6  * This encoder appears to be based on Anatoliy Wassermans considering
   7  * similarities in the bugs.
   8  *
   9  * This file is part of FFmpeg.
  10  *
  11  * FFmpeg is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * FFmpeg is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with FFmpeg; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  */
  25
  26 #include "libavutil/opt.h"
  27 #include "libavutil/pixdesc.h"
  28 #include "avcodec.h"
  29 #include "fdctdsp.h"
  30 #include "put_bits.h"
  31 #include "bytestream.h"
  32 #include "internal.h"
  33 #include "proresdata.h"
  34
  35 #define CFACTOR_Y422 2
  36 #define CFACTOR_Y444 3
  37
  38 #define MAX_MBS_PER_SLICE 8
  39
  40 #define MAX_PLANES 4
  41
  42 enum {
  43     PRORES_PROFILE_AUTO  = -1,
  44     PRORES_PROFILE_PROXY = 0,
  45     PRORES_PROFILE_LT,
  46     PRORES_PROFILE_STANDARD,
  47     PRORES_PROFILE_HQ,
  48     PRORES_PROFILE_4444,
  49 };
  50
  51 enum {
  52     QUANT_MAT_PROXY = 0,
  53     QUANT_MAT_LT,
  54     QUANT_MAT_STANDARD,
  55     QUANT_MAT_HQ,
  56     QUANT_MAT_DEFAULT,
  57 };
  58
  59 static const uint8_t prores_quant_matrices[][64] = {
  60     { // proxy
  61          4,  7,  9, 11, 13, 14, 15, 63,
  62          7,  7, 11, 12, 14, 15, 63, 63,
  63          9, 11, 13, 14, 15, 63, 63, 63,
  64         11, 11, 13, 14, 63, 63, 63, 63,
  65         11, 13, 14, 63, 63, 63, 63, 63,
  66         13, 14, 63, 63, 63, 63, 63, 63,
  67         13, 63, 63, 63, 63, 63, 63, 63,
  68         63, 63, 63, 63, 63, 63, 63, 63,
  69     },
  70     { // LT
  71          4,  5,  6,  7,  9, 11, 13, 15,
  72          5,  5,  7,  8, 11, 13, 15, 17,
  73          6,  7,  9, 11, 13, 15, 15, 17,
  74          7,  7,  9, 11, 13, 15, 17, 19,
  75          7,  9, 11, 13, 14, 16, 19, 23,
  76          9, 11, 13, 14, 16, 19, 23, 29,
  77          9, 11, 13, 15, 17, 21, 28, 35,
  78         11, 13, 16, 17, 21, 28, 35, 41,
  79     },
  80     { // standard
  81          4,  4,  5,  5,  6,  7,  7,  9,
  82          4,  4,  5,  6,  7,  7,  9,  9,
  83          5,  5,  6,  7,  7,  9,  9, 10,
  84          5,  5,  6,  7,  7,  9,  9, 10,
  85          5,  6,  7,  7,  8,  9, 10, 12,
  86          6,  7,  7,  8,  9, 10, 12, 15,
  87          6,  7,  7,  9, 10, 11, 14, 17,
  88          7,  7,  9, 10, 11, 14, 17, 21,
  89     },
  90     { // high quality
  91          4,  4,  4,  4,  4,  4,  4,  4,
  92          4,  4,  4,  4,  4,  4,  4,  4,
  93          4,  4,  4,  4,  4,  4,  4,  4,
  94          4,  4,  4,  4,  4,  4,  4,  5,
  95          4,  4,  4,  4,  4,  4,  5,  5,
  96          4,  4,  4,  4,  4,  5,  5,  6,
  97          4,  4,  4,  4,  5,  5,  6,  7,
  98          4,  4,  4,  4,  5,  6,  7,  7,
  99     },
 100     { // codec default
 101          4,  4,  4,  4,  4,  4,  4,  4,
 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,  4,
 106          4,  4,  4,  4,  4,  4,  4,  4,
 107          4,  4,  4,  4,  4,  4,  4,  4,
 108          4,  4,  4,  4,  4,  4,  4,  4,
 109     },
 110 };
 111
 112 #define NUM_MB_LIMITS 4
 113 static const int prores_mb_limits[NUM_MB_LIMITS] = {
 114     1620, // up to 720x576
 115     2700, // up to 960x720
 116     6075, // up to 1440x1080
 117     9216, // up to 2048x1152
 118 };
 119
 120 static const struct prores_profile {
 121     const char *full_name;
 122     uint32_t    tag;
 123     int         min_quant;
 124     int         max_quant;
 125     int         br_tab[NUM_MB_LIMITS];
 126     int         quant;
 127 } prores_profile_info[5] = {
 128     {
 129         .full_name = "proxy",
 130         .tag       = MKTAG('a', 'p', 'c', 'o'),
 131         .min_quant = 4,
 132         .max_quant = 8,
 133         .br_tab    = { 300, 242, 220, 194 },
 134         .quant     = QUANT_MAT_PROXY,
 135     },
 136     {
 137         .full_name = "LT",
 138         .tag       = MKTAG('a', 'p', 'c', 's'),
 139         .min_quant = 1,
 140         .max_quant = 9,
 141         .br_tab    = { 720, 560, 490, 440 },
 142         .quant     = QUANT_MAT_LT,
 143     },
 144     {
 145         .full_name = "standard",
 146         .tag       = MKTAG('a', 'p', 'c', 'n'),
 147         .min_quant = 1,
 148         .max_quant = 6,
 149         .br_tab    = { 1050, 808, 710, 632 },
 150         .quant     = QUANT_MAT_STANDARD,
 151     },
 152     {
 153         .full_name = "high quality",
 154         .tag       = MKTAG('a', 'p', 'c', 'h'),
 155         .min_quant = 1,
 156         .max_quant = 6,
 157         .br_tab    = { 1566, 1216, 1070, 950 },
 158         .quant     = QUANT_MAT_HQ,
 159     },
 160     {
 161         .full_name = "4444",
 162         .tag       = MKTAG('a', 'p', '4', 'h'),
 163         .min_quant = 1,
 164         .max_quant = 6,
 165         .br_tab    = { 2350, 1828, 1600, 1425 },
 166         .quant     = QUANT_MAT_HQ,
 167     }
 168 };
 169
 170 #define TRELLIS_WIDTH 16
 171 #define SCORE_LIMIT   INT_MAX / 2
 172
 173 struct TrellisNode {
 174     int prev_node;
 175     int quant;
 176     int bits;
 177     int score;
 178 };
 179
 180 #define MAX_STORED_Q 16
 181
 182 typedef struct ProresThreadData {
 183     DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 184     DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
 185     int16_t custom_q[64];
 186     struct TrellisNode *nodes;
 187 } ProresThreadData;
 188
 189 typedef struct ProresContext {
 190     AVClass *class;
 191     DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 192     DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
 193     int16_t quants[MAX_STORED_Q][64];
 194     int16_t custom_q[64];
 195     const uint8_t *quant_mat;
 196     const uint8_t *scantable;
 197
 198     void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
 199                  int linesize, int16_t *block);
 200     FDCTDSPContext fdsp;
 201
 202     int mb_width, mb_height;
 203     int mbs_per_slice;
 204     int num_chroma_blocks, chroma_factor;
 205     int slices_width;
 206     int slices_per_picture;
 207     int pictures_per_frame; // 1 for progressive, 2 for interlaced
 208     int cur_picture_idx;
 209     int num_planes;
 210     int bits_per_mb;
 211     int force_quant;
 212     int alpha_bits;
 213     int warn;
 214
 215     char *vendor;
 216     int quant_sel;
 217
 218     int frame_size_upper_bound;
 219
 220     int profile;
 221     const struct prores_profile *profile_info;
 222
 223     int *slice_q;
 224
 225     ProresThreadData *tdata;
 226 } ProresContext;
 227
 228 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
 229                            int linesize, int x, int y, int w, int h,
 230                            int16_t *blocks, uint16_t *emu_buf,
 231                            int mbs_per_slice, int blocks_per_mb, int is_chroma)
 232 {
 233     const uint16_t *esrc;
 234     const int mb_width = 4 * blocks_per_mb;
 235     int elinesize;
 236     int i, j, k;
 237
 238     for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
 239         if (x >= w) {
 240             memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
 241                               * sizeof(*blocks));
 242             return;
 243         }
 244         if (x + mb_width <= w && y + 16 <= h) {
 245             esrc      = src;
 246             elinesize = linesize;
 247         } else {
 248             int bw, bh, pix;
 249
 250             esrc      = emu_buf;
 251             elinesize = 16 * sizeof(*emu_buf);
 252
 253             bw = FFMIN(w - x, mb_width);
 254             bh = FFMIN(h - y, 16);
 255
 256             for (j = 0; j < bh; j++) {
 257                 memcpy(emu_buf + j * 16,
 258                        (const uint8_t*)src + j * linesize,
 259                        bw * sizeof(*src));
 260                 pix = emu_buf[j * 16 + bw - 1];
 261                 for (k = bw; k < mb_width; k++)
 262                     emu_buf[j * 16 + k] = pix;
 263             }
 264             for (; j < 16; j++)
 265                 memcpy(emu_buf + j * 16,
 266                        emu_buf + (bh - 1) * 16,
 267                        mb_width * sizeof(*emu_buf));
 268         }
 269         if (!is_chroma) {
 270             ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
 271             blocks += 64;
 272             if (blocks_per_mb > 2) {
 273                 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
 274                 blocks += 64;
 275             }
 276             ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
 277             blocks += 64;
 278             if (blocks_per_mb > 2) {
 279                 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
 280                 blocks += 64;
 281             }
 282         } else {
 283             ctx->fdct(&ctx->fdsp, esrc, elinesize, blocks);
 284             blocks += 64;
 285             ctx->fdct(&ctx->fdsp, esrc + elinesize * 4, elinesize, blocks);
 286             blocks += 64;
 287             if (blocks_per_mb > 2) {
 288                 ctx->fdct(&ctx->fdsp, esrc + 8, elinesize, blocks);
 289                 blocks += 64;
 290                 ctx->fdct(&ctx->fdsp, esrc + elinesize * 4 + 8, elinesize, blocks);
 291                 blocks += 64;
 292             }
 293         }
 294
 295         x += mb_width;
 296     }
 297 }
 298
 299 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
 300                            int linesize, int x, int y, int w, int h,
 301                            int16_t *blocks, int mbs_per_slice, int abits)
 302 {
 303     const int slice_width = 16 * mbs_per_slice;
 304     int i, j, copy_w, copy_h;
 305
 306     copy_w = FFMIN(w - x, slice_width);
 307     copy_h = FFMIN(h - y, 16);
 308     for (i = 0; i < copy_h; i++) {
 309         memcpy(blocks, src, copy_w * sizeof(*src));
 310         if (abits == 8)
 311             for (j = 0; j < copy_w; j++)
 312                 blocks[j] >>= 2;
 313         else
 314             for (j = 0; j < copy_w; j++)
 315                 blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
 316         for (j = copy_w; j < slice_width; j++)
 317             blocks[j] = blocks[copy_w - 1];
 318         blocks += slice_width;
 319         src    += linesize >> 1;
 320     }
 321     for (; i < 16; i++) {
 322         memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
 323         blocks += slice_width;
 324     }
 325 }
 326
 327 /**
 328  * Write an unsigned rice/exp golomb codeword.
 329  */
 330 static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
 331 {
 332     unsigned int rice_order, exp_order, switch_bits, switch_val;
 333     int exponent;
 334
 335     /* number of prefix bits to switch between Rice and expGolomb */
 336     switch_bits = (codebook & 3) + 1;
 337     rice_order  =  codebook >> 5;       /* rice code order */
 338     exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 339
 340     switch_val  = switch_bits << rice_order;
 341
 342     if (val >= switch_val) {
 343         val -= switch_val - (1 << exp_order);
 344         exponent = av_log2(val);
 345
 346         put_bits(pb, exponent - exp_order + switch_bits, 0);
 347         put_bits(pb, exponent + 1, val);
 348     } else {
 349         exponent = val >> rice_order;
 350
 351         if (exponent)
 352             put_bits(pb, exponent, 0);
 353         put_bits(pb, 1, 1);
 354         if (rice_order)
 355             put_sbits(pb, rice_order, val);
 356     }
 357 }
 358
 359 #define GET_SIGN(x)  ((x) >> 31)
 360 #define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
 361
 362 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
 363                        int blocks_per_slice, int scale)
 364 {
 365     int i;
 366     int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 367
 368     prev_dc = (blocks[0] - 0x4000) / scale;
 369     encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
 370     sign     = 0;
 371     codebook = 3;
 372     blocks  += 64;
 373
 374     for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 375         dc       = (blocks[0] - 0x4000) / scale;
 376         delta    = dc - prev_dc;
 377         new_sign = GET_SIGN(delta);
 378         delta    = (delta ^ sign) - sign;
 379         code     = MAKE_CODE(delta);
 380         encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
 381         codebook = (code + (code & 1)) >> 1;
 382         codebook = FFMIN(codebook, 3);
 383         sign     = new_sign;
 384         prev_dc  = dc;
 385     }
 386 }
 387
 388 static void encode_acs(PutBitContext *pb, int16_t *blocks,
 389                        int blocks_per_slice,
 390                        int plane_size_factor,
 391                        const uint8_t *scan, const int16_t *qmat)
 392 {
 393     int idx, i;
 394     int run, level, run_cb, lev_cb;
 395     int max_coeffs, abs_level;
 396
 397     max_coeffs = blocks_per_slice << 6;
 398     run_cb     = ff_prores_run_to_cb_index[4];
 399     lev_cb     = ff_prores_lev_to_cb_index[2];
 400     run        = 0;
 401
 402     for (i = 1; i < 64; i++) {
 403         for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 404             level = blocks[idx] / qmat[scan[i]];
 405             if (level) {
 406                 abs_level = FFABS(level);
 407                 encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
 408                 encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],
 409                                     abs_level - 1);
 410                 put_sbits(pb, 1, GET_SIGN(level));
 411
 412                 run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 413                 lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 414                 run    = 0;
 415             } else {
 416                 run++;
 417             }
 418         }
 419     }
 420 }
 421
 422 static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
 423                               const uint16_t *src, int linesize,
 424                               int mbs_per_slice, int16_t *blocks,
 425                               int blocks_per_mb, int plane_size_factor,
 426                               const int16_t *qmat)
 427 {
 428     int blocks_per_slice, saved_pos;
 429
 430     saved_pos = put_bits_count(pb);
 431     blocks_per_slice = mbs_per_slice * blocks_per_mb;
 432
 433     encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
 434     encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
 435                ctx->scantable, qmat);
 436     flush_put_bits(pb);
 437
 438     return (put_bits_count(pb) - saved_pos) >> 3;
 439 }
 440
 441 static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
 442 {
 443     const int mask  = (1 << abits) - 1;
 444     const int dbits = (abits == 8) ? 4 : 7;
 445     const int dsize = 1 << dbits - 1;
 446     int diff = cur - prev;
 447
 448     diff &= mask;
 449     if (diff >= (1 << abits) - dsize)
 450         diff -= 1 << abits;
 451     if (diff < -dsize || diff > dsize || !diff) {
 452         put_bits(pb, 1, 1);
 453         put_bits(pb, abits, diff);
 454     } else {
 455         put_bits(pb, 1, 0);
 456         put_bits(pb, dbits - 1, FFABS(diff) - 1);
 457         put_bits(pb, 1, diff < 0);
 458     }
 459 }
 460
 461 static void put_alpha_run(PutBitContext *pb, int run)
 462 {
 463     if (run) {
 464         put_bits(pb, 1, 0);
 465         if (run < 0x10)
 466             put_bits(pb, 4, run);
 467         else
 468             put_bits(pb, 15, run);
 469     } else {
 470         put_bits(pb, 1, 1);
 471     }
 472 }
 473
 474 // todo alpha quantisation for high quants
 475 static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
 476                               int mbs_per_slice, uint16_t *blocks,
 477                               int quant)
 478 {
 479     const int abits = ctx->alpha_bits;
 480     const int mask  = (1 << abits) - 1;
 481     const int num_coeffs = mbs_per_slice * 256;
 482     int saved_pos = put_bits_count(pb);
 483     int prev = mask, cur;
 484     int idx = 0;
 485     int run = 0;
 486
 487     cur = blocks[idx++];
 488     put_alpha_diff(pb, cur, prev, abits);
 489     prev = cur;
 490     do {
 491         cur = blocks[idx++];
 492         if (cur != prev) {
 493             put_alpha_run (pb, run);
 494             put_alpha_diff(pb, cur, prev, abits);
 495             prev = cur;
 496             run  = 0;
 497         } else {
 498             run++;
 499         }
 500     } while (idx < num_coeffs);
 501     if (run)
 502         put_alpha_run(pb, run);
 503     flush_put_bits(pb);
 504     return (put_bits_count(pb) - saved_pos) >> 3;
 505 }
 506
 507 static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
 508                         PutBitContext *pb,
 509                         int sizes[4], int x, int y, int quant,
 510                         int mbs_per_slice)
 511 {
 512     ProresContext *ctx = avctx->priv_data;
 513     int i, xp, yp;
 514     int total_size = 0;
 515     const uint16_t *src;
 516     int slice_width_factor = av_log2(mbs_per_slice);
 517     int num_cblocks, pwidth, linesize, line_add;
 518     int plane_factor, is_chroma;
 519     uint16_t *qmat;
 520
 521     if (ctx->pictures_per_frame == 1)
 522         line_add = 0;
 523     else
 524         line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
 525
 526     if (ctx->force_quant) {
 527         qmat = ctx->quants[0];
 528     } else if (quant < MAX_STORED_Q) {
 529         qmat = ctx->quants[quant];
 530     } else {
 531         qmat = ctx->custom_q;
 532         for (i = 0; i < 64; i++)
 533             qmat[i] = ctx->quant_mat[i] * quant;
 534     }
 535
 536     for (i = 0; i < ctx->num_planes; i++) {
 537         is_chroma    = (i == 1 || i == 2);
 538         plane_factor = slice_width_factor + 2;
 539         if (is_chroma)
 540             plane_factor += ctx->chroma_factor - 3;
 541         if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
 542             xp          = x << 4;
 543             yp          = y << 4;
 544             num_cblocks = 4;
 545             pwidth      = avctx->width;
 546         } else {
 547             xp          = x << 3;
 548             yp          = y << 4;
 549             num_cblocks = 2;
 550             pwidth      = avctx->width >> 1;
 551         }
 552
 553         linesize = pic->linesize[i] * ctx->pictures_per_frame;
 554         src = (const uint16_t*)(pic->data[i] + yp * linesize +
 555                                 line_add * pic->linesize[i]) + xp;
 556
 557         if (i < 3) {
 558             get_slice_data(ctx, src, linesize, xp, yp,
 559                            pwidth, avctx->height / ctx->pictures_per_frame,
 560                            ctx->blocks[0], ctx->emu_buf,
 561                            mbs_per_slice, num_cblocks, is_chroma);
 562             sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
 563                                           mbs_per_slice, ctx->blocks[0],
 564                                           num_cblocks, plane_factor,
 565                                           qmat);
 566         } else {
 567             get_alpha_data(ctx, src, linesize, xp, yp,
 568                            pwidth, avctx->height / ctx->pictures_per_frame,
 569                            ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
 570             sizes[i] = encode_alpha_plane(ctx, pb, mbs_per_slice,
 571                                           ctx->blocks[0], quant);
 572         }
 573         total_size += sizes[i];
 574         if (put_bits_left(pb) < 0) {
 575             av_log(avctx, AV_LOG_ERROR,
 576                    "Underestimated required buffer size.\n");
 577             return AVERROR_BUG;
 578         }
 579     }
 580     return total_size;
 581 }
 582
 583 static inline int estimate_vlc(unsigned codebook, int val)
 584 {
 585     unsigned int rice_order, exp_order, switch_bits, switch_val;
 586     int exponent;
 587
 588     /* number of prefix bits to switch between Rice and expGolomb */
 589     switch_bits = (codebook & 3) + 1;
 590     rice_order  =  codebook >> 5;       /* rice code order */
 591     exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 592
 593     switch_val  = switch_bits << rice_order;
 594
 595     if (val >= switch_val) {
 596         val -= switch_val - (1 << exp_order);
 597         exponent = av_log2(val);
 598
 599         return exponent * 2 - exp_order + switch_bits + 1;
 600     } else {
 601         return (val >> rice_order) + rice_order + 1;
 602     }
 603 }
 604
 605 static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
 606                         int scale)
 607 {
 608     int i;
 609     int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 610     int bits;
 611
 612     prev_dc  = (blocks[0] - 0x4000) / scale;
 613     bits     = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
 614     sign     = 0;
 615     codebook = 3;
 616     blocks  += 64;
 617     *error  += FFABS(blocks[0] - 0x4000) % scale;
 618
 619     for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 620         dc       = (blocks[0] - 0x4000) / scale;
 621         *error  += FFABS(blocks[0] - 0x4000) % scale;
 622         delta    = dc - prev_dc;
 623         new_sign = GET_SIGN(delta);
 624         delta    = (delta ^ sign) - sign;
 625         code     = MAKE_CODE(delta);
 626         bits    += estimate_vlc(ff_prores_dc_codebook[codebook], code);
 627         codebook = (code + (code & 1)) >> 1;
 628         codebook = FFMIN(codebook, 3);
 629         sign     = new_sign;
 630         prev_dc  = dc;
 631     }
 632
 633     return bits;
 634 }
 635
 636 static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
 637                         int plane_size_factor,
 638                         const uint8_t *scan, const int16_t *qmat)
 639 {
 640     int idx, i;
 641     int run, level, run_cb, lev_cb;
 642     int max_coeffs, abs_level;
 643     int bits = 0;
 644
 645     max_coeffs = blocks_per_slice << 6;
 646     run_cb     = ff_prores_run_to_cb_index[4];
 647     lev_cb     = ff_prores_lev_to_cb_index[2];
 648     run        = 0;
 649
 650     for (i = 1; i < 64; i++) {
 651         for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 652             level   = blocks[idx] / qmat[scan[i]];
 653             *error += FFABS(blocks[idx]) % qmat[scan[i]];
 654             if (level) {
 655                 abs_level = FFABS(level);
 656                 bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
 657                 bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
 658                                      abs_level - 1) + 1;
 659
 660                 run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 661                 lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 662                 run    = 0;
 663             } else {
 664                 run++;
 665             }
 666         }
 667     }
 668
 669     return bits;
 670 }
 671
 672 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
 673                                 const uint16_t *src, int linesize,
 674                                 int mbs_per_slice,
 675                                 int blocks_per_mb, int plane_size_factor,
 676                                 const int16_t *qmat, ProresThreadData *td)
 677 {
 678     int blocks_per_slice;
 679     int bits;
 680
 681     blocks_per_slice = mbs_per_slice * blocks_per_mb;
 682
 683     bits  = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
 684     bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
 685                          plane_size_factor, ctx->scantable, qmat);
 686
 687     return FFALIGN(bits, 8);
 688 }
 689
 690 static int est_alpha_diff(int cur, int prev, int abits)
 691 {
 692     const int mask  = (1 << abits) - 1;
 693     const int dbits = (abits == 8) ? 4 : 7;
 694     const int dsize = 1 << dbits - 1;
 695     int diff = cur - prev;
 696
 697     diff &= mask;
 698     if (diff >= (1 << abits) - dsize)
 699         diff -= 1 << abits;
 700     if (diff < -dsize || diff > dsize || !diff)
 701         return abits + 1;
 702     else
 703         return dbits + 1;
 704 }
 705
 706 static int estimate_alpha_plane(ProresContext *ctx, int *error,
 707                                 const uint16_t *src, int linesize,
 708                                 int mbs_per_slice, int quant,
 709                                 int16_t *blocks)
 710 {
 711     const int abits = ctx->alpha_bits;
 712     const int mask  = (1 << abits) - 1;
 713     const int num_coeffs = mbs_per_slice * 256;
 714     int prev = mask, cur;
 715     int idx = 0;
 716     int run = 0;
 717     int bits;
 718
 719     *error = 0;
 720     cur = blocks[idx++];
 721     bits = est_alpha_diff(cur, prev, abits);
 722     prev = cur;
 723     do {
 724         cur = blocks[idx++];
 725         if (cur != prev) {
 726             if (!run)
 727                 bits++;
 728             else if (run < 0x10)
 729                 bits += 4;
 730             else
 731                 bits += 15;
 732             bits += est_alpha_diff(cur, prev, abits);
 733             prev = cur;
 734             run  = 0;
 735         } else {
 736             run++;
 737         }
 738     } while (idx < num_coeffs);
 739
 740     if (run) {
 741         if (run < 0x10)
 742             bits += 4;
 743         else
 744             bits += 15;
 745     }
 746
 747     return bits;
 748 }
 749
 750 static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
 751                             int trellis_node, int x, int y, int mbs_per_slice,
 752                             ProresThreadData *td)
 753 {
 754     ProresContext *ctx = avctx->priv_data;
 755     int i, q, pq, xp, yp;
 756     const uint16_t *src;
 757     int slice_width_factor = av_log2(mbs_per_slice);
 758     int num_cblocks[MAX_PLANES], pwidth;
 759     int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
 760     const int min_quant = ctx->profile_info->min_quant;
 761     const int max_quant = ctx->profile_info->max_quant;
 762     int error, bits, bits_limit;
 763     int mbs, prev, cur, new_score;
 764     int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
 765     int overquant;
 766     uint16_t *qmat;
 767     int linesize[4], line_add;
 768
 769     if (ctx->pictures_per_frame == 1)
 770         line_add = 0;
 771     else
 772         line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
 773     mbs = x + mbs_per_slice;
 774
 775     for (i = 0; i < ctx->num_planes; i++) {
 776         is_chroma[i]    = (i == 1 || i == 2);
 777         plane_factor[i] = slice_width_factor + 2;
 778         if (is_chroma[i])
 779             plane_factor[i] += ctx->chroma_factor - 3;
 780         if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
 781             xp             = x << 4;
 782             yp             = y << 4;
 783             num_cblocks[i] = 4;
 784             pwidth         = avctx->width;
 785         } else {
 786             xp             = x << 3;
 787             yp             = y << 4;
 788             num_cblocks[i] = 2;
 789             pwidth         = avctx->width >> 1;
 790         }
 791
 792         linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;
 793         src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +
 794                                 line_add * pic->linesize[i]) + xp;
 795
 796         if (i < 3) {
 797             get_slice_data(ctx, src, linesize[i], xp, yp,
 798                            pwidth, avctx->height / ctx->pictures_per_frame,
 799                            td->blocks[i], td->emu_buf,
 800                            mbs_per_slice, num_cblocks[i], is_chroma[i]);
 801         } else {
 802             get_alpha_data(ctx, src, linesize[i], xp, yp,
 803                            pwidth, avctx->height / ctx->pictures_per_frame,
 804                            td->blocks[i], mbs_per_slice, ctx->alpha_bits);
 805         }
 806     }
 807
 808     for (q = min_quant; q < max_quant + 2; q++) {
 809         td->nodes[trellis_node + q].prev_node = -1;
 810         td->nodes[trellis_node + q].quant     = q;
 811     }
 812
 813     // todo: maybe perform coarser quantising to fit into frame size when needed
 814     for (q = min_quant; q <= max_quant; q++) {
 815         bits  = 0;
 816         error = 0;
 817         for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
 818             bits += estimate_slice_plane(ctx, &error, i,
 819                                          src, linesize[i],
 820                                          mbs_per_slice,
 821                                          num_cblocks[i], plane_factor[i],
 822                                          ctx->quants[q], td);
 823         }
 824         if (ctx->alpha_bits)
 825             bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
 826                                          mbs_per_slice, q, td->blocks[3]);
 827         if (bits > 65000 * 8)
 828             error = SCORE_LIMIT;
 829
 830         slice_bits[q]  = bits;
 831         slice_score[q] = error;
 832     }
 833     if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
 834         slice_bits[max_quant + 1]  = slice_bits[max_quant];
 835         slice_score[max_quant + 1] = slice_score[max_quant] + 1;
 836         overquant = max_quant;
 837     } else {
 838         for (q = max_quant + 1; q < 128; q++) {
 839             bits  = 0;
 840             error = 0;
 841             if (q < MAX_STORED_Q) {
 842                 qmat = ctx->quants[q];
 843             } else {
 844                 qmat = td->custom_q;
 845                 for (i = 0; i < 64; i++)
 846                     qmat[i] = ctx->quant_mat[i] * q;
 847             }
 848             for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
 849                 bits += estimate_slice_plane(ctx, &error, i,
 850                                              src, linesize[i],
 851                                              mbs_per_slice,
 852                                              num_cblocks[i], plane_factor[i],
 853                                              qmat, td);
 854             }
 855             if (ctx->alpha_bits)
 856                 bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
 857                                              mbs_per_slice, q, td->blocks[3]);
 858             if (bits <= ctx->bits_per_mb * mbs_per_slice)
 859                 break;
 860         }
 861
 862         slice_bits[max_quant + 1]  = bits;
 863         slice_score[max_quant + 1] = error;
 864         overquant = q;
 865     }
 866     td->nodes[trellis_node + max_quant + 1].quant = overquant;
 867
 868     bits_limit = mbs * ctx->bits_per_mb;
 869     for (pq = min_quant; pq < max_quant + 2; pq++) {
 870         prev = trellis_node - TRELLIS_WIDTH + pq;
 871
 872         for (q = min_quant; q < max_quant + 2; q++) {
 873             cur = trellis_node + q;
 874
 875             bits  = td->nodes[prev].bits + slice_bits[q];
 876             error = slice_score[q];
 877             if (bits > bits_limit)
 878                 error = SCORE_LIMIT;
 879
 880             if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
 881                 new_score = td->nodes[prev].score + error;
 882             else
 883                 new_score = SCORE_LIMIT;
 884             if (td->nodes[cur].prev_node == -1 ||
 885                 td->nodes[cur].score >= new_score) {
 886
 887                 td->nodes[cur].bits      = bits;
 888                 td->nodes[cur].score     = new_score;
 889                 td->nodes[cur].prev_node = prev;
 890             }
 891         }
 892     }
 893
 894     error = td->nodes[trellis_node + min_quant].score;
 895     pq    = trellis_node + min_quant;
 896     for (q = min_quant + 1; q < max_quant + 2; q++) {
 897         if (td->nodes[trellis_node + q].score <= error) {
 898             error = td->nodes[trellis_node + q].score;
 899             pq    = trellis_node + q;
 900         }
 901     }
 902
 903     return pq;
 904 }
 905
 906 static int find_quant_thread(AVCodecContext *avctx, void *arg,
 907                              int jobnr, int threadnr)
 908 {
 909     ProresContext *ctx = avctx->priv_data;
 910     ProresThreadData *td = ctx->tdata + threadnr;
 911     int mbs_per_slice = ctx->mbs_per_slice;
 912     int x, y = jobnr, mb, q = 0;
 913
 914     for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
 915         while (ctx->mb_width - x < mbs_per_slice)
 916             mbs_per_slice >>= 1;
 917         q = find_slice_quant(avctx, avctx->coded_frame,
 918                              (mb + 1) * TRELLIS_WIDTH, x, y,
 919                              mbs_per_slice, td);
 920     }
 921
 922     for (x = ctx->slices_width - 1; x >= 0; x--) {
 923         ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
 924         q = td->nodes[q].prev_node;
 925     }
 926
 927     return 0;
 928 }
 929
 930 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 931                         const AVFrame *pic, int *got_packet)
 932 {
 933     ProresContext *ctx = avctx->priv_data;
 934     uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
 935     uint8_t *picture_size_pos;
 936     PutBitContext pb;
 937     int x, y, i, mb, q = 0;
 938     int sizes[4] = { 0 };
 939     int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
 940     int frame_size, picture_size, slice_size;
 941     int pkt_size, ret;
 942     int max_slice_size = (ctx->frame_size_upper_bound - 200) / (ctx->pictures_per_frame * ctx->slices_per_picture + 1);
 943     uint8_t frame_flags;
 944
 945     *avctx->coded_frame           = *pic;
 946     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 947     avctx->coded_frame->key_frame = 1;
 948
 949     pkt_size = ctx->frame_size_upper_bound;
 950
 951     if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + FF_MIN_BUFFER_SIZE)) < 0)
 952         return ret;
 953
 954     orig_buf = pkt->data;
 955
 956     // frame atom
 957     orig_buf += 4;                              // frame size
 958     bytestream_put_be32  (&orig_buf, FRAME_ID); // frame container ID
 959     buf = orig_buf;
 960
 961     // frame header
 962     tmp = buf;
 963     buf += 2;                                   // frame header size will be stored here
 964     bytestream_put_be16  (&buf, 0);             // version 1
 965     bytestream_put_buffer(&buf, ctx->vendor, 4);
 966     bytestream_put_be16  (&buf, avctx->width);
 967     bytestream_put_be16  (&buf, avctx->height);
 968
 969     frame_flags = ctx->chroma_factor << 6;
 970     if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 971         frame_flags |= pic->top_field_first ? 0x04 : 0x08;
 972     bytestream_put_byte  (&buf, frame_flags);
 973
 974     bytestream_put_byte  (&buf, 0);             // reserved
 975     bytestream_put_byte  (&buf, avctx->color_primaries);
 976     bytestream_put_byte  (&buf, avctx->color_trc);
 977     bytestream_put_byte  (&buf, avctx->colorspace);
 978     bytestream_put_byte  (&buf, 0x40 | (ctx->alpha_bits >> 3));
 979     bytestream_put_byte  (&buf, 0);             // reserved
 980     if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
 981         bytestream_put_byte  (&buf, 0x03);      // matrix flags - both matrices are present
 982         // luma quantisation matrix
 983         for (i = 0; i < 64; i++)
 984             bytestream_put_byte(&buf, ctx->quant_mat[i]);
 985         // chroma quantisation matrix
 986         for (i = 0; i < 64; i++)
 987             bytestream_put_byte(&buf, ctx->quant_mat[i]);
 988     } else {
 989         bytestream_put_byte  (&buf, 0x00);      // matrix flags - default matrices are used
 990     }
 991     bytestream_put_be16  (&tmp, buf - orig_buf); // write back frame header size
 992
 993     for (ctx->cur_picture_idx = 0;
 994          ctx->cur_picture_idx < ctx->pictures_per_frame;
 995          ctx->cur_picture_idx++) {
 996         // picture header
 997         picture_size_pos = buf + 1;
 998         bytestream_put_byte  (&buf, 0x40);          // picture header size (in bits)
 999         buf += 4;                                   // picture data size will be stored here
1000         bytestream_put_be16  (&buf, ctx->slices_per_picture);
1001         bytestream_put_byte  (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
1002
1003         // seek table - will be filled during slice encoding
1004         slice_sizes = buf;
1005         buf += ctx->slices_per_picture * 2;
1006
1007         // slices
1008         if (!ctx->force_quant) {
1009             ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
1010                                   ctx->mb_height);
1011             if (ret)
1012                 return ret;
1013         }
1014
1015         for (y = 0; y < ctx->mb_height; y++) {
1016             int mbs_per_slice = ctx->mbs_per_slice;
1017             for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1018                 q = ctx->force_quant ? ctx->force_quant
1019                                      : ctx->slice_q[mb + y * ctx->slices_width];
1020
1021                 while (ctx->mb_width - x < mbs_per_slice)
1022                     mbs_per_slice >>= 1;
1023
1024                 bytestream_put_byte(&buf, slice_hdr_size << 3);
1025                 slice_hdr = buf;
1026                 buf += slice_hdr_size - 1;
1027                 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1028                     uint8_t *start = pkt->data;
1029                     // Recompute new size according to max_slice_size
1030                     // and deduce delta
1031                     int delta = 200 + (ctx->pictures_per_frame *
1032                                 ctx->slices_per_picture + 1) *
1033                                 max_slice_size - pkt_size;
1034
1035                     delta = FFMAX(delta, 2 * max_slice_size);
1036                     ctx->frame_size_upper_bound += delta;
1037
1038                     if (!ctx->warn) {
1039                         avpriv_request_sample(avctx,
1040                                               "Packet too small: is %i,"
1041                                               " needs %i (slice: %i). "
1042                                               "Correct allocation",
1043                                               pkt_size, delta, max_slice_size);
1044                         ctx->warn = 1;
1045                     }
1046
1047                     ret = av_grow_packet(pkt, delta);
1048                     if (ret < 0)
1049                         return ret;
1050
1051                     pkt_size += delta;
1052                     // restore pointers
1053                     orig_buf         = pkt->data + (orig_buf         - start);
1054                     buf              = pkt->data + (buf              - start);
1055                     picture_size_pos = pkt->data + (picture_size_pos - start);
1056                     slice_sizes      = pkt->data + (slice_sizes      - start);
1057                     slice_hdr        = pkt->data + (slice_hdr        - start);
1058                     tmp              = pkt->data + (tmp              - start);
1059                 }
1060                 init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1061                 ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1062                                    mbs_per_slice);
1063                 if (ret < 0)
1064                     return ret;
1065
1066                 bytestream_put_byte(&slice_hdr, q);
1067                 slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1068                 for (i = 0; i < ctx->num_planes - 1; i++) {
1069                     bytestream_put_be16(&slice_hdr, sizes[i]);
1070                     slice_size += sizes[i];
1071                 }
1072                 bytestream_put_be16(&slice_sizes, slice_size);
1073                 buf += slice_size - slice_hdr_size;
1074                 if (max_slice_size < slice_size)
1075                     max_slice_size = slice_size;
1076             }
1077         }
1078
1079         picture_size = buf - (picture_size_pos - 1);
1080         bytestream_put_be32(&picture_size_pos, picture_size);
1081     }
1082
1083     orig_buf -= 8;
1084     frame_size = buf - orig_buf;
1085     bytestream_put_be32(&orig_buf, frame_size);
1086
1087     pkt->size   = frame_size;
1088     pkt->flags |= AV_PKT_FLAG_KEY;
1089     *got_packet = 1;
1090
1091     return 0;
1092 }
1093
1094 static av_cold int encode_close(AVCodecContext *avctx)
1095 {
1096     ProresContext *ctx = avctx->priv_data;
1097     int i;
1098
1099     av_freep(&avctx->coded_frame);
1100
1101     if (ctx->tdata) {
1102         for (i = 0; i < avctx->thread_count; i++)
1103             av_freep(&ctx->tdata[i].nodes);
1104     }
1105     av_freep(&ctx->tdata);
1106     av_freep(&ctx->slice_q);
1107
1108     return 0;
1109 }
1110
1111 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1112                         int linesize, int16_t *block)
1113 {
1114     int x, y;
1115     const uint16_t *tsrc = src;
1116
1117     for (y = 0; y < 8; y++) {
1118         for (x = 0; x < 8; x++)
1119             block[y * 8 + x] = tsrc[x];
1120         tsrc += linesize >> 1;
1121     }
1122     fdsp->fdct(block);
1123 }
1124
1125 static av_cold int encode_init(AVCodecContext *avctx)
1126 {
1127     ProresContext *ctx = avctx->priv_data;
1128     int mps;
1129     int i, j;
1130     int min_quant, max_quant;
1131     int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
1132
1133     avctx->bits_per_raw_sample = 10;
1134     avctx->coded_frame = av_frame_alloc();
1135     if (!avctx->coded_frame)
1136         return AVERROR(ENOMEM);
1137
1138     ctx->fdct      = prores_fdct;
1139     ctx->scantable = interlaced ? ff_prores_interlaced_scan
1140                                 : ff_prores_progressive_scan;
1141     ff_fdctdsp_init(&ctx->fdsp, avctx);
1142
1143     mps = ctx->mbs_per_slice;
1144     if (mps & (mps - 1)) {
1145         av_log(avctx, AV_LOG_ERROR,
1146                "there should be an integer power of two MBs per slice\n");
1147         return AVERROR(EINVAL);
1148     }
1149     if (ctx->profile == PRORES_PROFILE_AUTO) {
1150         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1151         ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1152                         !(desc->log2_chroma_w + desc->log2_chroma_h))
1153                      ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;
1154         av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1155                "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1156                ? "4:4:4:4 profile because of the used input colorspace"
1157                : "HQ profile to keep best quality");
1158     }
1159     if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1160         if (ctx->profile != PRORES_PROFILE_4444) {
1161             // force alpha and warn
1162             av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1163                    "encode alpha. Override with -profile if needed.\n");
1164             ctx->alpha_bits = 0;
1165         }
1166         if (ctx->alpha_bits & 7) {
1167             av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1168             return AVERROR(EINVAL);
1169         }
1170     } else {
1171         ctx->alpha_bits = 0;
1172     }
1173
1174     ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1175                          ? CFACTOR_Y422
1176                          : CFACTOR_Y444;
1177     ctx->profile_info  = prores_profile_info + ctx->profile;
1178     ctx->num_planes    = 3 + !!ctx->alpha_bits;
1179
1180     ctx->mb_width      = FFALIGN(avctx->width,  16) >> 4;
1181
1182     if (interlaced)
1183         ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1184     else
1185         ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1186
1187     ctx->slices_width  = ctx->mb_width / mps;
1188     ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1189     ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1190     ctx->pictures_per_frame = 1 + interlaced;
1191
1192     if (ctx->quant_sel == -1)
1193         ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1194     else
1195         ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1196
1197     if (strlen(ctx->vendor) != 4) {
1198         av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1199         return AVERROR_INVALIDDATA;
1200     }
1201
1202     ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1203     if (!ctx->force_quant) {
1204         if (!ctx->bits_per_mb) {
1205             for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1206                 if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1207                                            ctx->pictures_per_frame)
1208                     break;
1209             ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
1210         } else if (ctx->bits_per_mb < 128) {
1211             av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1212             return AVERROR_INVALIDDATA;
1213         }
1214
1215         min_quant = ctx->profile_info->min_quant;
1216         max_quant = ctx->profile_info->max_quant;
1217         for (i = min_quant; i < MAX_STORED_Q; i++) {
1218             for (j = 0; j < 64; j++)
1219                 ctx->quants[i][j] = ctx->quant_mat[j] * i;
1220         }
1221
1222         ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1223         if (!ctx->slice_q) {
1224             encode_close(avctx);
1225             return AVERROR(ENOMEM);
1226         }
1227
1228         ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1229         if (!ctx->tdata) {
1230             encode_close(avctx);
1231             return AVERROR(ENOMEM);
1232         }
1233
1234         for (j = 0; j < avctx->thread_count; j++) {
1235             ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1236                                             * TRELLIS_WIDTH
1237                                             * sizeof(*ctx->tdata->nodes));
1238             if (!ctx->tdata[j].nodes) {
1239                 encode_close(avctx);
1240                 return AVERROR(ENOMEM);
1241             }
1242             for (i = min_quant; i < max_quant + 2; i++) {
1243                 ctx->tdata[j].nodes[i].prev_node = -1;
1244                 ctx->tdata[j].nodes[i].bits      = 0;
1245                 ctx->tdata[j].nodes[i].score     = 0;
1246             }
1247         }
1248     } else {
1249         int ls = 0;
1250
1251         if (ctx->force_quant > 64) {
1252             av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1253             return AVERROR_INVALIDDATA;
1254         }
1255
1256         for (j = 0; j < 64; j++) {
1257             ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1258             ls += av_log2((1 << 11)  / ctx->quants[0][j]) * 2 + 1;
1259         }
1260
1261         ctx->bits_per_mb = ls * 8;
1262         if (ctx->chroma_factor == CFACTOR_Y444)
1263             ctx->bits_per_mb += ls * 4;
1264     }
1265
1266     ctx->frame_size_upper_bound = (ctx->pictures_per_frame *
1267                                    ctx->slices_per_picture + 1) *
1268                                   (2 + 2 * ctx->num_planes +
1269                                    (mps * ctx->bits_per_mb) / 8)
1270                                   + 200;
1271
1272     if (ctx->alpha_bits) {
1273          // The alpha plane is run-coded and might exceed the bit budget.
1274          ctx->frame_size_upper_bound += (ctx->pictures_per_frame *
1275                                          ctx->slices_per_picture + 1) *
1276          /* num pixels per slice */     (ctx->mbs_per_slice * 256 *
1277          /* bits per pixel */            (1 + ctx->alpha_bits + 1) + 7 >> 3);
1278     }
1279
1280     avctx->codec_tag   = ctx->profile_info->tag;
1281
1282     av_log(avctx, AV_LOG_DEBUG,
1283            "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1284            ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1285            interlaced ? "yes" : "no", ctx->bits_per_mb);
1286     av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1287            ctx->frame_size_upper_bound);
1288
1289     return 0;
1290 }
1291
1292 #define OFFSET(x) offsetof(ProresContext, x)
1293 #define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1294
1295 static const AVOption options[] = {
1296     { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1297         AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1298     { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1299         { .i64 = PRORES_PROFILE_AUTO },
1300         PRORES_PROFILE_AUTO, PRORES_PROFILE_4444, VE, "profile" },
1301     { "auto",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1302         0, 0, VE, "profile" },
1303     { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1304         0, 0, VE, "profile" },
1305     { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1306         0, 0, VE, "profile" },
1307     { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1308         0, 0, VE, "profile" },
1309     { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1310         0, 0, VE, "profile" },
1311     { "4444",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1312         0, 0, VE, "profile" },
1313     { "vendor", "vendor ID", OFFSET(vendor),
1314         AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
1315     { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1316         AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1317     { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1318         { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1319     { "auto",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1320         0, 0, VE, "quant_mat" },
1321     { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1322         0, 0, VE, "quant_mat" },
1323     { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1324         0, 0, VE, "quant_mat" },
1325     { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1326         0, 0, VE, "quant_mat" },
1327     { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1328         0, 0, VE, "quant_mat" },
1329     { "default",       NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1330         0, 0, VE, "quant_mat" },
1331     { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1332         { .i64 = 16 }, 0, 16, VE },
1333     { NULL }
1334 };
1335
1336 static const AVClass proresenc_class = {
1337     .class_name = "ProRes encoder",
1338     .item_name  = av_default_item_name,
1339     .option     = options,
1340     .version    = LIBAVUTIL_VERSION_INT,
1341 };
1342
1343 AVCodec ff_prores_ks_encoder = {
1344     .name           = "prores_ks",
1345     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1346     .type           = AVMEDIA_TYPE_VIDEO,
1347     .id             = AV_CODEC_ID_PRORES,
1348     .priv_data_size = sizeof(ProresContext),
1349     .init           = encode_init,
1350     .close          = encode_close,
1351     .encode2        = encode_frame,
1352     .capabilities   = CODEC_CAP_SLICE_THREADS,
1353     .pix_fmts       = (const enum AVPixelFormat[]) {
1354                           AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1355                           AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1356                       },
1357     .priv_class     = &proresenc_class,
1358 };