git.sesse.net Git - ffmpeg/blob - libavcodec/4xm.c

   1 /*
   2  * 4XM codec
   3  * Copyright (c) 2003 Michael Niedermayer
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * 4XM codec.
  25  */
  26
  27 #include "libavutil/frame.h"
  28 #include "libavutil/intreadwrite.h"
  29 #include "avcodec.h"
  30 #include "bytestream.h"
  31 #include "dsputil.h"
  32 #include "get_bits.h"
  33 #include "internal.h"
  34
  35 #define BLOCK_TYPE_VLC_BITS 5
  36 #define ACDC_VLC_BITS 9
  37
  38 #define CFRAME_BUFFER_COUNT 100
  39
  40 static const uint8_t block_type_tab[2][4][8][2] = {
  41     {
  42         {    // { 8, 4, 2 } x { 8, 4, 2}
  43             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
  44         }, { // { 8, 4 } x 1
  45             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
  46         }, { // 1 x { 8, 4 }
  47             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
  48         }, { // 1 x 2, 2 x 1
  49             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
  50         }
  51     }, {
  52         {   // { 8, 4, 2 } x { 8, 4, 2}
  53             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  54         }, {// { 8, 4 } x 1
  55             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  56         }, {// 1 x { 8, 4 }
  57             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  58         }, {// 1 x 2, 2 x 1
  59             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
  60       }
  61     }
  62 };
  63
  64 static const uint8_t size2index[4][4] = {
  65     { -1, 3, 1, 1 },
  66     {  3, 0, 0, 0 },
  67     {  2, 0, 0, 0 },
  68     {  2, 0, 0, 0 },
  69 };
  70
  71 static const int8_t mv[256][2] = {
  72     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
  73     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
  74     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
  75     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
  76     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
  77     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
  78     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
  79     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
  80     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
  81     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
  82     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
  83     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
  84     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
  85     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
  86     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
  87     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
  88     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
  89     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
  90     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
  91     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
  92     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
  93     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
  94     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
  95     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
  96     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
  97     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
  98     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
  99     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
 100     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
 101     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
 102     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
 103     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
 104 };
 105
 106 /* This is simply the scaled down elementwise product of the standard JPEG
 107  * 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 *last_picture;
 133     GetBitContext pre_gb;          ///< ac/dc prefix
 134     GetBitContext gb;
 135     GetByteContext g;
 136     GetByteContext g2;
 137     int mv[256];
 138     VLC pre_vlc;
 139     int last_dc;
 140     DECLARE_ALIGNED(16, int16_t, 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(int16_t block[64])
 156 {
 157     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 158     int tmp10, tmp11, tmp12, tmp13;
 159     int z5, z10, z11, z12, z13;
 160     int i;
 161     int temp[64];
 162
 163     for (i = 0; i < 8; i++) {
 164         tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
 165         tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
 166
 167         tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
 168         tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
 169
 170         tmp0 = tmp10 + tmp13;
 171         tmp3 = tmp10 - tmp13;
 172         tmp1 = tmp11 + tmp12;
 173         tmp2 = tmp11 - tmp12;
 174
 175         z13 = block[8 * 5 + i] + block[8 * 3 + i];
 176         z10 = block[8 * 5 + i] - block[8 * 3 + i];
 177         z11 = block[8 * 1 + i] + block[8 * 7 + i];
 178         z12 = block[8 * 1 + i] - block[8 * 7 + i];
 179
 180         tmp7  =          z11 + z13;
 181         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 182
 183         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
 184         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
 185         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
 186
 187         tmp6 = tmp12 - tmp7;
 188         tmp5 = tmp11 - tmp6;
 189         tmp4 = tmp10 + tmp5;
 190
 191         temp[8 * 0 + i] = tmp0 + tmp7;
 192         temp[8 * 7 + i] = tmp0 - tmp7;
 193         temp[8 * 1 + i] = tmp1 + tmp6;
 194         temp[8 * 6 + i] = tmp1 - tmp6;
 195         temp[8 * 2 + i] = tmp2 + tmp5;
 196         temp[8 * 5 + i] = tmp2 - tmp5;
 197         temp[8 * 4 + i] = tmp3 + tmp4;
 198         temp[8 * 3 + i] = tmp3 - tmp4;
 199     }
 200
 201     for (i = 0; i < 8 * 8; i += 8) {
 202         tmp10 = temp[0 + i] + temp[4 + i];
 203         tmp11 = temp[0 + i] - temp[4 + i];
 204
 205         tmp13 = temp[2 + i] + temp[6 + i];
 206         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
 207
 208         tmp0 = tmp10 + tmp13;
 209         tmp3 = tmp10 - tmp13;
 210         tmp1 = tmp11 + tmp12;
 211         tmp2 = tmp11 - tmp12;
 212
 213         z13 = temp[5 + i] + temp[3 + i];
 214         z10 = temp[5 + i] - temp[3 + i];
 215         z11 = temp[1 + i] + temp[7 + i];
 216         z12 = temp[1 + i] - temp[7 + i];
 217
 218         tmp7  = z11 + z13;
 219         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 220
 221         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
 222         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
 223         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
 224
 225         tmp6 = tmp12 - tmp7;
 226         tmp5 = tmp11 - tmp6;
 227         tmp4 = tmp10 + tmp5;
 228
 229         block[0 + i] = (tmp0 + tmp7) >> 6;
 230         block[7 + i] = (tmp0 - tmp7) >> 6;
 231         block[1 + i] = (tmp1 + tmp6) >> 6;
 232         block[6 + i] = (tmp1 - tmp6) >> 6;
 233         block[2 + i] = (tmp2 + tmp5) >> 6;
 234         block[5 + i] = (tmp2 - tmp5) >> 6;
 235         block[4 + i] = (tmp3 + tmp4) >> 6;
 236         block[3 + i] = (tmp3 - tmp4) >> 6;
 237     }
 238 }
 239
 240 static av_cold void init_vlcs(FourXContext *f)
 241 {
 242     static VLC_TYPE table[2][4][32][2];
 243     int i, j;
 244
 245     for (i = 0; i < 2; i++) {
 246         for (j = 0; j < 4; j++) {
 247             block_type_vlc[i][j].table           = table[i][j];
 248             block_type_vlc[i][j].table_allocated = 32;
 249             init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
 250                      &block_type_tab[i][j][0][1], 2, 1,
 251                      &block_type_tab[i][j][0][0], 2, 1,
 252                      INIT_VLC_USE_NEW_STATIC);
 253         }
 254     }
 255 }
 256
 257 static void init_mv(FourXContext *f, int linesize)
 258 {
 259     int i;
 260
 261     for (i = 0; i < 256; i++) {
 262         if (f->version > 1)
 263             f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
 264         else
 265             f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
 266     }
 267 }
 268
 269 #if HAVE_BIGENDIAN
 270 #define LE_CENTRIC_MUL(dst, src, scale, dc)             \
 271     {                                                   \
 272         unsigned tmpval = AV_RN32(src);                 \
 273         tmpval = (tmpval << 16) | (tmpval >> 16);       \
 274         tmpval = tmpval * (scale) + (dc);               \
 275         tmpval = (tmpval << 16) | (tmpval >> 16);       \
 276         AV_WN32A(dst, tmpval);                          \
 277     }
 278 #else
 279 #define LE_CENTRIC_MUL(dst, src, scale, dc)              \
 280     {                                                    \
 281         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
 282         AV_WN32A(dst, tmpval);                           \
 283     }
 284 #endif
 285
 286 static inline void mcdc(uint16_t *dst, uint16_t *src, int log2w,
 287                         int h, int stride, int scale, unsigned dc)
 288 {
 289     int i;
 290     dc *= 0x10001;
 291
 292     switch (log2w) {
 293     case 0:
 294         for (i = 0; i < h; i++) {
 295             dst[0] = scale * src[0] + dc;
 296             if (scale)
 297                 src += stride;
 298             dst += stride;
 299         }
 300         break;
 301     case 1:
 302         for (i = 0; i < h; i++) {
 303             LE_CENTRIC_MUL(dst, src, scale, dc);
 304             if (scale)
 305                 src += stride;
 306             dst += stride;
 307         }
 308         break;
 309     case 2:
 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             if (scale)
 314                 src += stride;
 315             dst += stride;
 316         }
 317         break;
 318     case 3:
 319         for (i = 0; i < h; i++) {
 320             LE_CENTRIC_MUL(dst,     src,     scale, dc);
 321             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
 322             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
 323             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
 324             if (scale)
 325                 src += stride;
 326             dst += stride;
 327         }
 328         break;
 329     default:
 330         break;
 331     }
 332 }
 333
 334 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
 335                           int log2w, int log2h, int stride)
 336 {
 337     const int index = size2index[log2h][log2w];
 338     const int h     = 1 << log2h;
 339     int code        = get_vlc2(&f->gb,
 340                                block_type_vlc[1 - (f->version > 1)][index].table,
 341                                BLOCK_TYPE_VLC_BITS, 1);
 342     uint16_t *start = (uint16_t *)f->last_picture->data[0];
 343     uint16_t *end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
 344     int ret;
 345
 346     if (code < 0 || code > 6 || log2w < 0)
 347         return AVERROR_INVALIDDATA;
 348
 349     if (code == 0) {
 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 AVERROR_INVALIDDATA;
 354         }
 355         mcdc(dst, src, log2w, h, stride, 1, 0);
 356     } else if (code == 1) {
 357         log2h--;
 358         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
 359             return ret;
 360         if ((ret = decode_p_block(f, dst + (stride << log2h),
 361                                   src + (stride << log2h),
 362                                   log2w, log2h, stride)) < 0)
 363             return ret;
 364     } else if (code == 2) {
 365         log2w--;
 366         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
 367             return ret;
 368         if ((ret = decode_p_block(f, dst + (1 << log2w),
 369                                   src + (1 << log2w),
 370                                   log2w, log2h, stride)) < 0)
 371             return ret;
 372     } else if (code == 3 && f->version < 2) {
 373         if (start > src || src > end) {
 374             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 375             return AVERROR_INVALIDDATA;
 376         }
 377         mcdc(dst, src, log2w, h, stride, 1, 0);
 378     } else if (code == 4) {
 379         src += f->mv[bytestream2_get_byte(&f->g)];
 380         if (start > src || src > end) {
 381             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 382             return AVERROR_INVALIDDATA;
 383         }
 384         mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->g2));
 385     } else if (code == 5) {
 386         if (start > src || src > end) {
 387             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 388             return AVERROR_INVALIDDATA;
 389         }
 390         mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->g2));
 391     } else if (code == 6) {
 392         if (log2w) {
 393             dst[0]      = bytestream2_get_le16(&f->g2);
 394             dst[1]      = bytestream2_get_le16(&f->g2);
 395         } else {
 396             dst[0]      = bytestream2_get_le16(&f->g2);
 397             dst[stride] = bytestream2_get_le16(&f->g2);
 398         }
 399     }
 400     return 0;
 401 }
 402
 403 static int decode_p_frame(FourXContext *f, AVFrame *frame,
 404                           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 *dst    = (uint16_t *)frame->data[0];
 410     const int stride =             frame->linesize[0] >> 1;
 411     uint16_t *src;
 412     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
 413                  bytestream_offset, wordstream_offset;
 414     int ret;
 415
 416     if (!f->last_picture->data[0]) {
 417         if ((ret = ff_get_buffer(f->avctx, f->last_picture,
 418                                  AV_GET_BUFFER_FLAG_REF)) < 0) {
 419             av_log(f->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 420             return ret;
 421         }
 422         memset(f->last_picture->data[0], 0,
 423                f->avctx->height * FFABS(f->last_picture->linesize[0]));
 424     }
 425
 426     src = (uint16_t *)f->last_picture->data[0];
 427
 428     if (f->version > 1) {
 429         if (length < 20)
 430             return AVERROR_INVALIDDATA;
 431         extra           = 20;
 432         bitstream_size  = AV_RL32(buf + 8);
 433         wordstream_size = AV_RL32(buf + 12);
 434         bytestream_size = AV_RL32(buf + 16);
 435     } else {
 436         extra           = 0;
 437         bitstream_size  = AV_RL16(buf - 4);
 438         wordstream_size = AV_RL16(buf - 2);
 439         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
 440     }
 441
 442     if (bitstream_size + bytestream_size + wordstream_size + extra != length
 443         || bitstream_size  > (1 << 26)
 444         || bytestream_size > (1 << 26)
 445         || wordstream_size > (1 << 26)) {
 446         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n",
 447                bitstream_size, bytestream_size, wordstream_size,
 448                bitstream_size + bytestream_size + wordstream_size - length);
 449         return AVERROR_INVALIDDATA;
 450     }
 451
 452     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 453                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 454     if (!f->bitstream_buffer)
 455         return AVERROR(ENOMEM);
 456     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
 457                      bitstream_size / 4);
 458     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
 459            0, FF_INPUT_BUFFER_PADDING_SIZE);
 460     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
 461
 462     wordstream_offset = extra + bitstream_size;
 463     bytestream_offset = extra + bitstream_size + wordstream_size;
 464     bytestream2_init(&f->g2, buf + wordstream_offset,
 465                      length - wordstream_offset);
 466     bytestream2_init(&f->g, buf + bytestream_offset,
 467                      length - bytestream_offset);
 468
 469     init_mv(f, frame->linesize[0]);
 470
 471     for (y = 0; y < height; y += 8) {
 472         for (x = 0; x < width; x += 8)
 473             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
 474                 return ret;
 475         src += 8 * stride;
 476         dst += 8 * stride;
 477     }
 478
 479     return 0;
 480 }
 481
 482 /**
 483  * decode block and dequantize.
 484  * Note this is almost identical to MJPEG.
 485  */
 486 static int decode_i_block(FourXContext *f, int16_t *block)
 487 {
 488     int code, i, j, level, val;
 489
 490     /* DC coef */
 491     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 492     if (val >> 4)
 493         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
 494
 495     if (val)
 496         val = get_xbits(&f->gb, val);
 497
 498     val        = val * dequant_table[0] + f->last_dc;
 499     f->last_dc = block[0] = val;
 500     /* AC coefs */
 501     i = 1;
 502     for (;;) {
 503         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 504
 505         /* EOB */
 506         if (code == 0)
 507             break;
 508         if (code == 0xf0) {
 509             i += 16;
 510         } else {
 511             level = get_xbits(&f->gb, code & 0xf);
 512             i    += code >> 4;
 513             if (i >= 64) {
 514                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
 515                 return 0;
 516             }
 517
 518             j = ff_zigzag_direct[i];
 519             block[j] = level * dequant_table[j];
 520             i++;
 521             if (i >= 64)
 522                 break;
 523         }
 524     }
 525
 526     return 0;
 527 }
 528
 529 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
 530 {
 531     int16_t (*block)[64] = f->block;
 532     int stride           = frame->linesize[0] >> 1;
 533     int i;
 534     uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
 535
 536     for (i = 0; i < 4; i++) {
 537         block[i][0] += 0x80 * 8 * 8;
 538         idct(block[i]);
 539     }
 540
 541     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
 542         for (i = 4; i < 6; i++)
 543             idct(block[i]);
 544     }
 545
 546     /* Note transform is:
 547      * y  = ( 1b + 4g + 2r) / 14
 548      * cb = ( 3b - 2g - 1r) / 14
 549      * cr = (-1b - 4g + 5r) / 14 */
 550     for (y = 0; y < 8; y++) {
 551         for (x = 0; x < 8; x++) {
 552             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
 553                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
 554             int cb = block[4][x + 8 * y];
 555             int cr = block[5][x + 8 * y];
 556             int cg = (cb + cr) >> 1;
 557             int y;
 558
 559             cb += cb;
 560
 561             y               = temp[0];
 562             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 563             y               = temp[1];
 564             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 565             y               = temp[8];
 566             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 567             y               = temp[9];
 568             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 569             dst            += 2;
 570         }
 571         dst += 2 * stride - 2 * 8;
 572     }
 573 }
 574
 575 static int decode_i_mb(FourXContext *f)
 576 {
 577     int ret;
 578     int i;
 579
 580     f->dsp.clear_blocks(f->block[0]);
 581
 582     for (i = 0; i < 6; i++)
 583         if ((ret = decode_i_block(f, f->block[i])) < 0)
 584             return ret;
 585
 586     return 0;
 587 }
 588
 589 static const uint8_t *read_huffman_tables(FourXContext *f,
 590                                           const uint8_t * const buf,
 591                                           int len)
 592 {
 593     int frequency[512] = { 0 };
 594     uint8_t flag[512];
 595     int up[512];
 596     uint8_t len_tab[257];
 597     int bits_tab[257];
 598     int start, end;
 599     const uint8_t *ptr = buf;
 600     int j;
 601
 602     memset(up, -1, sizeof(up));
 603
 604     start = *ptr++;
 605     end   = *ptr++;
 606     for (;;) {
 607         int i;
 608
 609         len -= end - start + 1;
 610
 611         if (end < start || len < 0)
 612             return NULL;
 613
 614         for (i = start; i <= end; i++)
 615             frequency[i] = *ptr++;
 616         start = *ptr++;
 617         if (start == 0)
 618             break;
 619
 620         if (--len < 0)
 621             return NULL;
 622
 623         end = *ptr++;
 624     }
 625     frequency[256] = 1;
 626
 627     while ((ptr - buf) & 3)
 628         ptr++; // 4byte align
 629
 630     for (j = 257; j < 512; j++) {
 631         int min_freq[2] = { 256 * 256, 256 * 256 };
 632         int smallest[2] = { 0, 0 };
 633         int i;
 634         for (i = 0; i < j; i++) {
 635             if (frequency[i] == 0)
 636                 continue;
 637             if (frequency[i] < min_freq[1]) {
 638                 if (frequency[i] < min_freq[0]) {
 639                     min_freq[1] = min_freq[0];
 640                     smallest[1] = smallest[0];
 641                     min_freq[0] = frequency[i];
 642                     smallest[0] = i;
 643                 } else {
 644                     min_freq[1] = frequency[i];
 645                     smallest[1] = i;
 646                 }
 647             }
 648         }
 649         if (min_freq[1] == 256 * 256)
 650             break;
 651
 652         frequency[j]           = min_freq[0] + min_freq[1];
 653         flag[smallest[0]]      = 0;
 654         flag[smallest[1]]      = 1;
 655         up[smallest[0]]        =
 656         up[smallest[1]]        = j;
 657         frequency[smallest[0]] = frequency[smallest[1]] = 0;
 658     }
 659
 660     for (j = 0; j < 257; j++) {
 661         int node, len = 0, bits = 0;
 662
 663         for (node = j; up[node] != -1; node = up[node]) {
 664             bits += flag[node] << len;
 665             len++;
 666             if (len > 31)
 667                 // can this happen at all ?
 668                 av_log(f->avctx, AV_LOG_ERROR,
 669                        "vlc length overflow\n");
 670         }
 671
 672         bits_tab[j] = bits;
 673         len_tab[j]  = len;
 674     }
 675
 676     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
 677                  bits_tab, 4, 4, 0))
 678         return NULL;
 679
 680     return ptr;
 681 }
 682
 683 static int mix(int c0, int c1)
 684 {
 685     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
 686     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
 687     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
 688     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
 689 }
 690
 691 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
 692 {
 693     int x, y, x2, y2;
 694     const int width  = f->avctx->width;
 695     const int height = f->avctx->height;
 696     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
 697     uint16_t *dst    = (uint16_t*)frame->data[0];
 698     const int stride =            frame->linesize[0]>>1;
 699     GetByteContext g3;
 700
 701     if (length < mbs * 8) {
 702         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 703         return AVERROR_INVALIDDATA;
 704     }
 705     bytestream2_init(&g3, buf, length);
 706
 707     for (y = 0; y < height; y += 16) {
 708         for (x = 0; x < width; x += 16) {
 709             unsigned int color[4] = { 0 }, bits;
 710             // warning following is purely guessed ...
 711             color[0] = bytestream2_get_le16u(&g3);
 712             color[1] = bytestream2_get_le16u(&g3);
 713
 714             if (color[0] & 0x8000)
 715                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
 716             if (color[1] & 0x8000)
 717                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
 718
 719             color[2] = mix(color[0], color[1]);
 720             color[3] = mix(color[1], color[0]);
 721
 722             bits = bytestream2_get_le32u(&g3);
 723             for (y2 = 0; y2 < 16; y2++) {
 724                 for (x2 = 0; x2 < 16; x2++) {
 725                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
 726                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
 727                 }
 728             }
 729             dst += 16;
 730         }
 731         dst += 16 * stride - x;
 732     }
 733
 734     return 0;
 735 }
 736
 737 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
 738 {
 739     int x, y, ret;
 740     const int width  = f->avctx->width;
 741     const int height = f->avctx->height;
 742     const unsigned int bitstream_size = AV_RL32(buf);
 743     int token_count av_unused;
 744     unsigned int prestream_size;
 745     const uint8_t *prestream;
 746
 747     if (length < bitstream_size + 12) {
 748         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 749         return AVERROR_INVALIDDATA;
 750     }
 751
 752     token_count    =     AV_RL32(buf + bitstream_size + 8);
 753     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 754     prestream      =             buf + bitstream_size + 12;
 755
 756     if (prestream_size + bitstream_size + 12 != length
 757         || bitstream_size > (1 << 26)
 758         || prestream_size > (1 << 26)) {
 759         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 760                prestream_size, bitstream_size, length);
 761         return AVERROR_INVALIDDATA;
 762     }
 763
 764     prestream = read_huffman_tables(f, prestream, prestream_size);
 765     if (!prestream) {
 766         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
 767         return AVERROR_INVALIDDATA;
 768     }
 769
 770     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 771
 772     prestream_size = length + buf - prestream;
 773
 774     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 775                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 776     if (!f->bitstream_buffer)
 777         return AVERROR(ENOMEM);
 778     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 779                      prestream_size / 4);
 780     memset((uint8_t*)f->bitstream_buffer + prestream_size,
 781            0, FF_INPUT_BUFFER_PADDING_SIZE);
 782     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
 783
 784     f->last_dc = 0 * 128 * 8 * 8;
 785
 786     for (y = 0; y < height; y += 16) {
 787         for (x = 0; x < width; x += 16) {
 788             if ((ret = decode_i_mb(f)) < 0)
 789                 return ret;
 790
 791             idct_put(f, frame, x, y);
 792         }
 793     }
 794
 795     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 796         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 797
 798     return 0;
 799 }
 800
 801 static int decode_frame(AVCodecContext *avctx, void *data,
 802                         int *got_frame, AVPacket *avpkt)
 803 {
 804     const uint8_t *buf    = avpkt->data;
 805     int buf_size          = avpkt->size;
 806     FourXContext *const f = avctx->priv_data;
 807     AVFrame *picture      = data;
 808     int i, frame_4cc, frame_size, ret;
 809
 810     if (buf_size < 20)
 811         return AVERROR_INVALIDDATA;
 812
 813     if (buf_size < AV_RL32(buf + 4) + 8) {
 814         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
 815                buf_size, AV_RL32(buf + 4));
 816         return AVERROR_INVALIDDATA;
 817     }
 818
 819     frame_4cc = AV_RL32(buf);
 820
 821     if (frame_4cc == AV_RL32("cfrm")) {
 822         int free_index       = -1;
 823         int id, whole_size;
 824         const int data_size  = buf_size - 20;
 825         CFrameBuffer *cfrm;
 826
 827         if (data_size < 0)
 828             return AVERROR_INVALIDDATA;
 829
 830         id         = AV_RL32(buf + 12);
 831         whole_size = AV_RL32(buf + 16);
 832
 833         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 834             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 835                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 836                        f->cfrm[i].id);
 837
 838         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 839             if (f->cfrm[i].id == id)
 840                 break;
 841             if (f->cfrm[i].size == 0)
 842                 free_index = i;
 843         }
 844
 845         if (i >= CFRAME_BUFFER_COUNT) {
 846             i             = free_index;
 847             f->cfrm[i].id = id;
 848         }
 849         cfrm = &f->cfrm[i];
 850
 851         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 852                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 853         // explicit check needed as memcpy below might not catch a NULL
 854         if (!cfrm->data) {
 855             av_log(f->avctx, AV_LOG_ERROR, "realloc failure");
 856             return AVERROR(ENOMEM);
 857         }
 858
 859         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 860         cfrm->size += data_size;
 861
 862         if (cfrm->size >= whole_size) {
 863             buf        = cfrm->data;
 864             frame_size = cfrm->size;
 865
 866             if (id != avctx->frame_number)
 867                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 868                        id, avctx->frame_number);
 869
 870             if (f->version <= 1)
 871                 return AVERROR_INVALIDDATA;
 872
 873             cfrm->size = cfrm->id = 0;
 874             frame_4cc  = AV_RL32("pfrm");
 875         } else
 876             return buf_size;
 877     } else {
 878         buf        = buf      + 12;
 879         frame_size = buf_size - 12;
 880     }
 881
 882     // alternatively we would have to use our own buffer management
 883     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 884
 885     if ((ret = ff_get_buffer(avctx, picture, AV_GET_BUFFER_FLAG_REF)) < 0) {
 886         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 887         return ret;
 888     }
 889
 890     if (frame_4cc == AV_RL32("ifr2")) {
 891         picture->pict_type = AV_PICTURE_TYPE_I;
 892         if ((ret = decode_i2_frame(f, picture, buf - 4, frame_size + 4)) < 0)
 893             return ret;
 894     } else if (frame_4cc == AV_RL32("ifrm")) {
 895         picture->pict_type = AV_PICTURE_TYPE_I;
 896         if ((ret = decode_i_frame(f, picture, buf, frame_size)) < 0)
 897             return ret;
 898     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 899         picture->pict_type = AV_PICTURE_TYPE_P;
 900         if ((ret = decode_p_frame(f, picture, buf, frame_size)) < 0)
 901             return ret;
 902     } else if (frame_4cc == AV_RL32("snd_")) {
 903         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 904                buf_size);
 905     } else {
 906         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 907                buf_size);
 908     }
 909
 910     picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
 911
 912     av_frame_unref(f->last_picture);
 913     if ((ret = av_frame_ref(f->last_picture, picture)) < 0)
 914         return ret;
 915     *got_frame = 1;
 916
 917     emms_c();
 918
 919     return buf_size;
 920 }
 921
 922 static av_cold int decode_init(AVCodecContext *avctx)
 923 {
 924     FourXContext * const f = avctx->priv_data;
 925
 926     if (avctx->extradata_size != 4 || !avctx->extradata) {
 927         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 928         return 1;
 929     }
 930
 931     f->version = AV_RL32(avctx->extradata) >> 16;
 932     ff_dsputil_init(&f->dsp, avctx);
 933     f->avctx = avctx;
 934     init_vlcs(f);
 935
 936     if (f->version > 2)
 937         avctx->pix_fmt = AV_PIX_FMT_RGB565;
 938     else
 939         avctx->pix_fmt = AV_PIX_FMT_BGR555;
 940
 941     f->last_picture = av_frame_alloc();
 942     if (!f->last_picture)
 943         return AVERROR(ENOMEM);
 944
 945     return 0;
 946 }
 947
 948
 949 static av_cold int decode_end(AVCodecContext *avctx)
 950 {
 951     FourXContext * const f = avctx->priv_data;
 952     int i;
 953
 954     av_freep(&f->bitstream_buffer);
 955     f->bitstream_buffer_size = 0;
 956     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 957         av_freep(&f->cfrm[i].data);
 958         f->cfrm[i].allocated_size = 0;
 959     }
 960     ff_free_vlc(&f->pre_vlc);
 961     av_frame_free(&f->last_picture);
 962
 963     return 0;
 964 }
 965
 966 AVCodec ff_fourxm_decoder = {
 967     .name           = "4xm",
 968     .type           = AVMEDIA_TYPE_VIDEO,
 969     .id             = AV_CODEC_ID_4XM,
 970     .priv_data_size = sizeof(FourXContext),
 971     .init           = decode_init,
 972     .close          = decode_end,
 973     .decode         = decode_frame,
 974     .capabilities   = CODEC_CAP_DR1,
 975     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
 976 };