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