Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ da9c9637

History | View | Annotate | Download (41.7 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 3b64893d Mike Melanson
 * (SVQ1 Decoder)
21 861dfbb5 Nick Kurshev
 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
22 be8ffec9 Nick Kurshev
 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
23
 *
24 3b64893d Mike Melanson
 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
25 be8ffec9 Nick Kurshev
 */
26 983e3246 Michael Niedermayer
27
/**
28
 * @file svq1.c
29 3b64893d Mike Melanson
 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
30
 * For more information of the SVQ1 algorithm, visit:
31
 *   http://www.pcisys.net/~melanson/codecs/
32 983e3246 Michael Niedermayer
 */
33
34 59fcece9 Mike Melanson
35 be8ffec9 Nick Kurshev
//#define DEBUG_SVQ1
36
#include <stdio.h>
37
#include <stdlib.h>
38
#include <string.h>
39
#include <unistd.h>
40 fa2ae822 Michael Niedermayer
#include <limits.h>
41 be8ffec9 Nick Kurshev
42 82dd7d0d Nick Kurshev
#include "common.h"
43 be8ffec9 Nick Kurshev
#include "avcodec.h"
44
#include "dsputil.h"
45
#include "mpegvideo.h"
46 59fcece9 Mike Melanson
#include "bswap.h"
47 be8ffec9 Nick Kurshev
48 fa2ae822 Michael Niedermayer
#undef NDEBUG
49
#include <assert.h>
50
51 5e13a730 Michael Niedermayer
extern const uint8_t mvtab[33][2];
52
53 59fcece9 Mike Melanson
static VLC svq1_block_type;
54
static VLC svq1_motion_component;
55
static VLC svq1_intra_multistage[6];
56
static VLC svq1_inter_multistage[6];
57
static VLC svq1_intra_mean;
58
static VLC svq1_inter_mean;
59 be8ffec9 Nick Kurshev
60
#define SVQ1_BLOCK_SKIP                0
61
#define SVQ1_BLOCK_INTER        1
62
#define SVQ1_BLOCK_INTER_4V        2
63
#define SVQ1_BLOCK_INTRA        3
64
65 3b64893d Mike Melanson
typedef struct SVQ1Context {
66 5e13a730 Michael Niedermayer
    MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independant of MpegEncContext, so this will be removed then (FIXME/XXX)
67 3b64893d Mike Melanson
    AVCodecContext *avctx;
68
    DSPContext dsp;
69
    AVFrame picture;
70 ec6d8af5 Michael Niedermayer
    AVFrame current_picture;
71
    AVFrame last_picture;
72 3b64893d Mike Melanson
    PutBitContext pb;
73
    GetBitContext gb;
74 fa2ae822 Michael Niedermayer
    
75
    PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
76 3b64893d Mike Melanson
77
    int frame_width;
78
    int frame_height;
79
80
    /* Y plane block dimensions */
81
    int y_block_width;
82
    int y_block_height;
83
84
    /* U & V plane (C planes) block dimensions */
85
    int c_block_width;
86
    int c_block_height;
87 5e13a730 Michael Niedermayer
    
88
    uint16_t *mb_type;
89
    uint32_t *dummy;
90
    int16_t (*motion_val8[3])[2];
91
    int16_t (*motion_val16[3])[2];
92 3b64893d Mike Melanson
93 bab97b2f Michael Niedermayer
    int64_t rd_total;
94 3b64893d Mike Melanson
} SVQ1Context;
95
96 be8ffec9 Nick Kurshev
/* motion vector (prediction) */
97
typedef struct svq1_pmv_s {
98
  int                 x;
99
  int                 y;
100
} svq1_pmv_t;
101
102 ce23c668 Alex Beregszaszi
#include "svq1_cb.h"
103 59fcece9 Mike Melanson
#include "svq1_vlc.h"
104
105
static const uint16_t checksum_table[256] = {
106
  0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
107
  0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
108
  0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
109
  0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
110
  0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
111
  0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
112
  0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
113
  0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
114
  0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
115
  0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
116
  0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
117
  0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
118
  0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
119
  0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
120
  0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
121
  0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
122
  0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
123
  0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
124
  0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
125
  0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
126
  0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
127
  0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
128
  0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
129
  0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
130
  0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
131
  0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
132
  0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
133
  0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
134
  0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
135
  0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
136
  0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
137
  0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
138 be8ffec9 Nick Kurshev
};
139
140 59fcece9 Mike Melanson
static const uint8_t string_table[256] = {
141
  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
142
  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
143
  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
144
  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
145
  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
146
  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
147
  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
148
  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
149
  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
150
  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
151
  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
152
  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
153
  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
154
  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
155
  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
156
  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
157
  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
158
  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
159
  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
160
  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
161
  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
162
  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
163
  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
164
  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
165
  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
166
  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
167
  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
168
  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
169
  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
170
  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
171
  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
172
  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
173 be8ffec9 Nick Kurshev
};
174
175 82dd7d0d Nick Kurshev
#define SVQ1_PROCESS_VECTOR()\
176
    for (; level > 0; i++) {\
177
      /* process next depth */\
178
      if (i == m) {\
179
        m = n;\
180
        if (--level == 0)\
181
          break;\
182
      }\
183
      /* divide block if next bit set */\
184
      if (get_bits (bitbuf, 1) == 0)\
185
        break;\
186
      /* add child nodes */\
187
      list[n++] = list[i];\
188
      list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
189
    }
190
191
#define SVQ1_ADD_CODEBOOK()\
192
          /* add codebook entries to vector */\
193
          for (j=0; j < stages; j++) {\
194
            n3  = codebook[entries[j]] ^ 0x80808080;\
195
            n1 += ((n3 & 0xFF00FF00) >> 8);\
196
            n2 +=  (n3 & 0x00FF00FF);\
197
          }\
198
\
199
          /* clip to [0..255] */\
200
          if (n1 & 0xFF00FF00) {\
201
            n3  = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
202
            n1 += 0x7F007F00;\
203
            n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
204
            n1 &= (n3 & 0x00FF00FF);\
205
          }\
206
\
207
          if (n2 & 0xFF00FF00) {\
208
            n3  = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
209
            n2 += 0x7F007F00;\
210
            n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
211
            n2 &= (n3 & 0x00FF00FF);\
212
          }
213 be8ffec9 Nick Kurshev
214 82dd7d0d Nick Kurshev
#define SVQ1_DO_CODEBOOK_INTRA()\
215
      for (y=0; y < height; y++) {\
216
        for (x=0; x < (width / 4); x++, codebook++) {\
217
        n1 = n4;\
218
        n2 = n4;\
219
        SVQ1_ADD_CODEBOOK()\
220
        /* store result */\
221
        dst[x] = (n1 << 8) | n2;\
222
        }\
223
        dst += (pitch / 4);\
224
      }
225
226
#define SVQ1_DO_CODEBOOK_NONINTRA()\
227
      for (y=0; y < height; y++) {\
228
        for (x=0; x < (width / 4); x++, codebook++) {\
229
        n3 = dst[x];\
230
        /* add mean value to vector */\
231
        n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
232
        n2 =  (n3 & 0x00FF00FF)          + n4;\
233
        SVQ1_ADD_CODEBOOK()\
234
        /* store result */\
235
        dst[x] = (n1 << 8) | n2;\
236
        }\
237
        dst += (pitch / 4);\
238
      }
239
240
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
241 18f77016 Zdenek Kabelac
      codebook = (const uint32_t *) cbook[level];\
242 82dd7d0d Nick Kurshev
      bit_cache = get_bits (bitbuf, 4*stages);\
243
      /* calculate codebook entries for this vector */\
244
      for (j=0; j < stages; j++) {\
245
        entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
246
      }\
247
      mean -= (stages * 128);\
248
      n4    = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
249 be8ffec9 Nick Kurshev
250 59fcece9 Mike Melanson
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
251 be8ffec9 Nick Kurshev
  uint32_t    bit_cache;
252
  uint8_t    *list[63];
253
  uint32_t   *dst;
254 18f77016 Zdenek Kabelac
  const uint32_t *codebook;
255 be8ffec9 Nick Kurshev
  int              entries[6];
256
  int              i, j, m, n;
257
  int              mean, stages;
258 18f77016 Zdenek Kabelac
  unsigned    x, y, width, height, level;
259 be8ffec9 Nick Kurshev
  uint32_t    n1, n2, n3, n4;
260
261
  /* initialize list for breadth first processing of vectors */
262
  list[0] = pixels;
263
264
  /* recursively process vector */
265
  for (i=0, m=1, n=1, level=5; i < n; i++) {
266 82dd7d0d Nick Kurshev
    SVQ1_PROCESS_VECTOR();
267 be8ffec9 Nick Kurshev
268
    /* destination address and vector size */
269
    dst = (uint32_t *) list[i];
270
    width = 1 << ((4 + level) /2);
271
    height = 1 << ((3 + level) /2);
272
273
    /* get number of stages (-1 skips vector, 0 for mean only) */
274 59fcece9 Mike Melanson
    stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
275 be8ffec9 Nick Kurshev
276
    if (stages == -1) {
277
        for (y=0; y < height; y++) {
278
          memset (&dst[y*(pitch / 4)], 0, width);
279
        }
280
      continue;                /* skip vector */
281
    }
282
283
    if ((stages > 0) && (level >= 4)) {
284
#ifdef DEBUG_SVQ1
285 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
286 be8ffec9 Nick Kurshev
#endif
287
      return -1;        /* invalid vector */
288
    }
289
290 59fcece9 Mike Melanson
    mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
291 be8ffec9 Nick Kurshev
292 82dd7d0d Nick Kurshev
    if (stages == 0) {
293 be8ffec9 Nick Kurshev
      for (y=0; y < height; y++) {
294
        memset (&dst[y*(pitch / 4)], mean, width);
295
      }
296
    } else {
297 82dd7d0d Nick Kurshev
      SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298
      SVQ1_DO_CODEBOOK_INTRA()
299
    }
300
  }
301 be8ffec9 Nick Kurshev
302 82dd7d0d Nick Kurshev
  return 0;
303
}
304 be8ffec9 Nick Kurshev
305 59fcece9 Mike Melanson
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
306 82dd7d0d Nick Kurshev
  uint32_t    bit_cache;
