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>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
304 uint16_t *start= f->last_picture.data[0];
305 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
307 assert(code>=0 && code<=6);
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");
315 mcdc(dst, src, log2w, h, stride, 1, 0);
318 decode_p_block(f, dst , src , log2w, log2h, stride);
319 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
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);
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");
332 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
334 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
337 dst[0] = le2me_16(*f->wordstream++);
338 dst[1] = le2me_16(*f->wordstream++);
340 dst[0 ] = le2me_16(*f->wordstream++);
341 dst[stride] = le2me_16(*f->wordstream++);
346 static int get32(void *p){
347 return le2me_32(*(uint32_t*)p);
350 static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
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;
361 bitstream_size= get32(buf+8);
362 wordstream_size= get32(buf+12);
363 bytestream_size= get32(buf+16);
366 bitstream_size = AV_RL16(buf-4);
367 wordstream_size= AV_RL16(buf-2);
368 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
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)
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);
381 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
382 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + extra), bitstream_size/4);
383 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
385 f->wordstream= (uint16_t*)(buf + extra + bitstream_size);
386 f->bytestream= buf + extra + bitstream_size + wordstream_size;
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);
398 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
399 || (((char*)f->wordstream - (char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
400 || (((char*)f->bytestream - (char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
401 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
402 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
403 -(((char*)f->bytestream - (char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
404 -(((char*)f->wordstream - (char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
411 * decode block and dequantize.
412 * Note this is allmost identical to mjpeg
414 static int decode_i_block(FourXContext *f, DCTELEM *block){
415 int code, i, j, level, val;
418 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
420 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
424 val = get_xbits(&f->gb, val);
426 val = val * dequant_table[0] + f->last_dc;
432 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
440 level = get_xbits(&f->gb, code & 0xf);
443 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
447 j= ff_zigzag_direct[i];
448 block[j] = level * dequant_table[j];
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;
462 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
465 block[i][0] += 0x80*8*8;
469 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
470 for(i=4; i<6; i++) idct(block[i]);
473 /* Note transform is:
474 y= ( 1b + 4g + 2r)/14
475 cb=( 3b - 2g - 1r)/14
476 cr=(-1b - 4g + 5r)/14
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;
489 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
491 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
493 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
495 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
498 dst += 2*stride - 2*8;
502 static int decode_i_mb(FourXContext *f){
505 f->dsp.clear_blocks(f->block[0]);
508 if(decode_i_block(f, f->block[i]) < 0)
515 static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
519 uint8_t len_tab[257];
525 memset(frequency, 0, sizeof(frequency));
526 memset(up, -1, sizeof(up));
533 for(i=start; i<=end; i++){
534 frequency[i]= *ptr++;
543 while((ptr - buf)&3) ptr++; // 4byte align
545 for(j=257; j<512; j++){
546 int min_freq[2]= {256*256, 256*256};
547 int smallest[2]= {0, 0};
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;
556 min_freq[1]= frequency[i];smallest[1]= i;
560 if(min_freq[1] == 256*256) break;
562 frequency[j]= min_freq[0] + min_freq[1];
563 flag[ smallest[0] ]= 0;
564 flag[ smallest[1] ]= 1;
566 up[ smallest[1] ]= j;
567 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
570 for(j=0; j<257; j++){
575 for(node= j; up[node] != -1; node= up[node]){
576 bits += flag[node]<<len;
578 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
585 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
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;
599 static int decode_i2_frame(FourXContext *f, uint8_t *buf, int length){
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;
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);
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");
617 color[2]= mix(color[0], color[1]);
618 color[3]= mix(color[1], color[0]);
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];
629 dst += 16*stride - width;
635 static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
637 const int width= f->avctx->width;
638 const int height= f->avctx->height;
639 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
640 const int stride= f->current_picture.linesize[0]>>1;
641 const unsigned int bitstream_size= get32(buf);
642 const int token_count av_unused = get32(buf + bitstream_size + 8);
643 unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
644 uint8_t *prestream= buf + bitstream_size + 12;
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);
653 prestream= read_huffman_tables(f, prestream);
655 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
657 prestream_size= length + buf - prestream;
659 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
660 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
661 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
663 f->last_dc= 0*128*8*8;
665 for(y=0; y<height; y+=16){
666 for(x=0; x<width; x+=16){
667 if(decode_i_mb(f) < 0)
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");
681 static int decode_frame(AVCodecContext *avctx,
682 void *data, int *data_size,
683 uint8_t *buf, int buf_size)
685 FourXContext * const f = avctx->priv_data;
686 AVFrame *picture = data;
688 int i, frame_4cc, frame_size;
690 frame_4cc= get32(buf);
691 if(buf_size != get32(buf+4)+8 || buf_size < 20){
692 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
695 if(frame_4cc == ff_get_fourcc("cfrm")){
697 const int data_size= buf_size - 20;
698 const int id= get32(buf+12);
699 const int whole_size= get32(buf+16);
702 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
703 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
704 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
707 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
708 if(f->cfrm[i].id == id) break;
709 if(f->cfrm[i].size == 0 ) free_index= i;
712 if(i>=CFRAME_BUFFER_COUNT){
718 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
719 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
720 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
724 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
725 cfrm->size += data_size;
727 if(cfrm->size >= whole_size){
729 frame_size= cfrm->size;
731 if(id != avctx->frame_number){
732 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
735 cfrm->size= cfrm->id= 0;
736 frame_4cc= ff_get_fourcc("pfrm");
741 frame_size= buf_size - 12;
744 temp= f->current_picture;
745 f->current_picture= f->last_picture;
746 f->last_picture= temp;
748 p= &f->current_picture;
749 avctx->coded_frame= p;
751 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
754 avctx->release_buffer(avctx, p);
757 if(avctx->get_buffer(avctx, p) < 0){
758 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
762 if(frame_4cc == ff_get_fourcc("ifr2")){
763 p->pict_type= I_TYPE;
764 if(decode_i2_frame(f, buf-4, frame_size) < 0)
766 }else if(frame_4cc == ff_get_fourcc("ifrm")){
767 p->pict_type= I_TYPE;
768 if(decode_i_frame(f, buf, frame_size) < 0)
770 }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
771 p->pict_type= P_TYPE;
772 if(decode_p_frame(f, buf, frame_size) < 0)
774 }else if(frame_4cc == ff_get_fourcc("snd_")){
775 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
777 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
780 p->key_frame= p->pict_type == I_TYPE;
783 *data_size = sizeof(AVPicture);
791 static void common_init(AVCodecContext *avctx){
792 FourXContext * const f = avctx->priv_data;
794 dsputil_init(&f->dsp, avctx);
799 static int decode_init(AVCodecContext *avctx){
800 FourXContext * const f = avctx->priv_data;
802 if(avctx->extradata_size != 4 || !avctx->extradata) {
803 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
807 f->version= AV_RL32(avctx->extradata)>>16;
811 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
812 else avctx->pix_fmt= PIX_FMT_RGB555;
818 static int decode_end(AVCodecContext *avctx){
819 FourXContext * const f = avctx->priv_data;
822 av_freep(&f->bitstream_buffer);
823 f->bitstream_buffer_size=0;
824 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
825 av_freep(&f->cfrm[i].data);
826 f->cfrm[i].allocated_size= 0;
828 free_vlc(&f->pre_vlc);
833 AVCodec fourxm_decoder = {
837 sizeof(FourXContext),