Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1dec.c @ 8ed2ae09

History | View | Annotate | Download (24.5 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 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
//#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
  svq1_pmv *pmv;
654

    
655
  /* initialize bit buffer */
656
  init_get_bits(&s->gb,buf,buf_size*8);
657

    
658
  /* decode frame header */
659
  s->f_code = get_bits (&s->gb, 22);
660

    
661
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
662
    return -1;
663

    
664
  /* swap some header bytes (why?) */
665
  if (s->f_code != 0x20) {
666
    uint32_t *src = (uint32_t *) (buf + 4);
667

    
668
    for (i=0; i < 4; i++) {
669
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
670
    }
671
  }
672

    
673
  result = svq1_decode_frame_header (&s->gb, s);
674

    
675
  if (result != 0)
676
  {
677
#ifdef DEBUG_SVQ1
678
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
679
#endif
680
    return result;
681
  }
682

    
683
  //FIXME this avoids some confusion for "B frames" without 2 references
684
  //this should be removed after libavcodec can handle more flexible picture types & ordering
685
  if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
686

    
687
#if FF_API_HURRY_UP
688
  if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
689
#endif
690
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
691
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
692
     || avctx->skip_frame >= AVDISCARD_ALL)
693
      return buf_size;
694

    
695
  if(MPV_frame_start(s, avctx) < 0)
696
      return -1;
697

    
698
  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
699
  if (!pmv)
700
      return -1;
701

    
702
  /* decode y, u and v components */
703
  for (i=0; i < 3; i++) {
704
    int linesize;
705
    if (i == 0) {
706
      width  = FFALIGN(s->width, 16);
707
      height = FFALIGN(s->height, 16);
708
      linesize= s->linesize;
709
    } else {
710
      if(s->flags&CODEC_FLAG_GRAY) break;
711
      width  = FFALIGN(s->width/4, 16);
712
      height = FFALIGN(s->height/4, 16);
713
      linesize= s->uvlinesize;
714
    }
715

    
716
    current  = s->current_picture.data[i];
717

    
718
    if(s->pict_type==FF_B_TYPE){
719
        previous = s->next_picture.data[i];
720
    }else{
721
        previous = s->last_picture.data[i];
722
    }
723

    
724
    if (s->pict_type == FF_I_TYPE) {
725
      /* keyframe */
726
      for (y=0; y < height; y+=16) {
727
        for (x=0; x < width; x+=16) {
728
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
729
          if (result != 0)
730
          {
731
//#ifdef DEBUG_SVQ1
732
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
733
//#endif
734
            goto err;
735
          }
736
        }
737
        current += 16*linesize;
738
      }
739
    } else {
740
      /* delta frame */
741
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
742

    
743
      for (y=0; y < height; y+=16) {
744
        for (x=0; x < width; x+=16) {
745
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
746
                                            linesize, pmv, x, y);
747
          if (result != 0)
748
          {
749
#ifdef DEBUG_SVQ1
750
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
751
#endif
752
            goto err;
753
          }
754
        }
755

    
756
        pmv[0].x =
757
        pmv[0].y = 0;
758

    
759
        current += 16*linesize;
760
      }
761
    }
762
  }
763

    
764
  *pict = *(AVFrame*)&s->current_picture;
765

    
766

    
767
  MPV_frame_end(s);
768

    
769
  *data_size=sizeof(AVFrame);
770
  result = buf_size;
771
err:
772
  av_free(pmv);
773
  return result;
774
}
775

    
776
static av_cold int svq1_decode_init(AVCodecContext *avctx)
777
{
778
    MpegEncContext *s = avctx->priv_data;
779
    int i;
780
    int offset = 0;
781

    
782
    MPV_decode_defaults(s);
783

    
784
    s->avctx = avctx;
785
    s->width = (avctx->width+3)&~3;
786
    s->height = (avctx->height+3)&~3;
787
    s->codec_id= avctx->codec->id;
788
    avctx->pix_fmt = PIX_FMT_YUV410P;
789
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
790
    s->flags= avctx->flags;
791
    if (MPV_common_init(s) < 0) return -1;
792

    
793
    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
794
        &ff_svq1_block_type_vlc[0][1], 2, 1,
795
        &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
796

    
797
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
798
        &mvtab[0][1], 2, 1,
799
        &mvtab[0][0], 2, 1, 176);
800

    
801
    for (i = 0; i < 6; i++) {
802
        static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
803
        static VLC_TYPE table[168][2];
804
        svq1_intra_multistage[i].table = &table[offset];
805
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
806
        offset += sizes[0][i];
807
        init_vlc(&svq1_intra_multistage[i], 3, 8,
808
            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
809
            &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
810
        svq1_inter_multistage[i].table = &table[offset];
811
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
812
        offset += sizes[1][i];
813
        init_vlc(&svq1_inter_multistage[i], 3, 8,
814
            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
815
            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
816
    }
817

    
818
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
819
        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
820
        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
821

    
822
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
823
        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
824
        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
825

    
826
    return 0;
827
}
828

    
829
static av_cold int svq1_decode_end(AVCodecContext *avctx)
830
{
831
    MpegEncContext *s = avctx->priv_data;
832

    
833
    MPV_common_end(s);
834
    return 0;
835
}
836

    
837

    
838
AVCodec ff_svq1_decoder = {
839
    "svq1",
840
    AVMEDIA_TYPE_VIDEO,
841
    CODEC_ID_SVQ1,
842
    sizeof(MpegEncContext),
843
    svq1_decode_init,
844
    NULL,
845
    svq1_decode_end,
846
    svq1_decode_frame,
847
    CODEC_CAP_DR1,
848
    .flush= ff_mpeg_flush,
849
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
850
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
851
};