307
  uint8_t    *list[63];
308
  uint32_t   *dst;
309 18f77016 Zdenek Kabelac
  const uint32_t *codebook;
310 82dd7d0d Nick Kurshev
  int              entries[6];
311
  int              i, j, m, n;
312
  int              mean, stages;
313
  int              x, y, width, height, level;
314
  uint32_t    n1, n2, n3, n4;
315 be8ffec9 Nick Kurshev
316 82dd7d0d Nick Kurshev
  /* initialize list for breadth first processing of vectors */
317
  list[0] = pixels;
318 be8ffec9 Nick Kurshev
319 82dd7d0d Nick Kurshev
  /* recursively process vector */
320
  for (i=0, m=1, n=1, level=5; i < n; i++) {
321
    SVQ1_PROCESS_VECTOR();
322 be8ffec9 Nick Kurshev
323 82dd7d0d Nick Kurshev
    /* destination address and vector size */
324
    dst = (uint32_t *) list[i];
325
    width = 1 << ((4 + level) /2);
326
    height = 1 << ((3 + level) /2);
327 be8ffec9 Nick Kurshev
328 82dd7d0d Nick Kurshev
    /* get number of stages (-1 skips vector, 0 for mean only) */
329 59fcece9 Mike Melanson
    stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
330 82dd7d0d Nick Kurshev
331
    if (stages == -1) continue;        /* skip vector */
332
333
    if ((stages > 0) && (level >= 4)) {
334
#ifdef DEBUG_SVQ1
335 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
336 82dd7d0d Nick Kurshev
#endif
337
      return -1;        /* invalid vector */
338 be8ffec9 Nick Kurshev
    }
339
340 59fcece9 Mike Melanson
    mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
341 82dd7d0d Nick Kurshev
342
    SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343
    SVQ1_DO_CODEBOOK_NONINTRA()
344
  }
345 be8ffec9 Nick Kurshev
  return 0;
346
}
347
348 59fcece9 Mike Melanson
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
349
  int              diff;
350 be8ffec9 Nick Kurshev
  int              i;
351
352
  for (i=0; i < 2; i++) {
353
354
    /* get motion code */
355 5e13a730 Michael Niedermayer
    diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
356
    if(diff<0) 
357
        return -1;
358
    else if(diff){
359
        if(get_bits1(bitbuf)) diff= -diff;
360
    }
361 be8ffec9 Nick Kurshev
362
    /* add median of motion vector predictors and clip result */
363
    if (i == 1)
364 5e13a730 Michael Niedermayer
      mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
365 be8ffec9 Nick Kurshev
    else
366 5e13a730 Michael Niedermayer
      mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
367 be8ffec9 Nick Kurshev
  }
368
369
  return 0;
370
}
371
372 82dd7d0d Nick Kurshev
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
373 be8ffec9 Nick Kurshev
  uint8_t *src;
374
  uint8_t *dst;
375
  int           i;
376
377
  src = &previous[x + y*pitch];
378
  dst = current;
379
380
  for (i=0; i < 16; i++) {
381
    memcpy (dst, src, 16);
382
    src += pitch;
383
    dst += pitch;
384
  }
385
}
386
387 59fcece9 Mike Melanson
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
388 be8ffec9 Nick Kurshev
                               uint8_t *current, uint8_t *previous, int pitch,
