Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1dec.c @ 5228bcd8

History | View | Annotate | Download (24.5 KB)

1 54166165 Aurelien Jacobs
/*
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 ba87f080 Diego Biurrun
 * @file
30 54166165 Aurelien Jacobs
 * 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 199436b9 Aurelien Jacobs
#include "mathops.h"
41 54166165 Aurelien Jacobs
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 02fb2546 Mike Melanson
} svq1_pmv;
61 54166165 Aurelien Jacobs
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 5fc32c27 Alex Beregszaszi
      if (get_bits1 (bitbuf) == 0)\
142 54166165 Aurelien Jacobs
        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 02fb2546 Mike Melanson
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
306 54166165 Aurelien Jacobs
  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 02fb2546 Mike Melanson
                               svq1_pmv *motion, int x, int y) {
347 54166165 Aurelien Jacobs
  uint8_t    *src;
348
  uint8_t    *dst;
349 02fb2546 Mike Melanson
  svq1_pmv    mv;
350
  svq1_pmv   *pmv[3];
351 54166165 Aurelien Jacobs
  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 02fb2546 Mike Melanson
                                  svq1_pmv *motion,int x, int y) {
399 54166165 Aurelien Jacobs
  uint8_t    *src;
400
  uint8_t    *dst;
401 02fb2546 Mike Melanson
  svq1_pmv    mv;
402
  svq1_pmv   *pmv[4];
403 54166165 Aurelien Jacobs
  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 02fb2546 Mike Melanson
                        svq1_pmv *motion, int x, int y) {
489 54166165 Aurelien Jacobs
  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 795bb9dc Michael Niedermayer
uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
545 54166165 Aurelien Jacobs
  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 9701840b Aurelien Jacobs
  if (s->pict_type == FF_I_TYPE) {
580 54166165 Aurelien Jacobs
581
    /* unknown fields */
