Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ b928ec64

History | View | Annotate | Download (22.9 KB)

1 36577721 Nick Kurshev
/*
2
 * 
3 be8ffec9 Nick Kurshev
 * Copyright (C) 2002 the xine project
4 36577721 Nick Kurshev
 * Copyright (C) 2002 the ffmpeg project
5 be8ffec9 Nick Kurshev
 * 
6 36577721 Nick Kurshev
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20 861dfbb5 Nick Kurshev
 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
21 be8ffec9 Nick Kurshev
 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
22
 *
23
 */
24 983e3246 Michael Niedermayer
25
/**
26
 * @file svq1.c
27 59fcece9 Mike Melanson
 * Sorenson Vector Quantizer #1 (SVQ1) video decoder.
28 983e3246 Michael Niedermayer
 */
29
30 59fcece9 Mike Melanson
31 be8ffec9 Nick Kurshev
//#define DEBUG_SVQ1
32
#include <stdio.h>
33
#include <stdlib.h>
34
#include <string.h>
35
#include <unistd.h>
36
37 82dd7d0d Nick Kurshev
#include "common.h"
38 be8ffec9 Nick Kurshev
#include "avcodec.h"
39
#include "dsputil.h"
40
#include "mpegvideo.h"
41 59fcece9 Mike Melanson
#include "bswap.h"
42 be8ffec9 Nick Kurshev
43 59fcece9 Mike Melanson
static VLC svq1_block_type;
44
static VLC svq1_motion_component;
45
static VLC svq1_intra_multistage[6];
46
static VLC svq1_inter_multistage[6];
47
static VLC svq1_intra_mean;
48
static VLC svq1_inter_mean;
49 be8ffec9 Nick Kurshev
50 63e0d4ac Nick Kurshev
#define MEDIAN(a,b,c)        (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
51 be8ffec9 Nick Kurshev
52
#define SVQ1_BLOCK_SKIP                0
53
#define SVQ1_BLOCK_INTER        1
54
#define SVQ1_BLOCK_INTER_4V        2
55
#define SVQ1_BLOCK_INTRA        3
56
57
/* motion vector (prediction) */
58
typedef struct svq1_pmv_s {
59
  int                 x;
60
  int                 y;
61
} svq1_pmv_t;
62
63 ce23c668 Alex Beregszaszi
#include "svq1_cb.h"
64 59fcece9 Mike Melanson
#include "svq1_vlc.h"
65
66
static const uint16_t checksum_table[256] = {
67
  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
68
  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
69
  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
70
  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
71
  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
72
  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
73
  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
74
  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
75
  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
76
  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
77
  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
78
  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
79
  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
80
  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
81
  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
82
  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
83
  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
84
  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
85
  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
86
  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
87
  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
88
  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
89
  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
90
  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
91
  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
92
  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
93
  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
94
  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
95
  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
96
  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
97
  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
98
  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
99 be8ffec9 Nick Kurshev
};
100
101 59fcece9 Mike Melanson
static const uint8_t string_table[256] = {
102
  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
103
  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
104
  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
105
  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
106
  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
107
  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
108
  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
109
  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
110
  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
111
  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
112
  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
113
  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
114
  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
115
  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
116
  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
117
  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
118
  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
119
  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
120
  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
121
  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
122
  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
123
  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
124
  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
125
  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
126
  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
127
  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
128
  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
129
  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
130
  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
131
  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
132
  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
133
  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
134 be8ffec9 Nick Kurshev
};
135
136 82dd7d0d Nick Kurshev
#define SVQ1_PROCESS_VECTOR()\
137
    for (; level > 0; i++) {\
138
      /* process next depth */\
139
      if (i == m) {\
140
        m = n;\
141
        if (--level == 0)\
142
          break;\
143
      }\
144
      /* divide block if next bit set */\
145
      if (get_bits (bitbuf, 1) == 0)\
146
        break;\
147
      /* add child nodes */\
148
      list[n++] = list[i];\
149
      list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
150
    }
151
152
#define SVQ1_ADD_CODEBOOK()\
153
          /* add codebook entries to vector */\
