Replace some occurrences of -1 with PIX_FMT_NONE.
[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 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 svq1.c
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
36 //#define DEBUG_SVQ1
37 #include "avcodec.h"
38 #include "dsputil.h"
39 #include "mpegvideo.h"
40
41 #include "svq1.h"
42
43 #undef NDEBUG
44 #include <assert.h>
45
46 extern const uint8_t mvtab[33][2];
47
48 static VLC svq1_block_type;
49 static VLC svq1_motion_component;
50 static VLC svq1_intra_multistage[6];
51 static VLC svq1_inter_multistage[6];
52 static VLC svq1_intra_mean;
53 static VLC svq1_inter_mean;
54
55 /* motion vector (prediction) */
56 typedef struct svq1_pmv_s {
57   int           x;
58   int           y;
59 } svq1_pmv_t;
60
61 static const uint16_t checksum_table[256] = {
62   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
63   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
64   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
65   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
66   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
67   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
68   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
69   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
70   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
71   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
72   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
73   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
74   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
75   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
76   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
77   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
78   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
79   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
80   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
81   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
82   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
83   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
84   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
85   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
86   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
87   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
88   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
89   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
90   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
91   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
92   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
93   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
94 };
95
96 static const uint8_t string_table[256] = {
97   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
98   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
99   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
100   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
101   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
102   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
103   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
104   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
105   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
106   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
107   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
108   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
109   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
110   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
111   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
112   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
113   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
114   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
115   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
116   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
117   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
118   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
119   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
120   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
121   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
122   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
123   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
124   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
125   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
126   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
127   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
128   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
129 };
130
131 #define SVQ1_PROCESS_VECTOR()\
132     for (; level > 0; i++) {\
133       /* process next depth */\
134       if (i == m) {\
135         m = n;\
136         if (--level == 0)\
137           break;\
138       }\
139       /* divide block if next bit set */\
140       if (get_bits1 (bitbuf) == 0)\
141         break;\
142       /* add child nodes */\
143       list[n++] = list[i];\
144       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
145     }
146
147 #define SVQ1_ADD_CODEBOOK()\
148           /* add codebook entries to vector */\
149           for (j=0; j < stages; j++) {\
150             n3  = codebook[entries[j]] ^ 0x80808080;\
151             n1 += ((n3 & 0xFF00FF00) >> 8);\
152             n2 +=  (n3 & 0x00FF00FF);\
153           }\
154 \
155           /* clip to [0..255] */\
156           if (n1 & 0xFF00FF00) {\
157             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
158             n1 += 0x7F007F00;\
159             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
160             n1 &= (n3 & 0x00FF00FF);\
161           }\
162 \
163           if (n2 & 0xFF00FF00) {\
164             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165             n2 += 0x7F007F00;\
166             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
167             n2 &= (n3 & 0x00FF00FF);\
168           }
169
170 #define SVQ1_DO_CODEBOOK_INTRA()\
171       for (y=0; y < height; y++) {\
172         for (x=0; x < (width / 4); x++, codebook++) {\
173         n1 = n4;\
174         n2 = n4;\
175         SVQ1_ADD_CODEBOOK()\
176         /* store result */\
177         dst[x] = (n1 << 8) | n2;\
178         }\
179         dst += (pitch / 4);\
180       }
181
182 #define SVQ1_DO_CODEBOOK_NONINTRA()\
183       for (y=0; y < height; y++) {\
184         for (x=0; x < (width / 4); x++, codebook++) {\
185         n3 = dst[x];\
186         /* add mean value to vector */\
187         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
188         n2 =  (n3 & 0x00FF00FF)          + n4;\
189         SVQ1_ADD_CODEBOOK()\
190         /* store result */\
191         dst[x] = (n1 << 8) | n2;\
192         }\
193         dst += (pitch / 4);\
194       }
195
196 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
197       codebook = (const uint32_t *) cbook[level];\
198       bit_cache = get_bits (bitbuf, 4*stages);\
199       /* calculate codebook entries for this vector */\
200       for (j=0; j < stages; j++) {\
201         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
202       }\
203       mean -= (stages * 128);\
204       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
205
206 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
207   uint32_t    bit_cache;
208   uint8_t    *list[63];
209   uint32_t   *dst;
210   const uint32_t *codebook;
211   int         entries[6];
212   int         i, j, m, n;
213   int         mean, stages;
214   unsigned    x, y, width, height, level;
215   uint32_t    n1, n2, n3, n4;
216
217   /* initialize list for breadth first processing of vectors */
218   list[0] = pixels;
219
220   /* recursively process vector */
221   for (i=0, m=1, n=1, level=5; i < n; i++) {
222     SVQ1_PROCESS_VECTOR();
223
224     /* destination address and vector size */
225     dst = (uint32_t *) list[i];
226     width = 1 << ((4 + level) /2);
227     height = 1 << ((3 + level) /2);
228
229     /* get number of stages (-1 skips vector, 0 for mean only) */
230     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
231
232     if (stages == -1) {
233         for (y=0; y < height; y++) {
234           memset (&dst[y*(pitch / 4)], 0, width);
235         }
236       continue;                 /* skip vector */
237     }
238
239     if ((stages > 0) && (level >= 4)) {
240 #ifdef DEBUG_SVQ1
241     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
242 #endif
243       return -1;        /* invalid vector */
244     }
245
246     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
247
248     if (stages == 0) {
249       for (y=0; y < height; y++) {
250         memset (&dst[y*(pitch / 4)], mean, width);
251       }
252     } else {
253       SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
254       SVQ1_DO_CODEBOOK_INTRA()
255     }
256   }
257
258   return 0;
259 }
260
261 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
262   uint32_t    bit_cache;
263   uint8_t    *list[63];
264   uint32_t   *dst;
265   const uint32_t *codebook;
266   int         entries[6];
267   int         i, j, m, n;
268   int         mean, stages;
269   int         x, y, width, height, level;
270   uint32_t    n1, n2, n3, n4;
271
272   /* initialize list for breadth first processing of vectors */
273   list[0] = pixels;
274
275   /* recursively process vector */
276   for (i=0, m=1, n=1, level=5; i < n; i++) {
277     SVQ1_PROCESS_VECTOR();
278
279     /* destination address and vector size */
280     dst = (uint32_t *) list[i];
281     width = 1 << ((4 + level) /2);
282     height = 1 << ((3 + level) /2);
283
284     /* get number of stages (-1 skips vector, 0 for mean only) */
285     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
286
287     if (stages == -1) continue; /* skip vector */
288
289     if ((stages > 0) && (level >= 4)) {
290 #ifdef DEBUG_SVQ1
291     av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
292 #endif
293       return -1;        /* invalid vector */
294     }
295
296     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
297
298     SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
299     SVQ1_DO_CODEBOOK_NONINTRA()
300   }
301   return 0;
302 }
303
304 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
305   int        diff;
306   int        i;
307
308   for (i=0; i < 2; i++) {
309
310     /* get motion code */
311     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
312     if(diff<0)
313         return -1;
314     else if(diff){
315         if(get_bits1(bitbuf)) diff= -diff;
316     }
317
318     /* add median of motion vector predictors and clip result */
319     if (i == 1)
320       mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
321     else
322       mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
323   }
324
325   return 0;
326 }
327
328 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
329   uint8_t *src;
330   uint8_t *dst;
331   int      i;
332
333   src = &previous[x + y*pitch];
334   dst = current;
335
336   for (i=0; i < 16; i++) {
337     memcpy (dst, src, 16);
338     src += pitch;
339     dst += pitch;
340   }
341 }
342
343 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
344                                uint8_t *current, uint8_t *previous, int pitch,
345                                svq1_pmv_t *motion, int x, int y) {
346   uint8_t    *src;
347   uint8_t    *dst;
348   svq1_pmv_t  mv;
349   svq1_pmv_t *pmv[3];
350   int         result;
351
352   /* predict and decode motion vector */
353   pmv[0] = &motion[0];
354   if (y == 0) {
355     pmv[1] =
356     pmv[2] = pmv[0];
357   }
358   else {
359     pmv[1] = &motion[(x / 8) + 2];
360     pmv[2] = &motion[(x / 8) + 4];
361   }
362
363   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
364
365   if (result != 0)
366     return result;
367
368   motion[0].x                =
369   motion[(x / 8) + 2].x      =
370   motion[(x / 8) + 3].x      = mv.x;
371   motion[0].y                =
372   motion[(x / 8) + 2].y      =
373   motion[(x / 8) + 3].y      = mv.y;
374
375   if(y + (mv.y >> 1)<0)
376      mv.y= 0;
377   if(x + (mv.x >> 1)<0)
378      mv.x= 0;
379
380 #if 0
381   int w= (s->width+15)&~15;
382   int h= (s->height+15)&~15;
383   if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
384       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
385 #endif
386
387   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
388   dst = current;
389
390   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
391
392   return 0;
393 }
394
395 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
396                                   uint8_t *current, uint8_t *previous, int pitch,
397                                   svq1_pmv_t *motion,int x, int y) {
398   uint8_t    *src;
399   uint8_t    *dst;
400   svq1_pmv_t  mv;
401   svq1_pmv_t *pmv[4];
402   int         i, result;
403
404   /* predict and decode motion vector (0) */
405   pmv[0] = &motion[0];
406   if (y == 0) {
407     pmv[1] =
408     pmv[2] = pmv[0];
409   }
410   else {
411     pmv[1] = &motion[(x / 8) + 2];
412     pmv[2] = &motion[(x / 8) + 4];
413   }
414
415   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
416
417   if (result != 0)
418     return result;
419
420   /* predict and decode motion vector (1) */
421   pmv[0] = &mv;
422   if (y == 0) {
423     pmv[1] =
424     pmv[2] = pmv[0];
425   }
426   else {
427     pmv[1] = &motion[(x / 8) + 3];
428   }
429   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
430
431   if (result != 0)
432     return result;
433
434   /* predict and decode motion vector (2) */
435   pmv[1] = &motion[0];
436   pmv[2] = &motion[(x / 8) + 1];
437
438   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
439
440   if (result != 0)
441     return result;
442
443   /* predict and decode motion vector (3) */
444   pmv[2] = &motion[(x / 8) + 2];
445   pmv[3] = &motion[(x / 8) + 3];
446
447   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
448
449   if (result != 0)
450     return result;
451
452   /* form predictions */
453   for (i=0; i < 4; i++) {
454     int mvx= pmv[i]->x + (i&1)*16;
455     int mvy= pmv[i]->y + (i>>1)*16;
456
457     ///XXX /FIXME clipping or padding?
458     if(y + (mvy >> 1)<0)
459        mvy= 0;
460     if(x + (mvx >> 1)<0)
461        mvx= 0;
462
463 #if 0
464   int w= (s->width+15)&~15;
465   int h= (s->height+15)&~15;
466   if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
467       av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
468 #endif
469     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
470     dst = current;
471
472     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
473
474     /* select next block */
475     if (i & 1) {
476       current  += 8*(pitch - 1);
477     } else {
478       current  += 8;
479     }
480   }
481
482   return 0;
483 }
484
485 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
486                         uint8_t *current, uint8_t *previous, int pitch,
487                         svq1_pmv_t *motion, int x, int y) {
488   uint32_t block_type;
489   int      result = 0;
490
491   /* get block type */
492   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
493
494   /* reset motion vectors */
495   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
496     motion[0].x                 =
497     motion[0].y                 =
498     motion[(x / 8) + 2].x =
499     motion[(x / 8) + 2].y =
500     motion[(x / 8) + 3].x =
501     motion[(x / 8) + 3].y = 0;
502   }
503
504   switch (block_type) {
505   case SVQ1_BLOCK_SKIP:
506     svq1_skip_block (current, previous, pitch, x, y);
507     break;
508
509   case SVQ1_BLOCK_INTER:
510     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
511
512     if (result != 0)
513     {
514 #ifdef DEBUG_SVQ1
515     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
516 #endif
517       break;
518     }
519     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
520     break;
521
522   case SVQ1_BLOCK_INTER_4V:
523     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
524
525     if (result != 0)
526     {
527 #ifdef DEBUG_SVQ1
528     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
529 #endif
530       break;
531     }
532     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
533     break;
534
535   case SVQ1_BLOCK_INTRA:
536     result = svq1_decode_block_intra (bitbuf, current, pitch);
537     break;
538   }
539
540   return result;
541 }
542
543 static uint16_t svq1_packet_checksum (const uint8_t *data, const int length, int value) {
544   int i;
545
546   for (i=0; i < length; i++) {
547     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
548   }
549
550   return value;
551 }
552
553 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
554   uint8_t seed;
555   int     i;
556
557   out[0] = get_bits (bitbuf, 8);
558
559   seed = string_table[out[0]];
560
561   for (i=1; i <= out[0]; i++) {
562     out[i] = get_bits (bitbuf, 8) ^ seed;
563     seed   = string_table[out[i] ^ seed];
564   }
565 }
566
567 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
568   int frame_size_code;
569   int temporal_reference;
570
571   temporal_reference = get_bits (bitbuf, 8);
572
573   /* frame type */
574   s->pict_type= get_bits (bitbuf, 2)+1;
575   if(s->pict_type==4)
576       return -1;
577
578   if (s->pict_type == FF_I_TYPE) {
579
580     /* unknown fields */
581     if (s->f_code == 0x50 || s->f_code == 0x60) {
582       int csum = get_bits (bitbuf, 16);
583
584       csum = svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
585
586 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
587 //              (csum == 0) ? "correct" : "incorrect", csum);
588     }
589
590     if ((s->f_code ^ 0x10) >= 0x50) {
591       uint8_t msg[256];
592
593       svq1_parse_string (bitbuf, msg);
594
595       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
596     }
597
598     skip_bits (bitbuf, 2);
599     skip_bits (bitbuf, 2);
600     skip_bits1 (bitbuf);
601
602     /* load frame size */
603     frame_size_code = get_bits (bitbuf, 3);
604
605     if (frame_size_code == 7) {
606       /* load width, height (12 bits each) */
607       s->width = get_bits (bitbuf, 12);
608       s->height = get_bits (bitbuf, 12);
609
610       if (!s->width || !s->height)
611         return -1;
612     } else {
613       /* get width, height from table */
614       s->width = ff_svq1_frame_size_table[frame_size_code].width;
615       s->height = ff_svq1_frame_size_table[frame_size_code].height;
616     }
617   }
618
619   /* unknown fields */
620   if (get_bits1 (bitbuf) == 1) {
621     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
622     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
623
624     if (get_bits (bitbuf, 2) != 0)
625       return -1;
626   }
627
628   if (get_bits1 (bitbuf) == 1) {
629     skip_bits1 (bitbuf);
630     skip_bits (bitbuf, 4);
631     skip_bits1 (bitbuf);
632     skip_bits (bitbuf, 2);
633
634     while (get_bits1 (bitbuf) == 1) {
635       skip_bits (bitbuf, 8);
636     }
637   }
638
639   return 0;
640 }
641
642 static int svq1_decode_frame(AVCodecContext *avctx,
643                              void *data, int *data_size,
644                              const uint8_t *buf, int buf_size)
645 {
646   MpegEncContext *s=avctx->priv_data;
647   uint8_t        *current, *previous;
648   int             result, i, x, y, width, height;
649   AVFrame *pict = data;
650
651   /* initialize bit buffer */
652   init_get_bits(&s->gb,buf,buf_size*8);
653
654   /* decode frame header */
655   s->f_code = get_bits (&s->gb, 22);
656
657   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
658     return -1;
659
660   /* swap some header bytes (why?) */
661   if (s->f_code != 0x20) {
662     uint32_t *src = (uint32_t *) (buf + 4);
663
664     for (i=0; i < 4; i++) {
665       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
666     }
667   }
668
669   result = svq1_decode_frame_header (&s->gb, s);
670
671   if (result != 0)
672   {
673 #ifdef DEBUG_SVQ1
674     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
675 #endif
676     return result;
677   }
678
679   //FIXME this avoids some confusion for "B frames" without 2 references
680   //this should be removed after libavcodec can handle more flexible picture types & ordering
681   if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
682
683   if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
684   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
685      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
686      || avctx->skip_frame >= AVDISCARD_ALL)
687       return buf_size;
688
689   if(MPV_frame_start(s, avctx) < 0)
690       return -1;
691
692   /* decode y, u and v components */
693   for (i=0; i < 3; i++) {
694     int linesize;
695     if (i == 0) {
696       width  = (s->width+15)&~15;
697       height = (s->height+15)&~15;
698       linesize= s->linesize;
699     } else {
700       if(s->flags&CODEC_FLAG_GRAY) break;
701       width  = (s->width/4+15)&~15;
702       height = (s->height/4+15)&~15;
703       linesize= s->uvlinesize;
704     }
705
706     current  = s->current_picture.data[i];
707
708     if(s->pict_type==FF_B_TYPE){
709         previous = s->next_picture.data[i];
710     }else{
711         previous = s->last_picture.data[i];
712     }
713
714     if (s->pict_type == FF_I_TYPE) {
715       /* keyframe */
716       for (y=0; y < height; y+=16) {
717         for (x=0; x < width; x+=16) {
718           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
719           if (result != 0)
720           {
721 //#ifdef DEBUG_SVQ1
722             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
723 //#endif
724             return result;
725           }
726         }
727         current += 16*linesize;
728       }
729     } else {
730       svq1_pmv_t pmv[width/8+3];
731       /* delta frame */
732       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
733
734       for (y=0; y < height; y+=16) {
735         for (x=0; x < width; x+=16) {
736           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
737                                             linesize, pmv, x, y);
738           if (result != 0)
739           {
740 #ifdef DEBUG_SVQ1
741     av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
742 #endif
743             return result;
744           }
745         }
746
747         pmv[0].x =
748         pmv[0].y = 0;
749
750         current += 16*linesize;
751       }
752     }
753   }
754
755   *pict = *(AVFrame*)&s->current_picture;
756
757
758   MPV_frame_end(s);
759
760   *data_size=sizeof(AVFrame);
761   return buf_size;
762 }
763
764 static av_cold int svq1_decode_init(AVCodecContext *avctx)
765 {
766     MpegEncContext *s = avctx->priv_data;
767     int i;
768
769     MPV_decode_defaults(s);
770
771     s->avctx = avctx;
772     s->width = (avctx->width+3)&~3;
773     s->height = (avctx->height+3)&~3;
774     s->codec_id= avctx->codec->id;
775     avctx->pix_fmt = PIX_FMT_YUV410P;
776     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
777     s->flags= avctx->flags;
778     if (MPV_common_init(s) < 0) return -1;
779
780     init_vlc(&svq1_block_type, 2, 4,
781         &ff_svq1_block_type_vlc[0][1], 2, 1,
782         &ff_svq1_block_type_vlc[0][0], 2, 1, 1);
783
784     init_vlc(&svq1_motion_component, 7, 33,
785         &mvtab[0][1], 2, 1,
786         &mvtab[0][0], 2, 1, 1);
787
788     for (i = 0; i < 6; i++) {
789         init_vlc(&svq1_intra_multistage[i], 3, 8,
790             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
791             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
792         init_vlc(&svq1_inter_multistage[i], 3, 8,
793             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
794             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
795     }
796
797     init_vlc(&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, 1);
800
801     init_vlc(&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, 1);
804
805     return 0;
806 }
807
808 static av_cold int svq1_decode_end(AVCodecContext *avctx)
809 {
810     MpegEncContext *s = avctx->priv_data;
811
812     MPV_common_end(s);
813     return 0;
814 }
815
816
817 AVCodec svq1_decoder = {
818     "svq1",
819     CODEC_TYPE_VIDEO,
820     CODEC_ID_SVQ1,
821     sizeof(MpegEncContext),
822     svq1_decode_init,
823     NULL,
824     svq1_decode_end,
825     svq1_decode_frame,
826     CODEC_CAP_DR1,
827     .flush= ff_mpeg_flush,
828     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
829     .long_name= "Sorenson Vector Quantizer 1",
830 };