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

Generated on Wed Apr 11 2012 07:31:32 for FFmpeg by  doxygen 1.7.1