GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/speedhq.c Lines: 172 278 61.9 %
Date: 2020-10-23 17:01:47 Branches: 72 147 49.0 %

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 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 speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
156
157
static VLC dc_lum_vlc_le;
158
static VLC dc_chroma_vlc_le;
159
static VLC dc_alpha_run_vlc_le;
160
static VLC 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, dc_lum_vlc_le.table, DC_VLC_BITS, 2);
168
    } else {
169
168
        code = get_vlc2(gb, dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
170
    }
171
336
    if (!code) {
172
        diff = 0;
173
    } else {
174
336
        diff = get_xbits_le(gb, code);
175
    }
176
336
    return diff;
177
}
178
179
static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
180
{
181
    uint8_t block[128];
182
    int i = 0, x, y;
183
184
    memset(block, 0, sizeof(block));
185
186
    {
187
        OPEN_READER(re, gb);
188
189
        for ( ;; ) {
190
            int run, level;
191
192
            UPDATE_CACHE_LE(re, gb);
193
            GET_VLC(run, re, gb, dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
194
195
            if (run < 0) break;
196
            i += run;
197
            if (i >= 128)
198
                return AVERROR_INVALIDDATA;
199
200
            UPDATE_CACHE_LE(re, gb);
201
            GET_VLC(level, re, gb, dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
202
            block[i++] = level;
203
        }
204
205
        CLOSE_READER(re, gb);
206
    }
207
208
    for (y = 0; y < 8; y++) {
209
        for (x = 0; x < 16; x++) {
210
            last_alpha[x] -= block[y * 16 + x];
211
        }
212
        memcpy(dest, last_alpha, 16);
213
        dest += linesize;
214
    }
215
216
    return 0;
217
}
218
219
336
static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
220
{
221
336
    const int *quant_matrix = s->quant_matrix;
222
336
    const uint8_t *scantable = s->intra_scantable.permutated;
223
336
    LOCAL_ALIGNED_32(int16_t, block, [64]);
224
    int dc_offset;
225
226
336
    s->bdsp.clear_block(block);
227
228
336
    dc_offset = decode_dc_le(gb, component);
229
336
    last_dc[component] -= dc_offset;  /* Note: Opposite of most codecs. */
230
336
    block[scantable[0]] = last_dc[component];  /* quant_matrix[0] is always 16. */
231
232
    /* Read AC coefficients. */
233
    {
234
336
        int i = 0;
235
336
        OPEN_READER(re, gb);
236
14663
        for ( ;; ) {
237
            int level, run;
238
14999
            UPDATE_CACHE_LE(re, gb);
239
14999
            GET_RL_VLC(level, run, re, gb, rl_speedhq.rl_vlc[0],
240
                       TEX_VLC_BITS, 2, 0);
241
14999
            if (level == 127) {
242
336
                break;
243
14663
            } else if (level) {
244
14187
                i += run;
245
14187
                if (i > MAX_INDEX)
246
                    return AVERROR_INVALIDDATA;
247
                /* If next bit is 1, level = -level */
248
14187
                level = (level ^ SHOW_SBITS(re, gb, 1)) -
249
14187
                        SHOW_SBITS(re, gb, 1);
250
14187
                LAST_SKIP_BITS(re, gb, 1);
251
            } else {
252
                /* Escape. */
253
#if MIN_CACHE_BITS < 6 + 6 + 12
254
#error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
255
#endif
256
476
                run = SHOW_UBITS(re, gb, 6) + 1;
257
476
                SKIP_BITS(re, gb, 6);
258
476
                level = SHOW_UBITS(re, gb, 12) - 2048;
259
476
                LAST_SKIP_BITS(re, gb, 12);
260
261
476
                i += run;
262
476
                if (i > MAX_INDEX)
263
                    return AVERROR_INVALIDDATA;
264
            }
265
266
14663
            block[scantable[i]] = (level * quant_matrix[i]) >> 4;
267
        }
268
336
        CLOSE_READER(re, gb);
269
    }
270
271
336
    s->idsp.idct_put(dest, linesize, block);
272
273
336
    return 0;
274
}
275
276
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)
277
{
278
    int ret, slice_number, slice_offsets[5];
279
3
    int linesize_y  = frame->linesize[0] * line_stride;
280
3
    int linesize_cb = frame->linesize[1] * line_stride;
281
3
    int linesize_cr = frame->linesize[2] * line_stride;
282
    int linesize_a;
283
284
3
    if (s->alpha_type != SHQ_NO_ALPHA)
285
        linesize_a = frame->linesize[3] * line_stride;
286
287

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

9
        if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
300
            return AVERROR_INVALIDDATA;
301
    }
302
303
15
    for (slice_number = 0; slice_number < 4; slice_number++) {
304
        GetBitContext gb;
305
        uint32_t slice_begin, slice_end;
306
        int x, y;
307
308
12
        slice_begin = slice_offsets[slice_number];
309
12
        slice_end = slice_offsets[slice_number + 1];
310
311
12
        if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
312
            return ret;
313
314
18
        for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
315
            uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
316
6
            int last_dc[4] = { 1024, 1024, 1024, 1024 };
317
            uint8_t last_alpha[16];
318
319
6
            memset(last_alpha, 255, sizeof(last_alpha));
320
321
6
            dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
322
6
            if (s->subsampling == SHQ_SUBSAMPLING_420) {
323
                dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
324
                dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
325
            } else {
326
6
                dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
327
6
                dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
328
            }
329
6
            if (s->alpha_type != SHQ_NO_ALPHA) {
330
                dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
331
            }
332
333
48
            for (x = 0; x < frame->width; x += 16) {
334
                /* Decode the four luma blocks. */
335
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
336
                    return ret;
337
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
338
                    return ret;
339
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
340
                    return ret;
341
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
342
                    return ret;
343
344
                /*
345
                 * Decode the first chroma block. For 4:2:0, this is the only one;
346
                 * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
347
                 */
348
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
349
                    return ret;
350
42
                if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
351
                    return ret;
352
353
42
                if (s->subsampling != SHQ_SUBSAMPLING_420) {
354
                    /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
355
42
                    if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
356
                        return ret;
357
42
                    if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
358
                        return ret;
359
360
42
                    if (s->subsampling == SHQ_SUBSAMPLING_444) {
361
                        /* Top-right and bottom-right blocks. */
362
                        if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
363
                            return ret;
364
                        if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
365
                            return ret;
366
                        if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
367
                            return ret;
368
                        if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
369
                            return ret;
370
371
                        dest_cb += 8;
372
                        dest_cr += 8;
373
                    }
374
                }
375
42
                dest_y += 16;
376
42
                dest_cb += 8;
377
42
                dest_cr += 8;
378
379
42
                if (s->alpha_type == SHQ_RLE_ALPHA) {
380
                    /* Alpha coded using 16x8 RLE blocks. */
381
                    if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
382
                        return ret;
383
                    if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
384
                        return ret;
385
                    dest_a += 16;
386
42
                } else if (s->alpha_type == SHQ_DCT_ALPHA) {
387
                    /* Alpha encoded exactly like luma. */
388
                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
389
                        return ret;
390
                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
391
                        return ret;
392
                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
393
                        return ret;
394
                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
395
                        return ret;
396
                    dest_a += 16;
397
                }
398
            }
399
        }
400
    }
