fate: enable new sbr tests after our rsync server has them now.
[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
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 #include "avcodec.h"
37 #include "dsputil.h"
38 #include "mpegvideo.h"
39 #include "mathops.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;
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 >> 1) + 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 << 16) + mean;
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       av_dlog(NULL,
241               "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
242               stages, level);
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       av_dlog(NULL,
291               "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
292               stages, level);
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 *mv, svq1_pmv **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 *motion, int x, int y) {
346   uint8_t    *src;
347   uint8_t    *dst;
348   svq1_pmv    mv;
349   svq1_pmv   *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   src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
381   dst = current;
382
383   s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
384
385   return 0;
386 }
387
388 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
389                                   uint8_t *current, uint8_t *previous, int pitch,
390                                   svq1_pmv *motion,int x, int y) {
391   uint8_t    *src;
392   uint8_t    *dst;
393   svq1_pmv    mv;
394   svq1_pmv   *pmv[4];
395   int         i, result;
396
397   /* predict and decode motion vector (0) */
398   pmv[0] = &motion[0];
399   if (y == 0) {
400     pmv[1] =
401     pmv[2] = pmv[0];
402   }
403   else {
404     pmv[1] = &motion[(x / 8) + 2];
405     pmv[2] = &motion[(x / 8) + 4];
406   }
407
408   result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
409
410   if (result != 0)
411     return result;
412
413   /* predict and decode motion vector (1) */
414   pmv[0] = &mv;
415   if (y == 0) {
416     pmv[1] =
417     pmv[2] = pmv[0];
418   }
419   else {
420     pmv[1] = &motion[(x / 8) + 3];
421   }
422   result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
423
424   if (result != 0)
425     return result;
426
427   /* predict and decode motion vector (2) */
428   pmv[1] = &motion[0];
429   pmv[2] = &motion[(x / 8) + 1];
430
431   result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
432
433   if (result != 0)
434     return result;
435
436   /* predict and decode motion vector (3) */
437   pmv[2] = &motion[(x / 8) + 2];
438   pmv[3] = &motion[(x / 8) + 3];
439
440   result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
441
442   if (result != 0)
443     return result;
444
445   /* form predictions */
446   for (i=0; i < 4; i++) {
447     int mvx= pmv[i]->x + (i&1)*16;
448     int mvy= pmv[i]->y + (i>>1)*16;
449
450     ///XXX /FIXME clipping or padding?
451     if(y + (mvy >> 1)<0)
452        mvy= 0;
453     if(x + (mvx >> 1)<0)
454        mvx= 0;
455
456     src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
457     dst = current;
458
459     s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
460
461     /* select next block */
462     if (i & 1) {
463       current  += 8*(pitch - 1);
464     } else {
465       current  += 8;
466     }
467   }
468
469   return 0;
470 }
471
472 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
473                         uint8_t *current, uint8_t *previous, int pitch,
474                         svq1_pmv *motion, int x, int y) {
475   uint32_t block_type;
476   int      result = 0;
477
478   /* get block type */
479   block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
480
481   /* reset motion vectors */
482   if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
483     motion[0].x                 =
484     motion[0].y                 =
485     motion[(x / 8) + 2].x =
486     motion[(x / 8) + 2].y =
487     motion[(x / 8) + 3].x =
488     motion[(x / 8) + 3].y = 0;
489   }
490
491   switch (block_type) {
492   case SVQ1_BLOCK_SKIP:
493     svq1_skip_block (current, previous, pitch, x, y);
494     break;
495
496   case SVQ1_BLOCK_INTER:
497     result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
498
499     if (result != 0)
500     {
501       av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
502       break;
503     }
504     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
505     break;
506
507   case SVQ1_BLOCK_INTER_4V:
508     result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
509
510     if (result != 0)
511     {
512       av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
513       break;
514     }
515     result = svq1_decode_block_non_intra (bitbuf, current, pitch);
516     break;
517
518   case SVQ1_BLOCK_INTRA:
519     result = svq1_decode_block_intra (bitbuf, current, pitch);
520     break;
521   }
522
523   return result;
524 }
525
526 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
527   int i;
528
529   for (i=0; i < length; i++) {
530     value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
531   }
532
533   return value;
534 }
535
536 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
537   uint8_t seed;
538   int     i;
539
540   out[0] = get_bits (bitbuf, 8);
541
542   seed = string_table[out[0]];
543
544   for (i=1; i <= out[0]; i++) {
545     out[i] = get_bits (bitbuf, 8) ^ seed;
546     seed   = string_table[out[i] ^ seed];
547   }
548 }
549
550 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
551   int frame_size_code;
552
553   skip_bits(bitbuf, 8); /* temporal_reference */
554
555   /* frame type */
556   s->pict_type= get_bits (bitbuf, 2)+1;
557   if(s->pict_type==4)
558       return -1;
559
560   if (s->pict_type == AV_PICTURE_TYPE_I) {
561
562     /* unknown fields */
563     if (s->f_code == 0x50 || s->f_code == 0x60) {
564       int csum = get_bits (bitbuf, 16);
565
566       csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
567
568 //      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
569 //              (csum == 0) ? "correct" : "incorrect", csum);
570     }
571
572     if ((s->f_code ^ 0x10) >= 0x50) {
573       uint8_t msg[256];
574
575       svq1_parse_string (bitbuf, msg);
576
577       av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
578     }
579
580     skip_bits (bitbuf, 2);
581     skip_bits (bitbuf, 2);
582     skip_bits1 (bitbuf);
583
584     /* load frame size */
585     frame_size_code = get_bits (bitbuf, 3);
586
587     if (frame_size_code == 7) {
588       /* load width, height (12 bits each) */
589       s->width = get_bits (bitbuf, 12);
590       s->height = get_bits (bitbuf, 12);
591
592       if (!s->width || !s->height)
593         return -1;
594     } else {
595       /* get width, height from table */
596       s->width = ff_svq1_frame_size_table[frame_size_code].width;
597       s->height = ff_svq1_frame_size_table[frame_size_code].height;
598     }
599   }
600
601   /* unknown fields */
602   if (get_bits1 (bitbuf) == 1) {
603     skip_bits1 (bitbuf);       /* use packet checksum if (1) */
604     skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
605
606     if (get_bits (bitbuf, 2) != 0)
607       return -1;
608   }
609
610   if (get_bits1 (bitbuf) == 1) {
611     skip_bits1 (bitbuf);
612     skip_bits (bitbuf, 4);
613     skip_bits1 (bitbuf);
614     skip_bits (bitbuf, 2);
615
616     while (get_bits1 (bitbuf) == 1) {
617       skip_bits (bitbuf, 8);
618     }
619   }
620
621   return 0;
622 }
623
624 static int svq1_decode_frame(AVCodecContext *avctx,
625                              void *data, int *data_size,
626                              AVPacket *avpkt)
627 {
628   const uint8_t *buf = avpkt->data;
629   int buf_size = avpkt->size;
630   MpegEncContext *s=avctx->priv_data;
631   uint8_t        *current, *previous;
632   int             result, i, x, y, width, height;
633   AVFrame *pict = data;
634   svq1_pmv *pmv;
635
636   /* initialize bit buffer */
637   init_get_bits(&s->gb,buf,buf_size*8);
638
639   /* decode frame header */
640   s->f_code = get_bits (&s->gb, 22);
641
642   if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
643     return -1;
644
645   /* swap some header bytes (why?) */
646   if (s->f_code != 0x20) {
647     uint32_t *src = (uint32_t *) (buf + 4);
648
649     for (i=0; i < 4; i++) {
650       src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
651     }
652   }
653
654   result = svq1_decode_frame_header (&s->gb, s);
655
656   if (result != 0)
657   {
658     av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
659     return result;
660   }
661   avcodec_set_dimensions(avctx, s->width, s->height);
662
663   //FIXME this avoids some confusion for "B frames" without 2 references
664   //this should be removed after libavcodec can handle more flexible picture types & ordering
665   if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
666
667   if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
668      ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
669      || avctx->skip_frame >= AVDISCARD_ALL)
670       return buf_size;
671
672   if(MPV_frame_start(s, avctx) < 0)
673       return -1;
674
675   pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
676   if (!pmv)
677       return -1;
678
679   /* decode y, u and v components */
680   for (i=0; i < 3; i++) {
681     int linesize;
682     if (i == 0) {
683       width  = FFALIGN(s->width, 16);
684       height = FFALIGN(s->height, 16);
685       linesize= s->linesize;
686     } else {
687       if(s->flags&CODEC_FLAG_GRAY) break;
688       width  = FFALIGN(s->width/4, 16);
689       height = FFALIGN(s->height/4, 16);
690       linesize= s->uvlinesize;
691     }
692
693     current = s->current_picture.f.data[i];
694
695     if(s->pict_type==AV_PICTURE_TYPE_B){
696         previous = s->next_picture.f.data[i];
697     }else{
698         previous = s->last_picture.f.data[i];
699     }
700
701     if (s->pict_type == AV_PICTURE_TYPE_I) {
702       /* keyframe */
703       for (y=0; y < height; y+=16) {
704         for (x=0; x < width; x+=16) {
705           result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
706           if (result != 0)
707           {
708             av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
709             goto err;
710           }
711         }
712         current += 16*linesize;
713       }
714     } else {
715       /* delta frame */
716       memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
717
718       for (y=0; y < height; y+=16) {
719         for (x=0; x < width; x+=16) {
720           result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
721                                             linesize, pmv, x, y);
722           if (result != 0)
723           {
724             av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
725             goto err;
726           }
727         }
728
729         pmv[0].x =
730         pmv[0].y = 0;
731
732         current += 16*linesize;
733       }
734     }
735   }
736
737   *pict = *(AVFrame*)&s->current_picture;
738
739
740   MPV_frame_end(s);
741
742   *data_size=sizeof(AVFrame);
743   result = buf_size;
744 err:
745   av_free(pmv);
746   return result;
747 }
748
749 static av_cold int svq1_decode_init(AVCodecContext *avctx)
750 {
751     MpegEncContext *s = avctx->priv_data;
752     int i;
753     int offset = 0;
754
755     MPV_decode_defaults(s);
756
757     s->avctx = avctx;
758     s->width = (avctx->width+3)&~3;
759     s->height = (avctx->height+3)&~3;
760     s->codec_id= avctx->codec->id;
761     avctx->pix_fmt = PIX_FMT_YUV410P;
762     avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
763     s->flags= avctx->flags;
764     if (MPV_common_init(s) < 0) return -1;
765
766     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
767         &ff_svq1_block_type_vlc[0][1], 2, 1,
768         &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
769
770     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
771         &mvtab[0][1], 2, 1,
772         &mvtab[0][0], 2, 1, 176);
773
774     for (i = 0; i < 6; i++) {
775         static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
776         static VLC_TYPE table[168][2];
777         svq1_intra_multistage[i].table = &table[offset];
778         svq1_intra_multistage[i].table_allocated = sizes[0][i];
779         offset += sizes[0][i];
780         init_vlc(&svq1_intra_multistage[i], 3, 8,
781             &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
782             &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
783         svq1_inter_multistage[i].table = &table[offset];
784         svq1_inter_multistage[i].table_allocated = sizes[1][i];
785         offset += sizes[1][i];
786         init_vlc(&svq1_inter_multistage[i], 3, 8,
787             &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
788             &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
789     }
790
791     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
792         &ff_svq1_intra_mean_vlc[0][1], 4, 2,
793         &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
794
795     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
796         &ff_svq1_inter_mean_vlc[0][1], 4, 2,
797         &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
798
799     return 0;
800 }
801
802 static av_cold int svq1_decode_end(AVCodecContext *avctx)
803 {
804     MpegEncContext *s = avctx->priv_data;
805
806     MPV_common_end(s);
807     return 0;
808 }
809
810
811 AVCodec ff_svq1_decoder = {
812     .name           = "svq1",
813     .type           = AVMEDIA_TYPE_VIDEO,
814     .id             = CODEC_ID_SVQ1,
815     .priv_data_size = sizeof(MpegEncContext),
816     .init           = svq1_decode_init,
817     .close          = svq1_decode_end,
818     .decode         = svq1_decode_frame,
819     .capabilities   = CODEC_CAP_DR1,
820     .flush= ff_mpeg_flush,
821     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
822     .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
823 };