"Fossies" - the Fresh Open Source Software Archive

Member "quicktime4linux-2.3/thirdparty/ffmpeg.053108/libavcodec/4xm.c" (8 Aug 2008, 26791 Bytes) of package /linux/privat/old/quicktime4linux-2.3-src.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /*
    2  * 4XM codec
    3  * Copyright (c) 2003 Michael Niedermayer
    4  *
    5  * This file is part of FFmpeg.
    6  *
    7  * FFmpeg is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU Lesser General Public
    9  * License as published by the Free Software Foundation; either
   10  * version 2.1 of the License, or (at your option) any later version.
   11  *
   12  * FFmpeg is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15  * Lesser General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU Lesser General Public
   18  * License along with FFmpeg; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   20  */
   21 
   22 /**
   23  * @file 4xm.c
   24  * 4XM codec.
   25  */
   26 
   27 #include "avcodec.h"
   28 #include "dsputil.h"
   29 #include "bitstream.h"
   30 #include "bytestream.h"
   31 
   32 //#undef NDEBUG
   33 //#include <assert.h>
   34 
   35 #define BLOCK_TYPE_VLC_BITS 5
   36 #define ACDC_VLC_BITS 9
   37 
   38 #define CFRAME_BUFFER_COUNT 100
   39 
   40 static const uint8_t block_type_tab[2][4][8][2]={
   41  {
   42   {   //{8,4,2}x{8,4,2}
   43     { 0,1}, { 2,2}, { 6,3}, {14,4}, {30,5}, {31,5}, { 0,0}
   44   },{ //{8,4}x1
   45     { 0,1}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}, { 0,0}
   46   },{ //1x{8,4}
   47     { 0,1}, { 2,2}, { 0,0}, { 6,3}, {14,4}, {15,4}, { 0,0}
   48   },{ //1x2, 2x1
   49     { 0,1}, { 0,0}, { 0,0}, { 2,2}, { 6,3}, {14,4}, {15,4}
   50   }
   51  },{
   52   {  //{8,4,2}x{8,4,2}
   53     { 1,2}, { 4,3}, { 5,3}, {0,2}, {6,3}, {7,3}, {0,0}
   54   },{//{8,4}x1
   55     { 1,2}, { 0,0}, { 2,2}, {0,2}, {6,3}, {7,3}, {0,0}
   56   },{//1x{8,4}
   57     { 1,2}, { 2,2}, { 0,0}, {0,2}, {6,3}, {7,3}, {0,0}
   58   },{//1x2, 2x1
   59     { 1,2}, { 0,0}, { 0,0}, {0,2}, {2,2}, {6,3}, {7,3}
   60   }
   61  }
   62 };
   63 
   64 static const uint8_t size2index[4][4]={
   65   {-1, 3, 1, 1},
   66   { 3, 0, 0, 0},
   67   { 2, 0, 0, 0},
   68   { 2, 0, 0, 0},
   69 };
   70 
   71 static const int8_t mv[256][2]={
   72 {  0,  0},{  0, -1},{ -1,  0},{  1,  0},{  0,  1},{ -1, -1},{  1, -1},{ -1,  1},
   73 {  1,  1},{  0, -2},{ -2,  0},{  2,  0},{  0,  2},{ -1, -2},{  1, -2},{ -2, -1},
   74 {  2, -1},{ -2,  1},{  2,  1},{ -1,  2},{  1,  2},{ -2, -2},{  2, -2},{ -2,  2},
   75 {  2,  2},{  0, -3},{ -3,  0},{  3,  0},{  0,  3},{ -1, -3},{  1, -3},{ -3, -1},
   76 {  3, -1},{ -3,  1},{  3,  1},{ -1,  3},{  1,  3},{ -2, -3},{  2, -3},{ -3, -2},
   77 {  3, -2},{ -3,  2},{  3,  2},{ -2,  3},{  2,  3},{  0, -4},{ -4,  0},{  4,  0},
   78 {  0,  4},{ -1, -4},{  1, -4},{ -4, -1},{  4, -1},{  4,  1},{ -1,  4},{  1,  4},
   79 { -3, -3},{ -3,  3},{  3,  3},{ -2, -4},{ -4, -2},{  4, -2},{ -4,  2},{ -2,  4},
   80 {  2,  4},{ -3, -4},{  3, -4},{  4, -3},{ -5,  0},{ -4,  3},{ -3,  4},{  3,  4},
   81 { -1, -5},{ -5, -1},{ -5,  1},{ -1,  5},{ -2, -5},{  2, -5},{  5, -2},{  5,  2},
   82 { -4, -4},{ -4,  4},{ -3, -5},{ -5, -3},{ -5,  3},{  3,  5},{ -6,  0},{  0,  6},
   83 { -6, -1},{ -6,  1},{  1,  6},{  2, -6},{ -6,  2},{  2,  6},{ -5, -4},{  5,  4},
   84 {  4,  5},{ -6, -3},{  6,  3},{ -7,  0},{ -1, -7},{  5, -5},{ -7,  1},{ -1,  7},
   85 {  4, -6},{  6,  4},{ -2, -7},{ -7,  2},{ -3, -7},{  7, -3},{  3,  7},{  6, -5},
   86 {  0, -8},{ -1, -8},{ -7, -4},{ -8,  1},{  4,  7},{  2, -8},{ -2,  8},{  6,  6},
   87 { -8,  3},{  5, -7},{ -5,  7},{  8, -4},{  0, -9},{ -9, -1},{  1,  9},{  7, -6},
   88 { -7,  6},{ -5, -8},{ -5,  8},{ -9,  3},{  9, -4},{  7, -7},{  8, -6},{  6,  8},
   89 { 10,  1},{-10,  2},{  9, -5},{ 10, -3},{ -8, -7},{-10, -4},{  6, -9},{-11,  0},
   90 { 11,  1},{-11, -2},{ -2, 11},{  7, -9},{ -7,  9},{ 10,  6},{ -4, 11},{  8, -9},
   91 {  8,  9},{  5, 11},{  7,-10},{ 12, -3},{ 11,  6},{ -9, -9},{  8, 10},{  5, 12},
   92 {-11,  7},{ 13,  2},{  6,-12},{ 10,  9},{-11,  8},{ -7, 12},{  0, 14},{ 14, -2},
   93 { -9, 11},{ -6, 13},{-14, -4},{ -5,-14},{  5, 14},{-15, -1},{-14, -6},{  3,-15},
   94 { 11,-11},{ -7, 14},{ -5, 15},{  8,-14},{ 15,  6},{  3, 16},{  7,-15},{-16,  5},
   95 {  0, 17},{-16, -6},{-10, 14},{-16,  7},{ 12, 13},{-16,  8},{-17,  6},{-18,  3},
   96 { -7, 17},{ 15, 11},{ 16, 10},{  2,-19},{  3,-19},{-11,-16},{-18,  8},{-19, -6},
   97 {  2,-20},{-17,-11},{-10,-18},{  8, 19},{-21, -1},{-20,  7},{ -4, 21},{ 21,  5},
   98 { 15, 16},{  2,-22},{-10,-20},{-22,  5},{ 20,-11},{ -7,-22},{-12, 20},{ 23, -5},
   99 { 13,-20},{ 24, -2},{-15, 19},{-11, 22},{ 16, 19},{ 23,-10},{-18,-18},{ -9,-24},
  100 { 24,-10},{ -3, 26},{-23, 13},{-18,-20},{ 17, 21},{ -4, 27},{ 27,  6},{  1,-28},
  101 {-11, 26},{-17,-23},{  7, 28},{ 11,-27},{ 29,  5},{-23,-19},{-28,-11},{-21, 22},
  102 {-30,  7},{-17, 26},{-27, 16},{ 13, 29},{ 19,-26},{ 10,-31},{-14,-30},{ 20,-27},
  103 {-29, 18},{-16,-31},{-28,-22},{ 21,-30},{-25, 28},{ 26,-29},{ 25,-32},{-32,-32}
  104 };
  105 
  106 // this is simply the scaled down elementwise product of the standard jpeg quantizer table and the AAN premul table
  107 static const uint8_t dequant_table[64]={
  108  16, 15, 13, 19, 24, 31, 28, 17,
  109  17, 23, 25, 31, 36, 63, 45, 21,
  110  18, 24, 27, 37, 52, 59, 49, 20,
  111  16, 28, 34, 40, 60, 80, 51, 20,
  112  18, 31, 48, 66, 68, 86, 56, 21,
  113  19, 38, 56, 59, 64, 64, 48, 20,
  114  27, 48, 55, 55, 56, 51, 35, 15,
  115  20, 35, 34, 32, 31, 22, 15,  8,
  116 };
  117 
  118 static VLC block_type_vlc[2][4];
  119 
  120 
  121 typedef struct CFrameBuffer{
  122     unsigned int allocated_size;
  123     unsigned int size;
  124     int id;
  125     uint8_t *data;
  126 }CFrameBuffer;
  127 
  128 typedef struct FourXContext{
  129     AVCodecContext *avctx;
  130     DSPContext dsp;
  131     AVFrame current_picture, last_picture;
  132     GetBitContext pre_gb;          ///< ac/dc prefix
  133     GetBitContext gb;
  134     const uint8_t *bytestream;
  135     const uint16_t *wordstream;
  136     int mv[256];
  137     VLC pre_vlc;
  138     int last_dc;
  139     DECLARE_ALIGNED_8(DCTELEM, block[6][64]);
  140     uint8_t *bitstream_buffer;
  141     unsigned int bitstream_buffer_size;
  142     int version;
  143     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
  144 } FourXContext;
  145 
  146 
  147 #define FIX_1_082392200  70936
  148 #define FIX_1_414213562  92682
  149 #define FIX_1_847759065 121095
  150 #define FIX_2_613125930 171254
  151 
  152 #define MULTIPLY(var,const)  (((var)*(const)) >> 16)
  153 
  154 static void idct(DCTELEM block[64]){
  155     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  156     int tmp10, tmp11, tmp12, tmp13;
  157     int z5, z10, z11, z12, z13;
  158     int i;
  159     int temp[64];
  160 
  161     for(i=0; i<8; i++){
  162         tmp10 = block[8*0 + i] + block[8*4 + i];
  163         tmp11 = block[8*0 + i] - block[8*4 + i];
  164 
  165         tmp13 =          block[8*2 + i] + block[8*6 + i];
  166         tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
  167 
  168         tmp0 = tmp10 + tmp13;
  169         tmp3 = tmp10 - tmp13;
  170         tmp1 = tmp11 + tmp12;
  171         tmp2 = tmp11 - tmp12;
  172 
  173         z13 = block[8*5 + i] + block[8*3 + i];
  174         z10 = block[8*5 + i] - block[8*3 + i];
  175         z11 = block[8*1 + i] + block[8*7 + i];
  176         z12 = block[8*1 + i] - block[8*7 + i];
  177 
  178         tmp7  =          z11 + z13;
  179         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
  180 
  181         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
  182         tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
  183         tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
  184 
  185         tmp6 = tmp12 - tmp7;
  186         tmp5 = tmp11 - tmp6;
  187         tmp4 = tmp10 + tmp5;
  188 
  189         temp[8*0 + i] = tmp0 + tmp7;
  190         temp[8*7 + i] = tmp0 - tmp7;
  191         temp[8*1 + i] = tmp1 + tmp6;
  192         temp[8*6 + i] = tmp1 - tmp6;
  193         temp[8*2 + i] = tmp2 + tmp5;
  194         temp[8*5 + i] = tmp2 - tmp5;
  195         temp[8*4 + i] = tmp3 + tmp4;
  196         temp[8*3 + i] = tmp3 - tmp4;
  197     }
  198 
  199     for(i=0; i<8*8; i+=8){
  200         tmp10 = temp[0 + i] + temp[4 + i];
  201         tmp11 = temp[0 + i] - temp[4 + i];
  202 
  203         tmp13 = temp[2 + i] + temp[6 + i];
  204         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
  205 
  206         tmp0 = tmp10 + tmp13;
  207         tmp3 = tmp10 - tmp13;
  208         tmp1 = tmp11 + tmp12;
  209         tmp2 = tmp11 - tmp12;
  210 
  211         z13 = temp[5 + i] + temp[3 + i];
  212         z10 = temp[5 + i] - temp[3 + i];
  213         z11 = temp[1 + i] + temp[7 + i];
  214         z12 = temp[1 + i] - temp[7 + i];
  215 
  216         tmp7 = z11 + z13;
  217         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
  218 
  219         z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
  220         tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
  221         tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
  222 
  223         tmp6 = tmp12 - tmp7;
  224         tmp5 = tmp11 - tmp6;
  225         tmp4 = tmp10 + tmp5;
  226 
  227         block[0 + i] = (tmp0 + tmp7)>>6;
  228         block[7 + i] = (tmp0 - tmp7)>>6;
  229         block[1 + i] = (tmp1 + tmp6)>>6;
  230         block[6 + i] = (tmp1 - tmp6)>>6;
  231         block[2 + i] = (tmp2 + tmp5)>>6;
  232         block[5 + i] = (tmp2 - tmp5)>>6;
  233         block[4 + i] = (tmp3 + tmp4)>>6;
  234         block[3 + i] = (tmp3 - tmp4)>>6;
  235     }
  236 }
  237 
  238 static av_cold void init_vlcs(FourXContext *f){
  239     int i;
  240 
  241     for(i=0; i<8; i++){
  242         init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
  243                  &block_type_tab[0][i][0][1], 2, 1,
  244                  &block_type_tab[0][i][0][0], 2, 1, 1);
  245     }
  246 }
  247 
  248 static void init_mv(FourXContext *f){
  249     int i;
  250 
  251     for(i=0; i<256; i++){
  252         if(f->version>1)
  253             f->mv[i] = mv[i][0]   + mv[i][1]  *f->current_picture.linesize[0]/2;
  254         else
  255             f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
  256     }
  257 }
  258 
  259 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, int dc){
  260    int i;
  261    dc*= 0x10001;
  262 
  263    switch(log2w){
  264    case 0:
  265         for(i=0; i<h; i++){
  266             dst[0] = scale*src[0] + dc;
  267             if(scale) src += stride;
  268             dst += stride;
  269         }
  270         break;
  271     case 1:
  272         for(i=0; i<h; i++){
  273             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
  274             if(scale) src += stride;
  275             dst += stride;
  276         }
  277         break;
  278     case 2:
  279         for(i=0; i<h; i++){
  280             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
  281             ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
  282             if(scale) src += stride;
  283             dst += stride;
  284         }
  285         break;
  286     case 3:
  287         for(i=0; i<h; i++){
  288             ((uint32_t*)dst)[0] = scale*((uint32_t*)src)[0] + dc;
  289             ((uint32_t*)dst)[1] = scale*((uint32_t*)src)[1] + dc;
  290             ((uint32_t*)dst)[2] = scale*((uint32_t*)src)[2] + dc;
  291             ((uint32_t*)dst)[3] = scale*((uint32_t*)src)[3] + dc;
  292             if(scale) src += stride;
  293             dst += stride;
  294         }
  295         break;
  296     default: assert(0);
  297     }
  298 }
  299 
  300 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
  301     const int index= size2index[log2h][log2w];
  302     const int h= 1<<log2h;
  303     int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
  304     uint16_t *start= (uint16_t*)f->last_picture.data[0];
  305     uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
  306 
  307     assert(code>=0 && code<=6);
  308 
  309     if(code == 0){
  310         src += f->mv[ *f->bytestream++ ];
  311         if(start > src || src > end){
  312             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
  313             return;
  314         }
  315         mcdc(dst, src, log2w, h, stride, 1, 0);
  316     }else if(code == 1){
  317         log2h--;
  318         decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
  319         decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
  320     }else if(code == 2){
  321         log2w--;
  322         decode_p_block(f, dst             , src             , log2w, log2h, stride);
  323         decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
  324     }else if(code == 3 && f->version<2){
  325         mcdc(dst, src, log2w, h, stride, 1, 0);
  326     }else if(code == 4){
  327         src += f->mv[ *f->bytestream++ ];
  328         if(start > src || src > end){
  329             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
  330             return;
  331         }
  332         mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
  333     }else if(code == 5){
  334         mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
  335     }else if(code == 6){
  336         if(log2w){
  337             dst[0] = le2me_16(*f->wordstream++);
  338             dst[1] = le2me_16(*f->wordstream++);
  339         }else{
  340             dst[0     ] = le2me_16(*f->wordstream++);
  341             dst[stride] = le2me_16(*f->wordstream++);
  342         }
  343     }
  344 }
  345 
  346 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
  347     int x, y;
  348     const int width= f->avctx->width;
  349     const int height= f->avctx->height;
  350     uint16_t *src= (uint16_t*)f->last_picture.data[0];
  351     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
  352     const int stride= f->current_picture.linesize[0]>>1;
  353     unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
  354 
  355     if(f->version>1){
  356         extra=20;
  357         bitstream_size= AV_RL32(buf+8);
  358         wordstream_size= AV_RL32(buf+12);
  359         bytestream_size= AV_RL32(buf+16);
  360     }else{
  361         extra=0;
  362         bitstream_size = AV_RL16(buf-4);
  363         wordstream_size= AV_RL16(buf-2);
  364         bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
  365     }
  366 
  367     if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
  368        || bitstream_size  > (1<<26)
  369        || bytestream_size > (1<<26)
  370        || wordstream_size > (1<<26)
  371        ){
  372         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
  373         bitstream_size+ bytestream_size+ wordstream_size - length);
  374         return -1;
  375     }
  376 
  377     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
  378     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
  379     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
  380 
  381     f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
  382     f->bytestream= buf + extra + bitstream_size + wordstream_size;
  383 
  384     init_mv(f);
  385 
  386     for(y=0; y<height; y+=8){
  387         for(x=0; x<width; x+=8){
  388             decode_p_block(f, dst + x, src + x, 3, 3, stride);
  389         }
  390         src += 8*stride;
  391         dst += 8*stride;
  392     }
  393 
  394     if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
  395        || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
  396        || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
  397         av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
  398             bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
  399             -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
  400             -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
  401         );
  402 
  403     return 0;
  404 }
  405 
  406 /**
  407  * decode block and dequantize.
  408  * Note this is almost identical to MJPEG.
  409  */
  410 static int decode_i_block(FourXContext *f, DCTELEM *block){
  411     int code, i, j, level, val;
  412 
  413     /* DC coef */
  414     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
  415     if (val>>4){
  416         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
  417     }
  418 
  419     if(val)
  420         val = get_xbits(&f->gb, val);
  421 
  422     val = val * dequant_table[0] + f->last_dc;
  423     f->last_dc =
  424     block[0] = val;
  425     /* AC coefs */
  426     i = 1;
  427     for(;;) {
  428         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
  429 
  430         /* EOB */
  431         if (code == 0)
  432             break;
  433         if (code == 0xf0) {
  434             i += 16;
  435         } else {
  436             level = get_xbits(&f->gb, code & 0xf);
  437             i += code >> 4;
  438             if (i >= 64) {
  439                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
  440                 return 0;
  441             }
  442 
  443             j= ff_zigzag_direct[i];
  444             block[j] = level * dequant_table[j];
  445             i++;
  446             if (i >= 64)
  447                 break;
  448         }
  449     }
  450 
  451     return 0;
  452 }
  453 
  454 static inline void idct_put(FourXContext *f, int x, int y){
  455     DCTELEM (*block)[64]= f->block;
  456     int stride= f->current_picture.linesize[0]>>1;
  457     int i;
  458     uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
  459 
  460     for(i=0; i<4; i++){
  461         block[i][0] += 0x80*8*8;
  462         idct(block[i]);
  463     }
  464 
  465     if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
  466         for(i=4; i<6; i++) idct(block[i]);
  467     }
  468 
  469 /* Note transform is:
  470 y= ( 1b + 4g + 2r)/14
  471 cb=( 3b - 2g - 1r)/14
  472 cr=(-1b - 4g + 5r)/14
  473 */
  474     for(y=0; y<8; y++){
  475         for(x=0; x<8; x++){
  476             DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
  477             int cb= block[4][x + 8*y];
  478             int cr= block[5][x + 8*y];
  479             int cg= (cb + cr)>>1;
  480             int y;
  481 
  482             cb+=cb;
  483 
  484             y = temp[0];
  485             dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
  486             y = temp[1];
  487             dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
  488             y = temp[8];
  489             dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
  490             y = temp[9];
  491             dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
  492             dst += 2;
  493         }
  494         dst += 2*stride - 2*8;
  495     }
  496 }
  497 
  498 static int decode_i_mb(FourXContext *f){
  499     int i;
  500 
  501     f->dsp.clear_blocks(f->block[0]);
  502 
  503     for(i=0; i<6; i++){
  504         if(decode_i_block(f, f->block[i]) < 0)
  505             return -1;
  506     }
  507 
  508     return 0;
  509 }
  510 
  511 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf){
  512     int frequency[512];
  513     uint8_t flag[512];
  514     int up[512];
  515     uint8_t len_tab[257];
  516     int bits_tab[257];
  517     int start, end;
  518     const uint8_t *ptr= buf;
  519     int j;
  520 
  521     memset(frequency, 0, sizeof(frequency));
  522     memset(up, -1, sizeof(up));
  523 
  524     start= *ptr++;
  525     end= *ptr++;
  526     for(;;){
  527         int i;
  528 
  529         for(i=start; i<=end; i++){
  530             frequency[i]= *ptr++;
  531         }
  532         start= *ptr++;
  533         if(start==0) break;
  534 
  535         end= *ptr++;
  536     }
  537     frequency[256]=1;
  538 
  539     while((ptr - buf)&3) ptr++; // 4byte align
  540 
  541     for(j=257; j<512; j++){
  542         int min_freq[2]= {256*256, 256*256};
  543         int smallest[2]= {0, 0};
  544         int i;
  545         for(i=0; i<j; i++){
  546             if(frequency[i] == 0) continue;
  547             if(frequency[i] < min_freq[1]){
  548                 if(frequency[i] < min_freq[0]){
  549                     min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
  550                     min_freq[0]= frequency[i];smallest[0]= i;
  551                 }else{
  552                     min_freq[1]= frequency[i];smallest[1]= i;
  553                 }
  554             }
  555         }
  556         if(min_freq[1] == 256*256) break;
  557 
  558         frequency[j]= min_freq[0] + min_freq[1];
  559         flag[ smallest[0] ]= 0;
  560         flag[ smallest[1] ]= 1;
  561         up[ smallest[0] ]=
  562         up[ smallest[1] ]= j;
  563         frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
  564     }
  565 
  566     for(j=0; j<257; j++){
  567         int node;
  568         int len=0;
  569         int bits=0;
  570 
  571         for(node= j; up[node] != -1; node= up[node]){
  572             bits += flag[node]<<len;
  573             len++;
  574             if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
  575         }
  576 
  577         bits_tab[j]= bits;
  578         len_tab[j]= len;
  579     }
  580 
  581     init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
  582              len_tab , 1, 1,
  583              bits_tab, 4, 4, 0);
  584 
  585     return ptr;
  586 }
  587 
  588 static int mix(int c0, int c1){
  589     int blue = 2*(c0&0x001F) + (c1&0x001F);
  590     int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
  591     int red  = 2*(c0>>10) + (c1>>10);
  592     return red/3*1024 + green/3*32 + blue/3;
  593 }
  594 
  595 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
  596     int x, y, x2, y2;
  597     const int width= f->avctx->width;
  598     const int height= f->avctx->height;
  599     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
  600     const int stride= f->current_picture.linesize[0]>>1;
  601 
  602     for(y=0; y<height; y+=16){
  603         for(x=0; x<width; x+=16){
  604             unsigned int color[4], bits;
  605             memset(color, 0, sizeof(color));
  606 //warning following is purely guessed ...
  607             color[0]= bytestream_get_le16(&buf);
  608             color[1]= bytestream_get_le16(&buf);
  609 
  610             if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
  611             if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
  612 
  613             color[2]= mix(color[0], color[1]);
  614             color[3]= mix(color[1], color[0]);
  615 
  616             bits= bytestream_get_le32(&buf);
  617             for(y2=0; y2<16; y2++){
  618                 for(x2=0; x2<16; x2++){
  619                     int index= 2*(x2>>2) + 8*(y2>>2);
  620                     dst[y2*stride+x2]= color[(bits>>index)&3];
  621                 }
  622             }
  623             dst+=16;
  624         }
  625         dst += 16*stride - width;
  626     }
  627 
  628     return 0;
  629 }
  630 
  631 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
  632     int x, y;
  633     const int width= f->avctx->width;
  634     const int height= f->avctx->height;
  635     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
  636     const int stride= f->current_picture.linesize[0]>>1;
  637     const unsigned int bitstream_size= AV_RL32(buf);
  638     const int token_count av_unused = AV_RL32(buf + bitstream_size + 8);
  639     unsigned int prestream_size= 4*AV_RL32(buf + bitstream_size + 4);
  640     const uint8_t *prestream= buf + bitstream_size + 12;
  641 
  642     if(prestream_size + bitstream_size + 12 != length
  643        || bitstream_size > (1<<26)
  644        || prestream_size > (1<<26)){
  645         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
  646         return -1;
  647     }
  648 
  649     prestream= read_huffman_tables(f, prestream);
  650 
  651     init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
  652 
  653     prestream_size= length + buf - prestream;
  654 
  655     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
  656     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
  657     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
  658 
  659     f->last_dc= 0*128*8*8;
  660 
  661     for(y=0; y<height; y+=16){
  662         for(x=0; x<width; x+=16){
  663             if(decode_i_mb(f) < 0)
  664                 return -1;
  665 
  666             idct_put(f, x, y);
  667         }
  668         dst += 16*stride;
  669     }
  670 
  671     if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
  672         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
  673 
  674     return 0;
  675 }
  676 
  677 static int decode_frame(AVCodecContext *avctx,
  678                         void *data, int *data_size,
  679                         const uint8_t *buf, int buf_size)
  680 {
  681     FourXContext * const f = avctx->priv_data;
  682     AVFrame *picture = data;
  683     AVFrame *p, temp;
  684     int i, frame_4cc, frame_size;
  685 
  686     frame_4cc= AV_RL32(buf);
  687     if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
  688         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
  689     }
  690 
  691     if(frame_4cc == ff_get_fourcc("cfrm")){
  692         int free_index=-1;
  693         const int data_size= buf_size - 20;
  694         const int id= AV_RL32(buf+12);
  695         const int whole_size= AV_RL32(buf+16);
  696         CFrameBuffer *cfrm;
  697 
  698         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
  699             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
  700                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
  701         }
  702 
  703         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
  704             if(f->cfrm[i].id   == id) break;
  705             if(f->cfrm[i].size == 0 ) free_index= i;
  706         }
  707 
  708         if(i>=CFRAME_BUFFER_COUNT){
  709             i= free_index;
  710             f->cfrm[i].id= id;
  711         }
  712         cfrm= &f->cfrm[i];
  713 
  714         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
  715         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
  716             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
  717             return -1;
  718         }
  719 
  720         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
  721         cfrm->size += data_size;
  722 
  723         if(cfrm->size >= whole_size){
  724             buf= cfrm->data;
  725             frame_size= cfrm->size;
  726 
  727             if(id != avctx->frame_number){
  728                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
  729             }
  730 
  731             cfrm->size= cfrm->id= 0;
  732             frame_4cc= ff_get_fourcc("pfrm");
  733         }else
  734             return buf_size;
  735     }else{
  736         buf= buf + 12;
  737         frame_size= buf_size - 12;
  738     }
  739 
  740     temp= f->current_picture;
  741     f->current_picture= f->last_picture;
  742     f->last_picture= temp;
  743 
  744     p= &f->current_picture;
  745     avctx->coded_frame= p;
  746 
  747     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
  748 
  749     if(p->data[0])
  750         avctx->release_buffer(avctx, p);
  751 
  752     p->reference= 1;
  753     if(avctx->get_buffer(avctx, p) < 0){
  754         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  755         return -1;
  756     }
  757 
  758     if(frame_4cc == ff_get_fourcc("ifr2")){
  759         p->pict_type= FF_I_TYPE;
  760         if(decode_i2_frame(f, buf-4, frame_size) < 0)
  761             return -1;
  762     }else if(frame_4cc == ff_get_fourcc("ifrm")){
  763         p->pict_type= FF_I_TYPE;
  764         if(decode_i_frame(f, buf, frame_size) < 0)
  765             return -1;
  766     }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
  767         p->pict_type= FF_P_TYPE;
  768         if(decode_p_frame(f, buf, frame_size) < 0)
  769             return -1;
  770     }else if(frame_4cc == ff_get_fourcc("snd_")){
  771         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
  772     }else{
  773         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
  774     }
  775 
  776     p->key_frame= p->pict_type == FF_I_TYPE;
  777 
  778     *picture= *p;
  779     *data_size = sizeof(AVPicture);
  780 
  781     emms_c();
  782 
  783     return buf_size;
  784 }
  785 
  786 
  787 static void common_init(AVCodecContext *avctx){
  788     FourXContext * const f = avctx->priv_data;
  789 
  790     dsputil_init(&f->dsp, avctx);
  791 
  792     f->avctx= avctx;
  793 }
  794 
  795 static av_cold int decode_init(AVCodecContext *avctx){
  796     FourXContext * const f = avctx->priv_data;
  797 
  798     if(avctx->extradata_size != 4 || !avctx->extradata) {
  799         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
  800         return 1;
  801     }
  802 
  803     f->version= AV_RL32(avctx->extradata)>>16;
  804     common_init(avctx);
  805     init_vlcs(f);
  806 
  807     if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
  808     else             avctx->pix_fmt= PIX_FMT_RGB555;
  809 
  810     return 0;
  811 }
  812 
  813 
  814 static av_cold int decode_end(AVCodecContext *avctx){
  815     FourXContext * const f = avctx->priv_data;
  816     int i;
  817 
  818     av_freep(&f->bitstream_buffer);
  819     f->bitstream_buffer_size=0;
  820     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
  821         av_freep(&f->cfrm[i].data);
  822         f->cfrm[i].allocated_size= 0;
  823     }
  824     free_vlc(&f->pre_vlc);
  825 
  826     return 0;
  827 }
  828 
  829 AVCodec fourxm_decoder = {
  830     "4xm",
  831     CODEC_TYPE_VIDEO,
  832     CODEC_ID_4XM,
  833     sizeof(FourXContext),
  834     decode_init,
  835     NULL,
  836     decode_end,
  837     decode_frame,
  838     /*CODEC_CAP_DR1,*/
  839     .long_name = "4X Movie",
  840 };
  841