Libav
|
00001 /* 00002 * 4XM codec 00003 * Copyright (c) 2003 Michael Niedermayer 00004 * 00005 * This file is part of FFmpeg. 00006 * 00007 * FFmpeg is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * FFmpeg is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with FFmpeg; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 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 //#undef NDEBUG 00034 //#include <assert.h> 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 { //{8,4,2}x{8,4,2} 00044 { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0} 00045 },{ //{8,4}x1 00046 { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0} 00047 },{ //1x{8,4} 00048 { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0} 00049 },{ //1x2, 2x1 00050 { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4} 00051 } 00052 },{ 00053 { //{8,4,2}x{8,4,2} 00054 { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0} 00055 },{//{8,4}x1 00056 { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0} 00057 },{//1x{8,4} 00058 { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0} 00059 },{//1x2, 2x1 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 // this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table 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 /* DC coef */ 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 /* AC coefs */ 00432 i = 1; 00433 for(;;) { 00434 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3); 00435 00436 /* EOB */ 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 /* Note transform is: 00476 y= ( 1b + 4g + 2r)/14 00477 cb=( 3b - 2g - 1r)/14 00478 cr=(-1b - 4g + 5r)/14 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); //FIXME optimize 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++; // 4byte align 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"); //can this happen at all ? 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 //warning following is purely guessed ... 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){ //explicit check needed as memcpy below might not catch a NULL 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; // alternatively we would have to use our own buffer management 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