← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/svq1.c

  • Committer: Bazaar Package Importer
  • Author(s): Christian Marillat
  • Date: 2004-08-29 10:53:42 UTC
  • Revision ID: james.westby@ubuntu.com-20040829105342-qgmnry37eadfkoxx
Tags: upstream-1.1.3
Import upstream version 1.1.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/svq1.c
 
1
/*
 
2
 * 
 
3
 * Copyright (C) 2002 the xine project
 
4
 * Copyright (C) 2002 the ffmpeg project
 
5
 * 
 
6
 * 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
 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
 
21
 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
 
22
 *
 
23
 */
 
24
 
 
25
/**
 
26
 * @file svq1.c
 
27
 * Sorenson Vector Quantizer #1 (SVQ1) video decoder.
 
28
 */
 
29
 
 
30
 
 
31
//#define DEBUG_SVQ1
 
32
#include <stdio.h>
 
33
#include <stdlib.h>
 
34
#include <string.h>
 
35
#include <unistd.h>
 
36
 
 
37
#include "common.h"
 
38
#include "avcodec.h"
 
39
#include "dsputil.h"
 
40
#include "mpegvideo.h"
 
41
#include "bswap.h"
 
42
 
 
43
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
 
 
50
#define MEDIAN(a,b,c)   (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
 
51
 
 
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
#include "svq1_cb.h"
 
64
#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
};
 
100
 
 
101
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
};
 
135
 
 
136
#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
 
 
175
#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
      codebook = (const uint32_t *) cbook[level];\
 
203
      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
 
 
211
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 
212
  uint32_t    bit_cache;
 
213
  uint8_t    *list[63];
 
214
  uint32_t   *dst;
 
215
  const uint32_t *codebook;
 
216
  int         entries[6];
 
217
  int         i, j, m, n;
 
218
  int         mean, stages;
 
219
  unsigned    x, y, width, height, level;
 
220
  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
    SVQ1_PROCESS_VECTOR();
 
228
 
 
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
    stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
 
236
 
 
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
    printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
 
247
#endif
 
248
      return -1;        /* invalid vector */
 
249
    }
 
250
 
 
251
    mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
 
252
 
 
253
    if (stages == 0) {
 
254
      for (y=0; y < height; y++) {
 
255
        memset (&dst[y*(pitch / 4)], mean, width);
 
256
      }
 
257
    } else {
 
258
      SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
 
259
      SVQ1_DO_CODEBOOK_INTRA()
 
260
    }
 
261
  }
 
262
 
 
263
  return 0;
 
264
}
 
265
 
 
266
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 
267
  uint32_t    bit_cache;
 
268
  uint8_t    *list[63];
 
269
  uint32_t   *dst;
 
270
  const uint32_t *codebook;
 
271
  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
 
 
277
  /* initialize list for breadth first processing of vectors */
 
278
  list[0] = pixels;
 
279
 
 
280
  /* recursively process vector */
 
281
  for (i=0, m=1, n=1, level=5; i < n; i++) {
 
282
    SVQ1_PROCESS_VECTOR();
 
283
 
 
284
    /* destination address and vector size */
 
285
    dst = (uint32_t *) list[i];
 
286
    width = 1 << ((4 + level) /2);
 
287
    height = 1 << ((3 + level) /2);
 
288
 
 
289
    /* get number of stages (-1 skips vector, 0 for mean only) */
 
290
    stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
 
291
 
 
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
    }
 
300
 
 
301
    mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
 
302
 
 
303
    SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
 
304
    SVQ1_DO_CODEBOOK_NONINTRA()
 
305
  }
 
306
  return 0;
 
307
}
 
308
 
 
309
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
 
310
  int         diff;
 
311
  int         i;
 
312
 
 
313
  for (i=0; i < 2; i++) {
 
314
 
 
315
    /* get motion code */
 
316
    diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
 
317
 
 
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
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
 
329
  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
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
 
344
                               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
    pmv[1] =
 
356
    pmv[2] = pmv[0];
 
357
  }
 
358
  else {
 
359
    pmv[1] = &motion[(x / 8) + 2];
 
360
    pmv[2] = &motion[(x / 8) + 4];
 
361
  }
 
362
 
 
363
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
 
364
 
 
365
  if (result != 0)
 
366
    return result;
 
367
 
 
368
  motion[0].x           =
 
369
  motion[(x / 8) + 2].x =
 
370
  motion[(x / 8) + 3].x = mv.x;
 
371
  motion[0].y           =
 
372
  motion[(x / 8) + 2].y =
 
