3 * Copyright (c) 2003 Michael Niedermayer
5 * This file is part of FFmpeg.
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.
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.
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
29 #include "mpegvideo.h"
30 #include "bytestream.h"
35 #define BLOCK_TYPE_VLC_BITS 5
36 #define ACDC_VLC_BITS 9
38 #define CFRAME_BUFFER_COUNT 100
40 static const uint8_t block_type_tab[2][4][8][2]={
43 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
45 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
47 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
49 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
53 { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
55 { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
57 { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
59 { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
64 static const uint8_t size2index[4][4]={
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}
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,
118 static VLC block_type_vlc[2][4];
121 typedef struct CFrameBuffer{
122 unsigned int allocated_size;
128 typedef struct FourXContext{
129 AVCodecContext *avctx;
131 AVFrame current_picture, last_picture;
132 GetBitContext pre_gb; ///< ac/dc prefix
135 uint16_t *wordstream;
139 DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
140 uint8_t *bitstream_buffer;
141 unsigned int bitstream_buffer_size;
143 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
147 #define FIX_1_082392200 70936
148 #define FIX_1_414213562 92682
149 #define FIX_1_847759065 121095
150 #define FIX_2_613125930 171254
152 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
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;
162 tmp10 = block[8*0 + i] + block[8*4 + i];
163 tmp11 = block[8*0 + i] - block[8*4 + i];
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;
168 tmp0 = tmp10 + tmp13;
169 tmp3 = tmp10 - tmp13;
170 tmp1 = tmp11 + tmp12;
171 tmp2 = tmp11 - tmp12;
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];
179 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
181 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
182 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
183 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
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;
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];
203 tmp13 = temp[2 + i] + temp[6 + i];
204 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
206 tmp0 = tmp10 + tmp13;
207 tmp3 = tmp10 - tmp13;
208 tmp1 = tmp11 + tmp12;
209 tmp2 = tmp11 - tmp12;
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];
217 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
219 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
220 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
221 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
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;
238 static void init_vlcs(FourXContext *f){
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);
248 static void init_mv(FourXContext *f){
251 for(i=0; i<256; i++){
253 f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
255 f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
259 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
266 dst[0] = scale*src[0] + dc;
267 if(scale) src += stride;
273 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
274 if(scale) src += stride;
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;
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;
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);
305 assert(code>=0 && code<=6);
308 src += f->mv[ *f->bytestream++ ];
309 mcdc(dst, src, log2w, h, stride, 1, 0);
312 decode_p_block(f, dst , src , log2w, log2h, stride);
313 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
316 decode_p_block(f, dst , src , log2w, log2h, stride);
317 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
318 }else if(code == 3 && f->version==0){
319 mcdc(dst, src, log2w, h, stride, 1, 0);
321 src += f->mv[ *f->bytestream++ ];
322 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
324 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
327 dst[0] = le2me_16(*f->wordstream++);
328 dst[1] = le2me_16(*f->wordstream++);
330 dst[0 ] = le2me_16(*f->wordstream++);
331 dst[stride] = le2me_16(*f->wordstream++);
336 static int get32(void *p){
337 return le2me_32(*(uint32_t*)p);
340 static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
342 const int width= f->avctx->width;
343 const int height= f->avctx->height;
344 uint16_t *src= (uint16_t*)f->last_picture.data[0];
345 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
346 const int stride= f->current_picture.linesize[0]>>1;
347 unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
351 bitstream_size= get32(buf+8);
352 wordstream_size= get32(buf+12);
353 bytestream_size= get32(buf+16);
356 bitstream_size = AV_RL16(buf-4);
357 wordstream_size= AV_RL16(buf-2);
358 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
361 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
362 || bitstream_size > (1<<26)
363 || bytestream_size > (1<<26)
364 || wordstream_size > (1<<26)
366 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
367 bitstream_size+ bytestream_size+ wordstream_size - length);
371 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
372 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + extra), bitstream_size/4);
373 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
375 f->wordstream= (uint16_t*)(buf + extra + bitstream_size);
376 f->bytestream= buf + extra + bitstream_size + wordstream_size;
380 for(y=0; y<height; y+=8){
381 for(x=0; x<width; x+=8){
382 decode_p_block(f, dst + x, src + x, 3, 3, stride);
388 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
389 || (((char*)f->wordstream - (char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
390 || (((char*)f->bytestream - (char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
391 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
392 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
393 -(((char*)f->bytestream - (char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
394 -(((char*)f->wordstream - (char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
401 * decode block and dequantize.
402 * Note this is allmost identical to mjpeg
404 static int decode_i_block(FourXContext *f, DCTELEM *block){
405 int code, i, j, level, val;
408 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
410 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
414 val = get_xbits(&f->gb, val);
416 val = val * dequant_table[0] + f->last_dc;
422 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
430 level = get_xbits(&f->gb, code & 0xf);
433 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
437 j= ff_zigzag_direct[i];
438 block[j] = level * dequant_table[j];
448 static inline void idct_put(FourXContext *f, int x, int y){
449 DCTELEM (*block)[64]= f->block;
450 int stride= f->current_picture.linesize[0]>>1;
452 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
455 block[i][0] += 0x80*8*8;
459 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
460 for(i=4; i<6; i++) idct(block[i]);
463 /* Note transform is:
464 y= ( 1b + 4g + 2r)/14
465 cb=( 3b - 2g - 1r)/14
466 cr=(-1b - 4g + 5r)/14
470 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
471 int cb= block[4][x + 8*y];
472 int cr= block[5][x + 8*y];
473 int cg= (cb + cr)>>1;
479 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
481 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
483 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
485 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
488 dst += 2*stride - 2*8;
492 static int decode_i_mb(FourXContext *f){
495 f->dsp.clear_blocks(f->block[0]);
498 if(decode_i_block(f, f->block[i]) < 0)
505 static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
509 uint8_t len_tab[257];
515 memset(frequency, 0, sizeof(frequency));
516 memset(up, -1, sizeof(up));
523 for(i=start; i<=end; i++){
524 frequency[i]= *ptr++;
533 while((ptr - buf)&3) ptr++; // 4byte align
535 for(j=257; j<512; j++){
536 int min_freq[2]= {256*256, 256*256};
537 int smallest[2]= {0, 0};
540 if(frequency[i] == 0) continue;
541 if(frequency[i] < min_freq[1]){
542 if(frequency[i] < min_freq[0]){
543 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
544 min_freq[0]= frequency[i];smallest[0]= i;
546 min_freq[1]= frequency[i];smallest[1]= i;
550 if(min_freq[1] == 256*256) break;
552 frequency[j]= min_freq[0] + min_freq[1];
553 flag[ smallest[0] ]= 0;
554 flag[ smallest[1] ]= 1;
556 up[ smallest[1] ]= j;
557 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
560 for(j=0; j<257; j++){
565 for(node= j; up[node] != -1; node= up[node]){
566 bits += flag[node]<<len;
568 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
575 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
582 static int mix(int c0, int c1){
583 int blue = 2*(c0&0x001F) + (c1&0x001F);
584 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
585 int red = 2*(c0>>10) + (c1>>10);
586 return red/3*1024 + green/3*32 + blue/3;
589 static int decode_i2_frame(FourXContext *f, uint8_t *buf, int length){
591 const int width= f->avctx->width;
592 const int height= f->avctx->height;
593 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
594 const int stride= f->current_picture.linesize[0]>>1;
596 for(y=0; y<height; y+=16){
597 for(x=0; x<width; x+=16){
598 unsigned int color[4], bits;
599 memset(color, 0, sizeof(color));
600 //warning following is purely guessed ...
601 color[0]= bytestream_get_le16(&buf);
602 color[1]= bytestream_get_le16(&buf);
604 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
605 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
607 color[2]= mix(color[0], color[1]);
608 color[3]= mix(color[1], color[0]);
610 bits= bytestream_get_le32(&buf);
611 for(y2=0; y2<16; y2++){
612 for(x2=0; x2<16; x2++){
613 int index= 2*(x2>>2) + 8*(y2>>2);
614 dst[y2*stride+x2]= color[(bits>>index)&3];
619 dst += 16*stride - width;
625 static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
627 const int width= f->avctx->width;
628 const int height= f->avctx->height;
629 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
630 const int stride= f->current_picture.linesize[0]>>1;
631 const unsigned int bitstream_size= get32(buf);
632 const int token_count av_unused = get32(buf + bitstream_size + 8);
633 unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
634 uint8_t *prestream= buf + bitstream_size + 12;
636 if(prestream_size + bitstream_size + 12 != length
637 || bitstream_size > (1<<26)
638 || prestream_size > (1<<26)){
639 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
643 prestream= read_huffman_tables(f, prestream);
645 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
647 prestream_size= length + buf - prestream;
649 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
650 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
651 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
653 f->last_dc= 0*128*8*8;
655 for(y=0; y<height; y+=16){
656 for(x=0; x<width; x+=16){
657 if(decode_i_mb(f) < 0)
665 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
666 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
671 static int decode_frame(AVCodecContext *avctx,
672 void *data, int *data_size,
673 uint8_t *buf, int buf_size)
675 FourXContext * const f = avctx->priv_data;
676 AVFrame *picture = data;
678 int i, frame_4cc, frame_size;
680 frame_4cc= get32(buf);
681 if(buf_size != get32(buf+4)+8 || buf_size < 20){
682 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
685 if(frame_4cc == ff_get_fourcc("cfrm")){
687 const int data_size= buf_size - 20;
688 const int id= get32(buf+12);
689 const int whole_size= get32(buf+16);
692 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
693 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
694 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
697 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
698 if(f->cfrm[i].id == id) break;
699 if(f->cfrm[i].size == 0 ) free_index= i;
702 if(i>=CFRAME_BUFFER_COUNT){
708 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
709 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
710 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
714 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
715 cfrm->size += data_size;
717 if(cfrm->size >= whole_size){
719 frame_size= cfrm->size;
721 if(id != avctx->frame_number){
722 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
725 cfrm->size= cfrm->id= 0;
726 frame_4cc= ff_get_fourcc("pfrm");
731 frame_size= buf_size - 12;
734 temp= f->current_picture;
735 f->current_picture= f->last_picture;
736 f->last_picture= temp;
738 p= &f->current_picture;
739 avctx->coded_frame= p;
741 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
744 avctx->release_buffer(avctx, p);
747 if(avctx->get_buffer(avctx, p) < 0){
748 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
752 if(frame_4cc == ff_get_fourcc("ifr2")){
753 p->pict_type= I_TYPE;
754 if(decode_i2_frame(f, buf-4, frame_size) < 0)
756 }else if(frame_4cc == ff_get_fourcc("ifrm")){
757 p->pict_type= I_TYPE;
758 if(decode_i_frame(f, buf, frame_size) < 0)
760 }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
761 p->pict_type= P_TYPE;
762 if(decode_p_frame(f, buf, frame_size) < 0)
764 }else if(frame_4cc == ff_get_fourcc("snd_")){
765 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
767 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
770 p->key_frame= p->pict_type == I_TYPE;
773 *data_size = sizeof(AVPicture);
781 static void common_init(AVCodecContext *avctx){
782 FourXContext * const f = avctx->priv_data;
784 dsputil_init(&f->dsp, avctx);
789 static int decode_init(AVCodecContext *avctx){
790 FourXContext * const f = avctx->priv_data;
792 if(avctx->extradata_size != 4 || !avctx->extradata) {
793 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
797 f->version= AV_RL32(avctx->extradata) == 0x40000;
801 if(f->version) avctx->pix_fmt= PIX_FMT_RGB565;
802 else avctx->pix_fmt= PIX_FMT_RGB555;
808 static int decode_end(AVCodecContext *avctx){
809 FourXContext * const f = avctx->priv_data;
812 av_freep(&f->bitstream_buffer);
813 f->bitstream_buffer_size=0;
814 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
815 av_freep(&f->cfrm[i].data);
816 f->cfrm[i].allocated_size= 0;
818 free_vlc(&f->pre_vlc);
823 AVCodec fourxm_decoder = {
827 sizeof(FourXContext),