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