proresenc.c 36 KB
Newer Older
Kostya Shishkov's avatar
Kostya Shishkov committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/*
 * Apple ProRes encoder
 *
 * Copyright (c) 2012 Konstantin Shishkov
 *
 * This file is part of Libav.
 *
 * Libav is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * Libav is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/opt.h"
#include "avcodec.h"
#include "put_bits.h"
#include "bytestream.h"
#include "internal.h"
#include "proresdsp.h"
#include "proresdata.h"

#define CFACTOR_Y422 2
#define CFACTOR_Y444 3

#define MAX_MBS_PER_SLICE 8

#define MAX_PLANES 3 // should be increased to 4 when there's PIX_FMT_YUV444AP10

enum {
    PRORES_PROFILE_PROXY = 0,
    PRORES_PROFILE_LT,
    PRORES_PROFILE_STANDARD,
    PRORES_PROFILE_HQ,
};

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
enum {
    QUANT_MAT_PROXY = 0,
    QUANT_MAT_LT,
    QUANT_MAT_STANDARD,
    QUANT_MAT_HQ,
    QUANT_MAT_DEFAULT,
};

static const uint8_t prores_quant_matrices[][64] = {
    { // proxy
         4,  7,  9, 11, 13, 14, 15, 63,
         7,  7, 11, 12, 14, 15, 63, 63,
         9, 11, 13, 14, 15, 63, 63, 63,
        11, 11, 13, 14, 63, 63, 63, 63,
        11, 13, 14, 63, 63, 63, 63, 63,
        13, 14, 63, 63, 63, 63, 63, 63,
        13, 63, 63, 63, 63, 63, 63, 63,
        63, 63, 63, 63, 63, 63, 63, 63,
    },
    { // LT
         4,  5,  6,  7,  9, 11, 13, 15,
         5,  5,  7,  8, 11, 13, 15, 17,
         6,  7,  9, 11, 13, 15, 15, 17,
         7,  7,  9, 11, 13, 15, 17, 19,
         7,  9, 11, 13, 14, 16, 19, 23,
         9, 11, 13, 14, 16, 19, 23, 29,
         9, 11, 13, 15, 17, 21, 28, 35,
        11, 13, 16, 17, 21, 28, 35, 41,
    },
    { // standard
         4,  4,  5,  5,  6,  7,  7,  9,
         4,  4,  5,  6,  7,  7,  9,  9,
         5,  5,  6,  7,  7,  9,  9, 10,
         5,  5,  6,  7,  7,  9,  9, 10,
         5,  6,  7,  7,  8,  9, 10, 12,
         6,  7,  7,  8,  9, 10, 12, 15,
         6,  7,  7,  9, 10, 11, 14, 17,
         7,  7,  9, 10, 11, 14, 17, 21,
    },
    { // high quality
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  5,
         4,  4,  4,  4,  4,  4,  5,  5,
         4,  4,  4,  4,  4,  5,  5,  6,
         4,  4,  4,  4,  5,  5,  6,  7,
         4,  4,  4,  4,  5,  6,  7,  7,
    },
    { // codec default
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
         4,  4,  4,  4,  4,  4,  4,  4,
    },
};

Kostya Shishkov's avatar
Kostya Shishkov committed
106 107 108 109 110 111 112 113 114 115 116 117 118 119
#define NUM_MB_LIMITS 4
static const int prores_mb_limits[NUM_MB_LIMITS] = {
    1620, // up to 720x576
    2700, // up to 960x720
    6075, // up to 1440x1080
    9216, // up to 2048x1152
};

static const struct prores_profile {
    const char *full_name;
    uint32_t    tag;
    int         min_quant;
    int         max_quant;
    int         br_tab[NUM_MB_LIMITS];
120
    int         quant;
Kostya Shishkov's avatar
Kostya Shishkov committed
121 122 123 124 125 126 127
} prores_profile_info[4] = {
    {
        .full_name = "proxy",
        .tag       = MKTAG('a', 'p', 'c', 'o'),
        .min_quant = 4,
        .max_quant = 8,
        .br_tab    = { 300, 242, 220, 194 },
128
        .quant     = QUANT_MAT_PROXY,
Kostya Shishkov's avatar
Kostya Shishkov committed
129 130 131 132 133 134 135
    },
    {
        .full_name = "LT",
        .tag       = MKTAG('a', 'p', 'c', 's'),
        .min_quant = 1,
        .max_quant = 9,
        .br_tab    = { 720, 560, 490, 440 },
136
        .quant     = QUANT_MAT_LT,
Kostya Shishkov's avatar
Kostya Shishkov committed
137 138 139 140 141 142 143
    },
    {
        .full_name = "standard",
        .tag       = MKTAG('a', 'p', 'c', 'n'),
        .min_quant = 1,
        .max_quant = 6,
        .br_tab    = { 1050, 808, 710, 632 },
144
        .quant     = QUANT_MAT_STANDARD,
Kostya Shishkov's avatar
Kostya Shishkov committed
145 146 147 148 149 150 151
    },
    {
        .full_name = "high quality",
        .tag       = MKTAG('a', 'p', 'c', 'h'),
        .min_quant = 1,
        .max_quant = 6,
        .br_tab    = { 1566, 1216, 1070, 950 },
152
        .quant     = QUANT_MAT_HQ,
Kostya Shishkov's avatar
Kostya Shishkov committed
153 154 155 156 157 158 159 160 161 162 163 164 165 166
    }
// for 4444 profile bitrate numbers are { 2350, 1828, 1600, 1425 }
};

#define TRELLIS_WIDTH 16
#define SCORE_LIMIT   INT_MAX / 2

struct TrellisNode {
    int prev_node;
    int quant;
    int bits;
    int score;
};

167 168
#define MAX_STORED_Q 16

169 170 171 172 173 174 175
typedef struct ProresThreadData {
    DECLARE_ALIGNED(16, DCTELEM, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
    int16_t custom_q[64];
    struct TrellisNode *nodes;
} ProresThreadData;

Kostya Shishkov's avatar
Kostya Shishkov committed
176 177 178 179
typedef struct ProresContext {
    AVClass *class;
    DECLARE_ALIGNED(16, DCTELEM, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
180 181
    int16_t quants[MAX_STORED_Q][64];
    int16_t custom_q[64];
182
    const uint8_t *quant_mat;
Kostya Shishkov's avatar
Kostya Shishkov committed
183 184 185 186 187 188 189 190

    ProresDSPContext dsp;
    ScanTable  scantable;

    int mb_width, mb_height;
    int mbs_per_slice;
    int num_chroma_blocks, chroma_factor;
    int slices_width;
191 192 193
    int slices_per_picture;
    int pictures_per_frame; // 1 for progressive, 2 for interlaced
    int cur_picture_idx;
Kostya Shishkov's avatar
Kostya Shishkov committed
194 195
    int num_planes;
    int bits_per_mb;
196
    int force_quant;
Kostya Shishkov's avatar
Kostya Shishkov committed
197

198 199 200
    char *vendor;
    int quant_sel;

201
    int frame_size_upper_bound;
202

Kostya Shishkov's avatar
Kostya Shishkov committed
203 204 205 206
    int profile;
    const struct prores_profile *profile_info;

    int *slice_q;
207 208

    ProresThreadData *tdata;
Kostya Shishkov's avatar
Kostya Shishkov committed
209 210 211 212
} ProresContext;

static void get_slice_data(ProresContext *ctx, const uint16_t *src,
                           int linesize, int x, int y, int w, int h,
213
                           DCTELEM *blocks, uint16_t *emu_buf,
214
                           int mbs_per_slice, int blocks_per_mb, int is_chroma)
Kostya Shishkov's avatar
Kostya Shishkov committed
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
{
    const uint16_t *esrc;
    const int mb_width = 4 * blocks_per_mb;
    int elinesize;
    int i, j, k;

    for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
        if (x >= w) {
            memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
                              * sizeof(*blocks));
            return;
        }
        if (x + mb_width <= w && y + 16 <= h) {
            esrc      = src;
            elinesize = linesize;
        } else {
            int bw, bh, pix;

233 234
            esrc      = emu_buf;
            elinesize = 16 * sizeof(*emu_buf);
Kostya Shishkov's avatar
Kostya Shishkov committed
235 236 237 238 239

            bw = FFMIN(w - x, mb_width);
            bh = FFMIN(h - y, 16);

            for (j = 0; j < bh; j++) {
240
                memcpy(emu_buf + j * 16,
241
                       (const uint8_t*)src + j * linesize,
Kostya Shishkov's avatar
Kostya Shishkov committed
242
                       bw * sizeof(*src));
243
                pix = emu_buf[j * 16 + bw - 1];
Kostya Shishkov's avatar
Kostya Shishkov committed
244
                for (k = bw; k < mb_width; k++)
245
                    emu_buf[j * 16 + k] = pix;
Kostya Shishkov's avatar
Kostya Shishkov committed
246 247
            }
            for (; j < 16; j++)
248 249 250
                memcpy(emu_buf + j * 16,
                       emu_buf + (bh - 1) * 16,
                       mb_width * sizeof(*emu_buf));
Kostya Shishkov's avatar
Kostya Shishkov committed
251
        }
252 253
        if (!is_chroma) {
            ctx->dsp.fdct(esrc, elinesize, blocks);
Kostya Shishkov's avatar
Kostya Shishkov committed
254
            blocks += 64;
255
            if (blocks_per_mb > 2) {
256
                ctx->dsp.fdct(esrc + 8, elinesize, blocks);
257 258
                blocks += 64;
            }
259
            ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
Kostya Shishkov's avatar
Kostya Shishkov committed
260
            blocks += 64;
261
            if (blocks_per_mb > 2) {
262
                ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
263 264 265 266 267
                blocks += 64;
            }
        } else {
            ctx->dsp.fdct(esrc, elinesize, blocks);
            blocks += 64;
268
            ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
269 270
            blocks += 64;
            if (blocks_per_mb > 2) {
271
                ctx->dsp.fdct(esrc + 8, elinesize, blocks);
272
                blocks += 64;
273
                ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
274 275
                blocks += 64;
            }
Kostya Shishkov's avatar
Kostya Shishkov committed
276 277 278 279 280 281 282 283 284
        }

        x += mb_width;
    }
}

/**
 * Write an unsigned rice/exp golomb codeword.
 */
