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 GetByteContext g; 00136 GetByteContext g2; 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 #if HAVE_BIGENDIAN 00264 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 00265 { \ 00266 unsigned tmpval = AV_RN32(src); \ 00267 tmpval = (tmpval << 16) | (tmpval >> 16); \ 00268 tmpval = tmpval * (scale) + (dc); \ 00269 tmpval = (tmpval << 16) | (tmpval >> 16); \ 00270 AV_WN32A(dst, tmpval); \ 00271 } 00272 #else 00273 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 00274 { \ 00275 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \ 00276 AV_WN32A(dst, tmpval); \ 00277 } 00278 #endif 00279 00280 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc){ 00281 int i; 00282 dc*= 0x10001; 00283 00284 switch(log2w){ 00285 case 0: 00286 for(i=0; i<h; i++){ 00287 dst[0] = scale*src[0] + dc; 00288 if(scale) src += stride; 00289 dst += stride; 00290 } 00291 break; 00292 case 1: 00293 for(i=0; i<h; i++){ 00294 LE_CENTRIC_MUL(dst, src, scale, dc); 00295 if(scale) src += stride; 00296 dst += stride; 00297 } 00298 break; 00299 case 2: 00300 for(i=0; i<h; i++){ 00301 LE_CENTRIC_MUL(dst, src, scale, dc); 00302 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc); 00303 if(scale) src += stride; 00304 dst += stride; 00305 } 00306 break; 00307 case 3: 00308 for(i=0; i<h; i++){ 00309 LE_CENTRIC_MUL(dst, src, scale, dc); 00310 LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc); 00311 LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc); 00312 LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc); 00313 if(scale) src += stride; 00314 dst += stride; 00315 } 00316 break; 00317 default: assert(0); 00318 } 00319 } 00320 00321 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){ 00322 const int index= size2index[log2h][log2w]; 00323 const int h= 1<<log2h; 00324 int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1); 00325 uint16_t *start= (uint16_t*)f->last_picture.data[0]; 00326 uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w); 00327 00328 assert(code>=0 && code<=6); 00329 00330 if(code == 0){ 00331 if (f->g.buffer_end - f->g.buffer < 1){ 00332 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n"); 00333 return; 00334 } 00335 src += f->mv[ *f->g.buffer++ ]; 00336 if(start > src || src > end){ 00337 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n"); 00338 return; 00339 } 00340 mcdc(dst, src, log2w, h, stride, 1, 0); 00341 }else if(code == 1){ 00342 log2h--; 00343 decode_p_block(f, dst , src , log2w, log2h, stride); 00344 decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride); 00345 }else if(code == 2){ 00346 log2w--; 00347 decode_p_block(f, dst , src , log2w, log2h, stride); 00348 decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride); 00349 }else if(code == 3 && f->version<2){ 00350 mcdc(dst, src, log2w, h, stride, 1, 0); 00351 }else if(code == 4){ 00352 if (f->g.buffer_end - f->g.buffer < 1){ 00353 av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n"); 00354 return; 00355 } 00356 src += f->mv[ *f->g.buffer++ ]; 00357 if(start > src || src > end){ 00358 av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n"); 00359 return; 00360 } 00361 if (f->g2.buffer_end - f->g2.buffer < 1){ 00362 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n"); 00363 return; 00364 } 00365 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2)); 00366 }else if(code == 5){ 00367 if (f->g2.buffer_end - f->g2.buffer < 1){ 00368 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n"); 00369 return; 00370 } 00371 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2)); 00372 }else if(code == 6){ 00373 if (f->g2.buffer_end - f->g2.buffer < 2){ 00374 av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n"); 00375 return; 00376 } 00377 if(log2w){ 00378 dst[0] = bytestream2_get_le16(&f->g2); 00379 dst[1] = bytestream2_get_le16(&f->g2); 00380 }else{ 00381 dst[0 ] = bytestream2_get_le16(&f->g2); 00382 dst[stride] = bytestream2_get_le16(&f->g2); 00383 } 00384 } 00385 } 00386 00387 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){ 00388 int x, y; 00389 const int width= f->avctx->width; 00390 const int height= f->avctx->height; 00391 uint16_t *src= (uint16_t*)f->last_picture.data[0]; 00392 uint16_t *dst= (uint16_t*)f->current_picture.data[0]; 00393 const int stride= f->current_picture.linesize[0]>>1; 00394 unsigned int bitstream_size, bytestream_size, wordstream_size, extra, bytestream_offset, wordstream_offset; 00395 00396 if(f->version>1){ 00397 extra=20; 00398 if (length < extra) 00399 return -1; 00400 bitstream_size= AV_RL32(buf+8); 00401 wordstream_size= AV_RL32(buf+12); 00402 bytestream_size= AV_RL32(buf+16); 00403 }else{ 00404 extra=0; 00405 bitstream_size = AV_RL16(buf-4); 00406 wordstream_size= AV_RL16(buf-2); 00407 bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0); 00408 } 00409 00410 if (bitstream_size > length || 00411 bytestream_size > length - bitstream_size || 00412 wordstream_size > length - bytestream_size - bitstream_size || 00413 extra > length - bytestream_size - bitstream_size - wordstream_size){ 00414 av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size, 00415 bitstream_size+ bytestream_size+ wordstream_size - length); 00416 return -1; 00417 } 00418 00419 av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE); 00420 if (!f->bitstream_buffer) 00421 return AVERROR(ENOMEM); 00422 f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4); 00423 memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); 00424 init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size); 00425 00426 wordstream_offset = extra + bitstream_size; 00427 bytestream_offset = extra + bitstream_size + wordstream_size; 00428 bytestream2_init(&f->g2, buf + wordstream_offset, length - wordstream_offset); 00429 bytestream2_init(&f->g, buf + bytestream_offset, length - bytestream_offset); 00430 00431 init_mv(f); 00432 00433 for(y=0; y<height; y+=8){ 00434 for(x=0; x<width; x+=8){ 00435 decode_p_block(f, dst + x, src + x, 3, 3, stride); 00436 } 00437 src += 8*stride; 00438 dst += 8*stride; 00439 } 00440 00441 return 0; 00442 } 00443 00448 static int decode_i_block(FourXContext *f, DCTELEM *block){ 00449 int code, i, j, level, val; 00450 00451 if(get_bits_left(&f->gb) < 2){ 00452 av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb)); 00453 return -1; 00454 } 00455 00456 /* DC coef */ 00457 val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3); 00458 if (val>>4){ 00459 av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n"); 00460 } 00461 00462 if(val) 00463 val = get_xbits(&f->gb, val); 00464 00465 val = val * dequant_table[0] + f->last_dc; 00466 f->last_dc = 00467 block[0] = val; 00468 /* AC coefs */ 00469 i = 1; 00470 for(;;) { 00471 code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3); 00472 00473 /* EOB */ 00474 if (code == 0) 00475 break; 00476 if (code == 0xf0) { 00477 i += 16; 00478 } else { 00479 level = get_xbits(&f->gb, code & 0xf); 00480 i += code >> 4; 00481 if (i >= 64) { 00482 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i); 00483 return 0; 00484 } 00485 00486 j= ff_zigzag_direct[i]; 00487 block[j] = level * dequant_table[j]; 00488 i++; 00489 if (i >= 64) 00490 break; 00491 } 00492 } 00493 00494 return 0; 00495 } 00496 00497 static inline void idct_put(FourXContext *f, int x, int y){ 00498 DCTELEM (*block)[64]= f->block; 00499 int stride= f->current_picture.linesize[0]>>1; 00500 int i; 00501 uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x; 00502 00503 for(i=0; i<4; i++){ 00504 block[i][0] += 0x80*8*8; 00505 idct(block[i]); 00506 } 00507 00508 if(!(f->avctx->flags&CODEC_FLAG_GRAY)){ 00509 for(i=4; i<6; i++) idct(block[i]); 00510 } 00511 00512 /* Note transform is: 00513 y= ( 1b + 4g + 2r)/14 00514 cb=( 3b - 2g - 1r)/14 00515 cr=(-1b - 4g + 5r)/14 00516 */ 00517 for(y=0; y<8; y++){ 00518 for(x=0; x<8; x++){ 00519 DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize 00520 int cb= block[4][x + 8*y]; 00521 int cr= block[5][x + 8*y]; 00522 int cg= (cb + cr)>>1; 00523 int y; 00524 00525 cb+=cb; 00526 00527 y = temp[0]; 00528 dst[0 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8); 00529 y = temp[1]; 00530 dst[1 ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8); 00531 y = temp[8]; 00532 dst[ stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8); 00533 y = temp[9]; 00534 dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8); 00535 dst += 2; 00536 } 00537 dst += 2*stride - 2*8; 00538 } 00539 } 00540 00541 static int decode_i_mb(FourXContext *f){ 00542 int i; 00543 00544 f->dsp.clear_blocks(f->block[0]); 00545 00546 for(i=0; i<6; i++){ 00547 if(decode_i_block(f, f->block[i]) < 0) 00548 return -1; 00549 } 00550 00551 return 0; 00552 } 00553 00554 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf, int buf_size){ 00555 int frequency[512]; 00556 uint8_t flag[512]; 00557 int up[512]; 00558 uint8_t len_tab[257]; 00559 int bits_tab[257]; 00560 int start, end; 00561 const uint8_t *ptr= buf; 00562 const uint8_t *ptr_end = buf + buf_size; 00563 int j; 00564 00565 memset(frequency, 0, sizeof(frequency)); 00566 memset(up, -1, sizeof(up)); 00567 00568 start= *ptr++; 00569 end= *ptr++; 00570 for(;;){ 00571 int i; 00572 00573 if (start <= end && ptr_end - ptr < end - start + 1 + 1) 00574 return NULL; 00575 for(i=start; i<=end; i++){ 00576 frequency[i]= *ptr++; 00577 } 00578 start= *ptr++; 00579 if(start==0) break; 00580 00581 end= *ptr++; 00582 } 00583 frequency[256]=1; 00584 00585 while((ptr - buf)&3) ptr++; // 4byte align 00586 00587 for(j=257; j<512; j++){ 00588 int min_freq[2]= {256*256, 256*256}; 00589 int smallest[2]= {0, 0}; 00590 int i; 00591 for(i=0; i<j; i++){ 00592 if(frequency[i] == 0) continue; 00593 if(frequency[i] < min_freq[1]){ 00594 if(frequency[i] < min_freq[0]){ 00595 min_freq[1]= min_freq[0]; smallest[1]= smallest[0]; 00596 min_freq[0]= frequency[i];smallest[0]= i; 00597 }else{ 00598 min_freq[1]= frequency[i];smallest[1]= i; 00599 } 00600 } 00601 } 00602 if(min_freq[1] == 256*256) break; 00603 00604 frequency[j]= min_freq[0] + min_freq[1]; 00605 flag[ smallest[0] ]= 0; 00606 flag[ smallest[1] ]= 1; 00607 up[ smallest[0] ]= 00608 up[ smallest[1] ]= j; 00609 frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0; 00610 } 00611 00612 for(j=0; j<257; j++){ 00613 int node; 00614 int len=0; 00615 int bits=0; 00616 00617 for(node= j; up[node] != -1; node= up[node]){ 00618 bits += flag[node]<<len; 00619 len++; 00620 if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ? 00621 } 00622 00623 bits_tab[j]= bits; 00624 len_tab[j]= len; 00625 } 00626 00627 if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, 00628 len_tab , 1, 1, 00629 bits_tab, 4, 4, 0)) 00630 return NULL; 00631 00632 return ptr; 00633 } 00634 00635 static int mix(int c0, int c1){ 00636 int blue = 2*(c0&0x001F) + (c1&0x001F); 00637 int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5; 00638 int red = 2*(c0>>10) + (c1>>10); 00639 return red/3*1024 + green/3*32 + blue/3; 00640 } 00641 00642 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){ 00643 int x, y, x2, y2; 00644 const int width= f->avctx->width; 00645 const int height= f->avctx->height; 00646 const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4); 00647 uint16_t *dst= (uint16_t*)f->current_picture.data[0]; 00648 const int stride= f->current_picture.linesize[0]>>1; 00649 const uint8_t *buf_end = buf + length; 00650 GetByteContext g3; 00651 00652 if(length < mbs * 8) { 00653 av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n"); 00654 return AVERROR_INVALIDDATA; 00655 } 00656 bytestream2_init(&g3, buf, length); 00657 00658 for(y=0; y<height; y+=16){ 00659 for(x=0; x<width; x+=16){ 00660 unsigned int color[4], bits; 00661 if (buf_end - buf < 8) 00662 return -1; 00663 memset(color, 0, sizeof(color)); 00664 //warning following is purely guessed ... 00665 color[0]= bytestream2_get_le16u(&g3); 00666 color[1]= bytestream2_get_le16u(&g3); 00667 00668 if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n"); 00669 if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n"); 00670 00671 color[2]= mix(color[0], color[1]); 00672 color[3]= mix(color[1], color[0]); 00673 00674 bits= bytestream2_get_le32u(&g3); 00675 for(y2=0; y2<16; y2++){ 00676 for(x2=0; x2<16; x2++){ 00677 int index= 2*(x2>>2) + 8*(y2>>2); 00678 dst[y2*stride+x2]= color[(bits>>index)&3]; 00679 } 00680 } 00681 dst+=16; 00682 } 00683 dst += 16 * stride - x; 00684 } 00685 00686 return 0; 00687 } 00688 00689 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){ 00690 int x, y; 00691 const int width= f->avctx->width; 00692 const int height= f->avctx->height; 00693 const unsigned int bitstream_size= AV_RL32(buf); 00694 unsigned int prestream_size; 00695 const uint8_t *prestream; 00696 00697 if (bitstream_size > (1<<26) || 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 } 00736 00737 if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256) 00738 av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n"); 00739 00740 return 0; 00741 } 00742 00743 static int decode_frame(AVCodecContext *avctx, 00744 void *data, int *data_size, 00745 AVPacket *avpkt) 00746 { 00747 const uint8_t *buf = avpkt->data; 00748 int buf_size = avpkt->size; 00749 FourXContext * const f = avctx->priv_data; 00750 AVFrame *picture = data; 00751 AVFrame *p, temp; 00752 int i, frame_4cc, frame_size; 00753 00754 if (buf_size < 12) 00755 return AVERROR_INVALIDDATA; 00756 frame_4cc= AV_RL32(buf); 00757 if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){ 00758 av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4)); 00759 } 00760 00761 if(frame_4cc == AV_RL32("cfrm")){ 00762 int free_index=-1; 00763 const int data_size= buf_size - 20; 00764 const int id= AV_RL32(buf+12); 00765 const int whole_size= AV_RL32(buf+16); 00766 CFrameBuffer *cfrm; 00767 00768 if (data_size < 0 || whole_size < 0){ 00769 av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n"); 00770 return AVERROR_INVALIDDATA; 00771 } 00772 00773 for(i=0; i<CFRAME_BUFFER_COUNT; i++){ 00774 if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number) 00775 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id); 00776 } 00777 00778 for(i=0; i<CFRAME_BUFFER_COUNT; i++){ 00779 if(f->cfrm[i].id == id) break; 00780 if(f->cfrm[i].size == 0 ) free_index= i; 00781 } 00782 00783 if(i>=CFRAME_BUFFER_COUNT){ 00784 i= free_index; 00785 f->cfrm[i].id= id; 00786 } 00787 cfrm= &f->cfrm[i]; 00788 00789 if (data_size > UINT_MAX - cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE) 00790 return AVERROR_INVALIDDATA; 00791 cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE); 00792 if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL 00793 av_log(f->avctx, AV_LOG_ERROR, "realloc falure"); 00794 return -1; 00795 } 00796 00797 memcpy(cfrm->data + cfrm->size, buf+20, data_size); 00798 cfrm->size += data_size; 00799 00800 if(cfrm->size >= whole_size){ 00801 buf= cfrm->data; 00802 frame_size= cfrm->size; 00803 00804 if(id != avctx->frame_number){ 00805 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number); 00806 } 00807 00808 cfrm->size= cfrm->id= 0; 00809 frame_4cc= AV_RL32("pfrm"); 00810 }else 00811 return buf_size; 00812 }else{ 00813 buf= buf + 12; 00814 frame_size= buf_size - 12; 00815 } 00816 00817 temp= f->current_picture; 00818 f->current_picture= f->last_picture; 00819 f->last_picture= temp; 00820 00821 p= &f->current_picture; 00822 avctx->coded_frame= p; 00823 00824 avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management 00825 00826 p->reference= 3; 00827 if (avctx->reget_buffer(avctx, p) < 0) { 00828 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); 00829 return -1; 00830 } 00831 00832 if(frame_4cc == AV_RL32("ifr2")){ 00833 p->pict_type= AV_PICTURE_TYPE_I; 00834 if(decode_i2_frame(f, buf-4, frame_size + 4) < 0) { 00835 av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n"); 00836 return -1; 00837 } 00838 }else if(frame_4cc == AV_RL32("ifrm")){ 00839 p->pict_type= AV_PICTURE_TYPE_I; 00840 if(decode_i_frame(f, buf, frame_size) < 0){ 00841 av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n"); 00842 return -1; 00843 } 00844 }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){ 00845 if(!f->last_picture.data[0]){ 00846 f->last_picture.reference= 3; 00847 if(avctx->get_buffer(avctx, &f->last_picture) < 0){ 00848 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 00849 return -1; 00850 } 00851 } 00852 00853 p->pict_type= AV_PICTURE_TYPE_P; 00854 if(decode_p_frame(f, buf, frame_size) < 0){ 00855 av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n"); 00856 return -1; 00857 } 00858 }else if(frame_4cc == AV_RL32("snd_")){ 00859 av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size); 00860 }else{ 00861 av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size); 00862 } 00863 00864 p->key_frame= p->pict_type == AV_PICTURE_TYPE_I; 00865 00866 *picture= *p; 00867 *data_size = sizeof(AVPicture); 00868 00869 emms_c(); 00870 00871 return buf_size; 00872 } 00873 00874 00875 static av_cold void common_init(AVCodecContext *avctx){ 00876 FourXContext * const f = avctx->priv_data; 00877 00878 dsputil_init(&f->dsp, avctx); 00879 00880 f->avctx= avctx; 00881 } 00882 00883 static av_cold int decode_init(AVCodecContext *avctx){ 00884 FourXContext * const f = avctx->priv_data; 00885 00886 if(avctx->extradata_size != 4 || !avctx->extradata) { 00887 av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n"); 00888 return 1; 00889 } 00890 if((avctx->width % 16) || (avctx->height % 16)) { 00891 av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n"); 00892 return AVERROR_INVALIDDATA; 00893 } 00894 00895 avcodec_get_frame_defaults(&f->current_picture); 00896 avcodec_get_frame_defaults(&f->last_picture); 00897 f->version= AV_RL32(avctx->extradata)>>16; 00898 common_init(avctx); 00899 init_vlcs(f); 00900 00901 if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565; 00902 else avctx->pix_fmt= PIX_FMT_BGR555; 00903 00904 return 0; 00905 } 00906 00907 00908 static av_cold int decode_end(AVCodecContext *avctx){ 00909 FourXContext * const f = avctx->priv_data; 00910 int i; 00911 00912 av_freep(&f->bitstream_buffer); 00913 f->bitstream_buffer_size=0; 00914 for(i=0; i<CFRAME_BUFFER_COUNT; i++){ 00915 av_freep(&f->cfrm[i].data); 00916 f->cfrm[i].allocated_size= 0; 00917 } 00918 ff_free_vlc(&f->pre_vlc); 00919 if(f->current_picture.data[0]) 00920 avctx->release_buffer(avctx, &f->current_picture); 00921 if(f->last_picture.data[0]) 00922 avctx->release_buffer(avctx, &f->last_picture); 00923 00924 return 0; 00925 } 00926 00927 AVCodec ff_fourxm_decoder = { 00928 .name = "4xm", 00929 .type = AVMEDIA_TYPE_VIDEO, 00930 .id = CODEC_ID_4XM, 00931 .priv_data_size = sizeof(FourXContext), 00932 .init = decode_init, 00933 .close = decode_end, 00934 .decode = decode_frame, 00935 .capabilities = CODEC_CAP_DR1, 00936 .long_name = NULL_IF_CONFIG_SMALL("4X Movie"), 00937 }; 00938