Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1dec.c @ ce5e49b0

History | View | Annotate | Download (24 KB)

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

    
47
extern const uint8_t mvtab[33][2];
48

    
49
static VLC svq1_block_type;
50
static VLC svq1_motion_component;
51
static VLC svq1_intra_multistage[6];
52
static VLC svq1_inter_multistage[6];
53
static VLC svq1_intra_mean;
54
static VLC svq1_inter_mean;
55

    
56
/* motion vector (prediction) */
57
typedef struct svq1_pmv_s {
58
  int           x;
59
  int           y;
60
} svq1_pmv;
61

    
62
static 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

    
97
static 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

    
207
static 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

    
262
static 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

    
305
static 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

    
329
static 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

    
344
static 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

    
389
static 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

    
473
static 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
#ifdef DEBUG_SVQ1
503
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
504
#endif
505
      break;
506
    }
507
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
508
    break;
509

    
510
  case SVQ1_BLOCK_INTER_4V:
511
    result = svq1_motion_inter_4v_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_4v_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_INTRA:
524
    result = svq1_decode_block_intra (bitbuf, current, pitch);
525
    break;
526
  }
527

    
528
  return result;
529
}
530

    
531
uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
532
  int i;
533

    
534
  for (i=0; i < length; i++) {
535
    value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
536
  }
537

    
538
  return value;
539
}
540

    
541
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
542
  uint8_t seed;
543
  int     i;
544

    
545
  out[0] = get_bits (bitbuf, 8);
546

    
547
  seed = string_table[out[0]];
548

    
549
  for (i=1; i <= out[0]; i++) {
550
    out[i] = get_bits (bitbuf, 8) ^ seed;
551
    seed   = string_table[out[i] ^ seed];
552
  }
553
}
554

    
555
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
556
  int frame_size_code;
557
  int temporal_reference;
558

    
559
  temporal_reference = get_bits (bitbuf, 8);
560

    
561
  /* frame type */
562
  s->pict_type= get_bits (bitbuf, 2)+1;
563
  if(s->pict_type==4)
564
      return -1;
565

    
566
  if (s->pict_type == AV_PICTURE_TYPE_I) {
567

    
568
    /* unknown fields */
569
    if (s->f_code == 0x50 || s->f_code == 0x60) {
570
      int csum = get_bits (bitbuf, 16);
571

    
572
      csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
573

    
574
//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
575
//              (csum == 0) ? "correct" : "incorrect", csum);
576
    }
577

    
578
    if ((s->f_code ^ 0x10) >= 0x50) {
579
      uint8_t msg[256];
580

    
581
      svq1_parse_string (bitbuf, msg);
582

    
583
      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
584
    }
585

    
586
    skip_bits (bitbuf, 2);
587
    skip_bits (bitbuf, 2);
588
    skip_bits1 (bitbuf);
589

    
590
    /* load frame size */
591
    frame_size_code = get_bits (bitbuf, 3);
592

    
593
    if (frame_size_code == 7) {
594
      /* load width, height (12 bits each) */
595
      s->width = get_bits (bitbuf, 12);
596
      s->height = get_bits (bitbuf, 12);
597

    
598
      if (!s->width || !s->height)
599
        return -1;
600
    } else {
601
      /* get width, height from table */
602
      s->width = ff_svq1_frame_size_table[frame_size_code].width;
603
      s->height = ff_svq1_frame_size_table[frame_size_code].height;
604
    }
605
  }
606

    
607
  /* unknown fields */
608
  if (get_bits1 (bitbuf) == 1) {
609
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
610
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
611

    
612
    if (get_bits (bitbuf, 2) != 0)
613
      return -1;
614
  }
615

    
616
  if (get_bits1 (bitbuf) == 1) {
617
    skip_bits1 (bitbuf);
618
    skip_bits (bitbuf, 4);
619
    skip_bits1 (bitbuf);
620
    skip_bits (bitbuf, 2);
621

    
622
    while (get_bits1 (bitbuf) == 1) {
623
      skip_bits (bitbuf, 8);
624
    }
625
  }
626

    
627
  return 0;
628
}
629

    
630
static int svq1_decode_frame(AVCodecContext *avctx,
631
                             void *data, int *data_size,
632
                             AVPacket *avpkt)
633
{
634
  const uint8_t *buf = avpkt->data;
635
  int buf_size = avpkt->size;
636
  MpegEncContext *s=avctx->priv_data;
637
  uint8_t        *current, *previous;
638
  int             result, i, x, y, width, height;
639
  AVFrame *pict = data;
640
  svq1_pmv *pmv;
641

    
642
  /* initialize bit buffer */
643
  init_get_bits(&s->gb,buf,buf_size*8);
644

    
645
  /* decode frame header */
646
  s->f_code = get_bits (&s->gb, 22);
647

    
648
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
649
    return -1;
650

    
651
  /* swap some header bytes (why?) */
652
  if (s->f_code != 0x20) {
653
    uint32_t *src = (uint32_t *) (buf + 4);
654

    
655
    for (i=0; i < 4; i++) {
656
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
657
    }
658
  }
659

    
660
  result = svq1_decode_frame_header (&s->gb, s);
661

    
662
  if (result != 0)
663
  {
664
#ifdef DEBUG_SVQ1
665
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
666
#endif
667
    return result;
668
  }
669

    
670
  //FIXME this avoids some confusion for "B frames" without 2 references
671
  //this should be removed after libavcodec can handle more flexible picture types & ordering
672
  if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
673

    
674
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
675
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
676
     || avctx->skip_frame >= AVDISCARD_ALL)
