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