Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1dec.c @ 72415b2a

History | View | Annotate | Download (24.4 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 libavcodec/svq1.c
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
#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

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

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

    
544
uint16_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

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

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

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

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

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

    
829
AVCodec 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
};