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 "get_bits.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(16, DCTELEM, block)[6][64];
00141 void *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 static VLC_TYPE table[8][32][2];
00241 int i;
00242
00243 for(i=0; i<8; i++){
00244 block_type_vlc[0][i].table= table[i];
00245 block_type_vlc[0][i].table_allocated= 32;
00246 init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
00247 &block_type_tab[0][i][0][1], 2, 1,
00248 &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00249 }
00250 }
00251
00252 static void init_mv(FourXContext *f){
00253 int i;
00254
00255 for(i=0; i<256; i++){
00256 if(f->version>1)
00257 f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
00258 else
00259 f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
00260 }
00261 }
00262
00263 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
00264 int i;
00265 dc*= 0x10001;
00266
00267 switch(log2w){
00268 case 0:
00269 for(i=0; i<h; i++){
00270 dst[0] = scale*src[0] + dc;
00271 if(scale) src += stride;
00272 dst += stride;
00273 }
00274 break;
00275 case 1:
00276 for(i=0; i<h; i++){
00277 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00278 if(scale) src += stride;
00279 dst += stride;
00280 }
00281 break;
00282 case 2:
00283 for(i=0; i<h; i++){
00284 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00285 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
00286 if(scale) src += stride;
00287 dst += stride;
00288 }
00289 break;
00290 case 3:
00291 for(i=0; i<h; i++){
00292 ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
00293 ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
00294 ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
00295 ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
00296 if(scale) src += stride;
00297 dst += stride;
00298 }
00299 break;
00300 default: assert(0);
00301 }
00302 }
00303
00304 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
00305 const int index= size2index[log2h][log2w];
00306 const int h= 1<<log2h;
00307 int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
00308 uint16_t *start= (uint16_t*)f->last_picture.data[0];
00309 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
00310
00311 assert(code>=0 && code<=6);
00312
00313 if(code == 0){
00314 src += f->mv[ *f->bytestream++ ];
00315 if(start > src || src > end){
00316 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
00317 return;
00318 }
00319 mcdc(dst, src, log2w, h, stride, 1, 0);
00320 }else if(code == 1){
00321 log2h--;
00322 decode_p_block(f, dst , src , log2w, log2h, stride);
00323 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
00324 }else if(code == 2){
00325 log2w--;
00326 decode_p_block(f, dst , src , log2w, log2h, stride);
00327 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
00328 }else if(code == 3 && f->version<2){
00329 mcdc(dst, src, log2w, h, stride, 1, 0);
00330 }else if(code == 4){
00331 src += f->mv[ *f->bytestream++ ];
00332 if(start > src || src > end){
00333 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
00334 return;
00335 }
00336 mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
00337 }else if(code == 5){
00338 mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
00339 }else if(code == 6){
00340 if(log2w){
00341 dst[0] = le2me_16(*f->wordstream++);
00342 dst[1] = le2me_16(*f->wordstream++);
00343 }else{
00344 dst[0 ] = le2me_16(*f->wordstream++);
00345 dst[stride] = le2me_16(*f->wordstream++);
00346 }
00347 }
00348 }
00349
00350 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
00351 int x, y;
00352 const int width= f->avctx->width;
00353 const int height= f->avctx->height;
00354 uint16_t *src= (uint16_t*)f->last_picture.data[0];
00355 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00356 const int stride= f->current_picture.linesize[0]>>1;
00357 unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
00358
00359 if(f->version>1){
00360 extra=20;
00361 bitstream_size= AV_RL32(buf+8);
00362 wordstream_size= AV_RL32(buf+12);
00363 bytestream_size= AV_RL32(buf+16);
00364 }else{
00365 extra=0;
00366 bitstream_size = AV_RL16(buf-4);
00367 wordstream_size= AV_RL16(buf-2);
00368 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
00369 }
00370
00371 if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
00372 || bitstream_size > (1<<26)
00373 || bytestream_size > (1<<26)
00374 || wordstream_size > (1<<26)
00375 ){
00376 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
00377 bitstream_size+ bytestream_size+ wordstream_size - length);
00378 return -1;
00379 }
00380
00381 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00382 if (!f->bitstream_buffer)
00383 return AVERROR(ENOMEM);
00384 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
00385 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
00386
00387 f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
00388 f->bytestream= buf + extra + bitstream_size + wordstream_size;
00389
00390 init_mv(f);
00391
00392 for(y=0; y<height; y+=8){
00393 for(x=0; x<width; x+=8){
00394 decode_p_block(f, dst + x, src + x, 3, 3, stride);
00395 }
00396 src += 8*stride;
00397 dst += 8*stride;
00398 }
00399
00400 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
00401 || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
00402 || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
00403 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
00404 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
00405 -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
00406 -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
00407 );
00408
00409 return 0;
00410 }
00411
00416 static int decode_i_block(FourXContext *f, DCTELEM *block){
00417 int code, i, j, level, val;
00418
00419
00420 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00421 if (val>>4){
00422 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
00423 }
00424
00425 if(val)
00426 val = get_xbits(&f->gb, val);
00427
00428 val = val * dequant_table[0] + f->last_dc;
00429 f->last_dc =
00430 block[0] = val;
00431
00432 i = 1;
00433 for(;;) {
00434 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00435
00436
00437 if (code == 0)
00438 break;
00439 if (code == 0xf0) {
00440 i += 16;
00441 } else {
00442 level = get_xbits(&f->gb, code & 0xf);
00443 i += code >> 4;
00444 if (i >= 64) {
00445 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
00446 return 0;
00447 }
00448
00449 j= ff_zigzag_direct[i];
00450 block[j] = level * dequant_table[j];
00451 i++;
00452 if (i >= 64)
00453 break;
00454 }
00455 }
00456
00457 return 0;
00458 }
00459
00460 static inline void idct_put(FourXContext *f, int x, int y){
00461 DCTELEM (*block)[64]= f->block;
00462 int stride= f->current_picture.linesize[0]>>1;
00463 int i;
00464 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
00465
00466 for(i=0; i<4; i++){
00467 block[i][0] += 0x80*8*8;
00468 idct(block[i]);
00469 }
00470
00471 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
00472 for(i=4; i<6; i++) idct(block[i]);
00473 }
00474
00475
00476
00477
00478
00479
00480 for(y=0; y<8; y++){
00481 for(x=0; x<8; x++){
00482 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
00483 int cb= block[4][x + 8*y];
00484 int cr= block[5][x + 8*y];
00485 int cg= (cb + cr)>>1;
00486 int y;
00487
00488 cb+=cb;
00489
00490 y = temp[0];
00491 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00492 y = temp[1];
00493 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00494 y = temp[8];
00495 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00496 y = temp[9];
00497 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00498 dst += 2;
00499 }
00500 dst += 2*stride - 2*8;
00501 }
00502 }
00503
00504 static int decode_i_mb(FourXContext *f){
00505 int i;
00506
00507 f->dsp.clear_blocks(f->block[0]);
00508
00509 for(i=0; i<6; i++){
00510 if(decode_i_block(f, f->block[i]) < 0)
00511 return -1;
00512 }
00513
00514 return 0;
00515 }
00516
00517 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
00518 int frequency[512];
00519 uint8_t flag[512];
00520 int up[512];
00521 uint8_t len_tab[257];
00522 int bits_tab[257];
00523 int start, end;
00524 const uint8_t *ptr= buf;
00525 int j;
00526
00527 memset(frequency, 0, sizeof(frequency));
00528 memset(up, -1, sizeof(up));
00529
00530 start= *ptr++;
00531 end= *ptr++;
00532 for(;;){
00533 int i;
00534
00535 for(i=start; i<=end; i++){
00536 frequency[i]= *ptr++;
00537 }
00538 start= *ptr++;
00539 if(start==0) break;
00540
00541 end= *ptr++;
00542 }
00543 frequency[256]=1;
00544
00545 while((ptr - buf)&3) ptr++;
00546
00547 for(j=257; j<512; j++){
00548 int min_freq[2]= {256*256, 256*256};
00549 int smallest[2]= {0, 0};
00550 int i;
00551 for(i=0; i<j; i++){
00552 if(frequency[i] == 0) continue;
00553 if(frequency[i] < min_freq[1]){
00554 if(frequency[i] < min_freq[0]){
00555 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
00556 min_freq[0]= frequency[i];smallest[0]= i;
00557 }else{
00558 min_freq[1]= frequency[i];smallest[1]= i;
00559 }
00560 }
00561 }
00562 if(min_freq[1] == 256*256) break;
00563
00564 frequency[j]= min_freq[0] + min_freq[1];
00565 flag[ smallest[0] ]= 0;
00566 flag[ smallest[1] ]= 1;
00567 up[ smallest[0] ]=
00568 up[ smallest[1] ]= j;
00569 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
00570 }
00571
00572 for(j=0; j<257; j++){
00573 int node;
00574 int len=0;
00575 int bits=0;
00576
00577 for(node= j; up[node] != -1; node= up[node]){
00578 bits += flag[node]<<len;
00579 len++;
00580 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n");
00581 }
00582
00583 bits_tab[j]= bits;
00584 len_tab[j]= len;
00585 }
00586
00587 init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
00588 len_tab , 1, 1,
00589 bits_tab, 4, 4, 0);
00590
00591 return ptr;
00592 }
00593
00594 static int mix(int c0, int c1){
00595 int blue = 2*(c0&0x001F) + (c1&0x001F);
00596 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
00597 int red = 2*(c0>>10) + (c1>>10);
00598 return red/3*1024 + green/3*32 + blue/3;
00599 }
00600
00601 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
00602 int x, y, x2, y2;
00603 const int width= f->avctx->width;
00604 const int height= f->avctx->height;
00605 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00606 const int stride= f->current_picture.linesize[0]>>1;
00607
00608 for(y=0; y<height; y+=16){
00609 for(x=0; x<width; x+=16){
00610 unsigned int color[4], bits;
00611 memset(color, 0, sizeof(color));
00612
00613 color[0]= bytestream_get_le16(&buf);
00614 color[1]= bytestream_get_le16(&buf);
00615
00616 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
00617 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
00618
00619 color[2]= mix(color[0], color[1]);
00620 color[3]= mix(color[1], color[0]);
00621
00622 bits= bytestream_get_le32(&buf);
00623 for(y2=0; y2<16; y2++){
00624 for(x2=0; x2<16; x2++){
00625 int index= 2*(x2>>2) + 8*(y2>>2);
00626 dst[y2*stride+x2]= color[(bits>>index)&3];
00627 }
00628 }
00629 dst+=16;
00630 }
00631 dst += 16*stride - width;
00632 }
00633
00634 return 0;
00635 }
00636
00637 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
00638 int x, y;
00639 const int width= f->avctx->width;
00640 const int height= f->avctx->height;
00641 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00642 const int stride= f->current_picture.linesize[0]>>1;
00643 const unsigned int bitstream_size= AV_RL32(buf);
00644 int token_count av_unused;
00645 unsigned int prestream_size;
00646 const uint8_t *prestream;
00647
00648 if (length < bitstream_size + 12) {
00649 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
00650 return AVERROR_INVALIDDATA;
00651 }
00652
00653 token_count = AV_RL32(buf + bitstream_size + 8);
00654 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
00655 prestream = buf + bitstream_size + 12;
00656
00657 if(prestream_size + bitstream_size + 12 != length
00658 || bitstream_size > (1<<26)
00659 || prestream_size > (1<<26)){
00660 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
00661 return -1;
00662 }
00663
00664 prestream= read_huffman_tables(f, prestream);
00665
00666 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
00667
00668 prestream_size= length + buf - prestream;
00669
00670 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00671 if (!f->bitstream_buffer)
00672 return AVERROR(ENOMEM);
00673 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
00674 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
00675
00676 f->last_dc= 0*128*8*8;
00677
00678 for(y=0; y<height; y+=16){
00679 for(x=0; x<width; x+=16){
00680 if(decode_i_mb(f) < 0)
00681 return -1;
00682
00683 idct_put(f, x, y);
00684 }
00685 dst += 16*stride;
00686 }
00687
00688 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
00689 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
00690
00691 return 0;
00692 }
00693
00694 static int decode_frame(AVCodecContext *avctx,
00695 void *data, int *data_size,
00696 AVPacket *avpkt)
00697 {
00698 const uint8_t *buf = avpkt->data;
00699 int buf_size = avpkt->size;
00700 FourXContext * const f = avctx->priv_data;
00701 AVFrame *picture = data;
00702 AVFrame *p, temp;
00703 int i, frame_4cc, frame_size;
00704
00705 frame_4cc= AV_RL32(buf);
00706 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
00707 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
00708 }
00709
00710 if(frame_4cc == AV_RL32("cfrm")){
00711 int free_index=-1;
00712 const int data_size= buf_size - 20;
00713 const int id= AV_RL32(buf+12);
00714 const int whole_size= AV_RL32(buf+16);
00715 CFrameBuffer *cfrm;
00716
00717 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00718 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
00719 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
00720 }
00721
00722 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00723 if(f->cfrm[i].id == id) break;
00724 if(f->cfrm[i].size == 0 ) free_index= i;
00725 }
00726
00727 if(i>=CFRAME_BUFFER_COUNT){
00728 i= free_index;
00729 f->cfrm[i].id= id;
00730 }
00731 cfrm= &f->cfrm[i];
00732
00733 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
00734 if(!cfrm->data){
00735 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
00736 return -1;
00737 }
00738
00739 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
00740 cfrm->size += data_size;
00741
00742 if(cfrm->size >= whole_size){
00743 buf= cfrm->data;
00744 frame_size= cfrm->size;
00745
00746 if(id != avctx->frame_number){
00747 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
00748 }
00749
00750 cfrm->size= cfrm->id= 0;
00751 frame_4cc= AV_RL32("pfrm");
00752 }else
00753 return buf_size;
00754 }else{
00755 buf= buf + 12;
00756 frame_size= buf_size - 12;
00757 }
00758
00759 temp= f->current_picture;
00760 f->current_picture= f->last_picture;
00761 f->last_picture= temp;
00762
00763 p= &f->current_picture;
00764 avctx->coded_frame= p;
00765
00766 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00767
00768 if(p->data[0])
00769 avctx->release_buffer(avctx, p);
00770
00771 p->reference= 1;
00772 if(avctx->get_buffer(avctx, p) < 0){
00773 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00774 return -1;
00775 }
00776
00777 if(frame_4cc == AV_RL32("ifr2")){
00778 p->pict_type= FF_I_TYPE;
00779 if(decode_i2_frame(f, buf-4, frame_size) < 0)
00780 return -1;
00781 }else if(frame_4cc == AV_RL32("ifrm")){
00782 p->pict_type= FF_I_TYPE;
00783 if(decode_i_frame(f, buf, frame_size) < 0)
00784 return -1;
00785 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
00786 p->pict_type= FF_P_TYPE;
00787 if(decode_p_frame(f, buf, frame_size) < 0)
00788 return -1;
00789 }else if(frame_4cc == AV_RL32("snd_")){
00790 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
00791 }else{
00792 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
00793 }
00794
00795 p->key_frame= p->pict_type == FF_I_TYPE;
00796
00797 *picture= *p;
00798 *data_size = sizeof(AVPicture);
00799
00800 emms_c();
00801
00802 return buf_size;
00803 }
00804
00805
00806 static av_cold void common_init(AVCodecContext *avctx){
00807 FourXContext * const f = avctx->priv_data;
00808
00809 dsputil_init(&f->dsp, avctx);
00810
00811 f->avctx= avctx;
00812 }
00813
00814 static av_cold int decode_init(AVCodecContext *avctx){
00815 FourXContext * const f = avctx->priv_data;
00816
00817 if(avctx->extradata_size != 4 || !avctx->extradata) {
00818 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
00819 return 1;
00820 }
00821
00822 f->version= AV_RL32(avctx->extradata)>>16;
00823 common_init(avctx);
00824 init_vlcs(f);
00825
00826 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
00827 else avctx->pix_fmt= PIX_FMT_BGR555;
00828
00829 return 0;
00830 }
00831
00832
00833 static av_cold int decode_end(AVCodecContext *avctx){
00834 FourXContext * const f = avctx->priv_data;
00835 int i;
00836
00837 av_freep(&f->bitstream_buffer);
00838 f->bitstream_buffer_size=0;
00839 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00840 av_freep(&f->cfrm[i].data);
00841 f->cfrm[i].allocated_size= 0;
00842 }
00843 free_vlc(&f->pre_vlc);
00844 if(f->current_picture.data[0])
00845 avctx->release_buffer(avctx, &f->current_picture);
00846 if(f->last_picture.data[0])
00847 avctx->release_buffer(avctx, &f->last_picture);
00848
00849 return 0;
00850 }
00851
00852 AVCodec fourxm_decoder = {
00853 "4xm",
00854 AVMEDIA_TYPE_VIDEO,
00855 CODEC_ID_4XM,
00856 sizeof(FourXContext),
00857 decode_init,
00858 NULL,
00859 decode_end,
00860 decode_frame,
00861 CODEC_CAP_DR1,
00862 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
00863 };
00864
