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