← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/svq1dec.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/svq1dec.c
 
1
/*
 
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
 * @file svq1.c
 
30
 * 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
 
 
41
#include "svq1.h"
 
42
 
 
43
#undef NDEBUG
 
44
#include <assert.h>
 
45
 
 
46
extern const uint8_t mvtab[33][2];
 
47
 
 
48
static VLC svq1_block_type;
 
49
static VLC svq1_motion_component;
 
50
static VLC svq1_intra_multistage[6];
 
51
static VLC svq1_inter_multistage[6];
 
52
static VLC svq1_intra_mean;
 
53
static VLC svq1_inter_mean;
 
54
 
 
55
/* motion vector (prediction) */
 
56
typedef struct svq1_pmv_s {
 
57
  int           x;
 
58
  int           y;
 
59
} svq1_pmv_t;
 
60
 
 
61
static const uint16_t checksum_table[256] = {
 
62
  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
 
63
  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
 
64
  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
 
65
  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
 
66
  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
 
67
  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
 
68
  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
 
69
  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
 
70
  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
 
71
  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
 
72
  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
 
73
  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
 
74
  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
 
75
  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
 
76
  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
 
77
  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
 
78
  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
 
79
  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
 
80
  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
 
81
  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
 
82
  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
 
83
  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
 
84
  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
 
85
  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
 
86
  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
 
87
  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
 
88
  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
 
89
  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
 
90
  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
 
91
  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
 
92
  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
 
93
  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
 
94
};
 
95
 
 
96
static const uint8_t string_table[256] = {
 
97
  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
 
98
  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
 
99
  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
 
100
  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
 
101
  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
 
102
  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
 
103
  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
 
104
  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
 
105
  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
 
106
  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
 
107
  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
 
108
  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
 
109
  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
 
110
  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
 
111
  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
 
112
  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
 
113
  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
 
114
  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
 
115
  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
 
116
  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
 
117
  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
 
118
  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
 
119
  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
 
120
  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
 
121
  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
 
122
  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
 
123
  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
 
124
  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
 
125
  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
 
126
  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
 
127
  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
 
128
  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
 
129
};
 
130
 
 
131
#define SVQ1_PROCESS_VECTOR()\
 
132
    for (; level > 0; i++) {\
 
133
      /* process next depth */\
 
134
      if (i == m) {\
 
135
        m = n;\
 
136
        if (--level == 0)\
 
137
          break;\
 
138
      }\
 
139
      /* divide block if next bit set */\
 
140
      if (get_bits1 (bitbuf) == 0)\
 
141
        break;\
 
142
      /* add child nodes */\
 
143
      list[n++] = list[i];\
 
144
      list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
 
145
    }
 
146
 
 
147
#define SVQ1_ADD_CODEBOOK()\
 
148
          /* add codebook entries to vector */\
 
149
          for (j=0; j < stages; j++) {\
 
150
            n3  = codebook[entries[j]] ^ 0x80808080;\
 
151
            n1 += ((n3 & 0xFF00FF00) >> 8);\
 
152
            n2 +=  (n3 & 0x00FF00FF);\
 
153
          }\
 
154
\
 
155
          /* clip to [0..255] */\
 
156
          if (n1 & 0xFF00FF00) {\
 
157
            n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 
158
            n1 += 0x7F007F00;\
 
159
            n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 
160
            n1 &= (n3 & 0x00FF00FF);\
 
161
          }\
 
162
\
 
163
          if (n2 & 0xFF00FF00) {\
 
164
            n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 
165
            n2 += 0x7F007F00;\
 
166
            n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
 
167
            n2 &= (n3 & 0x00FF00FF);\
 
168
          }
 
169
 
 
170
#define SVQ1_DO_CODEBOOK_INTRA()\
 
171
      for (y=0; y < height; y++) {\
 
172
        for (x=0; x < (width / 4); x++, codebook++) {\
 
173
        n1 = n4;\
 
174
        n2 = n4;\
 
175
        SVQ1_ADD_CODEBOOK()\
 
176
        /* store result */\
 
177
        dst[x] = (n1 << 8) | n2;\
 
178
        }\
 
179
        dst += (pitch / 4);\
 
180
      }
 