285
static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
Kostya Shishkov's avatar
Kostya Shishkov committed
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
{
    unsigned int rice_order, exp_order, switch_bits, switch_val;
    int exponent;

    /* number of prefix bits to switch between Rice and expGolomb */
    switch_bits = (codebook & 3) + 1;
    rice_order  =  codebook >> 5;       /* rice code order */
    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */

    switch_val  = switch_bits << rice_order;

    if (val >= switch_val) {
        val -= switch_val - (1 << exp_order);
        exponent = av_log2(val);

        put_bits(pb, exponent - exp_order + switch_bits, 0);
302
        put_bits(pb, exponent + 1, val);
Kostya Shishkov's avatar
Kostya Shishkov committed
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
    } else {
        exponent = val >> rice_order;

        if (exponent)
            put_bits(pb, exponent, 0);
        put_bits(pb, 1, 1);
        if (rice_order)
            put_sbits(pb, rice_order, val);
    }
}

#define GET_SIGN(x)  ((x) >> 31)
#define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))

static void encode_dcs(PutBitContext *pb, DCTELEM *blocks,
                       int blocks_per_slice, int scale)
{
    int i;
    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;

    prev_dc = (blocks[0] - 0x4000) / scale;
    encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
325
    sign     = 0;
Kostya Shishkov's avatar
Kostya Shishkov committed
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
    codebook = 3;
    blocks  += 64;

    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
        dc       = (blocks[0] - 0x4000) / scale;
        delta    = dc - prev_dc;
        new_sign = GET_SIGN(delta);
        delta    = (delta ^ sign) - sign;
        code     = MAKE_CODE(delta);
        encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
        codebook = (code + (code & 1)) >> 1;
        codebook = FFMIN(codebook, 3);
        sign     = new_sign;
        prev_dc  = dc;
    }
}

