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