154
          for (j=0; j < stages; j++) {\
155
            n3  = codebook[entries[j]] ^ 0x80808080;\
156
            n1 += ((n3 & 0xFF00FF00) >> 8);\
157
            n2 +=  (n3 & 0x00FF00FF);\
158
          }\
159
\
160
          /* clip to [0..255] */\
161
          if (n1 & 0xFF00FF00) {\
162
            n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
163
            n1 += 0x7F007F00;\
164
            n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165
            n1 &= (n3 & 0x00FF00FF);\
166
          }\
167
\
168
          if (n2 & 0xFF00FF00) {\
169
            n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
170
            n2 += 0x7F007F00;\
171
            n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
172
            n2 &= (n3 & 0x00FF00FF);\
173
          }
174 be8ffec9 Nick Kurshev
175 82dd7d0d Nick Kurshev
#define SVQ1_DO_CODEBOOK_INTRA()\
176
      for (y=0; y < height; y++) {\
177
        for (x=0; x < (width / 4); x++, codebook++) {\
178
        n1 = n4;\
179
        n2 = n4;\
180
        SVQ1_ADD_CODEBOOK()\
181
        /* store result */\
182
        dst[x] = (n1 << 8) | n2;\
183
        }\
184
        dst += (pitch / 4);\
185
      }
186
187
#define SVQ1_DO_CODEBOOK_NONINTRA()\
188
      for (y=0; y < height; y++) {\
189
        for (x=0; x < (width / 4); x++, codebook++) {\
190
        n3 = dst[x];\
191
        /* add mean value to vector */\
192
        n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
193
        n2 =  (n3 & 0x00FF00FF)          + n4;\
194
        SVQ1_ADD_CODEBOOK()\
195
        /* store result */\
196
        dst[x] = (n1 << 8) | n2;\
197
        }\
198
        dst += (pitch / 4);\
199
      }
200
201
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
202 18f77016 Zdenek Kabelac
      codebook = (const uint32_t *) cbook[level];\
203 82dd7d0d Nick Kurshev
      bit_cache = get_bits (bitbuf, 4*stages);\
204
      /* calculate codebook entries for this vector */\
205
      for (j=0; j < stages; j++) {\
206
        entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
207
      }\
208
      mean -= (stages * 128);\
209
      n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
210 be8ffec9 Nick Kurshev
211 59fcece9 Mike Melanson
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
212 be8ffec9 Nick Kurshev
  uint32_t    bit_cache;
213
  uint8_t    *list[63];
214
  uint32_t   *dst;
215 18f77016 Zdenek Kabelac
  const uint32_t *codebook;
216 be8ffec9 Nick Kurshev
  int              entries[6];
217
  int              i, j, m, n;
218
  int              mean, stages;
219 18f77016 Zdenek Kabelac
  unsigned    x, y, width, height, level;
220 be8ffec9 Nick Kurshev
  uint32_t    n1, n2, n3, n4;
221
222
  /* initialize list for breadth first processing of vectors */
223
  list[0] = pixels;
224
225
  /* recursively process vector */
226
  for (i=0, m=1, n=1, level=5; i < n; i++) {
227 82dd7d0d Nick Kurshev
    SVQ1_PROCESS_VECTOR();
228 be8ffec9 Nick Kurshev
229
    /* destination address and vector size */
230
    dst = (uint32_t *) list[i];
231
    width = 1 << ((4 + level) /2);
232
    height = 1 << ((3 + level) /2);
233
234
    /* get number of stages (-1 skips vector, 0 for mean only) */
235 59fcece9 Mike Melanson
    stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
236 be8ffec9 Nick Kurshev
237
    if (stages == -1) {
238
        for (y=0; y < height; y++) {
239
          memset (&dst[y*(pitch / 4)], 0, width);
240
        }
241
      continue;                /* skip vector */
242
    }
243
244
    if ((stages > 0) && (level >= 4)) {
245
#ifdef DEBUG_SVQ1
246 82dd7d0d Nick Kurshev
    printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
247 be8ffec9 Nick Kurshev
#endif
248
      return -1;        /* invalid vector */
249
    }
250
251 59fcece9 Mike Melanson
    mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
252 be8ffec9 Nick Kurshev
253 82dd7d0d Nick Kurshev
    if (stages == 0) {
254 be8ffec9 Nick Kurshev
      for (y=0; y < height; y++) {
255
        memset (&dst[y*(pitch / 4)], mean, width);
256
      }
257
    } else {
258 82dd7d0d Nick Kurshev
      SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
259
      SVQ1_DO_CODEBOOK_INTRA()
260
    }
261
  }
