Statistics
| Branch: | Revision:

ffmpeg / libavcodec / svq1.c @ 5cf08f23

History | View | Annotate | Download (42 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 88730be6 Måns Rullgård
#if 0 /* unused, remove? */
604 59fcece9 Mike Melanson
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
605
                                         int width, int height, int value) {
606
  int x, y;
607

608
  for (y=0; y < height; y++) {
609
    for (x=0; x < width; x++) {
610
      value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
611
    }
612

613
    pixels += pitch;
614
  }
615

616
  return value;
617
}
618 88730be6 Måns Rullgård
#endif
619 59fcece9 Mike Melanson
620
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
621
  uint8_t seed;
622
  int     i;
623
624
  out[0] = get_bits (bitbuf, 8);
625
626
  seed = string_table[out[0]];
627
628 2ad5d5a8 Mike Melanson
  for (i=1; i <= out[0]; i++) {
629 59fcece9 Mike Melanson
    out[i] = get_bits (bitbuf, 8) ^ seed;
630
    seed   = string_table[out[i] ^ seed];
631
  }
632
}
633
634
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
635 be8ffec9 Nick Kurshev
  int frame_size_code;
636 59fcece9 Mike Melanson
  int temporal_reference;
637 be8ffec9 Nick Kurshev
638 59fcece9 Mike Melanson
  temporal_reference = get_bits (bitbuf, 8);
639 be8ffec9 Nick Kurshev
640
  /* frame type */
641 760acb18 Michael Niedermayer
  s->pict_type= get_bits (bitbuf, 2)+1;
642
  if(s->pict_type==4) 
643
      return -1;
644 b739d676 Michael Niedermayer
      
645 760acb18 Michael Niedermayer
  if (s->pict_type == I_TYPE) {
646 be8ffec9 Nick Kurshev
647
    /* unknown fields */
648
    if (s->f_code == 0x50 || s->f_code == 0x60) {
649 59fcece9 Mike Melanson
      int csum = get_bits (bitbuf, 16);
650
651
      csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
652
653 3b64893d Mike Melanson
//      av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
654 59fcece9 Mike Melanson
//              (csum == 0) ? "correct" : "incorrect", csum);
655 be8ffec9 Nick Kurshev
    }
656
657
    if ((s->f_code ^ 0x10) >= 0x50) {
658 59fcece9 Mike Melanson
      char msg[256];
659
660
      svq1_parse_string (bitbuf, (char *) msg);
661
662 9b879566 Michel Bardiaux
      av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
663 be8ffec9 Nick Kurshev
    }
664
665 0c938bd1 Alex Beregszaszi
    skip_bits (bitbuf, 2);
666
    skip_bits (bitbuf, 2);
667
    skip_bits1 (bitbuf);
668 be8ffec9 Nick Kurshev
669
    /* load frame size */
670
    frame_size_code = get_bits (bitbuf, 3);
671
672
    if (frame_size_code == 7) {
673
      /* load width, height (12 bits each) */
674
      s->width = get_bits (bitbuf, 12);
675
      s->height = get_bits (bitbuf, 12);
676
677
      if (!s->width || !s->height)
678
        return -1;
679
    } else {
680
      /* get width, height from table */
681 82dd7d0d Nick Kurshev
      s->width = svq1_frame_size_table[frame_size_code].width;
682
      s->height = svq1_frame_size_table[frame_size_code].height;
683 be8ffec9 Nick Kurshev
    }
684
  }
685
686
  /* unknown fields */
687
  if (get_bits (bitbuf, 1) == 1) {
688 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);       /* use packet checksum if (1) */
689
    skip_bits1 (bitbuf);       /* component checksums after image data if (1) */
690 be8ffec9 Nick Kurshev
691
    if (get_bits (bitbuf, 2) != 0)
692
      return -1;
693
  }
694
695
  if (get_bits (bitbuf, 1) == 1) {
696 0c938bd1 Alex Beregszaszi
    skip_bits1 (bitbuf);
697
    skip_bits (bitbuf, 4);
698
    skip_bits1 (bitbuf);
699
    skip_bits (bitbuf, 2);
700 be8ffec9 Nick Kurshev
701
    while (get_bits (bitbuf, 1) == 1) {
702 0c938bd1 Alex Beregszaszi
      skip_bits (bitbuf, 8);
703 be8ffec9 Nick Kurshev
    }
704
  }
705
  
706
  return 0;
707
}
708
709
static int svq1_decode_frame(AVCodecContext *avctx, 
710
                             void *data, int *data_size,
711 0c1a9eda Zdenek Kabelac
                             uint8_t *buf, int buf_size)