373
  motion[(x / 8) + 3].y = mv.y;
 
374
  
 
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
  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
 
388
  dst = current;
 
389
 
 
390
  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
 
391
 
 
392
  return 0;
 
393
}
 
394
 
 
395
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
 
396
                                  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
    pmv[1] =
 
408
    pmv[2] = pmv[0];
 
409
  }
 
410
  else {
 
411
    pmv[1] = &motion[(x / 8) + 2];
 
412
    pmv[2] = &motion[(x / 8) + 4];
 
413
  }
 
414
 
 
415
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
 
416
 
 
417
  if (result != 0)
 
418
    return result;
 
419
 
 
420
  /* predict and decode motion vector (1) */
 
421
  pmv[0] = &mv;
 
422
  if (y == 0) {
 
423
    pmv[1] =
 
424
    pmv[2] = pmv[0];
 
425
  }
 
426
  else {
 
427
    pmv[1] = &motion[(x / 8) + 3];
 
428
  }
 
429
  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
 
430
 
 
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
  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
 
439
 
 
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
  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
 
448
 
 
449
  if (result != 0)
 
450
    return result;
 
451
 
 
452
  /* form predictions */
 
453
  for (i=0; i < 4; i++) {
 
454
    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
    dst = current;
 
471
    
 
472
    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
 
473
 
 
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
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
 
486
                        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
  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
 
493
 
 
494
  /* reset motion vectors */
 
495
  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
 
496
    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
    motion[(x / 8) + 3].y = 0;
 
502
  }
 
503
 
 
504
  switch (block_type) {
 
505
  case SVQ1_BLOCK_SKIP:
 
506
    svq1_skip_block (current, previous, pitch, x, y);
 
507
    break;
 
508
 
 
509
  case SVQ1_BLOCK_INTER:
 
510
    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
 
511
 
 
512
    if (result != 0)
 
513
    {
 
514
#ifdef DEBUG_SVQ1
 
515
    printf("Error in svq1_motion_inter_block %i\n",result);
 
516
#endif
 
517
      break;
 
518
    }
 
519
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 
520
    break;
 
521
 
 
522
  case SVQ1_BLOCK_INTER_4V:
 
523
    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
 
524
 
 
525
    if (result != 0)
 
526
    {
 
527
#ifdef DEBUG_SVQ1
 
528
    printf("Error in svq1_motion_inter_4v_block %i\n",result);
 
529
#endif
 
530
      break;
 
531
    }
 
532
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
 
533
    break;
 
534
 
 
535
  case SVQ1_BLOCK_INTRA:
 
536
    result = svq1_decode_block_intra (bitbuf, current, pitch);
 
537
    break;
 
538
  }
 
539
 
 
540
  return result;
 
541
}
 
542
 
 
543
/* standard video sizes */
 
544
static struct { int width; int height; } svq1_frame_size_table[8] = {
 
545
  { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
 
546
  { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
 
547
};
 
548
 
 
549
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
  int frame_size_code;
 
590
  int temporal_reference;
 
591
 
 
592
  temporal_reference = get_bits (bitbuf, 8);
 
593
 
 
594
  /* frame type */
 
595
  s->pict_type= get_bits (bitbuf, 2)+1;
 
596
  if(s->pict_type==4) 
 
597
      return -1;
 
598
      
 
599
  if (s->pict_type == I_TYPE) {
 
600
 
 
601
    /* unknown fields */
 
602
    if (s->f_code == 0x50 || s->f_code == 0x60) {
 
603
      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
    }
 
610
 
 
611
    if ((s->f_code ^ 0x10) >= 0x50) {
 
612
      char msg[256];
 
613
 
 
614
      svq1_parse_string (bitbuf, (char *) msg);
 
615
 
 
616
      printf ("embedded message: \"%s\"\n", (char *) msg);
 
617
    }
 
618
 
 
619
    skip_bits (bitbuf, 2);
 
620
    skip_bits (bitbuf, 2);
 
621
    skip_bits1 (bitbuf);
 
622
 
 
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
      s->width = svq1_frame_size_table[frame_size_code].width;
 
636
      s->height = svq1_frame_size_table[frame_size_code].height;
 
637
    }
 
638
  }
 
639
 
 
640
  /* unknown fields */
 
641
  if (get_bits (bitbuf, 1) == 1) {
 
642
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
 
643
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
 
644
 
 
645
    if (get_bits (bitbuf, 2) != 0)
 
646
      return -1;
 
647
  }
 
648
 
 
649
  if (get_bits (bitbuf, 1) == 1) {
 
650
    skip_bits1 (bitbuf);
 
651
    skip_bits (bitbuf, 4);
 
652
    skip_bits1 (bitbuf);
 
653
    skip_bits (bitbuf, 2);
 
654
 
 
655
    while (get_bits (bitbuf, 1) == 1) {
 
656
      skip_bits (bitbuf, 8);
 
657
    }
 
658
  }
 
659
  
 
660
  return 0;
 
661
}
 
