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 "get_bits.h"
40 #include "h263.h"
41 #include "hpeldsp.h"
42 #include "internal.h"
43 #include "mathops.h"
44 #include "svq1.h"
45
46 #define SVQ1_BLOCK_TYPE_VLC_BITS 3
47 static VLC svq1_block_type;
48 static VLC svq1_motion_component;
49 static VLC svq1_intra_multistage[6];
50 static VLC svq1_inter_multistage[6];
51 static VLC svq1_intra_mean;
52 static VLC svq1_inter_mean;
53
54 /* motion vector (prediction) */
55 typedef struct svq1_pmv_s {
56 int x;
57 int y;
58 } svq1_pmv;
59
60 typedef struct SVQ1Context {
61 HpelDSPContext hdsp;
62 GetBitContext gb;
63 AVFrame *prev;
64
65 uint8_t *pkt_swapped;
66 int pkt_swapped_allocated;
67
68 svq1_pmv *pmv;
69 int pmv_allocated;
70
71 int width;
72 int height;
73 int frame_code;
74 int nonref; // 1 if the current frame won't be referenced
75 } SVQ1Context;
76
77 static const uint8_t string_table[256] = {
78 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
79 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
80 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
81 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
82 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
83 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
84 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
85 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
86 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
87 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
88 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
89 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
90 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
91 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
92 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
93 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
94 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
95 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
96 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
97 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
98 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
99 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
100 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
101 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
102 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
103 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
104 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
105 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
106 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
107 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
108 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
109 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
110 };
111
112 #define SVQ1_PROCESS_VECTOR() \
113 for (; level > 0; i++) { \
114 /* process next depth */ \
115 if (i == m) { \
116 m = n; \
117 if (--level == 0) \
118 break; \
119 } \
120 /* divide block if next bit set */ \
121 if (!get_bits1(bitbuf)) \
122 break; \
123 /* add child nodes */ \
124 list[n++] = list[i]; \
125 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
126 }
127
128 #define SVQ1_ADD_CODEBOOK() \
129 /* add codebook entries to vector */ \
130 for (j = 0; j < stages; j++) { \
131 n3 = codebook[entries[j]] ^ 0x80808080; \
132 n1 += (n3 & 0xFF00FF00) >> 8; \
133 n2 += n3 & 0x00FF00FF; \
134 } \
135 \
136 /* clip to [0..255] */ \
137 if (n1 & 0xFF00FF00) { \
138 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
139 n1 += 0x7F007F00; \
140 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
141 n1 &= n3 & 0x00FF00FF; \
142 } \
143 \
144 if (n2 & 0xFF00FF00) { \
145 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
146 n2 += 0x7F007F00; \
147 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
148 n2 &= n3 & 0x00FF00FF; \
149 }
150
151 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
152 codebook = (const uint32_t *)cbook[level]; \
153 if (stages > 0) \
154 bit_cache = get_bits(bitbuf, 4 * stages); \
155 /* calculate codebook entries for this vector */ \
156 for (j = 0; j < stages; j++) { \
157 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
158 16 * j) << (level + 1); \
159 } \
160 mean -= stages * 128; \
161 n4 = (mean << 16) + mean;
162
svq1_decode_block_intra(GetBitContext * bitbuf,uint8_t * pixels,ptrdiff_t pitch)163 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
164 ptrdiff_t pitch)
165 {
166 uint32_t bit_cache;
167 uint8_t *list[63];
168 uint32_t *dst;
169 const uint32_t *codebook;
170 int entries[6];
171 int i, j, m, n;
172 int stages;
173 unsigned mean;
174 unsigned x, y, width, height, level;
175 uint32_t n1, n2, n3, n4;
176
177 /* initialize list for breadth first processing of vectors */
178 list[0] = pixels;
179
180 /* recursively process vector */
181 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
182 SVQ1_PROCESS_VECTOR();
183
184 /* destination address and vector size */
185 dst = (uint32_t *)list[i];
186 width = 1 << ((4 + level) / 2);
187 height = 1 << ((3 + level) / 2);
188
189 /* get number of stages (-1 skips vector, 0 for mean only) */
190 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
191
192 if (stages == -1) {
193 for (y = 0; y < height; y++)
194 memset(&dst[y * (pitch / 4)], 0, width);
195 continue; /* skip vector */
196 }
197
198 if ((stages > 0 && level >= 4)) {
199 ff_dlog(NULL,
200 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
201 stages, level);
202 return AVERROR_INVALIDDATA; /* invalid vector */
203 }
204 av_assert0(stages >= 0);
205
206 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
207
208 if (stages == 0) {
209 for (y = 0; y < height; y++)
210 memset(&dst[y * (pitch / 4)], mean, width);
211 } else {
212 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
213
214 for (y = 0; y < height; y++) {
215 for (x = 0; x < width / 4; x++, codebook++) {
216 n1 = n4;
217 n2 = n4;
218 SVQ1_ADD_CODEBOOK()
219 /* store result */
220 dst[x] = n1 << 8 | n2;
221 }
222 dst += pitch / 4;
223 }
224 }
225 }
226
227 return 0;
228 }
229
svq1_decode_block_non_intra(GetBitContext * bitbuf,uint8_t * pixels,ptrdiff_t pitch)230 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
231 ptrdiff_t pitch)
232 {
233 uint32_t bit_cache;
234 uint8_t *list[63];
235 uint32_t *dst;
236 const uint32_t *codebook;
237 int entries[6];
238 int i, j, m, n;
239 int stages;
240 unsigned mean;
241 int x, y, width, height, level;
242 uint32_t n1, n2, n3, n4;
243
244 /* initialize list for breadth first processing of vectors */
245 list[0] = pixels;
246
247 /* recursively process vector */
248 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
249 SVQ1_PROCESS_VECTOR();
250
251 /* destination address and vector size */
252 dst = (uint32_t *)list[i];
253 width = 1 << ((4 + level) / 2);
254 height = 1 << ((3 + level) / 2);
255
256 /* get number of stages (-1 skips vector, 0 for mean only) */
257 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
258
259 if (stages == -1)
260 continue; /* skip vector */
261
262 if ((stages > 0 && level >= 4)) {
263 ff_dlog(NULL,
264 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
265 stages, level);
266 return AVERROR_INVALIDDATA; /* invalid vector */
267 }
268 av_assert0(stages >= 0);
269
270 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
271
272 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
273
274 for (y = 0; y < height; y++) {
275 for (x = 0; x < width / 4; x++, codebook++) {
276 n3 = dst[x];
277 /* add mean value to vector */
278 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
279 n2 = n4 + (n3 & 0x00FF00FF);
280 SVQ1_ADD_CODEBOOK()
281 /* store result */
282 dst[x] = n1 << 8 | n2;
283 }
284 dst += pitch / 4;
285 }
286 }
287 return 0;
288 }
289
svq1_decode_motion_vector(GetBitContext * bitbuf,svq1_pmv * mv,svq1_pmv ** pmv)290 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
291 svq1_pmv **pmv)
292 {
293 int diff;
294 int i;
295
296 for (i = 0; i < 2; i++) {
297 /* get motion code */
298 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
299 if (diff < 0)
300 return AVERROR_INVALIDDATA;
301 else if (diff) {
302 if (get_bits1(bitbuf))
303 diff = -diff;
304 }
305
306 /* add median of motion vector predictors and clip result */
307 if (i == 1)
308 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
309 else
310 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
311 }
312
313 return 0;
314 }
315
svq1_skip_block(uint8_t * current,uint8_t * previous,ptrdiff_t pitch,int x,int y)316 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
317 ptrdiff_t pitch, int x, int y)
318 {
319 uint8_t *src;
320 uint8_t *dst;
321 int i;
322
323 src = &previous[x + y * pitch];
324 dst = current;
325
326 for (i = 0; i < 16; i++) {
327 memcpy(dst, src, 16);
328 src += pitch;
329 dst += pitch;
330 }
331 }
332
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)333 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
334 uint8_t *current, uint8_t *previous,
335 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
336 int width, int height)
337 {
338 uint8_t *src;
339 uint8_t *dst;
340 svq1_pmv mv;
341 svq1_pmv *pmv[3];
342 int result;
343
344 /* predict and decode motion vector */
345 pmv[0] = &motion[0];
346 if (y == 0) {
347 pmv[1] =
348 pmv[2] = pmv[0];
349 } else {
350 pmv[1] = &motion[x / 8 + 2];
351 pmv[2] = &motion[x / 8 + 4];
352 }
353
354 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
355 if (result)
356 return result;
357
358 motion[0].x =
359 motion[x / 8 + 2].x =
360 motion[x / 8 + 3].x = mv.x;
361 motion[0].y =
362 motion[x / 8 + 2].y =
363 motion[x / 8 + 3].y = mv.y;
364
365 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
366 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
367
368 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
369 dst = current;
370
371 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
372
373 return 0;
374 }
375
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)376 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
377 uint8_t *current, uint8_t *previous,
378 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
379 int width, int height)
380 {
381 uint8_t *src;
382 uint8_t *dst;
383 svq1_pmv mv;
384 svq1_pmv *pmv[4];
385 int i, result;
386
387 /* predict and decode motion vector (0) */
388 pmv[0] = &motion[0];
389 if (y == 0) {
390 pmv[1] =
391 pmv[2] = pmv[0];
392 } else {
393 pmv[1] = &motion[(x / 8) + 2];
394 pmv[2] = &motion[(x / 8) + 4];
395 }
396
397 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
398 if (result)
399 return result;
400
401 /* predict and decode motion vector (1) */
402 pmv[0] = &mv;
403 if (y == 0) {
404 pmv[1] =
405 pmv[2] = pmv[0];
406 } else {
407 pmv[1] = &motion[(x / 8) + 3];
408 }
409 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
410 if (result)
411 return result;
412
413 /* predict and decode motion vector (2) */
414 pmv[1] = &motion[0];
415 pmv[2] = &motion[(x / 8) + 1];
416
417 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
418 if (result)
419 return result;
420
421 /* predict and decode motion vector (3) */
422 pmv[2] = &motion[(x / 8) + 2];
423 pmv[3] = &motion[(x / 8) + 3];
424
425 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
426 if (result)
427 return result;
428
429 /* form predictions */
430 for (i = 0; i < 4; i++) {
431 int mvx = pmv[i]->x + (i & 1) * 16;
432 int mvy = pmv[i]->y + (i >> 1) * 16;
433
434 // FIXME: clipping or padding?
435 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
436 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
437
438 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
439 dst = current;
440
441 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
442
443 /* select next block */
444 if (i & 1)
445 current += 8 * (pitch - 1);
446 else
447 current += 8;
448 }
449
450 return 0;
451 }
452
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)453 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
454 GetBitContext *bitbuf,
455 uint8_t *current, uint8_t *previous,
456 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
457 int width, int height)
458 {
459 uint32_t block_type;
460 int result = 0;
461
462 /* get block type */
463 block_type = get_vlc2(bitbuf, svq1_block_type.table,
464 SVQ1_BLOCK_TYPE_VLC_BITS, 1);
465
466 /* reset motion vectors */
467 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
468 motion[0].x =
469 motion[0].y =
470 motion[x / 8 + 2].x =
471 motion[x / 8 + 2].y =
472 motion[x / 8 + 3].x =
473 motion[x / 8 + 3].y = 0;
474 }
475
476 switch (block_type) {
477 case SVQ1_BLOCK_SKIP:
478 svq1_skip_block(current, previous, pitch, x, y);
479 break;
480
481 case SVQ1_BLOCK_INTER:
482 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
483 pitch, motion, x, y, width, height);
484
485 if (result != 0) {
486 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
487 break;
488 }
489 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
490 break;
491
492 case SVQ1_BLOCK_INTER_4V:
493 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
494 pitch, motion, x, y, width, height);
495
496 if (result != 0) {
497 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
498 break;
499 }
500 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
501 break;
502
503 case SVQ1_BLOCK_INTRA:
504 result = svq1_decode_block_intra(bitbuf, current, pitch);
505 break;
506 }
507
508 return result;
509 }
510
svq1_parse_string(GetBitContext * bitbuf,uint8_t out[257])511 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
512 {
513 uint8_t seed;
514 int i;
515
516 out[0] = get_bits(bitbuf, 8);
517 seed = string_table[out[0]];
518
519 for (i = 1; i <= out[0]; i++) {
520 out[i] = get_bits(bitbuf, 8) ^ seed;
521 seed = string_table[out[i] ^ seed];
522 }
523 out[i] = 0;
524 }
525
svq1_decode_frame_header(AVCodecContext * avctx,AVFrame * frame)526 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
527 {
528 SVQ1Context *s = avctx->priv_data;
529 GetBitContext *bitbuf = &s->gb;
530 int frame_size_code;
531 int width = s->width;
532 int height = s->height;
533
534 skip_bits(bitbuf, 8); /* temporal_reference */
535
536 /* frame type */
537 s->nonref = 0;
538 switch (get_bits(bitbuf, 2)) {
539 case 0:
540 frame->pict_type = AV_PICTURE_TYPE_I;
541 break;
542 case 2:
543 s->nonref = 1;
544 case 1:
545 frame->pict_type = AV_PICTURE_TYPE_P;
546 break;
547 default:
548 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
549 return AVERROR_INVALIDDATA;
550 }
551
552 if (frame->pict_type == AV_PICTURE_TYPE_I) {
553 /* unknown fields */
554 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
555 int csum = get_bits(bitbuf, 16);
556
557 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
558
559 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
560 (csum == 0) ? "correct" : "incorrect", csum);
561 }
562
563 if ((s->frame_code ^ 0x10) >= 0x50) {
564 uint8_t msg[257];
565
566 svq1_parse_string(bitbuf, msg);
567
568 av_log(avctx, AV_LOG_INFO,
569 "embedded message:\n%s\n", ((char *)msg) + 1);
570 }
571
572 skip_bits(bitbuf, 2);
573 skip_bits(bitbuf, 2);
574 skip_bits1(bitbuf);
575
576 /* load frame size */
577 frame_size_code = get_bits(bitbuf, 3);
578
579 if (frame_size_code == 7) {
580 /* load width, height (12 bits each) */
581 width = get_bits(bitbuf, 12);
582 height = get_bits(bitbuf, 12);
583
584 if (!width || !height)
585 return AVERROR_INVALIDDATA;
586 } else {
587 /* get width, height from table */
588 width = ff_svq1_frame_size_table[frame_size_code][0];
589 height = ff_svq1_frame_size_table[frame_size_code][1];
590 }
591 }
592
593 /* unknown fields */
594 if (get_bits1(bitbuf)) {
595 skip_bits1(bitbuf); /* use packet checksum if (1) */
596 skip_bits1(bitbuf); /* component checksums after image data if (1) */
597
598 if (get_bits(bitbuf, 2) != 0)
599 return AVERROR_INVALIDDATA;
600 }
601
602 if (get_bits1(bitbuf)) {
603 skip_bits1(bitbuf);
604 skip_bits(bitbuf, 4);
605 skip_bits1(bitbuf);
606 skip_bits(bitbuf, 2);
607
608 if (skip_1stop_8data_bits(bitbuf) < 0)
609 return AVERROR_INVALIDDATA;
610 }
611 if (get_bits_left(bitbuf) <= 0)
612 return AVERROR_INVALIDDATA;
613
614 s->width = width;
615 s->height = height;
616 return 0;
617 }
618
svq1_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)619 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
620 int *got_frame, AVPacket *avpkt)
621 {
622 const uint8_t *buf = avpkt->data;
623 int buf_size = avpkt->size;
624 SVQ1Context *s = avctx->priv_data;
625 AVFrame *cur = 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 VLC_TYPE table[168][2];
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 AVCodec ff_svq1_decoder = {
847 .name = "svq1",
848 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849 .type = AVMEDIA_TYPE_VIDEO,
850 .id = AV_CODEC_ID_SVQ1,
851 .priv_data_size = sizeof(SVQ1Context),
852 .init = svq1_decode_init,
853 .close = svq1_decode_end,
854 .decode = svq1_decode_frame,
855 .capabilities = AV_CODEC_CAP_DR1,
856 .flush = svq1_flush,
857 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
858 AV_PIX_FMT_NONE },
859 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
860 };
861