dump: split audio and video probing on multiple lines
[ffmpeg.git] / 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 Libav.
12  *
13  * Libav 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  * Libav 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 Libav; 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) == 0)                                     \
118             break;                                                      \
119         /* add child nodes */                                           \
120         list[n++] = list[i];                                            \
121         list[n++] = list[i] +                                           \
122                     (((level & 1) ? pitch : 1) << (level / 2 + 1));     \
123     }
124
125 #define SVQ1_ADD_CODEBOOK()                                             \
126     /* add codebook entries to vector */                                \
127     for (j = 0; j < stages; j++) {                                      \
128         n3  = codebook[entries[j]] ^ 0x80808080;                        \
129         n1 += (n3 & 0xFF00FF00) >> 8;                                   \
130         n2 +=  n3 & 0x00FF00FF;                                         \
131     }                                                                   \
132                                                                         \
133     /* clip to [0..255] */                                              \
134     if (n1 & 0xFF00FF00) {                                              \
135         n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
136         n1 += 0x7F007F00;                                               \
137         n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
138         n1 &= n3 & 0x00FF00FF;                                          \
139     }                                                                   \
140                                                                         \
141     if (n2 & 0xFF00FF00) {                                              \
142         n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
143         n2 += 0x7F007F00;                                               \
144         n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
145         n2 &= n3 & 0x00FF00FF;                                          \
146     }
147
148 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
149     codebook = (const uint32_t *)cbook[level];                          \
150     if (stages > 0)                                                     \
151         bit_cache = get_bits(bitbuf, 4 * stages);                       \
152     /* calculate codebook entries for this vector */                    \
153     for (j = 0; j < stages; j++) {                                      \
154         entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
155                       16 * j) << (level + 1);                           \
156     }                                                                   \
157     mean -= stages * 128;                                               \
158     n4    = mean + (mean >> 31) << 16 | (mean & 0xFFFF);
159
160 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
161                                    int pitch)
162 {
163     uint32_t bit_cache;
164     uint8_t *list[63];
165     uint32_t *dst;
166     const uint32_t *codebook;
167     int entries[6];
168     int i, j, m, n;
169     int mean, stages;
170     unsigned x, y, width, height, level;
171     uint32_t n1, n2, n3, n4;
172
173     /* initialize list for breadth first processing of vectors */
174     list[0] = pixels;
175
176     /* recursively process vector */
177     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
178         SVQ1_PROCESS_VECTOR();
179
180         /* destination address and vector size */
181         dst    = (uint32_t *)list[i];
182         width  = 1 << ((4 + level) / 2);
183         height = 1 << ((3 + level) / 2);
184
185         /* get number of stages (-1 skips vector, 0 for mean only) */
186         stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
187
188         if (stages == -1) {
189             for (y = 0; y < height; y++)
190                 memset(&dst[y * (pitch / 4)], 0, width);
191             continue;   /* skip vector */
192         }
193
194         if (stages > 0 && level >= 4) {
195             av_dlog(NULL,
196                     "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
197                     stages, level);
198             return AVERROR_INVALIDDATA;  /* invalid vector */
199         }
200
201         mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
202
203         if (stages == 0) {
204             for (y = 0; y < height; y++)
205                 memset(&dst[y * (pitch / 4)], mean, width);
206         } else {
207             SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
208
209             for (y = 0; y < height; y++) {
210                 for (x = 0; x < width / 4; x++, codebook++) {
211                     n1 = n4;
212                     n2 = n4;
213                     SVQ1_ADD_CODEBOOK()
214                     /* store result */
215                     dst[x] = n1 << 8 | n2;
216                 }
217                 dst += pitch / 4;
218             }
219         }
220     }
221
222     return 0;
223 }
224
225 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
226                                        int pitch)
227 {
228     uint32_t bit_cache;
229     uint8_t *list[63];
230     uint32_t *dst;
231     const uint32_t *codebook;
232     int entries[6];
233     int i, j, m, n;
234     int mean, stages;
235     int x, y, width, height, level;
236     uint32_t n1, n2, n3, n4;
237
238     /* initialize list for breadth first processing of vectors */
239     list[0] = pixels;
240
241     /* recursively process vector */
242     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
243         SVQ1_PROCESS_VECTOR();
244
245         /* destination address and vector size */
246         dst    = (uint32_t *)list[i];
247         width  = 1 << ((4 + level) / 2);
248         height = 1 << ((3 + level) / 2);
249
250         /* get number of stages (-1 skips vector, 0 for mean only) */
251         stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
252
253         if (stages == -1)
254             continue;           /* skip vector */
255
256         if ((stages > 0) && (level >= 4)) {
257             av_dlog(NULL,
258                     "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
259                     stages, level);
260             return AVERROR_INVALIDDATA;  /* invalid vector */
261         }
262
263         mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
264
265         SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
266
267         for (y = 0; y < height; y++) {
268             for (x = 0; x < width / 4; x++, codebook++) {
269                 n3 = dst[x];
270                 /* add mean value to vector */
271                 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
272                 n2 = n4 +  (n3 & 0x00FF00FF);
273                 SVQ1_ADD_CODEBOOK()
274                 /* store result */
275                 dst[x] = n1 << 8 | n2;
276             }
277             dst += pitch / 4;
278         }
279     }
280     return 0;
281 }
282
283 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
284                                      svq1_pmv **pmv)
285 {
286     int diff;
287     int i;
288
289     for (i = 0; i < 2; i++) {
290         /* get motion code */
291         diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
292         if (diff < 0)
293             return AVERROR_INVALIDDATA;
294         else if (diff) {
295             if (get_bits1(bitbuf))
296                 diff = -diff;
297         }
298
299         /* add median of motion vector predictors and clip result */
300         if (i == 1)
301             mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
302         else
303             mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
304     }
305
306     return 0;
307 }
308
309 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
310                             int pitch, int x, int y)
311 {
312     uint8_t *src;
313     uint8_t *dst;
314     int i;
315
316     src = &previous[x + y * pitch];
317     dst = current;
318
319     for (i = 0; i < 16; i++) {
320         memcpy(dst, src, 16);
321         src += pitch;
322         dst += pitch;
323     }
324 }
325
326 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
327                                    uint8_t *current, uint8_t *previous,
328                                    int pitch, svq1_pmv *motion, int x, int y,
329                                    int width, int height)
330 {
331     uint8_t *src;
332     uint8_t *dst;
333     svq1_pmv mv;
334     svq1_pmv *pmv[3];
335     int result;
336
337     /* predict and decode motion vector */
338     pmv[0] = &motion[0];
339     if (y == 0) {
340         pmv[1] =
341         pmv[2] = pmv[0];
342     } else {
343         pmv[1] = &motion[x / 8 + 2];
344         pmv[2] = &motion[x / 8 + 4];
345     }
346
347     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
348
349     if (result != 0)
350         return result;
351
352     motion[0].x         =
353     motion[x / 8 + 2].x =
354     motion[x / 8 + 3].x = mv.x;
355     motion[0].y         =
356     motion[x / 8 + 2].y =
357     motion[x / 8 + 3].y = mv.y;
358
359     mv.x = av_clip(mv.x, -2 * x, 2 * (width  - x - 16));
360     mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
361
362     src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
363     dst = current;
364
365     hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
366
367     return 0;
368 }
369
370 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
371                                       uint8_t *current, uint8_t *previous,
372                                       int pitch, svq1_pmv *motion, int x, int y,
373                                       int width, int height)
374 {
375     uint8_t *src;
376     uint8_t *dst;
377     svq1_pmv mv;
378     svq1_pmv *pmv[4];
379     int i, result;
380
381     /* predict and decode motion vector (0) */
382     pmv[0] = &motion[0];
383     if (y == 0) {
384         pmv[1] =
385         pmv[2] = pmv[0];
386     } else {
387         pmv[1] = &motion[(x / 8) + 2];
388         pmv[2] = &motion[(x / 8) + 4];
389     }
390
391     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
392
393     if (result != 0)
394         return result;
395
396     /* predict and decode motion vector (1) */
397     pmv[0] = &mv;
398     if (y == 0) {
399         pmv[1] =
400         pmv[2] = pmv[0];
401     } else {
402         pmv[1] = &motion[(x / 8) + 3];
403     }
404     result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
405
406     if (result != 0)
407         return result;
408
409     /* predict and decode motion vector (2) */
410     pmv[1] = &motion[0];
411     pmv[2] = &motion[(x / 8) + 1];
412
413     result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
414
415     if (result != 0)
416         return result;
417
418     /* predict and decode motion vector (3) */
419     pmv[2] = &motion[(x / 8) + 2];
420     pmv[3] = &motion[(x / 8) + 3];
421
422     result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
423
424     if (result != 0)
425         return result;
426
427     /* form predictions */
428     for (i = 0; i < 4; i++) {
429         int mvx = pmv[i]->x + (i  & 1) * 16;
430         int mvy = pmv[i]->y + (i >> 1) * 16;
431
432         // FIXME: clipping or padding?
433         mvx = av_clip(mvx, -2 * x, 2 * (width  - x - 8));
434         mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
435
436         src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
437         dst = current;
438
439         hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
440
441         /* select next block */
442         if (i & 1)
443             current += 8 * (pitch - 1);
444         else
445             current += 8;
446     }
447
448     return 0;
449 }
450
451 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
452                                    GetBitContext *bitbuf,
453                                    uint8_t *current, uint8_t *previous,
454                                    int pitch, svq1_pmv *motion, int x, int y,
455                                    int width, int height)
456 {
457     uint32_t block_type;
458     int result = 0;
459
460     /* get block type */
461     block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
462
463     /* reset motion vectors */
464     if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
465         motion[0].x         =
466         motion[0].y         =
467         motion[x / 8 + 2].x =
468         motion[x / 8 + 2].y =
469         motion[x / 8 + 3].x =
470         motion[x / 8 + 3].y = 0;
471     }
472
473     switch (block_type) {
474     case SVQ1_BLOCK_SKIP:
475         svq1_skip_block(current, previous, pitch, x, y);
476         break;
477
478     case SVQ1_BLOCK_INTER:
479         result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
480                                          pitch, motion, x, y, width, height);
481
482         if (result != 0) {
483             av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
484             break;
485         }
486         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
487         break;
488
489     case SVQ1_BLOCK_INTER_4V:
490         result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
491                                             pitch, motion, x, y, width, height);
492
493         if (result != 0) {
494             av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
495             break;
496         }
497         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
498         break;
499
500     case SVQ1_BLOCK_INTRA:
501         result = svq1_decode_block_intra(bitbuf, current, pitch);
502         break;
503     }
504
505     return result;
506 }
507
508 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
509 {
510     uint8_t seed;
511     int i;
512
513     out[0] = get_bits(bitbuf, 8);
514     seed   = string_table[out[0]];
515
516     for (i = 1; i <= out[0]; i++) {
517         out[i] = get_bits(bitbuf, 8) ^ seed;
518         seed   = string_table[out[i] ^ seed];
519     }
520 }
521
522 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
523 {
524     SVQ1Context *s = avctx->priv_data;
525     GetBitContext *bitbuf = &s->gb;
526     int frame_size_code;
527
528     skip_bits(bitbuf, 8); /* temporal_reference */
529
530     /* frame type */
531     s->nonref = 0;
532     switch (get_bits(bitbuf, 2)) {
533     case 0:
534         frame->pict_type = AV_PICTURE_TYPE_I;
535         break;
536     case 2:
537         s->nonref = 1;
538     case 1:
539         frame->pict_type = AV_PICTURE_TYPE_P;
540         break;
541     default:
542         av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
543         return AVERROR_INVALIDDATA;
544     }
545
546     if (frame->pict_type == AV_PICTURE_TYPE_I) {
547         /* unknown fields */
548         if (s->frame_code == 0x50 || s->frame_code == 0x60) {
549             int csum = get_bits(bitbuf, 16);
550
551             csum = ff_svq1_packet_checksum(bitbuf->buffer,
552                                            bitbuf->size_in_bits >> 3,
553                                            csum);
554
555             av_dlog(avctx, "%s checksum (%02x) for packet data\n",
556                     (csum == 0) ? "correct" : "incorrect", csum);
557         }
558
559         if ((s->frame_code ^ 0x10) >= 0x50) {
560             uint8_t msg[256];
561
562             svq1_parse_string(bitbuf, msg);
563
564             av_log(avctx, AV_LOG_INFO,
565                    "embedded message: \"%s\"\n", (char *)msg);
566         }
567
568         skip_bits(bitbuf, 2);
569         skip_bits(bitbuf, 2);
570         skip_bits1(bitbuf);
571
572         /* load frame size */
573         frame_size_code = get_bits(bitbuf, 3);
574
575         if (frame_size_code == 7) {
576             /* load width, height (12 bits each) */
577             s->width  = get_bits(bitbuf, 12);
578             s->height = get_bits(bitbuf, 12);
579
580             if (!s->width || !s->height)
581                 return AVERROR_INVALIDDATA;
582         } else {
583             /* get width, height from table */
584             s->width  = ff_svq1_frame_size_table[frame_size_code][0];
585             s->height = ff_svq1_frame_size_table[frame_size_code][1];
586         }
587     }
588
589     /* unknown fields */
590     if (get_bits1(bitbuf) == 1) {
591         skip_bits1(bitbuf);    /* use packet checksum if (1) */
592         skip_bits1(bitbuf);    /* component checksums after image data if (1) */
593
594         if (get_bits(bitbuf, 2) != 0)
595             return AVERROR_INVALIDDATA;
596     }
597
598     if (get_bits1(bitbuf) == 1) {
599         skip_bits1(bitbuf);
600         skip_bits(bitbuf, 4);
601         skip_bits1(bitbuf);
602         skip_bits(bitbuf, 2);
603
604         while (get_bits1(bitbuf) == 1)
605             skip_bits(bitbuf, 8);
606     }
607
608     return 0;
609 }
610
611 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
612                              int *got_frame, AVPacket *avpkt)
613 {
614     const uint8_t *buf = avpkt->data;
615     int buf_size       = avpkt->size;
616     SVQ1Context     *s = avctx->priv_data;
617     AVFrame       *cur = data;
618     uint8_t *current;
619     int result, i, x, y, width, height;
620     svq1_pmv *pmv;
621
622     /* initialize bit buffer */
623     init_get_bits(&s->gb, buf, buf_size * 8);
624
625     /* decode frame header */
626     s->frame_code = get_bits(&s->gb, 22);
627
628     if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
629         return AVERROR_INVALIDDATA;
630
631     /* swap some header bytes (why?) */
632     if (s->frame_code != 0x20) {
633         uint32_t *src;
634
635         if (buf_size < 9 * 4) {
636             av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
637             return AVERROR_INVALIDDATA;
638         }
639
640         av_fast_malloc(s->pkt_swapped, &s->pkt_swapped_allocated,
641                        buf_size);
642         if (!s->pkt_swapped)
643             return AVERROR(ENOMEM);
644
645         memcpy(s->pkt_swapped, buf, buf_size);
646         buf = s->pkt_swapped;
647         init_get_bits(&s->gb, buf, buf_size * 8);
648         skip_bits(&s->gb, 22);
649
650         src = (uint32_t *)(s->pkt_swapped + 4);
651
652         for (i = 0; i < 4; i++)
653             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
654     }
655
656     result = svq1_decode_frame_header(avctx, cur);
657
658     if (result != 0) {
659         av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
660         return result;
661     }
662
663     result = ff_set_dimensions(avctx, s->width, s->height);
664     if (result < 0)
665         return result;
666
667     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
668         (avctx->skip_frame >= AVDISCARD_NONKEY &&
669          cur->pict_type != AV_PICTURE_TYPE_I) ||
670         avctx->skip_frame >= AVDISCARD_ALL)
671         return buf_size;
672
673     result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
674     if (result < 0)
675         return result;
676
677     pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
678     if (!pmv)
679         return AVERROR(ENOMEM);
680
681     /* decode y, u and v components */
682     for (i = 0; i < 3; i++) {
683         int linesize = cur->linesize[i];
684         if (i == 0) {
685             width    = FFALIGN(s->width,  16);
686             height   = FFALIGN(s->height, 16);
687         } else {
688             if (avctx->flags & CODEC_FLAG_GRAY)
689                 break;
690             width    = FFALIGN(s->width  / 4, 16);
691             height   = FFALIGN(s->height / 4, 16);
692         }
693
694         current = cur->data[i];
695
696         if (cur->pict_type == AV_PICTURE_TYPE_I) {
697             /* keyframe */
698             for (y = 0; y < height; y += 16) {
699                 for (x = 0; x < width; x += 16) {
700                     result = svq1_decode_block_intra(&s->gb, &current[x],
701                                                      linesize);
702                     if (result != 0) {
703                         av_log(avctx, AV_LOG_INFO,
704                                "Error in svq1_decode_block %i (keyframe)\n",
705                                result);
706                         goto err;
707                     }
708                 }
709                 current += 16 * linesize;
710             }
711         } else {
712             /* delta frame */
713             uint8_t *previous = s->prev->data[i];
714             if (!previous ||
715                 s->prev->width != s->width || s->prev->height != s->height) {
716                 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
717                 result = AVERROR_INVALIDDATA;
718                 goto err;
719             }
720
721             memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
722
723             for (y = 0; y < height; y += 16) {
724                 for (x = 0; x < width; x += 16) {
725                     result = svq1_decode_delta_block(avctx, &s->hdsp,
726                                                      &s->gb, &current[x],
727                                                      previous, linesize,
728                                                      pmv, x, y, width, height);
729                     if (result != 0) {
730                         av_dlog(avctx,
731                                 "Error in svq1_decode_delta_block %i\n",
732                                 result);
733                         goto err;
734                     }
735                 }
736
737                 pmv[0].x     =
738                     pmv[0].y = 0;
739
740                 current += 16 * linesize;
741             }
742         }
743     }
744
745     if (!s->nonref) {
746         av_frame_unref(s->prev);
747         result = av_frame_ref(s->prev, cur);
748         if (result < 0)
749             goto err;
750     }
751
752     *got_frame = 1;
753     result     = buf_size;
754
755 err:
756     av_free(pmv);
757     return result;
758 }
759
760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
761 {
762     SVQ1Context *s = avctx->priv_data;
763     int i;
764     int offset = 0;
765
766     s->prev = av_frame_alloc();
767     if (!s->prev)
768         return AVERROR(ENOMEM);
769
770     s->width            = avctx->width  + 3 & ~3;
771     s->height           = avctx->height + 3 & ~3;
772     avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
773
774     ff_hpeldsp_init(&s->hdsp, avctx->flags);
775
776     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
777                     &ff_svq1_block_type_vlc[0][1], 2, 1,
778                     &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
779
780     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
781                     &ff_mvtab[0][1], 2, 1,
782                     &ff_mvtab[0][0], 2, 1, 176);
783
784     for (i = 0; i < 6; i++) {
785         static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
786                                              { 10, 10, 14, 14, 14, 16 } };
787         static VLC_TYPE table[168][2];
788         svq1_intra_multistage[i].table           = &table[offset];
789         svq1_intra_multistage[i].table_allocated = sizes[0][i];
790         offset                                  += sizes[0][i];
791         init_vlc(&svq1_intra_multistage[i], 3, 8,
792                  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793                  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
794                  INIT_VLC_USE_NEW_STATIC);
795         svq1_inter_multistage[i].table           = &table[offset];
796         svq1_inter_multistage[i].table_allocated = sizes[1][i];
797         offset                                  += sizes[1][i];
798         init_vlc(&svq1_inter_multistage[i], 3, 8,
799                  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
800                  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
801                  INIT_VLC_USE_NEW_STATIC);
802     }
803
804     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
805                     &ff_svq1_intra_mean_vlc[0][1], 4, 2,
806                     &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
807
808     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
809                     &ff_svq1_inter_mean_vlc[0][1], 4, 2,
810                     &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
811
812     return 0;
813 }
814
815 static av_cold int svq1_decode_end(AVCodecContext *avctx)
816 {
817     SVQ1Context *s = avctx->priv_data;
818
819     av_frame_free(&s->prev);
820     av_freep(&s->pkt_swapped);
821
822     return 0;
823 }
824
825 static void svq1_flush(AVCodecContext *avctx)
826 {
827     SVQ1Context *s = avctx->priv_data;
828
829     av_frame_unref(s->prev);
830 }
831
832 AVCodec ff_svq1_decoder = {
833     .name           = "svq1",
834     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
835     .type           = AVMEDIA_TYPE_VIDEO,
836     .id             = AV_CODEC_ID_SVQ1,
837     .priv_data_size = sizeof(SVQ1Context),
838     .init           = svq1_decode_init,
839     .close          = svq1_decode_end,
840     .decode         = svq1_decode_frame,
841     .capabilities   = CODEC_CAP_DR1,
842     .flush          = svq1_flush,
843     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
844                                                      AV_PIX_FMT_NONE },
845 };