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

   1 /*
   2  * NewTek SpeedHQ codec
   3  * Copyright 2017 Steinar H. Gunderson
   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 /**
  23  * @file
  24  * NewTek SpeedHQ decoder.
  25  */
  26
  27 #define BITSTREAM_READER_LE
  28
  29 #include "libavutil/attributes.h"
  30
  31 #include "avcodec.h"
  32 #include "get_bits.h"
  33 #include "internal.h"
  34 #include "libavutil/thread.h"
  35 #include "mathops.h"
  36 #include "mpeg12.h"
  37 #include "mpeg12data.h"
  38 #include "mpeg12vlc.h"
  39
  40 #define MAX_INDEX (64 - 1)
  41
  42 /*
  43  * 5 bits makes for very small tables, with no more than two lookups needed
  44  * for the longest (10-bit) codes.
  45  */
  46 #define ALPHA_VLC_BITS 5
  47
  48 typedef struct SHQContext {
  49     AVCodecContext *avctx;
  50     BlockDSPContext bdsp;
  51     IDCTDSPContext idsp;
  52     ScanTable intra_scantable;
  53     int quant_matrix[64];
  54     enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
  55         subsampling;
  56     enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
  57 } SHQContext;
  58
  59
  60 /* AC codes: Very similar but not identical to MPEG-2. */
  61 static const uint16_t speedhq_vlc[123][2] = {
  62     {0x0001,  2}, {0x0003,  3}, {0x000E,  4}, {0x0007,  5},
  63     {0x0017,  5}, {0x0028,  6}, {0x0008,  6}, {0x006F,  7},
  64     {0x001F,  7}, {0x00C4,  8}, {0x0044,  8}, {0x005F,  8},
  65     {0x00DF,  8}, {0x007F,  8}, {0x00FF,  8}, {0x3E00, 14},
  66     {0x1E00, 14}, {0x2E00, 14}, {0x0E00, 14}, {0x3600, 14},
  67     {0x1600, 14}, {0x2600, 14}, {0x0600, 14}, {0x3A00, 14},
  68     {0x1A00, 14}, {0x2A00, 14}, {0x0A00, 14}, {0x3200, 14},
  69     {0x1200, 14}, {0x2200, 14}, {0x0200, 14}, {0x0C00, 15},
  70     {0x7400, 15}, {0x3400, 15}, {0x5400, 15}, {0x1400, 15},
  71     {0x6400, 15}, {0x2400, 15}, {0x4400, 15}, {0x0400, 15},
  72     {0x0002,  3}, {0x000C,  5}, {0x004F,  7}, {0x00E4,  8},
  73     {0x0004,  8}, {0x0D00, 13}, {0x1500, 13}, {0x7C00, 15},
  74     {0x3C00, 15}, {0x5C00, 15}, {0x1C00, 15}, {0x6C00, 15},
  75     {0x2C00, 15}, {0x4C00, 15}, {0xC800, 16}, {0x4800, 16},
  76     {0x8800, 16}, {0x0800, 16}, {0x0300, 13}, {0x1D00, 13},
  77     {0x0014,  5}, {0x0070,  7}, {0x003F,  8}, {0x00C0, 10},
  78     {0x0500, 13}, {0x0180, 12}, {0x0280, 12}, {0x0C80, 12},
  79     {0x0080, 12}, {0x0B00, 13}, {0x1300, 13}, {0x001C,  5},
  80     {0x0064,  8}, {0x0380, 12}, {0x1900, 13}, {0x0D80, 12},
  81     {0x0018,  6}, {0x00BF,  8}, {0x0480, 12}, {0x0B80, 12},
  82     {0x0038,  6}, {0x0040,  9}, {0x0900, 13}, {0x0030,  7},
  83     {0x0780, 12}, {0x2800, 16}, {0x0010,  7}, {0x0A80, 12},
  84     {0x0050,  7}, {0x0880, 12}, {0x000F,  7}, {0x1100, 13},
  85     {0x002F,  7}, {0x0100, 13}, {0x0084,  8}, {0x5800, 16},
  86     {0x00A4,  8}, {0x9800, 16}, {0x0024,  8}, {0x1800, 16},
  87     {0x0140,  9}, {0xE800, 16}, {0x01C0,  9}, {0x6800, 16},
  88     {0x02C0, 10}, {0xA800, 16}, {0x0F80, 12}, {0x0580, 12},
  89     {0x0980, 12}, {0x0E80, 12}, {0x0680, 12}, {0x1F00, 13},
  90     {0x0F00, 13}, {0x1700, 13}, {0x0700, 13}, {0x1B00, 13},
  91     {0xF800, 16}, {0x7800, 16}, {0xB800, 16}, {0x3800, 16},
  92     {0xD800, 16},
  93     {0x0020,  6}, /* escape */
  94     {0x0006,  4}  /* EOB */
  95 };
  96
  97 static const uint8_t speedhq_level[121] = {
  98      1,  2,  3,  4,  5,  6,  7,  8,
  99      9, 10, 11, 12, 13, 14, 15, 16,
 100     17, 18, 19, 20, 21, 22, 23, 24,
 101     25, 26, 27, 28, 29, 30, 31, 32,
 102     33, 34, 35, 36, 37, 38, 39, 40,
 103      1,  2,  3,  4,  5,  6,  7,  8,
 104      9, 10, 11, 12, 13, 14, 15, 16,
 105     17, 18, 19, 20,  1,  2,  3,  4,
 106      5,  6,  7,  8,  9, 10, 11,  1,
 107      2,  3,  4,  5,  1,  2,  3,  4,
 108      1,  2,  3,  1,  2,  3,  1,  2,
 109      1,  2,  1,  2,  1,  2,  1,  2,
 110      1,  2,  1,  2,  1,  2,  1,  2,
 111      1,  2,  1,  1,  1,  1,  1,  1,
 112      1,  1,  1,  1,  1,  1,  1,  1,
 113      1,
 114 };
 115
 116 static const uint8_t speedhq_run[121] = {
 117      0,  0,  0,  0,  0,  0,  0,  0,
 118      0,  0,  0,  0,  0,  0,  0,  0,
 119      0,  0,  0,  0,  0,  0,  0,  0,
 120      0,  0,  0,  0,  0,  0,  0,  0,
 121      0,  0,  0,  0,  0,  0,  0,  0,
 122      1,  1,  1,  1,  1,  1,  1,  1,
 123      1,  1,  1,  1,  1,  1,  1,  1,
 124      1,  1,  1,  1,  2,  2,  2,  2,
 125      2,  2,  2,  2,  2,  2,  2,  3,
 126      3,  3,  3,  3,  4,  4,  4,  4,
 127      5,  5,  5,  6,  6,  6,  7,  7,
 128      8,  8,  9,  9, 10, 10, 11, 11,
 129     12, 12, 13, 13, 14, 14, 15, 15,
 130     16, 16, 17, 18, 19, 20, 21, 22,
 131     23, 24, 25, 26, 27, 28, 29, 30,
 132     31,
 133 };
 134
 135 static RLTable ff_rl_speedhq = {
 136     121,
 137     121,
 138     (const uint16_t (*)[])speedhq_vlc,
 139     speedhq_run,
 140     speedhq_level,
 141 };
 142
 143 /* NOTE: The first element is always 16, unscaled. */
 144 static const uint8_t unscaled_quant_matrix[64] = {
 145     16, 16, 19, 22, 26, 27, 29, 34,
 146     16, 16, 22, 24, 27, 29, 34, 37,
 147     19, 22, 26, 27, 29, 34, 34, 38,
 148     22, 22, 26, 27, 29, 34, 37, 40,
 149     22, 26, 27, 29, 32, 35, 40, 48,
 150     26, 27, 29, 32, 35, 40, 48, 58,
 151     26, 27, 29, 34, 38, 46, 56, 69,
 152     27, 29, 35, 38, 46, 56, 69, 83
 153 };
 154
 155 static uint8_t ff_speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
 156
 157 static VLC ff_dc_lum_vlc_le;
 158 static VLC ff_dc_chroma_vlc_le;
 159 static VLC ff_dc_alpha_run_vlc_le;
 160 static VLC ff_dc_alpha_level_vlc_le;
 161
 162 static inline int decode_dc_le(GetBitContext *gb, int component)
 163 {
 164     int code, diff;
 165
 166     if (component == 0 || component == 3) {
 167         code = get_vlc2(gb, ff_dc_lum_vlc_le.table, DC_VLC_BITS, 2);
 168     } else {
 169         code = get_vlc2(gb, ff_dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
 170     }
 171     if (code < 0) {
 172         av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
 173         return 0xffff;
 174     }
 175     if (!code) {
 176         diff = 0;
 177     } else {
 178         diff = get_xbits_le(gb, code);
 179     }
 180     return diff;
 181 }
 182
 183 static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
 184 {
 185     uint8_t block[128];
 186     int i = 0, x, y;
 187
 188     memset(block, 0, sizeof(block));
 189
 190     {
 191         OPEN_READER(re, gb);
 192
 193         for ( ;; ) {
 194             int run, level;
 195
 196             UPDATE_CACHE_LE(re, gb);
 197             GET_VLC(run, re, gb, ff_dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
 198
 199             if (run < 0) break;
 200             i += run;
 201             if (i >= 128)
 202                 return AVERROR_INVALIDDATA;
 203
 204             UPDATE_CACHE_LE(re, gb);
 205             GET_VLC(level, re, gb, ff_dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
 206             block[i++] = level;
 207         }
 208
 209         CLOSE_READER(re, gb);
 210     }
 211
 212     for (y = 0; y < 8; y++) {
 213         for (x = 0; x < 16; x++) {
 214             last_alpha[x] -= block[y * 16 + x];
 215         }
 216         memcpy(dest, last_alpha, 16);
 217         dest += linesize;
 218     }
 219
 220     return 0;
 221 }
 222
 223 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
 224 {
 225     const int *quant_matrix = s->quant_matrix;
 226     const uint8_t *scantable = s->intra_scantable.permutated;
 227     LOCAL_ALIGNED_32(int16_t, block, [64]);
 228     int dc_offset;
 229
 230     s->bdsp.clear_block(block);
 231
 232     dc_offset = decode_dc_le(gb, component);
 233     last_dc[component] -= dc_offset;  /* Note: Opposite of most codecs. */
 234     block[scantable[0]] = last_dc[component];  /* quant_matrix[0] is always 16. */
 235
 236     /* Read AC coefficients. */
 237     {
 238         int i = 0;
 239         OPEN_READER(re, gb);
 240         for ( ;; ) {
 241             int level, run;
 242             UPDATE_CACHE_LE(re, gb);
 243             GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
 244                        TEX_VLC_BITS, 2, 0);
 245             if (level == 127) {
 246                 break;
 247             } else if (level) {
 248                 i += run;
 249                 if (i > MAX_INDEX)
 250                     return AVERROR_INVALIDDATA;
 251                 /* If next bit is 1, level = -level */
 252                 level = (level ^ SHOW_SBITS(re, gb, 1)) -
 253                         SHOW_SBITS(re, gb, 1);
 254                 LAST_SKIP_BITS(re, gb, 1);
 255             } else {
 256                 /* Escape. */
 257 #if MIN_CACHE_BITS < 6 + 6 + 12
 258 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
 259 #endif
 260                 run = SHOW_UBITS(re, gb, 6) + 1;
 261                 SKIP_BITS(re, gb, 6);
 262                 level = SHOW_UBITS(re, gb, 12) - 2048;
 263                 LAST_SKIP_BITS(re, gb, 12);
 264
 265                 i += run;
 266                 if (i > MAX_INDEX)
 267                     return AVERROR_INVALIDDATA;
 268             }
 269
 270             block[scantable[i]] = (level * quant_matrix[i]) >> 4;
 271         }
 272         CLOSE_READER(re, gb);
 273     }
 274
 275     s->idsp.idct_put(dest, linesize, block);
 276
 277     return 0;
 278 }
 279
 280 static int decode_speedhq_field(const SHQContext *s, const uint8_t *buf, int buf_size, AVFrame *frame, int field_number, int start, int end, int line_stride)
 281 {
 282     int ret, slice_number, slice_offsets[5];
 283     int linesize_y  = frame->linesize[0] * line_stride;
 284     int linesize_cb = frame->linesize[1] * line_stride;
 285     int linesize_cr = frame->linesize[2] * line_stride;
 286     int linesize_a;
 287
 288     if (s->alpha_type != SHQ_NO_ALPHA)
 289         linesize_a = frame->linesize[3] * line_stride;
 290
 291     if (end < start || end - start < 3 || end > buf_size)
 292         return AVERROR_INVALIDDATA;
 293
 294     slice_offsets[0] = start;
 295     slice_offsets[4] = end;
 296     for (slice_number = 1; slice_number < 4; slice_number++) {
 297         uint32_t last_offset, slice_len;
 298
 299         last_offset = slice_offsets[slice_number - 1];
 300         slice_len = AV_RL24(buf + last_offset);
 301         slice_offsets[slice_number] = last_offset + slice_len;
 302
 303         if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
 304             return AVERROR_INVALIDDATA;
 305     }
 306
 307     for (slice_number = 0; slice_number < 4; slice_number++) {
 308         GetBitContext gb;
 309         uint32_t slice_begin, slice_end;
 310         int x, y;
 311
 312         slice_begin = slice_offsets[slice_number];
 313         slice_end = slice_offsets[slice_number + 1];
 314
 315         if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
 316             return ret;
 317
 318         for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
 319             uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
 320             int last_dc[4] = { 1024, 1024, 1024, 1024 };
 321             uint8_t last_alpha[16];
 322
 323             memset(last_alpha, 255, sizeof(last_alpha));
 324
 325             dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
 326             if (s->subsampling == SHQ_SUBSAMPLING_420) {
 327                 dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
 328                 dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
 329             } else {
 330                 dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
 331                 dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
 332             }
 333             if (s->alpha_type != SHQ_NO_ALPHA) {
 334                 dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
 335             }
 336
 337             for (x = 0; x < frame->width; x += 16) {
 338                 /* Decode the four luma blocks. */
 339                 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
 340                     return ret;
 341                 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
 342                     return ret;
 343                 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
 344                     return ret;
 345                 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
 346                     return ret;
 347
 348                 /*
 349                  * Decode the first chroma block. For 4:2:0, this is the only one;
 350                  * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
 351                  */
 352                 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
 353                     return ret;
 354                 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
 355                     return ret;
 356
 357                 if (s->subsampling != SHQ_SUBSAMPLING_420) {
 358                     /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
 359                     if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
 360                         return ret;
 361                     if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
 362                         return ret;
 363
 364                     if (s->subsampling == SHQ_SUBSAMPLING_444) {
 365                         /* Top-right and bottom-right blocks. */
 366                         if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
 367                             return ret;
 368                         if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
 369                             return ret;
 370                         if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
 371                             return ret;
 372                         if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
 373                             return ret;
 374
 375                         dest_cb += 8;
 376                         dest_cr += 8;
 377                     }
 378                 }
 379                 dest_y += 16;
 380                 dest_cb += 8;
 381                 dest_cr += 8;
 382
 383                 if (s->alpha_type == SHQ_RLE_ALPHA) {
 384                     /* Alpha coded using 16x8 RLE blocks. */
 385                     if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
 386                         return ret;
 387                     if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
 388                         return ret;
 389                     dest_a += 16;
 390                 } else if (s->alpha_type == SHQ_DCT_ALPHA) {
 391                     /* Alpha encoded exactly like luma. */
 392                     if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
 393                         return ret;
 394                     if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
 395                         return ret;
 396                     if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
 397                         return ret;
 398                     if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
 399                         return ret;
 400                     dest_a += 16;
 401                 }
 402             }
 403         }
 404     }
 405
 406     return 0;
 407 }
 408
 409 static void compute_quant_matrix(int *output, int qscale)
 410 {
 411     int i;
 412     for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
 413 }
 414
 415 static int speedhq_decode_frame(AVCodecContext *avctx,
 416                                 void *data, int *got_frame,
 417                                 AVPacket *avpkt)
 418 {
 419     SHQContext * const s = avctx->priv_data;
 420     const uint8_t *buf   = avpkt->data;
 421     int buf_size         = avpkt->size;
 422     AVFrame *frame       = data;
 423     uint8_t quality;
 424     uint32_t second_field_offset;
 425     int ret;
 426
 427     if (buf_size < 4)
 428         return AVERROR_INVALIDDATA;
 429
 430     quality = buf[0];
 431     if (quality >= 100) {
 432         return AVERROR_INVALIDDATA;
 433     }
 434
 435     compute_quant_matrix(s->quant_matrix, 100 - quality);
 436
 437     second_field_offset = AV_RL24(buf + 1);
 438     if (second_field_offset >= buf_size - 3) {
 439         return AVERROR_INVALIDDATA;
 440     }
 441
 442     avctx->coded_width = FFALIGN(avctx->width, 16);
 443     avctx->coded_height = FFALIGN(avctx->height, 16);
 444
 445     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 446         return ret;
 447     }
 448     frame->key_frame = 1;
 449
 450     if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
 451         /*
 452          * Overlapping first and second fields is used to signal
 453          * encoding only a single field. In this case, "height"
 454          * is ambiguous; it could mean either the height of the
 455          * frame as a whole, or of the field. The former would make
 456          * more sense for compatibility with legacy decoders,
 457          * but this matches the convention used in NDI, which is
 458          * the primary user of this trick.
 459          */
 460         if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
 461             return ret;
 462     } else {
 463         if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
 464             return ret;
 465         if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
 466             return ret;
 467     }
 468
 469     *got_frame = 1;
 470     return buf_size;
 471 }
 472
 473 /*
 474  * Alpha VLC. Run and level are independently coded, and would be
 475  * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
 476  * bother with combining them into one table.
 477  */
 478 static av_cold void compute_alpha_vlcs(void)
 479 {
 480     uint16_t run_code[134], level_code[266];
 481     uint8_t run_bits[134], level_bits[266];
 482     int16_t run_symbols[134], level_symbols[266];
 483     int entry, i, sign;
 484
 485     /* Initialize VLC for alpha run. */
 486     entry = 0;
 487
 488     /* 0 -> 0. */
 489     run_code[entry] = 0;
 490     run_bits[entry] = 1;
 491     run_symbols[entry] = 0;
 492     ++entry;
 493
 494     /* 10xx -> xx plus 1. */
 495     for (i = 0; i < 4; ++i) {
 496         run_code[entry] = (i << 2) | 1;
 497         run_bits[entry] = 4;
 498         run_symbols[entry] = i + 1;
 499         ++entry;
 500     }
 501
 502     /* 111xxxxxxx -> xxxxxxx. */
 503     for (i = 0; i < 128; ++i) {
 504         run_code[entry] = (i << 3) | 7;
 505         run_bits[entry] = 10;
 506         run_symbols[entry] = i;
 507         ++entry;
 508     }
 509
 510     /* 110 -> EOB. */
 511     run_code[entry] = 3;
 512     run_bits[entry] = 3;
 513     run_symbols[entry] = -1;
 514     ++entry;
 515
 516     av_assert0(entry == FF_ARRAY_ELEMS(run_code));
 517
 518     INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
 519                               FF_ARRAY_ELEMS(run_code),
 520                               run_bits, 1, 1,
 521                               run_code, 2, 2,
 522                               run_symbols, 2, 2, 160);
 523
 524     /* Initialize VLC for alpha level. */
 525     entry = 0;
 526
 527     for (sign = 0; sign <= 1; ++sign) {
 528         /* 1s -> -1 or +1 (depending on sign bit). */
 529         level_code[entry] = (sign << 1) | 1;
 530         level_bits[entry] = 2;
 531         level_symbols[entry] = sign ? -1 : 1;
 532         ++entry;
 533
 534         /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
 535         for (i = 0; i < 4; ++i) {
 536             level_code[entry] = (i << 3) | (sign << 2) | 2;
 537             level_bits[entry] = 5;
 538             level_symbols[entry] = sign ? -(i + 2) : (i + 2);
 539             ++entry;
 540         }
 541     }
 542
 543     /*
 544      * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
 545      * here that would better be encoded in other ways (e.g. 0 would be
 546      * encoded by increasing run, and +/- 1 would be encoded with a
 547      * shorter code), but it doesn't hurt to allow everything.
 548      */
 549     for (i = 0; i < 256; ++i) {
 550         level_code[entry] = i << 2;
 551         level_bits[entry] = 10;
 552         level_symbols[entry] = i;
 553         ++entry;
 554     }
 555
 556     av_assert0(entry == FF_ARRAY_ELEMS(level_code));
 557
 558     INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
 559                               FF_ARRAY_ELEMS(level_code),
 560                               level_bits, 1, 1,
 561                               level_code, 2, 2,
 562                               level_symbols, 2, 2, 288);
 563 }
 564
 565 static uint32_t reverse(uint32_t num, int bits)
 566 {
 567     return bitswap_32(num) >> (32 - bits);
 568 }
 569
 570 static void reverse_code(const uint16_t *code, const uint8_t *bits,
 571                          uint16_t *reversed_code, int num_entries)
 572 {
 573     int i;
 574     for (i = 0; i < num_entries; i++) {
 575         reversed_code[i] = reverse(code[i], bits[i]);
 576     }
 577 }
 578
 579 static av_cold void speedhq_static_init(void)
 580 {
 581     uint16_t ff_mpeg12_vlc_dc_lum_code_reversed[12];
 582     uint16_t ff_mpeg12_vlc_dc_chroma_code_reversed[12];
 583
 584     /* Exactly the same as MPEG-2, except little-endian. */
 585     reverse_code(ff_mpeg12_vlc_dc_lum_code,
 586                  ff_mpeg12_vlc_dc_lum_bits,
 587                  ff_mpeg12_vlc_dc_lum_code_reversed,
 588                  12);
 589     INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
 590                        ff_mpeg12_vlc_dc_lum_bits, 1, 1,
 591                        ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
 592     reverse_code(ff_mpeg12_vlc_dc_chroma_code,
 593                  ff_mpeg12_vlc_dc_chroma_bits,
 594                  ff_mpeg12_vlc_dc_chroma_code_reversed,
 595                  12);
 596     INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
 597                        ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
 598                        ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
 599
 600     ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
 601     INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
 602
 603     compute_alpha_vlcs();
 604 }
 605
 606 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
 607 {
 608     int ret;
 609     static AVOnce init_once = AV_ONCE_INIT;
 610     SHQContext * const s = avctx->priv_data;
 611
 612     s->avctx = avctx;
 613
 614     ret = ff_thread_once(&init_once, speedhq_static_init);
 615     if (ret)
 616         return AVERROR_UNKNOWN;
 617
 618     ff_blockdsp_init(&s->bdsp, avctx);
 619     ff_idctdsp_init(&s->idsp, avctx);
 620     ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
 621
 622     switch (avctx->codec_tag) {
 623     case MKTAG('S', 'H', 'Q', '0'):
 624         s->subsampling = SHQ_SUBSAMPLING_420;
 625         s->alpha_type = SHQ_NO_ALPHA;
 626         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 627         break;
 628     case MKTAG('S', 'H', 'Q', '1'):
 629         s->subsampling = SHQ_SUBSAMPLING_420;
 630         s->alpha_type = SHQ_RLE_ALPHA;
 631         avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 632         break;
 633     case MKTAG('S', 'H', 'Q', '2'):
 634         s->subsampling = SHQ_SUBSAMPLING_422;
 635         s->alpha_type = SHQ_NO_ALPHA;
 636         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 637         break;
 638     case MKTAG('S', 'H', 'Q', '3'):
 639         s->subsampling = SHQ_SUBSAMPLING_422;
 640         s->alpha_type = SHQ_RLE_ALPHA;
 641         avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 642         break;
 643     case MKTAG('S', 'H', 'Q', '4'):
 644         s->subsampling = SHQ_SUBSAMPLING_444;
 645         s->alpha_type = SHQ_NO_ALPHA;
 646         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 647         break;
 648     case MKTAG('S', 'H', 'Q', '5'):
 649         s->subsampling = SHQ_SUBSAMPLING_444;
 650         s->alpha_type = SHQ_RLE_ALPHA;
 651         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 652         break;
 653     case MKTAG('S', 'H', 'Q', '7'):
 654         s->subsampling = SHQ_SUBSAMPLING_422;
 655         s->alpha_type = SHQ_DCT_ALPHA;
 656         avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 657         break;
 658     case MKTAG('S', 'H', 'Q', '9'):
 659         s->subsampling = SHQ_SUBSAMPLING_444;
 660         s->alpha_type = SHQ_DCT_ALPHA;
 661         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 662         break;
 663     default:
 664         av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
 665                avctx->codec_tag);
 666         return AVERROR_INVALIDDATA;
 667     }
 668
 669     /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
 670     avctx->colorspace = AVCOL_SPC_BT470BG;
 671     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
 672
 673     return 0;
 674 }
 675
 676 AVCodec ff_speedhq_decoder = {
 677     .name           = "speedhq",
 678     .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
 679     .type           = AVMEDIA_TYPE_VIDEO,
 680     .id             = AV_CODEC_ID_SPEEDHQ,
 681     .priv_data_size = sizeof(SHQContext),
 682     .init           = speedhq_decode_init,
 683     .decode         = speedhq_decode_frame,
 684     .capabilities   = AV_CODEC_CAP_DR1,
 685 };