Use void * instead of uint8_t * for the destination buffer for dsp.bswap_buf
[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 libavcodec/4xm.c
24  * 4XM codec.
25  */
26
27 #include "libavutil/intreadwrite.h"
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "bitstream.h"
31 #include "bytestream.h"
32
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 static const uint8_t block_type_tab[2][4][8][2]={
42  {
43   {   //{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  },{
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 };
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 static VLC block_type_vlc[2][4];
120
121
122 typedef struct CFrameBuffer{
123     unsigned int allocated_size;
124     unsigned int size;
125     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     const uint8_t *bytestream;
136     const uint16_t *wordstream;
137     int mv[256];
138     VLC pre_vlc;
139     int last_dc;
140     DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
141     void *bitstream_buffer;
142     unsigned int bitstream_buffer_size;
143     int version;
144     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
162     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
174         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
200     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 static av_cold void init_vlcs(FourXContext *f){
240     static VLC_TYPE table[8][32][2];
241     int i;
242
243     for(i=0; i<8; i++){
244         block_type_vlc[0][i].table= table[i];
245         block_type_vlc[0][i].table_allocated= 32;
246         init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
247                  &block_type_tab[0][i][0][1], 2, 1,
248                  &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
249     }
250 }
251
252 static void init_mv(FourXContext *f){
253     int i;
254
255     for(i=0; i<256; i++){
256         if(f->version>1)
257             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     }
261 }
262
263 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
264    int i;
265    dc*= 0x10001;
266
267    switch(log2w){
268    case 0:
269         for(i=0; i<h; i++){
270             dst[0] = scale*src[0] + dc;
271             if(scale) src += stride;
272             dst += stride;
273         }
274         break;
275     case 1:
276         for(i=0; i<h; i++){
277             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
278             if(scale) src += stride;
279             dst += stride;
280         }
281         break;
282     case 2:
283         for(i=0; i<h; i++){
284             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
285             ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
286             if(scale) src += stride;
287             dst += stride;
288         }
289         break;
290     case 3:
291         for(i=0; i<h; i++){
292             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
293             ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
294             ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
295             ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
296             if(scale) src += stride;
297             dst += stride;
298         }
299         break;
300     default: assert(0);
301     }
302 }
303
304 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
305     const int index= size2index[log2h][log2w];
306     const int h= 1<<log2h;
307     int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
308     uint16_t *start= (uint16_t*)f->last_picture.data[0];
309     uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
310
311     assert(code>=0 && code<=6);
312
313     if(code == 0){
314         src += f->mv[ *f->bytestream++ ];
315         if(start > src || src > end){
316             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
317             return;
318         }
319         mcdc(dst, src, log2w, h, stride, 1, 0);
320     }else if(code == 1){
321         log2h--;
322         decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
323         decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
324     }else if(code == 2){
325         log2w--;
326         decode_p_block(f, dst             , src             , log2w, log2h, stride);
327         decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
328     }else if(code == 3 && f->version<2){
329         mcdc(dst, src, log2w, h, stride, 1, 0);
330     }else if(code == 4){
331         src += f->mv[ *f->bytestream++ ];
332         if(start > src || src > end){
333             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
334             return;
335         }
336         mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
337     }else if(code == 5){
338         mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
339     }else if(code == 6){
340         if(log2w){
341             dst[0] = le2me_16(*f->wordstream++);
342             dst[1] = le2me_16(*f->wordstream++);
343         }else{
344             dst[0     ] = le2me_16(*f->wordstream++);
345             dst[stride] = le2me_16(*f->wordstream++);
346         }
347     }
348 }
349
350 static int decode_p_frame(FourXContext *f, const 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>1){
360         extra=20;
361         bitstream_size= AV_RL32(buf+8);
362         wordstream_size= AV_RL32(buf+12);
363         bytestream_size= AV_RL32(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(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
383     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
384
385     f->wordstream= (const 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        || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
400        || (((const char*)f->bytestream - (const 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             -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
404             -(((const char*)f->wordstream - (const 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 almost 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 const uint8_t *read_huffman_tables(FourXContext *f, const 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     const 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, const 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, const 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= AV_RL32(buf);
642     const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
643     unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
644     const 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(f->bitstream_buffer, (const 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                         AVPacket *avpkt)
684 {
685     const uint8_t *buf = avpkt->data;
686     int buf_size = avpkt->size;
687     FourXContext * const f = avctx->priv_data;
688     AVFrame *picture = data;
689     AVFrame *p, temp;
690     int i, frame_4cc, frame_size;
691
692     frame_4cc= AV_RL32(buf);
693     if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
694         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
695     }
696
697     if(frame_4cc == AV_RL32("cfrm")){
698         int free_index=-1;
699         const int data_size= buf_size - 20;
700         const int id= AV_RL32(buf+12);
701         const int whole_size= AV_RL32(buf+16);
702         CFrameBuffer *cfrm;
703
704         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
705             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
706                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
707         }
708
709         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
710             if(f->cfrm[i].id   == id) break;
711             if(f->cfrm[i].size == 0 ) free_index= i;
712         }
713
714         if(i>=CFRAME_BUFFER_COUNT){
715             i= free_index;
716             f->cfrm[i].id= id;
717         }
718         cfrm= &f->cfrm[i];
719
720         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
721         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
722             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
723             return -1;
724         }
725
726         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
727         cfrm->size += data_size;
728
729         if(cfrm->size >= whole_size){
730             buf= cfrm->data;
731             frame_size= cfrm->size;
732
733             if(id != avctx->frame_number){
734                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
735             }
736
737             cfrm->size= cfrm->id= 0;
738             frame_4cc= AV_RL32("pfrm");
739         }else
740             return buf_size;
741     }else{
742         buf= buf + 12;
743         frame_size= buf_size - 12;
744     }
745
746     temp= f->current_picture;
747     f->current_picture= f->last_picture;
748     f->last_picture= temp;
749
750     p= &f->current_picture;
751     avctx->coded_frame= p;
752
753     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
754
755     if(p->data[0])
756         avctx->release_buffer(avctx, p);
757
758     p->reference= 1;
759     if(avctx->get_buffer(avctx, p) < 0){
760         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
761         return -1;
762     }
763
764     if(frame_4cc == AV_RL32("ifr2")){
765         p->pict_type= FF_I_TYPE;
766         if(decode_i2_frame(f, buf-4, frame_size) < 0)
767             return -1;
768     }else if(frame_4cc == AV_RL32("ifrm")){
769         p->pict_type= FF_I_TYPE;
770         if(decode_i_frame(f, buf, frame_size) < 0)
771             return -1;
772     }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
773         p->pict_type= FF_P_TYPE;
774         if(decode_p_frame(f, buf, frame_size) < 0)
775             return -1;
776     }else if(frame_4cc == AV_RL32("snd_")){
777         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
778     }else{
779         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
780     }
781
782     p->key_frame= p->pict_type == FF_I_TYPE;
783
784     *picture= *p;
785     *data_size = sizeof(AVPicture);
786
787     emms_c();
788
789     return buf_size;
790 }
791
792
793 static av_cold void common_init(AVCodecContext *avctx){
794     FourXContext * const f = avctx->priv_data;
795
796     dsputil_init(&f->dsp, avctx);
797
798     f->avctx= avctx;
799 }
800
801 static av_cold int decode_init(AVCodecContext *avctx){
802     FourXContext * const f = avctx->priv_data;
803
804     if(avctx->extradata_size != 4 || !avctx->extradata) {
805         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
806         return 1;
807     }
808
809     f->version= AV_RL32(avctx->extradata)>>16;
810     common_init(avctx);
811     init_vlcs(f);
812
813     if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
814     else             avctx->pix_fmt= PIX_FMT_RGB555;
815
816     return 0;
817 }
818
819
820 static av_cold int decode_end(AVCodecContext *avctx){
821     FourXContext * const f = avctx->priv_data;
822     int i;
823
824     av_freep(&f->bitstream_buffer);
825     f->bitstream_buffer_size=0;
826     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
827         av_freep(&f->cfrm[i].data);
828         f->cfrm[i].allocated_size= 0;
829     }
830     free_vlc(&f->pre_vlc);
831
832     return 0;
833 }
834
835 AVCodec fourxm_decoder = {
836     "4xm",
837     CODEC_TYPE_VIDEO,
838     CODEC_ID_4XM,
839     sizeof(FourXContext),
840     decode_init,
841     NULL,
842     decode_end,
843     decode_frame,
844     /*CODEC_CAP_DR1,*/
845     .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
846 };
847