GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/speedhq.c Lines: 181 289 62.6 %
Date: 2020-08-14 10:39:37 Branches: 75 151 49.7 %

Line Branch Exec Source
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
336
static inline int decode_dc_le(GetBitContext *gb, int component)
163
{
164
    int code, diff;
165
166

336
    if (component == 0 || component == 3) {
167
168
        code = get_vlc2(gb, ff_dc_lum_vlc_le.table, DC_VLC_BITS, 2);
168
    } else {
169
168
        code = get_vlc2(gb, ff_dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
170
    }
171
336
    if (code < 0) {
172
        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
173
        return 0xffff;
174
    }
175
336
    if (!code) {
176
        diff = 0;
177
    } else {
178
336
        diff = get_xbits_le(gb, code);
179
    }
180
336
    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
336
static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
224
{
225
336
    const int *quant_matrix = s->quant_matrix;
226
336
    const uint8_t *scantable = s->intra_scantable.permutated;
227
336
    LOCAL_ALIGNED_32(int16_t, block, [64]);
228
    int dc_offset;
229
230
336
    s->bdsp.clear_block(block);
231
232
336
    dc_offset = decode_dc_le(gb, component);
233
336
    last_dc[component] -= dc_offset;  /* Note: Opposite of most codecs. */
234
336
    block[scantable[0]] = last_dc[component];  /* quant_matrix[0] is always 16. */
235
236
    /* Read AC coefficients. */
237
    {
238
336
        int i = 0;
239
336
        OPEN_READER(re, gb);
240
14663
        for ( ;; ) {
241
            int level, run;
242
14999
            UPDATE_CACHE_LE(re, gb);
243
14999
            GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
244
                       TEX_VLC_BITS, 2, 0);
245
14999
            if (level == 127) {
246
336
                break;
247
14663
            } else if (level) {
248
14187
                i += run;
249
14187
                if (i > MAX_INDEX)
250
                    return AVERROR_INVALIDDATA;
251
                /* If next bit is 1, level = -level */
252
14187
                level = (level ^ SHOW_SBITS(re, gb, 1)) -
253
14187
                        SHOW_SBITS(re, gb, 1);
254
14187
                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
476
                run = SHOW_UBITS(re, gb, 6) + 1;
261
476
                SKIP_BITS(re, gb, 6);
262
476
                level = SHOW_UBITS(re, gb, 12) - 2048;
263
476
                LAST_SKIP_BITS(re, gb, 12);
264
265
476
                i += run;
266
476
                if (i > MAX_INDEX)
267
                    return AVERROR_INVALIDDATA;
268
            }
269
270
14663
            block[scantable[i]] = (level * quant_matrix[i]) >> 4;
271
        }
272
336
        CLOSE_READER(re, gb);
273
    }
274
275
336
    s->idsp.idct_put(dest, linesize, block);
276
277
336
    return 0;
278
}
279
280
3
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
3
    int linesize_y  = frame->linesize[0] * line_stride;
284
3
    int linesize_cb = frame->linesize[1] * line_stride;
285
3
    int linesize_cr = frame->linesize[2] * line_stride;
286
    int linesize_a;
287
288
3
    if (s->alpha_type != SHQ_NO_ALPHA)
289
        linesize_a = frame->linesize[3] * line_stride;
290
291

3
    if (end < start || end - start < 3 || end > buf_size)
292
        return AVERROR_INVALIDDATA;
293
294
3
    slice_offsets[0] = start;
295
3
    slice_offsets[4] = end;
296
12
    for (slice_number = 1; slice_number < 4; slice_number++) {
297
        uint32_t last_offset, slice_len;
298
299
9
        last_offset = slice_offsets[slice_number - 1];
300
9
        slice_len = AV_RL24(buf + last_offset);
301
9
        slice_offsets[slice_number] = last_offset + slice_len;
302
303

9
        if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
304
            return AVERROR_INVALIDDATA;
305
    }
306
307
15
    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
12
        slice_begin = slice_offsets[slice_number];
313
12
        slice_end = slice_offsets[slice_number + 1];
314
315
12
        if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
316
            return ret;
317
318
18
        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
6
            int last_dc[4] = { 1024, 1024, 1024, 1024 };
321
            uint8_t last_alpha[16];
322
323
6
            memset(last_alpha, 255, sizeof(last_alpha));
324
325
6
            dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
326
6
            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
6
                dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
331
6
                dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
332
            }
333
6
            if (s->alpha_type != SHQ_NO_ALPHA) {
334
                dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
335
            }
336
337
48
            for (x = 0; x < frame->width; x += 16) {
338
                /* Decode the four luma blocks. */
339
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
340
                    return ret;
341
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
342
                    return ret;
343
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
344
                    return ret;
345
42
                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
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
353
                    return ret;
354
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
355
                    return ret;
356
357
42
                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
42
                    if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
360
                        return ret;
361
42
                    if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
362
                        return ret;
363
364
42
                    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
42
                dest_y += 16;
380
42
                dest_cb += 8;
381
42
                dest_cr += 8;
382
383
42
                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
42
                } 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
3
    return 0;
407
}
408
409
2
static void compute_quant_matrix(int *output, int qscale)
410
{
411
    int i;
412
130
    for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
413
2
}
414
415
2
static int speedhq_decode_frame(AVCodecContext *avctx,
416
                                void *data, int *got_frame,
417
                                AVPacket *avpkt)