static void encode_acs(PutBitContext *pb, DCTELEM *blocks,
                       int blocks_per_slice,
                       int plane_size_factor,
                       const uint8_t *scan, const int16_t *qmat)
{
    int idx, i;
    int run, level, run_cb, lev_cb;
    int max_coeffs, abs_level;

    max_coeffs = blocks_per_slice << 6;
    run_cb     = ff_prores_run_to_cb_index[4];
    lev_cb     = ff_prores_lev_to_cb_index[2];
    run        = 0;

    for (i = 1; i < 64; i++) {
        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
            level = blocks[idx] / qmat[scan[i]];
            if (level) {
                abs_level = FFABS(level);
                encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
                encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],
                                    abs_level - 1);
                put_sbits(pb, 1, GET_SIGN(level));

                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
                run    = 0;
            } else {
                run++;
            }
        }
    }
}

static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
                              const uint16_t *src, int linesize,
                              int mbs_per_slice, DCTELEM *blocks,
                              int blocks_per_mb, int plane_size_factor,
                              const int16_t *qmat)
{
    int blocks_per_slice, saved_pos;

    saved_pos = put_bits_count(pb);
    blocks_per_slice = mbs_per_slice * blocks_per_mb;

    encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
    encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
               ctx->scantable.permutated, qmat);
    flush_put_bits(pb);

    return (put_bits_count(pb) - saved_pos) >> 3;
}

static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
                        PutBitContext *pb,
                        int sizes[4], int x, int y, int quant,
                        int mbs_per_slice)
{
    ProresContext *ctx = avctx->priv_data;
    int i, xp, yp;
    int total_size = 0;
    const uint16_t *src;
    int slice_width_factor = av_log2(mbs_per_slice);
406
    int num_cblocks, pwidth, linesize, line_add;
Kostya Shishkov's avatar
Kostya Shishkov committed
407
    int plane_factor, is_chroma;
408 409
    uint16_t *qmat;

410 411 412 413 414
    if (ctx->pictures_per_frame == 1)
        line_add = 0;
    else
        line_add = ctx->cur_picture_idx ^ !pic->top_field_first;

415 416 417
    if (ctx->force_quant) {
        qmat = ctx->quants[0];
    } else if (quant < MAX_STORED_Q) {
418 419 420 421
        qmat = ctx->quants[quant];
    } else {
        qmat = ctx->custom_q;
        for (i = 0; i < 64; i++)
422
            qmat[i] = ctx->quant_mat[i] * quant;
423
    }
Kostya Shishkov's avatar
Kostya Shishkov committed
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441

    for (i = 0; i < ctx->num_planes; i++) {
        is_chroma    = (i == 1 || i == 2);
        plane_factor = slice_width_factor + 2;
        if (is_chroma)
            plane_factor += ctx->chroma_factor - 3;
        if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
            xp          = x << 4;
            yp          = y << 4;
            num_cblocks = 4;
            pwidth      = avctx->width;
        } else {
            xp          = x << 3;
            yp          = y << 4;
            num_cblocks = 2;
            pwidth      = avctx->width >> 1;
        }

442 443 444 445 446 447 448
        linesize = pic->linesize[i] * ctx->pictures_per_frame;
        src = (const uint16_t*)(pic->data[i] + yp * linesize +
                                line_add * pic->linesize[i]) + xp;

        get_slice_data(ctx, src, linesize, xp, yp,
                       pwidth, avctx->height / ctx->pictures_per_frame,
                       ctx->blocks[0], ctx->emu_buf,
449
                       mbs_per_slice, num_cblocks, is_chroma);
450
        sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
Kostya Shishkov's avatar
Kostya Shishkov committed
451 452
                                      mbs_per_slice, ctx->blocks[0],
                                      num_cblocks, plane_factor,
453
                                      qmat);