401
402
3
    return 0;
403
}
404
405
2
static void compute_quant_matrix(int *output, int qscale)
406
{
407
    int i;
408
130
    for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
409
2
}
410
411
2
static int speedhq_decode_frame(AVCodecContext *avctx,
412
                                void *data, int *got_frame,
413
                                AVPacket *avpkt)
414
{
415
2
    SHQContext * const s = avctx->priv_data;
416
2
    const uint8_t *buf   = avpkt->data;
417
2
    int buf_size         = avpkt->size;
418
2
    AVFrame *frame       = data;
419
    uint8_t quality;
420
    uint32_t second_field_offset;
421
    int ret;
422
423
2
    if (buf_size < 4)
424
        return AVERROR_INVALIDDATA;
425
426
2
    quality = buf[0];
427
2
    if (quality >= 100) {
428
        return AVERROR_INVALIDDATA;
429
    }
430
431
2
    compute_quant_matrix(s->quant_matrix, 100 - quality);
432
433
2
    second_field_offset = AV_RL24(buf + 1);
434
2
    if (second_field_offset >= buf_size - 3) {
435
        return AVERROR_INVALIDDATA;
436
    }
437
438
2
    avctx->coded_width = FFALIGN(avctx->width, 16);
439
2
    avctx->coded_height = FFALIGN(avctx->height, 16);
440
441
2
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
442
        return ret;
443
    }