389
                               svq1_pmv_t *motion, int x, int y) {
390
  uint8_t    *src;
391
  uint8_t    *dst;
392
  svq1_pmv_t  mv;
393
  svq1_pmv_t *pmv[3];
394
  int              result;
395
396
  /* predict and decode motion vector */
397
  pmv[0] = &motion[0];
398
  if (y == 0) {
399 82dd7d0d Nick Kurshev
    pmv[1] =
400 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
401
  }
402 82dd7d0d Nick Kurshev
  else {
403
    pmv[1] = &motion[(x / 8) + 2];
404
    pmv[2] = &motion[(x / 8) + 4];
405
  }
406 be8ffec9 Nick Kurshev
407 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
408 be8ffec9 Nick Kurshev
409
  if (result != 0)
410
    return result;
411
412 82dd7d0d Nick Kurshev
  motion[0].x                =
413
  motion[(x / 8) + 2].x        =
414 be8ffec9 Nick Kurshev
  motion[(x / 8) + 3].x        = mv.x;
415 82dd7d0d Nick Kurshev
  motion[0].y                =
416
  motion[(x / 8) + 2].y        =
417 be8ffec9 Nick Kurshev
  motion[(x / 8) + 3].y        = mv.y;
418 b739d676 Michael Niedermayer
  
419
  if(y + (mv.y >> 1)<0)
420
     mv.y= 0;
421
  if(x + (mv.x >> 1)<0)
422
     mv.x= 0;
423
424
#if 0
425
  int w= (s->width+15)&~15;
426
  int h= (s->height+15)&~15;
427
  if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
428 3b64893d Mike Melanson
      av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
429 b739d676 Michael Niedermayer
#endif
430
 
431 be8ffec9 Nick Kurshev
  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
432
  dst = current;
433
434 eb4b3dd3 Zdenek Kabelac
  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
435 be8ffec9 Nick Kurshev
436
  return 0;
437
}
438
439 59fcece9 Mike Melanson
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
440 be8ffec9 Nick Kurshev
                                  uint8_t *current, uint8_t *previous, int pitch,
441
                                  svq1_pmv_t *motion,int x, int y) {
442
  uint8_t    *src;
443
  uint8_t    *dst;
444
  svq1_pmv_t  mv;
445
  svq1_pmv_t *pmv[4];
446
  int              i, result;
447
448
  /* predict and decode motion vector (0) */
449
  pmv[0] = &motion[0];
450
  if (y == 0) {
451 82dd7d0d Nick Kurshev
    pmv[1] =
452 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
453
  }
454 82dd7d0d Nick Kurshev
  else {
455
    pmv[1] = &motion[(x / 8) + 2];
456
    pmv[2] = &motion[(x / 8) + 4];
457
  }
458 be8ffec9 Nick Kurshev
459 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
460 be8ffec9 Nick Kurshev
461
  if (result != 0)
462
    return result;
463
464
  /* predict and decode motion vector (1) */
465
  pmv[0] = &mv;
466
  if (y == 0) {
467 82dd7d0d Nick Kurshev
    pmv[1] =
468 be8ffec9 Nick Kurshev
    pmv[2] = pmv[0];
469
  }
470 82dd7d0d Nick Kurshev
  else {
471
    pmv[1] = &motion[(x / 8) + 3];
472
  }
473
  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
474 be8ffec9 Nick Kurshev
475
  if (result != 0)
476
    return result;
477
478
  /* predict and decode motion vector (2) */
479
  pmv[1] = &motion[0];
480
  pmv[2] = &motion[(x / 8) + 1];
481
482 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
483 be8ffec9 Nick Kurshev
484
  if (result != 0)
485
    return result;
486
487
  /* predict and decode motion vector (3) */
488
  pmv[2] = &motion[(x / 8) + 2];
489
  pmv[3] = &motion[(x / 8) + 3];
490
491 82dd7d0d Nick Kurshev
  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
492 be8ffec9 Nick Kurshev
493
  if (result != 0)
494
    return result;
495
496
  /* form predictions */
497
  for (i=0; i < 4; i++) {
498 b739d676 Michael Niedermayer
    int mvx= pmv[i]->x + (i&1)*16;
499
    int mvy= pmv[i]->y + (i>>1)*16;
500
  
501
    ///XXX /FIXME cliping or padding?
502
    if(y + (mvy >> 1)<0)
503
       mvy= 0;
504
    if(x + (mvx >> 1)<0)
505
       mvx= 0;
506
507
#if 0
508
  int w= (s->width+15)&~15;
509
  int h= (s->height+15)&~15;
510
  if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
511 3b64893d Mike Melanson
      av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
512 b739d676 Michael Niedermayer
#endif
513
    src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
514 be8ffec9 Nick Kurshev
    dst = current;
515 b739d676 Michael Niedermayer
    
516
    s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
517 be8ffec9 Nick Kurshev
518
    /* select next block */
519
    if (i & 1) {
520
      current  += 8*(pitch - 1);
521
    } else {
522
      current  += 8;
523
    }
524
  }
525
526
  return 0;
527
}
528
529 59fcece9 Mike Melanson
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
530 be8ffec9 Nick Kurshev
                        uint8_t *current, uint8_t *previous, int pitch,
531
                        svq1_pmv_t *motion, int x, int y) {
532
  uint32_t block_type;
533
  int           result = 0;
534
535
  /* get block type */
536 59fcece9 Mike Melanson
  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
537 be8ffec9 Nick Kurshev
538
  /* reset motion vectors */
539
  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
540 82dd7d0d Nick Kurshev
    motion[0].x                  =
541
    motion[0].y                  =
542
    motion[(x / 8) + 2].x =
543
    motion[(x / 8) + 2].y =
544
    motion[(x / 8) + 3].x =
545 be8ffec9 Nick Kurshev
    motion[(x / 8) + 3].y = 0;
546
  }
547
548
  switch (block_type) {
549
  case SVQ1_BLOCK_SKIP:
550 82dd7d0d Nick Kurshev
    svq1_skip_block (current, previous, pitch, x, y);
551 be8ffec9 Nick Kurshev
    break;
552
553
  case SVQ1_BLOCK_INTER:
554 eb4b3dd3 Zdenek Kabelac
    result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
555 be8ffec9 Nick Kurshev
556
    if (result != 0)
557
    {
558
#ifdef DEBUG_SVQ1
559 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
560 be8ffec9 Nick Kurshev
#endif
561
      break;
562
    }
563 82dd7d0d Nick Kurshev
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
564 be8ffec9 Nick Kurshev
    break;
565
566
  case SVQ1_BLOCK_INTER_4V:
567 eb4b3dd3 Zdenek Kabelac
    result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
568 be8ffec9 Nick Kurshev
569
    if (result != 0)
570
    {
571
#ifdef DEBUG_SVQ1
572 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
573 be8ffec9 Nick Kurshev
#endif
574
      break;
575
    }
576 82dd7d0d Nick Kurshev
    result = svq1_decode_block_non_intra (bitbuf, current, pitch);
577 be8ffec9 Nick Kurshev
    break;
578
579
  case SVQ1_BLOCK_INTRA:
580 82dd7d0d Nick Kurshev
    result = svq1_decode_block_intra (bitbuf, current, pitch);
581 be8ffec9 Nick Kurshev
    break;
582
  }
583
584
  return result;
585
}
586
587
/* standard video sizes */
588 82dd7d0d Nick Kurshev
static struct { int width; int height; } svq1_frame_size_table[8] = {
589 be8ffec9 Nick Kurshev
  { 160, 120 }, { 128,  96 }, { 176, 144 }, { 352, 288 },
590
  { 704, 576 }, { 240, 180 }, { 320, 240 }, {  -1,  -1 }
591
};
592
593 59fcece9 Mike Melanson
static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
594
  int i;