262 be8ffec9 Nick Kurshev
263 82dd7d0d Nick Kurshev
  return 0;
264
}
265 be8ffec9 Nick Kurshev
266 59fcece9 Mike Melanson
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
267 82dd7d0d Nick Kurshev
  uint32_t    bit_cache;
268
  uint8_t    *list[63];
269
  uint32_t   *dst;
270 18f77016 Zdenek Kabelac
  const uint32_t *codebook;
271 82dd7d0d Nick Kurshev
  int              entries[6];
272
  int              i, j, m, n;
273
  int              mean, stages;
274
  int              x, y, width, height, level;
275
  uint32_t    n1, n2, n3, n4;
276 be8ffec9 Nick Kurshev
277 82dd7d0d Nick Kurshev
  /* initialize list for breadth first processing of vectors */
278
  list[0] = pixels;
279 be8ffec9 Nick Kurshev
280 82dd7d0d Nick Kurshev
  /* recursively process vector */
281
  for (i=0, m=1, n=1, level=5; i < n; i++) {
282
    SVQ1_PROCESS_VECTOR();
283 be8ffec9 Nick Kurshev
284 82dd7d0d Nick Kurshev
    /* destination address and vector size */
285
    dst = (uint32_t *) list[i];
286
    width = 1 << ((4 + level) /2);
287
    height = 1 << ((3 + level) /2);
288 be8ffec9 Nick Kurshev
289 82dd7d0d Nick Kurshev
    /* get number of stages (-1 skips vector, 0 for mean only) */
290 59fcece9 Mike Melanson
    stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
291 82dd7d0d Nick Kurshev
292
    if (stages == -1) continue;        /* skip vector */
293
294
    if ((stages > 0) && (level >= 4)) {
295
#ifdef DEBUG_SVQ1
296
    printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
297
#endif
298
      return -1;        /* invalid vector */
299 be8ffec9 Nick Kurshev
    }
300
301 59fcece9 Mike Melanson
    mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
302 82dd7d0d Nick Kurshev
303
    SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
304
    SVQ1_DO_CODEBOOK_NONINTRA()
305
  }
306 be8ffec9 Nick Kurshev
  return 0;
307
}
308
309 59fcece9 Mike Melanson
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
310
  int              diff;
311 be8ffec9 Nick Kurshev
  int              i;