582
    if (s->f_code == 0x50 || s->f_code == 0x60) {
583
      int csum = get_bits (bitbuf, 16);
584
585 795bb9dc Michael Niedermayer
      csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
586 54166165 Aurelien Jacobs
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 5fc32c27 Alex Beregszaszi
  if (get_bits1 (bitbuf) == 1) {
622 54166165 Aurelien Jacobs
    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 5fc32c27 Alex Beregszaszi
  if (get_bits1 (bitbuf) == 1) {
630 54166165 Aurelien Jacobs
    skip_bits1 (bitbuf);
631
    skip_bits (bitbuf, 4);
632
    skip_bits1 (bitbuf);
633
    skip_bits (bitbuf, 2);
634
635 5fc32c27 Alex Beregszaszi
    while (get_bits1 (bitbuf) == 1) {
636 54166165 Aurelien Jacobs
      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 7a00bbad Thilo Borgmann
                             AVPacket *avpkt)
646 54166165 Aurelien Jacobs
{
647 7a00bbad Thilo Borgmann
  const uint8_t *buf = avpkt->data;
648
  int buf_size = avpkt->size;
649 54166165 Aurelien Jacobs
  MpegEncContext *s=avctx->priv_data;
650
  uint8_t        *current, *previous;
651
  int             result, i, x, y, width, height;
652
  AVFrame *pict = data;
653 5228bcd8 Måns Rullgård
  svq1_pmv *pmv;
654 54166165 Aurelien Jacobs
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 9701840b Aurelien Jacobs
  if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
686 54166165 Aurelien Jacobs
687 9701840b Aurelien Jacobs
  if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
688
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
689
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
690 54166165 Aurelien Jacobs
     || avctx->skip_frame >= AVDISCARD_ALL)
691
      return buf_size;
692
693
  if(MPV_frame_start(s, avctx) < 0)
694
      return -1;
695
696 5228bcd8 Måns Rullgård
  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
697
  if (!pmv)
698
      return -1;
699
700 54166165 Aurelien Jacobs
  /* decode y, u and v components */
701
  for (i=0; i < 3; i++) {
702
    int linesize;
703
    if (i == 0) {
704 ef516f73 David Conrad
      width  = FFALIGN(s->width, 16);
705
      height = FFALIGN(s->height, 16);
706 54166165 Aurelien Jacobs
      linesize= s->linesize;
707
    } else {
708
      if(s->flags&CODEC_FLAG_GRAY) break;
709 ef516f73 David Conrad
      width  = FFALIGN(s->width/4, 16);
710
      height = FFALIGN(s->height/4, 16);
711 54166165 Aurelien Jacobs
      linesize= s->uvlinesize;
712
    }
713
714
    current  = s->current_picture.data[i];
715
716 9701840b Aurelien Jacobs
    if(s->pict_type==FF_B_TYPE){
717 54166165 Aurelien Jacobs
        previous = s->next_picture.data[i];
718
    }else{
719
        previous = s->last_picture.data[i];
720
    }
721
722 9701840b Aurelien Jacobs
    if (s->pict_type == FF_I_TYPE) {
723 54166165 Aurelien Jacobs
      /* keyframe */
724
      for (y=0; y < height; y+=16) {
725
        for (x=0; x < width; x+=16) {
726
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
727
          if (result != 0)
728
          {
729
//#ifdef DEBUG_SVQ1
730
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
731
//#endif
732 5228bcd8 Måns Rullgård
            goto err;
733 54166165 Aurelien Jacobs
          }
734
        }
735
        current += 16*linesize;
736
      }
737
    } else {
738
      /* delta frame */
739 02fb2546 Mike Melanson
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
740 54166165 Aurelien Jacobs
741
      for (y=0; y < height; y+=16) {
742
        for (x=0; x < width; x+=16) {
743
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
744
                                            linesize, pmv, x, y);
745
          if (result != 0)
746
          {
747
#ifdef DEBUG_SVQ1
748
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
749
#endif
750 5228bcd8 Måns Rullgård
            goto err;
751 54166165 Aurelien Jacobs
          }
752
        }
753
754
        pmv[0].x =
755
        pmv[0].y = 0;
756
757
        current += 16*linesize;
758
      }
759
    }
760
  }
761
762
  *pict = *(AVFrame*)&s->current_picture;
763
764
765
  MPV_frame_end(s);
766
767
  *data_size=sizeof(AVFrame);
768 5228bcd8 Måns Rullgård
  result = buf_size;
769
err:
770
  av_free(pmv);
771
  return result;
772 54166165 Aurelien Jacobs
}
773
774 98a6fff9 Zuxy Meng
static av_cold int svq1_decode_init(AVCodecContext *avctx)
775 54166165 Aurelien Jacobs
{
776
    MpegEncContext *s = avctx->priv_data;
777
    int i;
778 80bc3bbc Reimar Döffinger
    int offset = 0;
779 54166165 Aurelien Jacobs
780
    MPV_decode_defaults(s);
781
782
    s->avctx = avctx;
783
    s->width = (avctx->width+3)&~3;
784
    s->height = (avctx->height+3)&~3;
785
    s->codec_id= avctx->codec->id;
786
    avctx->pix_fmt = PIX_FMT_YUV410P;
787
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
788
    s->flags= avctx->flags;
789
    if (MPV_common_init(s) < 0) return -1;
790
791 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
792 54166165 Aurelien Jacobs
        &ff_svq1_block_type_vlc[0][1], 2, 1,
793 9c3068c8 Reimar Döffinger
        &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
794 54166165 Aurelien Jacobs
795 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
796 54166165 Aurelien Jacobs
        &mvtab[0][1], 2, 1,
797 9c3068c8 Reimar Döffinger
        &mvtab[0][0], 2, 1, 176);
798 54166165 Aurelien Jacobs
799
    for (i = 0; i < 6; i++) {
800 80bc3bbc Reimar Döffinger
        static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
801
        static VLC_TYPE table[168][2];
802
        svq1_intra_multistage[i].table = &table[offset];
803
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
804
        offset += sizes[0][i];
805 54166165 Aurelien Jacobs
        init_vlc(&svq1_intra_multistage[i], 3, 8,
806
            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
807 80bc3bbc Reimar Döffinger
            &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
808
        svq1_inter_multistage[i].table = &table[offset];
809
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
810
        offset += sizes[1][i];
811 54166165 Aurelien Jacobs
        init_vlc(&svq1_inter_multistage[i], 3, 8,
812
            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
813 80bc3bbc Reimar Döffinger
            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
814 54166165 Aurelien Jacobs
    }
815
816 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
817 54166165 Aurelien Jacobs
        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
818 9c3068c8 Reimar Döffinger
        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
819 54166165 Aurelien Jacobs
820 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
821 54166165 Aurelien Jacobs
        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
822 9c3068c8 Reimar Döffinger
        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
823 54166165 Aurelien Jacobs
824
    return 0;
825
}
826
827 98a6fff9 Zuxy Meng
static av_cold int svq1_decode_end(AVCodecContext *avctx)
828 54166165 Aurelien Jacobs
{
829
    MpegEncContext *s = avctx->priv_data;
830
831
    MPV_common_end(s);
832
    return 0;
833
}
834
835
836
AVCodec svq1_decoder = {
837
    "svq1",
838 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_VIDEO,
839 54166165 Aurelien Jacobs
    CODEC_ID_SVQ1,
840
    sizeof(MpegEncContext),
841
    svq1_decode_init,
842
    NULL,
843
    svq1_decode_end,
844
    svq1_decode_frame,
845
    CODEC_CAP_DR1,
846
    .flush= ff_mpeg_flush,
847 2ba83017 Reimar Döffinger
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
848 1c062b55 Stefano Sabatini
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849 54166165 Aurelien Jacobs
};