181
 
 
182
#define SVQ1_DO_CODEBOOK_NONINTRA()\
 
183
      for (y=0; y < height; y++) {\
 
184
        for (x=0; x < (width / 4); x++, codebook++) {\
 
185
        n3 = dst[x];\
 
186
        /* add mean value to vector */\
 
187
        n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
 
188
        n2 =  (n3 & 0x00FF00FF)          + n4;\
 
189
        SVQ1_ADD_CODEBOOK()\
 
190
        /* store result */\
 
191
        dst[x] = (n1 << 8) | n2;\
 
192
        }\
 
193
        dst += (pitch / 4);\
 
194
      }
 
195
 
 
196
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
 
197
      codebook = (const uint32_t *) cbook[level];\
 
198
      bit_cache = get_bits (bitbuf, 4*stages);\
 
199
      /* calculate codebook entries for this vector */\
 
200
      for (j=0; j < stages; j++) {\
 
201
        entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
 
202
      }\
 
203
      mean -= (stages * 128);\
 
204
      n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
 
205
 
 
206
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 
207
  uint32_t    bit_cache;
 
208
  uint8_t    *list[63];
 
209
  uint32_t   *dst;
 
210
  const uint32_t *codebook;
 
211
  int         entries[6];
 
212
  int         i, j, m, n;
 
213
  int         mean, stages;
 
214
  unsigned    x, y, width, height, level;
 
215
  uint32_t    n1, n2, n3, n4;
 
216
 
 
217
  /* initialize list for breadth first processing of vectors */
 
218
  list[0] = pixels;
 
219
 
 
220
  /* recursively process vector */
 
221
  for (i=0, m=1, n=1, level=5; i < n; i++) {
 
222
    SVQ1_PROCESS_VECTOR();
 
223
 
 
224
    /* destination address and vector size */
 
225
    dst = (uint32_t *) list[i];
 
226
    width = 1 << ((4 + level) /2);
 
227
    height = 1 << ((3 + level) /2);
 
228
 
 
229
    /* get number of stages (-1 skips vector, 0 for mean only) */
 
230
    stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
 
231
 
 
232
    if (stages == -1) {
 
233
        for (y=0; y < height; y++) {
 
234
          memset (&dst[y*(pitch / 4)], 0, width);
 
235
        }
 
236
      continue;                 /* skip vector */
 
237
    }
 
238
 
 
239
    if ((stages > 0) && (level >= 4)) {
 
240
#ifdef DEBUG_SVQ1
 
241
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
 
242
#endif
 
243
      return -1;        /* invalid vector */
 
244
    }
 
245
 
 
246
    mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
 
247
 
 
248
    if (stages == 0) {
 
249
      for (y=0; y < height; y++) {
 
250
        memset (&dst[y*(pitch / 4)], mean, width);
 
251
      }
 
252
    } else {
 
253
      SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
 
254
      SVQ1_DO_CODEBOOK_INTRA()
 
255
    }
 
256
  }
 
257
 
 
258
  return 0;
 
259
}
 
260
 
 
261
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
 
262
  uint32_t    bit_cache;
 
263
  uint8_t    *list[63];
 
264
  uint32_t   *dst;
 
265
  const uint32_t *codebook;
 
266
  int         entries[6];
 
267
  int         i, j, m, n;
 
268
  int         mean, stages;
 
269
  int         x, y, width, height, level;
 
270
  uint32_t    n1, n2, n3, n4;
 
271
 
 
272
  /* initialize list for breadth first processing of vectors */
 
273
  list[0] = pixels;
 
274
 
 
275
  /* recursively process vector */
 
