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)
 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][index].table, BLOCK_TYPE_VLC_BITS, 1);
 304
 305     assert(code>=0 && code<=6);
 306
 307     if(code == 0){
 308         src += f->mv[ *f->bytestream++ ];
 309         mcdc(dst, src, log2w, h, stride, 1, 0);
 310     }else if(code == 1){
 311         log2h--;
 312         decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
 313         decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
 314     }else if(code == 2){
 315         log2w--;
 316         decode_p_block(f, dst             , src             , log2w, log2h, stride);
 317         decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
 318     }else if(code == 3 && f->version==0){
 319         mcdc(dst, src, log2w, h, stride, 1, 0);
 320     }else if(code == 4){
 321         src += f->mv[ *f->bytestream++ ];
 322         mcdc(dst, src, log2w, h, stride, 1, le2me_16(*f->wordstream++));
 323     }else if(code == 5){
 324         mcdc(dst, src, log2w, h, stride, 0, le2me_16(*f->wordstream++));
 325     }else if(code == 6){
 326         if(log2w){
 327             dst[0] = le2me_16(*f->wordstream++);
 328             dst[1] = le2me_16(*f->wordstream++);
 329         }else{
 330             dst[0     ] = le2me_16(*f->wordstream++);
 331             dst[stride] = le2me_16(*f->wordstream++);
 332         }
 333     }
 334 }
 335
 336 static int get32(void *p){
 337     return le2me_32(*(uint32_t*)p);
 338 }
 339
 340 static int decode_p_frame(FourXContext *f, uint8_t *buf, int length){
 341     int x, y;
 342     const int width= f->avctx->width;
 343     const int height= f->avctx->height;
 344     uint16_t *src= (uint16_t*)f->last_picture.data[0];
 345     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 346     const int stride= f->current_picture.linesize[0]>>1;
 347     unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
 348
 349     if(f->version){
 350         extra=20;
 351         bitstream_size= get32(buf+8);
 352         wordstream_size= get32(buf+12);
 353         bytestream_size= get32(buf+16);
 354     }else{
 355         extra=0;
 356         bitstream_size = AV_RL16(buf-4);
 357         wordstream_size= AV_RL16(buf-2);
 358         bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
 359     }
 360
 361     if(bitstream_size+ bytestream_size+ wordstream_size + extra != length
 362        || bitstream_size  > (1<<26)
 363        || bytestream_size > (1<<26)
 364        || wordstream_size > (1<<26)
 365        ){
 366         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
 367         bitstream_size+ bytestream_size+ wordstream_size - length);
 368         return -1;
 369     }
 370
 371     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 372     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)(buf + extra), bitstream_size/4);
 373     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
 374
 375     f->wordstream= (uint16_t*)(buf + extra + bitstream_size);
 376     f->bytestream= buf + extra + bitstream_size + wordstream_size;
 377
 378     init_mv(f);
 379
 380     for(y=0; y<height; y+=8){
 381         for(x=0; x<width; x+=8){
 382             decode_p_block(f, dst + x, src + x, 3, 3, stride);
 383         }
 384         src += 8*stride;
 385         dst += 8*stride;
 386     }
 387
 388     if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
 389        || (((char*)f->wordstream - (char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
 390        || (((char*)f->bytestream - (char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
 391         av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
 392             bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
 393             -(((char*)f->bytestream - (char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
 394             -(((char*)f->wordstream - (char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
 395         );
 396
 397     return 0;
 398 }
 399
 400 /**
 401  * decode block and dequantize.
 402  * Note this is allmost identical to mjpeg
 403  */
 404 static int decode_i_block(FourXContext *f, DCTELEM *block){
 405     int code, i, j, level, val;
 406
 407     /* DC coef */
 408     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 409     if (val>>4){
 410         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
 411     }
 412
 413     if(val)
 414         val = get_xbits(&f->gb, val);
 415
 416     val = val * dequant_table[0] + f->last_dc;
 417     f->last_dc =
 418     block[0] = val;
 419     /* AC coefs */
 420     i = 1;
 421     for(;;) {
 422         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 423
 424         /* EOB */
 425         if (code == 0)
 426             break;
 427         if (code == 0xf0) {
 428             i += 16;
 429         } else {
 430             level = get_xbits(&f->gb, code & 0xf);
 431             i += code >> 4;
 432             if (i >= 64) {
 433                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
 434                 return 0;
 435             }
 436
 437             j= ff_zigzag_direct[i];
 438             block[j] = level * dequant_table[j];
 439             i++;
 440             if (i >= 64)
 441                 break;
 442         }
 443     }
 444
 445     return 0;
 446 }
 447
 448 static inline void idct_put(FourXContext *f, int x, int y){
 449     DCTELEM (*block)[64]= f->block;
 450     int stride= f->current_picture.linesize[0]>>1;
 451     int i;
 452     uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
 453
 454     for(i=0; i<4; i++){
 455         block[i][0] += 0x80*8*8;
 456         idct(block[i]);
 457     }
 458
 459     if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
 460         for(i=4; i<6; i++) idct(block[i]);
 461     }
 462
 463 /* Note transform is:
 464 y= ( 1b + 4g + 2r)/14
 465 cb=( 3b - 2g - 1r)/14
 466 cr=(-1b - 4g + 5r)/14
 467 */
 468     for(y=0; y<8; y++){
 469         for(x=0; x<8; x++){
 470             DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
 471             int cb= block[4][x + 8*y];
 472             int cr= block[5][x + 8*y];
 473             int cg= (cb + cr)>>1;
 474             int y;
 475
 476             cb+=cb;
 477
 478             y = temp[0];
 479             dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 480             y = temp[1];
 481             dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 482             y = temp[8];
 483             dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 484             y = temp[9];
 485             dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 486             dst += 2;
 487         }
 488         dst += 2*stride - 2*8;
 489     }
 490 }
 491
 492 static int decode_i_mb(FourXContext *f){
 493     int i;
 494
 495     f->dsp.clear_blocks(f->block[0]);
 496
 497     for(i=0; i<6; i++){
 498         if(decode_i_block(f, f->block[i]) < 0)
 499             return -1;
 500     }
 501
 502     return 0;
 503 }
 504
 505 static uint8_t *read_huffman_tables(FourXContext *f, uint8_t * const buf){
 506     int frequency[512];
 507     uint8_t flag[512];
 508     int up[512];
 509     uint8_t len_tab[257];
 510     int bits_tab[257];
 511     int start, end;
 512     uint8_t *ptr= buf;
 513     int j;
 514
 515     memset(frequency, 0, sizeof(frequency));
 516     memset(up, -1, sizeof(up));
 517
 518     start= *ptr++;
 519     end= *ptr++;
 520     for(;;){
 521         int i;
 522
 523         for(i=start; i<=end; i++){
 524             frequency[i]= *ptr++;
 525         }
 526         start= *ptr++;
 527         if(start==0) break;
 528
 529         end= *ptr++;
 530     }
 531     frequency[256]=1;
 532
 533     while((ptr - buf)&3) ptr++; // 4byte align
 534
 535     for(j=257; j<512; j++){
 536         int min_freq[2]= {256*256, 256*256};
 537         int smallest[2]= {0, 0};
 538         int i;
 539         for(i=0; i<j; i++){
 540             if(frequency[i] == 0) continue;
 541             if(frequency[i] < min_freq[1]){
 542                 if(frequency[i] < min_freq[0]){
 543                     min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
 544                     min_freq[0]= frequency[i];smallest[0]= i;
 545                 }else{
 546                     min_freq[1]= frequency[i];smallest[1]= i;
 547                 }
 548             }
 549         }
 550         if(min_freq[1] == 256*256) break;
 551
 552         frequency[j]= min_freq[0] + min_freq[1];
 553         flag[ smallest[0] ]= 0;
 554         flag[ smallest[1] ]= 1;
 555         up[ smallest[0] ]=
 556         up[ smallest[1] ]= j;
 557         frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
 558     }
 559
 560     for(j=0; j<257; j++){
 561         int node;
 562         int len=0;
 563         int bits=0;
 564
 565         for(node= j; up[node] != -1; node= up[node]){
 566             bits += flag[node]<<len;
 567             len++;
 568             if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
 569         }
 570
 571         bits_tab[j]= bits;
 572         len_tab[j]= len;
 573     }
 574
 575     init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
 576              len_tab , 1, 1,
 577              bits_tab, 4, 4, 0);
 578
 579     return ptr;
 580 }
 581
 582 static int mix(int c0, int c1){
 583     int blue = 2*(c0&0x001F) + (c1&0x001F);
 584     int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
 585     int red  = 2*(c0>>10) + (c1>>10);
 586     return red/3*1024 + green/3*32 + blue/3;
 587 }
 588
 589 static int decode_i2_frame(FourXContext *f, uint8_t *buf, int length){
 590     int x, y, x2, y2;
 591     const int width= f->avctx->width;
 592     const int height= f->avctx->height;
 593     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 594     const int stride= f->current_picture.linesize[0]>>1;
 595
 596     for(y=0; y<height; y+=16){
 597         for(x=0; x<width; x+=16){
 598             unsigned int color[4], bits;
 599             memset(color, 0, sizeof(color));
 600 //warning following is purely guessed ...
 601             color[0]= bytestream_get_le16(&buf);
 602             color[1]= bytestream_get_le16(&buf);
 603
 604             if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
 605             if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
 606
 607             color[2]= mix(color[0], color[1]);
 608             color[3]= mix(color[1], color[0]);
 609
 610             bits= bytestream_get_le32(&buf);
 611             for(y2=0; y2<16; y2++){
 612                 for(x2=0; x2<16; x2++){
 613                     int index= 2*(x2>>2) + 8*(y2>>2);
 614                     dst[y2*stride+x2]= color[(bits>>index)&3];
 615                 }
 616             }
 617             dst+=16;
 618         }
 619         dst += 16*stride - width;
 620     }
 621
 622     return 0;
 623 }
 624
 625 static int decode_i_frame(FourXContext *f, uint8_t *buf, int length){
 626     int x, y;
 627     const int width= f->avctx->width;
 628     const int height= f->avctx->height;
 629     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 630     const int stride= f->current_picture.linesize[0]>>1;
 631     const unsigned int bitstream_size= get32(buf);
 632     const int token_count av_unused = get32(buf + bitstream_size + 8);
 633     unsigned int prestream_size= 4*get32(buf + bitstream_size + 4);
 634     uint8_t *prestream= buf + bitstream_size + 12;
 635
 636     if(prestream_size + bitstream_size + 12 != length
 637        || bitstream_size > (1<<26)
 638        || prestream_size > (1<<26)){
 639         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
 640         return -1;
 641     }
 642
 643     prestream= read_huffman_tables(f, prestream);
 644
 645     init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
 646
 647     prestream_size= length + buf - prestream;
 648
 649     f->bitstream_buffer= av_fast_realloc(f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 650     f->dsp.bswap_buf((uint32_t*)f->bitstream_buffer, (uint32_t*)prestream, prestream_size/4);
 651     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
 652
 653     f->last_dc= 0*128*8*8;
 654
 655     for(y=0; y<height; y+=16){
 656         for(x=0; x<width; x+=16){
 657             if(decode_i_mb(f) < 0)
 658                 return -1;
 659
 660             idct_put(f, x, y);
 661         }
 662         dst += 16*stride;
 663     }
 664
 665     if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 666         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 667
 668     return 0;
 669 }
 670
 671 static int decode_frame(AVCodecContext *avctx,
 672                         void *data, int *data_size,
 673                         uint8_t *buf, int buf_size)
 674 {
 675     FourXContext * const f = avctx->priv_data;
 676     AVFrame *picture = data;
 677     AVFrame *p, temp;
 678     int i, frame_4cc, frame_size;
 679
 680     frame_4cc= get32(buf);
 681     if(buf_size != get32(buf+4)+8 || buf_size < 20){
 682         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, get32(buf+4));
 683     }
 684
 685     if(frame_4cc == ff_get_fourcc("cfrm")){
 686         int free_index=-1;
 687         const int data_size= buf_size - 20;
 688         const int id= get32(buf+12);
 689         const int whole_size= get32(buf+16);
 690         CFrameBuffer *cfrm;
 691
 692         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 693             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 694                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
 695         }
 696
 697         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 698             if(f->cfrm[i].id   == id) break;
 699             if(f->cfrm[i].size == 0 ) free_index= i;
 700         }
 701
 702         if(i>=CFRAME_BUFFER_COUNT){
 703             i= free_index;
 704             f->cfrm[i].id= id;
 705         }
 706         cfrm= &f->cfrm[i];
 707
 708         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 709         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
 710             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
 711             return -1;
 712         }
 713
 714         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
 715         cfrm->size += data_size;
 716
 717         if(cfrm->size >= whole_size){
 718             buf= cfrm->data;
 719             frame_size= cfrm->size;
 720
 721             if(id != avctx->frame_number){
 722                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
 723             }
 724
 725             cfrm->size= cfrm->id= 0;
 726             frame_4cc= ff_get_fourcc("pfrm");
 727         }else
 728             return buf_size;
 729     }else{
 730         buf= buf + 12;
 731         frame_size= buf_size - 12;
 732     }
 733
 734     temp= f->current_picture;
 735     f->current_picture= f->last_picture;
 736     f->last_picture= temp;
 737
 738     p= &f->current_picture;
 739     avctx->coded_frame= p;
 740
 741     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
 742
 743     if(p->data[0])
 744         avctx->release_buffer(avctx, p);
 745
 746     p->reference= 1;
 747     if(avctx->get_buffer(avctx, p) < 0){
 748         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 749         return -1;
 750     }
 751
 752     if(frame_4cc == ff_get_fourcc("ifr2")){
 753         p->pict_type= I_TYPE;
 754         if(decode_i2_frame(f, buf-4, frame_size) < 0)
 755             return -1;
 756     }else if(frame_4cc == ff_get_fourcc("ifrm")){
 757         p->pict_type= I_TYPE;
 758         if(decode_i_frame(f, buf, frame_size) < 0)
 759             return -1;
 760     }else if(frame_4cc == ff_get_fourcc("pfrm") || frame_4cc == ff_get_fourcc("pfr2")){
 761         p->pict_type= P_TYPE;
 762         if(decode_p_frame(f, buf, frame_size) < 0)
 763             return -1;
 764     }else if(frame_4cc == ff_get_fourcc("snd_")){
 765         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
 766     }else{
 767         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
 768     }
 769
 770     p->key_frame= p->pict_type == I_TYPE;
 771
 772     *picture= *p;
 773     *data_size = sizeof(AVPicture);
 774
 775     emms_c();
 776
 777     return buf_size;
 778 }
 779
 780
 781 static void common_init(AVCodecContext *avctx){
 782     FourXContext * const f = avctx->priv_data;
 783
 784     dsputil_init(&f->dsp, avctx);
 785
 786     f->avctx= avctx;
 787 }
 788
 789 static int decode_init(AVCodecContext *avctx){
 790     FourXContext * const f = avctx->priv_data;
 791
 792     if(avctx->extradata_size != 4 || !avctx->extradata) {
 793         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 794         return 1;
 795     }
 796
 797     f->version= AV_RL32(avctx->extradata) == 0x40000;
 798     common_init(avctx);
 799     init_vlcs(f);
 800
 801     if(f->version) avctx->pix_fmt= PIX_FMT_RGB565;
 802     else           avctx->pix_fmt= PIX_FMT_RGB555;
 803
 804     return 0;
 805 }
 806
 807
 808 static int decode_end(AVCodecContext *avctx){
 809     FourXContext * const f = avctx->priv_data;
 810     int i;
 811
 812     av_freep(&f->bitstream_buffer);
 813     f->bitstream_buffer_size=0;
 814     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 815         av_freep(&f->cfrm[i].data);
 816         f->cfrm[i].allocated_size= 0;
 817     }
 818     free_vlc(&f->pre_vlc);
 819
 820     return 0;
 821 }
 822
 823 AVCodec fourxm_decoder = {
 824     "4xm",
 825     CODEC_TYPE_VIDEO,
 826     CODEC_ID_4XM,
 827     sizeof(FourXContext),
 828     decode_init,
 829     NULL,
 830     decode_end,
 831     decode_frame,
 832     /*CODEC_CAP_DR1,*/
 833 };
 834