Kostya Shishkov's avatar
Kostya Shishkov committed
454 455 456 457 458
        total_size += sizes[i];
    }
    return total_size;
}

459
static inline int estimate_vlc(unsigned codebook, int val)
Kostya Shishkov's avatar
Kostya Shishkov committed
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
{
    unsigned int rice_order, exp_order, switch_bits, switch_val;
    int exponent;

    /* number of prefix bits to switch between Rice and expGolomb */
    switch_bits = (codebook & 3) + 1;
    rice_order  =  codebook >> 5;       /* rice code order */
    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */

    switch_val  = switch_bits << rice_order;

    if (val >= switch_val) {
        val -= switch_val - (1 << exp_order);
        exponent = av_log2(val);

        return exponent * 2 - exp_order + switch_bits + 1;
    } else {
        return (val >> rice_order) + rice_order + 1;
    }
}

static int estimate_dcs(int *error, DCTELEM *blocks, int blocks_per_slice,
                        int scale)
{
    int i;
    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
    int bits;

    prev_dc  = (blocks[0] - 0x4000) / scale;
    bits     = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
490
    sign     = 0;
Kostya Shishkov's avatar
Kostya Shishkov committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
    codebook = 3;
    blocks  += 64;
    *error  += FFABS(blocks[0] - 0x4000) % scale;

    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
        dc       = (blocks[0] - 0x4000) / scale;
        *error  += FFABS(blocks[0] - 0x4000) % scale;
        delta    = dc - prev_dc;
        new_sign = GET_SIGN(delta);
        delta    = (delta ^ sign) - sign;
        code     = MAKE_CODE(delta);
        bits    += estimate_vlc(ff_prores_dc_codebook[codebook], code);
        codebook = (code + (code & 1)) >> 1;
        codebook = FFMIN(codebook, 3);
        sign     = new_sign;
        prev_dc  = dc;
    }

    return bits;
}

static int estimate_acs(int *error, DCTELEM *blocks, int blocks_per_slice,
                        int plane_size_factor,
                        const uint8_t *scan, const int16_t *qmat)
{
    int idx, i;
    int run, level, run_cb, lev_cb;
    int max_coeffs, abs_level;
    int bits = 0;

    max_coeffs = blocks_per_slice << 6;
    run_cb     = ff_prores_run_to_cb_index[4];
    lev_cb     = ff_prores_lev_to_cb_index[2];
    run        = 0;

    for (i = 1; i < 64; i++) {
        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
            level   = blocks[idx] / qmat[scan[i]];
            *error += FFABS(blocks[idx]) % qmat[scan[i]];
            if (level) {
                abs_level = FFABS(level);
                bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
                bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
                                     abs_level - 1) + 1;

                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
                run    = 0;
            } else {
                run++;
            }
        }
    }

    return bits;
}

static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
                                const uint16_t *src, int linesize,
                                int mbs_per_slice,
                                int blocks_per_mb, int plane_size_factor,
552
                                const int16_t *qmat, ProresThreadData *td)
Kostya Shishkov's avatar
Kostya Shishkov committed
553 554 555 556 557 558
{
    int blocks_per_slice;
    int bits;

    blocks_per_slice = mbs_per_slice * blocks_per_mb;

559 560
    bits  = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
    bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
Kostya Shishkov's avatar
Kostya Shishkov committed
561 562 563 564 565 566
                         plane_size_factor, ctx->scantable.permutated, qmat);

    return FFALIGN(bits, 8);
}

static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
567 568
                            int trellis_node, int x, int y, int mbs_per_slice,
                            ProresThreadData *td)