595
596
  for (i=0; i < length; i++) {
597
    value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
598
  }
599
600
  return value;
601
}
602
603
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
604
                                         int width, int height, int value) {
605
  int x, y;
606
607
  for (y=0; y < height; y++) {
608
    for (x=0; x < width; x++) {
609
      value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
610
    }
611
612
    pixels += pitch;
613
  }
614
615
  return value;
616
}
617
618
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
619
  uint8_t seed;
620
  int     i;
621
622
  out[0] = get_bits (bitbuf, 8);
623
624
  seed = string_table[out[0]];
625
626 2ad5d5a8 Mike Melanson
  for (i=1; i <= out[0]; i++) {
627 59fcece9 Mike Melanson
    out[i] = get_bits (bitbuf, 8) ^ seed;
628
    seed   = string_table[out[i] ^ seed];
629
  }
630
}
631
632
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
633 be8ffec9 Nick Kurshev
  int frame_size_code;
634 59fcece9 Mike Melanson
  int temporal_reference;
635 be8ffec9 Nick Kurshev
636 59fcece9 Mike Melanson
  temporal_reference = get_bits (bitbuf, 8);
637 be8ffec9 Nick Kurshev
638
  /* frame type */
639 760acb18 Michael Niedermayer
  s->pict_type= get_bits (bitbuf, 2)+1;
640
  if(s->pict_type==4) 
641
      return -1;
642 b739d676 Michael Niedermayer
      
643 760acb18 Michael Niedermayer
  if (s->pict_type == I_TYPE) {
644 be8ffec9 Nick Kurshev
645
    /* unknown fields */
646
    if (s->f_code == 0x50 || s->f_code == 0x60) {
647 59fcece9 Mike Melanson
      int csum = get_bits (bitbuf, 16);
648
649
      csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
650
651 3b64893d Mike Melanson
//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
652 59fcece9 Mike Melanson
//              (csum == 0) ? "correct" : "incorrect", csum);
653 be8ffec9 Nick Kurshev
    }
654
655
    if ((s->f_code ^ 0x10) >= 0x50) {
656 59fcece9 Mike Melanson
      char msg[256];
657
658
      svq1_parse_string (bitbuf, (char *) msg);
659
660 9b879566 Michel Bardiaux
      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
661 be8ffec9 Nick Kurshev
    }
662
663 0c938bd1 Alex Beregszaszi
    skip_bits (bitbuf, 2);
664
    skip_bits (bitbuf, 2);
665
    skip_bits1 (bitbuf);
666 be8ffec9 Nick Kurshev
667
    /* load frame size */
668
    frame_size_code = get_bits (bitbuf, 3);
669
670
    if (frame_size_code == 7) {
671
      /* load width, height (12 bits each) */
672
      s->width = get_bits (bitbuf, 12);
673
      s->height = get_bits (bitbuf, 12);
674
675
      if (!s->width || !s->height)
676
        return -1;
677
    } else {
678
      /* get width, height from table */
679 82dd7d0d Nick Kurshev
      s->width = svq1_frame_size_table[frame_size_code].width;
680
      s->height = svq1_frame_size_table[frame_size_code].height;
681 be8ffec9 Nick Kurshev
    }
682
  }
683
684
  /* unknown fields */
685
  if (get_bits (bitbuf, 1) == 1) {
686 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
687
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
688 be8ffec9 Nick Kurshev
689
    if (get_bits (bitbuf, 2) != 0)
690
      return -1;
691
  }
692
693
  if (get_bits (bitbuf, 1) == 1) {
694 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);
695
    skip_bits (bitbuf, 4);
696
    skip_bits1 (bitbuf);
697
    skip_bits (bitbuf, 2);
698 be8ffec9 Nick Kurshev
699
    while (get_bits (bitbuf, 1) == 1) {
700 0c938bd1 Alex Beregszaszi
      skip_bits (bitbuf, 8);
701 be8ffec9 Nick Kurshev
    }
702
  }
703
  
704
  return 0;
