Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 4xm.c @ ce5e49b0

History | View | Annotate | Download (27.3 KB)

1 8809cfee Michael Niedermayer
/*
2
 * 4XM codec
3
 * Copyright (c) 2003 Michael Niedermayer
4
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 8809cfee Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 8809cfee Michael Niedermayer
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 8809cfee Michael Niedermayer
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 8809cfee Michael Niedermayer
 */
21 115329f1 Diego Biurrun
22 8809cfee Michael Niedermayer
/**
23 ba87f080 Diego Biurrun
 * @file
24 8809cfee Michael Niedermayer
 * 4XM codec.
25
 */
26 115329f1 Diego Biurrun
27 6a5d31ac Diego Biurrun
#include "libavutil/intreadwrite.h"
28 8809cfee Michael Niedermayer
#include "avcodec.h"
29
#include "dsputil.h"
30 9106a698 Stefano Sabatini
#include "get_bits.h"
31 07c02992 Michael Niedermayer
#include "bytestream.h"
32 8809cfee Michael Niedermayer
33
//#undef NDEBUG
34
//#include <assert.h>
35
36
#define BLOCK_TYPE_VLC_BITS 5
37
#define ACDC_VLC_BITS 9
38
39
#define CFRAME_BUFFER_COUNT 100
40
41 62f68aa9 Michael Niedermayer
static const uint8_t block_type_tab[2][4][8][2]={
42
 {
43 8809cfee Michael Niedermayer
  {   //{8,4,2}x{8,4,2}
44
    { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
45
  },{ //{8,4}x1
46
    { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
47
  },{ //1x{8,4}
48
    { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
49
  },{ //1x2, 2x1
50
    { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
51
  }
52 62f68aa9 Michael Niedermayer
 },{
53
  {  //{8,4,2}x{8,4,2}
54
    { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
55
  },{//{8,4}x1
56
    { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
57
  },{//1x{8,4}
58
    { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
59
  },{//1x2, 2x1
60
    { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
61
  }
62
 }
63 8809cfee Michael Niedermayer
};
64
65
static const uint8_t size2index[4][4]={
66
  {-1, 3, 1, 1},
67
  { 3, 0, 0, 0},
68
  { 2, 0, 0, 0},
69
  { 2, 0, 0, 0},
70
};
71
72
static const int8_t mv[256][2]={
73
{  0,  0},{  0, -1},{ -1,  0},{  1,  0},{  0,  1},{ -1, -1},{  1, -1},{ -1,  1},
74
{  1,  1},{  0, -2},{ -2,  0},{  2,  0},{  0,  2},{ -1, -2},{  1, -2},{ -2, -1},
75
{  2, -1},{ -2,  1},{  2,  1},{ -1,  2},{  1,  2},{ -2, -2},{  2, -2},{ -2,  2},
76
{  2,  2},{  0, -3},{ -3,  0},{  3,  0},{  0,  3},{ -1, -3},{  1, -3},{ -3, -1},
77
{  3, -1},{ -3,  1},{  3,  1},{ -1,  3},{  1,  3},{ -2, -3},{  2, -3},{ -3, -2},
78
{  3, -2},{ -3,  2},{  3,  2},{ -2,  3},{  2,  3},{  0, -4},{ -4,  0},{  4,  0},
79
{  0,  4},{ -1, -4},{  1, -4},{ -4, -1},{  4, -1},{  4,  1},{ -1,  4},{  1,  4},
80
{ -3, -3},{ -3,  3},{  3,  3},{ -2, -4},{ -4, -2},{  4, -2},{ -4,  2},{ -2,  4},
81
{  2,  4},{ -3, -4},{  3, -4},{  4, -3},{ -5,  0},{ -4,  3},{ -3,  4},{  3,  4},
82
{ -1, -5},{ -5, -1},{ -5,  1},{ -1,  5},{ -2, -5},{  2, -5},{  5, -2},{  5,  2},
83
{ -4, -4},{ -4,  4},{ -3, -5},{ -5, -3},{ -5,  3},{  3,  5},{ -6,  0},{  0,  6},
84
{ -6, -1},{ -6,  1},{  1,  6},{  2, -6},{ -6,  2},{  2,  6},{ -5, -4},{  5,  4},
85
{  4,  5},{ -6, -3},{  6,  3},{ -7,  0},{ -1, -7},{  5, -5},{ -7,  1},{ -1,  7},
86
{  4, -6},{  6,  4},{ -2, -7},{ -7,  2},{ -3, -7},{  7, -3},{  3,  7},{  6, -5},
87
{  0, -8},{ -1, -8},{ -7, -4},{ -8,  1},{  4,  7},{  2, -8},{ -2,  8},{  6,  6},
88
{ -8,  3},{  5, -7},{ -5,  7},{  8, -4},{  0, -9},{ -9, -1},{  1,  9},{  7, -6},
89
{ -7,  6},{ -5, -8},{ -5,  8},{ -9,  3},{  9, -4},{  7, -7},{  8, -6},{  6,  8},
90
{ 10,  1},{-10,  2},{  9, -5},{ 10, -3},{ -8, -7},{-10, -4},{  6, -9},{-11,  0},
91
{ 11,  1},{-11, -2},{ -2, 11},{  7, -9},{ -7,  9},{ 10,  6},{ -4, 11},{  8, -9},
92
{  8,  9},{  5, 11},{  7,-10},{ 12, -3},{ 11,  6},{ -9, -9},{  8, 10},{  5, 12},
93
{-11,  7},{ 13,  2},{  6,-12},{ 10,  9},{-11,  8},{ -7, 12},{  0, 14},{ 14, -2},
94
{ -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{  5, 14},{-15, -1},{-14, -6},{  3,-15},
95
{ 11,-11},{ -7, 14},{ -5, 15},{  8,-14},{ 15,  6},{  3, 16},{  7,-15},{-16,  5},
96
{  0, 17},{-16, -6},{-10, 14},{-16,  7},{ 12, 13},{-16,  8},{-17,  6},{-18,  3},
97
{ -7, 17},{ 15, 11},{ 16, 10},{  2,-19},{  3,-19},{-11,-16},{-18,  8},{-19, -6},
98
{  2,-20},{-17,-11},{-10,-18},{  8, 19},{-21, -1},{-20,  7},{ -4, 21},{ 21,  5},
99
{ 15, 16},{  2,-22},{-10,-20},{-22,  5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
100
{ 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
101
{ 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27,  6},{  1,-28},
102
{-11, 26},{-17,-23},{  7, 28},{ 11,-27},{ 29,  5},{-23,-19},{-28,-11},{-21, 22},
103
{-30,  7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
104
{-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
105
};
106
107
// this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
108
static const uint8_t dequant_table[64]={
109
 16, 15, 13, 19, 24, 31, 28, 17,
110
 17, 23, 25, 31, 36, 63, 45, 21,
111
 18, 24, 27, 37, 52, 59, 49, 20,
112
 16, 28, 34, 40, 60, 80, 51, 20,
113
 18, 31, 48, 66, 68, 86, 56, 21,
114
 19, 38, 56, 59, 64, 64, 48, 20,
115
 27, 48, 55, 55, 56, 51, 35, 15,
116
 20, 35, 34, 32, 31, 22, 15,  8,
117
};
118
119 62f68aa9 Michael Niedermayer
static VLC block_type_vlc[2][4];
120 8809cfee Michael Niedermayer
121
122
typedef struct CFrameBuffer{
123 191e8ca7 Måns Rullgård
    unsigned int allocated_size;
124
    unsigned int size;
125 8809cfee Michael Niedermayer
    int id;
126
    uint8_t *data;
127
}CFrameBuffer;
128
129
typedef struct FourXContext{
130
    AVCodecContext *avctx;
131
    DSPContext dsp;
132
    AVFrame current_picture, last_picture;
133
    GetBitContext pre_gb;          ///< ac/dc prefix
134
    GetBitContext gb;
135 530902f3 Michael Niedermayer
    const uint8_t *bytestream;
136
    const uint16_t *wordstream;
137 8809cfee Michael Niedermayer
    int mv[256];
138
    VLC pre_vlc;
139
    int last_dc;
140 84dc2d8a Måns Rullgård
    DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
141 9bf993a5 Reimar Döffinger
    void *bitstream_buffer;
142 f038fe8b Diego Biurrun
    unsigned int bitstream_buffer_size;
143 a0d30cbc Michael Niedermayer
    int version;
144 8809cfee Michael Niedermayer
    CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
145
} FourXContext;
146
147
148
#define FIX_1_082392200  70936
149
#define FIX_1_414213562  92682
150
#define FIX_1_847759065 121095
151
#define FIX_2_613125930 171254
152
153
#define MULTIPLY(var,const)  (((var)*(const)) >> 16)
154
155
static void idct(DCTELEM block[64]){
156
    int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
157
    int tmp10, tmp11, tmp12, tmp13;
158
    int z5, z10, z11, z12, z13;
159
    int i;
160
    int temp[64];
161 115329f1 Diego Biurrun
162 8809cfee Michael Niedermayer
    for(i=0; i<8; i++){
163
        tmp10 = block[8*0 + i] + block[8*4 + i];
164
        tmp11 = block[8*0 + i] - block[8*4 + i];
165
166
        tmp13 =          block[8*2 + i] + block[8*6 + i];
167
        tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
168
169
        tmp0 = tmp10 + tmp13;
170
        tmp3 = tmp10 - tmp13;
171
        tmp1 = tmp11 + tmp12;
172
        tmp2 = tmp11 - tmp12;
173 115329f1 Diego Biurrun
174 8809cfee Michael Niedermayer
        z13 = block[8*5 + i] + block[8*3 + i];
175
        z10 = block[8*5 + i] - block[8*3 + i];
176
        z11 = block[8*1 + i] + block[8*7 + i];
177
        z12 = block[8*1 + i] - block[8*7 + i];
178
179
        tmp7  =          z11 + z13;
180
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
181
182
        z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
183
        tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
184
        tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
185
186
        tmp6 = tmp12 - tmp7;
187
        tmp5 = tmp11 - tmp6;
188
        tmp4 = tmp10 + tmp5;
189
190
        temp[8*0 + i] = tmp0 + tmp7;
191
        temp[8*7 + i] = tmp0 - tmp7;
192
        temp[8*1 + i] = tmp1 + tmp6;
193
        temp[8*6 + i] = tmp1 - tmp6;
194
        temp[8*2 + i] = tmp2 + tmp5;
195
        temp[8*5 + i] = tmp2 - tmp5;
196
        temp[8*4 + i] = tmp3 + tmp4;
197
        temp[8*3 + i] = tmp3 - tmp4;
198
    }
199 115329f1 Diego Biurrun
200 8809cfee Michael Niedermayer
    for(i=0; i<8*8; i+=8){
201
        tmp10 = temp[0 + i] + temp[4 + i];
202
        tmp11 = temp[0 + i] - temp[4 + i];
203
204
        tmp13 = temp[2 + i] + temp[6 + i];
205
        tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
206
207
        tmp0 = tmp10 + tmp13;
208
        tmp3 = tmp10 - tmp13;
209
        tmp1 = tmp11 + tmp12;
210
        tmp2 = tmp11 - tmp12;
211
212
        z13 = temp[5 + i] + temp[3 + i];
213
        z10 = temp[5 + i] - temp[3 + i];
214
        z11 = temp[1 + i] + temp[7 + i];
215
        z12 = temp[1 + i] - temp[7 + i];
216
217
        tmp7 = z11 + z13;
218
        tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
219
220
        z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
221
        tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
222
        tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
223
224
        tmp6 = tmp12 - tmp7;
225
        tmp5 = tmp11 - tmp6;
226
        tmp4 = tmp10 + tmp5;
227
228
        block[0 + i] = (tmp0 + tmp7)>>6;
229
        block[7 + i] = (tmp0 - tmp7)>>6;
230
        block[1 + i] = (tmp1 + tmp6)>>6;
231
        block[6 + i] = (tmp1 - tmp6)>>6;
232
        block[2 + i] = (tmp2 + tmp5)>>6;
233
        block[5 + i] = (tmp2 - tmp5)>>6;
234
        block[4 + i] = (tmp3 + tmp4)>>6;
235
        block[3 + i] = (tmp3 - tmp4)>>6;
236
    }
237
}
238
239 98a6fff9 Zuxy Meng
static av_cold void init_vlcs(FourXContext *f){
240 2a0241ae Michael Niedermayer
    static VLC_TYPE table[8][32][2];
241 8809cfee Michael Niedermayer
    int i;
242
243 62f68aa9 Michael Niedermayer
    for(i=0; i<8; i++){
244 2a0241ae Michael Niedermayer
        block_type_vlc[0][i].table= table[i];
245
        block_type_vlc[0][i].table_allocated= 32;
246 62f68aa9 Michael Niedermayer
        init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
247
                 &block_type_tab[0][i][0][1], 2, 1,
248 2a0241ae Michael Niedermayer
                 &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
249 8809cfee Michael Niedermayer
    }
250
}
251
252
static void init_mv(FourXContext *f){
253
    int i;
254
255
    for(i=0; i<256; i++){
256 c08bbe6c Michael Niedermayer
        if(f->version>1)
257 9ac34d94 Michael Niedermayer
            f->mv[i] = mv[i][0]   + mv[i][1]  *f->current_picture.linesize[0]/2;
258
        else
259
            f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
260 8809cfee Michael Niedermayer
    }
261
}
262
263 c4e8733a Vitor Sessak
#if HAVE_BIGENDIAN
264
#define LE_CENTRIC_MUL(dst, src, scale, dc) \
265
    { \
266
        unsigned tmpval = AV_RN32(src);                 \
267
        tmpval = (tmpval <<  16) | (tmpval >>  16);     \
268
        tmpval = tmpval * (scale) + (dc);               \
269
        tmpval = (tmpval <<  16) | (tmpval >>  16);     \
270
        AV_WN32A(dst, tmpval);                          \
271
    }
272
#else
273
#define LE_CENTRIC_MUL(dst, src, scale, dc) \
274
    { \
275
        unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
276
        AV_WN32A(dst, tmpval);                           \
277
    }
278
#endif
279
280 8809cfee Michael Niedermayer
static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
281
   int i;
282
   dc*= 0x10001;
283
284
   switch(log2w){
285
   case 0:
286
        for(i=0; i<h; i++){
287
            dst[0] = scale*src[0] + dc;
288
            if(scale) src += stride;
289
            dst += stride;
290
        }
291
        break;
292
    case 1:
293
        for(i=0; i<h; i++){
294 c4e8733a Vitor Sessak
            LE_CENTRIC_MUL(dst, src, scale, dc);
295 8809cfee Michael Niedermayer
            if(scale) src += stride;
296
            dst += stride;
297
        }
298
        break;
299
    case 2:
300
        for(i=0; i<h; i++){
301 c4e8733a Vitor Sessak
            LE_CENTRIC_MUL(dst,     src,     scale, dc);
302
            LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
303 8809cfee Michael Niedermayer
            if(scale) src += stride;
304
            dst += stride;
305
        }
306
        break;
307
    case 3:
308
        for(i=0; i<h; i++){
309 c4e8733a Vitor Sessak
            LE_CENTRIC_MUL(dst,     src,     scale, dc);
310
            LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
311
            LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
312
            LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
313 8809cfee Michael Niedermayer
            if(scale) src += stride;
314
            dst += stride;
315
        }
316
        break;
317
    default: assert(0);
318
    }
319
}
320
321
static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
322
    const int index= size2index[log2h][log2w];
323
    const int h= 1<<log2h;
324 c08bbe6c Michael Niedermayer
    int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
325 7f4d2d83 Baptiste Coudurier
    uint16_t *start= (uint16_t*)f->last_picture.data[0];
326 f9f835ee Michael Niedermayer
    uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
327 115329f1 Diego Biurrun
328 8809cfee Michael Niedermayer
    assert(code>=0 && code<=6);
329
330
    if(code == 0){
331
        src += f->mv[ *f->bytestream++ ];
332 f9f835ee Michael Niedermayer
        if(start > src || src > end){
333
            av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
334
            return;
335
        }
336 8809cfee Michael Niedermayer
        mcdc(dst, src, log2w, h, stride, 1, 0);
337
    }else if(code == 1){
338
        log2h--;
339
        decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
340
        decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
341
    }else if(code == 2){
342
        log2w--;
343
        decode_p_block(f, dst             , src             , log2w, log2h, stride);
344
        decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
345 c08bbe6c Michael Niedermayer
    }else if(code == 3 && f->version<2){
346 40802d36 Michael Niedermayer
        mcdc(dst, src, log2w, h, stride, 1, 0);
347 8809cfee Michael Niedermayer
    }else if(code == 4){
348
        src += f->mv[ *f->bytestream++ ];
349 f9f835ee Michael Niedermayer
        if(start > src || src > end){
350
            av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
351
            return;
352
        }
353 8fc0162a Måns Rullgård
        mcdc(dst, src, log2w, h, stride, 1, av_le2ne16(*f->wordstream++));
354 8809cfee Michael Niedermayer
    }else if(code == 5){
355 8fc0162a Måns Rullgård
        mcdc(dst, src, log2w, h, stride, 0, av_le2ne16(*f->wordstream++));
356 8809cfee Michael Niedermayer
    }else if(code == 6){
357
        if(log2w){
358 8fc0162a Måns Rullgård
            dst[0] = av_le2ne16(*f->wordstream++);
359
            dst[1] = av_le2ne16(*f->wordstream++);
360 8809cfee Michael Niedermayer
        }else{
361 8fc0162a Måns Rullgård
            dst[0     ] = av_le2ne16(*f->wordstream++);
362
            dst[stride] = av_le2ne16(*f->wordstream++);
363 8809cfee Michael Niedermayer
        }
364
    }
365
}
366
367 530902f3 Michael Niedermayer
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
368 8809cfee Michael Niedermayer
    int x, y;
369
    const int width= f->avctx->width;
370
    const int height= f->avctx->height;
371
    uint16_t *src= (uint16_t*)f->last_picture.data[0];
372
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
373
    const int stride= f->current_picture.linesize[0]>>1;
374 62f68aa9 Michael Niedermayer
    unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
375
376 c08bbe6c Michael Niedermayer
    if(f->version>1){
377 62f68aa9 Michael Niedermayer
        extra=20;
378 ec9f6493 Michael Niedermayer
        bitstream_size= AV_RL32(buf+8);
379
        wordstream_size= AV_RL32(buf+12);
380
        bytestream_size= AV_RL32(buf+16);
381 62f68aa9 Michael Niedermayer
    }else{
382
        extra=0;
383
        bitstream_size = AV_RL16(buf-4);
384
        wordstream_size= AV_RL16(buf-2);
385
        bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
386
    }
387 115329f1 Diego Biurrun
388 62f68aa9 Michael Niedermayer
    if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
389 0ecca7a4 Michael Niedermayer
       || bitstream_size  > (1<<26)
390
       || bytestream_size > (1<<26)
391
       || wordstream_size > (1<<26)
392
       ){
393 115329f1 Diego Biurrun
        av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
394 8809cfee Michael Niedermayer
        bitstream_size+ bytestream_size+ wordstream_size - length);
395 0ecca7a4 Michael Niedermayer
        return -1;
396
    }
397 115329f1 Diego Biurrun
398 238ef6da Reimar Döffinger
    av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
399
    if (!f->bitstream_buffer)
400
        return AVERROR(ENOMEM);
401 9bf993a5 Reimar Döffinger
    f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
402 8809cfee Michael Niedermayer
    init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
403
404 530902f3 Michael Niedermayer
    f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
405 62f68aa9 Michael Niedermayer
    f->bytestream= buf + extra + bitstream_size + wordstream_size;
406 115329f1 Diego Biurrun
407 8809cfee Michael Niedermayer
    init_mv(f);
408 115329f1 Diego Biurrun
409 8809cfee Michael Niedermayer
    for(y=0; y<height; y+=8){
410
        for(x=0; x<width; x+=8){
411
            decode_p_block(f, dst + x, src + x, 3, 3, stride);
412
        }
413 115329f1 Diego Biurrun
        src += 8*stride;
414
        dst += 8*stride;
415 8809cfee Michael Niedermayer
    }
416 115329f1 Diego Biurrun
417 62f68aa9 Michael Niedermayer
    if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
418 530902f3 Michael Niedermayer
       || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
419
       || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
420 115329f1 Diego Biurrun
        av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
421
            bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
422 530902f3 Michael Niedermayer
            -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
423
            -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
424 8809cfee Michael Niedermayer
        );
425 115329f1 Diego Biurrun
426 8809cfee Michael Niedermayer
    return 0;
427
}
428
429
/**
430
 * decode block and dequantize.
431 04932b0d Diego Biurrun
 * Note this is almost identical to MJPEG.
432 8809cfee Michael Niedermayer
 */
433
static int decode_i_block(FourXContext *f, DCTELEM *block){
434
    int code, i, j, level, val;
435
436
    /* DC coef */
437
    val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
438
    if (val>>4){
439 9b879566 Michel Bardiaux
        av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
440 8809cfee Michael Niedermayer
    }
441
442
    if(val)
443
        val = get_xbits(&f->gb, val);
444
445
    val = val * dequant_table[0] + f->last_dc;
446
    f->last_dc =
447
    block[0] = val;
448
    /* AC coefs */
449
    i = 1;
450
    for(;;) {
451
        code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
452 115329f1 Diego Biurrun
453 8809cfee Michael Niedermayer
        /* EOB */
454
        if (code == 0)
455
            break;
456
        if (code == 0xf0) {
457
            i += 16;
458
        } else {
459
            level = get_xbits(&f->gb, code & 0xf);
460
            i += code >> 4;
461
            if (i >= 64) {
462 9b879566 Michel Bardiaux
                av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
463 8809cfee Michael Niedermayer
                return 0;
464
            }
465
466
            j= ff_zigzag_direct[i];
467
            block[j] = level * dequant_table[j];
468
            i++;
469
            if (i >= 64)
470
                break;
471
        }
472
    }
473
474
    return 0;
475
}
476
477
static inline void idct_put(FourXContext *f, int x, int y){
478
    DCTELEM (*block)[64]= f->block;
479
    int stride= f->current_picture.linesize[0]>>1;
480
    int i;
481
    uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
482 115329f1 Diego Biurrun
483 b60ad448 Michael Niedermayer
    for(i=0; i<4; i++){
484
        block[i][0] += 0x80*8*8;
485
        idct(block[i]);
486
    }
487 8809cfee Michael Niedermayer
488 b60ad448 Michael Niedermayer
    if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
489
        for(i=4; i<6; i++) idct(block[i]);
490
    }
491 8809cfee Michael Niedermayer
492 c9319f2e Michael Niedermayer
/* Note transform is:
493
y= ( 1b + 4g + 2r)/14
494
cb=( 3b - 2g - 1r)/14
495
cr=(-1b - 4g + 5r)/14
496 115329f1 Diego Biurrun
*/
497 8809cfee Michael Niedermayer
    for(y=0; y<8; y++){
498
        for(x=0; x<8; x++){
499
            DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
500 b60ad448 Michael Niedermayer
            int cb= block[4][x + 8*y];
501
            int cr= block[5][x + 8*y];
502 8809cfee Michael Niedermayer
            int cg= (cb + cr)>>1;
503
            int y;
504 115329f1 Diego Biurrun
505 b60ad448 Michael Niedermayer
            cb+=cb;
506 115329f1 Diego Biurrun
507 8809cfee Michael Niedermayer
            y = temp[0];
508 b60ad448 Michael Niedermayer
            dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
509 8809cfee Michael Niedermayer
            y = temp[1];
510 b60ad448 Michael Niedermayer
            dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
511 8809cfee Michael Niedermayer
            y = temp[8];
512 b60ad448 Michael Niedermayer
            dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
513 8809cfee Michael Niedermayer
            y = temp[9];
514 b60ad448 Michael Niedermayer
            dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
515 8809cfee Michael Niedermayer
            dst += 2;
516
        }
517
        dst += 2*stride - 2*8;
518
    }
519
}
520
521
static int decode_i_mb(FourXContext *f){
522
    int i;
523 115329f1 Diego Biurrun
524 8809cfee Michael Niedermayer
    f->dsp.clear_blocks(f->block[0]);
525 115329f1 Diego Biurrun
526 8809cfee Michael Niedermayer
    for(i=0; i<6; i++){
527
        if(decode_i_block(f, f->block[i]) < 0)
528
            return -1;
529
    }
530 115329f1 Diego Biurrun
531 8809cfee Michael Niedermayer
    return 0;
532
}
533
534 530902f3 Michael Niedermayer
static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
535 8809cfee Michael Niedermayer
    int frequency[512];
536
    uint8_t flag[512];
537
    int up[512];
538
    uint8_t len_tab[257];
539
    int bits_tab[257];
540
    int start, end;
541 530902f3 Michael Niedermayer
    const uint8_t *ptr= buf;
542 8809cfee Michael Niedermayer
    int j;
543 115329f1 Diego Biurrun
544 8809cfee Michael Niedermayer
    memset(frequency, 0, sizeof(frequency));
545
    memset(up, -1, sizeof(up));
546
547
    start= *ptr++;
548
    end= *ptr++;
549
    for(;;){
550
        int i;
551 115329f1 Diego Biurrun
552 8809cfee Michael Niedermayer
        for(i=start; i<=end; i++){
553
            frequency[i]= *ptr++;
554
        }
555
        start= *ptr++;
556
        if(start==0) break;
557 115329f1 Diego Biurrun
558 8809cfee Michael Niedermayer
        end= *ptr++;
559
    }
560
    frequency[256]=1;
561
562 115329f1 Diego Biurrun
    while((ptr - buf)&3) ptr++; // 4byte align
563 8809cfee Michael Niedermayer
564
    for(j=257; j<512; j++){
565 5be8a373 Michael Niedermayer
        int min_freq[2]= {256*256, 256*256};
566
        int smallest[2]= {0, 0};
567 8809cfee Michael Niedermayer
        int i;
568
        for(i=0; i<j; i++){
569
            if(frequency[i] == 0) continue;
570 5be8a373 Michael Niedermayer
            if(frequency[i] < min_freq[1]){
571
                if(frequency[i] < min_freq[0]){
572
                    min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
573
                    min_freq[0]= frequency[i];smallest[0]= i;
574
                }else{
575
                    min_freq[1]= frequency[i];smallest[1]= i;
576
                }
577 8809cfee Michael Niedermayer
            }
578
        }
579 5be8a373 Michael Niedermayer
        if(min_freq[1] == 256*256) break;
580 115329f1 Diego Biurrun
581 5be8a373 Michael Niedermayer
        frequency[j]= min_freq[0] + min_freq[1];
582 8809cfee Michael Niedermayer
        flag[ smallest[0] ]= 0;
583
        flag[ smallest[1] ]= 1;
584 115329f1 Diego Biurrun
        up[ smallest[0] ]=
585 8809cfee Michael Niedermayer
        up[ smallest[1] ]= j;
586
        frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
587
    }
588
589
    for(j=0; j<257; j++){
590
        int node;
591
        int len=0;
592
        int bits=0;
593
594
        for(node= j; up[node] != -1; node= up[node]){
595
            bits += flag[node]<<len;
596
            len++;
597 9b879566 Michel Bardiaux
            if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
598 8809cfee Michael Niedermayer
        }
599 115329f1 Diego Biurrun
600 8809cfee Michael Niedermayer
        bits_tab[j]= bits;
601
        len_tab[j]= len;
602
    }
603 115329f1 Diego Biurrun
604
    init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
605 8809cfee Michael Niedermayer
             len_tab , 1, 1,
606 073c2593 Burkhard Plaum
             bits_tab, 4, 4, 0);
607 115329f1 Diego Biurrun
608 8809cfee Michael Niedermayer
    return ptr;
609
}
610
611 b74fb935 Michael Niedermayer
static int mix(int c0, int c1){
612
    int blue = 2*(c0&0x001F) + (c1&0x001F);
613
    int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
614
    int red  = 2*(c0>>10) + (c1>>10);
615
    return red/3*1024 + green/3*32 + blue/3;
616
}
617
618 530902f3 Michael Niedermayer
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
619 b74fb935 Michael Niedermayer
    int x, y, x2, y2;
620
    const int width= f->avctx->width;
621
    const int height= f->avctx->height;
622
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
623
    const int stride= f->current_picture.linesize[0]>>1;
624
625
    for(y=0; y<height; y+=16){
626
        for(x=0; x<width; x+=16){
627
            unsigned int color[4], bits;
628
            memset(color, 0, sizeof(color));
629
//warning following is purely guessed ...
630 07c02992 Michael Niedermayer
            color[0]= bytestream_get_le16(&buf);
631
            color[1]= bytestream_get_le16(&buf);
632 b74fb935 Michael Niedermayer
633
            if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
634
            if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
635
636
            color[2]= mix(color[0], color[1]);
637
            color[3]= mix(color[1], color[0]);
638
639 07c02992 Michael Niedermayer
            bits= bytestream_get_le32(&buf);
640 b74fb935 Michael Niedermayer
            for(y2=0; y2<16; y2++){
641
                for(x2=0; x2<16; x2++){
642
                    int index= 2*(x2>>2) + 8*(y2>>2);
643
                    dst[y2*stride+x2]= color[(bits>>index)&3];
644
                }
645
            }
646
            dst+=16;
647
        }
648
        dst += 16*stride - width;
649
    }
650
651
    return 0;
652
}
653
654 530902f3 Michael Niedermayer
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
655 8809cfee Michael Niedermayer
    int x, y;
656
    const int width= f->avctx->width;
657
    const int height= f->avctx->height;
658
    uint16_t *dst= (uint16_t*)f->current_picture.data[0];
659
    const int stride= f->current_picture.linesize[0]>>1;
660 ec9f6493 Michael Niedermayer
    const unsigned int bitstream_size= AV_RL32(buf);
661
    const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
662
    unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
663 530902f3 Michael Niedermayer
    const uint8_t *prestream= buf + bitstream_size + 12;
664 115329f1 Diego Biurrun
665 0ecca7a4 Michael Niedermayer
    if(prestream_size + bitstream_size + 12 != length
666
       || bitstream_size > (1<<26)
667
       || prestream_size > (1<<26)){
668 160d679c Mike Melanson
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
669 0ecca7a4 Michael Niedermayer
        return -1;
670
    }
671 115329f1 Diego Biurrun
672 8809cfee Michael Niedermayer
    prestream= read_huffman_tables(f, prestream);
673
674
    init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
675
676
    prestream_size= length + buf - prestream;
677 5be8a373 Michael Niedermayer
678 238ef6da Reimar Döffinger
    av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
679
    if (!f->bitstream_buffer)
680
        return AVERROR(ENOMEM);
681 9bf993a5 Reimar Döffinger
    f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
682 8809cfee Michael Niedermayer
    init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
683
684
    f->last_dc= 0*128*8*8;
685 115329f1 Diego Biurrun
686 8809cfee Michael Niedermayer
    for(y=0; y<height; y+=16){
687
        for(x=0; x<width; x+=16){
688
            if(decode_i_mb(f) < 0)
689
                return -1;
690
691
            idct_put(f, x, y);
692
        }
693 115329f1 Diego Biurrun
        dst += 16*stride;
694 8809cfee Michael Niedermayer
    }
695
696
    if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
697 160d679c Mike Melanson
        av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
698 115329f1 Diego Biurrun
699 8809cfee Michael Niedermayer
    return 0;
700
}
701
702 115329f1 Diego Biurrun
static int decode_frame(AVCodecContext *avctx,
703 8809cfee Michael Niedermayer
                        void *data, int *data_size,
704 7a00bbad Thilo Borgmann
                        AVPacket *avpkt)
705 8809cfee Michael Niedermayer
{
706 7a00bbad Thilo Borgmann
    const uint8_t *buf = avpkt->data;
707
    int buf_size = avpkt->size;
708 8809cfee Michael Niedermayer
    FourXContext * const f = avctx->priv_data;
709
    AVFrame *picture = data;
710
    AVFrame *p, temp;
711
    int i, frame_4cc, frame_size;
712
713 ec9f6493 Michael Niedermayer
    frame_4cc= AV_RL32(buf);
714
    if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
715
        av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
716 8809cfee Michael Niedermayer
    }
717
718 2bb6eba2 Aurelien Jacobs
    if(frame_4cc == AV_RL32("cfrm")){
719 8809cfee Michael Niedermayer
        int free_index=-1;
720
        const int data_size= buf_size - 20;
721 ec9f6493 Michael Niedermayer
        const int id= AV_RL32(buf+12);
722
        const int whole_size= AV_RL32(buf+16);
723 8809cfee Michael Niedermayer
        CFrameBuffer *cfrm;
724
725
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
726
            if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
727 9b879566 Michel Bardiaux
                av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
728 8809cfee Michael Niedermayer
        }
729 115329f1 Diego Biurrun
730 8809cfee Michael Niedermayer
        for(i=0; i<CFRAME_BUFFER_COUNT; i++){
731
            if(f->cfrm[i].id   == id) break;
732
            if(f->cfrm[i].size == 0 ) free_index= i;
733
        }
734
735
        if(i>=CFRAME_BUFFER_COUNT){
736
            i= free_index;
737
            f->cfrm[i].id= id;
738
        }
739
        cfrm= &f->cfrm[i];
740 115329f1 Diego Biurrun
741 8809cfee Michael Niedermayer
        cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
742 3a1a7e32 Michael Niedermayer
        if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
743
            av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
744
            return -1;
745
        }
746 115329f1 Diego Biurrun
747 8809cfee Michael Niedermayer
        memcpy(cfrm->data + cfrm->size, buf+20, data_size);
748
        cfrm->size += data_size;
749 115329f1 Diego Biurrun
750 8809cfee Michael Niedermayer
        if(cfrm->size >= whole_size){
751
            buf= cfrm->data;
752
            frame_size= cfrm->size;
753 115329f1 Diego Biurrun
754 8809cfee Michael Niedermayer
            if(id != avctx->frame_number){
755 160d679c Mike Melanson
                av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
756 8809cfee Michael Niedermayer
            }
757 115329f1 Diego Biurrun
758 8809cfee Michael Niedermayer
            cfrm->size= cfrm->id= 0;
759 2bb6eba2 Aurelien Jacobs
            frame_4cc= AV_RL32("pfrm");
760 8809cfee Michael Niedermayer
        }else
761
            return buf_size;
762
    }else{
763
        buf= buf + 12;
764
        frame_size= buf_size - 12;
765 115329f1 Diego Biurrun
    }
