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 "bitstream.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 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 /* DC coef */ 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 /* AC coefs */ 00442 i = 1; 00443 for(;;) { 00444 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3); 00445 00446 /* EOB */ 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 /* Note transform is: 00486 y= ( 1b + 4g + 2r)/14 00487 cb=( 3b - 2g - 1r)/14 00488 cr=(-1b - 4g + 5r)/14 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); //FIXME optimize 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++; // 4byte align 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"); //can this happen at all ? 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 //warning following is purely guessed ... 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){ //explicit check needed as memcpy below might not catch a NULL 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; // alternatively we would have to use our own buffer management 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 /*CODEC_CAP_DR1,*/ 00873 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"), 00874 }; 00875