FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/svq1dec.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 292 345 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 "get_bits.h"
40 #include "h263.h"
41 #include "hpeldsp.h"
42 #include "internal.h"
43 #include "mathops.h"
44 #include "svq1.h"
45
46 #define SVQ1_BLOCK_TYPE_VLC_BITS 3
47 static VLC svq1_block_type;
48 static VLC svq1_motion_component;
49 static VLC svq1_intra_multistage[6];
50 static VLC svq1_inter_multistage[6];
51 static VLC svq1_intra_mean;
52 static VLC svq1_inter_mean;
53
54 /* motion vector (prediction) */
55 typedef struct svq1_pmv_s {
56 int x;
57 int y;
58 } svq1_pmv;
59
60 typedef struct SVQ1Context {
61 HpelDSPContext hdsp;
62 GetBitContext gb;
63 AVFrame *prev;
64
65 uint8_t *pkt_swapped;
66 int pkt_swapped_allocated;
67
68 svq1_pmv *pmv;
69 int pmv_allocated;
70
71 int width;
72 int height;
73 int frame_code;
74 int nonref; // 1 if the current frame won't be referenced
75 } SVQ1Context;
76
77 static const uint8_t string_table[256] = {
78 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
79 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
80 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
81 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
82 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
83 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
84 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
85 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
86 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
87 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
88 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
89 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
90 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
91 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
92 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
93 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
94 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
95 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
96 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
97 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
98 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
99 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
100 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
101 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
102 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
103 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
104 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
105 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
106 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
107 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
108 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
109 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
110 };
111
112 #define SVQ1_PROCESS_VECTOR() \
113 for (; level > 0; i++) { \
114 /* process next depth */ \
115 if (i == m) { \
116 m = n; \
117 if (--level == 0) \
118 break; \
119 } \
120 /* divide block if next bit set */ \
121 if (!get_bits1(bitbuf)) \
122 break; \
123 /* add child nodes */ \
124 list[n++] = list[i]; \
125 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
126 }
127
128 #define SVQ1_ADD_CODEBOOK() \
129 /* add codebook entries to vector */ \
130 for (j = 0; j < stages; j++) { \
131 n3 = codebook[entries[j]] ^ 0x80808080; \
132 n1 += (n3 & 0xFF00FF00) >> 8; \
133 n2 += n3 & 0x00FF00FF; \
134 } \
135 \
136 /* clip to [0..255] */ \
137 if (n1 & 0xFF00FF00) { \
138 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
139 n1 += 0x7F007F00; \
140 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
141 n1 &= n3 & 0x00FF00FF; \
142 } \
143 \
144 if (n2 & 0xFF00FF00) { \
145 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
146 n2 += 0x7F007F00; \
147 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
148 n2 &= n3 & 0x00FF00FF; \
149 }
150
151 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
152 codebook = (const uint32_t *)cbook[level]; \
153 if (stages > 0) \
154 bit_cache = get_bits(bitbuf, 4 * stages); \
155 /* calculate codebook entries for this vector */ \
156 for (j = 0; j < stages; j++) { \
157 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
158 16 * j) << (level + 1); \
159 } \
160 mean -= stages * 128; \
161 n4 = (mean << 16) + mean;
162
163 12351 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
164 ptrdiff_t pitch)
165 {
166 uint32_t bit_cache;
167 uint8_t *list[63];
168 uint32_t *dst;
169 const uint32_t *codebook;
170 int entries[6];
171 int i, j, m, n;
172 int stages;
173 unsigned mean;
174 unsigned x, y, width, height, level;
175 uint32_t n1, n2, n3, n4;
176
177 /* initialize list for breadth first processing of vectors */
178 12351 list[0] = pixels;
179
180 /* recursively process vector */
181
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++) {
182
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();
183
184 /* destination address and vector size */
185 243825 dst = (uint32_t *)list[i];
186 243825 width = 1 << ((4 + level) / 2);
187 243825 height = 1 << ((3 + level) / 2);
188
189 /* get number of stages (-1 skips vector, 0 for mean only) */
190 243825 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
191
192
2/2
✓ Branch 0 taken 371 times.
✓ Branch 1 taken 243454 times.
 243825 if (stages == -1) {
193
2/2
✓ Branch 0 taken 4122 times.
✓ Branch 1 taken 371 times.
 4493 for (y = 0; y < height; y++)
194 4122 memset(&dst[y * (pitch / 4)], 0, width);
195 371 continue; /* skip vector */
196 }
197
198
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)) {
199 ff_dlog(NULL,
200 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
201 stages, level);
202 ✗ return AVERROR_INVALIDDATA; /* invalid vector */
203 }
204
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 243454 times.
 243454 av_assert0(stages >= 0);
