FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/speedhq.c
Date: 2022-07-04 19:11:22
Exec Total Coverage
Lines: 171 328 52.1%
Branches: 76 197 38.6%

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