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