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 |