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