FFmpeg coverage

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