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