312
313
  for (i=0; i < 2; i++) {
314
315
    /* get motion code */
316 59fcece9 Mike Melanson
    diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
317 be8ffec9 Nick Kurshev
318
    /* add median of motion vector predictors and clip result */
319
    if (i == 1)
320
      mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
321
    else
322
      mv->x = ((diff + MEDIAN(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
323
  }
324
325
  return 0;
326
}
327
328 82dd7d0d Nick Kurshev
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
329 be8ffec9 Nick Kurshev
  uint8_t *src;
330
  uint8_t *dst;
331
  int           i;
332
333
  src = &previous[x + y*pitch];
334
  dst = current;
335
336
  for (i=0; i < 16; i++) {
337
    memcpy (dst, src, 16);
338
    src += pitch;
339
    dst += pitch;
340
  }
341
}
342
343 59fcece9 Mike Melanson
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
344 be8ffec9 Nick Kurshev
                               uint8_t *current, uint8_t *previous, int pitch,
345
                               svq1_pmv_t *motion, int x, int y) {
346
  uint8_t    *src;
347
  uint8_t    *dst;
348
  svq1_pmv_t  mv;
349
  svq1_pmv_t *pmv[3];
350
  int              result;
351
352
  /* predict and decode motion vector */
353
  pmv[0] = &motion[0];
354
  if (y == 0) {
355 82dd7d0d Nick Kurshev
    pmv[1] =
356 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
357
  }
358 82dd7d0d Nick Kurshev
  else {
359
    pmv[1] = &motion[(x / 8) + 2];
360
    pmv[2] = &motion[(x / 8) + 4];
361
  }
362 be8ffec9 Nick Kurshev
363 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
364 be8ffec9 Nick Kurshev
365
  if (result != 0)
366
    return result;
367
368 82dd7d0d Nick Kurshev
  motion[0].x                =
369
  motion[(x / 8) + 2].x        =
370 be8ffec9 Nick Kurshev
  motion[(x / 8) + 3].x        = mv.x;
371 82dd7d0d Nick Kurshev
  motion[0].y                =
372
  motion[(x / 8) + 2].y        =
373 be8ffec9 Nick Kurshev
  motion[(x / 8) + 3].y        = mv.y;
374 b739d676 Michael Niedermayer
  
375
  if(y + (mv.y >> 1)<0)
376
     mv.y= 0;
377
  if(x + (mv.x >> 1)<0)
378
     mv.x= 0;
379
380
#if 0
381
  int w= (s->width+15)&~15;
382
  int h= (s->height+15)&~15;
383
  if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
384
      printf("%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
385
#endif
386
 
387 be8ffec9 Nick Kurshev
  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
388
  dst = current;
389
390 eb4b3dd3 Zdenek Kabelac
  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
391 be8ffec9 Nick Kurshev
392
  return 0;
393
}
394
395 59fcece9 Mike Melanson
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
396 be8ffec9 Nick Kurshev
                                  uint8_t *current, uint8_t *previous, int pitch,
397
                                  svq1_pmv_t *motion,int x, int y) {
398
  uint8_t    *src;
399
  uint8_t    *dst;
400
  svq1_pmv_t  mv;
401
  svq1_pmv_t *pmv[4];
402
  int              i, result;
403
404
  /* predict and decode motion vector (0) */
405
  pmv[0] = &motion[0];
406
  if (y == 0) {
407 82dd7d0d Nick Kurshev
    pmv[1] =
408 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
409
  }
410 82dd7d0d Nick Kurshev
  else {
411
    pmv[1] = &motion[(x / 8) + 2];
412
    pmv[2] = &motion[(x / 8) + 4];
413
  }
414 be8ffec9 Nick Kurshev
415 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
416 be8ffec9 Nick Kurshev
417
  if (result != 0)
418
    return result;
419
420
  /* predict and decode motion vector (1) */
421
  pmv[0] = &mv;
422
  if (y == 0) {
423 82dd7d0d Nick Kurshev
    pmv[1] =
424 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
425
  }
426 82dd7d0d Nick Kurshev
  else {
427
    pmv[1] = &motion[(x / 8) + 3];
428
  }
429
  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
430 be8ffec9 Nick Kurshev
431
  if (result != 0)
432
    return result;
433
434
  /* predict and decode motion vector (2) */
435
  pmv[1] = &motion[0];
436
  pmv[2] = &motion[(x / 8) + 1];
437
438 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
439 be8ffec9 Nick Kurshev
440
  if (result != 0)
441
    return result;
442
443
  /* predict and decode motion vector (3) */
444
  pmv[2] = &motion[(x / 8) + 2];
445
  pmv[3] = &motion[(x / 8) + 3];
446
447 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
448 be8ffec9 Nick Kurshev
449
  if (result != 0)
450
    return result;
451
452
  /* form predictions */
453
  for (i=0; i < 4; i++) {
454 b739d676 Michael Niedermayer
    int mvx= pmv[i]->x + (i&1)*16;
455
    int mvy= pmv[i]->y + (i>>1)*16;
456
  
457
    ///XXX /FIXME cliping or padding?
458
    if(y + (mvy >> 1)<0)
459
       mvy= 0;
460
    if(x + (mvx >> 1)<0)
461
       mvx= 0;
462
463
#if 0
464
  int w= (s->width+15)&~15;
465
  int h= (s->height+15)&~15;
466
  if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
467
      printf("%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
468
#endif
469
    src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
470 be8ffec9 Nick Kurshev
    dst = current;
471 b739d676 Michael Niedermayer
    
472
    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
473 be8ffec9 Nick Kurshev
474
    /* select next block */
475
    if (i & 1) {
476
      current  += 8*(pitch - 1);
477
    } else {
478
      current  += 8;
479
    }
480
  }
481
482
  return 0;
483
}
484
485 59fcece9 Mike Melanson
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
486 be8ffec9 Nick Kurshev
                        uint8_t *current, uint8_t *previous, int pitch,
487
                        svq1_pmv_t *motion, int x, int y) {
488
  uint32_t block_type;
489
  int           result = 0;
490
491
  /* get block type */
492 59fcece9 Mike Melanson
  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
493 be8ffec9 Nick Kurshev
494
  /* reset motion vectors */
495
  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
496 82dd7d0d Nick Kurshev
    motion[0].x                  =
497
    motion[0].y                  =
498
    motion[(x / 8) + 2].x =
499
    motion[(x / 8) + 2].y =
500
    motion[(x / 8) + 3].x =
501 be8ffec9 Nick Kurshev
    motion[(x / 8) + 3].y = 0;
502
  }