Kostya Shishkov's avatar
Kostya Shishkov committed
569 570 571 572 573 574 575 576 577 578 579 580
{
    ProresContext *ctx = avctx->priv_data;
    int i, q, pq, xp, yp;
    const uint16_t *src;
    int slice_width_factor = av_log2(mbs_per_slice);
    int num_cblocks[MAX_PLANES], pwidth;
    int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
    const int min_quant = ctx->profile_info->min_quant;
    const int max_quant = ctx->profile_info->max_quant;
    int error, bits, bits_limit;
    int mbs, prev, cur, new_score;
    int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
581 582
    int overquant;
    uint16_t *qmat;
583
    int linesize[4], line_add;
Kostya Shishkov's avatar
Kostya Shishkov committed
584

585 586 587 588
    if (ctx->pictures_per_frame == 1)
        line_add = 0;
    else
        line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
Kostya Shishkov's avatar
Kostya Shishkov committed
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
    mbs = x + mbs_per_slice;

    for (i = 0; i < ctx->num_planes; i++) {
        is_chroma[i]    = (i == 1 || i == 2);
        plane_factor[i] = slice_width_factor + 2;
        if (is_chroma[i])
            plane_factor[i] += ctx->chroma_factor - 3;
        if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
            xp             = x << 4;
            yp             = y << 4;
            num_cblocks[i] = 4;
            pwidth         = avctx->width;
        } else {
            xp             = x << 3;
            yp             = y << 4;
            num_cblocks[i] = 2;
            pwidth         = avctx->width >> 1;
        }

608 609 610 611 612 613 614
        linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;
        src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +
                                line_add * pic->linesize[i]) + xp;

        get_slice_data(ctx, src, linesize[i], xp, yp,
                       pwidth, avctx->height / ctx->pictures_per_frame,
                       td->blocks[i], td->emu_buf,
615
                       mbs_per_slice, num_cblocks[i], is_chroma[i]);
Kostya Shishkov's avatar
Kostya Shishkov committed
616 617
    }

618
    for (q = min_quant; q < max_quant + 2; q++) {
619 620
        td->nodes[trellis_node + q].prev_node = -1;
        td->nodes[trellis_node + q].quant     = q;
Kostya Shishkov's avatar
Kostya Shishkov committed
621 622 623 624 625 626 627 628
    }

    // todo: maybe perform coarser quantising to fit into frame size when needed
    for (q = min_quant; q <= max_quant; q++) {
        bits  = 0;
        error = 0;
        for (i = 0; i < ctx->num_planes; i++) {
            bits += estimate_slice_plane(ctx, &error, i,
629
                                         src, linesize[i],
Kostya Shishkov's avatar
Kostya Shishkov committed
630 631
                                         mbs_per_slice,
                                         num_cblocks[i], plane_factor[i],
632
                                         ctx->quants[q], td);
Kostya Shishkov's avatar
Kostya Shishkov committed
633 634 635 636 637 638 639 640
        }
        if (bits > 65000 * 8) {
            error = SCORE_LIMIT;
            break;
        }
        slice_bits[q]  = bits;
        slice_score[q] = error;
    }
641 642 643 644 645 646 647 648 649 650 651
    if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
        slice_bits[max_quant + 1]  = slice_bits[max_quant];
        slice_score[max_quant + 1] = slice_score[max_quant] + 1;
        overquant = max_quant;
    } else {
        for (q = max_quant + 1; q < 128; q++) {
            bits  = 0;
            error = 0;
            if (q < MAX_STORED_Q) {
                qmat = ctx->quants[q];
            } else {
652
                qmat = td->custom_q;
653
                for (i = 0; i < 64; i++)
654
                    qmat[i] = ctx->quant_mat[i] * q;
655 656 657
            }
            for (i = 0; i < ctx->num_planes; i++) {
                bits += estimate_slice_plane(ctx, &error, i,
658
                                             src, linesize[i],
659 660
                                             mbs_per_slice,
                                             num_cblocks[i], plane_factor[i],
661
                                             qmat, td);
662 663 664 665 666 667 668 669 670
            }
            if (bits <= ctx->bits_per_mb * mbs_per_slice)
                break;
        }

        slice_bits[max_quant + 1]  = bits;
        slice_score[max_quant + 1] = error;
        overquant = q;
    }
671
    td->nodes[trellis_node + max_quant + 1].quant = overquant;
Kostya Shishkov's avatar
Kostya Shishkov committed
672 673

    bits_limit = mbs * ctx->bits_per_mb;
674
    for (pq = min_quant; pq < max_quant + 2; pq++) {
Kostya Shishkov's avatar
Kostya Shishkov committed
675 676
        prev = trellis_node - TRELLIS_WIDTH + pq;

677
        for (q = min_quant; q < max_quant + 2; q++) {
Kostya Shishkov's avatar
Kostya Shishkov committed
678 679
            cur = trellis_node + q;

680
            bits  = td->nodes[prev].bits + slice_bits[q];
Kostya Shishkov's avatar
Kostya Shishkov committed
681 682 683 684
            error = slice_score[q];
            if (bits > bits_limit)
                error = SCORE_LIMIT;

685 686
            if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
                new_score = td->nodes[prev].score + error;
Kostya Shishkov's avatar
Kostya Shishkov committed
687 688
            else
                new_score = SCORE_LIMIT;
689 690
            if (td->nodes[cur].prev_node == -1 ||
                td->nodes[cur].score >= new_score) {
Kostya Shishkov's avatar
Kostya Shishkov committed
691

692 693 694
                td->nodes[cur].bits      = bits;
                td->nodes[cur].score     = new_score;
                td->nodes[cur].prev_node = prev;
Kostya Shishkov's avatar
Kostya Shishkov committed
695 696 697 698
            }
        }
    }

