• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/4xm.c

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

Generated on Sat Feb 16 2013 09:23:11 for ffmpeg by  doxygen 1.7.1