503
504
  switch (block_type) {
505
  case SVQ1_BLOCK_SKIP:
506 82dd7d0d Nick Kurshev
    svq1_skip_block (current, previous, pitch, x, y);
507 be8ffec9 Nick Kurshev
    break;
508
509
  case SVQ1_BLOCK_INTER:
510 eb4b3dd3 Zdenek Kabelac
    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
511 be8ffec9 Nick Kurshev
512
    if (result != 0)
513
    {
514
#ifdef DEBUG_SVQ1
515 82dd7d0d Nick Kurshev
    printf("Error in svq1_motion_inter_block %i\n",result);
516 be8ffec9 Nick Kurshev
#endif
517
      break;
518
    }
519 82dd7d0d Nick Kurshev
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
520 be8ffec9 Nick Kurshev
    break;
521
522
  case SVQ1_BLOCK_INTER_4V:
523 eb4b3dd3 Zdenek Kabelac
    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
524 be8ffec9 Nick Kurshev
525
    if (result != 0)
526
    {
527
#ifdef DEBUG_SVQ1
528 82dd7d0d Nick Kurshev
    printf("Error in svq1_motion_inter_4v_block %i\n",result);
529 be8ffec9 Nick Kurshev
#endif
530
      break;
531
    }
532 82dd7d0d Nick Kurshev
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
533 be8ffec9 Nick Kurshev
    break;
534
535
  case SVQ1_BLOCK_INTRA:
536 82dd7d0d Nick Kurshev
    result = svq1_decode_block_intra (bitbuf, current, pitch);
537 be8ffec9 Nick Kurshev
    break;
538
  }
539
540
  return result;
541
}
542
543
/* standard video sizes */
544 82dd7d0d Nick Kurshev
static struct { int width; int height; } svq1_frame_size_table[8] = {
545 be8ffec9 Nick Kurshev
  { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
546
  { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
547
};
548
549 59fcece9 Mike Melanson
static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
550
  int i;
551
552
  for (i=0; i < length; i++) {
553
    value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
554
  }
555
556
  return value;
557
}
558
559
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
560
                                         int width, int height, int value) {
561
  int x, y;
562
563
  for (y=0; y < height; y++) {
564
    for (x=0; x < width; x++) {
565
      value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
566
    }
567
568
    pixels += pitch;
569
  }
570
571
  return value;
572
}
573
574
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
575
  uint8_t seed;
576
  int     i;
577
578
  out[0] = get_bits (bitbuf, 8);
579
580
  seed = string_table[out[0]];