699
    error = td->nodes[trellis_node + min_quant].score;
Kostya Shishkov's avatar
Kostya Shishkov committed
700
    pq    = trellis_node + min_quant;
701
    for (q = min_quant + 1; q < max_quant + 2; q++) {
702 703
        if (td->nodes[trellis_node + q].score <= error) {
            error = td->nodes[trellis_node + q].score;
Kostya Shishkov's avatar
Kostya Shishkov committed
704 705 706 707 708 709 710
            pq    = trellis_node + q;
        }
    }

    return pq;
}

711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
static int find_quant_thread(AVCodecContext *avctx, void *arg,
                             int jobnr, int threadnr)
{
    ProresContext *ctx = avctx->priv_data;
    ProresThreadData *td = ctx->tdata + threadnr;
    int mbs_per_slice = ctx->mbs_per_slice;
    int x, y = jobnr, mb, q = 0;

    for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
        while (ctx->mb_width - x < mbs_per_slice)
            mbs_per_slice >>= 1;
        q = find_slice_quant(avctx, avctx->coded_frame,
                             (mb + 1) * TRELLIS_WIDTH, x, y,
                             mbs_per_slice, td);
    }

    for (x = ctx->slices_width - 1; x >= 0; x--) {
        ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
        q = td->nodes[q].prev_node;
    }

    return 0;
}

Kostya Shishkov's avatar
Kostya Shishkov committed
735 736 737 738 739 740 741 742 743 744 745 746
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                        const AVFrame *pic, int *got_packet)
{
    ProresContext *ctx = avctx->priv_data;
    uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
    uint8_t *picture_size_pos;
    PutBitContext pb;
    int x, y, i, mb, q = 0;
    int sizes[4] = { 0 };
    int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
    int frame_size, picture_size, slice_size;
    int pkt_size, ret;
747
    uint8_t frame_flags;
Kostya Shishkov's avatar
Kostya Shishkov committed
748 749 750 751 752

    *avctx->coded_frame           = *pic;
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
    avctx->coded_frame->key_frame = 1;

753
    pkt_size = ctx->frame_size_upper_bound + FF_MIN_BUFFER_SIZE;
Kostya Shishkov's avatar
Kostya Shishkov committed
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770

    if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
        return ret;
    }

    orig_buf = pkt->data;

    // frame atom
    orig_buf += 4;                              // frame size
    bytestream_put_be32  (&orig_buf, FRAME_ID); // frame container ID
    buf = orig_buf;

    // frame header
    tmp = buf;
    buf += 2;                                   // frame header size will be stored here
    bytestream_put_be16  (&buf, 0);             // version 1
771
    bytestream_put_buffer(&buf, ctx->vendor, 4);
Kostya Shishkov's avatar
Kostya Shishkov committed
772 773
    bytestream_put_be16  (&buf, avctx->width);
    bytestream_put_be16  (&buf, avctx->height);
774 775 776 777 778 779

    frame_flags = ctx->chroma_factor << 6;
    if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)
        frame_flags |= pic->top_field_first ? 0x04 : 0x08;
    bytestream_put_byte  (&buf, frame_flags);

Kostya Shishkov's avatar
Kostya Shishkov committed
780
    bytestream_put_byte  (&buf, 0);             // reserved
781 782 783
    bytestream_put_byte  (&buf, avctx->color_primaries);
    bytestream_put_byte  (&buf, avctx->color_trc);
    bytestream_put_byte  (&buf, avctx->colorspace);
Kostya Shishkov's avatar
Kostya Shishkov committed
784 785
    bytestream_put_byte  (&buf, 0x40);          // source format and alpha information
    bytestream_put_byte  (&buf, 0);             // reserved
786 787 788 789 790 791 792 793 794 795 796
    if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
        bytestream_put_byte  (&buf, 0x03);      // matrix flags - both matrices are present
        // luma quantisation matrix
        for (i = 0; i < 64; i++)
            bytestream_put_byte(&buf, ctx->quant_mat[i]);
        // chroma quantisation matrix
        for (i = 0; i < 64; i++)
            bytestream_put_byte(&buf, ctx->quant_mat[i]);
    } else {
        bytestream_put_byte  (&buf, 0x00);      // matrix flags - default matrices are used
    }
Kostya Shishkov's avatar
Kostya Shishkov committed
797 798
    bytestream_put_be16  (&tmp, buf - orig_buf); // write back frame header size