276
  for (i=0, m=1, n=1, level=5; i < n; i++) {
 
277
    SVQ1_PROCESS_VECTOR();
 
278
 
 
279
    /* destination address and vector size */
 
280
    dst = (uint32_t *) list[i];
 
281
    width = 1 << ((4 + level) /2);
 
282
    height = 1 << ((3 + level) /2);
 
283
 
 
284
    /* get number of stages (-1 skips vector, 0 for mean only) */
 
285
    stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
 
286
 
 
287
    if (stages == -1) continue; /* skip vector */
 
288
 
 
289
    if ((stages > 0) && (level >= 4)) {
 
290
#ifdef DEBUG_SVQ1
 
291
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
 
292
#endif
 
293
      return -1;        /* invalid vector */
 
294
    }
 
295
 
 
296
    mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
 
297
 
 
298
    SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
 
299
    SVQ1_DO_CODEBOOK_NONINTRA()
 
300
  }
 
301
  return 0;
 
302
}
 
303
 
 
304
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
 
305
  int        diff;
 
306
  int        i;
 
307
 
 
308
  for (i=0; i < 2; i++) {
 
309
 
 
310
    /* get motion code */
 
311
    diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
 
312
    if(diff<0)
 
313
        return -1;
 
314
    else if(diff){
 
315
        if(get_bits1(bitbuf)) diff= -diff;
 
316
    }
 
317
 
 
318
    /* add median of motion vector predictors and clip result */
 
319
    if (i == 1)
 
320
      mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
 
321
    else
 
322
      mv->x = ((diff + mid_pred(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
      av_log(s->avctx, AV_LOG_INFO, "%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 clipping 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
      av_log(s->avctx, AV_LOG_INFO, "%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
    av_log(s->avctx, AV_LOG_INFO, "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
    av_log(s->avctx, AV_LOG_INFO, "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
static uint16_t svq1_packet_checksum (const uint8_t *data, const int length, int value) {
 
544
  int i;
 
545
 
 
546
  for (i=0; i < length; i++) {
 
547
    value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
 
548
  }
 
549
 
 
550
  return value;
 
551
}
 
552
 
 
553
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
 
554
  uint8_t seed;
 
555
  int     i;
 
556
 
 
557
  out[0] = get_bits (bitbuf, 8);
 
558
 
 
559
  seed = string_table[out[0]];
 
560
 
 
561
  for (i=1; i <= out[0]; i++) {
 
562
    out[i] = get_bits (bitbuf, 8) ^ seed;
 
563
    seed   = string_table[out[i] ^ seed];
 
564
  }
 
565
}
 
566
 
 
567
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
 
568
  int frame_size_code;
 
569
  int temporal_reference;
 
570
 
 
571
  temporal_reference = get_bits (bitbuf, 8);
 
572
 
 
573
  /* frame type */
 
574
  s->pict_type= get_bits (bitbuf, 2)+1;
 
575
  if(s->pict_type==4)
 
576
      return -1;
 
577
 
 
578
  if (s->pict_type == FF_I_TYPE) {
 
579
 
 
580
    /* unknown fields */
 
581
    if (s->f_code == 0x50 || s->f_code == 0x60) {
 
582
      int csum = get_bits (bitbuf, 16);
 
583
 
 
584
      csum = svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
 
585
 
 
586
//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
 
587
//              (csum == 0) ? "correct" : "incorrect", csum);
 
588
    }
 
589
 
 
590
    if ((s->f_code ^ 0x10) >= 0x50) {
 
591
      uint8_t msg[256];
 
592
 
 
593
      svq1_parse_string (bitbuf, msg);
 
594
 
 
595
      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
 
596
    }
 
597
 
 
598
    skip_bits (bitbuf, 2);
 
599
    skip_bits (bitbuf, 2);
 
600
    skip_bits1 (bitbuf);
 
601
 
 
602
    /* load frame size */
 
603
    frame_size_code = get_bits (bitbuf, 3);
 
604
 
 
605
    if (frame_size_code == 7) {
 
606
      /* load width, height (12 bits each) */
 
607
      s->width = get_bits (bitbuf, 12);
 
608
      s->height = get_bits (bitbuf, 12);
 
609
 
 
610
      if (!s->width || !s->height)
 
611
        return -1;
 
612
    } else {
 
613
      /* get width, height from table */
 
614
      s->width = ff_svq1_frame_size_table[frame_size_code].width;
 
615
      s->height = ff_svq1_frame_size_table[frame_size_code].height;
 
616
    }
 
617
  }
 
618
 
 
619
  /* unknown fields */
 
620
  if (get_bits1 (bitbuf) == 1) {
 
621
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
 
622
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
 
623
 
 
624
    if (get_bits (bitbuf, 2) != 0)
 
625
      return -1;
 
626
  }
 
627
 
 
628
  if (get_bits1 (bitbuf) == 1) {
 
629
    skip_bits1 (bitbuf);
 
630
    skip_bits (bitbuf, 4);
 
631
    skip_bits1 (bitbuf);
 
632
    skip_bits (bitbuf, 2);
 
633
 
 
634
    while (get_bits1 (bitbuf) == 1) {
 
635
      skip_bits (bitbuf, 8);
 
636
    }
 
637
  }
 
638
 
 
639
  return 0;
 
640
}
 
641
 
 
642
static int svq1_decode_frame(AVCodecContext *avctx,
 
643
                             void *data, int *data_size,
 
644
                             const uint8_t *buf, int buf_size)
 
645
{
 
646
  MpegEncContext *s=avctx->priv_data;
 
647
  uint8_t        *current, *previous;
 
648
  int             result, i, x, y, width, height;
 
649
  AVFrame *pict = data;
 
650
 
 
651
  /* initialize bit buffer */
 
652
  init_get_bits(&s->gb,buf,buf_size*8);
 
653
 
 
654
  /* decode frame header */
 
655
  s->f_code = get_bits (&s->gb, 22);
 
656
 
 
657
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
 
658
    return -1;
 
659
 
 
660
  /* swap some header bytes (why?) */
 
661
  if (s->f_code != 0x20) {
 
662
    uint32_t *src = (uint32_t *) (buf + 4);
 
663
 
 
664
    for (i=0; i < 4; i++) {
 
665
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 
666
    }
 
667
  }
 
668
 
 
669
  result = svq1_decode_frame_header (&s->gb, s);
 
670
 
 
671
  if (result != 0)
 
672
  {
 
673
#ifdef DEBUG_SVQ1
 
674
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
 
675
#endif
 
676
    return result;
 
677
  }
 
678
 
 
679
  //FIXME this avoids some confusion for "B frames" without 2 references
 
680
  //this should be removed after libavcodec can handle more flexible picture types & ordering
 
681
  if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
 
682
 
 
683
  if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
 
684
  if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
 
685
     ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
 
686
     || avctx->skip_frame >= AVDISCARD_ALL)
 
687
      return buf_size;
 
688
 
 
689
  if(MPV_frame_start(s, avctx) < 0)
 
690
      return -1;
 
691
 
 
692
  /* decode y, u and v components */
 
693
  for (i=0; i < 3; i++) {
 
694
    int linesize;
 
695
    if (i == 0) {
 
696
      width  = (s->width+15)&~15;
 
697
      height = (s->height+15)&~15;
 
698
      linesize= s->linesize;
 
699
    } else {
 
700
      if(s->flags&CODEC_FLAG_GRAY) break;
 
701
      width  = (s->width/4+15)&~15;
 
702
      height = (s->height/4+15)&~15;
 
703
      linesize= s->uvlinesize;
 
704
    }
 
705
 
 
706
    current  = s->current_picture.data[i];
 
707
 
 
708
    if(s->pict_type==FF_B_TYPE){
 
709
        previous = s->next_picture.data[i];
 
710
    }else{
 
711
        previous = s->last_picture.data[i];
 
712
    }
 
713
 
 
714
    if (s->pict_type == FF_I_TYPE) {
 
715
      /* keyframe */
 
716
      for (y=0; y < height; y+=16) {
 
717
        for (x=0; x < width; x+=16) {
 
718
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
 
719
          if (result != 0)
 
720
          {
 
721
//#ifdef DEBUG_SVQ1
 
722
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
 
723
//#endif
 
724
            return result;
 
725
          }
 
726
        }
 
727
        current += 16*linesize;
 
728
      }
 
729
    } else {
 
730
      svq1_pmv_t pmv[width/8+3];
 
731
      /* delta frame */
 
732
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
 
733
 
 
734
      for (y=0; y < height; y+=16) {
 
735
        for (x=0; x < width; x+=16) {
 
736
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
 
737
                                            linesize, pmv, x, y);
 
738
          if (result != 0)
 
739
          {
 
740
#ifdef DEBUG_SVQ1
 
741
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
 
742
#endif
 
743
            return result;
 
744
          }
 
745
        }
 
746
 
 
747
        pmv[0].x =
 
748
        pmv[0].y = 0;
 
749
 
 
750
        current += 16*linesize;
 
751
      }
 
752
    }
 
753
  }
 
754
 
 
755
  *pict = *(AVFrame*)&s->current_picture;
 
756
 
 
757
 
 
758
  MPV_frame_end(s);
 
759
 
 
760
  *data_size=sizeof(AVFrame);
 
761
  return buf_size;
 
762
}
 
763
 
 
764
static av_cold int svq1_decode_init(AVCodecContext *avctx)
 
765
{
 
766
    MpegEncContext *s = avctx->priv_data;
 
767
    int i;
 
768
 
 
769
    MPV_decode_defaults(s);
 
770
 
 
771
    s->avctx = avctx;
 
772
    s->width = (avctx->width+3)&~3;
 
773
    s->height = (avctx->height+3)&~3;
 
774
    s->codec_id= avctx->codec->id;
 
775
    avctx->pix_fmt = PIX_FMT_YUV410P;
 
776
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
 
777
    s->flags= avctx->flags;
 
778
    if (MPV_common_init(s) < 0) return -1;
 
779
 
 
780
    init_vlc(&svq1_block_type, 2, 4,
 
781
        &ff_svq1_block_type_vlc[0][1], 2, 1,
 
782
        &ff_svq1_block_type_vlc[0][0], 2, 1, 1);
 
783
 
 
784
    init_vlc(&svq1_motion_component, 7, 33,
 
785
        &mvtab[0][1], 2, 1,
 
786
        &mvtab[0][0], 2, 1, 1);
 
787
 
 
788
    for (i = 0; i < 6; i++) {
 
789
        init_vlc(&svq1_intra_multistage[i], 3, 8,
 
790
            &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
 
791
            &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
 
792
        init_vlc(&svq1_inter_multistage[i], 3, 8,
 
793
            &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
 
794
            &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
 
795
    }
 
796
 
 
797
    init_vlc(&svq1_intra_mean, 8, 256,
 
798
        &ff_svq1_intra_mean_vlc[0][1], 4, 2,
 
799
        &ff_svq1_intra_mean_vlc[0][0], 4, 2, 1);
 
800
 
 
801
    init_vlc(&svq1_inter_mean, 9, 512,
 
802
        &ff_svq1_inter_mean_vlc[0][1], 4, 2,
 
803
        &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1);
 
804
 
 
805
    return 0;
 
806
}
 
807
 
 
808
static av_cold int svq1_decode_end(AVCodecContext *avctx)
 
809
{
 
810
    MpegEncContext *s = avctx->priv_data;
 
811
 
 
812
    MPV_common_end(s);
 
813
    return 0;
 
814
}
 
815
 
 
816
 
 
817
AVCodec svq1_decoder = {
 
818
    "svq1",
 
819
    CODEC_TYPE_VIDEO,
 
820
    CODEC_ID_SVQ1,
 
821
    sizeof(MpegEncContext),
 
822
    svq1_decode_init,
 
823
    NULL,
 
824
    svq1_decode_end,
 
825
    svq1_decode_frame,
 
826
    CODEC_CAP_DR1,
 
827
    .flush= ff_mpeg_flush,
 
828
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
 
829
    .long_name= "Sorenson Vector Quantizer 1",
 
830
};