FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/speedhqdec.c
Date: 2024-07-26 21:54:09
Exec Total Coverage
Lines: 200 339 59.0%
Functions: 10 12 83.3%
Branches: 90 203 44.3%
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 #include "libavutil/mem_internal.h"
31
32 #include "avcodec.h"
33 #include "blockdsp.h"
34 #include "codec_internal.h"
35 #include "decode.h"
36 #include "get_bits.h"
37 #include "idctdsp.h"
38 #include "libavutil/thread.h"
39 #include "mathops.h"
40 #include "mpeg12data.h"
41 #include "mpeg12vlc.h"
42 #include "speedhq.h"
43 #include "thread.h"
44
45 #define MAX_INDEX (64 - 1)
46
47 /*
48 * 5 bits makes for very small tables, with no more than two lookups needed
49 * for the longest (10-bit) codes.
50 */
51 #define ALPHA_VLC_BITS 5
52
53 typedef struct SHQContext {
54 BlockDSPContext bdsp;
55 IDCTDSPContext idsp;
56 uint8_t permutated_intra_scantable[64];
57 int quant_matrix[64];
58 enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
59 subsampling;
60 enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
61 AVPacket *avpkt;
62 uint32_t second_field_offset;
63 } SHQContext;
64
65 /* NOTE: The first element is always 16, unscaled. */
66 static const uint8_t unscaled_quant_matrix[64] = {
67 16, 16, 19, 22, 26, 27, 29, 34,
68 16, 16, 22, 24, 27, 29, 34, 37,
69 19, 22, 26, 27, 29, 34, 34, 38,
70 22, 22, 26, 27, 29, 34, 37, 40,
71 22, 26, 27, 29, 32, 35, 40, 48,
72 26, 27, 29, 32, 35, 40, 48, 58,
73 26, 27, 29, 34, 38, 46, 56, 69,
74 27, 29, 35, 38, 46, 56, 69, 83
75 };
76
77 static VLCElem dc_lum_vlc_le[512];
78 static VLCElem dc_chroma_vlc_le[514];
79 static VLCElem dc_alpha_run_vlc_le[160];
80 static VLCElem dc_alpha_level_vlc_le[288];
81
82 static RL_VLC_ELEM speedhq_rl_vlc[674];
83
84 1544736 static inline int decode_dc_le(GetBitContext *gb, int component)
85 {
86 int code, diff;
87
88
3/4
✓ Branch 0 taken 831768 times.
✓ Branch 1 taken 712968 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 831768 times.
 1544736 if (component == 0 || component == 3) {
89 712968 code = get_vlc2(gb, dc_lum_vlc_le, DC_VLC_BITS, 2);
90 } else {
91 831768 code = get_vlc2(gb, dc_chroma_vlc_le, DC_VLC_BITS, 2);
92 }
93
2/2
✓ Branch 0 taken 9976 times.
✓ Branch 1 taken 1534760 times.
 1544736 if (!code) {
94 9976 diff = 0;
95 } else {
96 1534760 diff = get_xbits_le(gb, code);
97 }
98 1544736 return diff;
99 }
100
101 ✗ static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
102 {
103 uint8_t block[128];
104 ✗ int i = 0, x, y;
105
106 ✗ memset(block, 0, sizeof(block));
107
108 {
109 ✗ OPEN_READER(re, gb);
110
111 ✗ for ( ;; ) {
112 int run, level;
113
114 ✗ UPDATE_CACHE_LE(re, gb);
115 ✗ GET_VLC(run, re, gb, dc_alpha_run_vlc_le, ALPHA_VLC_BITS, 2);
116
117 ✗ if (run < 0) break;
118 ✗ i += run;
119 ✗ if (i >= 128)
120 ✗ return AVERROR_INVALIDDATA;
121
122 ✗ UPDATE_CACHE_LE(re, gb);
123 ✗ GET_VLC(level, re, gb, dc_alpha_level_vlc_le, ALPHA_VLC_BITS, 2);
124 ✗ block[i++] = level;
125 }
126
127 ✗ CLOSE_READER(re, gb);
128 }
129
130 ✗ for (y = 0; y < 8; y++) {
131 ✗ for (x = 0; x < 16; x++) {
132 ✗ last_alpha[x] -= block[y * 16 + x];
133 }
134 ✗ memcpy(dest, last_alpha, 16);
135 ✗ dest += linesize;
136 }
137
138 ✗ return 0;
139 }
140
141 1544736 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
142 {
143 1544736 const int *quant_matrix = s->quant_matrix;
144 1544736 const uint8_t *scantable = s->permutated_intra_scantable;
145 1544736 LOCAL_ALIGNED_32(int16_t, block, [64]);
146 int dc_offset;
147
148 1544736 s->bdsp.clear_block(block);
149
150 1544736 dc_offset = decode_dc_le(gb, component);
151 1544736 last_dc[component] -= dc_offset; /* Note: Opposite of most codecs. */
152 1544736 block[scantable[0]] = last_dc[component]; /* quant_matrix[0] is always 16. */
153
154 /* Read AC coefficients. */
155 {
156 1544736 int i = 0;
157 1544736 OPEN_READER(re, gb);
158 5781637 for ( ;; ) {
159 int level, run;
160 7326373 UPDATE_CACHE_LE(re, gb);
161
2/2
✓ Branch 0 taken 152486 times.
✓ Branch 1 taken 7173887 times.
 7326373 GET_RL_VLC(level, run, re, gb, speedhq_rl_vlc,
162 TEX_VLC_BITS, 2, 0);
163
2/2
✓ Branch 0 taken 1544736 times.
✓ Branch 1 taken 5781637 times.
 7326373 if (level == 127) {
164 1544736 break;
165
2/2
✓ Branch 0 taken 5755452 times.
✓ Branch 1 taken 26185 times.
 5781637 } else if (level) {
166 5755452 i += run;
167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5755452 times.
 5755452 if (i > MAX_INDEX)
168 ✗ return AVERROR_INVALIDDATA;
169 /* If next bit is 1, level = -level */
170 5755452 level = (level ^ SHOW_SBITS(re, gb, 1)) -
171 5755452 SHOW_SBITS(re, gb, 1);
172 5755452 LAST_SKIP_BITS(re, gb, 1);
173 } else {
174 /* Escape. */
175 #if MIN_CACHE_BITS < 6 + 6 + 12
176 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
177 #endif
178 26185 run = SHOW_UBITS(re, gb, 6) + 1;
179 26185 SKIP_BITS(re, gb, 6);
180 26185 level = SHOW_UBITS(re, gb, 12) - 2048;
181 26185 LAST_SKIP_BITS(re, gb, 12);
182
183 26185 i += run;
184
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 26185 times.
 26185 if (i > MAX_INDEX)
185 ✗ return AVERROR_INVALIDDATA;
186 }
187
188 5781637 block[scantable[i]] = (level * quant_matrix[i]) >> 4;
189 }
190 1544736 CLOSE_READER(re, gb);
191 }
192
193 1544736 s->idsp.idct_put(dest, linesize, block);
194
195 1544736 return 0;
196 }
197
198 ✗ static int decode_speedhq_border(const SHQContext *s, GetBitContext *gb, AVFrame *frame, int field_number, int line_stride)
199 {
200 ✗ int linesize_y = frame->linesize[0] * line_stride;
201 ✗ int linesize_cb = frame->linesize[1] * line_stride;
202 ✗ int linesize_cr = frame->linesize[2] * line_stride;
203 int linesize_a;
204 int ret;
205
206 ✗ if (s->alpha_type != SHQ_NO_ALPHA)
207 ✗ linesize_a = frame->linesize[3] * line_stride;
208
209 ✗ for (int y = 0; y < frame->height; y += 16 * line_stride) {
210 ✗ int last_dc[4] = { 1024, 1024, 1024, 1024 };
211 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
212 uint8_t last_alpha[16];
213 ✗ int x = frame->width - 8;
214
215 ✗ dest_y = frame->data[0] + frame->linesize[0] * (y + field_number) + x;
216 ✗ if (s->subsampling == SHQ_SUBSAMPLING_420) {
217 ✗ dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number) + x / 2;
218 ✗ dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number) + x / 2;
219 } else {
220 av_assert2(s->subsampling == SHQ_SUBSAMPLING_422);
221 ✗ dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number) + x / 2;
222 ✗ dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number) + x / 2;
223 }
224 ✗ if (s->alpha_type != SHQ_NO_ALPHA) {
225 ✗ memset(last_alpha, 255, sizeof(last_alpha));
226 ✗ dest_a = frame->data[3] + frame->linesize[3] * (y + field_number) + x;
227 }
228
229 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y, linesize_y)) < 0)
230 ✗ return ret;
231 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
232 ✗ return ret;
233 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
234 ✗ return ret;
235 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
236 ✗ return ret;
237 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
238 ✗ return ret;
239 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
240 ✗ return ret;
241
242 ✗ if (s->subsampling != SHQ_SUBSAMPLING_420) {
243 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
244 ✗ return ret;
245 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
246 ✗ return ret;
247 }
248
249 ✗ if (s->alpha_type == SHQ_RLE_ALPHA) {
250 /* Alpha coded using 16x8 RLE blocks. */
251 ✗ if ((ret = decode_alpha_block(s, gb, last_alpha, dest_a, linesize_a)) < 0)
252 ✗ return ret;
253 ✗ if ((ret = decode_alpha_block(s, gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
254 ✗ return ret;
255 ✗ } else if (s->alpha_type == SHQ_DCT_ALPHA) {
256 /* Alpha encoded exactly like luma. */
257 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a, linesize_a)) < 0)
258 ✗ return ret;
259 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
260 ✗ return ret;
261 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
262 ✗ return ret;
263 ✗ if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
264 ✗ return ret;
265 }
266 }
267
268 ✗ return 0;
269 }
270
271 1812 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, int slice_number)
272 {
273 int ret, x, y, slice_offsets[5];
274 uint32_t slice_begin, slice_end;
275 1812 int linesize_y = frame->linesize[0] * line_stride;
276 1812 int linesize_cb = frame->linesize[1] * line_stride;
277 1812 int linesize_cr = frame->linesize[2] * line_stride;
278 int linesize_a;
279 GetBitContext gb;
280
281
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1812 times.
 1812 if (s->alpha_type != SHQ_NO_ALPHA)
282 ✗ linesize_a = frame->linesize[3] * line_stride;
283
284
3/6
✓ Branch 0 taken 1812 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1812 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 1812 times.
 1812 if (end < start || end - start < 3 || end > buf_size)
285 ✗ return AVERROR_INVALIDDATA;
286
287 1812 slice_offsets[0] = start;
288 1812 slice_offsets[4] = end;
289
2/2
✓ Branch 0 taken 5436 times.
✓ Branch 1 taken 1812 times.
 7248 for (x = 1; x < 4; x++) {
290 uint32_t last_offset, slice_len;
291
292 5436 last_offset = slice_offsets[x - 1];
293 5436 slice_len = AV_RL24(buf + last_offset);
294 5436 slice_offsets[x] = last_offset + slice_len;
295
296
2/4
✓ Branch 0 taken 5436 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5436 times.
 5436 if (slice_len < 3 || slice_offsets[x] > end - 3)
297 ✗ return AVERROR_INVALIDDATA;
298 }
299
300 1812 slice_begin = slice_offsets[slice_number];
301 1812 slice_end = slice_offsets[slice_number + 1];
302
303
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1812 times.
 1812 if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
304 ✗ return ret;
305
306
2/2
✓ Branch 0 taken 8106 times.
✓ Branch 1 taken 1812 times.
 9918 for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
307 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
308 8106 int last_dc[4] = { 1024, 1024, 1024, 1024 };
309 uint8_t last_alpha[16];
310
311 8106 memset(last_alpha, 255, sizeof(last_alpha));
312
313 8106 dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
314
2/2
✓ Branch 0 taken 2700 times.
✓ Branch 1 taken 5406 times.
 8106 if (s->subsampling == SHQ_SUBSAMPLING_420) {
315 2700 dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
316 2700 dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
317 } else {
318 5406 dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
319 5406 dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
320 }
321
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8106 times.
 8106 if (s->alpha_type != SHQ_NO_ALPHA) {
322 ✗ dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
323 }
324
325
4/4
✓ Branch 0 taken 124248 times.
✓ Branch 1 taken 62100 times.
✓ Branch 2 taken 178242 times.
✓ Branch 3 taken 8106 times.
 186348 for (x = 0; x < frame->width - 8 * (s->subsampling != SHQ_SUBSAMPLING_444); x += 16) {
326 /* Decode the four luma blocks. */
327
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
328 ✗ return ret;
329
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
330 ✗ return ret;
331
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
332 ✗ return ret;
333
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
334 ✗ return ret;
335
336 /*
337 * Decode the first chroma block. For 4:2:0, this is the only one;
338 * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
339 */
340
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
341 ✗ return ret;
342
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 178242 times.
 178242 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
343 ✗ return ret;
344
345
2/2
✓ Branch 0 taken 118842 times.
✓ Branch 1 taken 59400 times.
 178242 if (s->subsampling != SHQ_SUBSAMPLING_420) {
346 /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
347
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 118842 times.
 118842 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
348 ✗ return ret;
349
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 118842 times.
 118842 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
350 ✗ return ret;
351
352
2/2
✓ Branch 0 taken 59400 times.
✓ Branch 1 taken 59442 times.
 118842 if (s->subsampling == SHQ_SUBSAMPLING_444) {
353 /* Top-right and bottom-right blocks. */
354
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59400 times.
 59400 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
355 ✗ return ret;
356
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59400 times.
 59400 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
357 ✗ return ret;
358
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59400 times.
 59400 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
359 ✗ return ret;
360
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 59400 times.
 59400 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
361 ✗ return ret;
362
363 59400 dest_cb += 8;
364 59400 dest_cr += 8;
365 }
366 }
367 178242 dest_y += 16;
368 178242 dest_cb += 8;
369 178242 dest_cr += 8;
370
371
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 178242 times.
 178242 if (s->alpha_type == SHQ_RLE_ALPHA) {
372 /* Alpha coded using 16x8 RLE blocks. */
373 ✗ if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
374 ✗ return ret;
375 ✗ if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
376 ✗ return ret;
377 ✗ dest_a += 16;
378
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 178242 times.
 178242 } else if (s->alpha_type == SHQ_DCT_ALPHA) {
379 /* Alpha encoded exactly like luma. */
380 ✗ if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
381 ✗ return ret;
382 ✗ if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
383 ✗ return ret;
384 ✗ if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
385 ✗ return ret;
386 ✗ if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
387 ✗ return ret;
388 ✗ dest_a += 16;
389 }
390 }
391 }
392
393
3/6
✓ Branch 0 taken 1212 times.
✓ Branch 1 taken 600 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1212 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 1812 if (s->subsampling != SHQ_SUBSAMPLING_444 && (frame->width & 15) && slice_number == 3)
394 ✗ return decode_speedhq_border(s, &gb, frame, field_number, line_stride);
395
396 1812 return 0;
397 }
398
399 1804 static int decode_slice_progressive(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
400 {
401 1804 SHQContext *s = avctx->priv_data;
402 (void)threadnr;
403
404 1804 return decode_speedhq_field(avctx->priv_data, s->avpkt->data, s->avpkt->size, arg, 0, 4, s->avpkt->size, 1, jobnr);
405 }
406
407 8 static int decode_slice_interlaced(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
408 {
409 8 SHQContext *s = avctx->priv_data;
410 8 int field_number = jobnr / 4;
411 8 int slice_number = jobnr % 4;
412 (void)threadnr;
413
414
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
 8 if (field_number == 0)
415 4 return decode_speedhq_field(avctx->priv_data, s->avpkt->data, s->avpkt->size, arg, 0, 4, s->second_field_offset, 2, slice_number);
416 else
417 4 return decode_speedhq_field(avctx->priv_data, s->avpkt->data, s->avpkt->size, arg, 1, s->second_field_offset, s->avpkt->size, 2, slice_number);
418 }
419
420 452 static void compute_quant_matrix(int *output, int qscale)
421 {
422 int i;
423
2/2
✓ Branch 0 taken 28928 times.
✓ Branch 1 taken 452 times.
 29380 for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
424 452 }
425
426 452 static int speedhq_decode_frame(AVCodecContext *avctx, AVFrame *frame,
427 int *got_frame, AVPacket *avpkt)
428 {
429 452 SHQContext * const s = avctx->priv_data;
430 452 const uint8_t *buf = avpkt->data;
431 452 int buf_size = avpkt->size;
432 uint8_t quality;
433 int ret;
434
435
3/6
✓ Branch 0 taken 452 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 452 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 452 times.
 452 if (buf_size < 4 || avctx->width < 8 || avctx->width % 8 != 0)
436 ✗ return AVERROR_INVALIDDATA;
437
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452 times.
 452 if (buf_size < avctx->width*avctx->height / 64 / 4)
438 ✗ return AVERROR_INVALIDDATA;
439
440 452 quality = buf[0];
441
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452 times.
 452 if (quality >= 100) {
442 ✗ return AVERROR_INVALIDDATA;
443 }
444
445
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452 times.
 452 if (avctx->skip_frame >= AVDISCARD_ALL)
446 ✗ return avpkt->size;
447
448 452 compute_quant_matrix(s->quant_matrix, 100 - quality);
449
450 452 s->second_field_offset = AV_RL24(buf + 1);
451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452 times.
 452 if (s->second_field_offset >= buf_size - 3) {
452 ✗ return AVERROR_INVALIDDATA;
453 }
454
455 452 avctx->coded_width = FFALIGN(avctx->width, 16);
456 452 avctx->coded_height = FFALIGN(avctx->height, 16);
457
458
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 452 times.
 452 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0) {
459 ✗ return ret;
460 }
461
462 452 s->avpkt = avpkt;
463
464
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 451 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 452 if (s->second_field_offset == 4 || s->second_field_offset == (buf_size-4)) {
465 /*
466 * Overlapping first and second fields is used to signal
467 * encoding only a single field. In this case, "height"
468 * is ambiguous; it could mean either the height of the
469 * frame as a whole, or of the field. The former would make
470 * more sense for compatibility with legacy decoders,
471 * but this matches the convention used in NDI, which is
472 * the primary user of this trick.
473 */
474
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 451 times.
 451 if ((ret = avctx->execute2(avctx, decode_slice_progressive, frame, NULL, 4)) < 0)
475 ✗ return ret;
476 } else {
477
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if ((ret = avctx->execute2(avctx, decode_slice_interlaced, frame, NULL, 8)) < 0)
478 ✗ return ret;
479 }
480
481 452 *got_frame = 1;
482 452 return buf_size;
483 }
484
485 /*
486 * Alpha VLC. Run and level are independently coded, and would be
487 * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
488 * bother with combining them into one table.
489 */
490 11 static av_cold void compute_alpha_vlcs(void)
491 {
492 uint16_t run_code[134], level_code[266];
493 uint8_t run_bits[134], level_bits[266];
494 int16_t run_symbols[134], level_symbols[266];
495 int entry, i, sign;
496
497 /* Initialize VLC for alpha run. */
498 11 entry = 0;
499
500 /* 0 -> 0. */
501 11 run_code[entry] = 0;
502 11 run_bits[entry] = 1;
503 11 run_symbols[entry] = 0;
504 11 ++entry;
505
506 /* 10xx -> xx plus 1. */
507
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 11 times.
 55 for (i = 0; i < 4; ++i) {
508 44 run_code[entry] = (i << 2) | 1;
509 44 run_bits[entry] = 4;
510 44 run_symbols[entry] = i + 1;
511 44 ++entry;
512 }
513
514 /* 111xxxxxxx -> xxxxxxx. */
515
2/2
✓ Branch 0 taken 1408 times.
✓ Branch 1 taken 11 times.
 1419 for (i = 0; i < 128; ++i) {
516 1408 run_code[entry] = (i << 3) | 7;
517 1408 run_bits[entry] = 10;
518 1408 run_symbols[entry] = i;
519 1408 ++entry;
520 }
521
522 /* 110 -> EOB. */
523 11 run_code[entry] = 3;
524 11 run_bits[entry] = 3;
525 11 run_symbols[entry] = -1;
526 11 ++entry;
527
528
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 av_assert0(entry == FF_ARRAY_ELEMS(run_code));
529
530 11 VLC_INIT_STATIC_SPARSE_TABLE(dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
531 FF_ARRAY_ELEMS(run_code),
532 run_bits, 1, 1,
533 run_code, 2, 2,
534 run_symbols, 2, 2, VLC_INIT_LE);
535
536 /* Initialize VLC for alpha level. */
537 11 entry = 0;
538
539
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 11 times.
 33 for (sign = 0; sign <= 1; ++sign) {
540 /* 1s -> -1 or +1 (depending on sign bit). */
541 22 level_code[entry] = (sign << 1) | 1;
542 22 level_bits[entry] = 2;
543
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 11 times.
 22 level_symbols[entry] = sign ? -1 : 1;
544 22 ++entry;
545
546 /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
547
2/2
✓ Branch 0 taken 88 times.
✓ Branch 1 taken 22 times.
 110 for (i = 0; i < 4; ++i) {
548 88 level_code[entry] = (i << 3) | (sign << 2) | 2;
549 88 level_bits[entry] = 5;
550
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 44 times.
 88 level_symbols[entry] = sign ? -(i + 2) : (i + 2);
551 88 ++entry;
552 }
553 }
554
555 /*
556 * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
557 * here that would better be encoded in other ways (e.g. 0 would be
558 * encoded by increasing run, and +/- 1 would be encoded with a
559 * shorter code), but it doesn't hurt to allow everything.
560 */
561
2/2
✓ Branch 0 taken 2816 times.
✓ Branch 1 taken 11 times.
 2827 for (i = 0; i < 256; ++i) {
562 2816 level_code[entry] = i << 2;
563 2816 level_bits[entry] = 10;
564 2816 level_symbols[entry] = i;
565 2816 ++entry;
566 }
567
568
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 av_assert0(entry == FF_ARRAY_ELEMS(level_code));
569
570 11 VLC_INIT_STATIC_SPARSE_TABLE(dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
571 FF_ARRAY_ELEMS(level_code),
572 level_bits, 1, 1,
573 level_code, 2, 2,
574 level_symbols, 2, 2, VLC_INIT_LE);
575 11 }
576
577 11 static av_cold void speedhq_static_init(void)
578 {
579 /* Exactly the same as MPEG-2, except for a little-endian reader. */
580 11 VLC_INIT_STATIC_TABLE(dc_lum_vlc_le, DC_VLC_BITS, 12,
581 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
582 ff_mpeg12_vlc_dc_lum_code, 2, 2,
583 VLC_INIT_OUTPUT_LE);
584 11 VLC_INIT_STATIC_TABLE(dc_chroma_vlc_le, DC_VLC_BITS, 12,
585 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
586 ff_mpeg12_vlc_dc_chroma_code, 2, 2,
587 VLC_INIT_OUTPUT_LE);
588
589 11 ff_init_2d_vlc_rl(ff_speedhq_vlc_table, speedhq_rl_vlc, ff_speedhq_run,
590 ff_speedhq_level, SPEEDHQ_RL_NB_ELEMS,
591 FF_ARRAY_ELEMS(speedhq_rl_vlc), VLC_INIT_LE);
592
593 11 compute_alpha_vlcs();
594 11 }
595
596 22 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
597 {
598 int ret;
599 static AVOnce init_once = AV_ONCE_INIT;
600 22 SHQContext * const s = avctx->priv_data;
601
602 22 ret = ff_thread_once(&init_once, speedhq_static_init);
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
 22 if (ret)
604 ✗ return AVERROR_UNKNOWN;
605
606 22 ff_blockdsp_init(&s->bdsp);
607 22 ff_idctdsp_init(&s->idsp, avctx);
608 22 ff_permute_scantable(s->permutated_intra_scantable, ff_zigzag_direct,
609 22 s->idsp.idct_permutation);
610
611
4/9
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
 22 switch (avctx->codec_tag) {
612 6 case MKTAG('S', 'H', 'Q', '0'):
613 6 s->subsampling = SHQ_SUBSAMPLING_420;
614 6 s->alpha_type = SHQ_NO_ALPHA;
615 6 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
616 6 break;
617 ✗ case MKTAG('S', 'H', 'Q', '1'):
618 ✗ s->subsampling = SHQ_SUBSAMPLING_420;
619 ✗ s->alpha_type = SHQ_RLE_ALPHA;
620 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
621 ✗ break;
622 8 case MKTAG('S', 'H', 'Q', '2'):
623 8 s->subsampling = SHQ_SUBSAMPLING_422;
624 8 s->alpha_type = SHQ_NO_ALPHA;
625 8 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
626 8 break;
627 ✗ case MKTAG('S', 'H', 'Q', '3'):
628 ✗ s->subsampling = SHQ_SUBSAMPLING_422;
629 ✗ s->alpha_type = SHQ_RLE_ALPHA;
630 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
631 ✗ break;
632 6 case MKTAG('S', 'H', 'Q', '4'):
633 6 s->subsampling = SHQ_SUBSAMPLING_444;
634 6 s->alpha_type = SHQ_NO_ALPHA;
635 6 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
636 6 break;
637 ✗ case MKTAG('S', 'H', 'Q', '5'):
638 ✗ s->subsampling = SHQ_SUBSAMPLING_444;
639 ✗ s->alpha_type = SHQ_RLE_ALPHA;
640 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
641 ✗ break;
642 ✗ case MKTAG('S', 'H', 'Q', '7'):
643 ✗ s->subsampling = SHQ_SUBSAMPLING_422;
644 ✗ s->alpha_type = SHQ_DCT_ALPHA;
645 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
646 ✗ break;
647 ✗ case MKTAG('S', 'H', 'Q', '9'):
648 ✗ s->subsampling = SHQ_SUBSAMPLING_444;
649 ✗ s->alpha_type = SHQ_DCT_ALPHA;
650 ✗ avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
651 ✗ break;
652 2 default:
653 2 av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
654 avctx->codec_tag);
655 2 return AVERROR_INVALIDDATA;
656 }
657
658 /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
659 20 avctx->colorspace = AVCOL_SPC_BT470BG;
660 20 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
661
662 20 return 0;
663 }
664
665 const FFCodec ff_speedhq_decoder = {
666 .p.name = "speedhq",
667 CODEC_LONG_NAME("NewTek SpeedHQ"),
668 .p.type = AVMEDIA_TYPE_VIDEO,
669 .p.id = AV_CODEC_ID_SPEEDHQ,
670 .priv_data_size = sizeof(SHQContext),
671 .init = speedhq_decode_init,
672 FF_CODEC_DECODE_CB(speedhq_decode_frame),
673 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
674 };
675