git.sesse.net Git - ffmpeg/blob - 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 4xm.c
  24  * 4XM codec.
  25  */
  26
  27 #include "avcodec.h"
  28 #include "dsputil.h"
  29 #include "mpegvideo.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     uint8_t *bytestream;
 135     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 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 get32(void *p){
 347     return le2me_32(*(uint32_t*)p);
 348 }
 349
 350 static int decode_p_frame(FourXContext *f, 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= get32(buf+8);
 362         wordstream_size= get32(buf+12);
 363         bytestream_size= get32(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, (uint32_t*)(buf + extra), bitstream_size/4);
 383     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
 384
 385     f->wordstream= (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        || (((char*)f->wordstream - (char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
 400        || (((char*)f->bytestream - (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             -(((char*)f->bytestream - (char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
 404             -(((char*)f->wordstream - (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 allmost 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 uint8_t *read_huffman_tables(FourXContext *f, 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     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, 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, 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= get32(buf);
 642     const int token_count av_unused = get32(buf + bitstream_size + 8);
 643     unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
 644     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, (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                         uint8_t *buf, int buf_size)
 684 {
 685     FourXContext * const f = avctx->priv_data;
 686     AVFrame *picture = data;
 687     AVFrame *p, temp;
 688     int i, frame_4cc, frame_size;
 689
 690     frame_4cc= get32(buf);
 691     if(buf_size != get32(buf+4)+8 || buf_size < 20){
 692         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
 693     }
 694
 695     if(frame_4cc == ff_get_fourcc("cfrm")){
 696         int free_index=-1;
 697         const int data_size= buf_size - 20;
 698         const int id= get32(buf+12);
 699         const int whole_size= get32(buf+16);
 700         CFrameBuffer *cfrm;
 701
 702         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 703             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 704                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
 705         }
 706
 707         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 708             if(f->cfrm[i].id   == id) break;
 709             if(f->cfrm[i].size == 0 ) free_index= i;
 710         }
 711
 712         if(i>=CFRAME_BUFFER_COUNT){
 713             i= free_index;
 714             f->cfrm[i].id= id;
 715         }
 716         cfrm= &f->cfrm[i];
 717
 718         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 719         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
 720             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
 721             return -1;
 722         }
 723
 724         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
 725         cfrm->size += data_size;
 726
 727         if(cfrm->size >= whole_size){
 728             buf= cfrm->data;
 729             frame_size= cfrm->size;
 730
 731             if(id != avctx->frame_number){
 732                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
 733             }
 734
 735             cfrm->size= cfrm->id= 0;
 736             frame_4cc= ff_get_fourcc("pfrm");
 737         }else
 738             return buf_size;
 739     }else{
 740         buf= buf + 12;
 741         frame_size= buf_size - 12;
 742     }
 743
 744     temp= f->current_picture;
 745     f->current_picture= f->last_picture;
 746     f->last_picture= temp;
 747
 748     p= &f->current_picture;
 749     avctx->coded_frame= p;
 750
 751     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
 752
 753     if(p->data[0])
 754         avctx->release_buffer(avctx, p);
 755
 756     p->reference= 1;
 757     if(avctx->get_buffer(avctx, p) < 0){
 758         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 759         return -1;
 760     }
 761
 762     if(frame_4cc == ff_get_fourcc("ifr2")){
 763         p->pict_type= I_TYPE;
 764         if(decode_i2_frame(f, buf-4, frame_size) < 0)
 765             return -1;
 766     }else if(frame_4cc == ff_get_fourcc("ifrm")){
 767         p->pict_type= I_TYPE;
 768         if(decode_i_frame(f, buf, frame_size) < 0)
 769             return -1;
 770     }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
 771         p->pict_type= P_TYPE;
 772         if(decode_p_frame(f, buf, frame_size) < 0)
 773             return -1;
 774     }else if(frame_4cc == ff_get_fourcc("snd_")){
 775         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
 776     }else{
 777         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
 778     }
 779
 780     p->key_frame= p->pict_type == I_TYPE;
 781
 782     *picture= *p;
 783     *data_size = sizeof(AVPicture);
 784
 785     emms_c();
 786
 787     return buf_size;
 788 }
 789
 790
 791 static void common_init(AVCodecContext *avctx){
 792     FourXContext * const f = avctx->priv_data;
 793
 794     dsputil_init(&f->dsp, avctx);
 795
 796     f->avctx= avctx;
 797 }
 798
 799 static int decode_init(AVCodecContext *avctx){
 800     FourXContext * const f = avctx->priv_data;
 801
 802     if(avctx->extradata_size != 4 || !avctx->extradata) {
 803         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 804         return 1;
 805     }
 806
 807     f->version= AV_RL32(avctx->extradata)>>16;
 808     common_init(avctx);
 809     init_vlcs(f);
 810
 811     if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
 812     else             avctx->pix_fmt= PIX_FMT_RGB555;
 813
 814     return 0;
 815 }
 816
 817
 818 static int decode_end(AVCodecContext *avctx){
 819     FourXContext * const f = avctx->priv_data;
 820     int i;
 821
 822     av_freep(&f->bitstream_buffer);
 823     f->bitstream_buffer_size=0;
 824     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 825         av_freep(&f->cfrm[i].data);
 826         f->cfrm[i].allocated_size= 0;
 827     }
 828     free_vlc(&f->pre_vlc);
 829
 830     return 0;
 831 }
 832
 833 AVCodec fourxm_decoder = {
 834     "4xm",
 835     CODEC_TYPE_VIDEO,
 836     CODEC_ID_4XM,
 837     sizeof(FourXContext),
 838     decode_init,
 839     NULL,
 840     decode_end,
 841     decode_frame,
 842     /*CODEC_CAP_DR1,*/
 843 };
 844