1/*
2 * SVQ1 decoder
3 * ported to MPlayer by Arpi <arpi@thot.banki.hu>
4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
5 *
6 * Copyright (C) 2002 the xine project
7 * Copyright (C) 2002 the ffmpeg project
8 *
9 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
10 *
11 * This file is part of Libav.
12 *
13 * Libav is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * Libav is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with Libav; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 */
27
28/**
29 * @file
30 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
31 * For more information of the SVQ1 algorithm, visit:
32 *   http://www.pcisys.net/~melanson/codecs/
33 */
34
35
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
46extern const uint8_t ff_mvtab[33][2];
47
48static VLC svq1_block_type;
49static VLC svq1_motion_component;
50static VLC svq1_intra_multistage[6];
51static VLC svq1_inter_multistage[6];
52static VLC svq1_intra_mean;
53static VLC svq1_inter_mean;
54
55/* motion vector (prediction) */
56typedef struct svq1_pmv_s {
57  int           x;
58  int           y;
59} svq1_pmv;
60
61static 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
96static 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      if (stages > 0)\
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      av_dlog(NULL,
242              "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
243              stages, level);
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      av_dlog(NULL,
292              "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
293              stages, level);
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 = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
322    else
323      mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
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  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
382  dst = current;
383
384  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
385
386  return 0;
387}
388
389static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
390                                  uint8_t *current, uint8_t *previous, int pitch,
391                                  svq1_pmv *motion,int x, int y) {
392  uint8_t    *src;
393  uint8_t    *dst;
394  svq1_pmv    mv;
395  svq1_pmv   *pmv[4];
396  int         i, result;
397
398  /* predict and decode motion vector (0) */
399  pmv[0] = &motion[0];
400  if (y == 0) {
401    pmv[1] =
402    pmv[2] = pmv[0];
403  }
404  else {
405    pmv[1] = &motion[(x / 8) + 2];
406    pmv[2] = &motion[(x / 8) + 4];
407  }
408
409  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
410
411  if (result != 0)
412    return result;
413
414  /* predict and decode motion vector (1) */
415  pmv[0] = &mv;
416  if (y == 0) {
417    pmv[1] =
418    pmv[2] = pmv[0];
419  }
420  else {
421    pmv[1] = &motion[(x / 8) + 3];
422  }
423  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
424
425  if (result != 0)
426    return result;
427
428  /* predict and decode motion vector (2) */
429  pmv[1] = &motion[0];
430  pmv[2] = &motion[(x / 8) + 1];
431
432  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
433
434  if (result != 0)
435    return result;
436
437  /* predict and decode motion vector (3) */
438  pmv[2] = &motion[(x / 8) + 2];
439  pmv[3] = &motion[(x / 8) + 3];
440
441  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
442
443  if (result != 0)
444    return result;
445
446  /* form predictions */
447  for (i=0; i < 4; i++) {
448    int mvx= pmv[i]->x + (i&1)*16;
449    int mvy= pmv[i]->y + (i>>1)*16;
450
451    ///XXX /FIXME clipping or padding?
452    if(y + (mvy >> 1)<0)
453       mvy= 0;
454    if(x + (mvx >> 1)<0)
455       mvx= 0;
456
457    src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
458    dst = current;
459
460    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
461
462    /* select next block */
463    if (i & 1) {
464      current  += 8*(pitch - 1);
465    } else {
466      current  += 8;
467    }
468  }
469
470  return 0;
471}
472
473static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
474                        uint8_t *current, uint8_t *previous, int pitch,
475                        svq1_pmv *motion, int x, int y) {
476  uint32_t block_type;
477  int      result = 0;
478
479  /* get block type */
480  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
481
482  /* reset motion vectors */
483  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
484    motion[0].x                 =
485    motion[0].y                 =
486    motion[(x / 8) + 2].x =
487    motion[(x / 8) + 2].y =
488    motion[(x / 8) + 3].x =
489    motion[(x / 8) + 3].y = 0;
490  }
491
492  switch (block_type) {
493  case SVQ1_BLOCK_SKIP:
494    svq1_skip_block (current, previous, pitch, x, y);
495    break;
496
497  case SVQ1_BLOCK_INTER:
498    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
499
500    if (result != 0)
501    {
502      av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
503      break;
504    }
505    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
506    break;
507
508  case SVQ1_BLOCK_INTER_4V:
509    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
510
511    if (result != 0)
512    {
513      av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
514      break;
515    }
516    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
517    break;
518
519  case SVQ1_BLOCK_INTRA:
520    result = svq1_decode_block_intra (bitbuf, current, pitch);
521    break;
522  }
523
524  return result;
525}
526
527uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
528  int i;
529
530  for (i=0; i < length; i++) {
531    value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
532  }
533
534  return value;
535}
536
537static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
538  uint8_t seed;
539  int     i;
540
541  out[0] = get_bits (bitbuf, 8);
542
543  seed = string_table[out[0]];
544
545  for (i=1; i <= out[0]; i++) {
546    out[i] = get_bits (bitbuf, 8) ^ seed;
547    seed   = string_table[out[i] ^ seed];
548  }
549}
550
551static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
552  int frame_size_code;
553
554  skip_bits(bitbuf, 8); /* temporal_reference */
555
556  /* frame type */
557  s->pict_type= get_bits (bitbuf, 2)+1;
558  if(s->pict_type==4)
559      return -1;
560
561  if (s->pict_type == AV_PICTURE_TYPE_I) {
562
563    /* unknown fields */
564    if (s->f_code == 0x50 || s->f_code == 0x60) {
565      int csum = get_bits (bitbuf, 16);
566
567      csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
568
569//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
570//              (csum == 0) ? "correct" : "incorrect", csum);
571    }
572
573    if ((s->f_code ^ 0x10) >= 0x50) {
574      uint8_t msg[256];
575
576      svq1_parse_string (bitbuf, msg);
577
578      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
579    }
580
581    skip_bits (bitbuf, 2);
582    skip_bits (bitbuf, 2);
583    skip_bits1 (bitbuf);
584
585    /* load frame size */
586    frame_size_code = get_bits (bitbuf, 3);
587
588    if (frame_size_code == 7) {
589      /* load width, height (12 bits each) */
590      s->width = get_bits (bitbuf, 12);
591      s->height = get_bits (bitbuf, 12);
592
593      if (!s->width || !s->height)
594        return -1;
595    } else {
596      /* get width, height from table */
597      s->width = ff_svq1_frame_size_table[frame_size_code].width;
598      s->height = ff_svq1_frame_size_table[frame_size_code].height;
599    }
600  }
601
602  /* unknown fields */
603  if (get_bits1 (bitbuf) == 1) {
604    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
605    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
606
607    if (get_bits (bitbuf, 2) != 0)
608      return -1;
609  }
610
611  if (get_bits1 (bitbuf) == 1) {
612    skip_bits1 (bitbuf);
613    skip_bits (bitbuf, 4);
614    skip_bits1 (bitbuf);
615    skip_bits (bitbuf, 2);
616
617    while (get_bits1 (bitbuf) == 1) {
618      skip_bits (bitbuf, 8);
619    }
620  }
621
622  return 0;
623}
624
625static int svq1_decode_frame(AVCodecContext *avctx,
626                             void *data, int *data_size,
627                             AVPacket *avpkt)
628{
629  const uint8_t *buf = avpkt->data;
630  int buf_size = avpkt->size;
631  MpegEncContext *s=avctx->priv_data;
632  uint8_t        *current, *previous;
633  int             result, i, x, y, width, height;
634  AVFrame *pict = data;
635  svq1_pmv *pmv;
636
637  /* initialize bit buffer */
638  init_get_bits(&s->gb,buf,buf_size*8);
639
640  /* decode frame header */
641  s->f_code = get_bits (&s->gb, 22);
642
643  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
644    return -1;
645
646  /* swap some header bytes (why?) */
647  if (s->f_code != 0x20) {
648    uint32_t *src = (uint32_t *) (buf + 4);
649
650    for (i=0; i < 4; i++) {
651      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
652    }
653  }
654
655  result = svq1_decode_frame_header (&s->gb, s);
656
657  if (result != 0)
658  {
659    av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
660    return result;
661  }
662  avcodec_set_dimensions(avctx, s->width, s->height);
663
664  //FIXME this avoids some confusion for "B frames" without 2 references
665  //this should be removed after libavcodec can handle more flexible picture types & ordering
666  if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
667
668  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
669     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
670     || avctx->skip_frame >= AVDISCARD_ALL)
671      return buf_size;
672
673  if(MPV_frame_start(s, avctx) < 0)
674      return -1;
675
676  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
677  if (!pmv)
678      return -1;
679
680  /* decode y, u and v components */
681  for (i=0; i < 3; i++) {
682    int linesize;
683    if (i == 0) {
684      width  = FFALIGN(s->width, 16);
685      height = FFALIGN(s->height, 16);
686      linesize= s->linesize;
687    } else {
688      if(s->flags&CODEC_FLAG_GRAY) break;
689      width  = FFALIGN(s->width/4, 16);
690      height = FFALIGN(s->height/4, 16);
691      linesize= s->uvlinesize;
692    }
693
694    current = s->current_picture.f.data[i];
695
696    if(s->pict_type==AV_PICTURE_TYPE_B){
697        previous = s->next_picture.f.data[i];
698    }else{
699        previous = s->last_picture.f.data[i];
700    }
701
702    if (s->pict_type == AV_PICTURE_TYPE_I) {
703      /* keyframe */
704      for (y=0; y < height; y+=16) {
705        for (x=0; x < width; x+=16) {
706          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
707          if (result != 0)
708          {
709            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
710            goto err;
711          }
712        }
713        current += 16*linesize;
714      }
715    } else {
716      /* delta frame */
717      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
718
719      for (y=0; y < height; y+=16) {
720        for (x=0; x < width; x+=16) {
721          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
722                                            linesize, pmv, x, y);
723          if (result != 0)
724          {
725            av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
726            goto err;
727          }
728        }
729
730        pmv[0].x =
731        pmv[0].y = 0;
732
733        current += 16*linesize;
734      }
735    }
736  }
737
738  *pict = *(AVFrame*)&s->current_picture;
739
740
741  MPV_frame_end(s);
742
743  *data_size=sizeof(AVFrame);
744  result = buf_size;
745err:
746  av_free(pmv);
747  return result;
748}
749
750static av_cold int svq1_decode_init(AVCodecContext *avctx)
751{
752    MpegEncContext *s = avctx->priv_data;
753    int i;
754    int offset = 0;
755
756    MPV_decode_defaults(s);
757
758    s->avctx = avctx;
759    s->width = (avctx->width+3)&~3;
760    s->height = (avctx->height+3)&~3;
761    s->codec_id= avctx->codec->id;
762    avctx->pix_fmt = PIX_FMT_YUV410P;
763    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
764    s->flags= avctx->flags;
765    if (MPV_common_init(s) < 0) return -1;
766
767    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
768        &ff_svq1_block_type_vlc[0][1], 2, 1,
769        &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
770
771    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
772        &ff_mvtab[0][1], 2, 1,
773        &ff_mvtab[0][0], 2, 1, 176);
774
775    for (i = 0; i < 6; i++) {
776        static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
777        static VLC_TYPE table[168][2];
778        svq1_intra_multistage[i].table = &table[offset];
779        svq1_intra_multistage[i].table_allocated = sizes[0][i];
780        offset += sizes[0][i];
781        init_vlc(&svq1_intra_multistage[i], 3, 8,
782            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
783            &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
784        svq1_inter_multistage[i].table = &table[offset];
785        svq1_inter_multistage[i].table_allocated = sizes[1][i];
786        offset += sizes[1][i];
787        init_vlc(&svq1_inter_multistage[i], 3, 8,
788            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
789            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
790    }
791
792    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
793        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
794        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
795
796    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
797        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
798        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
799
800    return 0;
801}
802
803static av_cold int svq1_decode_end(AVCodecContext *avctx)
804{
805    MpegEncContext *s = avctx->priv_data;
806
807    MPV_common_end(s);
808    return 0;
809}
810
811
812AVCodec ff_svq1_decoder = {
813    .name           = "svq1",
814    .type           = AVMEDIA_TYPE_VIDEO,
815    .id             = CODEC_ID_SVQ1,
816    .priv_data_size = sizeof(MpegEncContext),
817    .init           = svq1_decode_init,
818    .close          = svq1_decode_end,
819    .decode         = svq1_decode_frame,
820    .capabilities   = CODEC_CAP_DR1,
821    .flush= ff_mpeg_flush,
822    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
823    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
824};
825