705
}
706
707
static int svq1_decode_frame(AVCodecContext *avctx, 
708
                             void *data, int *data_size,
709 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
710 be8ffec9 Nick Kurshev
{
711
  MpegEncContext *s=avctx->priv_data;
712
  uint8_t      *current, *previous;
713
  int                result, i, x, y, width, height;
714 492cd3a9 Michael Niedermayer
  AVFrame *pict = data; 
715 be8ffec9 Nick Kurshev
716 270f8784 Michael Niedermayer
  if(buf==NULL && buf_size==0){
717
      return 0;
718
  }
719
  
720 be8ffec9 Nick Kurshev
  /* initialize bit buffer */
721 68f593b4 Michael Niedermayer
  init_get_bits(&s->gb,buf,buf_size*8);
722 be8ffec9 Nick Kurshev
723
  /* decode frame header */
724
  s->f_code = get_bits (&s->gb, 22);
725
726
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
727
    return -1;
728
729
  /* swap some header bytes (why?) */
730
  if (s->f_code != 0x20) {
731
    uint32_t *src = (uint32_t *) (buf + 4);
732
733
    for (i=0; i < 4; i++) {
734
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
735
    }
736
  }
737
738 82dd7d0d Nick Kurshev
  result = svq1_decode_frame_header (&s->gb, s);
739 be8ffec9 Nick Kurshev
740
  if (result != 0)
741
  {
742
#ifdef DEBUG_SVQ1
743 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
744 be8ffec9 Nick Kurshev
#endif
745
    return result;
746
  }
747 bc6d7776 Michael Niedermayer
  
748 e5ab4fdd Michael Niedermayer
  //FIXME this avoids some confusion for "B frames" without 2 references
749 3b64893d Mike Melanson
  //this should be removed after libavcodec can handle more flexible picture types & ordering
750 b536d0aa Michael Niedermayer
  if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
751 e5ab4fdd Michael Niedermayer
  
752 bc6d7776 Michael Niedermayer
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
753 be8ffec9 Nick Kurshev
754 1e491e29 Michael Niedermayer
  if(MPV_frame_start(s, avctx) < 0)
755
      return -1;
756
757 be8ffec9 Nick Kurshev
  /* decode y, u and v components */
758
  for (i=0; i < 3; i++) {
759 760acb18 Michael Niedermayer
    int linesize;
760 be8ffec9 Nick Kurshev
    if (i == 0) {
761 82dd7d0d Nick Kurshev
      width  = (s->width+15)&~15;
762
      height = (s->height+15)&~15;
763 760acb18 Michael Niedermayer
      linesize= s->linesize;
764 be8ffec9 Nick Kurshev
    } else {
765 22b13d5b Michael Niedermayer
      if(s->flags&CODEC_FLAG_GRAY) break;
766 82dd7d0d Nick Kurshev
      width  = (s->width/4+15)&~15;
767
      height = (s->height/4+15)&~15;
768 760acb18 Michael Niedermayer
      linesize= s->uvlinesize;
769 be8ffec9 Nick Kurshev
    }
770
771 1e491e29 Michael Niedermayer
    current  = s->current_picture.data[i];
772 be8ffec9 Nick Kurshev
773 760acb18 Michael Niedermayer
    if(s->pict_type==B_TYPE){
774 1e491e29 Michael Niedermayer
        previous = s->next_picture.data[i];
775 760acb18 Michael Niedermayer
    }else{
776 1e491e29 Michael Niedermayer
        previous = s->last_picture.data[i];
777 760acb18 Michael Niedermayer
    }
778
779
    if (s->pict_type == I_TYPE) {
780 be8ffec9 Nick Kurshev
      /* keyframe */
781
      for (y=0; y < height; y+=16) {
782
        for (x=0; x < width; x+=16) {
783 760acb18 Michael Niedermayer
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
784 be8ffec9 Nick Kurshev
          if (result != 0)
785
          {
786 3b64893d Mike Melanson
//#ifdef DEBUG_SVQ1
787
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
788
//#endif
789 be8ffec9 Nick Kurshev
            return result;
790
          }
791
        }
792 760acb18 Michael Niedermayer
        current += 16*linesize;
793 be8ffec9 Nick Kurshev
      }
794
    } else {
795 760acb18 Michael Niedermayer
      svq1_pmv_t pmv[width/8+3];
796 be8ffec9 Nick Kurshev
      /* delta frame */
797 760acb18 Michael Niedermayer
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
798 be8ffec9 Nick Kurshev
799
      for (y=0; y < height; y+=16) {
800
        for (x=0; x < width; x+=16) {
801 eb4b3dd3 Zdenek Kabelac
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
802
                                            linesize, pmv, x, y);
803 be8ffec9 Nick Kurshev
          if (result != 0)
804
          {
805
#ifdef DEBUG_SVQ1
806 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
807 be8ffec9 Nick Kurshev
#endif
808
            return result;
809
          }
810
        }
811
812 760acb18 Michael Niedermayer
        pmv[0].x =
813
        pmv[0].y = 0;
814 be8ffec9 Nick Kurshev
815 760acb18 Michael Niedermayer
        current += 16*linesize;
816 be8ffec9 Nick Kurshev
      }
817
    }
818
  }
819 1e491e29 Michael Niedermayer
  
820 492cd3a9 Michael Niedermayer
  *pict = *(AVFrame*)&s->current_picture;
821 760acb18 Michael Niedermayer
822 1e491e29 Michael Niedermayer
823
  MPV_frame_end(s);
824
  
825 492cd3a9 Michael Niedermayer
  *data_size=sizeof(AVFrame);
826 bc6d7776 Michael Niedermayer
  return buf_size;
827 be8ffec9 Nick Kurshev
}
828
829
static int svq1_decode_init(AVCodecContext *avctx)
830
{
831
    MpegEncContext *s = avctx->priv_data;
832 59fcece9 Mike Melanson
    int i;
833 ce23c668 Alex Beregszaszi
834 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
835
836 be8ffec9 Nick Kurshev
    s->avctx = avctx;
837
    s->width = (avctx->width+3)&~3;
838
    s->height = (avctx->height+3)&~3;
839
    s->codec_id= avctx->codec->id;
840
    avctx->pix_fmt = PIX_FMT_YUV410P;
841 4e00e76b Michael Niedermayer
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
842 3b64893d Mike Melanson
    s->flags= avctx->flags;
843 760acb18 Michael Niedermayer
    if (MPV_common_init(s) < 0) return -1;
844 59fcece9 Mike Melanson
845
    init_vlc(&svq1_block_type, 2, 4,
846
        &svq1_block_type_vlc[0][1], 2, 1,
847
        &svq1_block_type_vlc[0][0], 2, 1);
848
849 5e13a730 Michael Niedermayer
    init_vlc(&svq1_motion_component, 7, 33,
850
        &mvtab[0][1], 2, 1,
851
        &mvtab[0][0], 2, 1);
852 59fcece9 Mike Melanson
853
    for (i = 0; i < 6; i++) {
854
        init_vlc(&svq1_intra_multistage[i], 3, 8,
855
            &svq1_intra_multistage_vlc[i][0][1], 2, 1,
856
            &svq1_intra_multistage_vlc[i][0][0], 2, 1);
857
        init_vlc(&svq1_inter_multistage[i], 3, 8,
858
            &svq1_inter_multistage_vlc[i][0][1], 2, 1,
859
            &svq1_inter_multistage_vlc[i][0][0], 2, 1);
860
    }
861
862
    init_vlc(&svq1_intra_mean, 8, 256,
863
        &svq1_intra_mean_vlc[0][1], 4, 2,
864
        &svq1_intra_mean_vlc[0][0], 4, 2);
865
866
    init_vlc(&svq1_inter_mean, 9, 512,
867
        &svq1_inter_mean_vlc[0][1], 4, 2,
868
        &svq1_inter_mean_vlc[0][0], 4, 2);
869
870 be8ffec9 Nick Kurshev
    return 0;
871
}
872
873
static int svq1_decode_end(AVCodecContext *avctx)
874
{
875
    MpegEncContext *s = avctx->priv_data;
876
877
    MPV_common_end(s);
878
    return 0;
879
}
880
881 3b64893d Mike Melanson
static void svq1_write_header(SVQ1Context *s, int frame_type)
882
{
883 b2a1c771 Alex Beregszaszi
    int i;
884
885 3b64893d Mike Melanson
    /* frame code */
886
    put_bits(&s->pb, 22, 0x20);
887
888
    /* temporal reference (sure hope this is a "don't care") */
889
    put_bits(&s->pb, 8, 0x00);
890
891
    /* frame type */
892
    put_bits(&s->pb, 2, frame_type - 1);
893
894
    if (frame_type == I_TYPE) {
895
896
        /* no checksum since frame code is 0x20 */
897
898
        /* no embedded string either */
899
900
        /* output 5 unknown bits (2 + 2 + 1) */
901
        put_bits(&s->pb, 5, 0);
902
903 b2a1c771 Alex Beregszaszi
        for (i = 0; i < 7; i++)
904
        {
905
            if ((svq1_frame_size_table[i].width == s->frame_width) &&
906
                (svq1_frame_size_table[i].height == s->frame_height))
907
            {
908
                put_bits(&s->pb, 3, i);
909
                break;
910
            }
911
        }
912
        
913
        if (i == 7)
914
        {
915
            put_bits(&s->pb, 3, 7);
916
                put_bits(&s->pb, 12, s->frame_width);
917
                put_bits(&s->pb, 12, s->frame_height);
918
        }
919 3b64893d Mike Melanson
    }
920
921
    /* no checksum or extra data (next 2 bits get 0) */
922
    put_bits(&s->pb, 2, 0);
923
}
924
925
926
#define QUALITY_THRESHOLD 100
927
#define THRESHOLD_MULTIPLIER 0.6
928
929 69de449a Michael Niedermayer
#if defined(HAVE_ALTIVEC)
930
#undef vector
931
#endif
932 3b64893d Mike Melanson
933 ec6d8af5 Michael Niedermayer
static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
934 fa2ae822 Michael Niedermayer
    int count, y, x, i, j, split, best_mean, best_score, best_count;