712 be8ffec9 Nick Kurshev
{
713
  MpegEncContext *s=avctx->priv_data;
714
  uint8_t      *current, *previous;
715
  int                result, i, x, y, width, height;
716 492cd3a9 Michael Niedermayer
  AVFrame *pict = data; 
717 be8ffec9 Nick Kurshev
718
  /* initialize bit buffer */
719 68f593b4 Michael Niedermayer
  init_get_bits(&s->gb,buf,buf_size*8);
720 be8ffec9 Nick Kurshev
721
  /* decode frame header */
722
  s->f_code = get_bits (&s->gb, 22);
723
724
  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
725
    return -1;
726
727
  /* swap some header bytes (why?) */
728
  if (s->f_code != 0x20) {
729
    uint32_t *src = (uint32_t *) (buf + 4);
730
731
    for (i=0; i < 4; i++) {
732
      src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
733
    }
734
  }
735
736 82dd7d0d Nick Kurshev
  result = svq1_decode_frame_header (&s->gb, s);
737 be8ffec9 Nick Kurshev
738
  if (result != 0)
739
  {
740
#ifdef DEBUG_SVQ1
741 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
742 be8ffec9 Nick Kurshev
#endif
743
    return result;
744
  }
745 bc6d7776 Michael Niedermayer
  
746 e5ab4fdd Michael Niedermayer
  //FIXME this avoids some confusion for "B frames" without 2 references
747 3b64893d Mike Melanson
  //this should be removed after libavcodec can handle more flexible picture types & ordering
748 b536d0aa Michael Niedermayer
  if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
749 e5ab4fdd Michael Niedermayer
  
750 bc6d7776 Michael Niedermayer
  if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
751 be8ffec9 Nick Kurshev
752 1e491e29 Michael Niedermayer
  if(MPV_frame_start(s, avctx) < 0)
753
      return -1;
754
755 be8ffec9 Nick Kurshev
  /* decode y, u and v components */
756
  for (i=0; i < 3; i++) {
757 760acb18 Michael Niedermayer
    int linesize;
758 be8ffec9 Nick Kurshev
    if (i == 0) {
759 82dd7d0d Nick Kurshev
      width  = (s->width+15)&~15;
760
      height = (s->height+15)&~15;
761 760acb18 Michael Niedermayer
      linesize= s->linesize;
762 be8ffec9 Nick Kurshev
    } else {
763 22b13d5b Michael Niedermayer
      if(s->flags&CODEC_FLAG_GRAY) break;
764 82dd7d0d Nick Kurshev
      width  = (s->width/4+15)&~15;
765
      height = (s->height/4+15)&~15;
766 760acb18 Michael Niedermayer
      linesize= s->uvlinesize;
767 be8ffec9 Nick Kurshev
    }
768
769 1e491e29 Michael Niedermayer
    current  = s->current_picture.data[i];
770 be8ffec9 Nick Kurshev
771 760acb18 Michael Niedermayer
    if(s->pict_type==B_TYPE){
772 1e491e29 Michael Niedermayer
        previous = s->next_picture.data[i];
773 760acb18 Michael Niedermayer
    }else{
774 1e491e29 Michael Niedermayer
        previous = s->last_picture.data[i];
775 760acb18 Michael Niedermayer
    }
776
777
    if (s->pict_type == I_TYPE) {
778 be8ffec9 Nick Kurshev
      /* keyframe */
779
      for (y=0; y < height; y+=16) {
780
        for (x=0; x < width; x+=16) {
781 760acb18 Michael Niedermayer
          result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
782 be8ffec9 Nick Kurshev
          if (result != 0)
783
          {
784 3b64893d Mike Melanson
//#ifdef DEBUG_SVQ1
785
            av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
786
//#endif
787 be8ffec9 Nick Kurshev
            return result;
788
          }
789
        }
790 760acb18 Michael Niedermayer
        current += 16*linesize;
791 be8ffec9 Nick Kurshev
      }
792
    } else {
793 760acb18 Michael Niedermayer
      svq1_pmv_t pmv[width/8+3];
794 be8ffec9 Nick Kurshev
      /* delta frame */
795 760acb18 Michael Niedermayer
      memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
796 be8ffec9 Nick Kurshev
797
      for (y=0; y < height; y+=16) {
798
        for (x=0; x < width; x+=16) {
799 eb4b3dd3 Zdenek Kabelac
          result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
800
                                            linesize, pmv, x, y);
801 be8ffec9 Nick Kurshev
          if (result != 0)
802
          {
803
#ifdef DEBUG_SVQ1
804 3b64893d Mike Melanson
    av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
805 be8ffec9 Nick Kurshev
#endif
806
            return result;
807
          }
808
        }
809
810 760acb18 Michael Niedermayer
        pmv[0].x =
811
        pmv[0].y = 0;
812 be8ffec9 Nick Kurshev
813 760acb18 Michael Niedermayer
        current += 16*linesize;
814 be8ffec9 Nick Kurshev
      }
815
    }
816
  }
