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"
34 #define BLOCK_TYPE_VLC_BITS 5
35 #define ACDC_VLC_BITS 9
37 #define CFRAME_BUFFER_COUNT 100
39 static const uint8_t block_type_tab[4][8][2]={
41 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
43 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
45 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
47 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
51 static const uint8_t size2index[4][4]={
58 static const int8_t mv[256][2]={
59 { 0, 0},{ 0, -1},{ -1, 0},{ 1, 0},{ 0, 1},{ -1, -1},{ 1, -1},{ -1, 1},
60 { 1, 1},{ 0, -2},{ -2, 0},{ 2, 0},{ 0, 2},{ -1, -2},{ 1, -2},{ -2, -1},
61 { 2, -1},{ -2, 1},{ 2, 1},{ -1, 2},{ 1, 2},{ -2, -2},{ 2, -2},{ -2, 2},
62 { 2, 2},{ 0, -3},{ -3, 0},{ 3, 0},{ 0, 3},{ -1, -3},{ 1, -3},{ -3, -1},
63 { 3, -1},{ -3, 1},{ 3, 1},{ -1, 3},{ 1, 3},{ -2, -3},{ 2, -3},{ -3, -2},
64 { 3, -2},{ -3, 2},{ 3, 2},{ -2, 3},{ 2, 3},{ 0, -4},{ -4, 0},{ 4, 0},
65 { 0, 4},{ -1, -4},{ 1, -4},{ -4, -1},{ 4, -1},{ 4, 1},{ -1, 4},{ 1, 4},
66 { -3, -3},{ -3, 3},{ 3, 3},{ -2, -4},{ -4, -2},{ 4, -2},{ -4, 2},{ -2, 4},
67 { 2, 4},{ -3, -4},{ 3, -4},{ 4, -3},{ -5, 0},{ -4, 3},{ -3, 4},{ 3, 4},
68 { -1, -5},{ -5, -1},{ -5, 1},{ -1, 5},{ -2, -5},{ 2, -5},{ 5, -2},{ 5, 2},
69 { -4, -4},{ -4, 4},{ -3, -5},{ -5, -3},{ -5, 3},{ 3, 5},{ -6, 0},{ 0, 6},
70 { -6, -1},{ -6, 1},{ 1, 6},{ 2, -6},{ -6, 2},{ 2, 6},{ -5, -4},{ 5, 4},
71 { 4, 5},{ -6, -3},{ 6, 3},{ -7, 0},{ -1, -7},{ 5, -5},{ -7, 1},{ -1, 7},
72 { 4, -6},{ 6, 4},{ -2, -7},{ -7, 2},{ -3, -7},{ 7, -3},{ 3, 7},{ 6, -5},
73 { 0, -8},{ -1, -8},{ -7, -4},{ -8, 1},{ 4, 7},{ 2, -8},{ -2, 8},{ 6, 6},
74 { -8, 3},{ 5, -7},{ -5, 7},{ 8, -4},{ 0, -9},{ -9, -1},{ 1, 9},{ 7, -6},
75 { -7, 6},{ -5, -8},{ -5, 8},{ -9, 3},{ 9, -4},{ 7, -7},{ 8, -6},{ 6, 8},
76 { 10, 1},{-10, 2},{ 9, -5},{ 10, -3},{ -8, -7},{-10, -4},{ 6, -9},{-11, 0},
77 { 11, 1},{-11, -2},{ -2, 11},{ 7, -9},{ -7, 9},{ 10, 6},{ -4, 11},{ 8, -9},
78 { 8, 9},{ 5, 11},{ 7,-10},{ 12, -3},{ 11, 6},{ -9, -9},{ 8, 10},{ 5, 12},
79 {-11, 7},{ 13, 2},{ 6,-12},{ 10, 9},{-11, 8},{ -7, 12},{ 0, 14},{ 14, -2},
80 { -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{ 5, 14},{-15, -1},{-14, -6},{ 3,-15},
81 { 11,-11},{ -7, 14},{ -5, 15},{ 8,-14},{ 15, 6},{ 3, 16},{ 7,-15},{-16, 5},
82 { 0, 17},{-16, -6},{-10, 14},{-16, 7},{ 12, 13},{-16, 8},{-17, 6},{-18, 3},
83 { -7, 17},{ 15, 11},{ 16, 10},{ 2,-19},{ 3,-19},{-11,-16},{-18, 8},{-19, -6},
84 { 2,-20},{-17,-11},{-10,-18},{ 8, 19},{-21, -1},{-20, 7},{ -4, 21},{ 21, 5},
85 { 15, 16},{ 2,-22},{-10,-20},{-22, 5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
86 { 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
87 { 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27, 6},{ 1,-28},
88 {-11, 26},{-17,-23},{ 7, 28},{ 11,-27},{ 29, 5},{-23,-19},{-28,-11},{-21, 22},
89 {-30, 7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
90 {-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
93 // this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
94 static const uint8_t dequant_table[64]={
95 16, 15, 13, 19, 24, 31, 28, 17,
96 17, 23, 25, 31, 36, 63, 45, 21,
97 18, 24, 27, 37, 52, 59, 49, 20,
98 16, 28, 34, 40, 60, 80, 51, 20,
99 18, 31, 48, 66, 68, 86, 56, 21,
100 19, 38, 56, 59, 64, 64, 48, 20,
101 27, 48, 55, 55, 56, 51, 35, 15,
102 20, 35, 34, 32, 31, 22, 15, 8,
105 static VLC block_type_vlc[4];
108 typedef struct CFrameBuffer{
109 unsigned int allocated_size;
115 typedef struct FourXContext{
116 AVCodecContext *avctx;
118 AVFrame current_picture, last_picture;
119 GetBitContext pre_gb; ///< ac/dc prefix
122 uint16_t *wordstream;
126 DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
127 uint8_t *bitstream_buffer;
128 unsigned int bitstream_buffer_size;
129 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
133 #define FIX_1_082392200 70936
134 #define FIX_1_414213562 92682
135 #define FIX_1_847759065 121095
136 #define FIX_2_613125930 171254
138 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
140 static void idct(DCTELEM block[64]){
141 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
142 int tmp10, tmp11, tmp12, tmp13;
143 int z5, z10, z11, z12, z13;
148 tmp10 = block[8*0 + i] + block[8*4 + i];
149 tmp11 = block[8*0 + i] - block[8*4 + i];
151 tmp13 = block[8*2 + i] + block[8*6 + i];
152 tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
154 tmp0 = tmp10 + tmp13;
155 tmp3 = tmp10 - tmp13;
156 tmp1 = tmp11 + tmp12;
157 tmp2 = tmp11 - tmp12;
159 z13 = block[8*5 + i] + block[8*3 + i];
160 z10 = block[8*5 + i] - block[8*3 + i];
161 z11 = block[8*1 + i] + block[8*7 + i];
162 z12 = block[8*1 + i] - block[8*7 + i];
165 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
167 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
168 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
169 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
175 temp[8*0 + i] = tmp0 + tmp7;
176 temp[8*7 + i] = tmp0 - tmp7;
177 temp[8*1 + i] = tmp1 + tmp6;
178 temp[8*6 + i] = tmp1 - tmp6;
179 temp[8*2 + i] = tmp2 + tmp5;
180 temp[8*5 + i] = tmp2 - tmp5;
181 temp[8*4 + i] = tmp3 + tmp4;
182 temp[8*3 + i] = tmp3 - tmp4;
185 for(i=0; i<8*8; i+=8){
186 tmp10 = temp[0 + i] + temp[4 + i];
187 tmp11 = temp[0 + i] - temp[4 + i];
189 tmp13 = temp[2 + i] + temp[6 + i];
190 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
192 tmp0 = tmp10 + tmp13;
193 tmp3 = tmp10 - tmp13;
194 tmp1 = tmp11 + tmp12;
195 tmp2 = tmp11 - tmp12;
197 z13 = temp[5 + i] + temp[3 + i];
198 z10 = temp[5 + i] - temp[3 + i];
199 z11 = temp[1 + i] + temp[7 + i];
200 z12 = temp[1 + i] - temp[7 + i];
203 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
205 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
206 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
207 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
213 block[0 + i] = (tmp0 + tmp7)>>6;
214 block[7 + i] = (tmp0 - tmp7)>>6;
215 block[1 + i] = (tmp1 + tmp6)>>6;
216 block[6 + i] = (tmp1 - tmp6)>>6;
217 block[2 + i] = (tmp2 + tmp5)>>6;
218 block[5 + i] = (tmp2 - tmp5)>>6;
219 block[4 + i] = (tmp3 + tmp4)>>6;
220 block[3 + i] = (tmp3 - tmp4)>>6;
224 static void init_vlcs(FourXContext *f){
228 init_vlc(&block_type_vlc[i], BLOCK_TYPE_VLC_BITS, 7,
229 &block_type_tab[i][0][1], 2, 1,
230 &block_type_tab[i][0][0], 2, 1, 1);
234 static void init_mv(FourXContext *f){
237 for(i=0; i<256; i++){
238 f->mv[i] = mv[i][0] + mv[i][1]*f->current_picture.linesize[0]/2;
242 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
249 dst[0] = scale*src[0] + dc;
250 if(scale) src += stride;
256 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
257 if(scale) src += stride;
263 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
264 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
265 if(scale) src += stride;
271 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
272 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
273 ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
274 ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
275 if(scale) src += stride;
283 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
284 const int index= size2index[log2h][log2w];
285 const int h= 1<<log2h;
286 int code= get_vlc2(&f->gb, block_type_vlc[index].table, BLOCK_TYPE_VLC_BITS, 1);
288 assert(code>=0 && code<=6);
291 src += f->mv[ *f->bytestream++ ];
292 mcdc(dst, src, log2w, h, stride, 1, 0);
295 decode_p_block(f, dst , src , log2w, log2h, stride);
296 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
299 decode_p_block(f, dst , src , log2w, log2h, stride);
300 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
302 src += f->mv[ *f->bytestream++ ];
303 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
305 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
308 dst[0] = le2me_16(*f->wordstream++);
309 dst[1] = le2me_16(*f->wordstream++);
311 dst[0 ] = le2me_16(*f->wordstream++);
312 dst[stride] = le2me_16(*f->wordstream++);
317 static int get32(void *p){
318 return le2me_32(*(uint32_t*)p);
321 static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
323 const int width= f->avctx->width;
324 const int height= f->avctx->height;
325 uint16_t *src= (uint16_t*)f->last_picture.data[0];
326 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
327 const int stride= f->current_picture.linesize[0]>>1;
328 const unsigned int bitstream_size= get32(buf+8);
329 const unsigned int bytestream_size= get32(buf+16);
330 const unsigned int wordstream_size= get32(buf+12);
332 if(bitstream_size+ bytestream_size+ wordstream_size + 20 != length
333 || bitstream_size > (1<<26)
334 || bytestream_size > (1<<26)
335 || wordstream_size > (1<<26)
337 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
338 bitstream_size+ bytestream_size+ wordstream_size - length);
342 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
343 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + 20), bitstream_size/4);
344 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
346 f->wordstream= (uint16_t*)(buf + 20 + bitstream_size);
347 f->bytestream= buf + 20 + bitstream_size + wordstream_size;
351 for(y=0; y<height; y+=8){
352 for(x=0; x<width; x+=8){
353 decode_p_block(f, dst + x, src + x, 3, 3, stride);
359 if(bitstream_size != (get_bits_count(&f->gb)+31)/32*4)
360 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
361 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
362 bytestream_size - (f->bytestream - (buf + 20 + bitstream_size + wordstream_size)),
363 wordstream_size - (((uint8_t*)f->wordstream) - (buf + 20 + bitstream_size))
370 * decode block and dequantize.
371 * Note this is allmost identical to mjpeg
373 static int decode_i_block(FourXContext *f, DCTELEM *block){
374 int code, i, j, level, val;
377 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
379 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
383 val = get_xbits(&f->gb, val);
385 val = val * dequant_table[0] + f->last_dc;
391 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
399 level = get_xbits(&f->gb, code & 0xf);
402 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
406 j= ff_zigzag_direct[i];
407 block[j] = level * dequant_table[j];
417 static inline void idct_put(FourXContext *f, int x, int y){
418 DCTELEM (*block)[64]= f->block;
419 int stride= f->current_picture.linesize[0]>>1;
421 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
424 block[i][0] += 0x80*8*8;
428 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
429 for(i=4; i<6; i++) idct(block[i]);
432 /* Note transform is:
433 y= ( 1b + 4g + 2r)/14
434 cb=( 3b - 2g - 1r)/14
435 cr=(-1b - 4g + 5r)/14
439 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
440 int cb= block[4][x + 8*y];
441 int cr= block[5][x + 8*y];
442 int cg= (cb + cr)>>1;
448 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
450 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
452 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
454 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
457 dst += 2*stride - 2*8;
461 static int decode_i_mb(FourXContext *f){
464 f->dsp.clear_blocks(f->block[0]);
467 if(decode_i_block(f, f->block[i]) < 0)
474 static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
478 uint8_t len_tab[257];
484 memset(frequency, 0, sizeof(frequency));
485 memset(up, -1, sizeof(up));
492 for(i=start; i<=end; i++){
493 frequency[i]= *ptr++;
494 // printf("%d %d %d\n", start, end, frequency[i]);
503 while((ptr - buf)&3) ptr++; // 4byte align
505 // for(j=0; j<16; j++)
506 // printf("%2X", ptr[j]);
508 for(j=257; j<512; j++){
509 int min_freq[2]= {256*256, 256*256};
510 int smallest[2]= {0, 0};
513 if(frequency[i] == 0) continue;
514 if(frequency[i] < min_freq[1]){
515 if(frequency[i] < min_freq[0]){
516 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
517 min_freq[0]= frequency[i];smallest[0]= i;
519 min_freq[1]= frequency[i];smallest[1]= i;
523 if(min_freq[1] == 256*256) break;
525 frequency[j]= min_freq[0] + min_freq[1];
526 flag[ smallest[0] ]= 0;
527 flag[ smallest[1] ]= 1;
529 up[ smallest[1] ]= j;
530 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
533 for(j=0; j<257; j++){
538 for(node= j; up[node] != -1; node= up[node]){
539 bits += flag[node]<<len;
541 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
548 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
555 static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
557 const int width= f->avctx->width;
558 const int height= f->avctx->height;
559 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
560 const int stride= f->current_picture.linesize[0]>>1;
561 const unsigned int bitstream_size= get32(buf);
562 const int token_count __attribute__((unused)) = get32(buf + bitstream_size + 8);
563 unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
564 uint8_t *prestream= buf + bitstream_size + 12;
566 if(prestream_size + bitstream_size + 12 != length
567 || bitstream_size > (1<<26)
568 || prestream_size > (1<<26)){
569 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
573 prestream= read_huffman_tables(f, prestream);
575 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
577 prestream_size= length + buf - prestream;
579 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
580 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
581 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
583 f->last_dc= 0*128*8*8;
585 for(y=0; y<height; y+=16){
586 for(x=0; x<width; x+=16){
587 if(decode_i_mb(f) < 0)
595 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
596 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
601 static int decode_frame(AVCodecContext *avctx,
602 void *data, int *data_size,
603 uint8_t *buf, int buf_size)
605 FourXContext * const f = avctx->priv_data;
606 AVFrame *picture = data;
608 int i, frame_4cc, frame_size;
610 frame_4cc= get32(buf);
611 if(buf_size != get32(buf+4)+8 || buf_size < 20){
612 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
615 if(frame_4cc == ff_get_fourcc("cfrm")){
617 const int data_size= buf_size - 20;
618 const int id= get32(buf+12);
619 const int whole_size= get32(buf+16);
622 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
623 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
624 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
627 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
628 if(f->cfrm[i].id == id) break;
629 if(f->cfrm[i].size == 0 ) free_index= i;
632 if(i>=CFRAME_BUFFER_COUNT){
638 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
639 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
640 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
644 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
645 cfrm->size += data_size;
647 if(cfrm->size >= whole_size){
649 frame_size= cfrm->size;
651 if(id != avctx->frame_number){
652 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
655 cfrm->size= cfrm->id= 0;
656 frame_4cc= ff_get_fourcc("pfrm");
661 frame_size= buf_size - 12;
664 temp= f->current_picture;
665 f->current_picture= f->last_picture;
666 f->last_picture= temp;
668 p= &f->current_picture;
669 avctx->coded_frame= p;
671 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
674 avctx->release_buffer(avctx, p);
677 if(avctx->get_buffer(avctx, p) < 0){
678 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
682 if(frame_4cc == ff_get_fourcc("ifrm")){
683 p->pict_type= I_TYPE;
684 if(decode_i_frame(f, buf, frame_size) < 0)
686 }else if(frame_4cc == ff_get_fourcc("pfrm")){
687 p->pict_type= P_TYPE;
688 if(decode_p_frame(f, buf, frame_size) < 0)
690 }else if(frame_4cc == ff_get_fourcc("snd_")){
691 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
693 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
698 printf("%2X %c ", buf[i], clip(buf[i],16,126));
702 p->key_frame= p->pict_type == I_TYPE;
705 *data_size = sizeof(AVPicture);
713 static void common_init(AVCodecContext *avctx){
714 FourXContext * const f = avctx->priv_data;
716 dsputil_init(&f->dsp, avctx);
721 static int decode_init(AVCodecContext *avctx){
722 FourXContext * const f = avctx->priv_data;
727 avctx->pix_fmt= PIX_FMT_RGB565;
733 static int decode_end(AVCodecContext *avctx){
734 FourXContext * const f = avctx->priv_data;
737 av_freep(&f->bitstream_buffer);
738 f->bitstream_buffer_size=0;
739 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
740 av_freep(&f->cfrm[i].data);
741 f->cfrm[i].allocated_size= 0;
743 free_vlc(&f->pre_vlc);
748 AVCodec fourxm_decoder = {
752 sizeof(FourXContext),