Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/svq1dec.c |
Date: | 2022-07-07 01:21:54 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 291 | 344 | 84.6% |
Branches: | 163 | 215 | 75.8% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * SVQ1 decoder | ||
3 | * ported to MPlayer by Arpi <arpi@thot.banki.hu> | ||
4 | * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru> | ||
5 | * | ||
6 | * Copyright (c) 2002 The Xine project | ||
7 | * Copyright (c) 2002 The FFmpeg project | ||
8 | * | ||
9 | * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net> | ||
10 | * | ||
11 | * This file is part of FFmpeg. | ||
12 | * | ||
13 | * FFmpeg is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU Lesser General Public | ||
15 | * License as published by the Free Software Foundation; either | ||
16 | * version 2.1 of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * FFmpeg is distributed in the hope that it will be useful, | ||
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
21 | * Lesser General Public License for more details. | ||
22 | * | ||
23 | * You should have received a copy of the GNU Lesser General Public | ||
24 | * License along with FFmpeg; if not, write to the Free Software | ||
25 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
26 | */ | ||
27 | |||
28 | /** | ||
29 | * @file | ||
30 | * Sorenson Vector Quantizer #1 (SVQ1) video codec. | ||
31 | * For more information of the SVQ1 algorithm, visit: | ||
32 | * http://www.pcisys.net/~melanson/codecs/ | ||
33 | */ | ||
34 | |||
35 | #include "libavutil/crc.h" | ||
36 | #include "libavutil/thread.h" | ||
37 | |||
38 | #include "avcodec.h" | ||
39 | #include "codec_internal.h" | ||
40 | #include "get_bits.h" | ||
41 | #include "h263data.h" | ||
42 | #include "hpeldsp.h" | ||
43 | #include "internal.h" | ||
44 | #include "mathops.h" | ||
45 | #include "svq1.h" | ||
46 | |||
47 | #define SVQ1_BLOCK_TYPE_VLC_BITS 3 | ||
48 | static VLC svq1_block_type; | ||
49 | static VLC svq1_motion_component; | ||
50 | static VLC svq1_intra_multistage[6]; | ||
51 | static VLC svq1_inter_multistage[6]; | ||
52 | static VLC svq1_intra_mean; | ||
53 | static VLC svq1_inter_mean; | ||
54 | |||
55 | /* motion vector (prediction) */ | ||
56 | typedef struct svq1_pmv_s { | ||
57 | int x; | ||
58 | int y; | ||
59 | } svq1_pmv; | ||
60 | |||
61 | typedef struct SVQ1Context { | ||
62 | HpelDSPContext hdsp; | ||
63 | GetBitContext gb; | ||
64 | AVFrame *prev; | ||
65 | |||
66 | uint8_t *pkt_swapped; | ||
67 | int pkt_swapped_allocated; | ||
68 | |||
69 | svq1_pmv *pmv; | ||
70 | int pmv_allocated; | ||
71 | |||
72 | int width; | ||
73 | int height; | ||
74 | int frame_code; | ||
75 | int nonref; // 1 if the current frame won't be referenced | ||
76 | } SVQ1Context; | ||
77 | |||
78 | static const uint8_t string_table[256] = { | ||
79 | 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54, | ||
80 | 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D, | ||
81 | 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06, | ||
82 | 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F, | ||
83 | 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0, | ||
84 | 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9, | ||
85 | 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2, | ||
86 | 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B, | ||
87 | 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9, | ||
88 | 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0, | ||
89 | 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B, | ||
90 | 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2, | ||
91 | 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D, | ||
92 | 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44, | ||
93 | 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F, | ||
94 | 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16, | ||
95 | 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB, | ||
96 | 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92, | ||
97 | 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9, | ||
98 | 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0, | ||
99 | 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F, | ||
100 | 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36, | ||
101 | 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D, | ||
102 | 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64, | ||
103 | 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26, | ||
104 | 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F, | ||
105 | 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74, | ||
106 | 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D, | ||
107 | 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82, | ||
108 | 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB, | ||
109 | 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0, | ||
110 | 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 | ||
111 | }; | ||
112 | |||
113 | #define SVQ1_PROCESS_VECTOR() \ | ||
114 | for (; level > 0; i++) { \ | ||
115 | /* process next depth */ \ | ||
116 | if (i == m) { \ | ||
117 | m = n; \ | ||
118 | if (--level == 0) \ | ||
119 | break; \ | ||
120 | } \ | ||
121 | /* divide block if next bit set */ \ | ||
122 | if (!get_bits1(bitbuf)) \ | ||
123 | break; \ | ||
124 | /* add child nodes */ \ | ||
125 | list[n++] = list[i]; \ | ||
126 | list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\ | ||
127 | } | ||
128 | |||
129 | #define SVQ1_ADD_CODEBOOK() \ | ||
130 | /* add codebook entries to vector */ \ | ||
131 | for (j = 0; j < stages; j++) { \ | ||
132 | n3 = codebook[entries[j]] ^ 0x80808080; \ | ||
133 | n1 += (n3 & 0xFF00FF00) >> 8; \ | ||
134 | n2 += n3 & 0x00FF00FF; \ | ||
135 | } \ | ||
136 | \ | ||
137 | /* clip to [0..255] */ \ | ||
138 | if (n1 & 0xFF00FF00) { \ | ||
139 | n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ | ||
140 | n1 += 0x7F007F00; \ | ||
141 | n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ | ||
142 | n1 &= n3 & 0x00FF00FF; \ | ||
143 | } \ | ||
144 | \ | ||
145 | if (n2 & 0xFF00FF00) { \ | ||
146 | n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ | ||
147 | n2 += 0x7F007F00; \ | ||
148 | n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \ | ||
149 | n2 &= n3 & 0x00FF00FF; \ | ||
150 | } | ||
151 | |||
152 | #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \ | ||
153 | codebook = (const uint32_t *)cbook[level]; \ | ||
154 | if (stages > 0) \ | ||
155 | bit_cache = get_bits(bitbuf, 4 * stages); \ | ||
156 | /* calculate codebook entries for this vector */ \ | ||
157 | for (j = 0; j < stages; j++) { \ | ||
158 | entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \ | ||
159 | 16 * j) << (level + 1); \ | ||
160 | } \ | ||
161 | mean -= stages * 128; \ | ||
162 | n4 = (mean << 16) + mean; | ||
163 | |||
164 | 12351 | static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, | |
165 | ptrdiff_t pitch) | ||
166 | { | ||
167 | uint32_t bit_cache; | ||
168 | uint8_t *list[63]; | ||
169 | uint32_t *dst; | ||
170 | const uint32_t *codebook; | ||
171 | int entries[6]; | ||
172 | int i, j, m, n; | ||
173 | int stages; | ||
174 | unsigned mean; | ||
175 | unsigned x, y, width, height, level; | ||
176 | uint32_t n1, n2, n3, n4; | ||
177 | |||
178 | /* initialize list for breadth first processing of vectors */ | ||
179 | 12351 | list[0] = pixels; | |
180 | |||
181 | /* recursively process vector */ | ||
182 |
2/2✓ Branch 0 taken 243825 times.
✓ Branch 1 taken 12351 times.
|
256176 | for (i = 0, m = 1, n = 1, level = 5; i < n; i++) { |
183 |
10/10✓ Branch 0 taken 58403 times.
✓ Branch 1 taken 261398 times.
✓ Branch 2 taken 11200 times.
✓ Branch 3 taken 47203 times.
✓ Branch 5 taken 77127 times.
✓ Branch 6 taken 231474 times.
✓ Branch 7 taken 139134 times.
✓ Branch 8 taken 92340 times.
✓ Branch 9 taken 319801 times.
✓ Branch 10 taken 155498 times.
|
475299 | SVQ1_PROCESS_VECTOR(); |
184 | |||
185 | /* destination address and vector size */ | ||
186 | 243825 | dst = (uint32_t *)list[i]; | |
187 | 243825 | width = 1 << ((4 + level) / 2); | |
188 | 243825 | height = 1 << ((3 + level) / 2); | |
189 | |||
190 | /* get number of stages (-1 skips vector, 0 for mean only) */ | ||
191 | 243825 | stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; | |
192 | |||
193 |
2/2✓ Branch 0 taken 371 times.
✓ Branch 1 taken 243454 times.
|
243825 | if (stages == -1) { |
194 |
2/2✓ Branch 0 taken 4122 times.
✓ Branch 1 taken 371 times.
|
4493 | for (y = 0; y < height; y++) |
195 | 4122 | memset(&dst[y * (pitch / 4)], 0, width); | |
196 | 371 | continue; /* skip vector */ | |
197 | } | ||
198 | |||
199 |
3/4✓ Branch 0 taken 183685 times.
✓ Branch 1 taken 59769 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 183685 times.
|
243454 | if ((stages > 0 && level >= 4)) { |
200 | ff_dlog(NULL, | ||
201 | "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n", | ||
202 | stages, level); | ||
203 | ✗ | return AVERROR_INVALIDDATA; /* invalid vector */ | |
204 | } | ||
205 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 243454 times.
|
243454 | av_assert0(stages >= 0); |
206 | |||
207 | 243454 | mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); | |
208 | |||
209 |
2/2✓ Branch 0 taken 59769 times.
✓ Branch 1 taken 183685 times.
|
243454 | if (stages == 0) { |
210 |
2/2✓ Branch 0 taken 158460 times.
✓ Branch 1 taken 59769 times.
|
218229 | for (y = 0; y < height; y++) |
211 | 158460 | memset(&dst[y * (pitch / 4)], mean, width); | |
212 | } else { | ||
213 |
3/4✓ Branch 0 taken 183685 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 949620 times.
✓ Branch 4 taken 183685 times.
|
1133305 | SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks); |
214 | |||
215 |
2/2✓ Branch 0 taken 498670 times.
✓ Branch 1 taken 183685 times.
|
682355 | for (y = 0; y < height; y++) { |
216 |
2/2✓ Branch 0 taken 581038 times.
✓ Branch 1 taken 498670 times.
|
1079708 | for (x = 0; x < width / 4; x++, codebook++) { |
217 | 581038 | n1 = n4; | |
218 | 581038 | n2 = n4; | |
219 |
6/6✓ Branch 0 taken 2929164 times.
✓ Branch 1 taken 581038 times.
✓ Branch 2 taken 221 times.
✓ Branch 3 taken 580817 times.
✓ Branch 4 taken 350 times.
✓ Branch 5 taken 580688 times.
|
3510202 | SVQ1_ADD_CODEBOOK() |
220 | /* store result */ | ||
221 | 581038 | dst[x] = n1 << 8 | n2; | |
222 | } | ||
223 | 498670 | dst += pitch / 4; | |
224 | } | ||
225 | } | ||
226 | } | ||
227 | |||
228 | 12351 | return 0; | |
229 | } | ||
230 | |||
231 | 65696 | static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, | |
232 | ptrdiff_t pitch) | ||
233 | { | ||
234 | uint32_t bit_cache; | ||
235 | uint8_t *list[63]; | ||
236 | uint32_t *dst; | ||
237 | const uint32_t *codebook; | ||
238 | int entries[6]; | ||
239 | int i, j, m, n; | ||
240 | int stages; | ||
241 | unsigned mean; | ||
242 | int x, y, width, height, level; | ||
243 | uint32_t n1, n2, n3, n4; | ||
244 | |||
245 | /* initialize list for breadth first processing of vectors */ | ||
246 | 65696 | list[0] = pixels; | |
247 | |||
248 | /* recursively process vector */ | ||
249 |
2/2✓ Branch 0 taken 1233266 times.
✓ Branch 1 taken 65696 times.
|
1298962 | for (i = 0, m = 1, n = 1, level = 5; i < n; i++) { |
250 |
10/10✓ Branch 0 taken 310715 times.
✓ Branch 1 taken 1258020 times.
✓ Branch 2 taken 60447 times.
✓ Branch 3 taken 250268 times.
✓ Branch 5 taken 340718 times.
✓ Branch 6 taken 1167570 times.
✓ Branch 7 taken 713328 times.
✓ Branch 8 taken 454242 times.
✓ Branch 9 taken 1568735 times.
✓ Branch 10 taken 832101 times.
|
2400836 | SVQ1_PROCESS_VECTOR(); |
251 | |||
252 | /* destination address and vector size */ | ||
253 | 1233266 | dst = (uint32_t *)list[i]; | |
254 | 1233266 | width = 1 << ((4 + level) / 2); | |
255 | 1233266 | height = 1 << ((3 + level) / 2); | |
256 | |||
257 | /* get number of stages (-1 skips vector, 0 for mean only) */ | ||
258 | 1233266 | stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; | |
259 | |||
260 |
2/2✓ Branch 0 taken 29737 times.
✓ Branch 1 taken 1203529 times.
|
1233266 | if (stages == -1) |
261 | 29737 | continue; /* skip vector */ | |
262 | |||
263 |
3/4✓ Branch 0 taken 466226 times.
✓ Branch 1 taken 737303 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 466226 times.
|
1203529 | if ((stages > 0 && level >= 4)) { |
264 | ff_dlog(NULL, | ||
265 | "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n", | ||
266 | stages, level); | ||
267 | ✗ | return AVERROR_INVALIDDATA; /* invalid vector */ | |
268 | } | ||
269 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1203529 times.
|
1203529 | av_assert0(stages >= 0); |
270 | |||
271 | 1203529 | mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256; | |
272 | |||
273 |
4/4✓ Branch 0 taken 466226 times.
✓ Branch 1 taken 737303 times.
✓ Branch 3 taken 2167826 times.
✓ Branch 4 taken 1203529 times.
|
3371355 | SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks); |
274 | |||
275 |
2/2✓ Branch 0 taken 3227410 times.
✓ Branch 1 taken 1203529 times.
|
4430939 | for (y = 0; y < height; y++) { |
276 |
2/2✓ Branch 0 taken 4009806 times.
✓ Branch 1 taken 3227410 times.
|
7237216 | for (x = 0; x < width / 4; x++, codebook++) { |
277 | 4009806 | n3 = dst[x]; | |
278 | /* add mean value to vector */ | ||
279 | 4009806 | n1 = n4 + ((n3 & 0xFF00FF00) >> 8); | |
280 | 4009806 | n2 = n4 + (n3 & 0x00FF00FF); | |
281 |
6/6✓ Branch 0 taken 5352234 times.
✓ Branch 1 taken 4009806 times.
✓ Branch 2 taken 8338 times.
✓ Branch 3 taken 4001468 times.
✓ Branch 4 taken 8633 times.
✓ Branch 5 taken 4001173 times.
|
9362040 | SVQ1_ADD_CODEBOOK() |
282 | /* store result */ | ||
283 | 4009806 | dst[x] = n1 << 8 | n2; | |
284 | } | ||
285 | 3227410 | dst += pitch / 4; | |
286 | } | ||
287 | } | ||
288 | 65696 | return 0; | |
289 | } | ||
290 | |||
291 | 79616 | static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, | |
292 | svq1_pmv **pmv) | ||
293 | { | ||
294 | int diff; | ||
295 | int i; | ||
296 | |||
297 |
2/2✓ Branch 0 taken 159232 times.
✓ Branch 1 taken 79616 times.
|
238848 | for (i = 0; i < 2; i++) { |
298 | /* get motion code */ | ||
299 | 159232 | diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); | |
300 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 159232 times.
|
159232 | if (diff < 0) |
301 | ✗ | return AVERROR_INVALIDDATA; | |
302 |
2/2✓ Branch 0 taken 78989 times.
✓ Branch 1 taken 80243 times.
|
159232 | else if (diff) { |
303 |
2/2✓ Branch 1 taken 34286 times.
✓ Branch 2 taken 44703 times.
|
78989 | if (get_bits1(bitbuf)) |
304 | 34286 | diff = -diff; | |
305 | } | ||
306 | |||
307 | /* add median of motion vector predictors and clip result */ | ||
308 |
2/2✓ Branch 0 taken 79616 times.
✓ Branch 1 taken 79616 times.
|
159232 | if (i == 1) |
309 | 79616 | mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6); | |
310 | else | ||
311 | 79616 | mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6); | |
312 | } | ||
313 | |||
314 | 79616 | return 0; | |
315 | } | ||
316 | |||
317 | 5827 | static void svq1_skip_block(uint8_t *current, uint8_t *previous, | |
318 | ptrdiff_t pitch, int x, int y) | ||
319 | { | ||
320 | uint8_t *src; | ||
321 | uint8_t *dst; | ||
322 | int i; | ||
323 | |||
324 | 5827 | src = &previous[x + y * pitch]; | |
325 | 5827 | dst = current; | |
326 | |||
327 |
2/2✓ Branch 0 taken 93232 times.
✓ Branch 1 taken 5827 times.
|
99059 | for (i = 0; i < 16; i++) { |
328 | 93232 | memcpy(dst, src, 16); | |
329 | 93232 | src += pitch; | |
330 | 93232 | dst += pitch; | |
331 | } | ||
332 | 5827 | } | |
333 | |||
334 | 61056 | static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, | |
335 | uint8_t *current, uint8_t *previous, | ||
336 | ptrdiff_t pitch, svq1_pmv *motion, int x, int y, | ||
337 | int width, int height) | ||
338 | { | ||
339 | uint8_t *src; | ||
340 | uint8_t *dst; | ||
341 | svq1_pmv mv; | ||
342 | svq1_pmv *pmv[3]; | ||
343 | int result; | ||
344 | |||
345 | /* predict and decode motion vector */ | ||
346 | 61056 | pmv[0] = &motion[0]; | |
347 |
2/2✓ Branch 0 taken 5027 times.
✓ Branch 1 taken 56029 times.
|
61056 | if (y == 0) { |
348 | 5027 | pmv[1] = | |
349 | 5027 | pmv[2] = pmv[0]; | |
350 | } else { | ||
351 | 56029 | pmv[1] = &motion[x / 8 + 2]; | |
352 | 56029 | pmv[2] = &motion[x / 8 + 4]; | |
353 | } | ||
354 | |||
355 | 61056 | result = svq1_decode_motion_vector(bitbuf, &mv, pmv); | |
356 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61056 times.
|
61056 | if (result) |
357 | ✗ | return result; | |
358 | |||
359 | 61056 | motion[0].x = | |
360 | 61056 | motion[x / 8 + 2].x = | |
361 | 61056 | motion[x / 8 + 3].x = mv.x; | |
362 | 61056 | motion[0].y = | |
363 | 61056 | motion[x / 8 + 2].y = | |
364 | 61056 | motion[x / 8 + 3].y = mv.y; | |
365 | |||
366 | 61056 | mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16)); | |
367 | 61056 | mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16)); | |
368 | |||
369 | 61056 | src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch]; | |
370 | 61056 | dst = current; | |
371 | |||
372 | 61056 | hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16); | |
373 | |||
374 | 61056 | return 0; | |
375 | } | ||
376 | |||
377 | 4640 | static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, | |
378 | uint8_t *current, uint8_t *previous, | ||
379 | ptrdiff_t pitch, svq1_pmv *motion, int x, int y, | ||
380 | int width, int height) | ||
381 | { | ||
382 | uint8_t *src; | ||
383 | uint8_t *dst; | ||
384 | svq1_pmv mv; | ||
385 | svq1_pmv *pmv[4]; | ||
386 | int i, result; | ||
387 | |||
388 | /* predict and decode motion vector (0) */ | ||
389 | 4640 | pmv[0] = &motion[0]; | |
390 |
2/2✓ Branch 0 taken 729 times.
✓ Branch 1 taken 3911 times.
|
4640 | if (y == 0) { |
391 | 729 | pmv[1] = | |
392 | 729 | pmv[2] = pmv[0]; | |
393 | } else { | ||
394 | 3911 | pmv[1] = &motion[(x / 8) + 2]; | |
395 | 3911 | pmv[2] = &motion[(x / 8) + 4]; | |
396 | } | ||
397 | |||
398 | 4640 | result = svq1_decode_motion_vector(bitbuf, &mv, pmv); | |
399 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
|
4640 | if (result) |
400 | ✗ | return result; | |
401 | |||
402 | /* predict and decode motion vector (1) */ | ||
403 | 4640 | pmv[0] = &mv; | |
404 |
2/2✓ Branch 0 taken 729 times.
✓ Branch 1 taken 3911 times.
|
4640 | if (y == 0) { |
405 | 729 | pmv[1] = | |
406 | 729 | pmv[2] = pmv[0]; | |
407 | } else { | ||
408 | 3911 | pmv[1] = &motion[(x / 8) + 3]; | |
409 | } | ||
410 | 4640 | result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv); | |
411 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
|
4640 | if (result) |
412 | ✗ | return result; | |
413 | |||
414 | /* predict and decode motion vector (2) */ | ||
415 | 4640 | pmv[1] = &motion[0]; | |
416 | 4640 | pmv[2] = &motion[(x / 8) + 1]; | |
417 | |||
418 | 4640 | result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv); | |
419 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
|
4640 | if (result) |
420 | ✗ | return result; | |
421 | |||
422 | /* predict and decode motion vector (3) */ | ||
423 | 4640 | pmv[2] = &motion[(x / 8) + 2]; | |
424 | 4640 | pmv[3] = &motion[(x / 8) + 3]; | |
425 | |||
426 | 4640 | result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv); | |
427 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
|
4640 | if (result) |
428 | ✗ | return result; | |
429 | |||
430 | /* form predictions */ | ||
431 |
2/2✓ Branch 0 taken 18560 times.
✓ Branch 1 taken 4640 times.
|
23200 | for (i = 0; i < 4; i++) { |
432 | 18560 | int mvx = pmv[i]->x + (i & 1) * 16; | |
433 | 18560 | int mvy = pmv[i]->y + (i >> 1) * 16; | |
434 | |||
435 | // FIXME: clipping or padding? | ||
436 | 18560 | mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8)); | |
437 | 18560 | mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8)); | |
438 | |||
439 | 18560 | src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch]; | |
440 | 18560 | dst = current; | |
441 | |||
442 | 18560 | hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8); | |
443 | |||
444 | /* select next block */ | ||
445 |
2/2✓ Branch 0 taken 9280 times.
✓ Branch 1 taken 9280 times.
|
18560 | if (i & 1) |
446 | 9280 | current += 8 * (pitch - 1); | |
447 | else | ||
448 | 9280 | current += 8; | |
449 | } | ||
450 | |||
451 | 4640 | return 0; | |
452 | } | ||
453 | |||
454 | 75341 | static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, | |
455 | GetBitContext *bitbuf, | ||
456 | uint8_t *current, uint8_t *previous, | ||
457 | ptrdiff_t pitch, svq1_pmv *motion, int x, int y, | ||
458 | int width, int height) | ||
459 | { | ||
460 | uint32_t block_type; | ||
461 | 75341 | int result = 0; | |
462 | |||
463 | /* get block type */ | ||
464 | 75341 | block_type = get_vlc2(bitbuf, svq1_block_type.table, | |
465 | SVQ1_BLOCK_TYPE_VLC_BITS, 1); | ||
466 | |||
467 | /* reset motion vectors */ | ||
468 |
4/4✓ Branch 0 taken 69514 times.
✓ Branch 1 taken 5827 times.
✓ Branch 2 taken 3818 times.
✓ Branch 3 taken 65696 times.
|
75341 | if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) { |
469 | 9645 | motion[0].x = | |
470 | 9645 | motion[0].y = | |
471 | 9645 | motion[x / 8 + 2].x = | |
472 | 9645 | motion[x / 8 + 2].y = | |
473 | 9645 | motion[x / 8 + 3].x = | |
474 | 9645 | motion[x / 8 + 3].y = 0; | |
475 | } | ||
476 | |||
477 |
4/5✓ Branch 0 taken 5827 times.
✓ Branch 1 taken 61056 times.
✓ Branch 2 taken 4640 times.
✓ Branch 3 taken 3818 times.
✗ Branch 4 not taken.
|
75341 | switch (block_type) { |
478 | 5827 | case SVQ1_BLOCK_SKIP: | |
479 | 5827 | svq1_skip_block(current, previous, pitch, x, y); | |
480 | 5827 | break; | |
481 | |||
482 | 61056 | case SVQ1_BLOCK_INTER: | |
483 | 61056 | result = svq1_motion_inter_block(hdsp, bitbuf, current, previous, | |
484 | pitch, motion, x, y, width, height); | ||
485 | |||
486 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61056 times.
|
61056 | if (result != 0) { |
487 | ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result); | ||
488 | ✗ | break; | |
489 | } | ||
490 | 61056 | result = svq1_decode_block_non_intra(bitbuf, current, pitch); | |
491 | 61056 | break; | |
492 | |||
493 | 4640 | case SVQ1_BLOCK_INTER_4V: | |
494 | 4640 | result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous, | |
495 | pitch, motion, x, y, width, height); | ||
496 | |||
497 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
|
4640 | if (result != 0) { |
498 | ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result); | ||
499 | ✗ | break; | |
500 | } | ||
501 | 4640 | result = svq1_decode_block_non_intra(bitbuf, current, pitch); | |
502 | 4640 | break; | |
503 | |||
504 | 3818 | case SVQ1_BLOCK_INTRA: | |
505 | 3818 | result = svq1_decode_block_intra(bitbuf, current, pitch); | |
506 | 3818 | break; | |
507 | } | ||
508 | |||
509 | 75341 | return result; | |
510 | } | ||
511 | |||
512 | ✗ | static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257]) | |
513 | { | ||
514 | uint8_t seed; | ||
515 | int i; | ||
516 | |||
517 | ✗ | out[0] = get_bits(bitbuf, 8); | |
518 | ✗ | seed = string_table[out[0]]; | |
519 | |||
520 | ✗ | for (i = 1; i <= out[0]; i++) { | |
521 | ✗ | out[i] = get_bits(bitbuf, 8) ^ seed; | |
522 | ✗ | seed = string_table[out[i] ^ seed]; | |
523 | } | ||
524 | ✗ | out[i] = 0; | |
525 | } | ||
526 | |||
527 | 355 | static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame) | |
528 | { | ||
529 | 355 | SVQ1Context *s = avctx->priv_data; | |
530 | 355 | GetBitContext *bitbuf = &s->gb; | |
531 | int frame_size_code; | ||
532 | 355 | int width = s->width; | |
533 | 355 | int height = s->height; | |
534 | |||
535 | 355 | skip_bits(bitbuf, 8); /* temporal_reference */ | |
536 | |||
537 | /* frame type */ | ||
538 | 355 | s->nonref = 0; | |
539 |
2/4✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 319 times.
✗ Branch 4 not taken.
|
355 | switch (get_bits(bitbuf, 2)) { |
540 | 36 | case 0: | |
541 | 36 | frame->pict_type = AV_PICTURE_TYPE_I; | |
542 | 36 | break; | |
543 | ✗ | case 2: | |
544 | ✗ | s->nonref = 1; | |
545 | 319 | case 1: | |
546 | 319 | frame->pict_type = AV_PICTURE_TYPE_P; | |
547 | 319 | break; | |
548 | ✗ | default: | |
549 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n"); | |
550 | ✗ | return AVERROR_INVALIDDATA; | |
551 | } | ||
552 | |||
553 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 319 times.
|
355 | if (frame->pict_type == AV_PICTURE_TYPE_I) { |
554 | /* unknown fields */ | ||
555 |
3/4✓ Branch 0 taken 35 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 35 times.
|
36 | if (s->frame_code == 0x50 || s->frame_code == 0x60) { |
556 | 1 | int csum = get_bits(bitbuf, 16); | |
557 | |||
558 | 1 | csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3)); | |
559 | |||
560 | ff_dlog(avctx, "%s checksum (%02x) for packet data\n", | ||
561 | (csum == 0) ? "correct" : "incorrect", csum); | ||
562 | } | ||
563 | |||
564 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
|
36 | if ((s->frame_code ^ 0x10) >= 0x50) { |
565 | uint8_t msg[257]; | ||
566 | |||
567 | ✗ | svq1_parse_string(bitbuf, msg); | |
568 | |||
569 | ✗ | av_log(avctx, AV_LOG_INFO, | |
570 | "embedded message:\n%s\n", ((char *)msg) + 1); | ||
571 | } | ||
572 | |||
573 | 36 | skip_bits(bitbuf, 2); | |
574 | 36 | skip_bits(bitbuf, 2); | |
575 | 36 | skip_bits1(bitbuf); | |
576 | |||
577 | /* load frame size */ | ||
578 | 36 | frame_size_code = get_bits(bitbuf, 3); | |
579 | |||
580 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 30 times.
|
36 | if (frame_size_code == 7) { |
581 | /* load width, height (12 bits each) */ | ||
582 | 6 | width = get_bits(bitbuf, 12); | |
583 | 6 | height = get_bits(bitbuf, 12); | |
584 | |||
585 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
|
6 | if (!width || !height) |
586 | ✗ | return AVERROR_INVALIDDATA; | |
587 | } else { | ||
588 | /* get width, height from table */ | ||
589 | 30 | width = ff_svq1_frame_size_table[frame_size_code][0]; | |
590 | 30 | height = ff_svq1_frame_size_table[frame_size_code][1]; | |
591 | } | ||
592 | } | ||
593 | |||
594 | /* unknown fields */ | ||
595 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 355 times.
|
355 | if (get_bits1(bitbuf)) { |
596 | ✗ | skip_bits1(bitbuf); /* use packet checksum if (1) */ | |
597 | ✗ | skip_bits1(bitbuf); /* component checksums after image data if (1) */ | |
598 | |||
599 | ✗ | if (get_bits(bitbuf, 2) != 0) | |
600 | ✗ | return AVERROR_INVALIDDATA; | |
601 | } | ||
602 | |||
603 |
2/2✓ Branch 1 taken 155 times.
✓ Branch 2 taken 200 times.
|
355 | if (get_bits1(bitbuf)) { |
604 | 155 | skip_bits1(bitbuf); | |
605 | 155 | skip_bits(bitbuf, 4); | |
606 | 155 | skip_bits1(bitbuf); | |
607 | 155 | skip_bits(bitbuf, 2); | |
608 | |||
609 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 155 times.
|
155 | if (skip_1stop_8data_bits(bitbuf) < 0) |
610 | ✗ | return AVERROR_INVALIDDATA; | |
611 | } | ||
612 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 355 times.
|
355 | if (get_bits_left(bitbuf) <= 0) |
613 | ✗ | return AVERROR_INVALIDDATA; | |
614 | |||
615 | 355 | s->width = width; | |
616 | 355 | s->height = height; | |
617 | 355 | return 0; | |
618 | } | ||
619 | |||
620 | 355 | static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, | |
621 | int *got_frame, AVPacket *avpkt) | ||
622 | { | ||
623 | 355 | const uint8_t *buf = avpkt->data; | |
624 | 355 | int buf_size = avpkt->size; | |
625 | 355 | SVQ1Context *s = avctx->priv_data; | |
626 | uint8_t *current; | ||
627 | int result, i, x, y, width, height; | ||
628 | int ret; | ||
629 | |||
630 | /* initialize bit buffer */ | ||
631 | 355 | ret = init_get_bits8(&s->gb, buf, buf_size); | |
632 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (ret < 0) |
633 | ✗ | return ret; | |
634 | |||
635 | /* decode frame header */ | ||
636 | 355 | s->frame_code = get_bits(&s->gb, 22); | |
637 | |||
638 |
2/4✓ Branch 0 taken 355 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 355 times.
|
355 | if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60)) |
639 | ✗ | return AVERROR_INVALIDDATA; | |
640 | |||
641 | /* swap some header bytes (why?) */ | ||
642 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 351 times.
|
355 | if (s->frame_code != 0x20) { |
643 | uint32_t *src; | ||
644 | |||
645 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (buf_size < 9 * 4) { |
646 | ✗ | av_log(avctx, AV_LOG_ERROR, "Input packet too small\n"); | |
647 | ✗ | return AVERROR_INVALIDDATA; | |
648 | } | ||
649 | |||
650 | 4 | av_fast_padded_malloc(&s->pkt_swapped, | |
651 | 4 | &s->pkt_swapped_allocated, | |
652 | buf_size); | ||
653 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!s->pkt_swapped) |
654 | ✗ | return AVERROR(ENOMEM); | |
655 | |||
656 | 4 | memcpy(s->pkt_swapped, buf, buf_size); | |
657 | 4 | buf = s->pkt_swapped; | |
658 | 4 | init_get_bits(&s->gb, buf, buf_size * 8); | |
659 | 4 | skip_bits(&s->gb, 22); | |
660 | |||
661 | 4 | src = (uint32_t *)(s->pkt_swapped + 4); | |
662 | |||
663 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4 times.
|
20 | for (i = 0; i < 4; i++) |
664 | 16 | src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; | |
665 | } | ||
666 | |||
667 | 355 | result = svq1_decode_frame_header(avctx, cur); | |
668 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (result != 0) { |
669 | ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result); | ||
670 | ✗ | return result; | |
671 | } | ||
672 | |||
673 | 355 | result = ff_set_dimensions(avctx, s->width, s->height); | |
674 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (result < 0) |
675 | ✗ | return result; | |
676 | |||
677 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
355 | if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) || |
678 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | (avctx->skip_frame >= AVDISCARD_NONKEY && |
679 | ✗ | cur->pict_type != AV_PICTURE_TYPE_I) || | |
680 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | avctx->skip_frame >= AVDISCARD_ALL) |
681 | ✗ | return buf_size; | |
682 | |||
683 | 355 | result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF); | |
684 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (result < 0) |
685 | ✗ | return result; | |
686 | |||
687 | 355 | av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv)); | |
688 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (!s->pmv) |
689 | ✗ | return AVERROR(ENOMEM); | |
690 | |||
691 | /* decode y, u and v components */ | ||
692 |
2/2✓ Branch 0 taken 1065 times.
✓ Branch 1 taken 355 times.
|
1420 | for (i = 0; i < 3; i++) { |
693 | 1065 | int linesize = cur->linesize[i]; | |
694 |
2/2✓ Branch 0 taken 355 times.
✓ Branch 1 taken 710 times.
|
1065 | if (i == 0) { |
695 | 355 | width = FFALIGN(s->width, 16); | |
696 | 355 | height = FFALIGN(s->height, 16); | |
697 | } else { | ||
698 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 710 times.
|
710 | if (avctx->flags & AV_CODEC_FLAG_GRAY) |
699 | ✗ | break; | |
700 | 710 | width = FFALIGN(s->width / 4, 16); | |
701 | 710 | height = FFALIGN(s->height / 4, 16); | |
702 | } | ||
703 | |||
704 | 1065 | current = cur->data[i]; | |
705 | |||
706 |
2/2✓ Branch 0 taken 108 times.
✓ Branch 1 taken 957 times.
|
1065 | if (cur->pict_type == AV_PICTURE_TYPE_I) { |
707 | /* keyframe */ | ||
708 |
2/2✓ Branch 0 taken 643 times.
✓ Branch 1 taken 108 times.
|
751 | for (y = 0; y < height; y += 16) { |
709 |
2/2✓ Branch 0 taken 8533 times.
✓ Branch 1 taken 643 times.
|
9176 | for (x = 0; x < width; x += 16) { |
710 | 8533 | result = svq1_decode_block_intra(&s->gb, ¤t[x], | |
711 | linesize); | ||
712 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8533 times.
|
8533 | if (result) { |
713 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
714 | "Error in svq1_decode_block %i (keyframe)\n", | ||
715 | result); | ||
716 | ✗ | return result; | |
717 | } | ||
718 | } | ||
719 | 643 | current += 16 * linesize; | |
720 | } | ||
721 | } else { | ||
722 | /* delta frame */ | ||
723 | 957 | uint8_t *previous = s->prev->data[i]; | |
724 |
1/2✓ Branch 0 taken 957 times.
✗ Branch 1 not taken.
|
957 | if (!previous || |
725 |
2/4✓ Branch 0 taken 957 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 957 times.
|
957 | s->prev->width != s->width || s->prev->height != s->height) { |
726 | ✗ | av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n"); | |
727 | ✗ | return AVERROR_INVALIDDATA; | |
728 | } | ||
729 | |||
730 | 957 | memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); | |
731 | |||
732 |
2/2✓ Branch 0 taken 5691 times.
✓ Branch 1 taken 957 times.
|
6648 | for (y = 0; y < height; y += 16) { |
733 |
2/2✓ Branch 0 taken 75341 times.
✓ Branch 1 taken 5691 times.
|
81032 | for (x = 0; x < width; x += 16) { |
734 | 75341 | result = svq1_decode_delta_block(avctx, &s->hdsp, | |
735 | &s->gb, ¤t[x], | ||
736 | previous, linesize, | ||
737 | s->pmv, x, y, width, height); | ||
738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 75341 times.
|
75341 | if (result != 0) { |
739 | ff_dlog(avctx, | ||
740 | "Error in svq1_decode_delta_block %i\n", | ||
741 | result); | ||
742 | ✗ | return result; | |
743 | } | ||
744 | } | ||
745 | |||
746 | 5691 | s->pmv[0].x = | |
747 | 5691 | s->pmv[0].y = 0; | |
748 | |||
749 | 5691 | current += 16 * linesize; | |
750 | } | ||
751 | } | ||
752 | } | ||
753 | |||
754 |
1/2✓ Branch 0 taken 355 times.
✗ Branch 1 not taken.
|
355 | if (!s->nonref) { |
755 | 355 | av_frame_unref(s->prev); | |
756 | 355 | result = av_frame_ref(s->prev, cur); | |
757 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 355 times.
|
355 | if (result < 0) |
758 | ✗ | return result; | |
759 | } | ||
760 | |||
761 | 355 | *got_frame = 1; | |
762 | 355 | result = buf_size; | |
763 | |||
764 | 355 | return result; | |
765 | } | ||
766 | |||
767 | 9 | static av_cold void svq1_static_init(void) | |
768 | { | ||
769 | 9 | INIT_VLC_STATIC(&svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4, | |
770 | &ff_svq1_block_type_vlc[0][1], 2, 1, | ||
771 | &ff_svq1_block_type_vlc[0][0], 2, 1, 8); | ||
772 | |||
773 | 9 | INIT_VLC_STATIC(&svq1_motion_component, 7, 33, | |
774 | &ff_mvtab[0][1], 2, 1, | ||
775 | &ff_mvtab[0][0], 2, 1, 176); | ||
776 | |||
777 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 9 times.
|
63 | for (int i = 0, offset = 0; i < 6; i++) { |
778 | static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 }, | ||
779 | { 10, 10, 14, 14, 14, 16 } }; | ||
780 | static VLCElem table[168]; | ||
781 | 54 | svq1_intra_multistage[i].table = &table[offset]; | |
782 | 54 | svq1_intra_multistage[i].table_allocated = sizes[0][i]; | |
783 | 54 | offset += sizes[0][i]; | |
784 | 54 | init_vlc(&svq1_intra_multistage[i], 3, 8, | |
785 | &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, | ||
786 | &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, | ||
787 | INIT_VLC_USE_NEW_STATIC); | ||
788 | 54 | svq1_inter_multistage[i].table = &table[offset]; | |
789 | 54 | svq1_inter_multistage[i].table_allocated = sizes[1][i]; | |
790 | 54 | offset += sizes[1][i]; | |
791 | 54 | init_vlc(&svq1_inter_multistage[i], 3, 8, | |
792 | &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, | ||
793 | &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, | ||
794 | INIT_VLC_USE_NEW_STATIC); | ||
795 | } | ||
796 | |||
797 | 9 | INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, | |
798 | &ff_svq1_intra_mean_vlc[0][1], 4, 2, | ||
799 | &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632); | ||
800 | |||
801 | 9 | INIT_VLC_STATIC(&svq1_inter_mean, 9, 512, | |
802 | &ff_svq1_inter_mean_vlc[0][1], 4, 2, | ||
803 | &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434); | ||
804 | 9 | } | |
805 | |||
806 | 15 | static av_cold int svq1_decode_init(AVCodecContext *avctx) | |
807 | { | ||
808 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
809 | 15 | SVQ1Context *s = avctx->priv_data; | |
810 | |||
811 | 15 | s->prev = av_frame_alloc(); | |
812 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (!s->prev) |
813 | ✗ | return AVERROR(ENOMEM); | |
814 | |||
815 | 15 | s->width = avctx->width + 3 & ~3; | |
816 | 15 | s->height = avctx->height + 3 & ~3; | |
817 | 15 | avctx->pix_fmt = AV_PIX_FMT_YUV410P; | |
818 | |||
819 | 15 | ff_hpeldsp_init(&s->hdsp, avctx->flags); | |
820 | |||
821 | 15 | ff_thread_once(&init_static_once, svq1_static_init); | |
822 | |||
823 | 15 | return 0; | |
824 | } | ||
825 | |||
826 | 15 | static av_cold int svq1_decode_end(AVCodecContext *avctx) | |
827 | { | ||
828 | 15 | SVQ1Context *s = avctx->priv_data; | |
829 | |||
830 | 15 | av_frame_free(&s->prev); | |
831 | 15 | av_freep(&s->pkt_swapped); | |
832 | 15 | s->pkt_swapped_allocated = 0; | |
833 | 15 | av_freep(&s->pmv); | |
834 | 15 | s->pmv_allocated = 0; | |
835 | |||
836 | 15 | return 0; | |
837 | } | ||
838 | |||
839 | ✗ | static void svq1_flush(AVCodecContext *avctx) | |
840 | { | ||
841 | ✗ | SVQ1Context *s = avctx->priv_data; | |
842 | |||
843 | ✗ | av_frame_unref(s->prev); | |
844 | } | ||
845 | |||
846 | const FFCodec ff_svq1_decoder = { | ||
847 | .p.name = "svq1", | ||
848 | .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), | ||
849 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
850 | .p.id = AV_CODEC_ID_SVQ1, | ||
851 | .priv_data_size = sizeof(SVQ1Context), | ||
852 | .init = svq1_decode_init, | ||
853 | .close = svq1_decode_end, | ||
854 | FF_CODEC_DECODE_CB(svq1_decode_frame), | ||
855 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
856 | .flush = svq1_flush, | ||
857 | .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P, | ||
858 | AV_PIX_FMT_NONE }, | ||
859 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, | ||
860 | }; | ||
861 |