817 1e491e29 Michael Niedermayer
  
818 492cd3a9 Michael Niedermayer
  *pict = *(AVFrame*)&s->current_picture;
819 760acb18 Michael Niedermayer
820 1e491e29 Michael Niedermayer
821
  MPV_frame_end(s);
822
  
823 492cd3a9 Michael Niedermayer
  *data_size=sizeof(AVFrame);
824 bc6d7776 Michael Niedermayer
  return buf_size;
825 be8ffec9 Nick Kurshev
}
826
827
static int svq1_decode_init(AVCodecContext *avctx)
828
{
829
    MpegEncContext *s = avctx->priv_data;
830 59fcece9 Mike Melanson
    int i;
831 ce23c668 Alex Beregszaszi
832 3edcacde Michael Niedermayer
    MPV_decode_defaults(s);
833
834 be8ffec9 Nick Kurshev
    s->avctx = avctx;
835
    s->width = (avctx->width+3)&~3;
836
    s->height = (avctx->height+3)&~3;
837
    s->codec_id= avctx->codec->id;
838
    avctx->pix_fmt = PIX_FMT_YUV410P;
839 4e00e76b Michael Niedermayer
    avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
840 3b64893d Mike Melanson
    s->flags= avctx->flags;
841 760acb18 Michael Niedermayer
    if (MPV_common_init(s) < 0) return -1;
842 59fcece9 Mike Melanson
843
    init_vlc(&svq1_block_type, 2, 4,
844
        &svq1_block_type_vlc[0][1], 2, 1,
845 073c2593 Burkhard Plaum
        &svq1_block_type_vlc[0][0], 2, 1, 1);
846 59fcece9 Mike Melanson
847 5e13a730 Michael Niedermayer
    init_vlc(&svq1_motion_component, 7, 33,
848
        &mvtab[0][1], 2, 1,
849 073c2593 Burkhard Plaum
        &mvtab[0][0], 2, 1, 1);
850 59fcece9 Mike Melanson
851
    for (i = 0; i < 6; i++) {
852
        init_vlc(&svq1_intra_multistage[i], 3, 8,
853
            &svq1_intra_multistage_vlc[i][0][1], 2, 1,
854 073c2593 Burkhard Plaum
            &svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
855 59fcece9 Mike Melanson
        init_vlc(&svq1_inter_multistage[i], 3, 8,
856
            &svq1_inter_multistage_vlc[i][0][1], 2, 1,
857 073c2593 Burkhard Plaum
            &svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
858 59fcece9 Mike Melanson
    }
859
860
    init_vlc(&svq1_intra_mean, 8, 256,
861
        &svq1_intra_mean_vlc[0][1], 4, 2,
862 073c2593 Burkhard Plaum
        &svq1_intra_mean_vlc[0][0], 4, 2, 1);
863 59fcece9 Mike Melanson
864
    init_vlc(&svq1_inter_mean, 9, 512,
865
        &svq1_inter_mean_vlc[0][1], 4, 2,
866 073c2593 Burkhard Plaum
        &svq1_inter_mean_vlc[0][0], 4, 2, 1);
867 59fcece9 Mike Melanson
868 be8ffec9 Nick Kurshev
    return 0;
869
}
870
871
static int svq1_decode_end(AVCodecContext *avctx)
872
{
873
    MpegEncContext *s = avctx->priv_data;
874
875
    MPV_common_end(s);
876
    return 0;
877
}
878
879 3b64893d Mike Melanson
static void svq1_write_header(SVQ1Context *s, int frame_type)
880
{
881 b2a1c771 Alex Beregszaszi
    int i;
882
883 3b64893d Mike Melanson
    /* frame code */
884
    put_bits(&s->pb, 22, 0x20);
885
886
    /* temporal reference (sure hope this is a "don't care") */
887
    put_bits(&s->pb, 8, 0x00);
888
889
    /* frame type */
890
    put_bits(&s->pb, 2, frame_type - 1);
891
892
    if (frame_type == I_TYPE) {
893
894
        /* no checksum since frame code is 0x20 */
895
896
        /* no embedded string either */
897
898
        /* output 5 unknown bits (2 + 2 + 1) */
899
        put_bits(&s->pb, 5, 0);
900
901 b2a1c771 Alex Beregszaszi
        for (i = 0; i < 7; i++)
902
        {
903
            if ((svq1_frame_size_table[i].width == s->frame_width) &&
904
                (svq1_frame_size_table[i].height == s->frame_height))
905
            {
906
                put_bits(&s->pb, 3, i);
907
                break;
908
            }
909
        }
910
        
911
        if (i == 7)
912
        {
913
            put_bits(&s->pb, 3, 7);
914
                put_bits(&s->pb, 12, s->frame_width);
915
                put_bits(&s->pb, 12, s->frame_height);
916
        }
917 3b64893d Mike Melanson
    }
918
919
    /* no checksum or extra data (next 2 bits get 0) */
920
    put_bits(&s->pb, 2, 0);
921
}
922
923
924
#define QUALITY_THRESHOLD 100
925
#define THRESHOLD_MULTIPLIER 0.6
926
927 69de449a Michael Niedermayer
#if defined(HAVE_ALTIVEC)
928
#undef vector
929
#endif
930 3b64893d Mike Melanson
931 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){
932 fa2ae822 Michael Niedermayer
    int count, y, x, i, j, split, best_mean, best_score, best_count;
933
    int best_vector[6];
934
    int block_sum[7]= {0, 0, 0, 0, 0, 0};
935
    int w= 2<<((level+2)>>1);
936
    int h= 2<<((level+1)>>1);
937
    int size=w*h;
938
    int16_t block[7][256];
939 0d8e09f8 Michael Niedermayer
    const int8_t *codebook_sum, *codebook;
940
    const uint16_t (*mean_vlc)[2];
941
    const uint8_t (*multistage_vlc)[2];
942
943 ec6d8af5 Michael Niedermayer
    best_score=0;
944
    //FIXME optimize, this doenst need to be done multiple times
945 0d8e09f8 Michael Niedermayer
    if(intra){
946
        codebook_sum= svq1_intra_codebook_sum[level];
947
        codebook= svq1_intra_codebooks[level];
948
        mean_vlc= svq1_intra_mean_vlc;
949
        multistage_vlc= svq1_intra_multistage_vlc[level];
950 ec6d8af5 Michael Niedermayer
        for(y=0; y<h; y++){
951
            for(x=0; x<w; x++){
952
                int v= src[x + y*stride];
953
                block[0][x + w*y]= v;
954
                best_score += v*v;
955
                block_sum[0] += v;
956
            }
957
        }
958 0d8e09f8 Michael Niedermayer
    }else{
959
        codebook_sum= svq1_inter_codebook_sum[level];
960
        codebook= svq1_inter_codebooks[level];
961 ec6d8af5 Michael Niedermayer
        mean_vlc= svq1_inter_mean_vlc + 256;
962 0d8e09f8 Michael Niedermayer
        multistage_vlc= svq1_inter_multistage_vlc[level];
963 ec6d8af5 Michael Niedermayer
        for(y=0; y<h; y++){
964
            for(x=0; x<w; x++){
965
                int v= src[x + y*stride] - ref[x + y*stride];
966
                block[0][x + w*y]= v;
967
                best_score += v*v;
968
                block_sum[0] += v;
969
            }
970 fa2ae822 Michael Niedermayer
        }
971
    }
972
973
    best_count=0;
974
    best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
975
    best_mean= (block_sum[0] + (size>>1)) >> (level+3);
976
977
    if(level<4){
978
        for(count=1; count<7; count++){
979
            int best_vector_score= INT_MAX;
980 ec6d8af5 Michael Niedermayer
            int best_vector_sum=-999, best_vector_mean=-999;
981 fa2ae822 Michael Niedermayer
            const int stage= count-1;
982 0d8e09f8 Michael Niedermayer
            const int8_t *vector;
983 fa2ae822 Michael Niedermayer
    
984
            for(i=0; i<16; i++){
985 0d8e09f8 Michael Niedermayer
                int sum= codebook_sum[stage*16 + i];
986 fa2ae822 Michael Niedermayer
                int sqr=0;
987
                int diff, mean, score;
988
    
989 0d8e09f8 Michael Niedermayer
                vector = codebook + stage*size*16 + i*size;
990 fa2ae822 Michael Niedermayer
    
991
                for(j=0; j<size; j++){
992
                    int v= vector[j];
993
                    sqr += (v - block[stage][j])*(v - block[stage][j]);
994
                }
995
                diff= block_sum[stage] - sum;
996
                mean= (diff + (size>>1)) >> (level+3);
997 ec6d8af5 Michael Niedermayer
                assert(mean >-300 && mean<300);
998
                if(intra) mean= clip(mean, 0, 255);
999
                else      mean= clip(mean, -256, 255);
1000 fa2ae822 Michael Niedermayer
                score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1001
                if(score < best_vector_score){
1002
                    best_vector_score= score;
1003
                    best_vector[stage]= i;
1004
                    best_vector_sum= sum;
1005
                    best_vector_mean= mean;
1006
                }
1007
            }
1008 ec6d8af5 Michael Niedermayer
            assert(best_vector_mean != -999);
1009 0d8e09f8 Michael Niedermayer
            vector= codebook + stage*size*16 + best_vector[stage]*size;
1010 fa2ae822 Michael Niedermayer
            for(j=0; j<size; j++){
1011
                block[stage+1][j] = block[stage][j] - vector[j];
1012
            }
1013
            block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1014
            best_vector_score += 
1015
                lambda*(+ 1 + 4*count
1016 0d8e09f8 Michael Niedermayer
                        + multistage_vlc[1+count][1]
1017
                        + mean_vlc[best_vector_mean][1]);
1018 fa2ae822 Michael Niedermayer
    
1019
            if(best_vector_score < best_score){
1020
                best_score= best_vector_score;
1021
                best_count= count;
1022
                best_mean= best_vector_mean;
1023
            }
1024
        }
1025
    }
1026
    
1027
    split=0;
1028
    if(best_score > threshold && level){
1029
        int score=0;
1030
        int offset= (level&1) ? stride*h/2 : w/2;
1031
        PutBitContext backup[6];
1032
1033
        for(i=level-1; i>=0; i--){
1034
            backup[i]= s->reorder_pb[i];
1035
        }
1036 ec6d8af5 Michael Niedermayer
        score += encode_block(s, src         , ref         , decoded         , stride, level-1, threshold>>1, lambda, intra);
1037
        score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1038 fa2ae822 Michael Niedermayer
        score += lambda;
1039
        
1040
        if(score < best_score){
1041
            best_score= score;
1042
            split=1;
1043
        }else{
1044
            for(i=level-1; i>=0; i--){
1045
                s->reorder_pb[i]= backup[i];
1046
            }
1047
        }
1048
    }
1049
    if (level > 0)
1050
        put_bits(&s->reorder_pb[level], 1, split);
1051
1052
    if(!split){
1053 ec6d8af5 Michael Niedermayer
        assert((best_mean >= 0 && best_mean<256) || !intra);
1054
        assert(best_mean >= -256 && best_mean<256);
1055 fa2ae822 Michael Niedermayer
        assert(best_count >=0 && best_count<7);
1056
        assert(level<4 || best_count==0);
1057
            
1058
        /* output the encoding */
1059
        put_bits(&s->reorder_pb[level], 
1060 0d8e09f8 Michael Niedermayer
            multistage_vlc[1 + best_count][1],
1061
            multistage_vlc[1 + best_count][0]);
1062
        put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1063
            mean_vlc[best_mean][0]);
1064 fa2ae822 Michael Niedermayer
1065
        for (i = 0; i < best_count; i++){
1066
            assert(best_vector[i]>=0 && best_vector[i]<16);
1067
            put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1068
        }
1069 ec6d8af5 Michael Niedermayer
        
1070
        for(y=0; y<h; y++){
1071
            for(x=0; x<w; x++){
1072
                decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1073
            }
1074
        }
1075 fa2ae822 Michael Niedermayer
    }
1076
1077
    return best_score;
1078
}
1079
1080 975af7a9 Mike Melanson
#ifdef CONFIG_ENCODERS
1081
1082 0ecca7a4 Michael Niedermayer
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1083 ec6d8af5 Michael Niedermayer
    int width, int height, int src_stride, int stride)