935
    int best_vector[6];
936
    int block_sum[7]= {0, 0, 0, 0, 0, 0};
937
    int w= 2<<((level+2)>>1);
938
    int h= 2<<((level+1)>>1);
939
    int size=w*h;
940
    int16_t block[7][256];
941 0d8e09f8 Michael Niedermayer
    const int8_t *codebook_sum, *codebook;
942
    const uint16_t (*mean_vlc)[2];
943
    const uint8_t (*multistage_vlc)[2];
944
945 ec6d8af5 Michael Niedermayer
    best_score=0;
946
    //FIXME optimize, this doenst need to be done multiple times
947 0d8e09f8 Michael Niedermayer
    if(intra){
948
        codebook_sum= svq1_intra_codebook_sum[level];
949
        codebook= svq1_intra_codebooks[level];
950
        mean_vlc= svq1_intra_mean_vlc;
951
        multistage_vlc= svq1_intra_multistage_vlc[level];
952 ec6d8af5 Michael Niedermayer
        for(y=0; y<h; y++){
953
            for(x=0; x<w; x++){
954
                int v= src[x + y*stride];
955
                block[0][x + w*y]= v;
956
                best_score += v*v;
957
                block_sum[0] += v;
958
            }
959
        }
960 0d8e09f8 Michael Niedermayer
    }else{
961
        codebook_sum= svq1_inter_codebook_sum[level];
962
        codebook= svq1_inter_codebooks[level];
963 ec6d8af5 Michael Niedermayer
        mean_vlc= svq1_inter_mean_vlc + 256;
964 0d8e09f8 Michael Niedermayer
        multistage_vlc= svq1_inter_multistage_vlc[level];
965 ec6d8af5 Michael Niedermayer
        for(y=0; y<h; y++){
966
            for(x=0; x<w; x++){
967
                int v= src[x + y*stride] - ref[x + y*stride];
968
                block[0][x + w*y]= v;
969
                best_score += v*v;
970
                block_sum[0] += v;
971
            }
972 fa2ae822 Michael Niedermayer
        }
973
    }
974
975
    best_count=0;
976
    best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
977
    best_mean= (block_sum[0] + (size>>1)) >> (level+3);
978
979
    if(level<4){
980
        for(count=1; count<7; count++){
981
            int best_vector_score= INT_MAX;
982 ec6d8af5 Michael Niedermayer
            int best_vector_sum=-999, best_vector_mean=-999;
983 fa2ae822 Michael Niedermayer
            const int stage= count-1;
984 0d8e09f8 Michael Niedermayer
            const int8_t *vector;
985 fa2ae822 Michael Niedermayer
    
986
            for(i=0; i<16; i++){
987 0d8e09f8 Michael Niedermayer
                int sum= codebook_sum[stage*16 + i];
988 fa2ae822 Michael Niedermayer
                int sqr=0;
989
                int diff, mean, score;
990
    
991 0d8e09f8 Michael Niedermayer
                vector = codebook + stage*size*16 + i*size;
992 fa2ae822 Michael Niedermayer
    
993
                for(j=0; j<size; j++){
994
                    int v= vector[j];
995
                    sqr += (v - block[stage][j])*(v - block[stage][j]);
996
                }
997
                diff= block_sum[stage] - sum;
998
                mean= (diff + (size>>1)) >> (level+3);
999 ec6d8af5 Michael Niedermayer
                assert(mean >-300 && mean<300);
1000
                if(intra) mean= clip(mean, 0, 255);
1001
                else      mean= clip(mean, -256, 255);
1002 fa2ae822 Michael Niedermayer
                score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1003
                if(score < best_vector_score){
1004
                    best_vector_score= score;
1005
                    best_vector[stage]= i;
1006
                    best_vector_sum= sum;
1007
                    best_vector_mean= mean;
1008
                }
1009
            }
1010 ec6d8af5 Michael Niedermayer
            assert(best_vector_mean != -999);
1011 0d8e09f8 Michael Niedermayer
            vector= codebook + stage*size*16 + best_vector[stage]*size;
1012 fa2ae822 Michael Niedermayer
            for(j=0; j<size; j++){
1013
                block[stage+1][j] = block[stage][j] - vector[j];
1014
            }
1015
            block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1016
            best_vector_score += 
1017
                lambda*(+ 1 + 4*count
1018 0d8e09f8 Michael Niedermayer
                        + multistage_vlc[1+count][1]
1019
                        + mean_vlc[best_vector_mean][1]);
1020 fa2ae822 Michael Niedermayer
    
1021
            if(best_vector_score < best_score){
1022
                best_score= best_vector_score;
1023
                best_count= count;
1024
                best_mean= best_vector_mean;
1025
            }
1026
        }
1027
    }
1028
    
1029
    split=0;
1030
    if(best_score > threshold && level){
1031
        int score=0;
1032
        int offset= (level&1) ? stride*h/2 : w/2;
1033
        PutBitContext backup[6];
1034
1035
        for(i=level-1; i>=0; i--){
1036
            backup[i]= s->reorder_pb[i];
1037
        }
1038 ec6d8af5 Michael Niedermayer
        score += encode_block(s, src         , ref         , decoded         , stride, level-1, threshold>>1, lambda, intra);
1039
        score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1040 fa2ae822 Michael Niedermayer
        score += lambda;
1041
        
1042
        if(score < best_score){
1043
            best_score= score;
1044
            split=1;
1045
        }else{
1046
            for(i=level-1; i>=0; i--){
1047
                s->reorder_pb[i]= backup[i];
1048
            }
1049
        }
1050
    }
1051
    if (level > 0)
1052
        put_bits(&s->reorder_pb[level], 1, split);
1053
1054
    if(!split){
1055 ec6d8af5 Michael Niedermayer
        assert((best_mean >= 0 && best_mean<256) || !intra);
1056
        assert(best_mean >= -256 && best_mean<256);
1057 fa2ae822 Michael Niedermayer
        assert(best_count >=0 && best_count<7);
1058
        assert(level<4 || best_count==0);
1059
            
1060
        /* output the encoding */
1061
        put_bits(&s->reorder_pb[level], 
1062 0d8e09f8 Michael Niedermayer
            multistage_vlc[1 + best_count][1],
1063
            multistage_vlc[1 + best_count][0]);
1064
        put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1065
            mean_vlc[best_mean][0]);
1066 fa2ae822 Michael Niedermayer
1067
        for (i = 0; i < best_count; i++){
1068
            assert(best_vector[i]>=0 && best_vector[i]<16);
1069
            put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1070
        }
1071 ec6d8af5 Michael Niedermayer
        
1072
        for(y=0; y<h; y++){
1073
            for(x=0; x<w; x++){
1074
                decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1075
            }
1076
        }
1077 fa2ae822 Michael Niedermayer
    }
1078
1079
    return best_score;
1080
}
1081
1082 975af7a9 Mike Melanson
#ifdef CONFIG_ENCODERS
1083
1084 5e13a730 Michael Niedermayer
static void svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1085 ec6d8af5 Michael Niedermayer
    int width, int height, int src_stride, int stride)