444
2
    frame->key_frame = 1;
445
446

2
    if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
447
        /*
448
         * Overlapping first and second fields is used to signal
449
         * encoding only a single field. In this case, "height"
450
         * is ambiguous; it could mean either the height of the
451
         * frame as a whole, or of the field. The former would make
452
         * more sense for compatibility with legacy decoders,
453
         * but this matches the convention used in NDI, which is
454
         * the primary user of this trick.
455
         */
456
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
457
            return ret;
458
    } else {
459
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
460
            return ret;
461
1
        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
462
            return ret;
463
    }
464
465
2
    *got_frame = 1;
466
2
    return buf_size;
467
}
468
469
/*
470
 * Alpha VLC. Run and level are independently coded, and would be
471
 * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
472
 * bother with combining them into one table.
473
 */
474
2
static av_cold void compute_alpha_vlcs(void)
475
{
476
    uint16_t run_code[134], level_code[266];
477
    uint8_t run_bits[134], level_bits[266];
478
    int16_t run_symbols[134], level_symbols[266];
479
    int entry, i, sign;
480
481
    /* Initialize VLC for alpha run. */
482
2
    entry = 0;
483
484
    /* 0 -> 0. */
485
2
    run_code[entry] = 0;
486
2
    run_bits[entry] = 1;
487
2
    run_symbols[entry] = 0;
488
2
    ++entry;
489
490
    /* 10xx -> xx plus 1. */
491
10
    for (i = 0; i < 4; ++i) {
492
8
        run_code[entry] = (i << 2) | 1;
493
8
        run_bits[entry] = 4;
494
8
        run_symbols[entry] = i + 1;
495
8
        ++entry;
496
    }
497
498
    /* 111xxxxxxx -> xxxxxxx. */
499
258
    for (i = 0; i < 128; ++i) {
500
256
        run_code[entry] = (i << 3) | 7;
501
256
        run_bits[entry] = 10;
502
256
        run_symbols[entry] = i;
503
256
        ++entry;
504
    }
505
506
    /* 110 -> EOB. */
507
2
    run_code[entry] = 3;
508
2
    run_bits[entry] = 3;
509
2
    run_symbols[entry] = -1;
510
2
    ++entry;
511
512
2
    av_assert0(entry == FF_ARRAY_ELEMS(run_code));
513
514
2
    INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
515
                              FF_ARRAY_ELEMS(run_code),
516
                              run_bits, 1, 1,
517
                              run_code, 2, 2,
518
                              run_symbols, 2, 2, 160);
519
520
    /* Initialize VLC for alpha level. */
521
2
    entry = 0;
522
523
6
    for (sign = 0; sign <= 1; ++sign) {
524
        /* 1s -> -1 or +1 (depending on sign bit). */
525
4
        level_code[entry] = (sign << 1) | 1;
526
4
        level_bits[entry] = 2;
527
4
        level_symbols[entry] = sign ? -1 : 1;
528
4
        ++entry;
529
530
        /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
531
20
        for (i = 0; i < 4; ++i) {
532
16
            level_code[entry] = (i << 3) | (sign << 2) | 2;
533
16
            level_bits[entry] = 5;
534
16
            level_symbols[entry] = sign ? -(i + 2) : (i + 2);
535
16
            ++entry;
536
        }
537
    }
538
539
    /*
540
     * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
541
     * here that would better be encoded in other ways (e.g. 0 would be
542
     * encoded by increasing run, and +/- 1 would be encoded with a
543
     * shorter code), but it doesn't hurt to allow everything.
544
     */
545
514
    for (i = 0; i < 256; ++i) {
546
512
        level_code[entry] = i << 2;
547
512
        level_bits[entry] = 10;
548
512
        level_symbols[entry] = i;
549
512
        ++entry;
550
    }
551
552
2
    av_assert0(entry == FF_ARRAY_ELEMS(level_code));
553
554
2
    INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
555
                              FF_ARRAY_ELEMS(level_code),
556
                              level_bits, 1, 1,
557
                              level_code, 2, 2,
558
                              level_symbols, 2, 2, 288);