1084 3b64893d Mike Melanson
{
1085
    int x, y;
1086 cc77b943 Michael Niedermayer
    int i;
1087 3b64893d Mike Melanson
    int block_width, block_height;
1088
    int level;
1089
    int threshold[6];
1090 ec6d8af5 Michael Niedermayer
    const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1091 3b64893d Mike Melanson
1092
    /* figure out the acceptable level thresholds in advance */
1093
    threshold[5] = QUALITY_THRESHOLD;
1094
    for (level = 4; level >= 0; level--)
1095
        threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1096
1097
    block_width = (width + 15) / 16;
1098
    block_height = (height + 15) / 16;
1099
1100 5e13a730 Michael Niedermayer
    if(s->picture.pict_type == P_TYPE){
1101
        s->m.avctx= s->avctx;
1102
        s->m.current_picture_ptr= &s->m.current_picture;
1103
        s->m.last_picture_ptr   = &s->m.last_picture;
1104
        s->m.last_picture.data[0]= ref_plane;
1105
        s->m.linesize=
1106
        s->m.last_picture.linesize[0]= 
1107
        s->m.new_picture.linesize[0]= 
1108
        s->m.current_picture.linesize[0]= stride;
1109
        s->m.width= width;
1110
        s->m.height= height;
1111
        s->m.mb_width= block_width;
1112
        s->m.mb_height= block_height;
1113
        s->m.mb_stride= s->m.mb_width+1;
1114
        s->m.b8_stride= 2*s->m.mb_width+1;
1115
        s->m.f_code=1;
1116
        s->m.pict_type= s->picture.pict_type;
1117
        s->m.qscale= s->picture.quality/FF_QP2LAMBDA;
1118
        s->m.me_method= s->avctx->me_method;
1119
        
1120
        if(!s->motion_val8[plane]){
1121 7a046364 Michael Niedermayer
            s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1122
            s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1123 5e13a730 Michael Niedermayer
        }
1124 7a046364 Michael Niedermayer
1125 5e13a730 Michael Niedermayer
        s->m.mb_type= s->mb_type;
1126
        
1127
        //dummies, to avoid segfaults
1128 cc77b943 Michael Niedermayer
        s->m.current_picture.mb_mean=   (uint8_t *)s->dummy;
1129
        s->m.current_picture.mb_var=    (uint16_t*)s->dummy;
1130
        s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1131 5e13a730 Michael Niedermayer
        s->m.current_picture.mb_type= s->dummy;
1132
        
1133 7a046364 Michael Niedermayer
        s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1134
        s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1135 5e13a730 Michael Niedermayer
        s->m.dsp= s->dsp; //move
1136
        ff_init_me(&s->m);
1137
    
1138
        s->m.me.dia_size= s->avctx->dia_size;
1139
        s->m.first_slice_line=1;
1140
        for (y = 0; y < block_height; y++) {
1141
            uint8_t src[stride*16];
1142
            
1143
            s->m.new_picture.data[0]= src - y*16*stride; //ugly
1144
            s->m.mb_y= y;
1145
    
1146
            for(i=0; i<16 && i + 16*y<height; i++){
1147
                memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1148
                for(x=width; x<16*block_width; x++)
1149
                    src[i*stride+x]= src[i*stride+x-1];
1150
            }
1151
            for(; i<16 && i + 16*y<16*block_height; i++)
1152
                memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1153
    
1154
            for (x = 0; x < block_width; x++) {
1155
                s->m.mb_x= x;
1156
                ff_init_block_index(&s->m);
1157
                ff_update_block_index(&s->m);
1158
                
1159
                ff_estimate_p_frame_motion(&s->m, x, y);
1160
            }
1161
            s->m.first_slice_line=0;
1162
        }
1163
    
1164
        ff_fix_long_p_mvs(&s->m);
1165
        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1166
    }
1167
        
1168
    s->m.first_slice_line=1;
1169 3b64893d Mike Melanson
    for (y = 0; y < block_height; y++) {
1170 ec6d8af5 Michael Niedermayer
        uint8_t src[stride*16];
1171
        
1172
        for(i=0; i<16 && i + 16*y<height; i++){
1173
            memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1174
            for(x=width; x<16*block_width; x++)
1175
                src[i*stride+x]= src[i*stride+x-1];
1176
        }
1177
        for(; i<16 && i + 16*y<16*block_height; i++)
1178
            memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1179 3b64893d Mike Melanson
1180 5e13a730 Michael Niedermayer
        s->m.mb_y= y;
1181 3b64893d Mike Melanson
        for (x = 0; x < block_width; x++) {
1182 5e13a730 Michael Niedermayer
            uint8_t reorder_buffer[3][6][7*32];
1183
            int count[3][6];
1184 ec6d8af5 Michael Niedermayer
            int offset = y * 16 * stride + x * 16;
1185
            uint8_t *decoded= decoded_plane + offset;
1186
            uint8_t *ref= ref_plane + offset;
1187 5e13a730 Michael Niedermayer
            int score[4]={0,0,0,0}, best;
1188 ec6d8af5 Michael Niedermayer
            uint8_t temp[16*stride];
1189 0ecca7a4 Michael Niedermayer
            
1190
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1191
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1192
                return -1;
1193
            }
1194 3b64893d Mike Melanson
1195 5e13a730 Michael Niedermayer
            s->m.mb_x= x;
1196
            ff_init_block_index(&s->m);
1197
            ff_update_block_index(&s->m);
1198 fa2ae822 Michael Niedermayer
            
1199 5e13a730 Michael Niedermayer
            if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1200
                for(i=0; i<6; i++){
1201
                    init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1202
                }
1203
                if(s->picture.pict_type == P_TYPE){
1204
                    const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1205
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1206
                    score[0]= vlc[1]*lambda;
1207
                }
1208
                score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1209
                for(i=0; i<6; i++){
1210
                    count[0][i]= put_bits_count(&s->reorder_pb[i]);
1211
                    flush_put_bits(&s->reorder_pb[i]);
1212
                }
1213
            }else
1214
                score[0]= INT_MAX;
1215
            
1216
            best=0;
1217
            
1218 ec6d8af5 Michael Niedermayer
            if(s->picture.pict_type == P_TYPE){
1219
                const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1220 5e13a730 Michael Niedermayer
                int mx, my, pred_x, pred_y, dxy;
1221
                int16_t *motion_ptr;
1222
1223
                motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1224
                if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1225
                    for(i=0; i<6; i++)
1226
                        init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1227
1228 ec6d8af5 Michael Niedermayer
                    put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1229 5e13a730 Michael Niedermayer
    
1230
                    s->m.pb= s->reorder_pb[5];                
1231
                    mx= motion_ptr[0];
1232
                    my= motion_ptr[1];
1233
                    assert(mx>=-32 && mx<=31);
1234
                    assert(my>=-32 && my<=31);
1235
                    assert(pred_x>=-32 && pred_x<=31);
1236
                    assert(pred_y>=-32 && pred_y<=31);
1237
                    ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1238
                    ff_h263_encode_motion(&s->m, my - pred_y, 1);
1239
                    s->reorder_pb[5]= s->m.pb;
1240
                    score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1241
    
1242
                    dxy= (mx&1) + 2*(my&1);
1243
                    
1244
                    s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1245
                    
1246
                    score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1247
                    best= score[1] <= score[0];
1248 3178a865 Michael Niedermayer
1249
                    vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1250
                    score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1251
                    score[2]+= vlc[1]*lambda;
1252
                    if(score[2] < score[best] && mx==0 && my==0){
1253
                        best=2;
1254
                        s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1255
                        for(i=0; i<6; i++){
1256
                            count[2][i]=0;
1257
                        }
1258
                        put_bits(&s->pb, vlc[1], vlc[0]);
1259
                    }
1260 ec6d8af5 Michael Niedermayer
                }
1261 3178a865 Michael Niedermayer
1262 ec6d8af5 Michael Niedermayer
                if(best==1){
1263
                    for(i=0; i<6; i++){
1264
                        count[1][i]= put_bits_count(&s->reorder_pb[i]);
1265
                        flush_put_bits(&s->reorder_pb[i]);
1266
                    }
1267 5e13a730 Michael Niedermayer
                }else{
1268
                    motion_ptr[0                 ] = motion_ptr[1                 ]=
1269
                    motion_ptr[2                 ] = motion_ptr[3                 ]=
1270
                    motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1271
                    motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1272 ec6d8af5 Michael Niedermayer
                }
1273 5e13a730 Michael Niedermayer
            }