418
{
419
2
    SHQContext * const s = avctx->priv_data;
420
2
    const uint8_t *buf   = avpkt->data;
421
2
    int buf_size         = avpkt->size;
422
2
    AVFrame *frame       = data;
423
    uint8_t quality;
424
    uint32_t second_field_offset;
425
    int ret;
426
427
2
    if (buf_size < 4)
428
        return AVERROR_INVALIDDATA;
429
430
2
    quality = buf[0];
431
2
    if (quality >= 100) {
432
        return AVERROR_INVALIDDATA;
433
    }
434
435
2
    compute_quant_matrix(s->quant_matrix, 100 - quality);
436
437
2
    second_field_offset = AV_RL24(buf + 1);
438
2
    if (second_field_offset >= buf_size - 3) {
439
        return AVERROR_INVALIDDATA;
440
    }
441
442
2
    avctx->coded_width = FFALIGN(avctx->width, 16);
443
2
    avctx->coded_height = FFALIGN(avctx->height, 16);
444
445
2
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
446
        return ret;
447
    }
448
2
    frame->key_frame = 1;
449
450

2
    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
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
461
            return ret;
462
    } else {
463
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
464
            return ret;
465
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
466
            return ret;
467
    }
468
469
2
    *got_frame = 1;
470
2
    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
2
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
2
    entry = 0;
487
488
    /* 0 -> 0. */
489
2
    run_code[entry] = 0;
490
2
    run_bits[entry] = 1;
491
2
    run_symbols[entry] = 0;
492
2
    ++entry;
493
494
    /* 10xx -> xx plus 1. */
495
10
    for (i = 0; i < 4; ++i) {
496
8
        run_code[entry] = (i << 2) | 1;
497
8
        run_bits[entry] = 4;
498
8
        run_symbols[entry] = i + 1;
499
8
        ++entry;
500
    }
501
502
    /* 111xxxxxxx -> xxxxxxx. */
503
258
    for (i = 0; i < 128; ++i) {
504
256
        run_code[entry] = (i << 3) | 7;
505
256
        run_bits[entry] = 10;
506
256
        run_symbols[entry] = i;
507
256
        ++entry;
508
    }
509
510
    /* 110 -> EOB. */
511
2
    run_code[entry] = 3;
512
2
    run_bits[entry] = 3;
513
2
    run_symbols[entry] = -1;
514
2
    ++entry;
515
516
2
    av_assert0(entry == FF_ARRAY_ELEMS(run_code));
517
518
2
    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
2
    entry = 0;
526
527
6
    for (sign = 0; sign <= 1; ++sign) {
528
        /* 1s -> -1 or +1 (depending on sign bit). */
529
4
        level_code[entry] = (sign << 1) | 1;
530
4
        level_bits[entry] = 2;
531
4
        level_symbols[entry] = sign ? -1 : 1;
532
4
        ++entry;
533
534
        /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
535
20
        for (i = 0; i < 4; ++i) {
536
16
            level_code[entry] = (i << 3) | (sign << 2) | 2;
537
16
            level_bits[entry] = 5;
538
16
            level_symbols[entry] = sign ? -(i + 2) : (i + 2);
539
16
            ++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
514
    for (i = 0; i < 256; ++i) {
550
512
        level_code[entry] = i << 2;
551
512
        level_bits[entry] = 10;
552
512
        level_symbols[entry] = i;
553
512
        ++entry;
554
    }
555
556
2
    av_assert0(entry == FF_ARRAY_ELEMS(level_code));
557
558
2
    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
2
}
564
565
48
static uint32_t reverse(uint32_t num, int bits)
566
{
567
48
    return bitswap_32(num) >> (32 - bits);
568
}
569
570
4
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
52
    for (i = 0; i < num_entries; i++) {
575
48
        reversed_code[i] = reverse(code[i], bits[i]);
576
    }
577
4
}
578
579
2
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
2
    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
2
    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
2
    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
2
    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
2
    ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
601
2
    INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
602
603
2
    compute_alpha_vlcs();
604
2
}
605
606
4
static av_cold int speedhq_decode_init(AVCodecContext *avctx)
607
{
608
    int ret;
609
    static AVOnce init_once = AV_ONCE_INIT;
610
4
    SHQContext * const s = avctx->priv_data;
611
612
4
    s->avctx = avctx;
613
614
4
    ret = ff_thread_once(&init_once, speedhq_static_init);
615
4
    if (ret)
616
        return AVERROR_UNKNOWN;
617
618
4
    ff_blockdsp_init(&s->bdsp, avctx);
619
4
    ff_idctdsp_init(&s->idsp, avctx);
620
4
    ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
621
622


4
    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
2
    case MKTAG('S', 'H', 'Q', '2'):
634
2
        s->subsampling = SHQ_SUBSAMPLING_422;
635
2
        s->alpha_type = SHQ_NO_ALPHA;
636
2
        avctx->pix_fmt = AV_PIX_FMT_YUV422P;
637
2
        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
2
    default:
664
2
        av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
665
               avctx->codec_tag);
666
2
        return AVERROR_INVALIDDATA;
667
    }
668
669
    /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
670
2
    avctx->colorspace = AVCOL_SPC_BT470BG;
671
2
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
672
673
2
    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
};