00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00025 #include "avcodec.h"
00026 #include "dsputil.h"
00027 #include "mpegvideo.h"
00028
00029
00030
00031
00032 #define BLOCK_TYPE_VLC_BITS 5
00033 #define ACDC_VLC_BITS 9
00034
00035 #define CFRAME_BUFFER_COUNT 100
00036
00037 static const uint8_t block_type_tab[4][8][2]={
00038 {
00039 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
00040 },{
00041 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
00042 },{
00043 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
00044 },{
00045 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
00046 }
00047 };
00048
00049 static const uint8_t size2index[4][4]={
00050 {-1, 3, 1, 1},
00051 { 3, 0, 0, 0},
00052 { 2, 0, 0, 0},
00053 { 2, 0, 0, 0},
00054 };
00055
00056 static const int8_t mv[256][2]={
00057 { 0, 0},{ 0, -1},{ -1, 0},{ 1, 0},{ 0, 1},{ -1, -1},{ 1, -1},{ -1, 1},
00058 { 1, 1},{ 0, -2},{ -2, 0},{ 2, 0},{ 0, 2},{ -1, -2},{ 1, -2},{ -2, -1},
00059 { 2, -1},{ -2, 1},{ 2, 1},{ -1, 2},{ 1, 2},{ -2, -2},{ 2, -2},{ -2, 2},
00060 { 2, 2},{ 0, -3},{ -3, 0},{ 3, 0},{ 0, 3},{ -1, -3},{ 1, -3},{ -3, -1},
00061 { 3, -1},{ -3, 1},{ 3, 1},{ -1, 3},{ 1, 3},{ -2, -3},{ 2, -3},{ -3, -2},
00062 { 3, -2},{ -3, 2},{ 3, 2},{ -2, 3},{ 2, 3},{ 0, -4},{ -4, 0},{ 4, 0},
00063 { 0, 4},{ -1, -4},{ 1, -4},{ -4, -1},{ 4, -1},{ 4, 1},{ -1, 4},{ 1, 4},
00064 { -3, -3},{ -3, 3},{ 3, 3},{ -2, -4},{ -4, -2},{ 4, -2},{ -4, 2},{ -2, 4},
00065 { 2, 4},{ -3, -4},{ 3, -4},{ 4, -3},{ -5, 0},{ -4, 3},{ -3, 4},{ 3, 4},
00066 { -1, -5},{ -5, -1},{ -5, 1},{ -1, 5},{ -2, -5},{ 2, -5},{ 5, -2},{ 5, 2},
00067 { -4, -4},{ -4, 4},{ -3, -5},{ -5, -3},{ -5, 3},{ 3, 5},{ -6, 0},{ 0, 6},
00068 { -6, -1},{ -6, 1},{ 1, 6},{ 2, -6},{ -6, 2},{ 2, 6},{ -5, -4},{ 5, 4},
00069 { 4, 5},{ -6, -3},{ 6, 3},{ -7, 0},{ -1, -7},{ 5, -5},{ -7, 1},{ -1, 7},
00070 { 4, -6},{ 6, 4},{ -2, -7},{ -7, 2},{ -3, -7},{ 7, -3},{ 3, 7},{ 6, -5},
00071 { 0, -8},{ -1, -8},{ -7, -4},{ -8, 1},{ 4, 7},{ 2, -8},{ -2, 8},{ 6, 6},
00072 { -8, 3},{ 5, -7},{ -5, 7},{ 8, -4},{ 0, -9},{ -9, -1},{ 1, 9},{ 7, -6},
00073 { -7, 6},{ -5, -8},{ -5, 8},{ -9, 3},{ 9, -4},{ 7, -7},{ 8, -6},{ 6, 8},
00074 { 10, 1},{-10, 2},{ 9, -5},{ 10, -3},{ -8, -7},{-10, -4},{ 6, -9},{-11, 0},
00075 { 11, 1},{-11, -2},{ -2, 11},{ 7, -9},{ -7, 9},{ 10, 6},{ -4, 11},{ 8, -9},
00076 { 8, 9},{ 5, 11},{ 7,-10},{ 12, -3},{ 11, 6},{ -9, -9},{ 8, 10},{ 5, 12},
00077 {-11, 7},{ 13, 2},{ 6,-12},{ 10, 9},{-11, 8},{ -7, 12},{ 0, 14},{ 14, -2},
00078 { -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{ 5, 14},{-15, -1},{-14, -6},{ 3,-15},
00079 { 11,-11},{ -7, 14},{ -5, 15},{ 8,-14},{ 15, 6},{ 3, 16},{ 7,-15},{-16, 5},
00080 { 0, 17},{-16, -6},{-10, 14},{-16, 7},{ 12, 13},{-16, 8},{-17, 6},{-18, 3},
00081 { -7, 17},{ 15, 11},{ 16, 10},{ 2,-19},{ 3,-19},{-11,-16},{-18, 8},{-19, -6},
00082 { 2,-20},{-17,-11},{-10,-18},{ 8, 19},{-21, -1},{-20, 7},{ -4, 21},{ 21, 5},
00083 { 15, 16},{ 2,-22},{-10,-20},{-22, 5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
00084 { 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
00085 { 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27, 6},{ 1,-28},
00086 {-11, 26},{-17,-23},{ 7, 28},{ 11,-27},{ 29, 5},{-23,-19},{-28,-11},{-21, 22},
00087 {-30, 7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
00088 {-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
00089 };
00090
00091
00092 static const uint8_t dequant_table[64]={
00093 16, 15, 13, 19, 24, 31, 28, 17,
00094 17, 23, 25, 31, 36, 63, 45, 21,
00095 18, 24, 27, 37, 52, 59, 49, 20,
00096 16, 28, 34, 40, 60, 80, 51, 20,
00097 18, 31, 48, 66, 68, 86, 56, 21,
00098 19, 38, 56, 59, 64, 64, 48, 20,
00099 27, 48, 55, 55, 56, 51, 35, 15,
00100 20, 35, 34, 32, 31, 22, 15, 8,
00101 };
00102
00103 static VLC block_type_vlc[4];
00104
00105
00106 typedef struct CFrameBuffer{
00107 int allocated_size;
00108 int size;
00109 int id;
00110 uint8_t *data;
00111 }CFrameBuffer;
00112
00113 typedef struct FourXContext{
00114 AVCodecContext *avctx;
00115 DSPContext dsp;
00116 AVFrame current_picture, last_picture;
00117 GetBitContext pre_gb;
00118 GetBitContext gb;
00119 uint8_t *bytestream;
00120 uint16_t *wordstream;
00121 int mv[256];
00122 VLC pre_vlc;
00123 int last_dc;
00124 DCTELEM __align8 block[6][64];
00125 uint8_t *bitstream_buffer;
00126 int bitstream_buffer_size;
00127 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
00128 } FourXContext;
00129
00130
00131 #define FIX_1_082392200 70936
00132 #define FIX_1_414213562 92682
00133 #define FIX_1_847759065 121095
00134 #define FIX_2_613125930 171254
00135
00136 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
00137
00138 static void idct(DCTELEM block[64]){
00139 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
00140 int tmp10, tmp11, tmp12, tmp13;
00141 int z5, z10, z11, z12, z13;
00142 int i;
00143 int temp[64];
00144
00145 for(i=0; i<8; i++){
00146 tmp10 = block[8*0 + i] + block[8*4 + i];
00147 tmp11 = block[8*0 + i] - block[8*4 + i];
00148
00149 tmp13 = block[8*2 + i] + block[8*6 + i];
00150 tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
00151
00152 tmp0 = tmp10 + tmp13;
00153 tmp3 = tmp10 - tmp13;
00154 tmp1 = tmp11 + tmp12;
00155 tmp2 = tmp11 - tmp12;
00156
00157 z13 = block[8*5 + i] + block[8*3 + i];
00158 z10 = block[8*5 + i] - block[8*3 + i];
00159 z11 = block[8*1 + i] + block[8*7 + i];
00160 z12 = block[8*1 + i] - block[8*7 + i];
00161
00162 tmp7 = z11 + z13;
00163 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
00164
00165 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
00166 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
00167 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
00168
00169 tmp6 = tmp12 - tmp7;
00170 tmp5 = tmp11 - tmp6;
00171 tmp4 = tmp10 + tmp5;
00172
00173 temp[8*0 + i] = tmp0 + tmp7;
00174 temp[8*7 + i] = tmp0 - tmp7;
00175 temp[8*1 + i] = tmp1 + tmp6;
00176 temp[8*6 + i] = tmp1 - tmp6;
00177 temp[8*2 + i] = tmp2 + tmp5;
00178 temp[8*5 + i] = tmp2 - tmp5;
00179 temp[8*4 + i] = tmp3 + tmp4;
00180 temp[8*3 + i] = tmp3 - tmp4;
00181 }
00182
00183 for(i=0; i<8*8; i+=8){
00184 tmp10 = temp[0 + i] + temp[4 + i];
00185 tmp11 = temp[0 + i] - temp[4 + i];
00186
00187 tmp13 = temp[2 + i] + temp[6 + i];
00188 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
00189
00190 tmp0 = tmp10 + tmp13;
00191 tmp3 = tmp10 - tmp13;
00192 tmp1 = tmp11 + tmp12;
00193 tmp2 = tmp11 - tmp12;
00194
00195 z13 = temp[5 + i] + temp[3 + i];
00196 z10 = temp[5 + i] - temp[3 + i];
00197 z11 = temp[1 + i] + temp[7 + i];
00198 z12 = temp[1 + i] - temp[7 + i];
00199
00200 tmp7 = z11 + z13;
00201 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
00202
00203 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
00204 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
00205 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
00206
00207 tmp6 = tmp12 - tmp7;
00208 tmp5 = tmp11 - tmp6;
00209 tmp4 = tmp10 + tmp5;
00210
00211 block[0 + i] = (tmp0 + tmp7)>>6;
00212 block[7 + i] = (tmp0 - tmp7)>>6;
00213 block[1 + i] = (tmp1 + tmp6)>>6;
00214 block[6 + i] = (tmp1 - tmp6)>>6;
00215 block[2 + i] = (tmp2 + tmp5)>>6;
00216 block[5 + i] = (tmp2 - tmp5)>>6;
00217 block[4 + i] = (tmp3 + tmp4)>>6;
00218 block[3 + i] = (tmp3 - tmp4)>>6;
00219 }
00220 }
00221
00222 static void init_vlcs(FourXContext *f){
00223 int i;
00224
00225 for(i=0; i<4; i++){
00226 init_vlc(&block_type_vlc[i], BLOCK_TYPE_VLC_BITS, 7,
00227 &block_type_tab[i][0][1], 2, 1,
00228 &block_type_tab[i][0][0], 2, 1, 1);
00229 }
00230 }
00231
00232 static void init_mv(FourXContext *f){
00233 int i;
00234
00235 for(i=0; i<256; i++){
00236 f->mv[i] = mv[i][0] + mv[i][1]*f->current_picture.linesize[0]/2;
00237 }
00238 }
00239
00240 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
00241 int i;
00242 dc*= 0x10001;
00243
00244 switch(log2w){
00245 case 0:
00246 for(i=0; i<h; i++){
00247 dst[0] = scale*src[0] + dc;
00248 if(scale) src += stride;
00249 dst += stride;
00250 }
00251 break;
00252 case 1:
00253 for(i=0; i<h; i++){
00254 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00255 if(scale) src += stride;
00256 dst += stride;
00257 }
00258 break;
00259 case 2:
00260 for(i=0; i<h; i++){
00261 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00262 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
00263 if(scale) src += stride;
00264 dst += stride;
00265 }
00266 break;
00267 case 3:
00268 for(i=0; i<h; i++){
00269 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00270 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
00271 ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
00272 ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
00273 if(scale) src += stride;
00274 dst += stride;
00275 }
00276 break;
00277 default: assert(0);
00278 }
00279 }
00280
00281 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
00282 const int index= size2index[log2h][log2w];
00283 const int h= 1<<log2h;
00284 int code= get_vlc2(&f->gb, block_type_vlc[index].table, BLOCK_TYPE_VLC_BITS, 1);
00285
00286 assert(code>=0 && code<=6);
00287
00288 if(code == 0){
00289 src += f->mv[ *f->bytestream++ ];
00290 mcdc(dst, src, log2w, h, stride, 1, 0);
00291 }else if(code == 1){
00292 log2h--;
00293 decode_p_block(f, dst , src , log2w, log2h, stride);
00294 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
00295 }else if(code == 2){
00296 log2w--;
00297 decode_p_block(f, dst , src , log2w, log2h, stride);
00298 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
00299 }else if(code == 4){
00300 src += f->mv[ *f->bytestream++ ];
00301 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
00302 }else if(code == 5){
00303 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
00304 }else if(code == 6){
00305 if(log2w){
00306 dst[0] = le2me_16(*f->wordstream++);
00307 dst[1] = le2me_16(*f->wordstream++);
00308 }else{
00309 dst[0 ] = le2me_16(*f->wordstream++);
00310 dst[stride] = le2me_16(*f->wordstream++);
00311 }
00312 }
00313 }
00314
00315 static int get32(void *p){
00316 return le2me_32(*(uint32_t*)p);
00317 }
00318
00319 static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
00320 int x, y;
00321 const int width= f->avctx->width;
00322 const int height= f->avctx->height;
00323 uint16_t *src= (uint16_t*)f->last_picture.data[0];
00324 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00325 const int stride= f->current_picture.linesize[0]>>1;
00326 const unsigned int bitstream_size= get32(buf+8);
00327 const unsigned int bytestream_size= get32(buf+16);
00328 const unsigned int wordstream_size= get32(buf+12);
00329
00330 if(bitstream_size+ bytestream_size+ wordstream_size + 20 != length
00331 || bitstream_size > (1<<26)
00332 || bytestream_size > (1<<26)
00333 || wordstream_size > (1<<26)
00334 ){
00335 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
00336 bitstream_size+ bytestream_size+ wordstream_size - length);
00337 return -1;
00338 }
00339
00340 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00341 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + 20), bitstream_size/4);
00342 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
00343
00344 f->wordstream= (uint16_t*)(buf + 20 + bitstream_size);
00345 f->bytestream= buf + 20 + bitstream_size + wordstream_size;
00346
00347 init_mv(f);
00348
00349 for(y=0; y<height; y+=8){
00350 for(x=0; x<width; x+=8){
00351 decode_p_block(f, dst + x, src + x, 3, 3, stride);
00352 }
00353 src += 8*stride;
00354 dst += 8*stride;
00355 }
00356
00357 if(bitstream_size != (get_bits_count(&f->gb)+31)/32*4)
00358 av_log(f->avctx, AV_LOG_ERROR, " %d %d %d bytes left\n",
00359 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
00360 bytestream_size - (f->bytestream - (buf + 20 + bitstream_size + wordstream_size)),
00361 wordstream_size - (((uint8_t*)f->wordstream) - (buf + 20 + bitstream_size))
00362 );
00363
00364 return 0;
00365 }
00366
00371 static int decode_i_block(FourXContext *f, DCTELEM *block){
00372 int code, i, j, level, val;
00373
00374
00375 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00376 if (val>>4){
00377 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
00378 }
00379
00380 if(val)
00381 val = get_xbits(&f->gb, val);
00382
00383 val = val * dequant_table[0] + f->last_dc;
00384 f->last_dc =
00385 block[0] = val;
00386
00387 i = 1;
00388 for(;;) {
00389 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00390
00391
00392 if (code == 0)
00393 break;
00394 if (code == 0xf0) {
00395 i += 16;
00396 } else {
00397 level = get_xbits(&f->gb, code & 0xf);
00398 i += code >> 4;
00399 if (i >= 64) {
00400 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
00401 return 0;
00402 }
00403
00404 j= ff_zigzag_direct[i];
00405 block[j] = level * dequant_table[j];
00406 i++;
00407 if (i >= 64)
00408 break;
00409 }
00410 }
00411
00412 return 0;
00413 }
00414
00415 static inline void idct_put(FourXContext *f, int x, int y){
00416 DCTELEM (*block)[64]= f->block;
00417 int stride= f->current_picture.linesize[0]>>1;
00418 int i;
00419 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
00420
00421 for(i=0; i<4; i++){
00422 block[i][0] += 0x80*8*8;
00423 idct(block[i]);
00424 }
00425
00426 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
00427 for(i=4; i<6; i++) idct(block[i]);
00428 }
00429
00430
00431
00432
00433
00434
00435 for(y=0; y<8; y++){
00436 for(x=0; x<8; x++){
00437 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
00438 int cb= block[4][x + 8*y];
00439 int cr= block[5][x + 8*y];
00440 int cg= (cb + cr)>>1;
00441 int y;
00442
00443 cb+=cb;
00444
00445 y = temp[0];
00446 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00447 y = temp[1];
00448 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00449 y = temp[8];
00450 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00451 y = temp[9];
00452 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00453 dst += 2;
00454 }
00455 dst += 2*stride - 2*8;
00456 }
00457 }
00458
00459 static int decode_i_mb(FourXContext *f){
00460 int i;
00461
00462 f->dsp.clear_blocks(f->block[0]);
00463
00464 for(i=0; i<6; i++){
00465 if(decode_i_block(f, f->block[i]) < 0)
00466 return -1;
00467 }
00468
00469 return 0;
00470 }
00471
00472 static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
00473 int frequency[512];
00474 uint8_t flag[512];
00475 int up[512];
00476 uint8_t len_tab[257];
00477 int bits_tab[257];
00478 int start, end;
00479 uint8_t *ptr= buf;
00480 int j;
00481
00482 memset(frequency, 0, sizeof(frequency));
00483 memset(up, -1, sizeof(up));
00484
00485 start= *ptr++;
00486 end= *ptr++;
00487 for(;;){
00488 int i;
00489
00490 for(i=start; i<=end; i++){
00491 frequency[i]= *ptr++;
00492
00493 }
00494 start= *ptr++;
00495 if(start==0) break;
00496
00497 end= *ptr++;
00498 }
00499 frequency[256]=1;
00500
00501 while((ptr - buf)&3) ptr++;
00502
00503
00504
00505
00506 for(j=257; j<512; j++){
00507 int min_freq[2]= {256*256, 256*256};
00508 int smallest[2]= {0, 0};
00509 int i;
00510 for(i=0; i<j; i++){
00511 if(frequency[i] == 0) continue;
00512 if(frequency[i] < min_freq[1]){
00513 if(frequency[i] < min_freq[0]){
00514 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
00515 min_freq[0]= frequency[i];smallest[0]= i;
00516 }else{
00517 min_freq[1]= frequency[i];smallest[1]= i;
00518 }
00519 }
00520 }
00521 if(min_freq[1] == 256*256) break;
00522
00523 frequency[j]= min_freq[0] + min_freq[1];
00524 flag[ smallest[0] ]= 0;
00525 flag[ smallest[1] ]= 1;
00526 up[ smallest[0] ]=
00527 up[ smallest[1] ]= j;
00528 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
00529 }
00530
00531 for(j=0; j<257; j++){
00532 int node;
00533 int len=0;
00534 int bits=0;
00535
00536 for(node= j; up[node] != -1; node= up[node]){
00537 bits += flag[node]<<len;
00538 len++;
00539 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n");
00540 }
00541
00542 bits_tab[j]= bits;
00543 len_tab[j]= len;
00544 }
00545
00546 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
00547 len_tab , 1, 1,
00548 bits_tab, 4, 4, 0);
00549
00550 return ptr;
00551 }
00552
00553 static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
00554 int x, y;
00555 const int width= f->avctx->width;
00556 const int height= f->avctx->height;
00557 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00558 const int stride= f->current_picture.linesize[0]>>1;
00559 const unsigned int bitstream_size= get32(buf);
00560 const int token_count __attribute__((unused)) = get32(buf + bitstream_size + 8);
00561 unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
00562 uint8_t *prestream= buf + bitstream_size + 12;
00563
00564 if(prestream_size + bitstream_size + 12 != length
00565 || bitstream_size > (1<<26)
00566 || prestream_size > (1<<26)){
00567 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
00568 return -1;
00569 }
00570
00571 prestream= read_huffman_tables(f, prestream);
00572
00573 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
00574
00575 prestream_size= length + buf - prestream;
00576
00577 f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00578 f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
00579 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
00580
00581 f->last_dc= 0*128*8*8;
00582
00583 for(y=0; y<height; y+=16){
00584 for(x=0; x<width; x+=16){
00585 if(decode_i_mb(f) < 0)
00586 return -1;
00587
00588 idct_put(f, x, y);
00589 }
00590 dst += 16*stride;
00591 }
00592
00593 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
00594 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
00595
00596 return 0;
00597 }
00598
00599 static int decode_frame(AVCodecContext *avctx,
00600 void *data, int *data_size,
00601 uint8_t *buf, int buf_size)
00602 {
00603 FourXContext * const f = avctx->priv_data;
00604 AVFrame *picture = data;
00605 AVFrame *p, temp;
00606 int i, frame_4cc, frame_size;
00607
00608 frame_4cc= get32(buf);
00609 if(buf_size != get32(buf+4)+8){
00610 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
00611 }
00612
00613 if(frame_4cc == ff_get_fourcc("cfrm")){
00614 int free_index=-1;
00615 const int data_size= buf_size - 20;
00616 const int id= get32(buf+12);
00617 const int whole_size= get32(buf+16);
00618 CFrameBuffer *cfrm;
00619
00620 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00621 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
00622 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
00623 }
00624
00625 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00626 if(f->cfrm[i].id == id) break;
00627 if(f->cfrm[i].size == 0 ) free_index= i;
00628 }
00629
00630 if(i>=CFRAME_BUFFER_COUNT){
00631 i= free_index;
00632 f->cfrm[i].id= id;
00633 }
00634 cfrm= &f->cfrm[i];
00635
00636 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
00637
00638 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
00639 cfrm->size += data_size;
00640
00641 if(cfrm->size >= whole_size){
00642 buf= cfrm->data;
00643 frame_size= cfrm->size;
00644
00645 if(id != avctx->frame_number){
00646 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
00647 }
00648
00649 cfrm->size= cfrm->id= 0;
00650 frame_4cc= ff_get_fourcc("pfrm");
00651 }else
00652 return buf_size;
00653 }else{
00654 buf= buf + 12;
00655 frame_size= buf_size - 12;
00656 }
00657
00658 temp= f->current_picture;
00659 f->current_picture= f->last_picture;
00660 f->last_picture= temp;
00661
00662 p= &f->current_picture;
00663 avctx->coded_frame= p;
00664
00665 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00666
00667 if(p->data[0])
00668 avctx->release_buffer(avctx, p);
00669
00670 p->reference= 1;
00671 if(avctx->get_buffer(avctx, p) < 0){
00672 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00673 return -1;
00674 }
00675
00676 if(frame_4cc == ff_get_fourcc("ifrm")){
00677 p->pict_type= I_TYPE;
00678 if(decode_i_frame(f, buf, frame_size) < 0)
00679 return -1;
00680 }else if(frame_4cc == ff_get_fourcc("pfrm")){
00681 p->pict_type= P_TYPE;
00682 if(decode_p_frame(f, buf, frame_size) < 0)
00683 return -1;
00684 }else if(frame_4cc == ff_get_fourcc("snd_")){
00685 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
00686 }else{
00687 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
00688 }
00689
00690 #if 0
00691 for(i=0; i<20; i++){
00692 printf("%2X %c ", buf[i], clip(buf[i],16,126));
00693 }
00694 #endif
00695
00696 p->key_frame= p->pict_type == I_TYPE;
00697
00698 *picture= *p;
00699 *data_size = sizeof(AVPicture);
00700
00701 emms_c();
00702
00703 return buf_size;
00704 }
00705
00706
00707 static void common_init(AVCodecContext *avctx){
00708 FourXContext * const f = avctx->priv_data;
00709
00710 dsputil_init(&f->dsp, avctx);
00711
00712 f->avctx= avctx;
00713 }
00714
00715 static int decode_init(AVCodecContext *avctx){
00716 FourXContext * const f = avctx->priv_data;
00717
00718 common_init(avctx);
00719 init_vlcs(f);
00720
00721 avctx->pix_fmt= PIX_FMT_RGB565;
00722
00723 return 0;
00724 }
00725
00726
00727 static int decode_end(AVCodecContext *avctx){
00728 FourXContext * const f = avctx->priv_data;
00729 int i;
00730
00731 av_freep(&f->bitstream_buffer);
00732 f->bitstream_buffer_size=0;
00733 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00734 av_freep(&f->cfrm[i].data);
00735 f->cfrm[i].allocated_size= 0;
00736 }
00737 free_vlc(&f->pre_vlc);
00738
00739 return 0;
00740 }
00741
00742 AVCodec fourxm_decoder = {
00743 "4xm",
00744 CODEC_TYPE_VIDEO,
00745 CODEC_ID_4XM,
00746 sizeof(FourXContext),
00747 decode_init,
00748 NULL,
00749 decode_end,
00750 decode_frame,
00751
00752 };
00753