1274 ec6d8af5 Michael Niedermayer
                
1275
            s->rd_total += score[best];
1276
1277
            for(i=5; i>=0; i--){
1278
                ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1279
            }
1280
            if(best==0){
1281
                s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1282 fa2ae822 Michael Niedermayer
            }
1283 3b64893d Mike Melanson
        }
1284 5e13a730 Michael Niedermayer
        s->m.first_slice_line=0;
1285 3b64893d Mike Melanson
    }
1286 0ecca7a4 Michael Niedermayer
    return 0;
1287 3b64893d Mike Melanson
}
1288
1289
static int svq1_encode_init(AVCodecContext *avctx)
1290
{
1291
    SVQ1Context * const s = avctx->priv_data;
1292
1293
    dsputil_init(&s->dsp, avctx);
1294
    avctx->coded_frame= (AVFrame*)&s->picture;
1295
1296
    s->frame_width = avctx->width;
1297
    s->frame_height = avctx->height;
1298
1299
    s->y_block_width = (s->frame_width + 15) / 16;
1300
    s->y_block_height = (s->frame_height + 15) / 16;
1301
1302
    s->c_block_width = (s->frame_width / 4 + 15) / 16;
1303
    s->c_block_height = (s->frame_height / 4 + 15) / 16;
1304
1305 5e13a730 Michael Niedermayer
    s->avctx= avctx;
1306 8b392ae2 Michael Niedermayer
    s->m.avctx= avctx;
1307 5e13a730 Michael Niedermayer
    s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); 
