FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/svq1dec.c
Date: 2024-04-19 17:50:32
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 12347 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 12347 list[0] = pixels;
183
184 /* recursively process vector */
185
2/2
✓ Branch 0 taken 243721 times.
✓ Branch 1 taken 12347 times.
256068 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
186
10/10
✓ Branch 0 taken 58383 times.
✓ Branch 1 taken 261280 times.
✓ Branch 2 taken 11196 times.
✓ Branch 3 taken 47187 times.
✓ Branch 5 taken 77093 times.
✓ Branch 6 taken 231374 times.
✓ Branch 7 taken 139080 times.
✓ Branch 8 taken 92294 times.
✓ Branch 9 taken 319663 times.
✓ Branch 10 taken 155432 times.
475095 SVQ1_PROCESS_VECTOR();
187
188 /* destination address and vector size */
189 243721 dst = (uint32_t *)list[i];
190 243721 width = 1 << ((4 + level) / 2);
191 243721 height = 1 << ((3 + level) / 2);
192
193 /* get number of stages (-1 skips vector, 0 for mean only) */
194 243721 stages = get_vlc2(bitbuf, svq1_intra_multistage[level], 4, 2) - 1;
195
196
2/2
✓ Branch 0 taken 371 times.
✓ Branch 1 taken 243350 times.
243721 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 183606 times.
✓ Branch 1 taken 59744 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 183606 times.
243350 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 243350 times.
243350 av_assert0(stages >= 0);
209
210 243350 mean = get_vlc2(bitbuf, svq1_intra_mean, 8, 3);
211
212
2/2
✓ Branch 0 taken 59744 times.
✓ Branch 1 taken 183606 times.
243350 if (stages == 0) {
213
2/2
✓ Branch 0 taken 158400 times.
✓ Branch 1 taken 59744 times.
218144 for (y = 0; y < height; y++)
214 158400 memset(&dst[y * (pitch / 4)], mean, width);
215 } else {
216
3/4
✓ Branch 0 taken 183606 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 949117 times.
✓ Branch 4 taken 183606 times.
1132723 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
217
218
2/2
✓ Branch 0 taken 498450 times.
✓ Branch 1 taken 183606 times.
682056 for (y = 0; y < height; y++) {
219
2/2
✓ Branch 0 taken 580842 times.
✓ Branch 1 taken 498450 times.
1079292 for (x = 0; x < width / 4; x++, codebook++) {
220 580842 n1 = n4;
221 580842 n2 = n4;
222
6/6
✓ Branch 0 taken 2927940 times.
✓ Branch 1 taken 580842 times.
✓ Branch 2 taken 221 times.
✓ Branch 3 taken 580621 times.
✓ Branch 4 taken 350 times.
✓ Branch 5 taken 580492 times.
3508782 SVQ1_ADD_CODEBOOK()
223 /* store result */
224 580842 dst[x] = n1 << 8 | n2;
225 }
226 498450 dst += pitch / 4;
227 }
228 }
229 }
230
231 12347 return 0;
232 }
233
234 65737 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 65737 list[0] = pixels;
250
251 /* recursively process vector */
252
2/2
✓ Branch 0 taken 1234047 times.
✓ Branch 1 taken 65737 times.
1299784 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
253
10/10
✓ Branch 0 taken 311020 times.
✓ Branch 1 taken 1259002 times.
✓ Branch 2 taken 60529 times.
✓ Branch 3 taken 250491 times.
✓ Branch 5 taken 341183 times.
✓ Branch 6 taken 1168310 times.
✓ Branch 7 taken 713751 times.
✓ Branch 8 taken 454559 times.
✓ Branch 9 taken 1570022 times.
✓ Branch 10 taken 832335 times.
2402357 SVQ1_PROCESS_VECTOR();
254
255 /* destination address and vector size */
256 1234047 dst = (uint32_t *)list[i];
257 1234047 width = 1 << ((4 + level) / 2);
258 1234047 height = 1 << ((3 + level) / 2);
259
260 /* get number of stages (-1 skips vector, 0 for mean only) */
261 1234047 stages = get_vlc2(bitbuf, svq1_inter_multistage[level], 3, 2) - 1;
262
263
2/2
✓ Branch 0 taken 29883 times.
✓ Branch 1 taken 1204164 times.
1234047 if (stages == -1)
264 29883 continue; /* skip vector */
265
266
3/4
✓ Branch 0 taken 466312 times.
✓ Branch 1 taken 737852 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 466312 times.
1204164 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 1204164 times.
1204164 av_assert0(stages >= 0);
273
274 1204164 mean = get_vlc2(bitbuf, svq1_inter_mean, 9, 3) - 256;
275
276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1204164 times.
1204164 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 466312 times.
✓ Branch 1 taken 737852 times.
✓ Branch 3 taken 2167843 times.
✓ Branch 4 taken 1204164 times.
3372007 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
284
285
2/2
✓ Branch 0 taken 3229280 times.
✓ Branch 1 taken 1204164 times.
4433444 for (y = 0; y < height; y++) {
286
2/2
✓ Branch 0 taken 4011448 times.
✓ Branch 1 taken 3229280 times.
7240728 for (x = 0; x < width / 4; x++) {
287 4011448 n3 = dst[x];
288 /* add mean value to vector */
289 4011448 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
290 4011448 n2 = n4 + (n3 & 0x00FF00FF);
291
6/6
✓ Branch 0 taken 5356192 times.
✓ Branch 1 taken 4011448 times.
✓ Branch 2 taken 8297 times.
✓ Branch 3 taken 4003151 times.
✓ Branch 4 taken 8590 times.
✓ Branch 5 taken 4002858 times.
9367640 SVQ1_ADD_CODEBOOK()
292 /* store result */
293 4011448 dst[x] = n1 << 8 | n2;
294
2/2
✓ Branch 0 taken 3641176 times.
✓ Branch 1 taken 370272 times.
4011448 if (codebook != NULL)
295 3641176 codebook++;
296 }
297 3229280 dst += pitch / 4;
298 }
299 }
300 65737 return 0;
301 }
302
303 79711 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 159422 times.
✓ Branch 1 taken 79711 times.
239133 for (i = 0; i < 2; i++) {
310 /* get motion code */
311 159422 diff = get_vlc2(bitbuf, svq1_motion_component, 7, 2);
312
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 159422 times.
159422 if (diff < 0)
313 return AVERROR_INVALIDDATA;
314
2/2
✓ Branch 0 taken 79034 times.
✓ Branch 1 taken 80388 times.
159422 else if (diff) {
315
2/2
✓ Branch 1 taken 34296 times.
✓ Branch 2 taken 44738 times.
79034 if (get_bits1(bitbuf))
316 34296 diff = -diff;
317 }
318
319 /* add median of motion vector predictors and clip result */
320
2/2
✓ Branch 0 taken 79711 times.
✓ Branch 1 taken 79711 times.
159422 if (i == 1)
321 79711 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
322 else
323 79711 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
324 }
325
326 79711 return 0;
327 }
328
329 8204 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 8204 src = &previous[x + y * pitch];
337 8204 dst = current;
338
339
2/2
✓ Branch 0 taken 131264 times.
✓ Branch 1 taken 8204 times.
139468 for (i = 0; i < 16; i++) {
340 131264 memcpy(dst, src, 16);
341 131264 src += pitch;
342 131264 dst += pitch;
343 }
344 8204 }
345
346 61079 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 61079 pmv[0] = &motion[0];
359
2/2
✓ Branch 0 taken 5028 times.
✓ Branch 1 taken 56051 times.
61079 if (y == 0) {
360 5028 pmv[1] =
361 5028 pmv[2] = pmv[0];
362 } else {
363 56051 pmv[1] = &motion[x / 8 + 2];
364 56051 pmv[2] = &motion[x / 8 + 4];
365 }
366
367 61079 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 61079 times.
61079 if (result)
369 return result;
370
371 61079 motion[0].x =
372 61079 motion[x / 8 + 2].x =
373 61079 motion[x / 8 + 3].x = mv.x;
374 61079 motion[0].y =
375 61079 motion[x / 8 + 2].y =
376 61079 motion[x / 8 + 3].y = mv.y;
377
378 61079 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
379 61079 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
380
381 61079 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
382 61079 dst = current;
383
384 61079 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
385
386 61079 return 0;
387 }
388
389 4658 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 4658 pmv[0] = &motion[0];
402
2/2
✓ Branch 0 taken 731 times.
✓ Branch 1 taken 3927 times.
4658 if (y == 0) {
403 731 pmv[1] =
404 731 pmv[2] = pmv[0];
405 } else {
406 3927 pmv[1] = &motion[(x / 8) + 2];
407 3927 pmv[2] = &motion[(x / 8) + 4];
408 }
409
410 4658 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
411
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4658 times.
4658 if (result)
412 return result;
413
414 /* predict and decode motion vector (1) */
415 4658 pmv[0] = &mv;
416
2/2
✓ Branch 0 taken 731 times.
✓ Branch 1 taken 3927 times.
4658 if (y == 0) {
417 731 pmv[1] =
418 731 pmv[2] = pmv[0];
419 } else {
420 3927 pmv[1] = &motion[(x / 8) + 3];
421 }
422 4658 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
423
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4658 times.
4658 if (result)
424 return result;
425
426 /* predict and decode motion vector (2) */
427 4658 pmv[1] = &motion[0];
428 4658 pmv[2] = &motion[(x / 8) + 1];
429
430 4658 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4658 times.
4658 if (result)
432 return result;
433
434 /* predict and decode motion vector (3) */
435 4658 pmv[2] = &motion[(x / 8) + 2];
436 4658 pmv[3] = &motion[(x / 8) + 3];
437
438 4658 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
439
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4658 times.
4658 if (result)
440 return result;
441
442 /* form predictions */
443
2/2
✓ Branch 0 taken 18632 times.
✓ Branch 1 taken 4658 times.
23290 for (i = 0; i < 4; i++) {
444 18632 int mvx = pmv[i]->x + (i & 1) * 16;
445 18632 int mvy = pmv[i]->y + (i >> 1) * 16;
446
447 // FIXME: clipping or padding?
448 18632 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
449 18632 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
450
451 18632 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
452 18632 dst = current;
453
454 18632 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 9316 times.
✓ Branch 1 taken 9316 times.
18632 if (i & 1)
458 9316 current += 8 * (pitch - 1);
459 else
460 9316 current += 8;
461 }
462
463 4658 return 0;
464 }
465
466 77755 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 77755 int result = 0;
474
475 /* get block type */
476 77755 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 69551 times.
✓ Branch 1 taken 8204 times.
✓ Branch 2 taken 3814 times.
✓ Branch 3 taken 65737 times.
77755 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
481 12018 motion[0].x =
482 12018 motion[0].y =
483 12018 motion[x / 8 + 2].x =
484 12018 motion[x / 8 + 2].y =
485 12018 motion[x / 8 + 3].x =
486 12018 motion[x / 8 + 3].y = 0;
487 }
488
489
4/5
✓ Branch 0 taken 8204 times.
✓ Branch 1 taken 61079 times.
✓ Branch 2 taken 4658 times.
✓ Branch 3 taken 3814 times.
✗ Branch 4 not taken.
77755 switch (block_type) {
490 8204 case SVQ1_BLOCK_SKIP:
491 8204 svq1_skip_block(current, previous, pitch, x, y);
492 8204 break;
493
494 61079 case SVQ1_BLOCK_INTER:
495 61079 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 61079 times.
61079 if (result != 0) {
499 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
500 break;
501 }
502 61079 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
503 61079 break;
504
505 4658 case SVQ1_BLOCK_INTER_4V:
506 4658 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 4658 times.
4658 if (result != 0) {
510 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
511 break;
512 }
513 4658 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
514 4658 break;
515
516 3814 case SVQ1_BLOCK_INTRA:
517 3814 result = svq1_decode_block_intra(bitbuf, current, pitch);
518 3814 break;
519 }
520
521 77755 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 365 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int * buggy)
540 {
541 365 SVQ1Context *s = avctx->priv_data;
542 365 GetBitContext *bitbuf = &s->gb;
543 int frame_size_code;
544 365 int width = s->width;
545 365 int height = s->height;
546 int tempref;
547
548 365 tempref = get_bits(bitbuf, 8); /* temporal_reference */
549
5/6
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 163 times.
✓ Branch 2 taken 196 times.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 196 times.
365 *buggy = tempref == 0 && s->last_tempref == 0 && avctx->extradata_size == 0;
550 365 s->last_tempref = tempref;
551
552 /* frame type */
553 365 s->nonref = 0;
554
2/4
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 329 times.
✗ Branch 4 not taken.
365 switch (get_bits(bitbuf, 2)) {
555 36 case 0:
556 36 frame->pict_type = AV_PICTURE_TYPE_I;
557 36 break;
558 case 2:
559 s->nonref = 1;
560 329 case 1:
561 329 frame->pict_type = AV_PICTURE_TYPE_P;
562 329 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 36 times.
✓ Branch 1 taken 329 times.
365 if (frame->pict_type == AV_PICTURE_TYPE_I) {
569 /* unknown fields */
570
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) {
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 36 times.
36 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 36 skip_bits(bitbuf, 2);
589 36 skip_bits(bitbuf, 2);
590 36 skip_bits1(bitbuf);
591
592 /* load frame size */
593 36 frame_size_code = get_bits(bitbuf, 3);
594
595
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 30 times.
36 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 30 width = ff_svq1_frame_size_table[frame_size_code][0];
605 30 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 365 times.
365 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 165 times.
✓ Branch 2 taken 200 times.
365 if (get_bits1(bitbuf)) {
619 165 skip_bits1(bitbuf);
620 165 skip_bits(bitbuf, 4);
621 165 skip_bits1(bitbuf);
622 165 skip_bits(bitbuf, 2);
623
624
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 165 times.
165 if (skip_1stop_8data_bits(bitbuf) < 0)
625 return AVERROR_INVALIDDATA;
626 }
627
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 365 times.
365 if (get_bits_left(bitbuf) <= 0)
628 return AVERROR_INVALIDDATA;
629
630 365 s->width = width;
631 365 s->height = height;
632 365 return 0;
633 }
634
635 365 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,
636 int *got_frame, AVPacket *avpkt)
637 {
638 365 const uint8_t *buf = avpkt->data;
639 365 int buf_size = avpkt->size;
640 365 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 365 ret = init_get_bits8(&s->gb, buf, buf_size);
647
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 if (ret < 0)
648 return ret;
649
650 /* decode frame header */
651 365 s->frame_code = get_bits(&s->gb, 22);
652
653
2/4
✓ Branch 0 taken 365 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 365 times.
365 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 13 times.
✓ Branch 1 taken 352 times.
365 if (s->frame_code != 0x20) {
658 uint32_t *src;
659
660
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (buf_size < 9 * 4) {
661 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
662 return AVERROR_INVALIDDATA;
663 }
664
665 13 av_fast_padded_malloc(&s->pkt_swapped,
666 13 &s->pkt_swapped_allocated,
667 buf_size);
668
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 if (!s->pkt_swapped)
669 return AVERROR(ENOMEM);
670
671 13 memcpy(s->pkt_swapped, buf, buf_size);
672 13 buf = s->pkt_swapped;
673 13 init_get_bits(&s->gb, buf, buf_size * 8);
674 13 skip_bits(&s->gb, 22);
675
676 13 src = (uint32_t *)(s->pkt_swapped + 4);
677
678
2/2
✓ Branch 0 taken 52 times.
✓ Branch 1 taken 13 times.
65 for (i = 0; i < 4; i++)
679 52 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
680 }
681
682 365 result = svq1_decode_frame_header(avctx, cur, &buggy);
683
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 if (result != 0) {
684 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
685 return result;
686 }
687
688 365 result = ff_set_dimensions(avctx, s->width, s->height);
689
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 if (result < 0)
690 return result;
691
692
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
365 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
693
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 (avctx->skip_frame >= AVDISCARD_NONKEY &&
694 cur->pict_type != AV_PICTURE_TYPE_I) ||
695
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 avctx->skip_frame >= AVDISCARD_ALL)
696 return buf_size;
697
698 365 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
699
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 if (result < 0)
700 return result;
701
702 365 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 365 times.
365 if (!s->pmv)
704 return AVERROR(ENOMEM);
705
706 /* decode y, u and v components */
707
2/2
✓ Branch 0 taken 1095 times.
✓ Branch 1 taken 365 times.
1460 for (i = 0; i < 3; i++) {
708 1095 int linesize = cur->linesize[i];
709
2/2
✓ Branch 0 taken 365 times.
✓ Branch 1 taken 730 times.
1095 if (i == 0) {
710 365 width = FFALIGN(s->width, 16);
711 365 height = FFALIGN(s->height, 16);
712 } else {
713
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 730 times.
730 if (avctx->flags & AV_CODEC_FLAG_GRAY)
714 break;
715 730 width = FFALIGN(s->width / 4, 16);
716 730 height = FFALIGN(s->height / 4, 16);
717 }
718
719 1095 current = cur->data[i];
720
721
2/2
✓ Branch 0 taken 108 times.
✓ Branch 1 taken 987 times.
1095 if (cur->pict_type == AV_PICTURE_TYPE_I) {
722 /* keyframe */
723
2/2
✓ Branch 0 taken 643 times.
✓ Branch 1 taken 108 times.
751 for (y = 0; y < height; y += 16) {
724
2/2
✓ Branch 0 taken 8533 times.
✓ Branch 1 taken 643 times.
9176 for (x = 0; x < width; x += 16) {
725 8533 result = svq1_decode_block_intra(&s->gb, &current[x],
726 linesize);
727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8533 times.
8533 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 643 current += 16 * linesize;
735 }
736 } else {
737 /* delta frame */
738 987 uint8_t *previous = s->prev->data[i];
739
1/2
✓ Branch 0 taken 987 times.
✗ Branch 1 not taken.
987 if (!previous ||
740
2/4
✓ Branch 0 taken 987 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 987 times.
987 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 987 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
746
747
2/2
✓ Branch 0 taken 5865 times.
✓ Branch 1 taken 987 times.
6852 for (y = 0; y < height; y += 16) {
748
2/2
✓ Branch 0 taken 77755 times.
✓ Branch 1 taken 5865 times.
83620 for (x = 0; x < width; x += 16) {
749 77755 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 77755 times.
77755 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 5865 s->pmv[0].x =
762 5865 s->pmv[0].y = 0;
763
764 5865 current += 16 * linesize;
765 }
766 }
767 }
768
769
1/2
✓ Branch 0 taken 365 times.
✗ Branch 1 not taken.
365 if (!s->nonref) {
770 365 result = av_frame_replace(s->prev, cur);
771
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 365 times.
365 if (result < 0)
772 return result;
773 }
774
775 365 *got_frame = 1;
776 365 result = buf_size;
777
778 365 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