Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1dec.c @ ce5e49b0

History | View | Annotate | Download (24 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
  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 02fb2546 Mike Melanson
                                  svq1_pmv *motion,int x, int y) {
392 54166165 Aurelien Jacobs
  uint8_t    *src;
393
  uint8_t    *dst;
394 02fb2546 Mike Melanson
  svq1_pmv    mv;
395
  svq1_pmv   *pmv[4];
396 54166165 Aurelien Jacobs
  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 02fb2546 Mike Melanson
                        svq1_pmv *motion, int x, int y) {
476 54166165 Aurelien Jacobs
  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 795bb9dc Michael Niedermayer
uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
532 54166165 Aurelien Jacobs
  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 ce5e49b0 Stefano Sabatini
  if (s->pict_type == AV_PICTURE_TYPE_I) {
567 54166165 Aurelien Jacobs
568
    /* unknown fields */
569
    if (s->f_code == 0x50 || s->f_code == 0x60) {
570
      int csum = get_bits (bitbuf, 16);
571
572 795bb9dc Michael Niedermayer
      csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
573 54166165 Aurelien Jacobs
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 5fc32c27 Alex Beregszaszi
  if (get_bits1 (bitbuf) == 1) {
609 54166165 Aurelien Jacobs
    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 5fc32c27 Alex Beregszaszi
  if (get_bits1 (bitbuf) == 1) {
617 54166165 Aurelien Jacobs
    skip_bits1 (bitbuf);
618
    skip_bits (bitbuf, 4);
619
    skip_bits1 (bitbuf);
620
    skip_bits (bitbuf, 2);
621
622 5fc32c27 Alex Beregszaszi
    while (get_bits1 (bitbuf) == 1) {
623 54166165 Aurelien Jacobs
      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 7a00bbad Thilo Borgmann
                             AVPacket *avpkt)
633 54166165 Aurelien Jacobs
{
634 7a00bbad Thilo Borgmann
  const uint8_t *buf = avpkt->data;
635
  int buf_size = avpkt->size;
636 54166165 Aurelien Jacobs
  MpegEncContext *s=avctx->priv_data;
637
  uint8_t        *current, *previous;
638
  int             result, i, x, y, width, height;
639
  AVFrame *pict = data;
640 5228bcd8 Måns Rullgård
  svq1_pmv *pmv;
641 54166165 Aurelien Jacobs
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 ce5e49b0 Stefano Sabatini
  if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
673 54166165 Aurelien Jacobs
674 ce5e49b0 Stefano Sabatini
  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 54166165 Aurelien Jacobs
     || avctx->skip_frame >= AVDISCARD_ALL)
677
      return buf_size;
678
679
  if(MPV_frame_start(s, avctx) < 0)
680
      return -1;
681
682 5228bcd8 Måns Rullgård
  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
683
  if (!pmv)
684
      return -1;
685
686 54166165 Aurelien Jacobs
  /* decode y, u and v components */
687
  for (i=0; i < 3; i++) {
688
    int linesize;
689
    if (i == 0) {
690 ef516f73 David Conrad
      width  = FFALIGN(s->width, 16);
691
      height = FFALIGN(s->height, 16);
692 54166165 Aurelien Jacobs
      linesize= s->linesize;
693
    } else {
694
      if(s->flags&CODEC_FLAG_GRAY) break;
695 ef516f73 David Conrad
      width  = FFALIGN(s->width/4, 16);
696
      height = FFALIGN(s->height/4, 16);
697 54166165 Aurelien Jacobs
      linesize= s->uvlinesize;
698
    }
699
700
    current  = s->current_picture.data[i];
701
702 ce5e49b0 Stefano Sabatini
    if(s->pict_type==AV_PICTURE_TYPE_B){
703 54166165 Aurelien Jacobs
        previous = s->next_picture.data[i];
704
    }else{
705
        previous = s->last_picture.data[i];
706
    }
707
708 ce5e49b0 Stefano Sabatini
    if (s->pict_type == AV_PICTURE_TYPE_I) {
709 54166165 Aurelien Jacobs
      /* 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 5228bcd8 Måns Rullgård
            goto err;
719 54166165 Aurelien Jacobs
          }
720
        }
721
        current += 16*linesize;
722
      }
723
    } else {
724
      /* delta frame */
725 02fb2546 Mike Melanson
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
726 54166165 Aurelien Jacobs
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 5228bcd8 Måns Rullgård
            goto err;
737 54166165 Aurelien Jacobs
          }
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 5228bcd8 Måns Rullgård
  result = buf_size;
755
err:
756
  av_free(pmv);
757
  return result;
758 54166165 Aurelien Jacobs
}
759
760 98a6fff9 Zuxy Meng
static av_cold int svq1_decode_init(AVCodecContext *avctx)
761 54166165 Aurelien Jacobs
{
762
    MpegEncContext *s = avctx->priv_data;
763
    int i;
764 80bc3bbc Reimar Döffinger
    int offset = 0;
765 54166165 Aurelien Jacobs
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 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
778 54166165 Aurelien Jacobs
        &ff_svq1_block_type_vlc[0][1], 2, 1,
779 9c3068c8 Reimar Döffinger
        &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780 54166165 Aurelien Jacobs
781 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782 54166165 Aurelien Jacobs
        &mvtab[0][1], 2, 1,
783 9c3068c8 Reimar Döffinger
        &mvtab[0][0], 2, 1, 176);
784 54166165 Aurelien Jacobs
785
    for (i = 0; i < 6; i++) {
786 80bc3bbc Reimar Döffinger
        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 54166165 Aurelien Jacobs
        init_vlc(&svq1_intra_multistage[i], 3, 8,
792
            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793 80bc3bbc Reimar Döffinger
            &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 54166165 Aurelien Jacobs
        init_vlc(&svq1_inter_multistage[i], 3, 8,
798
            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
799 80bc3bbc Reimar Döffinger
            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
800 54166165 Aurelien Jacobs
    }
801
802 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
803 54166165 Aurelien Jacobs
        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
804 9c3068c8 Reimar Döffinger
        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
805 54166165 Aurelien Jacobs
806 9c3068c8 Reimar Döffinger
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
807 54166165 Aurelien Jacobs
        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
808 9c3068c8 Reimar Döffinger
        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
809 54166165 Aurelien Jacobs
810
    return 0;
811
}
812
813 98a6fff9 Zuxy Meng
static av_cold int svq1_decode_end(AVCodecContext *avctx)
814 54166165 Aurelien Jacobs
{
815
    MpegEncContext *s = avctx->priv_data;
816
817
    MPV_common_end(s);
818
    return 0;
819
}
820
821
822 e7e2df27 Diego Elio Pettenò
AVCodec ff_svq1_decoder = {
823 54166165 Aurelien Jacobs
    "svq1",
824 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_VIDEO,
825 54166165 Aurelien Jacobs
    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 2ba83017 Reimar Döffinger
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
834 1c062b55 Stefano Sabatini
    .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
835 54166165 Aurelien Jacobs
};