766 8809cfee Michael Niedermayer
767
    temp= f->current_picture;
768
    f->current_picture= f->last_picture;
769
    f->last_picture= temp;
770
771
    p= &f->current_picture;
772
    avctx->coded_frame= p;
773
774
    avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
775
776
    p->reference= 1;
777 10aa5a6c Stefano Sabatini
    if (avctx->reget_buffer(avctx, p) < 0) {
778
        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
779 8809cfee Michael Niedermayer
        return -1;
780
    }
781
782 2bb6eba2 Aurelien Jacobs
    if(frame_4cc == AV_RL32("ifr2")){
783 ce5e49b0 Stefano Sabatini
        p->pict_type= AV_PICTURE_TYPE_I;
784 b74fb935 Michael Niedermayer
        if(decode_i2_frame(f, buf-4, frame_size) < 0)
785
            return -1;
786 2bb6eba2 Aurelien Jacobs
    }else if(frame_4cc == AV_RL32("ifrm")){
787 ce5e49b0 Stefano Sabatini
        p->pict_type= AV_PICTURE_TYPE_I;
788 8809cfee Michael Niedermayer
        if(decode_i_frame(f, buf, frame_size) < 0)
789
            return -1;
790 2bb6eba2 Aurelien Jacobs
    }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
791 01329150 Michael Niedermayer
        if(!f->last_picture.data[0]){
792
            f->last_picture.reference= 1;
793
            if(avctx->get_buffer(avctx, &f->last_picture) < 0){
794
                av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
795
                return -1;
796
            }
797
        }