662
 
 
663
static int svq1_decode_frame(AVCodecContext *avctx, 
 
664
                             void *data, int *data_size,
 
665
                             uint8_t *buf, int buf_size)
 
666
{
 
667
  MpegEncContext *s=avctx->priv_data;
 
668
  uint8_t      *current, *previous;
 
669
  int           result, i, x, y, width, height;
 
670
  AVFrame *pict = data; 
 
671
 
 
672
  /* initialize bit buffer */
 
673
  init_get_bits(&s->gb,buf,buf_size*8);
 
674
 
 
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
  result = svq1_decode_frame_header (&s->gb, s);
 
691
 
 
692
  if (result != 0)
 
693
  {
 
694
#ifdef DEBUG_SVQ1
 
695
    printf("Error in svq1_decode_frame_header %i\n",result);
 
696
#endif
 
697
    return result;
 
698
  }
 
699
  
 
700
  //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
  if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
 
703
  
 
704
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
 
705
 
 
706
  if(MPV_frame_start(s, avctx) < 0)
 
707
      return -1;
 
708
 
 
709
  /* decode y, u and v components */
 
710
  for (i=0; i < 3; i++) {
 
711
    int linesize;
 
712
    if (i == 0) {
 
713
      width  = (s->width+15)&~15;
 
714
      height = (s->height+15)&~15;
 
715
      linesize= s->linesize;
 
716
    } else {
 
717
      if(s->flags&CODEC_FLAG_GRAY) break;
 
718
      width  = (s->width/4+15)&~15;
 
719
      height = (s->height/4+15)&~15;
 
720
      linesize= s->uvlinesize;
 
721
    }
 
722
 
 
723
    current  = s->current_picture.data[i];
 
724
 
 
725
    if(s->pict_type==B_TYPE){
 
726
        previous = s->next_picture.data[i];
 
727
    }else{
 
728
        previous = s->last_picture.data[i];
 
729
    }
 
730
 
 
731
    if (s->pict_type == I_TYPE) {
 
732
      /* keyframe */
 
733
      for (y=0; y < height; y+=16) {
 
734
        for (x=0; x < width; x+=16) {
 
735
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
 
736
          if (result != 0)
 
737
          {
 
738
#ifdef DEBUG_SVQ1
 
739
            printf("Error in svq1_decode_block %i (keyframe)\n",result);
 
740
#endif
 
741
            return result;
 
742
          }
 
743
        }
 
744
        current += 16*linesize;
 
745
      }
 
746
    } else {
 
747
      svq1_pmv_t pmv[width/8+3];
 
748
      /* delta frame */
 
749
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
 
750
 
 
751
      for (y=0; y < height; y+=16) {
 
752
        for (x=0; x < width; x+=16) {
 
753
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
 
754
                                            linesize, pmv, x, y);
 
755
          if (result != 0)
 
756
          {
 
757
#ifdef DEBUG_SVQ1
 
758
    printf("Error in svq1_decode_delta_block %i\n",result);
 
759
#endif
 
760
            return result;
 
761
          }
 
762
        }
 
763
 
 
764
        pmv[0].x =
 
765
        pmv[0].y = 0;
 
766
 
 
767
        current += 16*linesize;
 
768
      }
 
769
    }
 
770
  }
 
771
  
 
772
  *pict = *(AVFrame*)&s->current_picture;
 
773
 
 
774
 
 
775
  MPV_frame_end(s);
 
776
  
 
777
  *data_size=sizeof(AVFrame);
 
778
  return buf_size;
 
779
}
 
780
 
 
781
static int svq1_decode_init(AVCodecContext *avctx)
 
782
{
 
783
    MpegEncContext *s = avctx->priv_data;
 
784
    int i;
 
785
 
 
786
    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
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
 
792
    s->flags= avctx->flags;
 
793
    if (MPV_common_init(s) < 0) return -1;
 
794
 
 
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
    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
    svq1_decode_frame,
 
840
    CODEC_CAP_DR1,
 
841
    .flush= ff_mpeg_flush,
 
842
};