799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819
    for (ctx->cur_picture_idx = 0;
         ctx->cur_picture_idx < ctx->pictures_per_frame;
         ctx->cur_picture_idx++) {
        // picture header
        picture_size_pos = buf + 1;
        bytestream_put_byte  (&buf, 0x40);          // picture header size (in bits)
        buf += 4;                                   // picture data size will be stored here
        bytestream_put_be16  (&buf, ctx->slices_per_picture);
        bytestream_put_byte  (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs

        // seek table - will be filled during slice encoding
        slice_sizes = buf;
        buf += ctx->slices_per_picture * 2;

        // slices
        if (!ctx->force_quant) {
            ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
                                  ctx->mb_height);
            if (ret)
                return ret;
        }
Kostya Shishkov's avatar
Kostya Shishkov committed
820

821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
        for (y = 0; y < ctx->mb_height; y++) {
            int mbs_per_slice = ctx->mbs_per_slice;
            for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
                q = ctx->force_quant ? ctx->force_quant
                                     : ctx->slice_q[mb + y * ctx->slices_width];

                while (ctx->mb_width - x < mbs_per_slice)
                    mbs_per_slice >>= 1;

                bytestream_put_byte(&buf, slice_hdr_size << 3);
                slice_hdr = buf;
                buf += slice_hdr_size - 1;
                init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)) * 8);
                encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);

                bytestream_put_byte(&slice_hdr, q);
                slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
                for (i = 0; i < ctx->num_planes - 1; i++) {
                    bytestream_put_be16(&slice_hdr, sizes[i]);
                    slice_size += sizes[i];
                }
                bytestream_put_be16(&slice_sizes, slice_size);
                buf += slice_size - slice_hdr_size;
Kostya Shishkov's avatar
Kostya Shishkov committed
844 845
            }
        }
846 847 848 849 850 851

        if (ctx->pictures_per_frame == 1)
            picture_size = buf - picture_size_pos - 6;
        else
            picture_size = buf - picture_size_pos + 1;
        bytestream_put_be32(&picture_size_pos, picture_size);
Kostya Shishkov's avatar
Kostya Shishkov committed
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
    }

    orig_buf -= 8;
    frame_size = buf - orig_buf;
    bytestream_put_be32(&orig_buf, frame_size);

    pkt->size   = frame_size;
    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;

    return 0;
}

static av_cold int encode_close(AVCodecContext *avctx)
{
    ProresContext *ctx = avctx->priv_data;
868
    int i;
Kostya Shishkov's avatar
Kostya Shishkov committed
869 870 871

    av_freep(&avctx->coded_frame);

872 873 874 875 876
    if (ctx->tdata) {
        for (i = 0; i < avctx->thread_count; i++)
            av_free(ctx->tdata[i].nodes);
    }
    av_freep(&ctx->tdata);
Kostya Shishkov's avatar
Kostya Shishkov committed
877 878 879 880 881 882 883 884 885 886 887
    av_freep(&ctx->slice_q);

    return 0;
}

static av_cold int encode_init(AVCodecContext *avctx)
{
    ProresContext *ctx = avctx->priv_data;
    int mps;
    int i, j;
    int min_quant, max_quant;
888
    int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
Kostya Shishkov's avatar
Kostya Shishkov committed
889 890 891 892 893 894 895 896

    avctx->bits_per_raw_sample = 10;
    avctx->coded_frame = avcodec_alloc_frame();
    if (!avctx->coded_frame)
        return AVERROR(ENOMEM);

    ff_proresdsp_init(&ctx->dsp);
    ff_init_scantable(ctx->dsp.dct_permutation, &ctx->scantable,
897 898
                      interlaced ? ff_prores_interlaced_scan
                                 : ff_prores_progressive_scan);
Kostya Shishkov's avatar
Kostya Shishkov committed
899 900 901 902 903 904 905 906 907 908 909 910 911 912 913

    mps = ctx->mbs_per_slice;
    if (mps & (mps - 1)) {
        av_log(avctx, AV_LOG_ERROR,
               "there should be an integer power of two MBs per slice\n");
        return AVERROR(EINVAL);
    }

    ctx->chroma_factor = avctx->pix_fmt == PIX_FMT_YUV422P10
                         ? CFACTOR_Y422
                         : CFACTOR_Y444;
    ctx->profile_info  = prores_profile_info + ctx->profile;
    ctx->num_planes    = 3;

    ctx->mb_width      = FFALIGN(avctx->width,  16) >> 4;
914 915 916 917 918 919

    if (interlaced)
        ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
    else
        ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;

Kostya Shishkov's avatar
Kostya Shishkov committed
920 921
    ctx->slices_width  = ctx->mb_width / mps;
    ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
922 923
    ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
    ctx->pictures_per_frame = 1 + interlaced;
Kostya Shishkov's avatar
Kostya Shishkov committed
924

925 926 927 928 929 930 931 932 933 934
    if (ctx->quant_sel == -1)
        ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
    else
        ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];

    if (strlen(ctx->vendor) != 4) {
        av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
        return AVERROR_INVALIDDATA;
    }

935 936 937 938
    ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
    if (!ctx->force_quant) {
        if (!ctx->bits_per_mb) {
            for (i = 0; i < NUM_MB_LIMITS - 1; i++)
939 940
                if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
                                           ctx->pictures_per_frame)
941 942 943 944 945 946 947 948 949 950 951 952 953 954
                    break;
            ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
        } else if (ctx->bits_per_mb < 128) {
            av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
            return AVERROR_INVALIDDATA;
        }

        min_quant = ctx->profile_info->min_quant;
        max_quant = ctx->profile_info->max_quant;
        for (i = min_quant; i < MAX_STORED_Q; i++) {
            for (j = 0; j < 64; j++)
                ctx->quants[i][j] = ctx->quant_mat[j] * i;
        }

