lavc: Add DSS SP decoder
[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) || stages < 0) {
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) || stages < 0) {
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_padded_malloc(&s->pkt_swapped,
641                               &s->pkt_swapped_allocated,
642                               buf_size);
643         if (!s->pkt_swapped)
644             return AVERROR(ENOMEM);
645
646         memcpy(s->pkt_swapped, buf, buf_size);
647         buf = s->pkt_swapped;
648         init_get_bits(&s->gb, buf, buf_size * 8);
649         skip_bits(&s->gb, 22);
650
651         src = (uint32_t *)(s->pkt_swapped + 4);
652
653         for (i = 0; i < 4; i++)
654             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
655     }
656
657     result = svq1_decode_frame_header(avctx, cur);
658
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 != 0) {
704                         av_log(avctx, AV_LOG_INFO,
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
823     return 0;
824 }
825
826 static void svq1_flush(AVCodecContext *avctx)
827 {
828     SVQ1Context *s = avctx->priv_data;
829
830     av_frame_unref(s->prev);
831 }
832
833 AVCodec ff_svq1_decoder = {
834     .name           = "svq1",
835     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
836     .type           = AVMEDIA_TYPE_VIDEO,
837     .id             = AV_CODEC_ID_SVQ1,
838     .priv_data_size = sizeof(SVQ1Context),
839     .init           = svq1_decode_init,
840     .close          = svq1_decode_end,
841     .decode         = svq1_decode_frame,
842     .capabilities   = CODEC_CAP_DR1,
843     .flush          = svq1_flush,
844     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
845                                                      AV_PIX_FMT_NONE },
846 };