559
2
}
560
561
2
static av_cold void speedhq_static_init(void)
562
{
563
    /* Exactly the same as MPEG-2, except for a little-endian reader. */
564
2
    INIT_CUSTOM_VLC_STATIC(&dc_lum_vlc_le, DC_VLC_BITS, 12,
565
                           ff_mpeg12_vlc_dc_lum_bits, 1, 1,
566
                           ff_mpeg12_vlc_dc_lum_code, 2, 2,
567
                           INIT_VLC_OUTPUT_LE, 512);
568
2
    INIT_CUSTOM_VLC_STATIC(&dc_chroma_vlc_le, DC_VLC_BITS, 12,
569
                           ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
570
                           ff_mpeg12_vlc_dc_chroma_code, 2, 2,
571
                           INIT_VLC_OUTPUT_LE, 514);
572
573
2
    ff_rl_init(&rl_speedhq, speedhq_static_rl_table_store);
574
2
    INIT_2D_VLC_RL(rl_speedhq, 674, INIT_VLC_LE);
575
576
2
    compute_alpha_vlcs();
577
2
}
578
579
4
static av_cold int speedhq_decode_init(AVCodecContext *avctx)
580
{
581
    int ret;
582
    static AVOnce init_once = AV_ONCE_INIT;
583
4
    SHQContext * const s = avctx->priv_data;
584
585
4
    s->avctx = avctx;
586
587
4
    ret = ff_thread_once(&init_once, speedhq_static_init);
588
4
    if (ret)
589
        return AVERROR_UNKNOWN;
590
591
4
    ff_blockdsp_init(&s->bdsp, avctx);
592
4
    ff_idctdsp_init(&s->idsp, avctx);
593
4
    ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
594
595


4
    switch (avctx->codec_tag) {
596
    case MKTAG('S', 'H', 'Q', '0'):
597
        s->subsampling = SHQ_SUBSAMPLING_420;
598
        s->alpha_type = SHQ_NO_ALPHA;
599
        avctx->pix_fmt = AV_PIX_FMT_YUV420P;
600
        break;
601
    case MKTAG('S', 'H', 'Q', '1'):
602
        s->subsampling = SHQ_SUBSAMPLING_420;
603
        s->alpha_type = SHQ_RLE_ALPHA;
604
        avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
605
        break;
606
2
    case MKTAG('S', 'H', 'Q', '2'):
607
2
        s->subsampling = SHQ_SUBSAMPLING_422;
608
2
        s->alpha_type = SHQ_NO_ALPHA;
609
2
        avctx->pix_fmt = AV_PIX_FMT_YUV422P;
610
2
        break;
611
    case MKTAG('S', 'H', 'Q', '3'):
612
        s->subsampling = SHQ_SUBSAMPLING_422;
613
        s->alpha_type = SHQ_RLE_ALPHA;
614
        avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
615
        break;
616
    case MKTAG('S', 'H', 'Q', '4'):
617
        s->subsampling = SHQ_SUBSAMPLING_444;
618
        s->alpha_type = SHQ_NO_ALPHA;
619
        avctx->pix_fmt = AV_PIX_FMT_YUV444P;
620
        break;
621
    case MKTAG('S', 'H', 'Q', '5'):
622
        s->subsampling = SHQ_SUBSAMPLING_444;
623
        s->alpha_type = SHQ_RLE_ALPHA;
624
        avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
625
        break;
626
    case MKTAG('S', 'H', 'Q', '7'):
627
        s->subsampling = SHQ_SUBSAMPLING_422;
628
        s->alpha_type = SHQ_DCT_ALPHA;
629
        avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
630
        break;
631
    case MKTAG('S', 'H', 'Q', '9'):
632
        s->subsampling = SHQ_SUBSAMPLING_444;
633
        s->alpha_type = SHQ_DCT_ALPHA;
634
        avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
635
        break;
636
2
    default:
637
2
        av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
638
               avctx->codec_tag);
639
2
        return AVERROR_INVALIDDATA;
640
    }
641
642
    /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
643
2
    avctx->colorspace = AVCOL_SPC_BT470BG;
644
2
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
645
646
2
    return 0;
647
}
648
649
AVCodec ff_speedhq_decoder = {
650
    .name           = "speedhq",
651
    .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
652
    .type           = AVMEDIA_TYPE_VIDEO,
653
    .id             = AV_CODEC_ID_SPEEDHQ,
654
    .priv_data_size = sizeof(SHQContext),
655
    .init           = speedhq_decode_init,
656
    .decode         = speedhq_decode_frame,
657
    .capabilities   = AV_CODEC_CAP_DR1,
658
};