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