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 uint8_t *bytestream_end;
00137 const uint16_t *wordstream;
00138 const uint16_t *wordstream_end;
00139 int mv[256];
00140 VLC pre_vlc;
00141 int last_dc;
00142 DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
00143 void *bitstream_buffer;
00144 unsigned int bitstream_buffer_size;
00145 int version;
00146 CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
00147 } FourXContext;
00148
00149
00150 #define FIX_1_082392200 70936
00151 #define FIX_1_414213562 92682
00152 #define FIX_1_847759065 121095
00153 #define FIX_2_613125930 171254
00154
00155 #define MULTIPLY(var,const) (((var)*(const)) >> 16)
00156
00157 static void idct(DCTELEM block[64]){
00158 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
00159 int tmp10, tmp11, tmp12, tmp13;
00160 int z5, z10, z11, z12, z13;
00161 int i;
00162 int temp[64];
00163
00164 for(i=0; i<8; i++){
00165 tmp10 = block[8*0 + i] + block[8*4 + i];
00166 tmp11 = block[8*0 + i] - block[8*4 + i];
00167
00168 tmp13 = block[8*2 + i] + block[8*6 + i];
00169 tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
00170
00171 tmp0 = tmp10 + tmp13;
00172 tmp3 = tmp10 - tmp13;
00173 tmp1 = tmp11 + tmp12;
00174 tmp2 = tmp11 - tmp12;
00175
00176 z13 = block[8*5 + i] + block[8*3 + i];
00177 z10 = block[8*5 + i] - block[8*3 + i];
00178 z11 = block[8*1 + i] + block[8*7 + i];
00179 z12 = block[8*1 + i] - block[8*7 + i];
00180
00181 tmp7 = z11 + z13;
00182 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
00183
00184 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
00185 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
00186 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
00187
00188 tmp6 = tmp12 - tmp7;
00189 tmp5 = tmp11 - tmp6;
00190 tmp4 = tmp10 + tmp5;
00191
00192 temp[8*0 + i] = tmp0 + tmp7;
00193 temp[8*7 + i] = tmp0 - tmp7;
00194 temp[8*1 + i] = tmp1 + tmp6;
00195 temp[8*6 + i] = tmp1 - tmp6;
00196 temp[8*2 + i] = tmp2 + tmp5;
00197 temp[8*5 + i] = tmp2 - tmp5;
00198 temp[8*4 + i] = tmp3 + tmp4;
00199 temp[8*3 + i] = tmp3 - tmp4;
00200 }
00201
00202 for(i=0; i<8*8; i+=8){
00203 tmp10 = temp[0 + i] + temp[4 + i];
00204 tmp11 = temp[0 + i] - temp[4 + i];
00205
00206 tmp13 = temp[2 + i] + temp[6 + i];
00207 tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
00208
00209 tmp0 = tmp10 + tmp13;
00210 tmp3 = tmp10 - tmp13;
00211 tmp1 = tmp11 + tmp12;
00212 tmp2 = tmp11 - tmp12;
00213
00214 z13 = temp[5 + i] + temp[3 + i];
00215 z10 = temp[5 + i] - temp[3 + i];
00216 z11 = temp[1 + i] + temp[7 + i];
00217 z12 = temp[1 + i] - temp[7 + i];
00218
00219 tmp7 = z11 + z13;
00220 tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
00221
00222 z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
00223 tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
00224 tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
00225
00226 tmp6 = tmp12 - tmp7;
00227 tmp5 = tmp11 - tmp6;
00228 tmp4 = tmp10 + tmp5;
00229
00230 block[0 + i] = (tmp0 + tmp7)>>6;
00231 block[7 + i] = (tmp0 - tmp7)>>6;
00232 block[1 + i] = (tmp1 + tmp6)>>6;
00233 block[6 + i] = (tmp1 - tmp6)>>6;
00234 block[2 + i] = (tmp2 + tmp5)>>6;
00235 block[5 + i] = (tmp2 - tmp5)>>6;
00236 block[4 + i] = (tmp3 + tmp4)>>6;
00237 block[3 + i] = (tmp3 - tmp4)>>6;
00238 }
00239 }
00240
00241 static av_cold void init_vlcs(FourXContext *f){
00242 static VLC_TYPE table[8][32][2];
00243 int i;
00244
00245 for(i=0; i<8; i++){
00246 block_type_vlc[0][i].table= table[i];
00247 block_type_vlc[0][i].table_allocated= 32;
00248 init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
00249 &block_type_tab[0][i][0][1], 2, 1,
00250 &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
00251 }
00252 }
00253
00254 static void init_mv(FourXContext *f){
00255 int i;
00256
00257 for(i=0; i<256; i++){
00258 if(f->version>1)
00259 f->mv[i] = mv[i][0] + mv[i][1] *f->current_picture.linesize[0]/2;
00260 else
00261 f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
00262 }
00263 }
00264
00265 #if HAVE_BIGENDIAN
00266 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
00267 { \
00268 unsigned tmpval = AV_RN32(src); \
00269 tmpval = (tmpval << 16) | (tmpval >> 16); \
00270 tmpval = tmpval * (scale) + (dc); \
00271 tmpval = (tmpval << 16) | (tmpval >> 16); \
00272 AV_WN32A(dst, tmpval); \
00273 }
00274 #else
00275 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
00276 { \
00277 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
00278 AV_WN32A(dst, tmpval); \
00279 }
00280 #endif
00281
00282 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc){
00283 int i;
00284 dc*= 0x10001;
00285
00286 switch(log2w){
00287 case 0:
00288 for(i=0; i<h; i++){
00289 dst[0] = scale*src[0] + dc;
00290 if(scale) src += stride;
00291 dst += stride;
00292 }
00293 break;
00294 case 1:
00295 for(i=0; i<h; i++){
00296 LE_CENTRIC_MUL(dst, src, scale, dc);
00297 if(scale) src += stride;
00298 dst += stride;
00299 }
00300 break;
00301 case 2:
00302 for(i=0; i<h; i++){
00303 LE_CENTRIC_MUL(dst, src, scale, dc);
00304 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
00305 if(scale) src += stride;
00306 dst += stride;
00307 }
00308 break;
00309 case 3:
00310 for(i=0; i<h; i++){
00311 LE_CENTRIC_MUL(dst, src, scale, dc);
00312 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
00313 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
00314 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
00315 if(scale) src += stride;
00316 dst += stride;
00317 }
00318 break;
00319 default: assert(0);
00320 }
00321 }
00322
00323 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
00324 const int index= size2index[log2h][log2w];
00325 const int h= 1<<log2h;
00326 int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
00327 uint16_t *start= (uint16_t*)f->last_picture.data[0];
00328 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
00329
00330 assert(code>=0 && code<=6);
00331
00332 if(code == 0){
00333 if (f->bytestream_end - f->bytestream < 1){
00334 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
00335 return;
00336 }
00337 src += f->mv[ *f->bytestream++ ];
00338 if(start > src || src > end){
00339 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
00340 return;
00341 }
00342 mcdc(dst, src, log2w, h, stride, 1, 0);
00343 }else if(code == 1){
00344 log2h--;
00345 decode_p_block(f, dst , src , log2w, log2h, stride);
00346 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
00347 }else if(code == 2){
00348 log2w--;
00349 decode_p_block(f, dst , src , log2w, log2h, stride);
00350 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
00351 }else if(code == 3 && f->version<2){
00352 mcdc(dst, src, log2w, h, stride, 1, 0);
00353 }else if(code == 4){
00354 if (f->bytestream_end - f->bytestream < 1){
00355 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
00356 return;
00357 }
00358 src += f->mv[ *f->bytestream++ ];
00359 if(start > src || src > end){
00360 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
00361 return;
00362 }
00363 if (f->wordstream_end - f->wordstream < 1){
00364 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
00365 return;
00366 }
00367 mcdc(dst, src, log2w, h, stride, 1, av_le2ne16(*f->wordstream++));
00368 }else if(code == 5){
00369 if (f->wordstream_end - f->wordstream < 1){
00370 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
00371 return;
00372 }
00373 mcdc(dst, src, log2w, h, stride, 0, av_le2ne16(*f->wordstream++));
00374 }else if(code == 6){
00375 if (f->wordstream_end - f->wordstream < 2){
00376 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
00377 return;
00378 }
00379 if(log2w){
00380 dst[0] = av_le2ne16(*f->wordstream++);
00381 dst[1] = av_le2ne16(*f->wordstream++);
00382 }else{
00383 dst[0 ] = av_le2ne16(*f->wordstream++);
00384 dst[stride] = av_le2ne16(*f->wordstream++);
00385 }
00386 }
00387 }
00388
00389 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
00390 int x, y;
00391 const int width= f->avctx->width;
00392 const int height= f->avctx->height;
00393 uint16_t *src= (uint16_t*)f->last_picture.data[0];
00394 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00395 const int stride= f->current_picture.linesize[0]>>1;
00396 unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
00397
00398 if(f->version>1){
00399 extra=20;
00400 if (length < extra)
00401 return -1;
00402 bitstream_size= AV_RL32(buf+8);
00403 wordstream_size= AV_RL32(buf+12);
00404 bytestream_size= AV_RL32(buf+16);
00405 }else{
00406 extra=0;
00407 bitstream_size = AV_RL16(buf-4);
00408 wordstream_size= AV_RL16(buf-2);
00409 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
00410 }
00411
00412 if (bitstream_size > length ||
00413 bytestream_size > length - bitstream_size ||
00414 wordstream_size > length - bytestream_size - bitstream_size ||
00415 extra > length - bytestream_size - bitstream_size - wordstream_size){
00416 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
00417 bitstream_size+ bytestream_size+ wordstream_size - length);
00418 return -1;
00419 }
00420
00421 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00422 if (!f->bitstream_buffer)
00423 return AVERROR(ENOMEM);
00424 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
00425 memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00426 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
00427
00428 f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
00429 f->wordstream_end= f->wordstream + wordstream_size/2;
00430 f->bytestream= buf + extra + bitstream_size + wordstream_size;
00431 f->bytestream_end = f->bytestream + bytestream_size;
00432
00433 init_mv(f);
00434
00435 for(y=0; y<height; y+=8){
00436 for(x=0; x<width; x+=8){
00437 decode_p_block(f, dst + x, src + x, 3, 3, stride);
00438 }
00439 src += 8*stride;
00440 dst += 8*stride;
00441 }
00442
00443 if( bitstream_size != (get_bits_count(&f->gb)+31)/32*4
00444 || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
00445 || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
00446 av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
00447 bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
00448 -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
00449 -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
00450 );
00451
00452 return 0;
00453 }
00454
00459 static int decode_i_block(FourXContext *f, DCTELEM *block){
00460 int code, i, j, level, val;
00461
00462 if(get_bits_left(&f->gb) < 2){
00463 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
00464 return -1;
00465 }
00466
00467
00468 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00469 if (val>>4){
00470 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
00471 }
00472
00473 if(val)
00474 val = get_xbits(&f->gb, val);
00475
00476 val = val * dequant_table[0] + f->last_dc;
00477 f->last_dc =
00478 block[0] = val;
00479
00480 i = 1;
00481 for(;;) {
00482 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00483
00484
00485 if (code == 0)
00486 break;
00487 if (code == 0xf0) {
00488 i += 16;
00489 } else {
00490 level = get_xbits(&f->gb, code & 0xf);
00491 i += code >> 4;
00492 if (i >= 64) {
00493 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
00494 return 0;
00495 }
00496
00497 j= ff_zigzag_direct[i];
00498 block[j] = level * dequant_table[j];
00499 i++;
00500 if (i >= 64)
00501 break;
00502 }
00503 }
00504
00505 return 0;
00506 }
00507
00508 static inline void idct_put(FourXContext *f, int x, int y){
00509 DCTELEM (*block)[64]= f->block;
00510 int stride= f->current_picture.linesize[0]>>1;
00511 int i;
00512 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
00513
00514 for(i=0; i<4; i++){
00515 block[i][0] += 0x80*8*8;
00516 idct(block[i]);
00517 }
00518
00519 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
00520 for(i=4; i<6; i++) idct(block[i]);
00521 }
00522
00523
00524
00525
00526
00527
00528 for(y=0; y<8; y++){
00529 for(x=0; x<8; x++){
00530 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
00531 int cb= block[4][x + 8*y];
00532 int cr= block[5][x + 8*y];
00533 int cg= (cb + cr)>>1;
00534 int y;
00535
00536 cb+=cb;
00537
00538 y = temp[0];
00539 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00540 y = temp[1];
00541 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00542 y = temp[8];
00543 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00544 y = temp[9];
00545 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00546 dst += 2;
00547 }
00548 dst += 2*stride - 2*8;
00549 }
00550 }
00551
00552 static int decode_i_mb(FourXContext *f){
00553 int i;
00554
00555 f->dsp.clear_blocks(f->block[0]);
00556
00557 for(i=0; i<6; i++){
00558 if(decode_i_block(f, f->block[i]) < 0)
00559 return -1;
00560 }
00561
00562 return 0;
00563 }
00564
00565 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf, int buf_size){
00566 int frequency[512];
00567 uint8_t flag[512];
00568 int up[512];
00569 uint8_t len_tab[257];
00570 int bits_tab[257];
00571 int start, end;
00572 const uint8_t *ptr= buf;
00573 const uint8_t *ptr_end = buf + buf_size;
00574 int j;
00575
00576 memset(frequency, 0, sizeof(frequency));
00577 memset(up, -1, sizeof(up));
00578
00579 start= *ptr++;
00580 end= *ptr++;
00581 for(;;){
00582 int i;
00583
00584 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
00585 return NULL;
00586 for(i=start; i<=end; i++){
00587 frequency[i]= *ptr++;
00588 }
00589 start= *ptr++;
00590 if(start==0) break;
00591
00592 end= *ptr++;
00593 }
00594 frequency[256]=1;
00595
00596 while((ptr - buf)&3) ptr++;
00597
00598 for(j=257; j<512; j++){
00599 int min_freq[2]= {256*256, 256*256};
00600 int smallest[2]= {0, 0};
00601 int i;
00602 for(i=0; i<j; i++){
00603 if(frequency[i] == 0) continue;
00604 if(frequency[i] < min_freq[1]){
00605 if(frequency[i] < min_freq[0]){
00606 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
00607 min_freq[0]= frequency[i];smallest[0]= i;
00608 }else{
00609 min_freq[1]= frequency[i];smallest[1]= i;
00610 }
00611 }
00612 }
00613 if(min_freq[1] == 256*256) break;
00614
00615 frequency[j]= min_freq[0] + min_freq[1];
00616 flag[ smallest[0] ]= 0;
00617 flag[ smallest[1] ]= 1;
00618 up[ smallest[0] ]=
00619 up[ smallest[1] ]= j;
00620 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
00621 }
00622
00623 for(j=0; j<257; j++){
00624 int node;
00625 int len=0;
00626 int bits=0;
00627
00628 for(node= j; up[node] != -1; node= up[node]){
00629 bits += flag[node]<<len;
00630 len++;
00631 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n");
00632 }
00633
00634 bits_tab[j]= bits;
00635 len_tab[j]= len;
00636 }
00637
00638 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
00639 len_tab , 1, 1,
00640 bits_tab, 4, 4, 0))
00641 return NULL;
00642
00643 return ptr;
00644 }
00645
00646 static int mix(int c0, int c1){
00647 int blue = 2*(c0&0x001F) + (c1&0x001F);
00648 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
00649 int red = 2*(c0>>10) + (c1>>10);
00650 return red/3*1024 + green/3*32 + blue/3;
00651 }
00652
00653 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
00654 int x, y, x2, y2;
00655 const int width= f->avctx->width;
00656 const int height= f->avctx->height;
00657 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00658 const int stride= f->current_picture.linesize[0]>>1;
00659 const uint8_t *buf_end = buf + length;
00660
00661 for(y=0; y<height; y+=16){
00662 for(x=0; x<width; x+=16){
00663 unsigned int color[4], bits;
00664 if (buf_end - buf < 8)
00665 return -1;
00666 memset(color, 0, sizeof(color));
00667
00668 color[0]= bytestream_get_le16(&buf);
00669 color[1]= bytestream_get_le16(&buf);
00670
00671 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
00672 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
00673
00674 color[2]= mix(color[0], color[1]);
00675 color[3]= mix(color[1], color[0]);
00676
00677 bits= bytestream_get_le32(&buf);
00678 for(y2=0; y2<16; y2++){
00679 for(x2=0; x2<16; x2++){
00680 int index= 2*(x2>>2) + 8*(y2>>2);
00681 dst[y2*stride+x2]= color[(bits>>index)&3];
00682 }
00683 }
00684 dst+=16;
00685 }
00686 dst += 16*stride - width;
00687 }
00688
00689 return 0;
00690 }
00691
00692 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
00693 int x, y;
00694 const int width= f->avctx->width;
00695 const int height= f->avctx->height;
00696 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00697 const int stride= f->current_picture.linesize[0]>>1;
00698 const unsigned int bitstream_size= AV_RL32(buf);
00699 unsigned int prestream_size;
00700 const uint8_t *prestream;
00701
00702 if (bitstream_size > (1<<26) || length < bitstream_size + 12)
00703 return -1;
00704 prestream_size = 4*AV_RL32(buf + bitstream_size + 4);
00705 prestream = buf + bitstream_size + 12;
00706
00707 if (prestream_size > (1<<26) ||
00708 prestream_size != length - (bitstream_size + 12)){
00709 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
00710 return -1;
00711 }
00712
00713 prestream= read_huffman_tables(f, prestream, buf + length - prestream);
00714 if (!prestream)
00715 return -1;
00716
00717 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
00718
00719 prestream_size= length + buf - prestream;
00720
00721 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00722 if (!f->bitstream_buffer)
00723 return AVERROR(ENOMEM);
00724 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
00725 memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00726 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
00727
00728 f->last_dc= 0*128*8*8;
00729
00730 for(y=0; y<height; y+=16){
00731 for(x=0; x<width; x+=16){
00732 if(decode_i_mb(f) < 0)
00733 return -1;
00734
00735 idct_put(f, x, y);
00736 }
00737 dst += 16*stride;
00738 }
00739
00740 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
00741 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
00742
00743 return 0;
00744 }
00745
00746 static int decode_frame(AVCodecContext *avctx,
00747 void *data, int *data_size,
00748 AVPacket *avpkt)
00749 {
00750 const uint8_t *buf = avpkt->data;
00751 int buf_size = avpkt->size;
00752 FourXContext * const f = avctx->priv_data;
00753 AVFrame *picture = data;
00754 AVFrame *p, temp;
00755 int i, frame_4cc, frame_size;
00756
00757 if (buf_size < 12)
00758 return AVERROR_INVALIDDATA;
00759 frame_4cc= AV_RL32(buf);
00760 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
00761 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
00762 }
00763
00764 if(frame_4cc == AV_RL32("cfrm")){
00765 int free_index=-1;
00766 const int data_size= buf_size - 20;
00767 const int id= AV_RL32(buf+12);
00768 const int whole_size= AV_RL32(buf+16);
00769 CFrameBuffer *cfrm;
00770
00771 if (data_size < 0 || whole_size < 0){
00772 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
00773 return AVERROR_INVALIDDATA;
00774 }
00775
00776 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00777 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
00778 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
00779 }
00780
00781 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00782 if(f->cfrm[i].id == id) break;
00783 if(f->cfrm[i].size == 0 ) free_index= i;
00784 }
00785
00786 if(i>=CFRAME_BUFFER_COUNT){
00787 i= free_index;
00788 f->cfrm[i].id= id;
00789 }
00790 cfrm= &f->cfrm[i];
00791
00792 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
00793 return AVERROR_INVALIDDATA;
00794 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
00795 if(!cfrm->data){
00796 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
00797 return -1;
00798 }
00799
00800 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
00801 cfrm->size += data_size;
00802
00803 if(cfrm->size >= whole_size){
00804 buf= cfrm->data;
00805 frame_size= cfrm->size;
00806
00807 if(id != avctx->frame_number){
00808 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
00809 }
00810
00811 cfrm->size= cfrm->id= 0;
00812 frame_4cc= AV_RL32("pfrm");
00813 }else
00814 return buf_size;
00815 }else{
00816 buf= buf + 12;
00817 frame_size= buf_size - 12;
00818 }
00819
00820 temp= f->current_picture;
00821 f->current_picture= f->last_picture;
00822 f->last_picture= temp;
00823
00824 p= &f->current_picture;
00825 avctx->coded_frame= p;
00826
00827 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00828
00829 p->reference= 3;
00830 if (avctx->reget_buffer(avctx, p) < 0) {
00831 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
00832 return -1;
00833 }
00834
00835 if(frame_4cc == AV_RL32("ifr2")){
00836 p->pict_type= AV_PICTURE_TYPE_I;
00837 if(decode_i2_frame(f, buf-4, frame_size+4) < 0){
00838 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
00839 return -1;
00840 }
00841 }else if(frame_4cc == AV_RL32("ifrm")){
00842 p->pict_type= AV_PICTURE_TYPE_I;
00843 if(decode_i_frame(f, buf, frame_size) < 0){
00844 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
00845 return -1;
00846 }
00847 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
00848 if(!f->last_picture.data[0]){
00849 f->last_picture.reference= 3;
00850 if(avctx->get_buffer(avctx, &f->last_picture) < 0){
00851 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00852 return -1;
00853 }
00854 }
00855
00856 p->pict_type= AV_PICTURE_TYPE_P;
00857 if(decode_p_frame(f, buf, frame_size) < 0){
00858 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
00859 return -1;
00860 }
00861 }else if(frame_4cc == AV_RL32("snd_")){
00862 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
00863 }else{
00864 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
00865 }
00866
00867 p->key_frame= p->pict_type == AV_PICTURE_TYPE_I;
00868
00869 *picture= *p;
00870 *data_size = sizeof(AVPicture);
00871
00872 emms_c();
00873
00874 return buf_size;
00875 }
00876
00877
00878 static av_cold void common_init(AVCodecContext *avctx){
00879 FourXContext * const f = avctx->priv_data;
00880
00881 dsputil_init(&f->dsp, avctx);
00882
00883 f->avctx= avctx;
00884 }
00885
00886 static av_cold int decode_init(AVCodecContext *avctx){
00887 FourXContext * const f = avctx->priv_data;
00888
00889 if(avctx->extradata_size != 4 || !avctx->extradata) {
00890 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
00891 return 1;
00892 }
00893 if((avctx->width % 16) || (avctx->height % 16)) {
00894 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
00895 return AVERROR_INVALIDDATA;
00896 }
00897
00898 avcodec_get_frame_defaults(&f->current_picture);
00899 avcodec_get_frame_defaults(&f->last_picture);
00900 f->version= AV_RL32(avctx->extradata)>>16;
00901 common_init(avctx);
00902 init_vlcs(f);
00903
00904 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
00905 else avctx->pix_fmt= PIX_FMT_BGR555;
00906
00907 return 0;
00908 }
00909
00910
00911 static av_cold int decode_end(AVCodecContext *avctx){
00912 FourXContext * const f = avctx->priv_data;
00913 int i;
00914
00915 av_freep(&f->bitstream_buffer);
00916 f->bitstream_buffer_size=0;
00917 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00918 av_freep(&f->cfrm[i].data);
00919 f->cfrm[i].allocated_size= 0;
00920 }
00921 free_vlc(&f->pre_vlc);
00922 if(f->current_picture.data[0])
00923 avctx->release_buffer(avctx, &f->current_picture);
00924 if(f->last_picture.data[0])
00925 avctx->release_buffer(avctx, &f->last_picture);
00926
00927 return 0;
00928 }
00929
00930 AVCodec ff_fourxm_decoder = {
00931 .name = "4xm",
00932 .type = AVMEDIA_TYPE_VIDEO,
00933 .id = CODEC_ID_4XM,
00934 .priv_data_size = sizeof(FourXContext),
00935 .init = decode_init,
00936 .close = decode_end,
00937 .decode = decode_frame,
00938 .capabilities = CODEC_CAP_DR1,
00939 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
00940 };
00941