205
206 243454 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
207
208
2/2
✓ Branch 0 taken 59769 times.
✓ Branch 1 taken 183685 times.
 243454 if (stages == 0) {
209
2/2
✓ Branch 0 taken 158460 times.
✓ Branch 1 taken 59769 times.
 218229 for (y = 0; y < height; y++)
210 158460 memset(&dst[y * (pitch / 4)], mean, width);
211 } else {
212
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);
213
214
2/2
✓ Branch 0 taken 498670 times.
✓ Branch 1 taken 183685 times.
 682355 for (y = 0; y < height; y++) {
215
2/2
✓ Branch 0 taken 581038 times.
✓ Branch 1 taken 498670 times.
 1079708 for (x = 0; x < width / 4; x++, codebook++) {
216 581038 n1 = n4;
217 581038 n2 = n4;
218
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()
219 /* store result */
220 581038 dst[x] = n1 << 8 | n2;
221 }
222 498670 dst += pitch / 4;
223 }
224 }
225 }
226
227 12351 return 0;
228 }
229
230 65696 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
231 ptrdiff_t pitch)
232 {
233 uint32_t bit_cache;
234 uint8_t *list[63];
235 uint32_t *dst;
236 const uint32_t *codebook;
237 int entries[6];
238 int i, j, m, n;
239 int stages;
240 unsigned mean;
241 int x, y, width, height, level;
242 uint32_t n1, n2, n3, n4;
243
244 /* initialize list for breadth first processing of vectors */
245 65696 list[0] = pixels;
246
247 /* recursively process vector */
248
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++) {
249
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();
250
251 /* destination address and vector size */
252 1233266 dst = (uint32_t *)list[i];
253 1233266 width = 1 << ((4 + level) / 2);
254 1233266 height = 1 << ((3 + level) / 2);
255
256 /* get number of stages (-1 skips vector, 0 for mean only) */
257 1233266 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
258
259
2/2
✓ Branch 0 taken 29737 times.
✓ Branch 1 taken 1203529 times.
 1233266 if (stages == -1)
260 29737 continue; /* skip vector */
261
262
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)) {
263 ff_dlog(NULL,
264 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
265 stages, level);
266 ✗ return AVERROR_INVALIDDATA; /* invalid vector */
267 }
268
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1203529 times.
 1203529 av_assert0(stages >= 0);
