FFmpeg coverage

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