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
00463 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00464 if (val>>4){
00465 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
00466 }
00467
00468 if(val)
00469 val = get_xbits(&f->gb, val);
00470
00471 val = val * dequant_table[0] + f->last_dc;
00472 f->last_dc =
00473 block[0] = val;
00474
00475 i = 1;
00476 for(;;) {
00477 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
00478
00479
00480 if (code == 0)
00481 break;
00482 if (code == 0xf0) {
00483 i += 16;
00484 } else {
00485 level = get_xbits(&f->gb, code & 0xf);
00486 i += code >> 4;
00487 if (i >= 64) {
00488 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
00489 return 0;
00490 }
00491
00492 j= ff_zigzag_direct[i];
00493 block[j] = level * dequant_table[j];
00494 i++;
00495 if (i >= 64)
00496 break;
00497 }
00498 }
00499
00500 return 0;
00501 }
00502
00503 static inline void idct_put(FourXContext *f, int x, int y){
00504 DCTELEM (*block)[64]= f->block;
00505 int stride= f->current_picture.linesize[0]>>1;
00506 int i;
00507 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
00508
00509 for(i=0; i<4; i++){
00510 block[i][0] += 0x80*8*8;
00511 idct(block[i]);
00512 }
00513
00514 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
00515 for(i=4; i<6; i++) idct(block[i]);
00516 }
00517
00518
00519
00520
00521
00522
00523 for(y=0; y<8; y++){
00524 for(x=0; x<8; x++){
00525 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3);
00526 int cb= block[4][x + 8*y];
00527 int cr= block[5][x + 8*y];
00528 int cg= (cb + cr)>>1;
00529 int y;
00530
00531 cb+=cb;
00532
00533 y = temp[0];
00534 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00535 y = temp[1];
00536 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00537 y = temp[8];
00538 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00539 y = temp[9];
00540 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
00541 dst += 2;
00542 }
00543 dst += 2*stride - 2*8;
00544 }
00545 }
00546
00547 static int decode_i_mb(FourXContext *f){
00548 int i;
00549
00550 f->dsp.clear_blocks(f->block[0]);
00551
00552 for(i=0; i<6; i++){
00553 if(decode_i_block(f, f->block[i]) < 0)
00554 return -1;
00555 }
00556
00557 return 0;
00558 }
00559
00560 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf, int buf_size){
00561 int frequency[512];
00562 uint8_t flag[512];
00563 int up[512];
00564 uint8_t len_tab[257];
00565 int bits_tab[257];
00566 int start, end;
00567 const uint8_t *ptr= buf;
00568 const uint8_t *ptr_end = buf + buf_size;
00569 int j;
00570
00571 memset(frequency, 0, sizeof(frequency));
00572 memset(up, -1, sizeof(up));
00573
00574 start= *ptr++;
00575 end= *ptr++;
00576 for(;;){
00577 int i;
00578
00579 if (start <= end && ptr_end - ptr < end - start + 1 + 1)
00580 return NULL;
00581 for(i=start; i<=end; i++){
00582 frequency[i]= *ptr++;
00583 }
00584 start= *ptr++;
00585 if(start==0) break;
00586
00587 end= *ptr++;
00588 }
00589 frequency[256]=1;
00590
00591 while((ptr - buf)&3) ptr++;
00592
00593 for(j=257; j<512; j++){
00594 int min_freq[2]= {256*256, 256*256};
00595 int smallest[2]= {0, 0};
00596 int i;
00597 for(i=0; i<j; i++){
00598 if(frequency[i] == 0) continue;
00599 if(frequency[i] < min_freq[1]){
00600 if(frequency[i] < min_freq[0]){
00601 min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
00602 min_freq[0]= frequency[i];smallest[0]= i;
00603 }else{
00604 min_freq[1]= frequency[i];smallest[1]= i;
00605 }
00606 }
00607 }
00608 if(min_freq[1] == 256*256) break;
00609
00610 frequency[j]= min_freq[0] + min_freq[1];
00611 flag[ smallest[0] ]= 0;
00612 flag[ smallest[1] ]= 1;
00613 up[ smallest[0] ]=
00614 up[ smallest[1] ]= j;
00615 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
00616 }
00617
00618 for(j=0; j<257; j++){
00619 int node;
00620 int len=0;
00621 int bits=0;
00622
00623 for(node= j; up[node] != -1; node= up[node]){
00624 bits += flag[node]<<len;
00625 len++;
00626 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n");
00627 }
00628
00629 bits_tab[j]= bits;
00630 len_tab[j]= len;
00631 }
00632
00633 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
00634 len_tab , 1, 1,
00635 bits_tab, 4, 4, 0))
00636 return NULL;
00637
00638 return ptr;
00639 }
00640
00641 static int mix(int c0, int c1){
00642 int blue = 2*(c0&0x001F) + (c1&0x001F);
00643 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
00644 int red = 2*(c0>>10) + (c1>>10);
00645 return red/3*1024 + green/3*32 + blue/3;
00646 }
00647
00648 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
00649 int x, y, x2, y2;
00650 const int width= f->avctx->width;
00651 const int height= f->avctx->height;
00652 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00653 const int stride= f->current_picture.linesize[0]>>1;
00654 const uint8_t *buf_end = buf + length;
00655
00656 for(y=0; y<height; y+=16){
00657 for(x=0; x<width; x+=16){
00658 unsigned int color[4], bits;
00659 if (buf_end - buf < 8)
00660 return -1;
00661 memset(color, 0, sizeof(color));
00662
00663 color[0]= bytestream_get_le16(&buf);
00664 color[1]= bytestream_get_le16(&buf);
00665
00666 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
00667 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
00668
00669 color[2]= mix(color[0], color[1]);
00670 color[3]= mix(color[1], color[0]);
00671
00672 bits= bytestream_get_le32(&buf);
00673 for(y2=0; y2<16; y2++){
00674 for(x2=0; x2<16; x2++){
00675 int index= 2*(x2>>2) + 8*(y2>>2);
00676 dst[y2*stride+x2]= color[(bits>>index)&3];
00677 }
00678 }
00679 dst+=16;
00680 }
00681 dst += 16*stride - width;
00682 }
00683
00684 return 0;
00685 }
00686
00687 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
00688 int x, y;
00689 const int width= f->avctx->width;
00690 const int height= f->avctx->height;
00691 uint16_t *dst= (uint16_t*)f->current_picture.data[0];
00692 const int stride= f->current_picture.linesize[0]>>1;
00693 const unsigned int bitstream_size= AV_RL32(buf);
00694 unsigned int prestream_size;
00695 const uint8_t *prestream;
00696
00697 if (length < bitstream_size + 12) {
00698 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
00699 return AVERROR_INVALIDDATA;
00700 }
00701
00702 prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
00703 prestream = buf + bitstream_size + 12;
00704
00705 if (prestream_size > (1<<26) ||
00706 prestream_size != length - (bitstream_size + 12)){
00707 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
00708 return -1;
00709 }
00710
00711 prestream= read_huffman_tables(f, prestream, buf + length - prestream);
00712 if (!prestream)
00713 return -1;
00714
00715 init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
00716
00717 prestream_size= length + buf - prestream;
00718
00719 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
00720 if (!f->bitstream_buffer)
00721 return AVERROR(ENOMEM);
00722 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
00723 memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00724 init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
00725
00726 f->last_dc= 0*128*8*8;
00727
00728 for(y=0; y<height; y+=16){
00729 for(x=0; x<width; x+=16){
00730 if(decode_i_mb(f) < 0)
00731 return -1;
00732
00733 idct_put(f, x, y);
00734 }
00735 dst += 16*stride;
00736 }
00737
00738 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
00739 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
00740
00741 return 0;
00742 }
00743
00744 static int decode_frame(AVCodecContext *avctx,
00745 void *data, int *data_size,
00746 AVPacket *avpkt)
00747 {
00748 const uint8_t *buf = avpkt->data;
00749 int buf_size = avpkt->size;
00750 FourXContext * const f = avctx->priv_data;
00751 AVFrame *picture = data;
00752 AVFrame *p, temp;
00753 int i, frame_4cc, frame_size;
00754
00755 if (buf_size < 12)
00756 return AVERROR_INVALIDDATA;
00757 frame_4cc= AV_RL32(buf);
00758 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
00759 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
00760 }
00761
00762 if(frame_4cc == AV_RL32("cfrm")){
00763 int free_index=-1;
00764 const int data_size= buf_size - 20;
00765 const int id= AV_RL32(buf+12);
00766 const int whole_size= AV_RL32(buf+16);
00767 CFrameBuffer *cfrm;
00768
00769 if (data_size < 0 || whole_size < 0){
00770 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
00771 return AVERROR_INVALIDDATA;
00772 }
00773
00774 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00775 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
00776 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
00777 }
00778
00779 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00780 if(f->cfrm[i].id == id) break;
00781 if(f->cfrm[i].size == 0 ) free_index= i;
00782 }
00783
00784 if(i>=CFRAME_BUFFER_COUNT){
00785 i= free_index;
00786 f->cfrm[i].id= id;
00787 }
00788 cfrm= &f->cfrm[i];
00789
00790 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
00791 return AVERROR_INVALIDDATA;
00792 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
00793 if(!cfrm->data){
00794 av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
00795 return -1;
00796 }
00797
00798 memcpy(cfrm->data + cfrm->size, buf+20, data_size);
00799 cfrm->size += data_size;
00800
00801 if(cfrm->size >= whole_size){
00802 buf= cfrm->data;
00803 frame_size= cfrm->size;
00804
00805 if(id != avctx->frame_number){
00806 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
00807 }
00808
00809 cfrm->size= cfrm->id= 0;
00810 frame_4cc= AV_RL32("pfrm");
00811 }else
00812 return buf_size;
00813 }else{
00814 buf= buf + 12;
00815 frame_size= buf_size - 12;
00816 }
00817
00818 temp= f->current_picture;
00819 f->current_picture= f->last_picture;
00820 f->last_picture= temp;
00821
00822 p= &f->current_picture;
00823 avctx->coded_frame= p;
00824
00825 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00826
00827 p->reference= 1;
00828 if (avctx->reget_buffer(avctx, p) < 0) {
00829 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
00830 return -1;
00831 }
00832
00833 if(frame_4cc == AV_RL32("ifr2")){
00834 p->pict_type= AV_PICTURE_TYPE_I;
00835 if(decode_i2_frame(f, buf-4, frame_size+4) < 0){
00836 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
00837 return -1;
00838 }
00839 }else if(frame_4cc == AV_RL32("ifrm")){
00840 p->pict_type= AV_PICTURE_TYPE_I;
00841 if(decode_i_frame(f, buf, frame_size) < 0){
00842 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
00843 return -1;
00844 }
00845 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
00846 if(!f->last_picture.data[0]){
00847 f->last_picture.reference= 1;
00848 if(avctx->get_buffer(avctx, &f->last_picture) < 0){
00849 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00850 return -1;
00851 }
00852 }
00853
00854 p->pict_type= AV_PICTURE_TYPE_P;
00855 if(decode_p_frame(f, buf, frame_size) < 0){
00856 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
00857 return -1;
00858 }
00859 }else if(frame_4cc == AV_RL32("snd_")){
00860 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
00861 }else{
00862 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
00863 }
00864
00865 p->key_frame= p->pict_type == AV_PICTURE_TYPE_I;
00866
00867 *picture= *p;
00868 *data_size = sizeof(AVPicture);
00869
00870 emms_c();
00871
00872 return buf_size;
00873 }
00874
00875
00876 static av_cold void common_init(AVCodecContext *avctx){
00877 FourXContext * const f = avctx->priv_data;
00878
00879 dsputil_init(&f->dsp, avctx);
00880
00881 f->avctx= avctx;
00882 }
00883
00884 static av_cold int decode_init(AVCodecContext *avctx){
00885 FourXContext * const f = avctx->priv_data;
00886
00887 if(avctx->extradata_size != 4 || !avctx->extradata) {
00888 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
00889 return 1;
00890 }
00891 if((avctx->width % 16) || (avctx->height % 16)) {
00892 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
00893 return AVERROR_INVALIDDATA;
00894 }
00895
00896 avcodec_get_frame_defaults(&f->current_picture);
00897 avcodec_get_frame_defaults(&f->last_picture);
00898 f->version= AV_RL32(avctx->extradata)>>16;
00899 common_init(avctx);
00900 init_vlcs(f);
00901
00902 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
00903 else avctx->pix_fmt= PIX_FMT_BGR555;
00904
00905 return 0;
00906 }
00907
00908
00909 static av_cold int decode_end(AVCodecContext *avctx){
00910 FourXContext * const f = avctx->priv_data;
00911 int i;
00912
00913 av_freep(&f->bitstream_buffer);
00914 f->bitstream_buffer_size=0;
00915 for(i=0; i<CFRAME_BUFFER_COUNT; i++){
00916 av_freep(&f->cfrm[i].data);
00917 f->cfrm[i].allocated_size= 0;
00918 }
00919 free_vlc(&f->pre_vlc);
00920 if(f->current_picture.data[0])
00921 avctx->release_buffer(avctx, &f->current_picture);
00922 if(f->last_picture.data[0])
00923 avctx->release_buffer(avctx, &f->last_picture);
00924
00925 return 0;
00926 }
00927
00928 AVCodec ff_fourxm_decoder = {
00929 "4xm",
00930 AVMEDIA_TYPE_VIDEO,
00931 CODEC_ID_4XM,
00932 sizeof(FourXContext),
00933 decode_init,
00934 NULL,
00935 decode_end,
00936 decode_frame,
00937 CODEC_CAP_DR1,
00938 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
00939 };
00940
