FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/svq1dec.c
Date: 2022-07-07 01:21:54
Exec Total Coverage
Lines: 291 344 84.6%
Branches: 163 215 75.8%

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