Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ f20f8a8b

History | View | Annotate | Download (22.9 KB)

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
      av_log(s->avctx, AV_LOG_INFO, "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
    MPV_decode_defaults(s);
787

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

    
796
    init_vlc(&svq1_block_type, 2, 4,
797
        &svq1_block_type_vlc[0][1], 2, 1,
798
        &svq1_block_type_vlc[0][0], 2, 1);
799

    
800
    init_vlc(&svq1_motion_component, 7, 65,
801
        &svq1_motion_component_vlc[0][1], 4, 2,
802
        &svq1_motion_component_vlc[0][0], 4, 2);
803

    
804
    for (i = 0; i < 6; i++) {
805
        init_vlc(&svq1_intra_multistage[i], 3, 8,
806
            &svq1_intra_multistage_vlc[i][0][1], 2, 1,
807
            &svq1_intra_multistage_vlc[i][0][0], 2, 1);
808
        init_vlc(&svq1_inter_multistage[i], 3, 8,
809
            &svq1_inter_multistage_vlc[i][0][1], 2, 1,
810
            &svq1_inter_multistage_vlc[i][0][0], 2, 1);
811
    }
812

    
813
    init_vlc(&svq1_intra_mean, 8, 256,
814
        &svq1_intra_mean_vlc[0][1], 4, 2,
815
        &svq1_intra_mean_vlc[0][0], 4, 2);
816

    
817
    init_vlc(&svq1_inter_mean, 9, 512,
818
        &svq1_inter_mean_vlc[0][1], 4, 2,
819
        &svq1_inter_mean_vlc[0][0], 4, 2);
820

    
821
    return 0;
822
}
823

    
824
static int svq1_decode_end(AVCodecContext *avctx)
825
{
826
    MpegEncContext *s = avctx->priv_data;
827

    
828
    MPV_common_end(s);
829
    return 0;
830
}
831

    
832
AVCodec svq1_decoder = {
833
    "svq1",
834
    CODEC_TYPE_VIDEO,
835
    CODEC_ID_SVQ1,
836
    sizeof(MpegEncContext),
837
    svq1_decode_init,
838
    NULL,
839
    svq1_decode_end,
840
    svq1_decode_frame,
841
    CODEC_CAP_DR1,
842
    .flush= ff_mpeg_flush,
843
};