AVCodec.flush()
[ffmpeg.git] / libavcodec / svq1.c
1 /*
2  * 
3  * Copyright (C) 2002 the xine project
4  * Copyright (C) 2002 the ffmpeg project
5  * 
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  * Ported to mplayer by Arpi <arpi@thot.banki.hu>
21  * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
22  *
23  */
24
25 /**
26  * @file svq1.c
27  * Sorenson Vector Quantizer #1 (SVQ1) video decoder.
28  */
29
30
31 //#define DEBUG_SVQ1
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include "common.h"
38 #include "avcodec.h"
39 #include "dsputil.h"
40 #include "mpegvideo.h"
41 #include "bswap.h"
42
43 static VLC svq1_block_type;
44 static VLC svq1_motion_component;
45 static VLC svq1_intra_multistage[6];
46 static VLC svq1_inter_multistage[6];
47 static VLC svq1_intra_mean;
48 static VLC svq1_inter_mean;
49
50 #define MEDIAN(a,b,c)   (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
51
52 #define SVQ1_BLOCK_SKIP         0
53 #define SVQ1_BLOCK_INTER        1
54 #define SVQ1_BLOCK_INTER_4V     2
55 #define SVQ1_BLOCK_INTRA        3
56
57 /* motion vector (prediction) */
58 typedef struct svq1_pmv_s {
59   int            x;
60   int            y;
61 } svq1_pmv_t;
62
63 #include "svq1_cb.h"
64 #include "svq1_vlc.h"
65
66 static const uint16_t checksum_table[256] = {
67   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
68   0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
69   0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
70   0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
71   0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
72   0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
73   0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
74   0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
75   0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
76   0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
77   0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
78   0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
79   0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
80   0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
81   0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
82   0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
83   0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
84   0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
85   0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
86   0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
87   0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
88   0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
89   0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
90   0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
91   0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
92   0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
93   0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
94   0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
95   0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
96   0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
97   0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
98   0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
99 };
100
101 static const uint8_t string_table[256] = {
102   0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
103   0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
104   0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
105   0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
106   0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
107   0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
108   0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
109   0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
110   0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
111   0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
112   0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
113   0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
114   0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
115   0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
116   0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
117   0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
118   0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
119   0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
120   0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
121   0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
122   0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
123   0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
124   0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
125   0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
126   0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
127   0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
128   0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
129   0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
130   0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
131   0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
132   0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
133   0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
134 };
135
136 #define SVQ1_PROCESS_VECTOR()\
137     for (; level > 0; i++) {\
138       /* process next depth */\
139       if (i == m) {\
140         m = n;\
141         if (--level == 0)\
142           break;\
143       }\
144       /* divide block if next bit set */\
145       if (get_bits (bitbuf, 1) == 0)\
146         break;\
147       /* add child nodes */\
148       list[n++] = list[i];\
149       list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
150     }
151
152 #define SVQ1_ADD_CODEBOOK()\
153           /* add codebook entries to vector */\
154           for (j=0; j < stages; j++) {\
155             n3  = codebook[entries[j]] ^ 0x80808080;\
156             n1 += ((n3 & 0xFF00FF00) >> 8);\
157             n2 +=  (n3 & 0x00FF00FF);\
158           }\
159 \
160           /* clip to [0..255] */\
161           if (n1 & 0xFF00FF00) {\
162             n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
163             n1 += 0x7F007F00;\
164             n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165             n1 &= (n3 & 0x00FF00FF);\
166           }\
167 \
168           if (n2 & 0xFF00FF00) {\
169             n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
170             n2 += 0x7F007F00;\
171             n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
172             n2 &= (n3 & 0x00FF00FF);\
173           }
174
175 #define SVQ1_DO_CODEBOOK_INTRA()\
176       for (y=0; y < height; y++) {\
177         for (x=0; x < (width / 4); x++, codebook++) {\
178         n1 = n4;\
179         n2 = n4;\
180         SVQ1_ADD_CODEBOOK()\
181         /* store result */\
182         dst[x] = (n1 << 8) | n2;\
183         }\
184         dst += (pitch / 4);\
185       }
186
187 #define SVQ1_DO_CODEBOOK_NONINTRA()\
188       for (y=0; y < height; y++) {\
189         for (x=0; x < (width / 4); x++, codebook++) {\
190         n3 = dst[x];\
191         /* add mean value to vector */\
192         n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
193         n2 =  (n3 & 0x00FF00FF)   + n4;\
194         SVQ1_ADD_CODEBOOK()\
195         /* store result */\
196         dst[x] = (n1 << 8) | n2;\
197         }\
198         dst += (pitch / 4);\
199       }
200
201 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
202       codebook = (const uint32_t *) cbook[level];\
203       bit_cache = get_bits (bitbuf, 4*stages);\
204       /* calculate codebook entries for this vector */\
205       for (j=0; j < stages; j++) {\
206         entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
207       }\
208       mean -= (stages * 128);\
209       n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
210
211 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
212   uint32_t    bit_cache;
213   uint8_t    *list[63];
214   uint32_t   *dst;
215   const uint32_t *codebook;
216   int         entries[6];
217   int         i, j, m, n;
218   int         mean, stages;
219   unsigned    x, y, width, height, level;
220   uint32_t    n1, n2, n3, n4;
221
222   /* initialize list for breadth first processing of vectors */
223   list[0] = pixels;
224
225   /* recursively process vector */
226   for (i=0, m=1, n=1, level=5; i < n; i++) {
227     SVQ1_PROCESS_VECTOR();
228
229     /* destination address and vector size */
230     dst = (uint32_t *) list[i];
231     width = 1 << ((4 + level) /2);
232     height = 1 << ((3 + level) /2);
233
234     /* get number of stages (-1 skips vector, 0 for mean only) */
235     stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
236
237     if (stages == -1) {
238         for (y=0; y < height; y++) {
239           memset (&dst[y*(pitch / 4)], 0, width);
240         }
241       continue;         /* skip vector */
242     }
243
244     if ((stages > 0) && (level >= 4)) {
245 #ifdef DEBUG_SVQ1
246     printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
247 #endif
248       return -1;        /* invalid vector */
249     }
250
251     mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
252
253     if (stages == 0) {
254       for (y=0; y < height; y++) {
255         memset (&dst[y*(pitch / 4)], mean, width);
256       }
257     } else {
258       SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
259       SVQ1_DO_CODEBOOK_INTRA()
260     }
261   }
262
263   return 0;
264 }
265
266 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
267   uint32_t    bit_cache;
268   uint8_t    *list[63];
269   uint32_t   *dst;
270   const uint32_t *codebook;
271   int         entries[6];
272   int         i, j, m, n;
273   int         mean, stages;
274   int         x, y, width, height, level;
275   uint32_t    n1, n2, n3, n4;
276
277   /* initialize list for breadth first processing of vectors */
278   list[0] = pixels;
279
280   /* recursively process vector */
281   for (i=0, m=1, n=1, level=5; i < n; i++) {
282     SVQ1_PROCESS_VECTOR();
283
284     /* destination address and vector size */
285     dst = (uint32_t *) list[i];
286     width = 1 << ((4 + level) /2);
287     height = 1 << ((3 + level) /2);
288
289     /* get number of stages (-1 skips vector, 0 for mean only) */
290     stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
291
292     if (stages == -1) continue; /* skip vector */
293
294     if ((stages > 0) && (level >= 4)) {
295 #ifdef DEBUG_SVQ1
296     printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
297 #endif
298       return -1;        /* invalid vector */
299     }
300
301     mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
302
303     SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
304     SVQ1_DO_CODEBOOK_NONINTRA()
305   }
306   return 0;
307 }
308
309 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
310   int         diff;
311   int         i;
312
313   for (i=0; i < 2; i++) {
314
315     /* get motion code */
316     diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
317
318     /* add median of motion vector predictors and clip result */
319     if (i == 1)
320       mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
321     else
322       mv->x = ((diff + MEDIAN(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       printf("%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 cliping 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       printf("%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     printf("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     printf("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 /* standard video sizes */
544 static struct { int width; int height; } svq1_frame_size_table[8] = {
545   { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
546   { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
547 };
548
549 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
550   int i;
551
552   for (i=0; i < length; i++) {
553     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
554   }
555
556   return value;
557 }
558
559 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
560                                          int width, int height, int value) {
561   int x, y;
562
563   for (y=0; y < height; y++) {
564     for (x=0; x < width; x++) {
565       value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
566     }
567
568     pixels += pitch;
569   }
570
571   return value;
572 }
573
574 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
575   uint8_t seed;
576   int     i;
577
578   out[0] = get_bits (bitbuf, 8);
579
580   seed = string_table[out[0]];
581
582   for (i=1; i < out[0]; i++) {
583     out[i] = get_bits (bitbuf, 8) ^ seed;
584     seed   = string_table[out[i] ^ seed];
585   }
586 }
587
588 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
589   int frame_size_code;
590   int temporal_reference;
591
592   temporal_reference = get_bits (bitbuf, 8);
593
594   /* frame type */
595   s->pict_type= get_bits (bitbuf, 2)+1;
596   if(s->pict_type==4) 
597       return -1;
598       
599   if (s->pict_type == I_TYPE) {
600
601     /* unknown fields */
602     if (s->f_code == 0x50 || s->f_code == 0x60) {
603       int csum = get_bits (bitbuf, 16);
604
605       csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
606
607 //      printf ("%s checksum (%02x) for packet data\n",
608 //              (csum == 0) ? "correct" : "incorrect", csum);
609     }
610
611     if ((s->f_code ^ 0x10) >= 0x50) {
612       char msg[256];
613
614       svq1_parse_string (bitbuf, (char *) msg);
615
616       printf ("embedded message: \"%s\"\n", (char *) msg);
617     }
618
619     get_bits (bitbuf, 2);
620     get_bits (bitbuf, 2);
621     get_bits (bitbuf, 1);
622
623     /* load frame size */
624     frame_size_code = get_bits (bitbuf, 3);
625
626     if (frame_size_code == 7) {
627       /* load width, height (12 bits each) */
628       s->width = get_bits (bitbuf, 12);
629       s->height = get_bits (bitbuf, 12);
630
631       if (!s->width || !s->height)
632         return -1;
633     } else {
634       /* get width, height from table */
635       s->width = svq1_frame_size_table[frame_size_code].width;
636       s->height = svq1_frame_size_table[frame_size_code].height;
637     }
638   }
639
640   /* unknown fields */
641   if (get_bits (bitbuf, 1) == 1) {
642     get_bits (bitbuf, 1);       /* use packet checksum if (1) */
643     get_bits (bitbuf, 1);       /* component checksums after image data if (1) */
644
645     if (get_bits (bitbuf, 2) != 0)
646       return -1;
647   }
648
649   if (get_bits (bitbuf, 1) == 1) {
650     get_bits (bitbuf, 1);
651     get_bits (bitbuf, 4);
652     get_bits (bitbuf, 1);
653     get_bits (bitbuf, 2);
654
655     while (get_bits (bitbuf, 1) == 1) {
656       get_bits (bitbuf, 8);
657     }
658   }
659   
660   return 0;
661 }
662
663 static int svq1_decode_frame(AVCodecContext *avctx, 
664                              void *data, int *data_size,
665                              uint8_t *buf, int buf_size)
666 {
667   MpegEncContext *s=avctx->priv_data;
668   uint8_t      *current, *previous;
669   int           result, i, x, y, width, height;
670   AVFrame *pict = data; 
671
672   /* initialize bit buffer */
673   init_get_bits(&s->gb,buf,buf_size*8);
674
675   /* decode frame header */
676   s->f_code = get_bits (&s->gb, 22);
677
678   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
679     return -1;
680
681   /* swap some header bytes (why?) */
682   if (s->f_code != 0x20) {
683     uint32_t *src = (uint32_t *) (buf + 4);
684
685     for (i=0; i < 4; i++) {
686       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
687     }
688   }
689
690   result = svq1_decode_frame_header (&s->gb, s);
691
692   if (result != 0)
693   {
694 #ifdef DEBUG_SVQ1
695     printf("Error in svq1_decode_frame_header %i\n",result);
696 #endif
697     return result;
698   }
699   
700   //FIXME this avoids some confusion for "B frames" without 2 references
701   //this should be removed after libavcodec can handle more flaxible picture types & ordering
702   if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
703   
704   if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
705
706   if(MPV_frame_start(s, avctx) < 0)
707       return -1;
708
709   /* decode y, u and v components */
710   for (i=0; i < 3; i++) {
711     int linesize;
712     if (i == 0) {
713       width  = (s->width+15)&~15;
714       height = (s->height+15)&~15;
715       linesize= s->linesize;
716     } else {
717       if(s->flags&CODEC_FLAG_GRAY) break;
718       width  = (s->width/4+15)&~15;
719       height = (s->height/4+15)&~15;
720       linesize= s->uvlinesize;
721     }
722
723     current  = s->current_picture.data[i];
724
725     if(s->pict_type==B_TYPE){
726         previous = s->next_picture.data[i];
727     }else{
728         previous = s->last_picture.data[i];
729     }
730
731     if (s->pict_type == I_TYPE) {
732       /* keyframe */
733       for (y=0; y < height; y+=16) {
734         for (x=0; x < width; x+=16) {
735           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
736           if (result != 0)
737           {
738 #ifdef DEBUG_SVQ1
739             printf("Error in svq1_decode_block %i (keyframe)\n",result);
740 #endif
741             return result;
742           }
743         }
744         current += 16*linesize;
745       }
746     } else {
747       svq1_pmv_t pmv[width/8+3];
748       /* delta frame */
749       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
750
751       for (y=0; y < height; y+=16) {
752         for (x=0; x < width; x+=16) {
753           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
754                                             linesize, pmv, x, y);
755           if (result != 0)
756           {
757 #ifdef DEBUG_SVQ1
758     printf("Error in svq1_decode_delta_block %i\n",result);
759 #endif
760             return result;
761           }
762         }
763
764         pmv[0].x =
765         pmv[0].y = 0;
766
767         current += 16*linesize;
768       }
769     }
770   }
771   
772   *pict = *(AVFrame*)&s->current_picture;
773
774
775   MPV_frame_end(s);
776   
777   *data_size=sizeof(AVFrame);
778   return buf_size;
779 }
780
781 static int svq1_decode_init(AVCodecContext *avctx)
782 {
783     MpegEncContext *s = avctx->priv_data;
784     int i;
785
786     s->avctx = avctx;
787     s->width = (avctx->width+3)&~3;
788     s->height = (avctx->height+3)&~3;
789     s->codec_id= avctx->codec->id;
790     avctx->pix_fmt = PIX_FMT_YUV410P;
791     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
792     s->flags= avctx->flags;
793     if (MPV_common_init(s) < 0) return -1;
794
795     init_vlc(&svq1_block_type, 2, 4,
796         &svq1_block_type_vlc[0][1], 2, 1,
797         &svq1_block_type_vlc[0][0], 2, 1);
798
799     init_vlc(&svq1_motion_component, 7, 65,
800         &svq1_motion_component_vlc[0][1], 4, 2,
801         &svq1_motion_component_vlc[0][0], 4, 2);
802
803     for (i = 0; i < 6; i++) {
804         init_vlc(&svq1_intra_multistage[i], 3, 8,
805             &svq1_intra_multistage_vlc[i][0][1], 2, 1,
806             &svq1_intra_multistage_vlc[i][0][0], 2, 1);
807         init_vlc(&svq1_inter_multistage[i], 3, 8,
808             &svq1_inter_multistage_vlc[i][0][1], 2, 1,
809             &svq1_inter_multistage_vlc[i][0][0], 2, 1);
810     }
811
812     init_vlc(&svq1_intra_mean, 8, 256,
813         &svq1_intra_mean_vlc[0][1], 4, 2,
814         &svq1_intra_mean_vlc[0][0], 4, 2);
815
816     init_vlc(&svq1_inter_mean, 9, 512,
817         &svq1_inter_mean_vlc[0][1], 4, 2,
818         &svq1_inter_mean_vlc[0][0], 4, 2);
819
820     return 0;
821 }
822
823 static int svq1_decode_end(AVCodecContext *avctx)
824 {
825     MpegEncContext *s = avctx->priv_data;
826
827     MPV_common_end(s);
828     return 0;
829 }
830
831 AVCodec svq1_decoder = {
832     "svq1",
833     CODEC_TYPE_VIDEO,
834     CODEC_ID_SVQ1,
835     sizeof(MpegEncContext),
836     svq1_decode_init,
837     NULL,
838     svq1_decode_end,
839     svq1_decode_frame,
840     CODEC_CAP_DR1,
841     .flush= ff_mpeg_flush,
842 };