677
      return buf_size;
678

    
679
  if(MPV_frame_start(s, avctx) < 0)
680
      return -1;
681

    
682
  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
683
  if (!pmv)
684
      return -1;
685

    
686
  /* decode y, u and v components */
687
  for (i=0; i < 3; i++) {
688
    int linesize;
689
    if (i == 0) {
690
      width  = FFALIGN(s->width, 16);
691
      height = FFALIGN(s->height, 16);
692
      linesize= s->linesize;
693
    } else {
694
      if(s->flags&CODEC_FLAG_GRAY) break;
695
      width  = FFALIGN(s->width/4, 16);
696
      height = FFALIGN(s->height/4, 16);
697
      linesize= s->uvlinesize;
698
    }
699

    
700
    current  = s->current_picture.data[i];
701

    
702
    if(s->pict_type==AV_PICTURE_TYPE_B){
703
        previous = s->next_picture.data[i];
704
    }else{
705
        previous = s->last_picture.data[i];
706
    }
707

    
708
    if (s->pict_type == AV_PICTURE_TYPE_I) {
709
      /* keyframe */
710
      for (y=0; y < height; y+=16) {
711
        for (x=0; x < width; x+=16) {
712
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
713
          if (result != 0)
714
          {
715
//#ifdef DEBUG_SVQ1
716
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
717
//#endif
718
            goto err;
719
          }
720
        }
721
        current += 16*linesize;
722
      }
723
    } else {
724
      /* delta frame */
725
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
726

    
727
      for (y=0; y < height; y+=16) {
728
        for (x=0; x < width; x+=16) {
729
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
730
                                            linesize, pmv, x, y);
731
          if (result != 0)
732
          {
733
#ifdef DEBUG_SVQ1
734
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
735
#endif
736
            goto err;
737
          }
738
        }
739

    
740
        pmv[0].x =
741
        pmv[0].y = 0;
742

    
743
        current += 16*linesize;
744
      }
745
    }
746
  }
747

    
748
  *pict = *(AVFrame*)&s->current_picture;
749

    
750

    
751
  MPV_frame_end(s);
752

    
753
  *data_size=sizeof(AVFrame);
754
  result = buf_size;
755
err:
756
  av_free(pmv);
757
  return result;
758
}
759

    
760
static av_cold int svq1_decode_init(AVCodecContext *avctx)
761
{
762
    MpegEncContext *s = avctx->priv_data;
763
    int i;
764
    int offset = 0;
765

    
766
    MPV_decode_defaults(s);
767

    
768
    s->avctx = avctx;
769
    s->width = (avctx->width+3)&~3;
770
    s->height = (avctx->height+3)&~3;
771
    s->codec_id= avctx->codec->id;
772
    avctx->pix_fmt = PIX_FMT_YUV410P;
773
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
774
    s->flags= avctx->flags;
775
    if (MPV_common_init(s) < 0) return -1;
776

    
777
    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
778
        &ff_svq1_block_type_vlc[0][1], 2, 1,
779
        &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780

    
781
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782
        &mvtab[0][1], 2, 1,
783
        &mvtab[0][0], 2, 1, 176);
784

    
785
    for (i = 0; i < 6; i++) {
786
        static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
787
        static VLC_TYPE table[168][2];
788
        svq1_intra_multistage[i].table = &table[offset];
789
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
790
        offset += sizes[0][i];
791
        init_vlc(&svq1_intra_multistage[i], 3, 8,
792
            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793
            &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
794
        svq1_inter_multistage[i].table = &table[offset];
795
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
796
        offset += sizes[1][i];
797
        init_vlc(&svq1_inter_multistage[i], 3, 8,
798
            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
799
            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
800
    }
801

    
802
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
803
        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
804
        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
805

    
806
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
807
        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
808
        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
809

    
810
    return 0;
811
}
812

    
813
static av_cold int svq1_decode_end(AVCodecContext *avctx)
814
{
815
    MpegEncContext *s = avctx->priv_data;
816

    
817
    MPV_common_end(s);
818
    return 0;
819
}
820

    
821

    
822
AVCodec ff_svq1_decoder = {
823
    "svq1",
824
    AVMEDIA_TYPE_VIDEO,
825
    CODEC_ID_SVQ1,
826
    sizeof(MpegEncContext),
827
    svq1_decode_init,
828
    NULL,
829
    svq1_decode_end,
830
    svq1_decode_frame,
831
    CODEC_CAP_DR1,
832
    .flush= ff_mpeg_flush,
833
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
834
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
835
};