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
svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)164 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 list[0] = pixels;
180
181 /* recursively process vector */
182 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
183 SVQ1_PROCESS_VECTOR();
184
185 /* destination address and vector size */
186 dst = (uint32_t *)list[i];
187 width = 1 << ((4 + level) / 2);
188 height = 1 << ((3 + level) / 2);
189
190 /* get number of stages (-1 skips vector, 0 for mean only) */
191 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
192
193 if (stages == -1) {
194 for (y = 0; y < height; y++)
195 memset(&dst[y * (pitch / 4)], 0, width);
196 continue; /* skip vector */
197 }
198
199 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 av_assert0(stages >= 0);
206
207 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
208
209 if (stages == 0) {
210 for (y = 0; y < height; y++)
211 memset(&dst[y * (pitch / 4)], mean, width);
212 } else {
213 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
214
215 for (y = 0; y < height; y++) {
216 for (x = 0; x < width / 4; x++, codebook++) {
217 n1 = n4;
218 n2 = n4;
219 SVQ1_ADD_CODEBOOK()
220 /* store result */
221 dst[x] = n1 << 8 | n2;
222 }
223 dst += pitch / 4;
224 }
225 }
226 }
227
228 return 0;
229 }
230
svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)231 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 list[0] = pixels;
247
248 /* recursively process vector */
249 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
250 SVQ1_PROCESS_VECTOR();
251
252 /* destination address and vector size */
253 dst = (uint32_t *)list[i];
254 width = 1 << ((4 + level) / 2);
255 height = 1 << ((3 + level) / 2);
256
257 /* get number of stages (-1 skips vector, 0 for mean only) */
258 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
259
260 if (stages == -1)
261 continue; /* skip vector */
262
263 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 av_assert0(stages >= 0);
270
271 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
272
273 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
274
275 for (y = 0; y < height; y++) {
276 for (x = 0; x < width / 4; x++, codebook++) {
277 n3 = dst[x];
278 /* add mean value to vector */
279 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
280 n2 = n4 + (n3 & 0x00FF00FF);
281 SVQ1_ADD_CODEBOOK()
282 /* store result */
283 dst[x] = n1 << 8 | n2;
284 }
285 dst += pitch / 4;
286 }
287 }
288 return 0;
289 }
290
svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)291 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
292 svq1_pmv **pmv)
293 {
294 int diff;
295 int i;
296
297 for (i = 0; i < 2; i++) {
298 /* get motion code */
299 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
300 if (diff < 0)
301 return AVERROR_INVALIDDATA;
302 else if (diff) {
303 if (get_bits1(bitbuf))
304 diff = -diff;
305 }
306
307 /* add median of motion vector predictors and clip result */
308 if (i == 1)
309 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
310 else
311 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
312 }
313
314 return 0;
315 }
316
svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)317 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 src = &previous[x + y * pitch];
325 dst = current;
326
327 for (i = 0; i < 16; i++) {
328 memcpy(dst, src, 16);
329 src += pitch;
330 dst += pitch;
331 }
332 }
333
svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)334 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 pmv[0] = &motion[0];
347 if (y == 0) {
348 pmv[1] =
349 pmv[2] = pmv[0];
350 } else {
351 pmv[1] = &motion[x / 8 + 2];
352 pmv[2] = &motion[x / 8 + 4];
353 }
354
355 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
356 if (result)
357 return result;
358
359 motion[0].x =
360 motion[x / 8 + 2].x =
361 motion[x / 8 + 3].x = mv.x;
362 motion[0].y =
363 motion[x / 8 + 2].y =
364 motion[x / 8 + 3].y = mv.y;
365
366 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
367 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
368
369 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
370 dst = current;
371
372 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
373
374 return 0;
375 }
376
svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)377 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 pmv[0] = &motion[0];
390 if (y == 0) {
391 pmv[1] =
392 pmv[2] = pmv[0];
393 } else {
394 pmv[1] = &motion[(x / 8) + 2];
395 pmv[2] = &motion[(x / 8) + 4];
396 }
397
398 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
399 if (result)
400 return result;
401
402 /* predict and decode motion vector (1) */
403 pmv[0] = &mv;
404 if (y == 0) {
405 pmv[1] =
406 pmv[2] = pmv[0];
407 } else {
408 pmv[1] = &motion[(x / 8) + 3];
409 }
410 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
411 if (result)
412 return result;
413
414 /* predict and decode motion vector (2) */
415 pmv[1] = &motion[0];
416 pmv[2] = &motion[(x / 8) + 1];
417
418 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
419 if (result)
420 return result;
421
422 /* predict and decode motion vector (3) */
423 pmv[2] = &motion[(x / 8) + 2];
424 pmv[3] = &motion[(x / 8) + 3];
425
426 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
427 if (result)
428 return result;
429
430 /* form predictions */
431 for (i = 0; i < 4; i++) {
432 int mvx = pmv[i]->x + (i & 1) * 16;
433 int mvy = pmv[i]->y + (i >> 1) * 16;
434
435 // FIXME: clipping or padding?
436 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
437 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
438
439 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
440 dst = current;
441
442 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
443
444 /* select next block */
445 if (i & 1)
446 current += 8 * (pitch - 1);
447 else
448 current += 8;
449 }
450
451 return 0;
452 }
453
svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)454 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 int result = 0;
462
463 /* get block type */
464 block_type = get_vlc2(bitbuf, svq1_block_type.table,
465 SVQ1_BLOCK_TYPE_VLC_BITS, 1);
466
467 /* reset motion vectors */
468 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
469 motion[0].x =
470 motion[0].y =
471 motion[x / 8 + 2].x =
472 motion[x / 8 + 2].y =
473 motion[x / 8 + 3].x =
474 motion[x / 8 + 3].y = 0;
475 }
476
477 switch (block_type) {
478 case SVQ1_BLOCK_SKIP:
479 svq1_skip_block(current, previous, pitch, x, y);
480 break;
481
482 case SVQ1_BLOCK_INTER:
483 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
484 pitch, motion, x, y, width, height);
485
486 if (result != 0) {
487 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
488 break;
489 }
490 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
491 break;
492
493 case SVQ1_BLOCK_INTER_4V:
494 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
495 pitch, motion, x, y, width, height);
496
497 if (result != 0) {
498 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
499 break;
500 }
501 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
502 break;
503
504 case SVQ1_BLOCK_INTRA:
505 result = svq1_decode_block_intra(bitbuf, current, pitch);
506 break;
507 }
508
509 return result;
510 }
511
svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])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
svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)527 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
528 {
529 SVQ1Context *s = avctx->priv_data;
530 GetBitContext *bitbuf = &s->gb;
531 int frame_size_code;
532 int width = s->width;
533 int height = s->height;
534
535 skip_bits(bitbuf, 8); /* temporal_reference */
536
537 /* frame type */
538 s->nonref = 0;
539 switch (get_bits(bitbuf, 2)) {
540 case 0:
541 frame->pict_type = AV_PICTURE_TYPE_I;
542 break;
543 case 2:
544 s->nonref = 1;
545 case 1:
546 frame->pict_type = AV_PICTURE_TYPE_P;
547 break;
548 default:
549 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
550 return AVERROR_INVALIDDATA;
551 }
552
553 if (frame->pict_type == AV_PICTURE_TYPE_I) {
554 /* unknown fields */
555 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
556 int csum = get_bits(bitbuf, 16);
557
558 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 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 skip_bits(bitbuf, 2);
574 skip_bits(bitbuf, 2);
575 skip_bits1(bitbuf);
576
577 /* load frame size */
578 frame_size_code = get_bits(bitbuf, 3);
579
580 if (frame_size_code == 7) {
581 /* load width, height (12 bits each) */
582 width = get_bits(bitbuf, 12);
583 height = get_bits(bitbuf, 12);
584
585 if (!width || !height)
586 return AVERROR_INVALIDDATA;
587 } else {
588 /* get width, height from table */
589 width = ff_svq1_frame_size_table[frame_size_code][0];
590 height = ff_svq1_frame_size_table[frame_size_code][1];
591 }
592 }
593
594 /* unknown fields */
595 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 if (get_bits1(bitbuf)) {
604 skip_bits1(bitbuf);
605 skip_bits(bitbuf, 4);
606 skip_bits1(bitbuf);
607 skip_bits(bitbuf, 2);
608
609 if (skip_1stop_8data_bits(bitbuf) < 0)
610 return AVERROR_INVALIDDATA;
611 }
612 if (get_bits_left(bitbuf) <= 0)
613 return AVERROR_INVALIDDATA;
614
615 s->width = width;
616 s->height = height;
617 return 0;
618 }
619
svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)620 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,
621 int *got_frame, AVPacket *avpkt)
622 {
623 const uint8_t *buf = avpkt->data;
624 int buf_size = avpkt->size;
625 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 ret = init_get_bits8(&s->gb, buf, buf_size);
632 if (ret < 0)
633 return ret;
634
635 /* decode frame header */
636 s->frame_code = get_bits(&s->gb, 22);
637
638 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
639 return AVERROR_INVALIDDATA;
640
641 /* swap some header bytes (why?) */
642 if (s->frame_code != 0x20) {
643 uint32_t *src;
644
645 if (buf_size < 9 * 4) {
646 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
647 return AVERROR_INVALIDDATA;
648 }
649
650 av_fast_padded_malloc(&s->pkt_swapped,
651 &s->pkt_swapped_allocated,
652 buf_size);
653 if (!s->pkt_swapped)
654 return AVERROR(ENOMEM);
655
656 memcpy(s->pkt_swapped, buf, buf_size);
657 buf = s->pkt_swapped;
658 init_get_bits(&s->gb, buf, buf_size * 8);
659 skip_bits(&s->gb, 22);
660
661 src = (uint32_t *)(s->pkt_swapped + 4);
662
663 for (i = 0; i < 4; i++)
664 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
665 }
666
667 result = svq1_decode_frame_header(avctx, cur);
668 if (result != 0) {
669 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
670 return result;
671 }
672
673 result = ff_set_dimensions(avctx, s->width, s->height);
674 if (result < 0)
675 return result;
676
677 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
678 (avctx->skip_frame >= AVDISCARD_NONKEY &&
679 cur->pict_type != AV_PICTURE_TYPE_I) ||
680 avctx->skip_frame >= AVDISCARD_ALL)
681 return buf_size;
682
683 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
684 if (result < 0)
685 return result;
686
687 av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
688 if (!s->pmv)
689 return AVERROR(ENOMEM);
690
691 /* decode y, u and v components */
692 for (i = 0; i < 3; i++) {
693 int linesize = cur->linesize[i];
694 if (i == 0) {
695 width = FFALIGN(s->width, 16);
696 height = FFALIGN(s->height, 16);
697 } else {
698 if (avctx->flags & AV_CODEC_FLAG_GRAY)
699 break;
700 width = FFALIGN(s->width / 4, 16);
701 height = FFALIGN(s->height / 4, 16);
702 }
703
704 current = cur->data[i];
705
706 if (cur->pict_type == AV_PICTURE_TYPE_I) {
707 /* keyframe */
708 for (y = 0; y < height; y += 16) {
709 for (x = 0; x < width; x += 16) {
710 result = svq1_decode_block_intra(&s->gb, ¤t[x],
711 linesize);
712 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 current += 16 * linesize;
720 }
721 } else {
722 /* delta frame */
723 uint8_t *previous = s->prev->data[i];
724 if (!previous ||
725 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 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
731
732 for (y = 0; y < height; y += 16) {
733 for (x = 0; x < width; x += 16) {
734 result = svq1_decode_delta_block(avctx, &s->hdsp,
735 &s->gb, ¤t[x],
736 previous, linesize,
737 s->pmv, x, y, width, height);
738 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 s->pmv[0].x =
747 s->pmv[0].y = 0;
748
749 current += 16 * linesize;
750 }
751 }
752 }
753
754 if (!s->nonref) {
755 av_frame_unref(s->prev);
756 result = av_frame_ref(s->prev, cur);
757 if (result < 0)
758 return result;
759 }
760
761 *got_frame = 1;
762 result = buf_size;
763
764 return result;
765 }
766
svq1_static_init(void)767 static av_cold void svq1_static_init(void)
768 {
769 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 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 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 svq1_intra_multistage[i].table = &table[offset];
782 svq1_intra_multistage[i].table_allocated = sizes[0][i];
783 offset += sizes[0][i];
784 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 svq1_inter_multistage[i].table = &table[offset];
789 svq1_inter_multistage[i].table_allocated = sizes[1][i];
790 offset += sizes[1][i];
791 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 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 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 }
805
svq1_decode_init(AVCodecContext *avctx)806 static av_cold int svq1_decode_init(AVCodecContext *avctx)
807 {
808 static AVOnce init_static_once = AV_ONCE_INIT;
809 SVQ1Context *s = avctx->priv_data;
810
811 s->prev = av_frame_alloc();
812 if (!s->prev)
813 return AVERROR(ENOMEM);
814
815 s->width = avctx->width + 3 & ~3;
816 s->height = avctx->height + 3 & ~3;
817 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
818
819 ff_hpeldsp_init(&s->hdsp, avctx->flags);
820
821 ff_thread_once(&init_static_once, svq1_static_init);
822
823 return 0;
824 }
825
svq1_decode_end(AVCodecContext *avctx)826 static av_cold int svq1_decode_end(AVCodecContext *avctx)
827 {
828 SVQ1Context *s = avctx->priv_data;
829
830 av_frame_free(&s->prev);
831 av_freep(&s->pkt_swapped);
832 s->pkt_swapped_allocated = 0;
833 av_freep(&s->pmv);
834 s->pmv_allocated = 0;
835
836 return 0;
837 }
838
svq1_flush(AVCodecContext *avctx)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