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