libavcodec/4xm.c

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