269
270 1203529 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
271
272
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);
273
274
2/2
✓ Branch 0 taken 3227410 times.
✓ Branch 1 taken 1203529 times.
 4430939 for (y = 0; y < height; y++) {
275
2/2
✓ Branch 0 taken 4009806 times.
✓ Branch 1 taken 3227410 times.
 7237216 for (x = 0; x < width / 4; x++, codebook++) {
276 4009806 n3 = dst[x];
277 /* add mean value to vector */
278 4009806 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
279 4009806 n2 = n4 + (n3 & 0x00FF00FF);
280
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()
281 /* store result */
282 4009806 dst[x] = n1 << 8 | n2;
283 }
284 3227410 dst += pitch / 4;
285 }
286 }
287 65696 return 0;
288 }
289
290 79616 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
291 svq1_pmv **pmv)
292 {
293 int diff;
294 int i;
295
296
2/2
✓ Branch 0 taken 159232 times.
✓ Branch 1 taken 79616 times.
 238848 for (i = 0; i < 2; i++) {
297 /* get motion code */
298 159232 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
299
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 159232 times.
 159232 if (diff < 0)
300 ✗ return AVERROR_INVALIDDATA;
301
2/2
✓ Branch 0 taken 78989 times.
✓ Branch 1 taken 80243 times.
 159232 else if (diff) {
302
2/2
✓ Branch 1 taken 34286 times.
✓ Branch 2 taken 44703 times.
 78989 if (get_bits1(bitbuf))
303 34286 diff = -diff;
304 }
305
306 /* add median of motion vector predictors and clip result */
307
2/2
✓ Branch 0 taken 79616 times.
✓ Branch 1 taken 79616 times.
 159232 if (i == 1)
308 79616 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
309 else
310 79616 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
311 }
312
313 79616 return 0;
314 }
315
316 5827 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
317 ptrdiff_t pitch, int x, int y)
318 {
319 uint8_t *src;
320 uint8_t *dst;
321 int i;
322
323 5827 src = &previous[x + y * pitch];
324 5827 dst = current;
325
326
2/2
✓ Branch 0 taken 93232 times.
✓ Branch 1 taken 5827 times.
 99059 for (i = 0; i < 16; i++) {
327 93232 memcpy(dst, src, 16);
328 93232 src += pitch;
329 93232 dst += pitch;
330 }
331 5827 }
332
333 61056 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
334 uint8_t *current, uint8_t *previous,
335 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
336 int width, int height)
337 {
338 uint8_t *src;
339 uint8_t *dst;
340 svq1_pmv mv;
341 svq1_pmv *pmv[3];
342 int result;
343
344 /* predict and decode motion vector */
345 61056 pmv[0] = &motion[0];
346
2/2
✓ Branch 0 taken 5027 times.
✓ Branch 1 taken 56029 times.
 61056 if (y == 0) {
347 5027 pmv[1] =
348 5027 pmv[2] = pmv[0];
349 } else {
350 56029 pmv[1] = &motion[x / 8 + 2];
351 56029 pmv[2] = &motion[x / 8 + 4];
352 }
353
354 61056 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
355
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 61056 times.
 61056 if (result)
356 ✗ return result;
357
358 61056 motion[0].x =
359 61056 motion[x / 8 + 2].x =
360 61056 motion[x / 8 + 3].x = mv.x;
361 61056 motion[0].y =
362 61056 motion[x / 8 + 2].y =
363 61056 motion[x / 8 + 3].y = mv.y;
364
365 61056 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
366 61056 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
367
368 61056 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
369 61056 dst = current;
370
371 61056 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
372
373 61056 return 0;
374 }
375
376 4640 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
377 uint8_t *current, uint8_t *previous,
378 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
379 int width, int height)
380 {
381 uint8_t *src;
382 uint8_t *dst;
383 svq1_pmv mv;
384 svq1_pmv *pmv[4];
385 int i, result;
386
387 /* predict and decode motion vector (0) */
388 4640 pmv[0] = &motion[0];
389
2/2
✓ Branch 0 taken 729 times.
✓ Branch 1 taken 3911 times.
 4640 if (y == 0) {
390 729 pmv[1] =
391 729 pmv[2] = pmv[0];
392 } else {
393 3911 pmv[1] = &motion[(x / 8) + 2];
394 3911 pmv[2] = &motion[(x / 8) + 4];
395 }
396
397 4640 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
398
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
 4640 if (result)
399 ✗ return result;
400
401 /* predict and decode motion vector (1) */
402 4640 pmv[0] = &mv;
403
2/2
✓ Branch 0 taken 729 times.
✓ Branch 1 taken 3911 times.
 4640 if (y == 0) {
404 729 pmv[1] =
405 729 pmv[2] = pmv[0];
406 } else {
407 3911 pmv[1] = &motion[(x / 8) + 3];
408 }
409 4640 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
410
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
 4640 if (result)
411 ✗ return result;
412
413 /* predict and decode motion vector (2) */
414 4640 pmv[1] = &motion[0];
415 4640 pmv[2] = &motion[(x / 8) + 1];
416
417 4640 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
 4640 if (result)
419 ✗ return result;
420
421 /* predict and decode motion vector (3) */
422 4640 pmv[2] = &motion[(x / 8) + 2];
423 4640 pmv[3] = &motion[(x / 8) + 3];
424
425 4640 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
426
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
 4640 if (result)
427 ✗ return result;
428
429 /* form predictions */
430
2/2
✓ Branch 0 taken 18560 times.
✓ Branch 1 taken 4640 times.
 23200 for (i = 0; i < 4; i++) {
431 18560 int mvx = pmv[i]->x + (i & 1) * 16;
432 18560 int mvy = pmv[i]->y + (i >> 1) * 16;
433
434 // FIXME: clipping or padding?
435 18560 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
436 18560 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
437
438 18560 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
439 18560 dst = current;
440
441 18560 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
442
443 /* select next block */
444
2/2
✓ Branch 0 taken 9280 times.
✓ Branch 1 taken 9280 times.
 18560 if (i & 1)
445 9280 current += 8 * (pitch - 1);
446 else
447 9280 current += 8;
448 }
449
450 4640 return 0;
451 }
452
453 75341 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
454 GetBitContext *bitbuf,
455 uint8_t *current, uint8_t *previous,
456 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
457 int width, int height)
458 {
459 uint32_t block_type;
460 75341 int result = 0;
461
462 /* get block type */
463 75341 block_type = get_vlc2(bitbuf, svq1_block_type.table,
464 SVQ1_BLOCK_TYPE_VLC_BITS, 1);
465
466 /* reset motion vectors */
467
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) {
468 9645 motion[0].x =
469 9645 motion[0].y =
470 9645 motion[x / 8 + 2].x =
471 9645 motion[x / 8 + 2].y =
472 9645 motion[x / 8 + 3].x =
473 9645 motion[x / 8 + 3].y = 0;
474 }
475
476
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) {
477 5827 case SVQ1_BLOCK_SKIP:
478 5827 svq1_skip_block(current, previous, pitch, x, y);
479 5827 break;
480
481 61056 case SVQ1_BLOCK_INTER:
482 61056 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
483 pitch, motion, x, y, width, height);
484
485
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 61056 times.
 61056 if (result != 0) {
486 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
487 ✗ break;
488 }
489 61056 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
490 61056 break;
491
492 4640 case SVQ1_BLOCK_INTER_4V:
493 4640 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
494 pitch, motion, x, y, width, height);
495
496
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4640 times.
 4640 if (result != 0) {
497 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
498 ✗ break;
499 }
500 4640 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
501 4640 break;
502
503 3818 case SVQ1_BLOCK_INTRA:
504 3818 result = svq1_decode_block_intra(bitbuf, current, pitch);
505 3818 break;
506 }
507
508 75341 return result;
509 }
510
511 ✗ static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
512 {
513 uint8_t seed;
514 int i;
515
516 ✗ out[0] = get_bits(bitbuf, 8);
517 ✗ seed = string_table[out[0]];
518
519 ✗ for (i = 1; i <= out[0]; i++) {
520 ✗ out[i] = get_bits(bitbuf, 8) ^ seed;
521 ✗ seed = string_table[out[i] ^ seed];
522 }
523 ✗ out[i] = 0;
524 }
525
526 355 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
527 {
528 355 SVQ1Context *s = avctx->priv_data;
529 355 GetBitContext *bitbuf = &s->gb;
530 int frame_size_code;
531 355 int width = s->width;
532 355 int height = s->height;
533
534 355 skip_bits(bitbuf, 8); /* temporal_reference */
535
536 /* frame type */
537 355 s->nonref = 0;
538
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)) {
539 36 case 0:
540 36 frame->pict_type = AV_PICTURE_TYPE_I;
541 36 break;
542 ✗ case 2:
543 ✗ s->nonref = 1;
544 319 case 1:
545 319 frame->pict_type = AV_PICTURE_TYPE_P;
546 319 break;
547 ✗ default:
548 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
549 ✗ return AVERROR_INVALIDDATA;
550 }
551
552
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 319 times.
 355 if (frame->pict_type == AV_PICTURE_TYPE_I) {
553 /* unknown fields */
554
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) {
555 1 int csum = get_bits(bitbuf, 16);
556
557 1 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
558
559 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
560 (csum == 0) ? "correct" : "incorrect", csum);
561 }
562
563
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36 times.
 36 if ((s->frame_code ^ 0x10) >= 0x50) {
564 uint8_t msg[257];
565
566 ✗ svq1_parse_string(bitbuf, msg);
567
568 ✗ av_log(avctx, AV_LOG_INFO,
569 "embedded message:\n%s\n", ((char *)msg) + 1);
570 }
571
572 36 skip_bits(bitbuf, 2);
573 36 skip_bits(bitbuf, 2);
574 36 skip_bits1(bitbuf);
575
576 /* load frame size */
577 36 frame_size_code = get_bits(bitbuf, 3);
578
579
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 30 times.
 36 if (frame_size_code == 7) {
580 /* load width, height (12 bits each) */
581 6 width = get_bits(bitbuf, 12);
582 6 height = get_bits(bitbuf, 12);
583
584
2/4
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
 6 if (!width || !height)
585 ✗ return AVERROR_INVALIDDATA;
586 } else {
587 /* get width, height from table */
588 30 width = ff_svq1_frame_size_table[frame_size_code][0];
589 30 height = ff_svq1_frame_size_table[frame_size_code][1];
590 }
591 }
592
593 /* unknown fields */
594
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 355 times.
 355 if (get_bits1(bitbuf)) {
595 ✗ skip_bits1(bitbuf); /* use packet checksum if (1) */
596 ✗ skip_bits1(bitbuf); /* component checksums after image data if (1) */
597
598 ✗ if (get_bits(bitbuf, 2) != 0)
599 ✗ return AVERROR_INVALIDDATA;
600 }
601
602
2/2
✓ Branch 1 taken 155 times.
✓ Branch 2 taken 200 times.
 355 if (get_bits1(bitbuf)) {
603 155 skip_bits1(bitbuf);
604 155 skip_bits(bitbuf, 4);
605 155 skip_bits1(bitbuf);
606 155 skip_bits(bitbuf, 2);
607
608
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 155 times.
 155 if (skip_1stop_8data_bits(bitbuf) < 0)
609 ✗ return AVERROR_INVALIDDATA;
610 }
611
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 355 times.
 355 if (get_bits_left(bitbuf) <= 0)
