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     const uint8_t *bytestream;
 136     const uint8_t *bytestream_end;
 137     const uint16_t *wordstream;
 138     const uint16_t *wordstream_end;
 139     int mv[256];
 140     VLC pre_vlc;
 141     int last_dc;
 142     DECLARE_ALIGNED(16, DCTELEM, block)[6][64];
 143     void *bitstream_buffer;
 144     unsigned int bitstream_buffer_size;
 145     int version;
 146     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
 147 } FourXContext;
 148
 149
 150 #define FIX_1_082392200  70936
 151 #define FIX_1_414213562  92682
 152 #define FIX_1_847759065 121095
 153 #define FIX_2_613125930 171254
 154
 155 #define MULTIPLY(var,const)  (((var)*(const)) >> 16)
 156
 157 static void idct(DCTELEM block[64]){
 158     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 159     int tmp10, tmp11, tmp12, tmp13;
 160     int z5, z10, z11, z12, z13;
 161     int i;
 162     int temp[64];
 163
 164     for(i=0; i<8; i++){
 165         tmp10 = block[8*0 + i] + block[8*4 + i];
 166         tmp11 = block[8*0 + i] - block[8*4 + i];
 167
 168         tmp13 =          block[8*2 + i] + block[8*6 + i];
 169         tmp12 = MULTIPLY(block[8*2 + i] - block[8*6 + i], FIX_1_414213562) - tmp13;
 170
 171         tmp0 = tmp10 + tmp13;
 172         tmp3 = tmp10 - tmp13;
 173         tmp1 = tmp11 + tmp12;
 174         tmp2 = tmp11 - tmp12;
 175
 176         z13 = block[8*5 + i] + block[8*3 + i];
 177         z10 = block[8*5 + i] - block[8*3 + i];
 178         z11 = block[8*1 + i] + block[8*7 + i];
 179         z12 = block[8*1 + i] - block[8*7 + i];
 180
 181         tmp7  =          z11 + z13;
 182         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 183
 184         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
 185         tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
 186         tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
 187
 188         tmp6 = tmp12 - tmp7;
 189         tmp5 = tmp11 - tmp6;
 190         tmp4 = tmp10 + tmp5;
 191
 192         temp[8*0 + i] = tmp0 + tmp7;
 193         temp[8*7 + i] = tmp0 - tmp7;
 194         temp[8*1 + i] = tmp1 + tmp6;
 195         temp[8*6 + i] = tmp1 - tmp6;
 196         temp[8*2 + i] = tmp2 + tmp5;
 197         temp[8*5 + i] = tmp2 - tmp5;
 198         temp[8*4 + i] = tmp3 + tmp4;
 199         temp[8*3 + i] = tmp3 - tmp4;
 200     }
 201
 202     for(i=0; i<8*8; i+=8){
 203         tmp10 = temp[0 + i] + temp[4 + i];
 204         tmp11 = temp[0 + i] - temp[4 + i];
 205
 206         tmp13 = temp[2 + i] + temp[6 + i];
 207         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
 208
 209         tmp0 = tmp10 + tmp13;
 210         tmp3 = tmp10 - tmp13;
 211         tmp1 = tmp11 + tmp12;
 212         tmp2 = tmp11 - tmp12;
 213
 214         z13 = temp[5 + i] + temp[3 + i];
 215         z10 = temp[5 + i] - temp[3 + i];
 216         z11 = temp[1 + i] + temp[7 + i];
 217         z12 = temp[1 + i] - temp[7 + i];
 218
 219         tmp7 = z11 + z13;
 220         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 221
 222         z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
 223         tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
 224         tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5;
 225
 226         tmp6 = tmp12 - tmp7;
 227         tmp5 = tmp11 - tmp6;
 228         tmp4 = tmp10 + tmp5;
 229
 230         block[0 + i] = (tmp0 + tmp7)>>6;
 231         block[7 + i] = (tmp0 - tmp7)>>6;
 232         block[1 + i] = (tmp1 + tmp6)>>6;
 233         block[6 + i] = (tmp1 - tmp6)>>6;
 234         block[2 + i] = (tmp2 + tmp5)>>6;
 235         block[5 + i] = (tmp2 - tmp5)>>6;
 236         block[4 + i] = (tmp3 + tmp4)>>6;
 237         block[3 + i] = (tmp3 - tmp4)>>6;
 238     }
 239 }
 240
 241 static av_cold void init_vlcs(FourXContext *f){
 242     static VLC_TYPE table[8][32][2];
 243     int i;
 244
 245     for(i=0; i<8; i++){
 246         block_type_vlc[0][i].table= table[i];
 247         block_type_vlc[0][i].table_allocated= 32;
 248         init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7,
 249                  &block_type_tab[0][i][0][1], 2, 1,
 250                  &block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
 251     }
 252 }
 253
 254 static void init_mv(FourXContext *f){
 255     int i;
 256
 257     for(i=0; i<256; i++){
 258         if(f->version>1)
 259             f->mv[i] = mv[i][0]   + mv[i][1]  *f->current_picture.linesize[0]/2;
 260         else
 261             f->mv[i] = (i&15) - 8 + ((i>>4)-8)*f->current_picture.linesize[0]/2;
 262     }
 263 }
 264
 265 #if HAVE_BIGENDIAN
 266 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
 267     { \
 268         unsigned tmpval = AV_RN32(src);                 \
 269         tmpval = (tmpval <<  16) | (tmpval >>  16);     \
 270         tmpval = tmpval * (scale) + (dc);               \
 271         tmpval = (tmpval <<  16) | (tmpval >>  16);     \
 272         AV_WN32A(dst, tmpval);                          \
 273     }
 274 #else
 275 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
 276     { \
 277         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
 278         AV_WN32A(dst, tmpval);                           \
 279     }
 280 #endif
 281
 282 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc){
 283    int i;
 284    dc*= 0x10001;
 285
 286    switch(log2w){
 287    case 0:
 288         for(i=0; i<h; i++){
 289             dst[0] = scale*src[0] + dc;
 290             if(scale) src += stride;
 291             dst += stride;
 292         }
 293         break;
 294     case 1:
 295         for(i=0; i<h; i++){
 296             LE_CENTRIC_MUL(dst, src, scale, dc);
 297             if(scale) src += stride;
 298             dst += stride;
 299         }
 300         break;
 301     case 2:
 302         for(i=0; i<h; i++){
 303             LE_CENTRIC_MUL(dst,     src,     scale, dc);
 304             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
 305             if(scale) src += stride;
 306             dst += stride;
 307         }
 308         break;
 309     case 3:
 310         for(i=0; i<h; i++){
 311             LE_CENTRIC_MUL(dst,     src,     scale, dc);
 312             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
 313             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
 314             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
 315             if(scale) src += stride;
 316             dst += stride;
 317         }
 318         break;
 319     default: assert(0);
 320     }
 321 }
 322
 323 static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
 324     const int index= size2index[log2h][log2w];
 325     const int h= 1<<log2h;
 326     int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
 327     uint16_t *start= (uint16_t*)f->last_picture.data[0];
 328     uint16_t *end= start + stride*(f->avctx->height-h+1) - (1<<log2w);
 329
 330     assert(code>=0 && code<=6);
 331
 332     if(code == 0){
 333         if (f->bytestream_end - f->bytestream < 1){
 334             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
 335             return;
 336         }
 337         src += f->mv[ *f->bytestream++ ];
 338         if(start > src || src > end){
 339             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 340             return;
 341         }
 342         mcdc(dst, src, log2w, h, stride, 1, 0);
 343     }else if(code == 1){
 344         log2h--;
 345         decode_p_block(f, dst                  , src                  , log2w, log2h, stride);
 346         decode_p_block(f, dst + (stride<<log2h), src + (stride<<log2h), log2w, log2h, stride);
 347     }else if(code == 2){
 348         log2w--;
 349         decode_p_block(f, dst             , src             , log2w, log2h, stride);
 350         decode_p_block(f, dst + (1<<log2w), src + (1<<log2w), log2w, log2h, stride);
 351     }else if(code == 3 && f->version<2){
 352         mcdc(dst, src, log2w, h, stride, 1, 0);
 353     }else if(code == 4){
 354         if (f->bytestream_end - f->bytestream < 1){
 355             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
 356             return;
 357         }
 358         src += f->mv[ *f->bytestream++ ];
 359         if(start > src || src > end){
 360             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 361             return;
 362         }
 363         if (f->wordstream_end - f->wordstream < 1){
 364             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 365             return;
 366         }
 367         mcdc(dst, src, log2w, h, stride, 1, av_le2ne16(*f->wordstream++));
 368     }else if(code == 5){
 369         if (f->wordstream_end - f->wordstream < 1){
 370             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 371             return;
 372         }
 373         mcdc(dst, src, log2w, h, stride, 0, av_le2ne16(*f->wordstream++));
 374     }else if(code == 6){
 375         if (f->wordstream_end - f->wordstream < 2){
 376             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 377             return;
 378         }
 379         if(log2w){
 380             dst[0] = av_le2ne16(*f->wordstream++);
 381             dst[1] = av_le2ne16(*f->wordstream++);
 382         }else{
 383             dst[0     ] = av_le2ne16(*f->wordstream++);
 384             dst[stride] = av_le2ne16(*f->wordstream++);
 385         }
 386     }
 387 }
 388
 389 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length){
 390     int x, y;
 391     const int width= f->avctx->width;
 392     const int height= f->avctx->height;
 393     uint16_t *src= (uint16_t*)f->last_picture.data[0];
 394     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 395     const int stride= f->current_picture.linesize[0]>>1;
 396     unsigned int bitstream_size, bytestream_size, wordstream_size, extra;
 397
 398     if(f->version>1){
 399         extra=20;
 400         if (length < extra)
 401             return -1;
 402         bitstream_size= AV_RL32(buf+8);
 403         wordstream_size= AV_RL32(buf+12);
 404         bytestream_size= AV_RL32(buf+16);
 405     }else{
 406         extra=0;
 407         bitstream_size = AV_RL16(buf-4);
 408         wordstream_size= AV_RL16(buf-2);
 409         bytestream_size= FFMAX(length - bitstream_size - wordstream_size, 0);
 410     }
 411
 412     if (bitstream_size > length ||
 413         bytestream_size > length - bitstream_size ||
 414         wordstream_size > length - bytestream_size - bitstream_size ||
 415         extra > length - bytestream_size - bitstream_size - wordstream_size){
 416         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
 417         bitstream_size+ bytestream_size+ wordstream_size - length);
 418         return -1;
 419     }
 420
 421     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 422     if (!f->bitstream_buffer)
 423         return AVERROR(ENOMEM);
 424     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra), bitstream_size/4);
 425     memset((uint8_t*)f->bitstream_buffer + bitstream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 426     init_get_bits(&f->gb, f->bitstream_buffer, 8*bitstream_size);
 427
 428     f->wordstream= (const uint16_t*)(buf + extra + bitstream_size);
 429     f->wordstream_end= f->wordstream + wordstream_size/2;
 430     f->bytestream= buf + extra + bitstream_size + wordstream_size;
 431     f->bytestream_end = f->bytestream + bytestream_size;
 432
 433     init_mv(f);
 434
 435     for(y=0; y<height; y+=8){
 436         for(x=0; x<width; x+=8){
 437             decode_p_block(f, dst + x, src + x, 3, 3, stride);
 438         }
 439         src += 8*stride;
 440         dst += 8*stride;
 441     }
 442
 443     if(   bitstream_size != (get_bits_count(&f->gb)+31)/32*4
 444        || (((const char*)f->wordstream - (const char*)buf + 2)&~2) != extra + bitstream_size + wordstream_size
 445        || (((const char*)f->bytestream - (const char*)buf + 3)&~3) != extra + bitstream_size + wordstream_size + bytestream_size)
 446         av_log(f->avctx, AV_LOG_ERROR, " %d %td %td bytes left\n",
 447             bitstream_size - (get_bits_count(&f->gb)+31)/32*4,
 448             -(((const char*)f->bytestream - (const char*)buf + 3)&~3) + (extra + bitstream_size + wordstream_size + bytestream_size),
 449             -(((const char*)f->wordstream - (const char*)buf + 2)&~2) + (extra + bitstream_size + wordstream_size)
 450         );
 451
 452     return 0;
 453 }
 454
 455 /**
 456  * decode block and dequantize.
 457  * Note this is almost identical to MJPEG.
 458  */
 459 static int decode_i_block(FourXContext *f, DCTELEM *block){
 460     int code, i, j, level, val;
 461
 462     if(get_bits_left(&f->gb) < 2){
 463         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
 464         return -1;
 465     }
 466
 467     /* DC coef */
 468     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 469     if (val>>4){
 470         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
 471     }
 472
 473     if(val)
 474         val = get_xbits(&f->gb, val);
 475
 476     val = val * dequant_table[0] + f->last_dc;
 477     f->last_dc =
 478     block[0] = val;
 479     /* AC coefs */
 480     i = 1;
 481     for(;;) {
 482         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 483
 484         /* EOB */
 485         if (code == 0)
 486             break;
 487         if (code == 0xf0) {
 488             i += 16;
 489         } else {
 490             level = get_xbits(&f->gb, code & 0xf);
 491             i += code >> 4;
 492             if (i >= 64) {
 493                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
 494                 return 0;
 495             }
 496
 497             j= ff_zigzag_direct[i];
 498             block[j] = level * dequant_table[j];
 499             i++;
 500             if (i >= 64)
 501                 break;
 502         }
 503     }
 504
 505     return 0;
 506 }
 507
 508 static inline void idct_put(FourXContext *f, int x, int y){
 509     DCTELEM (*block)[64]= f->block;
 510     int stride= f->current_picture.linesize[0]>>1;
 511     int i;
 512     uint16_t *dst = ((uint16_t*)f->current_picture.data[0]) + y * stride + x;
 513
 514     for(i=0; i<4; i++){
 515         block[i][0] += 0x80*8*8;
 516         idct(block[i]);
 517     }
 518
 519     if(!(f->avctx->flags&CODEC_FLAG_GRAY)){
 520         for(i=4; i<6; i++) idct(block[i]);
 521     }
 522
 523 /* Note transform is:
 524 y= ( 1b + 4g + 2r)/14
 525 cb=( 3b - 2g - 1r)/14
 526 cr=(-1b - 4g + 5r)/14
 527 */
 528     for(y=0; y<8; y++){
 529         for(x=0; x<8; x++){
 530             DCTELEM *temp= block[(x>>2) + 2*(y>>2)] + 2*(x&3) + 2*8*(y&3); //FIXME optimize
 531             int cb= block[4][x + 8*y];
 532             int cr= block[5][x + 8*y];
 533             int cg= (cb + cr)>>1;
 534             int y;
 535
 536             cb+=cb;
 537
 538             y = temp[0];
 539             dst[0       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 540             y = temp[1];
 541             dst[1       ]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 542             y = temp[8];
 543             dst[  stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 544             y = temp[9];
 545             dst[1+stride]= ((y+cb)>>3) + (((y-cg)&0xFC)<<3) + (((y+cr)&0xF8)<<8);
 546             dst += 2;
 547         }
 548         dst += 2*stride - 2*8;
 549     }
 550 }
 551
 552 static int decode_i_mb(FourXContext *f){
 553     int i;
 554
 555     f->dsp.clear_blocks(f->block[0]);
 556
 557     for(i=0; i<6; i++){
 558         if(decode_i_block(f, f->block[i]) < 0)
 559             return -1;
 560     }
 561
 562     return 0;
 563 }
 564
 565 static const uint8_t *read_huffman_tables(FourXContext *f, const uint8_t * const buf, int buf_size){
 566     int frequency[512];
 567     uint8_t flag[512];
 568     int up[512];
 569     uint8_t len_tab[257];
 570     int bits_tab[257];
 571     int start, end;
 572     const uint8_t *ptr= buf;
 573     const uint8_t *ptr_end = buf + buf_size;
 574     int j;
 575
 576     memset(frequency, 0, sizeof(frequency));
 577     memset(up, -1, sizeof(up));
 578
 579     start= *ptr++;
 580     end= *ptr++;
 581     for(;;){
 582         int i;
 583
 584         if (start <= end && ptr_end - ptr < end - start + 1 + 1)
 585             return NULL;
 586         for(i=start; i<=end; i++){
 587             frequency[i]= *ptr++;
 588         }
 589         start= *ptr++;
 590         if(start==0) break;
 591
 592         end= *ptr++;
 593     }
 594     frequency[256]=1;
 595
 596     while((ptr - buf)&3) ptr++; // 4byte align
 597
 598     for(j=257; j<512; j++){
 599         int min_freq[2]= {256*256, 256*256};
 600         int smallest[2]= {0, 0};
 601         int i;
 602         for(i=0; i<j; i++){
 603             if(frequency[i] == 0) continue;
 604             if(frequency[i] < min_freq[1]){
 605                 if(frequency[i] < min_freq[0]){
 606                     min_freq[1]= min_freq[0]; smallest[1]= smallest[0];
 607                     min_freq[0]= frequency[i];smallest[0]= i;
 608                 }else{
 609                     min_freq[1]= frequency[i];smallest[1]= i;
 610                 }
 611             }
 612         }
 613         if(min_freq[1] == 256*256) break;
 614
 615         frequency[j]= min_freq[0] + min_freq[1];
 616         flag[ smallest[0] ]= 0;
 617         flag[ smallest[1] ]= 1;
 618         up[ smallest[0] ]=
 619         up[ smallest[1] ]= j;
 620         frequency[ smallest[0] ]= frequency[ smallest[1] ]= 0;
 621     }
 622
 623     for(j=0; j<257; j++){
 624         int node;
 625         int len=0;
 626         int bits=0;
 627
 628         for(node= j; up[node] != -1; node= up[node]){
 629             bits += flag[node]<<len;
 630             len++;
 631             if(len > 31) av_log(f->avctx, AV_LOG_ERROR, "vlc length overflow\n"); //can this happen at all ?
 632         }
 633
 634         bits_tab[j]= bits;
 635         len_tab[j]= len;
 636     }
 637
 638     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257,
 639                  len_tab , 1, 1,
 640                  bits_tab, 4, 4, 0))
 641         return NULL;
 642
 643     return ptr;
 644 }
 645
 646 static int mix(int c0, int c1){
 647     int blue = 2*(c0&0x001F) + (c1&0x001F);
 648     int green= (2*(c0&0x03E0) + (c1&0x03E0))>>5;
 649     int red  = 2*(c0>>10) + (c1>>10);
 650     return red/3*1024 + green/3*32 + blue/3;
 651 }
 652
 653 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length){
 654     int x, y, x2, y2;
 655     const int width= f->avctx->width;
 656     const int height= f->avctx->height;
 657     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 658     const int stride= f->current_picture.linesize[0]>>1;
 659     const uint8_t *buf_end = buf + length;
 660
 661     for(y=0; y<height; y+=16){
 662         for(x=0; x<width; x+=16){
 663             unsigned int color[4], bits;
 664             if (buf_end - buf < 8)
 665                 return -1;
 666             memset(color, 0, sizeof(color));
 667 //warning following is purely guessed ...
 668             color[0]= bytestream_get_le16(&buf);
 669             color[1]= bytestream_get_le16(&buf);
 670
 671             if(color[0]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
 672             if(color[1]&0x8000) av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
 673
 674             color[2]= mix(color[0], color[1]);
 675             color[3]= mix(color[1], color[0]);
 676
 677             bits= bytestream_get_le32(&buf);
 678             for(y2=0; y2<16; y2++){
 679                 for(x2=0; x2<16; x2++){
 680                     int index= 2*(x2>>2) + 8*(y2>>2);
 681                     dst[y2*stride+x2]= color[(bits>>index)&3];
 682                 }
 683             }
 684             dst+=16;
 685         }
 686         dst += 16*stride - width;
 687     }
 688
 689     return 0;
 690 }
 691
 692 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length){
 693     int x, y;
 694     const int width= f->avctx->width;
 695     const int height= f->avctx->height;
 696     uint16_t *dst= (uint16_t*)f->current_picture.data[0];
 697     const int stride= f->current_picture.linesize[0]>>1;
 698     const unsigned int bitstream_size= AV_RL32(buf);
 699     unsigned int prestream_size;
 700     const uint8_t *prestream;
 701
 702     if (bitstream_size > (1<<26) || length < bitstream_size + 12)
 703         return -1;
 704     prestream_size = 4*AV_RL32(buf + bitstream_size + 4);
 705     prestream = buf + bitstream_size + 12;
 706
 707     if (prestream_size > (1<<26) ||
 708         prestream_size != length - (bitstream_size + 12)){
 709         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n", prestream_size, bitstream_size, length);
 710         return -1;
 711     }
 712
 713     prestream= read_huffman_tables(f, prestream, buf + length - prestream);
 714     if (!prestream)
 715         return -1;
 716
 717     init_get_bits(&f->gb, buf + 4, 8*bitstream_size);
 718
 719     prestream_size= length + buf - prestream;
 720
 721     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size, prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 722     if (!f->bitstream_buffer)
 723         return AVERROR(ENOMEM);
 724     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream, prestream_size/4);
 725     memset((uint8_t*)f->bitstream_buffer + prestream_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 726     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8*prestream_size);
 727
 728     f->last_dc= 0*128*8*8;
 729
 730     for(y=0; y<height; y+=16){
 731         for(x=0; x<width; x+=16){
 732             if(decode_i_mb(f) < 0)
 733                 return -1;
 734
 735             idct_put(f, x, y);
 736         }
 737         dst += 16*stride;
 738     }
 739
 740     if(get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 741         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 742
 743     return 0;
 744 }
 745
 746 static int decode_frame(AVCodecContext *avctx,
 747                         void *data, int *data_size,
 748                         AVPacket *avpkt)
 749 {
 750     const uint8_t *buf = avpkt->data;
 751     int buf_size = avpkt->size;
 752     FourXContext * const f = avctx->priv_data;
 753     AVFrame *picture = data;
 754     AVFrame *p, temp;
 755     int i, frame_4cc, frame_size;
 756
 757     if (buf_size < 12)
 758         return AVERROR_INVALIDDATA;
 759     frame_4cc= AV_RL32(buf);
 760     if(buf_size != AV_RL32(buf+4)+8 || buf_size < 20){
 761         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n", buf_size, AV_RL32(buf+4));
 762     }
 763
 764     if(frame_4cc == AV_RL32("cfrm")){
 765         int free_index=-1;
 766         const int data_size= buf_size - 20;
 767         const int id= AV_RL32(buf+12);
 768         const int whole_size= AV_RL32(buf+16);
 769         CFrameBuffer *cfrm;
 770
 771         if (data_size < 0 || whole_size < 0){
 772             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
 773             return AVERROR_INVALIDDATA;
 774         }
 775
 776         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 777             if(f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 778                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n", f->cfrm[i].id);
 779         }
 780
 781         for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 782             if(f->cfrm[i].id   == id) break;
 783             if(f->cfrm[i].size == 0 ) free_index= i;
 784         }
 785
 786         if(i>=CFRAME_BUFFER_COUNT){
 787             i= free_index;
 788             f->cfrm[i].id= id;
 789         }
 790         cfrm= &f->cfrm[i];
 791
 792         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
 793             return AVERROR_INVALIDDATA;
 794         cfrm->data= av_fast_realloc(cfrm->data, &cfrm->allocated_size, cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 795         if(!cfrm->data){ //explicit check needed as memcpy below might not catch a NULL
 796             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
 797             return -1;
 798         }
 799
 800         memcpy(cfrm->data + cfrm->size, buf+20, data_size);
 801         cfrm->size += data_size;
 802
 803         if(cfrm->size >= whole_size){
 804             buf= cfrm->data;
 805             frame_size= cfrm->size;
 806
 807             if(id != avctx->frame_number){
 808                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n", id, avctx->frame_number);
 809             }
 810
 811             cfrm->size= cfrm->id= 0;
 812             frame_4cc= AV_RL32("pfrm");
 813         }else
 814             return buf_size;
 815     }else{
 816         buf= buf + 12;
 817         frame_size= buf_size - 12;
 818     }
 819
 820     temp= f->current_picture;
 821     f->current_picture= f->last_picture;
 822     f->last_picture= temp;
 823
 824     p= &f->current_picture;
 825     avctx->coded_frame= p;
 826
 827     avctx->flags |= CODEC_FLAG_EMU_EDGE; // alternatively we would have to use our own buffer management
 828
 829     p->reference= 3;
 830     if (avctx->reget_buffer(avctx, p) < 0) {
 831         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 832         return -1;
 833     }
 834
 835     if(frame_4cc == AV_RL32("ifr2")){
 836         p->pict_type= AV_PICTURE_TYPE_I;
 837         if(decode_i2_frame(f, buf-4, frame_size+4) < 0){
 838             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
 839             return -1;
 840         }
 841     }else if(frame_4cc == AV_RL32("ifrm")){
 842         p->pict_type= AV_PICTURE_TYPE_I;
 843         if(decode_i_frame(f, buf, frame_size) < 0){
 844             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
 845             return -1;
 846         }
 847     }else if(frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")){
 848         if(!f->last_picture.data[0]){
 849             f->last_picture.reference= 3;
 850             if(avctx->get_buffer(avctx, &f->last_picture) < 0){
 851                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 852                 return -1;
 853             }
 854         }
 855
 856         p->pict_type= AV_PICTURE_TYPE_P;
 857         if(decode_p_frame(f, buf, frame_size) < 0){
 858             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
 859             return -1;
 860         }
 861     }else if(frame_4cc == AV_RL32("snd_")){
 862         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n", buf_size);
 863     }else{
 864         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n", buf_size);
 865     }
 866
 867     p->key_frame= p->pict_type == AV_PICTURE_TYPE_I;
 868
 869     *picture= *p;
 870     *data_size = sizeof(AVPicture);
 871
 872     emms_c();
 873
 874     return buf_size;
 875 }
 876
 877
 878 static av_cold void common_init(AVCodecContext *avctx){
 879     FourXContext * const f = avctx->priv_data;
 880
 881     dsputil_init(&f->dsp, avctx);
 882
 883     f->avctx= avctx;
 884 }
 885
 886 static av_cold int decode_init(AVCodecContext *avctx){
 887     FourXContext * const f = avctx->priv_data;
 888
 889     if(avctx->extradata_size != 4 || !avctx->extradata) {
 890         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 891         return 1;
 892     }
 893     if((avctx->width % 16) || (avctx->height % 16)) {
 894         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
 895         return AVERROR_INVALIDDATA;
 896     }
 897
 898     avcodec_get_frame_defaults(&f->current_picture);
 899     avcodec_get_frame_defaults(&f->last_picture);
 900     f->version= AV_RL32(avctx->extradata)>>16;
 901     common_init(avctx);
 902     init_vlcs(f);
 903
 904     if(f->version>2) avctx->pix_fmt= PIX_FMT_RGB565;
 905     else             avctx->pix_fmt= PIX_FMT_BGR555;
 906
 907     return 0;
 908 }
 909
 910
 911 static av_cold int decode_end(AVCodecContext *avctx){
 912     FourXContext * const f = avctx->priv_data;
 913     int i;
 914
 915     av_freep(&f->bitstream_buffer);
 916     f->bitstream_buffer_size=0;
 917     for(i=0; i<CFRAME_BUFFER_COUNT; i++){
 918         av_freep(&f->cfrm[i].data);
 919         f->cfrm[i].allocated_size= 0;
 920     }
 921     free_vlc(&f->pre_vlc);
 922     if(f->current_picture.data[0])
 923         avctx->release_buffer(avctx, &f->current_picture);
 924     if(f->last_picture.data[0])
 925         avctx->release_buffer(avctx, &f->last_picture);
 926
 927     return 0;
 928 }
 929
 930 AVCodec ff_fourxm_decoder = {
 931     .name           = "4xm",
 932     .type           = AVMEDIA_TYPE_VIDEO,
 933     .id             = CODEC_ID_4XM,
 934     .priv_data_size = sizeof(FourXContext),
 935     .init           = decode_init,
 936     .close          = decode_end,
 937     .decode         = decode_frame,
 938     .capabilities   = CODEC_CAP_DR1,
 939     .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
 940 };
 941