1086 3b64893d Mike Melanson
{
1087
    int x, y;
1088 cc77b943 Michael Niedermayer
    int i;
1089 3b64893d Mike Melanson
    int block_width, block_height;
1090
    int level;
1091
    int threshold[6];
1092 ec6d8af5 Michael Niedermayer
    const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1093 3b64893d Mike Melanson
1094
    /* figure out the acceptable level thresholds in advance */
1095
    threshold[5] = QUALITY_THRESHOLD;
1096
    for (level = 4; level >= 0; level--)
1097
        threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1098
1099
    block_width = (width + 15) / 16;
1100
    block_height = (height + 15) / 16;
1101
1102 5e13a730 Michael Niedermayer
    if(s->picture.pict_type == P_TYPE){
1103
        s->m.avctx= s->avctx;
1104
        s->m.current_picture_ptr= &s->m.current_picture;
1105
        s->m.last_picture_ptr   = &s->m.last_picture;
1106
        s->m.last_picture.data[0]= ref_plane;
1107
        s->m.linesize=
1108
        s->m.last_picture.linesize[0]= 
1109
        s->m.new_picture.linesize[0]= 
1110
        s->m.current_picture.linesize[0]= stride;
1111
        s->m.width= width;
1112
        s->m.height= height;
1113
        s->m.mb_width= block_width;
1114
        s->m.mb_height= block_height;
1115
        s->m.mb_stride= s->m.mb_width+1;
1116
        s->m.b8_stride= 2*s->m.mb_width+1;
1117
        s->m.f_code=1;
1118
        s->m.pict_type= s->picture.pict_type;
1119
        s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1120
        s->m.me_method= s->avctx->me_method;
1121
        
1122
        if(!s->motion_val8[plane]){
1123 7a046364 Michael Niedermayer
            s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1124
            s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1125 5e13a730 Michael Niedermayer
        }
1126 7a046364 Michael Niedermayer
1127 5e13a730 Michael Niedermayer
        s->m.mb_type= s->mb_type;
1128
        
1129
        //dummies, to avoid segfaults
1130 cc77b943 Michael Niedermayer
        s->m.current_picture.mb_mean=   (uint8_t *)s->dummy;
1131
        s->m.current_picture.mb_var=    (uint16_t*)s->dummy;
1132
        s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1133 5e13a730 Michael Niedermayer
        s->m.current_picture.mb_type= s->dummy;
1134
        
1135 7a046364 Michael Niedermayer
        s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1136
        s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1137 5e13a730 Michael Niedermayer
        s->m.dsp= s->dsp; //move
1138
        ff_init_me(&s->m);
1139
    
1140
        s->m.me.dia_size= s->avctx->dia_size;
1141
        s->m.first_slice_line=1;
1142
        for (y = 0; y < block_height; y++) {
1143
            uint8_t src[stride*16];
1144
            
1145
            s->m.new_picture.data[0]= src - y*16*stride; //ugly
1146
            s->m.mb_y= y;
1147
    
1148
            for(i=0; i<16 && i + 16*y<height; i++){
1149
                memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1150
                for(x=width; x<16*block_width; x++)
1151
                    src[i*stride+x]= src[i*stride+x-1];
1152
            }
1153
            for(; i<16 && i + 16*y<16*block_height; i++)
1154
                memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1155
    
1156
            for (x = 0; x < block_width; x++) {
1157
                s->m.mb_x= x;
1158
                ff_init_block_index(&s->m);
1159
                ff_update_block_index(&s->m);
1160
                
1161
                ff_estimate_p_frame_motion(&s->m, x, y);
1162
            }
1163
            s->m.first_slice_line=0;
1164
        }
1165
    
1166
        ff_fix_long_p_mvs(&s->m);
1167
        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1168
    }
1169
        
1170
    s->m.first_slice_line=1;
1171 3b64893d Mike Melanson
    for (y = 0; y < block_height; y++) {
1172 ec6d8af5 Michael Niedermayer
        uint8_t src[stride*16];
1173
        
1174
        for(i=0; i<16 && i + 16*y<height; i++){
1175
            memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1176
            for(x=width; x<16*block_width; x++)
1177
                src[i*stride+x]= src[i*stride+x-1];
1178
        }
1179
        for(; i<16 && i + 16*y<16*block_height; i++)
1180
            memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1181 3b64893d Mike Melanson
1182 5e13a730 Michael Niedermayer
        s->m.mb_y= y;
1183 3b64893d Mike Melanson
        for (x = 0; x < block_width; x++) {
1184 5e13a730 Michael Niedermayer
            uint8_t reorder_buffer[3][6][7*32];
1185
            int count[3][6];
1186 ec6d8af5 Michael Niedermayer
            int offset = y * 16 * stride + x * 16;
1187
            uint8_t *decoded= decoded_plane + offset;
1188
            uint8_t *ref= ref_plane + offset;
1189 5e13a730 Michael Niedermayer
            int score[4]={0,0,0,0}, best;
1190 ec6d8af5 Michael Niedermayer
            uint8_t temp[16*stride];
1191 3b64893d Mike Melanson
1192 5e13a730 Michael Niedermayer
            s->m.mb_x= x;
1193
            ff_init_block_index(&s->m);
1194
            ff_update_block_index(&s->m);
1195 fa2ae822 Michael Niedermayer
            
1196 5e13a730 Michael Niedermayer
            if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1197
                for(i=0; i<6; i++){
1198
                    init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1199
                }
1200
                if(s->picture.pict_type == P_TYPE){
1201
                    const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1202
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1203
                    score[0]= vlc[1]*lambda;
1204
                }
1205
                score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1206
                for(i=0; i<6; i++){
1207
                    count[0][i]= put_bits_count(&s->reorder_pb[i]);
1208
                    flush_put_bits(&s->reorder_pb[i]);
1209
                }
1210
            }else
1211
                score[0]= INT_MAX;
1212
            
1213
            best=0;
1214
            
1215 ec6d8af5 Michael Niedermayer
            if(s->picture.pict_type == P_TYPE){
1216
                const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1217 5e13a730 Michael Niedermayer
                int mx, my, pred_x, pred_y, dxy;
1218
                int16_t *motion_ptr;
1219
1220
                motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1221
                if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1222
                    for(i=0; i<6; i++)
1223
                        init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1224
1225 ec6d8af5 Michael Niedermayer
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1226 5e13a730 Michael Niedermayer
    
1227
                    s->m.pb= s->reorder_pb[5];                
1228
                    mx= motion_ptr[0];
1229
                    my= motion_ptr[1];
1230
                    assert(mx>=-32 && mx<=31);
1231
                    assert(my>=-32 && my<=31);
1232
                    assert(pred_x>=-32 && pred_x<=31);
1233
                    assert(pred_y>=-32 && pred_y<=31);
1234
                    ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1235
                    ff_h263_encode_motion(&s->m, my - pred_y, 1);
1236
                    s->reorder_pb[5]= s->m.pb;
1237
                    score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1238
    
1239
                    dxy= (mx&1) + 2*(my&1);
1240
                    
1241
                    s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1242
                    
1243
                    score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1244
                    best= score[1] <= score[0];
1245 3178a865 Michael Niedermayer
1246
                    vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1247
                    score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1248
                    score[2]+= vlc[1]*lambda;
1249
                    if(score[2] < score[best] && mx==0 && my==0){
1250
                        best=2;
1251
                        s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1252
                        for(i=0; i<6; i++){
1253
                            count[2][i]=0;
1254
                        }
1255
                        put_bits(&s->pb, vlc[1], vlc[0]);
1256
                    }
1257 ec6d8af5 Michael Niedermayer
                }
1258 3178a865 Michael Niedermayer
1259 ec6d8af5 Michael Niedermayer
                if(best==1){
1260
                    for(i=0; i<6; i++){
1261
                        count[1][i]= put_bits_count(&s->reorder_pb[i]);
1262
                        flush_put_bits(&s->reorder_pb[i]);
1263
                    }
1264 5e13a730 Michael Niedermayer
                }else{
1265
                    motion_ptr[0                 ] = motion_ptr[1                 ]=
1266
                    motion_ptr[2                 ] = motion_ptr[3                 ]=
1267
                    motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1268
                    motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1269 ec6d8af5 Michael Niedermayer
                }
1270 5e13a730 Michael Niedermayer
            }
1271 ec6d8af5 Michael Niedermayer
                
1272
            s->rd_total += score[best];
1273
1274
            for(i=5; i>=0; i--){
1275
                ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1276
            }
1277
            if(best==0){
1278
                s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1279 fa2ae822 Michael Niedermayer
            }
1280 3b64893d Mike Melanson
        }
