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