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