1281 5e13a730 Michael Niedermayer
        s->m.first_slice_line=0;
1282 3b64893d Mike Melanson
    }
1283
}
1284
1285
static int svq1_encode_init(AVCodecContext *avctx)
1286
{
1287
    SVQ1Context * const s = avctx->priv_data;
1288
1289
    dsputil_init(&s->dsp, avctx);
1290
    avctx->coded_frame= (AVFrame*)&s->picture;
1291
1292
    s->frame_width = avctx->width;
1293
    s->frame_height = avctx->height;
1294
1295
    s->y_block_width = (s->frame_width + 15) / 16;
1296
    s->y_block_height = (s->frame_height + 15) / 16;
1297
1298
    s->c_block_width = (s->frame_width / 4 + 15) / 16;
1299
    s->c_block_height = (s->frame_height / 4 + 15) / 16;
1300
1301 5e13a730 Michael Niedermayer
    s->avctx= avctx;
1302
    s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); 
1303
    s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1304
    s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1305
    s->mb_type        = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1306
    s->dummy          = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1307
    h263_encode_init(&s->m); //mv_penalty
1308
    
1309 3b64893d Mike Melanson
    return 0;
1310
}
1311
1312
static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, 
1313
    int buf_size, void *data)
1314
{
1315
    SVQ1Context * const s = avctx->priv_data;
1316
    AVFrame *pict = data;
1317
    AVFrame * const p= (AVFrame*)&s->picture;
1318 ec6d8af5 Michael Niedermayer
    AVFrame temp;
1319
    int i;
1320 3b64893d Mike Melanson
1321 ec6d8af5 Michael Niedermayer
    if(avctx->pix_fmt != PIX_FMT_YUV410P){
1322
        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1323
        return -1;
1324
    }
1325
    
1326
    if(!s->current_picture.data[0]){
1327
        avctx->get_buffer(avctx, &s->current_picture);
1328
        avctx->get_buffer(avctx, &s->last_picture);
1329
    }
1330
    
1331
    temp= s->current_picture;
1332
    s->current_picture= s->last_picture;
1333
    s->last_picture= temp;
1334
    
1335 3b64893d Mike Melanson
    init_put_bits(&s->pb, buf, buf_size);
1336
1337
    *p = *pict;
1338 ec6d8af5 Michael Niedermayer
    p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1339 0d8e09f8 Michael Niedermayer
    p->key_frame = p->pict_type == I_TYPE;
1340 3b64893d Mike Melanson
1341
    svq1_write_header(s, p->pict_type);
1342 ec6d8af5 Michael Niedermayer
    for(i=0; i<3; i++){
1343 5e13a730 Michael Niedermayer
        svq1_encode_plane(s, i,
1344 ec6d8af5 Michael Niedermayer
            s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1345
            s->frame_width / (i?4:1), s->frame_height / (i?4:1), 
1346
            s->picture.linesize[i], s->current_picture.linesize[i]);
1347 3b64893d Mike Melanson
    }
1348
1349
//    align_put_bits(&s->pb);
1350
    while(put_bits_count(&s->pb) & 31)
1351
        put_bits(&s->pb, 1, 0);
1352 14aa9da3 Michael Niedermayer
        
1353
    flush_put_bits(&s->pb);
1354 3b64893d Mike Melanson
1355
    return (put_bits_count(&s->pb) / 8);
1356
}
1357
1358
static int svq1_encode_end(AVCodecContext *avctx)
1359
{
1360
    SVQ1Context * const s = avctx->priv_data;
1361 5e13a730 Michael Niedermayer
    int i;
1362 3b64893d Mike Melanson
1363 bab97b2f Michael Niedermayer
    av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1364
    
1365 5e13a730 Michael Niedermayer
    av_freep(&s->m.me.scratchpad);     
1366
    av_freep(&s->m.me.map);
1367
    av_freep(&s->m.me.score_map);
1368
    av_freep(&s->mb_type);
1369
    av_freep(&s->dummy);
1370
1371
    for(i=0; i<3; i++){
1372
        av_freep(&s->motion_val8[i]);
1373
        av_freep(&s->motion_val16[i]);
1374
    }
1375 3b64893d Mike Melanson
1376
    return 0;
1377
}
1378
1379 975af7a9 Mike Melanson
#endif //CONFIG_ENCODERS
1380
1381 be8ffec9 Nick Kurshev
AVCodec svq1_decoder = {
1382
    "svq1",
1383
    CODEC_TYPE_VIDEO,
1384
    CODEC_ID_SVQ1,
1385
    sizeof(MpegEncContext),
1386
    svq1_decode_init,
1387
    NULL,
1388
    svq1_decode_end,
1389 760acb18 Michael Niedermayer
    svq1_decode_frame,
1390
    CODEC_CAP_DR1,
1391 7a06ff14 Michael Niedermayer
    .flush= ff_mpeg_flush,
1392 fcee0164 Michael Niedermayer
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1393 be8ffec9 Nick Kurshev
};
1394 3b64893d Mike Melanson
1395
#ifdef CONFIG_ENCODERS
1396
1397
AVCodec svq1_encoder = {
1398
    "svq1",
1399
    CODEC_TYPE_VIDEO,
1400
    CODEC_ID_SVQ1,
1401
    sizeof(SVQ1Context),
1402
    svq1_encode_init,
1403
    svq1_encode_frame,
1404
    svq1_encode_end,
1405 fcee0164 Michael Niedermayer
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1406 3b64893d Mike Melanson
};
1407
1408
#endif //CONFIG_ENCODERS