581
582
  for (i=1; i < out[0]; i++) {
583
    out[i] = get_bits (bitbuf, 8) ^ seed;
584
    seed   = string_table[out[i] ^ seed];
585
  }
586
}
587
588
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
589 be8ffec9 Nick Kurshev
  int frame_size_code;
590 59fcece9 Mike Melanson
  int temporal_reference;
591 be8ffec9 Nick Kurshev
592 59fcece9 Mike Melanson
  temporal_reference = get_bits (bitbuf, 8);
593 be8ffec9 Nick Kurshev
594
  /* frame type */
595 760acb18 Michael Niedermayer
  s->pict_type= get_bits (bitbuf, 2)+1;
596
  if(s->pict_type==4) 
597
      return -1;
598 b739d676 Michael Niedermayer
      
599 760acb18 Michael Niedermayer
  if (s->pict_type == I_TYPE) {
600 be8ffec9 Nick Kurshev
601
    /* unknown fields */
602
    if (s->f_code == 0x50 || s->f_code == 0x60) {
603 59fcece9 Mike Melanson
      int csum = get_bits (bitbuf, 16);
604
605
      csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
606
607
//      printf ("%s checksum (%02x) for packet data\n",
608
//              (csum == 0) ? "correct" : "incorrect", csum);
609 be8ffec9 Nick Kurshev
    }
610
611
    if ((s->f_code ^ 0x10) >= 0x50) {
612 59fcece9 Mike Melanson
      char msg[256];
613
614
      svq1_parse_string (bitbuf, (char *) msg);
615
616
      printf ("embedded message: \"%s\"\n", (char *) msg);
617 be8ffec9 Nick Kurshev
    }
618
619 0c938bd1 Alex Beregszaszi
    skip_bits (bitbuf, 2);
620
    skip_bits (bitbuf, 2);
621
    skip_bits1 (bitbuf);
622 be8ffec9 Nick Kurshev
623
    /* load frame size */
624
    frame_size_code = get_bits (bitbuf, 3);
625
626
    if (frame_size_code == 7) {
627
      /* load width, height (12 bits each) */
628
      s->width = get_bits (bitbuf, 12);
629
      s->height = get_bits (bitbuf, 12);
630
631
      if (!s->width || !s->height)
632
        return -1;
633
    } else {
634
      /* get width, height from table */
635 82dd7d0d Nick Kurshev
      s->width = svq1_frame_size_table[frame_size_code].width;
636
      s->height = svq1_frame_size_table[frame_size_code].height;
637 be8ffec9 Nick Kurshev
    }
638
  }
639
640
  /* unknown fields */
641
  if (get_bits (bitbuf, 1) == 1) {
642 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
643
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
644 be8ffec9 Nick Kurshev
645
    if (get_bits (bitbuf, 2) != 0)
646
      return -1;
647
  }
648
649
  if (get_bits (bitbuf, 1) == 1) {
650 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);
651
    skip_bits (bitbuf, 4);
652
    skip_bits1 (bitbuf);
653
    skip_bits (bitbuf, 2);
654 be8ffec9 Nick Kurshev
655
    while (get_bits (bitbuf, 1) == 1) {
656 0c938bd1 Alex Beregszaszi
      skip_bits (bitbuf, 8);
657 be8ffec9 Nick Kurshev
    }
658
  }
659
  
660
  return 0;
