libavcodec/vc2enc.c

   1 /*
   2  * Copyright (C) 2016 Open Broadcast Systems Ltd.
   3  * Author        2016 Rostislav Pehlivanov <atomnuker@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/pixdesc.h"
  23 #include "libavutil/opt.h"
  24 #include "dirac.h"
  25 #include "put_bits.h"
  26 #include "internal.h"
  27 #include "version.h"
  28
  29 #include "vc2enc_dwt.h"
  30 #include "diractab.h"
  31
  32 /* Quantizations above this usually zero coefficients and lower the quality */
  33 #define MAX_QUANT_INDEX FF_ARRAY_ELEMS(ff_dirac_qscale_tab)
  34
  35 /* Total range is -COEF_LUT_TAB to +COEFF_LUT_TAB, but total tab size is half
  36  * (COEF_LUT_TAB*MAX_QUANT_INDEX) since the sign is appended during encoding */
  37 #define COEF_LUT_TAB 2048
  38
  39 /* The limited size resolution of each slice forces us to do this */
  40 #define SSIZE_ROUND(b) (FFALIGN((b), s->size_scaler) + 4 + s->prefix_bytes)
  41
  42 /* Decides the cutoff point in # of slices to distribute the leftover bytes */
  43 #define SLICE_REDIST_TOTAL 150
  44
  45 typedef struct VC2BaseVideoFormat {
  46     enum AVPixelFormat pix_fmt;
  47     AVRational time_base;
  48     int width, height, interlaced, level;
  49     const char *name;
  50 } VC2BaseVideoFormat;
  51
  52 static const VC2BaseVideoFormat base_video_fmts[] = {
  53     { 0 }, /* Custom format, here just to make indexing equal to base_vf */
  54     { AV_PIX_FMT_YUV420P,   { 1001, 15000 },  176,  120, 0, 1,     "QSIF525" },
  55     { AV_PIX_FMT_YUV420P,   {    2,    25 },  176,  144, 0, 1,     "QCIF"    },
  56     { AV_PIX_FMT_YUV420P,   { 1001, 15000 },  352,  240, 0, 1,     "SIF525"  },
  57     { AV_PIX_FMT_YUV420P,   {    2,    25 },  352,  288, 0, 1,     "CIF"     },
  58     { AV_PIX_FMT_YUV420P,   { 1001, 15000 },  704,  480, 0, 1,     "4SIF525" },
  59     { AV_PIX_FMT_YUV420P,   {    2,    25 },  704,  576, 0, 1,     "4CIF"    },
  60
  61     { AV_PIX_FMT_YUV422P10, { 1001, 30000 },  720,  480, 1, 2,   "SD480I-60" },
  62     { AV_PIX_FMT_YUV422P10, {    1,    25 },  720,  576, 1, 2,   "SD576I-50" },
  63
  64     { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1280,  720, 0, 3,  "HD720P-60"  },
  65     { AV_PIX_FMT_YUV422P10, {    1,    50 }, 1280,  720, 0, 3,  "HD720P-50"  },
  66     { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 1920, 1080, 1, 3,  "HD1080I-60" },
  67     { AV_PIX_FMT_YUV422P10, {    1,    25 }, 1920, 1080, 1, 3,  "HD1080I-50" },
  68     { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1920, 1080, 1, 3,  "HD1080P-60" },
  69     { AV_PIX_FMT_YUV422P10, {    1,    50 }, 1920, 1080, 1, 3,  "HD1080P-50" },
  70
  71     { AV_PIX_FMT_YUV444P12, {    1,    24 }, 2048, 1080, 0, 4,        "DC2K" },
  72     { AV_PIX_FMT_YUV444P12, {    1,    24 }, 4096, 2160, 0, 5,        "DC4K" },
  73
  74     { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 3840, 2160, 0, 6, "UHDTV 4K-60" },
  75     { AV_PIX_FMT_YUV422P10, {    1,    50 }, 3840, 2160, 0, 6, "UHDTV 4K-50" },
  76
  77     { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 7680, 4320, 0, 7, "UHDTV 8K-60" },
  78     { AV_PIX_FMT_YUV422P10, {    1,    50 }, 7680, 4320, 0, 7, "UHDTV 8K-50" },
  79
  80     { AV_PIX_FMT_YUV422P10, { 1001, 24000 }, 1920, 1080, 0, 3,  "HD1080P-24" },
  81     { AV_PIX_FMT_YUV422P10, { 1001, 30000 },  720,  486, 1, 2,  "SD Pro486"  },
  82 };
  83 static const int base_video_fmts_len = FF_ARRAY_ELEMS(base_video_fmts);
  84
  85 enum VC2_QM {
  86     VC2_QM_DEF = 0,
  87     VC2_QM_COL,
  88     VC2_QM_FLAT,
  89
  90     VC2_QM_NB
  91 };
  92
  93 typedef struct SubBand {
  94     dwtcoef *buf;
  95     ptrdiff_t stride;
  96     int width;
  97     int height;
  98 } SubBand;
  99
 100 typedef struct Plane {
 101     SubBand band[MAX_DWT_LEVELS][4];
 102     dwtcoef *coef_buf;
 103     int width;
 104     int height;
 105     int dwt_width;
 106     int dwt_height;
 107     ptrdiff_t coef_stride;
 108 } Plane;
 109
 110 typedef struct SliceArgs {
 111     PutBitContext pb;
 112     int cache[MAX_QUANT_INDEX];
 113     void *ctx;
 114     int x;
 115     int y;
 116     int quant_idx;
 117     int bits_ceil;
 118     int bits_floor;
 119     int bytes;
 120 } SliceArgs;
 121
 122 typedef struct TransformArgs {
 123     void *ctx;
 124     Plane *plane;
 125     void *idata;
 126     ptrdiff_t istride;
 127     int field;
 128     VC2TransformContext t;
 129 } TransformArgs;
 130
 131 typedef struct VC2EncContext {
 132     AVClass *av_class;
 133     PutBitContext pb;
 134     Plane plane[3];
 135     AVCodecContext *avctx;
 136     DiracVersionInfo ver;
 137
 138     SliceArgs *slice_args;
 139     TransformArgs transform_args[3];
 140
 141     /* For conversion from unsigned pixel values to signed */
 142     int diff_offset;
 143     int bpp;
 144     int bpp_idx;
 145
 146     /* Picture number */
 147     uint32_t picture_number;
 148
 149     /* Base video format */
 150     int base_vf;
 151     int level;
 152     int profile;
 153
 154     /* Quantization matrix */
 155     uint8_t quant[MAX_DWT_LEVELS][4];
 156     int custom_quant_matrix;
 157
 158     /* Coefficient LUT */
 159     uint32_t *coef_lut_val;
 160     uint8_t  *coef_lut_len;
 161
 162     int num_x; /* #slices horizontally */
 163     int num_y; /* #slices vertically */
 164     int prefix_bytes;
 165     int size_scaler;
 166     int chroma_x_shift;
 167     int chroma_y_shift;
 168
 169     /* Rate control stuff */
 170     int slice_max_bytes;
 171     int slice_min_bytes;
 172     int q_ceil;
 173     int q_avg;
 174
 175     /* Options */
 176     double tolerance;
 177     int wavelet_idx;
 178     int wavelet_depth;
 179     int strict_compliance;
 180     int slice_height;
 181     int slice_width;
 182     int interlaced;
 183     enum VC2_QM quant_matrix;
 184
 185     /* Parse code state */
 186     uint32_t next_parse_offset;
 187     enum DiracParseCodes last_parse_code;
 188 } VC2EncContext;
 189
 190 static av_always_inline void put_vc2_ue_uint(PutBitContext *pb, uint32_t val)
 191 {
 192     int i;
 193     int pbits = 0, bits = 0, topbit = 1, maxval = 1;
 194
 195     if (!val++) {
 196         put_bits(pb, 1, 1);
 197         return;
 198     }
 199
 200     while (val > maxval) {
 201         topbit <<= 1;
 202         maxval <<= 1;
 203         maxval |=  1;
 204     }
 205
 206     bits = ff_log2(topbit);
 207
 208     for (i = 0; i < bits; i++) {
 209         topbit >>= 1;
 210         pbits <<= 2;
 211         if (val & topbit)
 212             pbits |= 0x1;
 213     }
 214
 215     put_bits(pb, bits*2 + 1, (pbits << 1) | 1);
 216 }
 217
 218 static av_always_inline int count_vc2_ue_uint(uint32_t val)
 219 {
 220     int topbit = 1, maxval = 1;
 221
 222     if (!val++)
 223         return 1;
 224
 225     while (val > maxval) {
 226         topbit <<= 1;
 227         maxval <<= 1;
 228         maxval |=  1;
 229     }
 230
 231     return ff_log2(topbit)*2 + 1;
 232 }
 233
 234 static av_always_inline void get_vc2_ue_uint(int val, uint8_t *nbits,
 235                                              uint32_t *eval)
 236 {
 237     int i;
 238     int pbits = 0, bits = 0, topbit = 1, maxval = 1;
 239
 240     if (!val++) {
 241         *nbits = 1;
 242         *eval = 1;
 243         return;
 244     }
 245
 246     while (val > maxval) {
 247         topbit <<= 1;
 248         maxval <<= 1;
 249         maxval |=  1;
 250     }
 251
 252     bits = ff_log2(topbit);
 253
 254     for (i = 0; i < bits; i++) {
 255         topbit >>= 1;
 256         pbits <<= 2;
 257         if (val & topbit)
 258             pbits |= 0x1;
 259     }
 260
 261     *nbits = bits*2 + 1;
 262     *eval = (pbits << 1) | 1;
 263 }
 264
 265 /* VC-2 10.4 - parse_info() */
 266 static void encode_parse_info(VC2EncContext *s, enum DiracParseCodes pcode)
 267 {
 268     uint32_t cur_pos, dist;
 269
 270     avpriv_align_put_bits(&s->pb);
 271
 272     cur_pos = put_bits_count(&s->pb) >> 3;
 273
 274     /* Magic string */
 275     avpriv_put_string(&s->pb, "BBCD", 0);
 276
 277     /* Parse code */
 278     put_bits(&s->pb, 8, pcode);
 279
 280     /* Next parse offset */
 281     dist = cur_pos - s->next_parse_offset;
 282     AV_WB32(s->pb.buf + s->next_parse_offset + 5, dist);
 283     s->next_parse_offset = cur_pos;
 284     put_bits32(&s->pb, pcode == DIRAC_PCODE_END_SEQ ? 13 : 0);
 285
 286     /* Last parse offset */
 287     put_bits32(&s->pb, s->last_parse_code == DIRAC_PCODE_END_SEQ ? 13 : dist);
 288
 289     s->last_parse_code = pcode;
 290 }
 291
 292 /* VC-2 11.1 - parse_parameters()
 293  * The level dictates what the decoder should expect in terms of resolution
 294  * and allows it to quickly reject whatever it can't support. Remember,
 295  * this codec kinda targets cheapo FPGAs without much memory. Unfortunately
 296  * it also limits us greatly in our choice of formats, hence the flag to disable
 297  * strict_compliance */
 298 static void encode_parse_params(VC2EncContext *s)
 299 {
 300     put_vc2_ue_uint(&s->pb, s->ver.major); /* VC-2 demands this to be 2 */
 301     put_vc2_ue_uint(&s->pb, s->ver.minor); /* ^^ and this to be 0       */
 302     put_vc2_ue_uint(&s->pb, s->profile);   /* 3 to signal HQ profile    */
 303     put_vc2_ue_uint(&s->pb, s->level);     /* 3 - 1080/720, 6 - 4K      */
 304 }
 305
 306 /* VC-2 11.3 - frame_size() */
 307 static void encode_frame_size(VC2EncContext *s)
 308 {
 309     put_bits(&s->pb, 1, !s->strict_compliance);
 310     if (!s->strict_compliance) {
 311         AVCodecContext *avctx = s->avctx;
 312         put_vc2_ue_uint(&s->pb, avctx->width);
 313         put_vc2_ue_uint(&s->pb, avctx->height);
 314     }
 315 }
 316
 317 /* VC-2 11.3.3 - color_diff_sampling_format() */
 318 static void encode_sample_fmt(VC2EncContext *s)
 319 {
 320     put_bits(&s->pb, 1, !s->strict_compliance);
 321     if (!s->strict_compliance) {
 322         int idx;
 323         if (s->chroma_x_shift == 1 && s->chroma_y_shift == 0)
 324             idx = 1; /* 422 */
 325         else if (s->chroma_x_shift == 1 && s->chroma_y_shift == 1)
 326             idx = 2; /* 420 */
 327         else
 328             idx = 0; /* 444 */
 329         put_vc2_ue_uint(&s->pb, idx);
 330     }
 331 }
 332
 333 /* VC-2 11.3.4 - scan_format() */
 334 static void encode_scan_format(VC2EncContext *s)
 335 {
 336     put_bits(&s->pb, 1, !s->strict_compliance);
 337     if (!s->strict_compliance)
 338         put_vc2_ue_uint(&s->pb, s->interlaced);
 339 }
 340
 341 /* VC-2 11.3.5 - frame_rate() */
 342 static void encode_frame_rate(VC2EncContext *s)
 343 {
 344     put_bits(&s->pb, 1, !s->strict_compliance);
 345     if (!s->strict_compliance) {
 346         AVCodecContext *avctx = s->avctx;
 347         put_vc2_ue_uint(&s->pb, 0);
 348         put_vc2_ue_uint(&s->pb, avctx->time_base.den);
 349         put_vc2_ue_uint(&s->pb, avctx->time_base.num);
 350     }
 351 }
 352
 353 /* VC-2 11.3.6 - aspect_ratio() */
 354 static void encode_aspect_ratio(VC2EncContext *s)
 355 {
 356     put_bits(&s->pb, 1, !s->strict_compliance);
 357     if (!s->strict_compliance) {
 358         AVCodecContext *avctx = s->avctx;
 359         put_vc2_ue_uint(&s->pb, 0);
 360         put_vc2_ue_uint(&s->pb, avctx->sample_aspect_ratio.num);
 361         put_vc2_ue_uint(&s->pb, avctx->sample_aspect_ratio.den);
 362     }
 363 }
 364
 365 /* VC-2 11.3.7 - clean_area() */
 366 static void encode_clean_area(VC2EncContext *s)
 367 {
 368     put_bits(&s->pb, 1, 0);
 369 }
 370
 371 /* VC-2 11.3.8 - signal_range() */
 372 static void encode_signal_range(VC2EncContext *s)
 373 {
 374     put_bits(&s->pb, 1, !s->strict_compliance);
 375     if (!s->strict_compliance)
 376         put_vc2_ue_uint(&s->pb, s->bpp_idx);
 377 }
 378
 379 /* VC-2 11.3.9 - color_spec() */
 380 static void encode_color_spec(VC2EncContext *s)
 381 {
 382     AVCodecContext *avctx = s->avctx;
 383     put_bits(&s->pb, 1, !s->strict_compliance);
 384     if (!s->strict_compliance) {
 385         int val;
 386         put_vc2_ue_uint(&s->pb, 0);
 387
 388         /* primaries */
 389         put_bits(&s->pb, 1, 1);
 390         if (avctx->color_primaries == AVCOL_PRI_BT470BG)
 391             val = 2;
 392         else if (avctx->color_primaries == AVCOL_PRI_SMPTE170M)
 393             val = 1;
 394         else if (avctx->color_primaries == AVCOL_PRI_SMPTE240M)
 395             val = 1;
 396         else
 397             val = 0;
 398         put_vc2_ue_uint(&s->pb, val);
 399
 400         /* color matrix */
 401         put_bits(&s->pb, 1, 1);
 402         if (avctx->colorspace == AVCOL_SPC_RGB)
 403             val = 3;
 404         else if (avctx->colorspace == AVCOL_SPC_YCOCG)
 405             val = 2;
 406         else if (avctx->colorspace == AVCOL_SPC_BT470BG)
 407             val = 1;
 408         else
 409             val = 0;
 410         put_vc2_ue_uint(&s->pb, val);
 411
 412         /* transfer function */
 413         put_bits(&s->pb, 1, 1);
 414         if (avctx->color_trc == AVCOL_TRC_LINEAR)
 415             val = 2;
 416         else if (avctx->color_trc == AVCOL_TRC_BT1361_ECG)
 417             val = 1;
 418         else
 419             val = 0;
 420         put_vc2_ue_uint(&s->pb, val);
 421     }
 422 }
 423
 424 /* VC-2 11.3 - source_parameters() */
 425 static void encode_source_params(VC2EncContext *s)
 426 {
 427     encode_frame_size(s);
 428     encode_sample_fmt(s);
 429     encode_scan_format(s);
 430     encode_frame_rate(s);
 431     encode_aspect_ratio(s);
 432     encode_clean_area(s);
 433     encode_signal_range(s);
 434     encode_color_spec(s);
 435 }
 436
 437 /* VC-2 11 - sequence_header() */
 438 static void encode_seq_header(VC2EncContext *s)
 439 {
 440     avpriv_align_put_bits(&s->pb);
 441     encode_parse_params(s);
 442     put_vc2_ue_uint(&s->pb, s->base_vf);
 443     encode_source_params(s);
 444     put_vc2_ue_uint(&s->pb, s->interlaced); /* Frames or fields coding */
 445 }
 446
 447 /* VC-2 12.1 - picture_header() */
 448 static void encode_picture_header(VC2EncContext *s)
 449 {
 450     avpriv_align_put_bits(&s->pb);
 451     put_bits32(&s->pb, s->picture_number++);
 452 }
 453
 454 /* VC-2 12.3.4.1 - slice_parameters() */
 455 static void encode_slice_params(VC2EncContext *s)
 456 {
 457     put_vc2_ue_uint(&s->pb, s->num_x);
 458     put_vc2_ue_uint(&s->pb, s->num_y);
 459     put_vc2_ue_uint(&s->pb, s->prefix_bytes);
 460     put_vc2_ue_uint(&s->pb, s->size_scaler);
 461 }
 462
 463 /* 1st idx = LL, second - vertical, third - horizontal, fourth - total */
 464 const uint8_t vc2_qm_col_tab[][4] = {
 465     {20,  9, 15,  4},
 466     { 0,  6,  6,  4},
 467     { 0,  3,  3,  5},
 468     { 0,  3,  5,  1},
 469     { 0, 11, 10, 11}
 470 };
 471
 472 const uint8_t vc2_qm_flat_tab[][4] = {
 473     { 0,  0,  0,  0},
 474     { 0,  0,  0,  0},
 475     { 0,  0,  0,  0},
 476     { 0,  0,  0,  0},
 477     { 0,  0,  0,  0}
 478 };
 479
 480 static void init_quant_matrix(VC2EncContext *s)
 481 {
 482     int level, orientation;
 483
 484     if (s->wavelet_depth <= 4 && s->quant_matrix == VC2_QM_DEF) {
 485         s->custom_quant_matrix = 0;
 486         for (level = 0; level < s->wavelet_depth; level++) {
 487             s->quant[level][0] = ff_dirac_default_qmat[s->wavelet_idx][level][0];
 488             s->quant[level][1] = ff_dirac_default_qmat[s->wavelet_idx][level][1];
 489             s->quant[level][2] = ff_dirac_default_qmat[s->wavelet_idx][level][2];
 490             s->quant[level][3] = ff_dirac_default_qmat[s->wavelet_idx][level][3];
 491         }
 492         return;
 493     }
 494
 495     s->custom_quant_matrix = 1;
 496
 497     if (s->quant_matrix == VC2_QM_DEF) {
 498         for (level = 0; level < s->wavelet_depth; level++) {
 499             for (orientation = 0; orientation < 4; orientation++) {
 500                 if (level <= 3)
 501                     s->quant[level][orientation] = ff_dirac_default_qmat[s->wavelet_idx][level][orientation];
 502                 else
 503                     s->quant[level][orientation] = vc2_qm_col_tab[level][orientation];
 504             }
 505         }
 506     } else if (s->quant_matrix == VC2_QM_COL) {
 507         for (level = 0; level < s->wavelet_depth; level++) {
 508             for (orientation = 0; orientation < 4; orientation++) {
 509                 s->quant[level][orientation] = vc2_qm_col_tab[level][orientation];
 510             }
 511         }
 512     } else {
 513         for (level = 0; level < s->wavelet_depth; level++) {
 514             for (orientation = 0; orientation < 4; orientation++) {
 515                 s->quant[level][orientation] = vc2_qm_flat_tab[level][orientation];
 516             }
 517         }
 518     }
 519 }
 520
 521 /* VC-2 12.3.4.2 - quant_matrix() */
 522 static void encode_quant_matrix(VC2EncContext *s)
 523 {
 524     int level;
 525     put_bits(&s->pb, 1, s->custom_quant_matrix);
 526     if (s->custom_quant_matrix) {
 527         put_vc2_ue_uint(&s->pb, s->quant[0][0]);
 528         for (level = 0; level < s->wavelet_depth; level++) {
 529             put_vc2_ue_uint(&s->pb, s->quant[level][1]);
 530             put_vc2_ue_uint(&s->pb, s->quant[level][2]);
 531             put_vc2_ue_uint(&s->pb, s->quant[level][3]);
 532         }
 533     }
 534 }
 535
 536 /* VC-2 12.3 - transform_parameters() */
 537 static void encode_transform_params(VC2EncContext *s)
 538 {
 539     put_vc2_ue_uint(&s->pb, s->wavelet_idx);
 540     put_vc2_ue_uint(&s->pb, s->wavelet_depth);
 541
 542     encode_slice_params(s);
 543     encode_quant_matrix(s);
 544 }
 545
 546 /* VC-2 12.2 - wavelet_transform() */
 547 static void encode_wavelet_transform(VC2EncContext *s)
 548 {
 549     encode_transform_params(s);
 550     avpriv_align_put_bits(&s->pb);
 551 }
 552
 553 /* VC-2 12 - picture_parse() */
 554 static void encode_picture_start(VC2EncContext *s)
 555 {
 556     avpriv_align_put_bits(&s->pb);
 557     encode_picture_header(s);
 558     avpriv_align_put_bits(&s->pb);
 559     encode_wavelet_transform(s);
 560 }
 561
 562 #define QUANT(c, qf) (((c) << 2)/(qf))
 563
 564 /* VC-2 13.5.5.2 - slice_band() */
 565 static void encode_subband(VC2EncContext *s, PutBitContext *pb, int sx, int sy,
 566                            SubBand *b, int quant)
 567 {
 568     int x, y;
 569
 570     const int left   = b->width  * (sx+0) / s->num_x;
 571     const int right  = b->width  * (sx+1) / s->num_x;
 572     const int top    = b->height * (sy+0) / s->num_y;
 573     const int bottom = b->height * (sy+1) / s->num_y;
 574
 575     const int qfactor = ff_dirac_qscale_tab[quant];
 576     const uint8_t  *len_lut = &s->coef_lut_len[quant*COEF_LUT_TAB];
 577     const uint32_t *val_lut = &s->coef_lut_val[quant*COEF_LUT_TAB];
 578
 579     dwtcoef *coeff = b->buf + top * b->stride;
 580
 581     for (y = top; y < bottom; y++) {
 582         for (x = left; x < right; x++) {
 583             const int neg = coeff[x] < 0;
 584             uint32_t c_abs = FFABS(coeff[x]);
 585             if (c_abs < COEF_LUT_TAB) {
 586                 put_bits(pb, len_lut[c_abs], val_lut[c_abs] | neg);
 587             } else {
 588                 c_abs = QUANT(c_abs, qfactor);
 589                 put_vc2_ue_uint(pb, c_abs);
 590                 if (c_abs)
 591                     put_bits(pb, 1, neg);
 592             }
 593         }
 594         coeff += b->stride;
 595     }
 596 }
 597
 598 static int count_hq_slice(SliceArgs *slice, int quant_idx)
 599 {
 600     int x, y;
 601     uint8_t quants[MAX_DWT_LEVELS][4];
 602     int bits = 0, p, level, orientation;
 603     VC2EncContext *s = slice->ctx;
 604
 605     if (slice->cache[quant_idx])
 606         return slice->cache[quant_idx];
 607
 608     bits += 8*s->prefix_bytes;
 609     bits += 8; /* quant_idx */
 610
 611     for (level = 0; level < s->wavelet_depth; level++)
 612         for (orientation = !!level; orientation < 4; orientation++)
 613             quants[level][orientation] = FFMAX(quant_idx - s->quant[level][orientation], 0);
 614
 615     for (p = 0; p < 3; p++) {
 616         int bytes_start, bytes_len, pad_s, pad_c;
 617         bytes_start = bits >> 3;
 618         bits += 8;
 619         for (level = 0; level < s->wavelet_depth; level++) {
 620             for (orientation = !!level; orientation < 4; orientation++) {
 621                 SubBand *b = &s->plane[p].band[level][orientation];
 622
 623                 const int q_idx = quants[level][orientation];
 624                 const uint8_t *len_lut = &s->coef_lut_len[q_idx*COEF_LUT_TAB];
 625                 const int qfactor = ff_dirac_qscale_tab[q_idx];
 626
 627                 const int left   = b->width  * slice->x    / s->num_x;
 628                 const int right  = b->width  *(slice->x+1) / s->num_x;
 629                 const int top    = b->height * slice->y    / s->num_y;
 630                 const int bottom = b->height *(slice->y+1) / s->num_y;
 631
 632                 dwtcoef *buf = b->buf + top * b->stride;
 633
 634                 for (y = top; y < bottom; y++) {
 635                     for (x = left; x < right; x++) {
 636                         uint32_t c_abs = FFABS(buf[x]);
 637                         if (c_abs < COEF_LUT_TAB) {
 638                             bits += len_lut[c_abs];
 639                         } else {
 640                             c_abs = QUANT(c_abs, qfactor);
 641                             bits += count_vc2_ue_uint(c_abs);
 642                             bits += !!c_abs;
 643                         }
 644                     }
 645                     buf += b->stride;
 646                 }
 647             }
 648         }
 649         bits += FFALIGN(bits, 8) - bits;
 650         bytes_len = (bits >> 3) - bytes_start - 1;
 651         pad_s = FFALIGN(bytes_len, s->size_scaler)/s->size_scaler;
 652         pad_c = (pad_s*s->size_scaler) - bytes_len;
 653         bits += pad_c*8;
 654     }
 655
 656     slice->cache[quant_idx] = bits;
 657
 658     return bits;
 659 }
 660
 661 /* Approaches the best possible quantizer asymptotically, its kinda exaustive
 662  * but we have a LUT to get the coefficient size in bits. Guaranteed to never
 663  * overshoot, which is apparently very important when streaming */
 664 static int rate_control(AVCodecContext *avctx, void *arg)
 665 {
 666     SliceArgs *slice_dat = arg;
 667     VC2EncContext *s = slice_dat->ctx;
 668     const int top = slice_dat->bits_ceil;
 669     const int bottom = slice_dat->bits_floor;
 670     int quant_buf[2] = {-1, -1};
 671     int quant = slice_dat->quant_idx, step = 1;
 672     int bits_last, bits = count_hq_slice(slice_dat, quant);
 673     while ((bits > top) || (bits < bottom)) {
 674         const int signed_step = bits > top ? +step : -step;
 675         quant  = av_clip(quant + signed_step, 0, s->q_ceil-1);
 676         bits   = count_hq_slice(slice_dat, quant);
 677         if (quant_buf[1] == quant) {
 678             quant = FFMAX(quant_buf[0], quant);
 679             bits  = quant == quant_buf[0] ? bits_last : bits;
 680             break;
 681         }
 682         step         = av_clip(step/2, 1, (s->q_ceil-1)/2);
 683         quant_buf[1] = quant_buf[0];
 684         quant_buf[0] = quant;
 685         bits_last    = bits;
 686     }
 687     slice_dat->quant_idx = av_clip(quant, 0, s->q_ceil-1);
 688     slice_dat->bytes = SSIZE_ROUND(bits >> 3);
 689     return 0;
 690 }
 691
 692 static int calc_slice_sizes(VC2EncContext *s)
 693 {
 694     int i, j, slice_x, slice_y, bytes_left = 0;
 695     int bytes_top[SLICE_REDIST_TOTAL] = {0};
 696     int64_t total_bytes_needed = 0;
 697     int slice_redist_range = FFMIN(SLICE_REDIST_TOTAL, s->num_x*s->num_y);
 698     SliceArgs *enc_args = s->slice_args;
 699     SliceArgs *top_loc[SLICE_REDIST_TOTAL] = {NULL};
 700
 701     init_quant_matrix(s);
 702
 703     for (slice_y = 0; slice_y < s->num_y; slice_y++) {
 704         for (slice_x = 0; slice_x < s->num_x; slice_x++) {
 705             SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
 706             args->ctx = s;
 707             args->x   = slice_x;
 708             args->y   = slice_y;
 709             args->bits_ceil  = s->slice_max_bytes << 3;
 710             args->bits_floor = s->slice_min_bytes << 3;
 711             memset(args->cache, 0, s->q_ceil*sizeof(*args->cache));
 712         }
 713     }
 714
 715     /* First pass - determine baseline slice sizes w.r.t. max_slice_size */
 716     s->avctx->execute(s->avctx, rate_control, enc_args, NULL, s->num_x*s->num_y,
 717                       sizeof(SliceArgs));
 718
 719     for (i = 0; i < s->num_x*s->num_y; i++) {
 720         SliceArgs *args = &enc_args[i];
 721         bytes_left += s->slice_max_bytes - args->bytes;
 722         for (j = 0; j < slice_redist_range; j++) {
 723             if (args->bytes > bytes_top[j]) {
 724                 bytes_top[j] = args->bytes;
 725                 top_loc[j]   = args;
 726                 break;
 727             }
 728         }
 729     }
 730
 731     /* Second pass - distribute leftover bytes */
 732     while (1) {
 733         int distributed = 0;
 734         for (i = 0; i < slice_redist_range; i++) {
 735             SliceArgs *args;
 736             int bits, bytes, diff, prev_bytes, new_idx;
 737             if (bytes_left <= 0)
 738                 break;
 739             if (!top_loc[i] || !top_loc[i]->quant_idx)
 740                 break;
 741             args = top_loc[i];
 742             prev_bytes = args->bytes;
 743             new_idx = FFMAX(args->quant_idx - 1, 0);
 744             bits  = count_hq_slice(args, new_idx);
 745             bytes = SSIZE_ROUND(bits >> 3);
 746             diff  = bytes - prev_bytes;
 747             if ((bytes_left - diff) > 0) {
 748                 args->quant_idx = new_idx;
 749                 args->bytes = bytes;
 750                 bytes_left -= diff;
 751                 distributed++;
 752             }
 753         }
 754         if (!distributed)
 755             break;
 756     }
 757
 758     for (i = 0; i < s->num_x*s->num_y; i++) {
 759         SliceArgs *args = &enc_args[i];
 760         total_bytes_needed += args->bytes;
 761         s->q_avg = (s->q_avg + args->quant_idx)/2;
 762     }
 763
 764     return total_bytes_needed;
 765 }
 766
 767 /* VC-2 13.5.3 - hq_slice */
 768 static int encode_hq_slice(AVCodecContext *avctx, void *arg)
 769 {
 770     SliceArgs *slice_dat = arg;
 771     VC2EncContext *s = slice_dat->ctx;
 772     PutBitContext *pb = &slice_dat->pb;
 773     const int slice_x = slice_dat->x;
 774     const int slice_y = slice_dat->y;
 775     const int quant_idx = slice_dat->quant_idx;
 776     const int slice_bytes_max = slice_dat->bytes;
 777     uint8_t quants[MAX_DWT_LEVELS][4];
 778     int p, level, orientation;
 779
 780     skip_put_bytes(pb, s->prefix_bytes);
 781     put_bits(pb, 8, quant_idx);
 782
 783     /* Slice quantization (slice_quantizers() in the specs) */
 784     for (level = 0; level < s->wavelet_depth; level++)
 785         for (orientation = !!level; orientation < 4; orientation++)
 786             quants[level][orientation] = FFMAX(quant_idx - s->quant[level][orientation], 0);
 787
 788     /* Luma + 2 Chroma planes */
 789     for (p = 0; p < 3; p++) {
 790         int bytes_start, bytes_len, pad_s, pad_c;
 791         bytes_start = put_bits_count(pb) >> 3;
 792         put_bits(pb, 8, 0);
 793         for (level = 0; level < s->wavelet_depth; level++) {
 794             for (orientation = !!level; orientation < 4; orientation++) {
 795                 encode_subband(s, pb, slice_x, slice_y,
 796                                &s->plane[p].band[level][orientation],
 797                                quants[level][orientation]);
 798             }
 799         }
 800         avpriv_align_put_bits(pb);
 801         bytes_len = (put_bits_count(pb) >> 3) - bytes_start - 1;
 802         if (p == 2) {
 803             int len_diff = slice_bytes_max - (put_bits_count(pb) >> 3);
 804             pad_s = FFALIGN((bytes_len + len_diff), s->size_scaler)/s->size_scaler;
 805             pad_c = (pad_s*s->size_scaler) - bytes_len;
 806         } else {
 807             pad_s = FFALIGN(bytes_len, s->size_scaler)/s->size_scaler;
 808             pad_c = (pad_s*s->size_scaler) - bytes_len;
 809         }
 810         pb->buf[bytes_start] = pad_s;
 811         flush_put_bits(pb);
 812         skip_put_bytes(pb, pad_c);
 813     }
 814
 815     return 0;
 816 }
 817
 818 /* VC-2 13.5.1 - low_delay_transform_data() */
 819 static int encode_slices(VC2EncContext *s)
 820 {
 821     uint8_t *buf;
 822     int slice_x, slice_y, skip = 0;
 823     SliceArgs *enc_args = s->slice_args;
 824
 825     avpriv_align_put_bits(&s->pb);
 826     flush_put_bits(&s->pb);
 827     buf = put_bits_ptr(&s->pb);
 828
 829     for (slice_y = 0; slice_y < s->num_y; slice_y++) {
 830         for (slice_x = 0; slice_x < s->num_x; slice_x++) {
 831             SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
 832             init_put_bits(&args->pb, buf + skip, args->bytes+s->prefix_bytes);
 833             skip += args->bytes;
 834         }
 835     }
 836
 837     s->avctx->execute(s->avctx, encode_hq_slice, enc_args, NULL, s->num_x*s->num_y,
 838                       sizeof(SliceArgs));
 839
 840     skip_put_bytes(&s->pb, skip);
 841
 842     return 0;
 843 }
 844
 845 /*
 846  * Transform basics for a 3 level transform
 847  * |---------------------------------------------------------------------|
 848  * |  LL-0  | HL-0  |                 |                                  |
 849  * |--------|-------|      HL-1       |                                  |
 850  * |  LH-0  | HH-0  |                 |                                  |
 851  * |----------------|-----------------|              HL-2                |
 852  * |                |                 |                                  |
 853  * |     LH-1       |      HH-1       |                                  |
 854  * |                |                 |                                  |
 855  * |----------------------------------|----------------------------------|
 856  * |                                  |                                  |
 857  * |                                  |                                  |
 858  * |                                  |                                  |
 859  * |              LH-2                |              HH-2                |
 860  * |                                  |                                  |
 861  * |                                  |                                  |
 862  * |                                  |                                  |
 863  * |---------------------------------------------------------------------|
 864  *
 865  * DWT transforms are generally applied by splitting the image in two vertically
 866  * and applying a low pass transform on the left part and a corresponding high
 867  * pass transform on the right hand side. This is known as the horizontal filter
 868  * stage.
 869  * After that, the same operation is performed except the image is divided
 870  * horizontally, with the high pass on the lower and the low pass on the higher
 871  * side.
 872  * Therefore, you're left with 4 subdivisions - known as  low-low, low-high,
 873  * high-low and high-high. They're referred to as orientations in the decoder
 874  * and encoder.
 875  *
 876  * The LL (low-low) area contains the original image downsampled by the amount
 877  * of levels. The rest of the areas can be thought as the details needed
 878  * to restore the image perfectly to its original size.
 879  */
 880 static int dwt_plane(AVCodecContext *avctx, void *arg)
 881 {
 882     TransformArgs *transform_dat = arg;
 883     VC2EncContext *s = transform_dat->ctx;
 884     const void *frame_data = transform_dat->idata;
 885     const ptrdiff_t linesize = transform_dat->istride;
 886     const int field = transform_dat->field;
 887     const Plane *p = transform_dat->plane;
 888     VC2TransformContext *t = &transform_dat->t;
 889     dwtcoef *buf = p->coef_buf;
 890     const int idx = s->wavelet_idx;
 891     const int skip = 1 + s->interlaced;
 892
 893     int x, y, level, offset;
 894     ptrdiff_t pix_stride = linesize >> (s->bpp - 1);
 895
 896     if (field == 1) {
 897         offset = 0;
 898         pix_stride <<= 1;
 899     } else if (field == 2) {
 900         offset = pix_stride;
 901         pix_stride <<= 1;
 902     } else {
 903         offset = 0;
 904     }
 905
 906     if (s->bpp == 1) {
 907         const uint8_t *pix = (const uint8_t *)frame_data + offset;
 908         for (y = 0; y < p->height*skip; y+=skip) {
 909             for (x = 0; x < p->width; x++) {
 910                 buf[x] = pix[x] - s->diff_offset;
 911             }
 912             buf += p->coef_stride;
 913             pix += pix_stride;
 914         }
 915     } else {
 916         const uint16_t *pix = (const uint16_t *)frame_data + offset;
 917         for (y = 0; y < p->height*skip; y+=skip) {
 918             for (x = 0; x < p->width; x++) {
 919                 buf[x] = pix[x] - s->diff_offset;
 920             }
 921             buf += p->coef_stride;
 922             pix += pix_stride;
 923         }
 924     }
 925
 926     memset(buf, 0, p->coef_stride * (p->dwt_height - p->height) * sizeof(dwtcoef));
 927
 928     for (level = s->wavelet_depth-1; level >= 0; level--) {
 929         const SubBand *b = &p->band[level][0];
 930         t->vc2_subband_dwt[idx](t, p->coef_buf, p->coef_stride,
 931                                 b->width, b->height);
 932     }
 933
 934     return 0;
 935 }
 936
 937 static int encode_frame(VC2EncContext *s, AVPacket *avpkt, const AVFrame *frame,
 938                         const char *aux_data, const int header_size, int field)
 939 {
 940     int i, ret;
 941     int64_t max_frame_bytes;
 942
 943      /* Threaded DWT transform */
 944     for (i = 0; i < 3; i++) {
 945         s->transform_args[i].ctx   = s;
 946         s->transform_args[i].field = field;
 947         s->transform_args[i].plane = &s->plane[i];
 948         s->transform_args[i].idata = frame->data[i];
 949         s->transform_args[i].istride = frame->linesize[i];
 950     }
 951     s->avctx->execute(s->avctx, dwt_plane, s->transform_args, NULL, 3,
 952                       sizeof(TransformArgs));
 953
 954     /* Calculate per-slice quantizers and sizes */
 955     max_frame_bytes = header_size + calc_slice_sizes(s);
 956
 957     if (field < 2) {
 958         ret = ff_alloc_packet2(s->avctx, avpkt,
 959                                max_frame_bytes << s->interlaced,
 960                                max_frame_bytes << s->interlaced);
 961         if (ret) {
 962             av_log(s->avctx, AV_LOG_ERROR, "Error getting output packet.\n");
 963             return ret;
 964         }
 965         init_put_bits(&s->pb, avpkt->data, avpkt->size);
 966     }
 967
 968     /* Sequence header */
 969     encode_parse_info(s, DIRAC_PCODE_SEQ_HEADER);
 970     encode_seq_header(s);
 971
 972     /* Encoder version */
 973     if (aux_data) {
 974         encode_parse_info(s, DIRAC_PCODE_AUX);
 975         avpriv_put_string(&s->pb, aux_data, 1);
 976     }
 977
 978     /* Picture header */
 979     encode_parse_info(s, DIRAC_PCODE_PICTURE_HQ);
 980     encode_picture_start(s);
 981
 982     /* Encode slices */
 983     encode_slices(s);
 984
 985     /* End sequence */
 986     encode_parse_info(s, DIRAC_PCODE_END_SEQ);
 987
 988     return 0;
 989 }
 990
 991 static av_cold int vc2_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 992                                       const AVFrame *frame, int *got_packet)
 993 {
 994     int ret = 0;
 995     int sig_size = 256;
 996     VC2EncContext *s = avctx->priv_data;
 997     const char aux_data[] = LIBAVCODEC_IDENT;
 998     const int aux_data_size = sizeof(aux_data);
 999     const int header_size = 100 + aux_data_size;
1000     int64_t max_frame_bytes, r_bitrate = avctx->bit_rate >> (s->interlaced);
1001
1002     s->avctx = avctx;
1003     s->size_scaler = 2;
1004     s->prefix_bytes = 0;
1005     s->last_parse_code = 0;
1006     s->next_parse_offset = 0;
1007
1008     /* Rate control */
1009     max_frame_bytes = (av_rescale(r_bitrate, s->avctx->time_base.num,
1010                                   s->avctx->time_base.den) >> 3) - header_size;
1011     s->slice_max_bytes = av_rescale(max_frame_bytes, 1, s->num_x*s->num_y);
1012
1013     /* Find an appropriate size scaler */
1014     while (sig_size > 255) {
1015         int r_size = SSIZE_ROUND(s->slice_max_bytes);
1016         sig_size = r_size/s->size_scaler; /* Signalled slize size */
1017         s->size_scaler <<= 1;
1018     }
1019
1020     s->slice_max_bytes = SSIZE_ROUND(s->slice_max_bytes);
1021     s->slice_min_bytes = s->slice_max_bytes - s->slice_max_bytes*(s->tolerance/100.0f);
1022
1023     ret = encode_frame(s, avpkt, frame, aux_data, header_size, s->interlaced);
1024     if (ret)
1025         return ret;
1026     if (s->interlaced) {
1027         ret = encode_frame(s, avpkt, frame, aux_data, header_size, 2);
1028         if (ret)
1029             return ret;
1030     }
1031
1032     flush_put_bits(&s->pb);
1033     avpkt->size = put_bits_count(&s->pb) >> 3;
1034
1035     *got_packet = 1;
1036
1037     return 0;
1038 }
1039
1040 static av_cold int vc2_encode_end(AVCodecContext *avctx)
1041 {
1042     int i;
1043     VC2EncContext *s = avctx->priv_data;
1044
1045     av_log(avctx, AV_LOG_INFO, "Qavg: %i\n", s->q_avg);
1046
1047     for (i = 0; i < 3; i++) {
1048         ff_vc2enc_free_transforms(&s->transform_args[i].t);
1049         av_freep(&s->plane[i].coef_buf);
1050     }
1051
1052     av_freep(&s->slice_args);
1053     av_freep(&s->coef_lut_len);
1054     av_freep(&s->coef_lut_val);
1055
1056     return 0;
1057 }
1058
1059 static av_cold int vc2_encode_init(AVCodecContext *avctx)
1060 {
1061     Plane *p;
1062     SubBand *b;
1063     int i, j, level, o, shift;
1064     const AVPixFmtDescriptor *fmt = av_pix_fmt_desc_get(avctx->pix_fmt);
1065     const int depth = fmt->comp[0].depth;
1066     VC2EncContext *s = avctx->priv_data;
1067
1068     s->picture_number = 0;
1069
1070     /* Total allowed quantization range */
1071     s->q_ceil    = MAX_QUANT_INDEX;
1072
1073     s->ver.major = 2;
1074     s->ver.minor = 0;
1075     s->profile   = 3;
1076     s->level     = 3;
1077
1078     s->base_vf   = -1;
1079     s->strict_compliance = 1;
1080
1081     s->q_avg = 0;
1082     s->slice_max_bytes = 0;
1083     s->slice_min_bytes = 0;
1084
1085     /* Mark unknown as progressive */
1086     s->interlaced = !((avctx->field_order == AV_FIELD_UNKNOWN) ||
1087                       (avctx->field_order == AV_FIELD_PROGRESSIVE));
1088
1089     for (i = 0; i < base_video_fmts_len; i++) {
1090         const VC2BaseVideoFormat *fmt = &base_video_fmts[i];
1091         if (avctx->pix_fmt != fmt->pix_fmt)
1092             continue;
1093         if (avctx->time_base.num != fmt->time_base.num)
1094             continue;
1095         if (avctx->time_base.den != fmt->time_base.den)
1096             continue;
1097         if (avctx->width != fmt->width)
1098             continue;
1099         if (avctx->height != fmt->height)
1100             continue;
1101         if (s->interlaced != fmt->interlaced)
1102             continue;
1103         s->base_vf = i;
1104         s->level   = base_video_fmts[i].level;
1105         break;
1106     }
1107
1108     if (s->interlaced)
1109         av_log(avctx, AV_LOG_WARNING, "Interlacing enabled!\n");
1110
1111     if ((s->slice_width  & (s->slice_width  - 1)) ||
1112         (s->slice_height & (s->slice_height - 1))) {
1113         av_log(avctx, AV_LOG_ERROR, "Slice size is not a power of two!\n");
1114         return AVERROR_UNKNOWN;
1115     }
1116
1117     if ((s->slice_width > avctx->width) ||
1118         (s->slice_height > avctx->height)) {
1119         av_log(avctx, AV_LOG_ERROR, "Slice size is bigger than the image!\n");
1120         return AVERROR_UNKNOWN;
1121     }
1122
1123     if (s->base_vf <= 0) {
1124         if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
1125             s->strict_compliance = s->base_vf = 0;
1126             av_log(avctx, AV_LOG_WARNING, "Disabling strict compliance\n");
1127         } else {
1128             av_log(avctx, AV_LOG_WARNING, "Given format does not strictly comply with "
1129                    "the specifications, please add a -strict -1 flag to use it\n");
1130             return AVERROR_UNKNOWN;
1131         }
1132     } else {
1133         av_log(avctx, AV_LOG_INFO, "Selected base video format = %i (%s)\n",
1134                s->base_vf, base_video_fmts[s->base_vf].name);
1135     }
1136
1137     /* Chroma subsampling */
1138     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1139
1140     /* Bit depth and color range index */
1141     if (depth == 8 && avctx->color_range == AVCOL_RANGE_JPEG) {
1142         s->bpp = 1;
1143         s->bpp_idx = 1;
1144         s->diff_offset = 128;
1145     } else if (depth == 8 && (avctx->color_range == AVCOL_RANGE_MPEG ||
1146                avctx->color_range == AVCOL_RANGE_UNSPECIFIED)) {
1147         s->bpp = 1;
1148         s->bpp_idx = 2;
1149         s->diff_offset = 128;
1150     } else if (depth == 10) {
1151         s->bpp = 2;
1152         s->bpp_idx = 3;
1153         s->diff_offset = 512;
1154     } else {
1155         s->bpp = 2;
1156         s->bpp_idx = 4;
1157         s->diff_offset = 2048;
1158     }
1159
1160     /* Planes initialization */
1161     for (i = 0; i < 3; i++) {
1162         int w, h;
1163         p = &s->plane[i];
1164         p->width      = avctx->width  >> (i ? s->chroma_x_shift : 0);
1165         p->height     = avctx->height >> (i ? s->chroma_y_shift : 0);
1166         if (s->interlaced)
1167             p->height >>= 1;
1168         p->dwt_width  = w = FFALIGN(p->width,  (1 << s->wavelet_depth));
1169         p->dwt_height = h = FFALIGN(p->height, (1 << s->wavelet_depth));
1170         p->coef_stride = FFALIGN(p->dwt_width, 32);
1171         p->coef_buf = av_malloc(p->coef_stride*p->dwt_height*sizeof(dwtcoef));
1172         if (!p->coef_buf)
1173             goto alloc_fail;
1174         for (level = s->wavelet_depth-1; level >= 0; level--) {
1175             w = w >> 1;
1176             h = h >> 1;
1177             for (o = 0; o < 4; o++) {
1178                 b = &p->band[level][o];
1179                 b->width  = w;
1180                 b->height = h;
1181                 b->stride = p->coef_stride;
1182                 shift = (o > 1)*b->height*b->stride + (o & 1)*b->width;
1183                 b->buf = p->coef_buf + shift;
1184             }
1185         }
1186
1187         /* DWT init */
1188         if (ff_vc2enc_init_transforms(&s->transform_args[i].t,
1189                                       s->plane[i].coef_stride,
1190                                       s->plane[i].dwt_height))
1191             goto alloc_fail;
1192     }
1193
1194     /* Slices */
1195     s->num_x = s->plane[0].dwt_width/s->slice_width;
1196     s->num_y = s->plane[0].dwt_height/s->slice_height;
1197
1198     s->slice_args = av_calloc(s->num_x*s->num_y, sizeof(SliceArgs));
1199     if (!s->slice_args)
1200         goto alloc_fail;
1201
1202     /* Lookup tables */
1203     s->coef_lut_len = av_malloc(COEF_LUT_TAB*(s->q_ceil+1)*sizeof(*s->coef_lut_len));
1204     if (!s->coef_lut_len)
1205         goto alloc_fail;
1206
1207     s->coef_lut_val = av_malloc(COEF_LUT_TAB*(s->q_ceil+1)*sizeof(*s->coef_lut_val));
1208     if (!s->coef_lut_val)
1209         goto alloc_fail;
1210
1211     for (i = 0; i < s->q_ceil; i++) {
1212         uint8_t  *len_lut = &s->coef_lut_len[i*COEF_LUT_TAB];
1213         uint32_t *val_lut = &s->coef_lut_val[i*COEF_LUT_TAB];
1214         for (j = 0; j < COEF_LUT_TAB; j++) {
1215             get_vc2_ue_uint(QUANT(j, ff_dirac_qscale_tab[i]),
1216                             &len_lut[j], &val_lut[j]);
1217             if (len_lut[j] != 1) {
1218                 len_lut[j] += 1;
1219                 val_lut[j] <<= 1;
1220             } else {
1221                 val_lut[j] = 1;
1222             }
1223         }
1224     }
1225
1226     return 0;
1227
1228 alloc_fail:
1229     vc2_encode_end(avctx);
1230     av_log(avctx, AV_LOG_ERROR, "Unable to allocate memory!\n");
1231     return AVERROR(ENOMEM);
1232 }
1233
1234 #define VC2ENC_FLAGS (AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
1235 static const AVOption vc2enc_options[] = {
1236     {"tolerance",     "Max undershoot in percent", offsetof(VC2EncContext, tolerance), AV_OPT_TYPE_DOUBLE, {.dbl = 5.0f}, 0.0f, 45.0f, VC2ENC_FLAGS, "tolerance"},
1237     {"slice_width",   "Slice width",  offsetof(VC2EncContext, slice_width), AV_OPT_TYPE_INT, {.i64 = 64}, 32, 1024, VC2ENC_FLAGS, "slice_width"},
1238     {"slice_height",  "Slice height", offsetof(VC2EncContext, slice_height), AV_OPT_TYPE_INT, {.i64 = 32}, 8, 1024, VC2ENC_FLAGS, "slice_height"},
1239     {"wavelet_depth", "Transform depth", offsetof(VC2EncContext, wavelet_depth), AV_OPT_TYPE_INT, {.i64 = 4}, 1, 5, VC2ENC_FLAGS, "wavelet_depth"},
1240     {"wavelet_type",  "Transform type",  offsetof(VC2EncContext, wavelet_idx), AV_OPT_TYPE_INT, {.i64 = VC2_TRANSFORM_9_7}, 0, VC2_TRANSFORMS_NB, VC2ENC_FLAGS, "wavelet_idx"},
1241         {"9_7",          "Deslauriers-Dubuc (9,7)", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_9_7},    INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1242         {"5_3",          "LeGall (5,3)",            0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_5_3},    INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1243         {"haar",         "Haar (with shift)",       0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_HAAR_S}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1244         {"haar_noshift", "Haar (without shift)",    0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_HAAR},   INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1245     {"qm", "Custom quantization matrix", offsetof(VC2EncContext, quant_matrix), AV_OPT_TYPE_INT, {.i64 = VC2_QM_DEF}, 0, VC2_QM_NB, VC2ENC_FLAGS, "quant_matrix"},
1246         {"default",   "Default from the specifications", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_DEF}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1247         {"color",     "Prevents low bitrate discoloration", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_COL}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1248         {"flat",      "Optimize for PSNR", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_FLAT}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1249     {NULL}
1250 };
1251
1252 static const AVClass vc2enc_class = {
1253     .class_name = "SMPTE VC-2 encoder",
1254     .category = AV_CLASS_CATEGORY_ENCODER,
1255     .option = vc2enc_options,
1256     .item_name = av_default_item_name,
1257     .version = LIBAVUTIL_VERSION_INT
1258 };
1259
1260 static const AVCodecDefault vc2enc_defaults[] = {
1261     { "b",              "600000000"   },
1262     { NULL },
1263 };
1264
1265 static const enum AVPixelFormat allowed_pix_fmts[] = {
1266     AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV444P,
1267     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
1268     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
1269     AV_PIX_FMT_NONE
1270 };
1271
1272 AVCodec ff_vc2_encoder = {
1273     .name           = "vc2",
1274     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-2"),
1275     .type           = AVMEDIA_TYPE_VIDEO,
1276     .id             = AV_CODEC_ID_DIRAC,
1277     .priv_data_size = sizeof(VC2EncContext),
1278     .init           = vc2_encode_init,
1279     .close          = vc2_encode_end,
1280     .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
1281     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
1282     .encode2        = vc2_encode_frame,
1283     .priv_class     = &vc2enc_class,
1284     .defaults       = vc2enc_defaults,
1285     .pix_fmts       = allowed_pix_fmts
1286 };