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