661
}
662
663
static int svq1_decode_frame(AVCodecContext *avctx, 
664
                             void *data, int *data_size,
665 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
666 be8ffec9 Nick Kurshev
{
667
  MpegEncContext *s=avctx->priv_data;
668
  uint8_t      *current, *previous;
669
  int                result, i, x, y, width, height;
670 492cd3a9 Michael Niedermayer
  AVFrame *pict = data; 
671 be8ffec9 Nick Kurshev
672
  /* initialize bit buffer */
673 68f593b4 Michael Niedermayer
  init_get_bits(&s->gb,buf,buf_size*8);
674 be8ffec9 Nick Kurshev
675
  /* decode frame header */
676
  s->f_code = get_bits (&s->gb, 22);
677
678
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
679
    return -1;
680
681
  /* swap some header bytes (why?) */
682
  if (s->f_code != 0x20) {
683
    uint32_t *src = (uint32_t *) (buf + 4);
684
685
    for (i=0; i < 4; i++) {
686
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
687
    }
688
  }
689
690 82dd7d0d Nick Kurshev
  result = svq1_decode_frame_header (&s->gb, s);
691 be8ffec9 Nick Kurshev
692
  if (result != 0)
693
  {
694
#ifdef DEBUG_SVQ1
695 82dd7d0d Nick Kurshev
    printf("Error in svq1_decode_frame_header %i\n",result);
696 be8ffec9 Nick Kurshev
#endif
697
    return result;
698
  }
699 bc6d7776 Michael Niedermayer
  
700 e5ab4fdd Michael Niedermayer
  //FIXME this avoids some confusion for "B frames" without 2 references
701
  //this should be removed after libavcodec can handle more flaxible picture types & ordering
702 b536d0aa Michael Niedermayer
  if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
703 e5ab4fdd Michael Niedermayer
  
704 bc6d7776 Michael Niedermayer
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
705 be8ffec9 Nick Kurshev
706 1e491e29 Michael Niedermayer
  if(MPV_frame_start(s, avctx) < 0)
707
      return -1;
708
709 be8ffec9 Nick Kurshev
  /* decode y, u and v components */
710
  for (i=0; i < 3; i++) {
711 760acb18 Michael Niedermayer
    int linesize;
712 be8ffec9 Nick Kurshev
    if (i == 0) {
713 82dd7d0d Nick Kurshev
      width  = (s->width+15)&~15;
714
      height = (s->height+15)&~15;
715 760acb18 Michael Niedermayer
      linesize= s->linesize;
716 be8ffec9 Nick Kurshev
    } else {
717 22b13d5b Michael Niedermayer
      if(s->flags&CODEC_FLAG_GRAY) break;
718 82dd7d0d Nick Kurshev
      width  = (s->width/4+15)&~15;
719
      height = (s->height/4+15)&~15;
720 760acb18 Michael Niedermayer
      linesize= s->uvlinesize;
721 be8ffec9 Nick Kurshev
    }
722
723 1e491e29 Michael Niedermayer
    current  = s->current_picture.data[i];
724 be8ffec9 Nick Kurshev
725 760acb18 Michael Niedermayer
    if(s->pict_type==B_TYPE){
726 1e491e29 Michael Niedermayer
        previous = s->next_picture.data[i];
727 760acb18 Michael Niedermayer
    }else{
728 1e491e29 Michael Niedermayer
        previous = s->last_picture.data[i];
729 760acb18 Michael Niedermayer
    }
730
731
    if (s->pict_type == I_TYPE) {
732 be8ffec9 Nick Kurshev
      /* keyframe */
733
      for (y=0; y < height; y+=16) {
734
        for (x=0; x < width; x+=16) {
735 760acb18 Michael Niedermayer
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
736 be8ffec9 Nick Kurshev
          if (result != 0)
737
          {
738
#ifdef DEBUG_SVQ1
739 82dd7d0d Nick Kurshev
            printf("Error in svq1_decode_block %i (keyframe)\n",result);
740 be8ffec9 Nick Kurshev
#endif
741
            return result;
742
          }
743
        }
744 760acb18 Michael Niedermayer
        current += 16*linesize;
745 be8ffec9 Nick Kurshev
      }
746
    } else {
747 760acb18 Michael Niedermayer
      svq1_pmv_t pmv[width/8+3];
748 be8ffec9 Nick Kurshev
      /* delta frame */
749 760acb18 Michael Niedermayer
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
750 be8ffec9 Nick Kurshev
751
      for (y=0; y < height; y+=16) {
752
        for (x=0; x < width; x+=16) {
753 eb4b3dd3 Zdenek Kabelac
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
754
                                            linesize, pmv, x, y);
755 be8ffec9 Nick Kurshev
          if (result != 0)
756
          {
757
#ifdef DEBUG_SVQ1
758 82dd7d0d Nick Kurshev
    printf("Error in svq1_decode_delta_block %i\n",result);
759 be8ffec9 Nick Kurshev
#endif
760
            return result;
761
          }
762
        }
763
764 760acb18 Michael Niedermayer
        pmv[0].x =
765
        pmv[0].y = 0;
766 be8ffec9 Nick Kurshev
767 760acb18 Michael Niedermayer
        current += 16*linesize;
768 be8ffec9 Nick Kurshev
      }
769
    }
770
  }
771 1e491e29 Michael Niedermayer
  
772 492cd3a9 Michael Niedermayer
  *pict = *(AVFrame*)&s->current_picture;
773 760acb18 Michael Niedermayer
774 1e491e29 Michael Niedermayer
775
  MPV_frame_end(s);
776
  
777 492cd3a9 Michael Niedermayer
  *data_size=sizeof(AVFrame);
778 bc6d7776 Michael Niedermayer
  return buf_size;
779 be8ffec9 Nick Kurshev
}
780
781
static int svq1_decode_init(AVCodecContext *avctx)
782
{
783
    MpegEncContext *s = avctx->priv_data;
784 59fcece9 Mike Melanson
    int i;
785 ce23c668 Alex Beregszaszi
786 be8ffec9 Nick Kurshev
    s->avctx = avctx;
787
    s->width = (avctx->width+3)&~3;
788
    s->height = (avctx->height+3)&~3;
789
    s->codec_id= avctx->codec->id;
790
    avctx->pix_fmt = PIX_FMT_YUV410P;
791 4e00e76b Michael Niedermayer
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
792 22b13d5b Michael Niedermayer
    s->flags= avctx->flags;
793 760acb18 Michael Niedermayer
    if (MPV_common_init(s) < 0) return -1;
794 59fcece9 Mike Melanson
795
    init_vlc(&svq1_block_type, 2, 4,
796
        &svq1_block_type_vlc[0][1], 2, 1,
797
        &svq1_block_type_vlc[0][0], 2, 1);
798
799
    init_vlc(&svq1_motion_component, 7, 65,
800
        &svq1_motion_component_vlc[0][1], 4, 2,
801
        &svq1_motion_component_vlc[0][0], 4, 2);
802
803
    for (i = 0; i < 6; i++) {
804
        init_vlc(&svq1_intra_multistage[i], 3, 8,
805
            &svq1_intra_multistage_vlc[i][0][1], 2, 1,
806
            &svq1_intra_multistage_vlc[i][0][0], 2, 1);
807
        init_vlc(&svq1_inter_multistage[i], 3, 8,
808
            &svq1_inter_multistage_vlc[i][0][1], 2, 1,
809
            &svq1_inter_multistage_vlc[i][0][0], 2, 1);
810
    }
811
812
    init_vlc(&svq1_intra_mean, 8, 256,
813
        &svq1_intra_mean_vlc[0][1], 4, 2,
814
        &svq1_intra_mean_vlc[0][0], 4, 2);
815
816
    init_vlc(&svq1_inter_mean, 9, 512,
817
        &svq1_inter_mean_vlc[0][1], 4, 2,
818
        &svq1_inter_mean_vlc[0][0], 4, 2);
819
820 be8ffec9 Nick Kurshev
    return 0;
821
}
822
823
static int svq1_decode_end(AVCodecContext *avctx)
824
{
825
    MpegEncContext *s = avctx->priv_data;
826
827
    MPV_common_end(s);
828
    return 0;
829
}
830
831
AVCodec svq1_decoder = {
832
    "svq1",
833
    CODEC_TYPE_VIDEO,
834
    CODEC_ID_SVQ1,
835
    sizeof(MpegEncContext),
836
    svq1_decode_init,
837
    NULL,
838
    svq1_decode_end,
839 760acb18 Michael Niedermayer
    svq1_decode_frame,
840
    CODEC_CAP_DR1,
841 7a06ff14 Michael Niedermayer
    .flush= ff_mpeg_flush,
842 be8ffec9 Nick Kurshev
};