Change aac and ac3 parsers to use ff_combine_frame().
[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 "bitstream.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     const uint8_t *bytestream;
135     const 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 av_cold 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>1)
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>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
304     uint16_t *start= (uint16_t*)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<2){
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 decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
347     int x, y;
348     const int width= f->avctx->width;
349     const int height= f->avctx->height;
350     uint16_t *src= (uint16_t*)f->last_picture.data[0];
351     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
352     const int stride= f->current_picture.linesize[0]>>1;
353     unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
354
355     if(f->version>1){
356         extra=20;
357         bitstream_size= AV_RL32(buf+8);
358         wordstream_size= AV_RL32(buf+12);
359         bytestream_size= AV_RL32(buf+16);
360     }else{
361         extra=0;
362         bitstream_size = AV_RL16(buf-4);
363         wordstream_size= AV_RL16(buf-2);
364         bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
365     }
366
367     if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
368        || bitstream_size  > (1<<26)
369        || bytestream_size > (1<<26)
370        || wordstream_size > (1<<26)
371        ){
372         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
373         bitstream_size+ bytestream_size+ wordstream_size - length);
374         return -1;
375     }
376
377     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
378     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
379     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
380
381     f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
382     f->bytestream= buf + extra + bitstream_size + wordstream_size;
383
384     init_mv(f);
385
386     for(y=0; y<height; y+=8){
387         for(x=0; x<width; x+=8){
388             decode_p_block(f, dst + x, src + x, 3, 3, stride);
389         }
390         src += 8*stride;
391         dst += 8*stride;
392     }
393
394     if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
395        || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
396        || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
397         av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
398             bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
399             -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
400             -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
401         );
402
403     return 0;
404 }
405
406 /**
407  * decode block and dequantize.
408  * Note this is almost identical to MJPEG.
409  */
410 static int decode_i_block(FourXContext *f, DCTELEM *block){
411     int code, i, j, level, val;
412
413     /* DC coef */
414     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
415     if (val>>4){
416         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
417     }
418
419     if(val)
420         val = get_xbits(&f->gb, val);
421
422     val = val * dequant_table[0] + f->last_dc;
423     f->last_dc =
424     block[0] = val;
425     /* AC coefs */
426     i = 1;
427     for(;;) {
428         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
429
430         /* EOB */
431         if (code == 0)
432             break;
433         if (code == 0xf0) {
434             i += 16;
435         } else {
436             level = get_xbits(&f->gb, code & 0xf);
437             i += code >> 4;
438             if (i >= 64) {
439                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
440                 return 0;
441             }
442
443             j= ff_zigzag_direct[i];
444             block[j] = level * dequant_table[j];
445             i++;
446             if (i >= 64)
447                 break;
448         }
449     }
450
451     return 0;
452 }
453
454 static inline void idct_put(FourXContext *f, int x, int y){
455     DCTELEM (*block)[64]= f->block;
456     int stride= f->current_picture.linesize[0]>>1;
457     int i;
458     uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
459
460     for(i=0; i<4; i++){
461         block[i][0] += 0x80*8*8;
462         idct(block[i]);
463     }
464
465     if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
466         for(i=4; i<6; i++) idct(block[i]);
467     }
468
469 /* Note transform is:
470 y= ( 1b + 4g + 2r)/14
471 cb=( 3b - 2g - 1r)/14
472 cr=(-1b - 4g + 5r)/14
473 */
474     for(y=0; y<8; y++){
475         for(x=0; x<8; x++){
476             DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
477             int cb= block[4][x + 8*y];
478             int cr= block[5][x + 8*y];
479             int cg= (cb + cr)>>1;
480             int y;
481
482             cb+=cb;
483
484             y = temp[0];
485             dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
486             y = temp[1];
487             dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
488             y = temp[8];
489             dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
490             y = temp[9];
491             dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
492             dst += 2;
493         }
494         dst += 2*stride - 2*8;
495     }
496 }
497
498 static int decode_i_mb(FourXContext *f){
499     int i;
500
501     f->dsp.clear_blocks(f->block[0]);
502
503     for(i=0; i<6; i++){
504         if(decode_i_block(f, f->block[i]) < 0)
505             return -1;
506     }
507
508     return 0;
509 }
510
511 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
512     int frequency[512];
513     uint8_t flag[512];
514     int up[512];
515     uint8_t len_tab[257];
516     int bits_tab[257];
517     int start, end;
518     const uint8_t *ptr= buf;
519     int j;
520
521     memset(frequency, 0, sizeof(frequency));
522     memset(up, -1, sizeof(up));
523
524     start= *ptr++;
525     end= *ptr++;
526     for(;;){
527         int i;
528
529         for(i=start; i<=end; i++){
530             frequency[i]= *ptr++;
531         }
532         start= *ptr++;
533         if(start==0) break;
534
535         end= *ptr++;
536     }
537     frequency[256]=1;
538
539     while((ptr - buf)&3) ptr++; // 4byte align
540
541     for(j=257; j<512; j++){
542         int min_freq[2]= {256*256, 256*256};
543         int smallest[2]= {0, 0};
544         int i;
545         for(i=0; i<j; i++){
546             if(frequency[i] == 0) continue;
547             if(frequency[i] < min_freq[1]){
548                 if(frequency[i] < min_freq[0]){
549                     min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
550                     min_freq[0]= frequency[i];smallest[0]= i;
551                 }else{
552                     min_freq[1]= frequency[i];smallest[1]= i;
553                 }
554             }
555         }
556         if(min_freq[1] == 256*256) break;
557
558         frequency[j]= min_freq[0] + min_freq[1];
559         flag[ smallest[0] ]= 0;
560         flag[ smallest[1] ]= 1;
561         up[ smallest[0] ]=
562         up[ smallest[1] ]= j;
563         frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
564     }
565
566     for(j=0; j<257; j++){
567         int node;
568         int len=0;
569         int bits=0;
570
571         for(node= j; up[node] != -1; node= up[node]){
572             bits += flag[node]<<len;
573             len++;
574             if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
575         }
576
577         bits_tab[j]= bits;
578         len_tab[j]= len;
579     }
580
581     init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
582              len_tab , 1, 1,
583              bits_tab, 4, 4, 0);
584
585     return ptr;
586 }
587
588 static int mix(int c0, int c1){
589     int blue = 2*(c0&0x001F) + (c1&0x001F);
590     int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
591     int red  = 2*(c0>>10) + (c1>>10);
592     return red/3*1024 + green/3*32 + blue/3;
593 }
594
595 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
596     int x, y, x2, y2;
597     const int width= f->avctx->width;
598     const int height= f->avctx->height;
599     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
600     const int stride= f->current_picture.linesize[0]>>1;
601
602     for(y=0; y<height; y+=16){
603         for(x=0; x<width; x+=16){
604             unsigned int color[4], bits;
605             memset(color, 0, sizeof(color));
606 //warning following is purely guessed ...
607             color[0]= bytestream_get_le16(&buf);
608             color[1]= bytestream_get_le16(&buf);
609
610             if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
611             if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
612
613             color[2]= mix(color[0], color[1]);
614             color[3]= mix(color[1], color[0]);
615
616             bits= bytestream_get_le32(&buf);
617             for(y2=0; y2<16; y2++){
618                 for(x2=0; x2<16; x2++){
619                     int index= 2*(x2>>2) + 8*(y2>>2);
620                     dst[y2*stride+x2]= color[(bits>>index)&3];
621                 }
622             }
623             dst+=16;
624         }
625         dst += 16*stride - width;
626     }
627
628     return 0;
629 }
630
631 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
632     int x, y;
633     const int width= f->avctx->width;
634     const int height= f->avctx->height;
635     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
636     const int stride= f->current_picture.linesize[0]>>1;
637     const unsigned int bitstream_size= AV_RL32(buf);
638     const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
639     unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
640     const uint8_t *prestream= buf + bitstream_size + 12;
641
642     if(prestream_size + bitstream_size + 12 != length
643        || bitstream_size > (1<<26)
644        || prestream_size > (1<<26)){
645         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
646         return -1;
647     }
648
649     prestream= read_huffman_tables(f, prestream);
650
651     init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
652
653     prestream_size= length + buf - prestream;
654
655     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
656     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
657     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
658
659     f->last_dc= 0*128*8*8;
660
661     for(y=0; y<height; y+=16){
662         for(x=0; x<width; x+=16){
663             if(decode_i_mb(f) < 0)
664                 return -1;
665
666             idct_put(f, x, y);
667         }
668         dst += 16*stride;
669     }
670
671     if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
672         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
673
674     return 0;
675 }
676
677 static int decode_frame(AVCodecContext *avctx,
678                         void *data, int *data_size,
679                         const uint8_t *buf, int buf_size)
680 {
681     FourXContext * const f = avctx->priv_data;
682     AVFrame *picture = data;
683     AVFrame *p, temp;
684     int i, frame_4cc, frame_size;
685
686     frame_4cc= AV_RL32(buf);
687     if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
688         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
689     }
690
691     if(frame_4cc == ff_get_fourcc("cfrm")){
692         int free_index=-1;
693         const int data_size= buf_size - 20;
694         const int id= AV_RL32(buf+12);
695         const int whole_size= AV_RL32(buf+16);
696         CFrameBuffer *cfrm;
697
698         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
699             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
700                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
701         }
702
703         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
704             if(f->cfrm[i].id   == id) break;
705             if(f->cfrm[i].size == 0 ) free_index= i;
706         }
707
708         if(i>=CFRAME_BUFFER_COUNT){
709             i= free_index;
710             f->cfrm[i].id= id;
711         }
712         cfrm= &f->cfrm[i];
713
714         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
715         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
716             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
717             return -1;
718         }
719
720         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
721         cfrm->size += data_size;
722
723         if(cfrm->size >= whole_size){
724             buf= cfrm->data;
725             frame_size= cfrm->size;
726
727             if(id != avctx->frame_number){
728                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
729             }
730
731             cfrm->size= cfrm->id= 0;
732             frame_4cc= ff_get_fourcc("pfrm");
733         }else
734             return buf_size;
735     }else{
736         buf= buf + 12;
737         frame_size= buf_size - 12;
738     }
739
740     temp= f->current_picture;
741     f->current_picture= f->last_picture;
742     f->last_picture= temp;
743
744     p= &f->current_picture;
745     avctx->coded_frame= p;
746
747     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
748
749     if(p->data[0])
750         avctx->release_buffer(avctx, p);
751
752     p->reference= 1;
753     if(avctx->get_buffer(avctx, p) < 0){
754         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
755         return -1;
756     }
757
758     if(frame_4cc == ff_get_fourcc("ifr2")){
759         p->pict_type= FF_I_TYPE;
760         if(decode_i2_frame(f, buf-4, frame_size) < 0)
761             return -1;
762     }else if(frame_4cc == ff_get_fourcc("ifrm")){
763         p->pict_type= FF_I_TYPE;
764         if(decode_i_frame(f, buf, frame_size) < 0)
765             return -1;
766     }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
767         p->pict_type= FF_P_TYPE;
768         if(decode_p_frame(f, buf, frame_size) < 0)
769             return -1;
770     }else if(frame_4cc == ff_get_fourcc("snd_")){
771         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
772     }else{
773         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
774     }
775
776     p->key_frame= p->pict_type == FF_I_TYPE;
777
778     *picture= *p;
779     *data_size = sizeof(AVPicture);
780
781     emms_c();
782
783     return buf_size;
784 }
785
786
787 static void common_init(AVCodecContext *avctx){
788     FourXContext * const f = avctx->priv_data;
789
790     dsputil_init(&f->dsp, avctx);
791
792     f->avctx= avctx;
793 }
794
795 static av_cold int decode_init(AVCodecContext *avctx){
796     FourXContext * const f = avctx->priv_data;
797
798     if(avctx->extradata_size != 4 || !avctx->extradata) {
799         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
800         return 1;
801     }
802
803     f->version= AV_RL32(avctx->extradata)>>16;
804     common_init(avctx);
805     init_vlcs(f);
806
807     if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
808     else             avctx->pix_fmt= PIX_FMT_RGB555;
809
810     return 0;
811 }
812
813
814 static av_cold int decode_end(AVCodecContext *avctx){
815     FourXContext * const f = avctx->priv_data;
816     int i;
817
818     av_freep(&f->bitstream_buffer);
819     f->bitstream_buffer_size=0;
820     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
821         av_freep(&f->cfrm[i].data);
822         f->cfrm[i].allocated_size= 0;
823     }
824     free_vlc(&f->pre_vlc);
825
826     return 0;
827 }
828
829 AVCodec fourxm_decoder = {
830     "4xm",
831     CODEC_TYPE_VIDEO,
832     CODEC_ID_4XM,
833     sizeof(FourXContext),
834     decode_init,
835     NULL,
836     decode_end,
837     decode_frame,
838     /*CODEC_CAP_DR1,*/
839 };
840