955
        ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
956
        if (!ctx->slice_q) {
957 958 959 960
            encode_close(avctx);
            return AVERROR(ENOMEM);
        }

961 962
        ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
        if (!ctx->tdata) {
963 964 965
            encode_close(avctx);
            return AVERROR(ENOMEM);
        }
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980

        for (j = 0; j < avctx->thread_count; j++) {
            ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
                                            * TRELLIS_WIDTH
                                            * sizeof(*ctx->tdata->nodes));
            if (!ctx->tdata[j].nodes) {
                encode_close(avctx);
                return AVERROR(ENOMEM);
            }
            for (i = min_quant; i < max_quant + 2; i++) {
                ctx->tdata[j].nodes[i].prev_node = -1;
                ctx->tdata[j].nodes[i].bits      = 0;
                ctx->tdata[j].nodes[i].score     = 0;
            }
        }
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
    } else {
        int ls = 0;

        if (ctx->force_quant > 64) {
            av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
            return AVERROR_INVALIDDATA;
        }

        for (j = 0; j < 64; j++) {
            ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
            ls += av_log2((1 << 11)  / ctx->quants[0][j]) * 2 + 1;
        }

        ctx->bits_per_mb = ls * 8;
        if (ctx->chroma_factor == CFACTOR_Y444)
            ctx->bits_per_mb += ls * 4;
        if (ctx->num_planes == 4)
            ctx->bits_per_mb += ls * 4;
999
    }
Kostya Shishkov's avatar
Kostya Shishkov committed
1000

1001 1002 1003 1004 1005
    ctx->frame_size_upper_bound = ctx->pictures_per_frame *
                                  ctx->slices_per_picture *
                                  (2 + 2 * ctx->num_planes +
                                   (mps * ctx->bits_per_mb) / 8)
                                  + 200;
1006

Kostya Shishkov's avatar
Kostya Shishkov committed
1007 1008
    avctx->codec_tag   = ctx->profile_info->tag;

1009 1010 1011 1012 1013 1014
    av_log(avctx, AV_LOG_DEBUG,
           "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
           ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
           interlaced ? "yes" : "no", ctx->bits_per_mb);
    av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
           ctx->frame_size_upper_bound);
Kostya Shishkov's avatar
Kostya Shishkov committed
1015 1016 1017 1018 1019 1020 1021 1022 1023

    return 0;
}

#define OFFSET(x) offsetof(ProresContext, x)
#define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

static const AVOption options[] = {
    { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
1024
        AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
Kostya Shishkov's avatar
Kostya Shishkov committed
1025
    { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
1026
        { .i64 = PRORES_PROFILE_STANDARD },
Kostya Shishkov's avatar
Kostya Shishkov committed
1027
        PRORES_PROFILE_PROXY, PRORES_PROFILE_HQ, VE, "profile" },
1028
    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
Kostya Shishkov's avatar
Kostya Shishkov committed
1029
        0, 0, VE, "profile" },
1030
    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
Kostya Shishkov's avatar
Kostya Shishkov committed
1031
        0, 0, VE, "profile" },
1032
    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
Kostya Shishkov's avatar
Kostya Shishkov committed
1033
        0, 0, VE, "profile" },
1034
    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
Kostya Shishkov's avatar
Kostya Shishkov committed
1035
        0, 0, VE, "profile" },
1036 1037 1038
    { "vendor", "vendor ID", OFFSET(vendor),
        AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
    { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
1039
        AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
1040
    { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
1041
        { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
1042
    { "auto",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
1043
        0, 0, VE, "quant_mat" },
1044
    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
1045
        0, 0, VE, "quant_mat" },
1046
    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
1047
        0, 0, VE, "quant_mat" },
1048
    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
1049
        0, 0, VE, "quant_mat" },
1050
    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
1051
        0, 0, VE, "quant_mat" },
1052
    { "default",       NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
1053
        0, 0, VE, "quant_mat" },
Kostya Shishkov's avatar
Kostya Shishkov committed
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
    { NULL }
};

static const AVClass proresenc_class = {
    .class_name = "ProRes encoder",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVCodec ff_prores_encoder = {
    .name           = "prores",
    .type           = AVMEDIA_TYPE_VIDEO,
1067
    .id             = AV_CODEC_ID_PRORES,
Kostya Shishkov's avatar
Kostya Shishkov committed
1068 1069 1070 1071
    .priv_data_size = sizeof(ProresContext),
    .init           = encode_init,
    .close          = encode_close,
    .encode2        = encode_frame,
1072
    .capabilities   = CODEC_CAP_SLICE_THREADS,
Kostya Shishkov's avatar
Kostya Shishkov committed
1073 1074 1075 1076 1077 1078
    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
    .pix_fmts       = (const enum PixelFormat[]) {
                          PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_NONE
                      },
    .priv_class     = &proresenc_class,
};