1308
    s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1309
    s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1310
    s->mb_type        = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1311
    s->dummy          = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1312
    h263_encode_init(&s->m); //mv_penalty
1313
    
1314 3b64893d Mike Melanson
    return 0;
1315
}
1316
1317
static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf, 
1318
    int buf_size, void *data)
1319
{
1320
    SVQ1Context * const s = avctx->priv_data;
1321
    AVFrame *pict = data;
1322
    AVFrame * const p= (AVFrame*)&s->picture;
1323 ec6d8af5 Michael Niedermayer
    AVFrame temp;
1324
    int i;
1325 3b64893d Mike Melanson
1326 ec6d8af5 Michael Niedermayer
    if(avctx->pix_fmt != PIX_FMT_YUV410P){
1327
        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1328
        return -1;
1329
    }
1330
    
1331
    if(!s->current_picture.data[0]){
1332
        avctx->get_buffer(avctx, &s->current_picture);
1333
        avctx->get_buffer(avctx, &s->last_picture);
1334
    }
1335
    
1336
    temp= s->current_picture;
1337
    s->current_picture= s->last_picture;
1338
    s->last_picture= temp;
1339
    
1340 3b64893d Mike Melanson
    init_put_bits(&s->pb, buf, buf_size);
1341
1342
    *p = *pict;
1343 ec6d8af5 Michael Niedermayer
    p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1344 0d8e09f8 Michael Niedermayer
    p->key_frame = p->pict_type == I_TYPE;
1345 3b64893d Mike Melanson
1346
    svq1_write_header(s, p->pict_type);
1347 ec6d8af5 Michael Niedermayer
    for(i=0; i<3; i++){
1348 0ecca7a4 Michael Niedermayer
        if(svq1_encode_plane(s, i,
1349 ec6d8af5 Michael Niedermayer
            s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1350
            s->frame_width / (i?4:1), s->frame_height / (i?4:1), 
1351 0ecca7a4 Michael Niedermayer
            s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1352
                return -1;
1353 3b64893d Mike Melanson
    }
1354
1355
//    align_put_bits(&s->pb);
1356
    while(put_bits_count(&s->pb) & 31)
1357
        put_bits(&s->pb, 1, 0);
1358 14aa9da3 Michael Niedermayer
        
1359
    flush_put_bits(&s->pb);
1360 3b64893d Mike Melanson
1361
    return (put_bits_count(&s->pb) / 8);
1362
}
1363
1364
static int svq1_encode_end(AVCodecContext *avctx)
1365
{
1366
    SVQ1Context * const s = avctx->priv_data;
1367 5e13a730 Michael Niedermayer
    int i;
1368 3b64893d Mike Melanson
1369 bab97b2f Michael Niedermayer
    av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1370
    
1371 5e13a730 Michael Niedermayer
    av_freep(&s->m.me.scratchpad);     
1372
    av_freep(&s->m.me.map);
1373
    av_freep(&s->m.me.score_map);
1374
    av_freep(&s->mb_type);
1375
    av_freep(&s->dummy);
1376
1377
    for(i=0; i<3; i++){
1378
        av_freep(&s->motion_val8[i]);
1379
        av_freep(&s->motion_val16[i]);
1380
    }
1381 3b64893d Mike Melanson
1382
    return 0;
1383
}
1384
1385 975af7a9 Mike Melanson
#endif //CONFIG_ENCODERS
1386
1387 be8ffec9 Nick Kurshev
AVCodec svq1_decoder = {
1388
    "svq1",
1389
    CODEC_TYPE_VIDEO,
1390
    CODEC_ID_SVQ1,
1391
    sizeof(MpegEncContext),
1392
    svq1_decode_init,
1393
    NULL,
1394
    svq1_decode_end,
1395 760acb18 Michael Niedermayer
    svq1_decode_frame,
1396
    CODEC_CAP_DR1,
1397 7a06ff14 Michael Niedermayer
    .flush= ff_mpeg_flush,
1398 fcee0164 Michael Niedermayer
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1399 be8ffec9 Nick Kurshev
};
1400 3b64893d Mike Melanson
1401
#ifdef CONFIG_ENCODERS
1402
1403
AVCodec svq1_encoder = {
1404
    "svq1",
1405
    CODEC_TYPE_VIDEO,
1406
    CODEC_ID_SVQ1,
1407
    sizeof(SVQ1Context),
1408
    svq1_encode_init,
1409
    svq1_encode_frame,
1410
    svq1_encode_end,
1411 fcee0164 Michael Niedermayer
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1412 3b64893d Mike Melanson
};
1413
1414
#endif //CONFIG_ENCODERS