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, arg,
 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     pkt_size = ctx->frame_size_upper_bound;
 946
 947     if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size + FF_MIN_BUFFER_SIZE)) < 0)
 948         return ret;
 949
 950     orig_buf = pkt->data;
 951
 952     // frame atom
 953     orig_buf += 4;                              // frame size
 954     bytestream_put_be32  (&orig_buf, FRAME_ID); // frame container ID
 955     buf = orig_buf;
 956
 957     // frame header
 958     tmp = buf;
 959     buf += 2;                                   // frame header size will be stored here
 960     bytestream_put_be16  (&buf, 0);             // version 1
 961     bytestream_put_buffer(&buf, ctx->vendor, 4);
 962     bytestream_put_be16  (&buf, avctx->width);
 963     bytestream_put_be16  (&buf, avctx->height);
 964
 965     frame_flags = ctx->chroma_factor << 6;
 966     if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 967         frame_flags |= pic->top_field_first ? 0x04 : 0x08;
 968     bytestream_put_byte  (&buf, frame_flags);
 969
 970     bytestream_put_byte  (&buf, 0);             // reserved
 971     bytestream_put_byte  (&buf, avctx->color_primaries);
 972     bytestream_put_byte  (&buf, avctx->color_trc);
 973     bytestream_put_byte  (&buf, avctx->colorspace);
 974     bytestream_put_byte  (&buf, 0x40 | (ctx->alpha_bits >> 3));
 975     bytestream_put_byte  (&buf, 0);             // reserved
 976     if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
 977         bytestream_put_byte  (&buf, 0x03);      // matrix flags - both matrices are present
 978         // luma quantisation matrix
 979         for (i = 0; i < 64; i++)
 980             bytestream_put_byte(&buf, ctx->quant_mat[i]);
 981         // chroma quantisation matrix
 982         for (i = 0; i < 64; i++)
 983             bytestream_put_byte(&buf, ctx->quant_mat[i]);
 984     } else {
 985         bytestream_put_byte  (&buf, 0x00);      // matrix flags - default matrices are used
 986     }
 987     bytestream_put_be16  (&tmp, buf - orig_buf); // write back frame header size
 988
 989     for (ctx->cur_picture_idx = 0;
 990          ctx->cur_picture_idx < ctx->pictures_per_frame;
 991          ctx->cur_picture_idx++) {
 992         // picture header
 993         picture_size_pos = buf + 1;
 994         bytestream_put_byte  (&buf, 0x40);          // picture header size (in bits)
 995         buf += 4;                                   // picture data size will be stored here
 996         bytestream_put_be16  (&buf, ctx->slices_per_picture);
 997         bytestream_put_byte  (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
 998
 999         // seek table - will be filled during slice encoding
1000         slice_sizes = buf;
1001         buf += ctx->slices_per_picture * 2;
1002
1003         // slices
1004         if (!ctx->force_quant) {
1005             ret = avctx->execute2(avctx, find_quant_thread, (void*)pic, NULL,
1006                                   ctx->mb_height);
1007             if (ret)
1008                 return ret;
1009         }
1010
1011         for (y = 0; y < ctx->mb_height; y++) {
1012             int mbs_per_slice = ctx->mbs_per_slice;
1013             for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
1014                 q = ctx->force_quant ? ctx->force_quant
1015                                      : ctx->slice_q[mb + y * ctx->slices_width];
1016
1017                 while (ctx->mb_width - x < mbs_per_slice)
1018                     mbs_per_slice >>= 1;
1019
1020                 bytestream_put_byte(&buf, slice_hdr_size << 3);
1021                 slice_hdr = buf;
1022                 buf += slice_hdr_size - 1;
1023                 if (pkt_size <= buf - orig_buf + 2 * max_slice_size) {
1024                     uint8_t *start = pkt->data;
1025                     // Recompute new size according to max_slice_size
1026                     // and deduce delta
1027                     int delta = 200 + (ctx->pictures_per_frame *
1028                                 ctx->slices_per_picture + 1) *
1029                                 max_slice_size - pkt_size;
1030
1031                     delta = FFMAX(delta, 2 * max_slice_size);
1032                     ctx->frame_size_upper_bound += delta;
1033
1034                     if (!ctx->warn) {
1035                         avpriv_request_sample(avctx,
1036                                               "Packet too small: is %i,"
1037                                               " needs %i (slice: %i). "
1038                                               "Correct allocation",
1039                                               pkt_size, delta, max_slice_size);
1040                         ctx->warn = 1;
1041                     }
1042
1043                     ret = av_grow_packet(pkt, delta);
1044                     if (ret < 0)
1045                         return ret;
1046
1047                     pkt_size += delta;
1048                     // restore pointers
1049                     orig_buf         = pkt->data + (orig_buf         - start);
1050                     buf              = pkt->data + (buf              - start);
1051                     picture_size_pos = pkt->data + (picture_size_pos - start);
1052                     slice_sizes      = pkt->data + (slice_sizes      - start);
1053                     slice_hdr        = pkt->data + (slice_hdr        - start);
1054                     tmp              = pkt->data + (tmp              - start);
1055                 }
1056                 init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)));
1057                 ret = encode_slice(avctx, pic, &pb, sizes, x, y, q,
1058                                    mbs_per_slice);
1059                 if (ret < 0)
1060                     return ret;
1061
1062                 bytestream_put_byte(&slice_hdr, q);
1063                 slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
1064                 for (i = 0; i < ctx->num_planes - 1; i++) {
1065                     bytestream_put_be16(&slice_hdr, sizes[i]);
1066                     slice_size += sizes[i];
1067                 }
1068                 bytestream_put_be16(&slice_sizes, slice_size);
1069                 buf += slice_size - slice_hdr_size;
1070                 if (max_slice_size < slice_size)
1071                     max_slice_size = slice_size;
1072             }
1073         }
1074
1075         picture_size = buf - (picture_size_pos - 1);
1076         bytestream_put_be32(&picture_size_pos, picture_size);
1077     }
1078
1079     orig_buf -= 8;
1080     frame_size = buf - orig_buf;
1081     bytestream_put_be32(&orig_buf, frame_size);
1082
1083     pkt->size   = frame_size;
1084     pkt->flags |= AV_PKT_FLAG_KEY;
1085     *got_packet = 1;
1086
1087     return 0;
1088 }
1089
1090 static av_cold int encode_close(AVCodecContext *avctx)
1091 {
1092     ProresContext *ctx = avctx->priv_data;
1093     int i;
1094
1095     av_frame_free(&avctx->coded_frame);
1096
1097     if (ctx->tdata) {
1098         for (i = 0; i < avctx->thread_count; i++)
1099             av_freep(&ctx->tdata[i].nodes);
1100     }
1101     av_freep(&ctx->tdata);
1102     av_freep(&ctx->slice_q);
1103
1104     return 0;
1105 }
1106
1107 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
1108                         int linesize, int16_t *block)
1109 {
1110     int x, y;
1111     const uint16_t *tsrc = src;
1112
1113     for (y = 0; y < 8; y++) {
1114         for (x = 0; x < 8; x++)
1115             block[y * 8 + x] = tsrc[x];
1116         tsrc += linesize >> 1;
1117     }
1118     fdsp->fdct(block);
1119 }
1120
1121 static av_cold int encode_init(AVCodecContext *avctx)
1122 {
1123     ProresContext *ctx = avctx->priv_data;
1124     int mps;
1125     int i, j;
1126     int min_quant, max_quant;
1127     int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
1128
1129     avctx->bits_per_raw_sample = 10;
1130     avctx->coded_frame = av_frame_alloc();
1131     if (!avctx->coded_frame)
1132         return AVERROR(ENOMEM);
1133     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1134     avctx->coded_frame->key_frame = 1;
1135
1136     ctx->fdct      = prores_fdct;
1137     ctx->scantable = interlaced ? ff_prores_interlaced_scan
1138                                 : ff_prores_progressive_scan;
1139     ff_fdctdsp_init(&ctx->fdsp, avctx);
1140
1141     mps = ctx->mbs_per_slice;
1142     if (mps & (mps - 1)) {
1143         av_log(avctx, AV_LOG_ERROR,
1144                "there should be an integer power of two MBs per slice\n");
1145         return AVERROR(EINVAL);
1146     }
1147     if (ctx->profile == PRORES_PROFILE_AUTO) {
1148         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
1149         ctx->profile = (desc->flags & AV_PIX_FMT_FLAG_ALPHA ||
1150                         !(desc->log2_chroma_w + desc->log2_chroma_h))
1151                      ? PRORES_PROFILE_4444 : PRORES_PROFILE_HQ;
1152         av_log(avctx, AV_LOG_INFO, "Autoselected %s. It can be overridden "
1153                "through -profile option.\n", ctx->profile == PRORES_PROFILE_4444
1154                ? "4:4:4:4 profile because of the used input colorspace"
1155                : "HQ profile to keep best quality");
1156     }
1157     if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
1158         if (ctx->profile != PRORES_PROFILE_4444) {
1159             // force alpha and warn
1160             av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
1161                    "encode alpha. Override with -profile if needed.\n");
1162             ctx->alpha_bits = 0;
1163         }
1164         if (ctx->alpha_bits & 7) {
1165             av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
1166             return AVERROR(EINVAL);
1167         }
1168     } else {
1169         ctx->alpha_bits = 0;
1170     }
1171
1172     ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
1173                          ? CFACTOR_Y422
1174                          : CFACTOR_Y444;
1175     ctx->profile_info  = prores_profile_info + ctx->profile;
1176     ctx->num_planes    = 3 + !!ctx->alpha_bits;
1177
1178     ctx->mb_width      = FFALIGN(avctx->width,  16) >> 4;
1179
1180     if (interlaced)
1181         ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
1182     else
1183         ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
1184
1185     ctx->slices_width  = ctx->mb_width / mps;
1186     ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
1187     ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
1188     ctx->pictures_per_frame = 1 + interlaced;
1189
1190     if (ctx->quant_sel == -1)
1191         ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
1192     else
1193         ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
1194
1195     if (strlen(ctx->vendor) != 4) {
1196         av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
1197         return AVERROR_INVALIDDATA;
1198     }
1199
1200     ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
1201     if (!ctx->force_quant) {
1202         if (!ctx->bits_per_mb) {
1203             for (i = 0; i < NUM_MB_LIMITS - 1; i++)
1204                 if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
1205                                            ctx->pictures_per_frame)
1206                     break;
1207             ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
1208         } else if (ctx->bits_per_mb < 128) {
1209             av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
1210             return AVERROR_INVALIDDATA;
1211         }
1212
1213         min_quant = ctx->profile_info->min_quant;
1214         max_quant = ctx->profile_info->max_quant;
1215         for (i = min_quant; i < MAX_STORED_Q; i++) {
1216             for (j = 0; j < 64; j++)
1217                 ctx->quants[i][j] = ctx->quant_mat[j] * i;
1218         }
1219
1220         ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
1221         if (!ctx->slice_q) {
1222             encode_close(avctx);
1223             return AVERROR(ENOMEM);
1224         }
1225
1226         ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
1227         if (!ctx->tdata) {
1228             encode_close(avctx);
1229             return AVERROR(ENOMEM);
1230         }
1231
1232         for (j = 0; j < avctx->thread_count; j++) {
1233             ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
1234                                             * TRELLIS_WIDTH
1235                                             * sizeof(*ctx->tdata->nodes));
1236             if (!ctx->tdata[j].nodes) {
1237                 encode_close(avctx);
1238                 return AVERROR(ENOMEM);
1239             }
1240             for (i = min_quant; i < max_quant + 2; i++) {
1241                 ctx->tdata[j].nodes[i].prev_node = -1;
1242                 ctx->tdata[j].nodes[i].bits      = 0;
1243                 ctx->tdata[j].nodes[i].score     = 0;
1244             }
1245         }
1246     } else {
1247         int ls = 0;
1248
1249         if (ctx->force_quant > 64) {
1250             av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
1251             return AVERROR_INVALIDDATA;
1252         }
1253
1254         for (j = 0; j < 64; j++) {
1255             ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
1256             ls += av_log2((1 << 11)  / ctx->quants[0][j]) * 2 + 1;
1257         }
1258
1259         ctx->bits_per_mb = ls * 8;
1260         if (ctx->chroma_factor == CFACTOR_Y444)
1261             ctx->bits_per_mb += ls * 4;
1262     }
1263
1264     ctx->frame_size_upper_bound = (ctx->pictures_per_frame *
1265                                    ctx->slices_per_picture + 1) *
1266                                   (2 + 2 * ctx->num_planes +
1267                                    (mps * ctx->bits_per_mb) / 8)
1268                                   + 200;
1269
1270     if (ctx->alpha_bits) {
1271          // The alpha plane is run-coded and might exceed the bit budget.
1272          ctx->frame_size_upper_bound += (ctx->pictures_per_frame *
1273                                          ctx->slices_per_picture + 1) *
1274          /* num pixels per slice */     (ctx->mbs_per_slice * 256 *
1275          /* bits per pixel */            (1 + ctx->alpha_bits + 1) + 7 >> 3);
1276     }
1277
1278     avctx->codec_tag   = ctx->profile_info->tag;
1279
1280     av_log(avctx, AV_LOG_DEBUG,
1281            "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
1282            ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
1283            interlaced ? "yes" : "no", ctx->bits_per_mb);
1284     av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
1285            ctx->frame_size_upper_bound);
1286
1287     return 0;
1288 }
1289
1290 #define OFFSET(x) offsetof(ProresContext, x)
1291 #define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1292
1293 static const AVOption options[] = {
1294     { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1295         AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
1296     { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1297         { .i64 = PRORES_PROFILE_AUTO },
1298         PRORES_PROFILE_AUTO, PRORES_PROFILE_4444, VE, "profile" },
1299     { "auto",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
1300         0, 0, VE, "profile" },
1301     { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
1302         0, 0, VE, "profile" },
1303     { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
1304         0, 0, VE, "profile" },
1305     { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
1306         0, 0, VE, "profile" },
1307     { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
1308         0, 0, VE, "profile" },
1309     { "4444",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
1310         0, 0, VE, "profile" },
1311     { "vendor", "vendor ID", OFFSET(vendor),
1312         AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
1313     { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1314         AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1315     { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1316         { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1317     { "auto",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1318         0, 0, VE, "quant_mat" },
1319     { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1320         0, 0, VE, "quant_mat" },
1321     { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1322         0, 0, VE, "quant_mat" },
1323     { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1324         0, 0, VE, "quant_mat" },
1325     { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1326         0, 0, VE, "quant_mat" },
1327     { "default",       NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1328         0, 0, VE, "quant_mat" },
1329     { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
1330         { .i64 = 16 }, 0, 16, VE },
1331     { NULL }
1332 };
1333
1334 static const AVClass proresenc_class = {
1335     .class_name = "ProRes encoder",
1336     .item_name  = av_default_item_name,
1337     .option     = options,
1338     .version    = LIBAVUTIL_VERSION_INT,
1339 };
1340
1341 AVCodec ff_prores_ks_encoder = {
1342     .name           = "prores_ks",
1343     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
1344     .type           = AVMEDIA_TYPE_VIDEO,
1345     .id             = AV_CODEC_ID_PRORES,
1346     .priv_data_size = sizeof(ProresContext),
1347     .init           = encode_init,
1348     .close          = encode_close,
1349     .encode2        = encode_frame,
1350     .capabilities   = CODEC_CAP_SLICE_THREADS,
1351     .pix_fmts       = (const enum AVPixelFormat[]) {
1352                           AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1353                           AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
1354                       },
1355     .priv_class     = &proresenc_class,
1356 };