GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/speedhq.c Lines: 172 278 61.9 %
Date: 2021-01-20 23:14:43 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 "config.h"
30
#include "libavutil/attributes.h"
31
#include "libavutil/mem_internal.h"
32
33
#include "avcodec.h"
34
#include "get_bits.h"
35
#include "internal.h"
36
#include "libavutil/thread.h"
37
#include "mathops.h"
38
#include "mpeg12.h"
39
#include "mpeg12data.h"
40
#include "mpeg12vlc.h"
41
42
#define MAX_INDEX (64 - 1)
43
44
/*
45
 * 5 bits makes for very small tables, with no more than two lookups needed
46
 * for the longest (10-bit) codes.
47
 */
48
#define ALPHA_VLC_BITS 5
49
50
typedef struct SHQContext {
51
    AVCodecContext *avctx;
52
    BlockDSPContext bdsp;
53
    IDCTDSPContext idsp;
54
    ScanTable intra_scantable;
55
    int quant_matrix[64];
56
    enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
57
        subsampling;
58
    enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
59
} SHQContext;
60
61
62
/* AC codes: Very similar but not identical to MPEG-2. */
63
static const uint16_t speedhq_vlc[123][2] = {
64
    {0x0001,  2}, {0x0003,  3}, {0x000E,  4}, {0x0007,  5},
65
    {0x0017,  5}, {0x0028,  6}, {0x0008,  6}, {0x006F,  7},
66
    {0x001F,  7}, {0x00C4,  8}, {0x0044,  8}, {0x005F,  8},
67
    {0x00DF,  8}, {0x007F,  8}, {0x00FF,  8}, {0x3E00, 14},
68
    {0x1E00, 14}, {0x2E00, 14}, {0x0E00, 14}, {0x3600, 14},
69
    {0x1600, 14}, {0x2600, 14}, {0x0600, 14}, {0x3A00, 14},
70
    {0x1A00, 14}, {0x2A00, 14}, {0x0A00, 14}, {0x3200, 14},
71
    {0x1200, 14}, {0x2200, 14}, {0x0200, 14}, {0x0C00, 15},
72
    {0x7400, 15}, {0x3400, 15}, {0x5400, 15}, {0x1400, 15},
73
    {0x6400, 15}, {0x2400, 15}, {0x4400, 15}, {0x0400, 15},
74
    {0x0002,  3}, {0x000C,  5}, {0x004F,  7}, {0x00E4,  8},
75
    {0x0004,  8}, {0x0D00, 13}, {0x1500, 13}, {0x7C00, 15},
76
    {0x3C00, 15}, {0x5C00, 15}, {0x1C00, 15}, {0x6C00, 15},
77
    {0x2C00, 15}, {0x4C00, 15}, {0xC800, 16}, {0x4800, 16},
78
    {0x8800, 16}, {0x0800, 16}, {0x0300, 13}, {0x1D00, 13},
79
    {0x0014,  5}, {0x0070,  7}, {0x003F,  8}, {0x00C0, 10},
80
    {0x0500, 13}, {0x0180, 12}, {0x0280, 12}, {0x0C80, 12},
81
    {0x0080, 12}, {0x0B00, 13}, {0x1300, 13}, {0x001C,  5},
82
    {0x0064,  8}, {0x0380, 12}, {0x1900, 13}, {0x0D80, 12},
83
    {0x0018,  6}, {0x00BF,  8}, {0x0480, 12}, {0x0B80, 12},
84
    {0x0038,  6}, {0x0040,  9}, {0x0900, 13}, {0x0030,  7},
85
    {0x0780, 12}, {0x2800, 16}, {0x0010,  7}, {0x0A80, 12},
86
    {0x0050,  7}, {0x0880, 12}, {0x000F,  7}, {0x1100, 13},
87
    {0x002F,  7}, {0x0100, 13}, {0x0084,  8}, {0x5800, 16},
88
    {0x00A4,  8}, {0x9800, 16}, {0x0024,  8}, {0x1800, 16},
89
    {0x0140,  9}, {0xE800, 16}, {0x01C0,  9}, {0x6800, 16},
90
    {0x02C0, 10}, {0xA800, 16}, {0x0F80, 12}, {0x0580, 12},
91
    {0x0980, 12}, {0x0E80, 12}, {0x0680, 12}, {0x1F00, 13},
92
    {0x0F00, 13}, {0x1700, 13}, {0x0700, 13}, {0x1B00, 13},
93
    {0xF800, 16}, {0x7800, 16}, {0xB800, 16}, {0x3800, 16},
94
    {0xD800, 16},
95
    {0x0020,  6}, /* escape */
96
    {0x0006,  4}  /* EOB */
97
};
98
99
static const uint8_t speedhq_level[121] = {
100
     1,  2,  3,  4,  5,  6,  7,  8,
101
     9, 10, 11, 12, 13, 14, 15, 16,
102
    17, 18, 19, 20, 21, 22, 23, 24,
103
    25, 26, 27, 28, 29, 30, 31, 32,
104
    33, 34, 35, 36, 37, 38, 39, 40,
105
     1,  2,  3,  4,  5,  6,  7,  8,
106
     9, 10, 11, 12, 13, 14, 15, 16,
107
    17, 18, 19, 20,  1,  2,  3,  4,
108
     5,  6,  7,  8,  9, 10, 11,  1,
109
     2,  3,  4,  5,  1,  2,  3,  4,
110
     1,  2,  3,  1,  2,  3,  1,  2,
111
     1,  2,  1,  2,  1,  2,  1,  2,
112
     1,  2,  1,  2,  1,  2,  1,  2,
113
     1,  2,  1,  1,  1,  1,  1,  1,
114
     1,  1,  1,  1,  1,  1,  1,  1,
115
     1,
116
};
117
118
static const uint8_t speedhq_run[121] = {
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
     0,  0,  0,  0,  0,  0,  0,  0,
123
     0,  0,  0,  0,  0,  0,  0,  0,
124
     1,  1,  1,  1,  1,  1,  1,  1,
125
     1,  1,  1,  1,  1,  1,  1,  1,
126
     1,  1,  1,  1,  2,  2,  2,  2,
127
     2,  2,  2,  2,  2,  2,  2,  3,
128
     3,  3,  3,  3,  4,  4,  4,  4,
129
     5,  5,  5,  6,  6,  6,  7,  7,
130
     8,  8,  9,  9, 10, 10, 11, 11,
131
    12, 12, 13, 13, 14, 14, 15, 15,
132
    16, 16, 17, 18, 19, 20, 21, 22,
133
    23, 24, 25, 26, 27, 28, 29, 30,
134
    31,
135
};
136
137
RLTable ff_rl_speedhq = {
138
    121,
139
    121,
140
    speedhq_vlc,
141
    speedhq_run,
142
    speedhq_level,
143
};
144
145
#if CONFIG_SPEEDHQ_DECODER
146
/* NOTE: The first element is always 16, unscaled. */
147
static const uint8_t unscaled_quant_matrix[64] = {
148
    16, 16, 19, 22, 26, 27, 29, 34,
149
    16, 16, 22, 24, 27, 29, 34, 37,
150
    19, 22, 26, 27, 29, 34, 34, 38,
151
    22, 22, 26, 27, 29, 34, 37, 40,
152
    22, 26, 27, 29, 32, 35, 40, 48,
153
    26, 27, 29, 32, 35, 40, 48, 58,
154
    26, 27, 29, 34, 38, 46, 56, 69,
155
    27, 29, 35, 38, 46, 56, 69, 83
156
};
157
158
static uint8_t speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
159
160
static VLC dc_lum_vlc_le;
161
static VLC dc_chroma_vlc_le;
162
static VLC dc_alpha_run_vlc_le;
163
static VLC dc_alpha_level_vlc_le;
164
165
336
static inline int decode_dc_le(GetBitContext *gb, int component)
166
{
167
    int code, diff;
168
169

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

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

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

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


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