798
799 ce5e49b0 Stefano Sabatini
        p->pict_type= AV_PICTURE_TYPE_P;
800 8809cfee Michael Niedermayer
        if(decode_p_frame(f, buf, frame_size) < 0)
801
            return -1;
802 2bb6eba2 Aurelien Jacobs
    }else if(frame_4cc == AV_RL32("snd_")){
803 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
804 8809cfee Michael Niedermayer
    }else{
805 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
806 8809cfee Michael Niedermayer
    }
807
808 ce5e49b0 Stefano Sabatini
    p->key_frame= p->pict_type == AV_PICTURE_TYPE_I;
809 8809cfee Michael Niedermayer
810
    *picture= *p;
811
    *data_size = sizeof(AVPicture);
812
813
    emms_c();
814 115329f1 Diego Biurrun
815 8809cfee Michael Niedermayer
    return buf_size;
816
}
817
818
819 5ef251e5 Daniel Verkamp
static av_cold void common_init(AVCodecContext *avctx){
820 8809cfee Michael Niedermayer
    FourXContext * const f = avctx->priv_data;
821
822
    dsputil_init(&f->dsp, avctx);
823
824
    f->avctx= avctx;
825
}
826
827 98a6fff9 Zuxy Meng
static av_cold int decode_init(AVCodecContext *avctx){
828 8809cfee Michael Niedermayer
    FourXContext * const f = avctx->priv_data;
829 115329f1 Diego Biurrun
830 b6f508bb Roberto Togni
    if(avctx->extradata_size != 4 || !avctx->extradata) {
831
        av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
832
        return 1;
833
    }
834
835 c08bbe6c Michael Niedermayer
    f->version= AV_RL32(avctx->extradata)>>16;
836 8809cfee Michael Niedermayer
    common_init(avctx);
837
    init_vlcs(f);
838
839 c08bbe6c Michael Niedermayer
    if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
840 59043195 Carl Eugen Hoyos
    else             avctx->pix_fmt= PIX_FMT_BGR555;
841 8809cfee Michael Niedermayer
842
    return 0;
843
}
844
845
846 98a6fff9 Zuxy Meng
static av_cold int decode_end(AVCodecContext *avctx){
847 8809cfee Michael Niedermayer
    FourXContext * const f = avctx->priv_data;
848
    int i;
849
850
    av_freep(&f->bitstream_buffer);
851
    f->bitstream_buffer_size=0;
852
    for(i=0; i<CFRAME_BUFFER_COUNT; i++){
853
        av_freep(&f->cfrm[i].data);
854
        f->cfrm[i].allocated_size= 0;
855
    }
856
    free_vlc(&f->pre_vlc);
857 4b5fee02 Reimar Döffinger
    if(f->current_picture.data[0])
858
        avctx->release_buffer(avctx, &f->current_picture);
859
    if(f->last_picture.data[0])
860
        avctx->release_buffer(avctx, &f->last_picture);
861 115329f1 Diego Biurrun
862 8809cfee Michael Niedermayer
    return 0;
863
}
864
865 e7e2df27 Diego Elio Pettenò
AVCodec ff_fourxm_decoder = {
866 8809cfee Michael Niedermayer
    "4xm",
867 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_VIDEO,
868 8809cfee Michael Niedermayer
    CODEC_ID_4XM,
869
    sizeof(FourXContext),
870
    decode_init,
871
    NULL,
872
    decode_end,
873
    decode_frame,
874 53e67085 Baptiste Coudurier
    CODEC_CAP_DR1,
875 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
876 8809cfee Michael Niedermayer
};