612 ✗ return AVERROR_INVALIDDATA;
613
614 355 s->width = width;
615 355 s->height = height;
616 355 return 0;
617 }
618
619 355 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
620 int *got_frame, AVPacket *avpkt)
621 {
622 355 const uint8_t *buf = avpkt->data;
623 355 int buf_size = avpkt->size;
624 355 SVQ1Context *s = avctx->priv_data;
625 355 AVFrame *cur = 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, &current[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, &current[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 7 static av_cold void svq1_static_init(void)
768 {
769 7 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 7 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 42 times.
✓ Branch 1 taken 7 times.
 49 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 VLC_TYPE table[168][2];
781 42 svq1_intra_multistage[i].table = &table[offset];
782 42 svq1_intra_multistage[i].table_allocated = sizes[0][i];
783 42 offset += sizes[0][i];
784 42 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 42 svq1_inter_multistage[i].table = &table[offset];
789 42 svq1_inter_multistage[i].table_allocated = sizes[1][i];
790 42 offset += sizes[1][i];
791 42 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 7 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 7 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 7 }
805
806 13 static av_cold int svq1_decode_init(AVCodecContext *avctx)
807 {
808 static AVOnce init_static_once = AV_ONCE_INIT;
809 13 SVQ1Context *s = avctx->priv_data;
810
811 13 s->prev = av_frame_alloc();
812
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 if (!s->prev)
813 ✗ return AVERROR(ENOMEM);
814
815 13 s->width = avctx->width + 3 & ~3;
816 13 s->height = avctx->height + 3 & ~3;
817 13 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
818
819 13 ff_hpeldsp_init(&s->hdsp, avctx->flags);
820
821 13 ff_thread_once(&init_static_once, svq1_static_init);
822
823 13 return 0;
824 }
825
826 13 static av_cold int svq1_decode_end(AVCodecContext *avctx)
827 {
828 13 SVQ1Context *s = avctx->priv_data;
829
830 13 av_frame_free(&s->prev);
831 13 av_freep(&s->pkt_swapped);
832 13 s->pkt_swapped_allocated = 0;
833 13 av_freep(&s->pmv);
834 13 s->pmv_allocated = 0;
835
836 13 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 AVCodec ff_svq1_decoder = {
847 .name = "svq1",
848 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849 .type = AVMEDIA_TYPE_VIDEO,
850 .id = AV_CODEC_ID_SVQ1,
851 .priv_data_size = sizeof(SVQ1Context),
852 .init = svq1_decode_init,
853 .close = svq1_decode_end,
854 .decode = svq1_decode_frame,
855 .capabilities = AV_CODEC_CAP_DR1,
856 .flush = svq1_flush,
857 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
858 AV_PIX_FMT_NONE },
859 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
860 };
861