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_assert0(0);
 333     }
 334 }
 335
 336 static int 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     int ret;
 347
 348     av_assert0(code >= 0 && code <= 6 && log2w >= 0);
 349
 350     if (code == 0) {
 351         if (bytestream2_get_bytes_left(&f->g) < 1) {
 352             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
 353             return AVERROR_INVALIDDATA;
 354         }
 355         src += f->mv[bytestream2_get_byteu(&f->g)];
 356         if (start > src || src > end) {
 357             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 358             return AVERROR_INVALIDDATA;
 359         }
 360         mcdc(dst, src, log2w, h, stride, 1, 0);
 361     } else if (code == 1) {
 362         log2h--;
 363         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
 364             return ret;
 365         if ((ret = decode_p_block(f, dst + (stride << log2h),
 366                                   src + (stride << log2h),
 367                                   log2w, log2h, stride)) < 0)
 368             return ret;
 369     } else if (code == 2) {
 370         log2w--;
 371         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
 372             return ret;
 373         if ((ret = decode_p_block(f, dst + (1 << log2w),
 374                                   src + (1 << log2w),
 375                                   log2w, log2h, stride)) < 0)
 376             return ret;
 377     } else if (code == 3 && f->version < 2) {
 378         mcdc(dst, src, log2w, h, stride, 1, 0);
 379     } else if (code == 4) {
 380         if (bytestream2_get_bytes_left(&f->g) < 1) {
 381             av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
 382             return AVERROR_INVALIDDATA;
 383         }
 384         src += f->mv[bytestream2_get_byteu(&f->g)];
 385         if (start > src || src > end) {
 386             av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 387             return AVERROR_INVALIDDATA;
 388         }
 389         if (bytestream2_get_bytes_left(&f->g2) < 2){
 390             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 391             return AVERROR_INVALIDDATA;
 392         }
 393         mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16u(&f->g2));
 394     } else if (code == 5) {
 395         if (bytestream2_get_bytes_left(&f->g2) < 2) {
 396             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 397             return AVERROR_INVALIDDATA;
 398         }
 399         mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16u(&f->g2));
 400     } else if (code == 6) {
 401         if (bytestream2_get_bytes_left(&f->g2) < 4) {
 402             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 403             return AVERROR_INVALIDDATA;
 404         }
 405         if (log2w) {
 406             dst[0]      = bytestream2_get_le16u(&f->g2);
 407             dst[1]      = bytestream2_get_le16u(&f->g2);
 408         } else {
 409             dst[0]      = bytestream2_get_le16u(&f->g2);
 410             dst[stride] = bytestream2_get_le16u(&f->g2);
 411         }
 412     }
 413     return 0;
 414 }
 415
 416 static int decode_p_frame(FourXContext *f, AVFrame *frame,
 417                           const uint8_t *buf, int length)
 418 {
 419     int x, y;
 420     const int width  = f->avctx->width;
 421     const int height = f->avctx->height;
 422     uint16_t *dst    = (uint16_t *)frame->data[0];
 423     const int stride =             frame->linesize[0] >> 1;
 424     uint16_t *src;
 425     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
 426                  bytestream_offset, wordstream_offset;
 427     int ret;
 428
 429     if (!f->last_picture->data[0]) {
 430         if ((ret = ff_get_buffer(f->avctx, f->last_picture,
 431                                  AV_GET_BUFFER_FLAG_REF)) < 0) {
 432             return ret;
 433         }
 434         for (y=0; y<f->avctx->height; y++)
 435             memset(f->last_picture->data[0] + y*f->last_picture->linesize[0], 0, 2*f->avctx->width);
 436     }
 437
 438     src = (uint16_t *)f->last_picture->data[0];
 439
 440     if (f->version > 1) {
 441         extra           = 20;
 442         if (length < extra)
 443             return AVERROR_INVALIDDATA;
 444         bitstream_size  = AV_RL32(buf + 8);
 445         wordstream_size = AV_RL32(buf + 12);
 446         bytestream_size = AV_RL32(buf + 16);
 447     } else {
 448         extra           = 0;
 449         bitstream_size  = AV_RL16(buf - 4);
 450         wordstream_size = AV_RL16(buf - 2);
 451         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
 452     }
 453
 454     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
 455         bytestream_size > length - bitstream_size ||
 456         wordstream_size > length - bytestream_size - bitstream_size ||
 457         extra > length - bytestream_size - bitstream_size - wordstream_size) {
 458         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
 459         bitstream_size+ bytestream_size+ wordstream_size - length);
 460         return AVERROR_INVALIDDATA;
 461     }
 462
 463     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 464                    bitstream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 465     if (!f->bitstream_buffer)
 466         return AVERROR(ENOMEM);
 467     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
 468                      bitstream_size / 4);
 469     memset((uint8_t*)f->bitstream_buffer + bitstream_size,
 470            0, FF_INPUT_BUFFER_PADDING_SIZE);
 471     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
 472
 473     wordstream_offset = extra + bitstream_size;
 474     bytestream_offset = extra + bitstream_size + wordstream_size;
 475     bytestream2_init(&f->g2, buf + wordstream_offset,
 476                      length - wordstream_offset);
 477     bytestream2_init(&f->g, buf + bytestream_offset,
 478                      length - bytestream_offset);
 479
 480     init_mv(f, frame->linesize[0]);
 481
 482     for (y = 0; y < height; y += 8) {
 483         for (x = 0; x < width; x += 8)
 484             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
 485                 return ret;
 486         src += 8 * stride;
 487         dst += 8 * stride;
 488     }
 489
 490     return 0;
 491 }
 492
 493 /**
 494  * decode block and dequantize.
 495  * Note this is almost identical to MJPEG.
 496  */
 497 static int decode_i_block(FourXContext *f, int16_t *block)
 498 {
 499     int code, i, j, level, val;
 500
 501     if (get_bits_left(&f->gb) < 2){
 502         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
 503         return -1;
 504     }
 505
 506     /* DC coef */
 507     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 508     if (val >> 4)
 509         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
 510
 511     if (val)
 512         val = get_xbits(&f->gb, val);
 513
 514     val        = val * dequant_table[0] + f->last_dc;
 515     f->last_dc = block[0] = val;
 516     /* AC coefs */
 517     i = 1;
 518     for (;;) {
 519         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 520
 521         /* EOB */
 522         if (code == 0)
 523             break;
 524         if (code == 0xf0) {
 525             i += 16;
 526         } else {
 527             level = get_xbits(&f->gb, code & 0xf);
 528             i    += code >> 4;
 529             if (i >= 64) {
 530                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
 531                 return 0;
 532             }
 533
 534             j = ff_zigzag_direct[i];
 535             block[j] = level * dequant_table[j];
 536             i++;
 537             if (i >= 64)
 538                 break;
 539         }
 540     }
 541
 542     return 0;
 543 }
 544
 545 static inline void idct_put(FourXContext *f, AVFrame *frame, int x, int y)
 546 {
 547     int16_t (*block)[64] = f->block;
 548     int stride           = frame->linesize[0] >> 1;
 549     int i;
 550     uint16_t *dst = ((uint16_t*)frame->data[0]) + y * stride + x;
 551
 552     for (i = 0; i < 4; i++) {
 553         block[i][0] += 0x80 * 8 * 8;
 554         idct(block[i]);
 555     }
 556
 557     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
 558         for (i = 4; i < 6; i++)
 559             idct(block[i]);
 560     }
 561
 562     /* Note transform is:
 563      * y  = ( 1b + 4g + 2r) / 14
 564      * cb = ( 3b - 2g - 1r) / 14
 565      * cr = (-1b - 4g + 5r) / 14 */
 566     for (y = 0; y < 8; y++) {
 567         for (x = 0; x < 8; x++) {
 568             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
 569                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
 570             int cb = block[4][x + 8 * y];
 571             int cr = block[5][x + 8 * y];
 572             int cg = (cb + cr) >> 1;
 573             int y;
 574
 575             cb += cb;
 576
 577             y               = temp[0];
 578             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 579             y               = temp[1];
 580             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 581             y               = temp[8];
 582             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 583             y               = temp[9];
 584             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 585             dst            += 2;
 586         }
 587         dst += 2 * stride - 2 * 8;
 588     }
 589 }
 590
 591 static int decode_i_mb(FourXContext *f)
 592 {
 593     int ret;
 594     int i;
 595
 596     f->dsp.clear_blocks(f->block[0]);
 597
 598     for (i = 0; i < 6; i++)
 599         if ((ret = decode_i_block(f, f->block[i])) < 0)
 600             return ret;
 601
 602     return 0;
 603 }
 604
 605 static const uint8_t *read_huffman_tables(FourXContext *f,
 606                                           const uint8_t * const buf,
 607                                           int buf_size)
 608 {
 609     int frequency[512] = { 0 };
 610     uint8_t flag[512];
 611     int up[512];
 612     uint8_t len_tab[257];
 613     int bits_tab[257];
 614     int start, end;
 615     const uint8_t *ptr = buf;
 616     const uint8_t *ptr_end = buf + buf_size;
 617     int j;
 618
 619     memset(up, -1, sizeof(up));
 620
 621     start = *ptr++;
 622     end   = *ptr++;
 623     for (;;) {
 624         int i;
 625
 626         if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
 627             av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
 628             return NULL;
 629         }
 630
 631         for (i = start; i <= end; i++)
 632             frequency[i] = *ptr++;
 633         start = *ptr++;
 634         if (start == 0)
 635             break;
 636
 637         end = *ptr++;
 638     }
 639     frequency[256] = 1;
 640
 641     while ((ptr - buf) & 3)
 642         ptr++; // 4byte align
 643
 644     if (ptr > ptr_end) {
 645         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
 646         return NULL;
 647     }
 648
 649     for (j = 257; j < 512; j++) {
 650         int min_freq[2] = { 256 * 256, 256 * 256 };
 651         int smallest[2] = { 0, 0 };
 652         int i;
 653         for (i = 0; i < j; i++) {
 654             if (frequency[i] == 0)
 655                 continue;
 656             if (frequency[i] < min_freq[1]) {
 657                 if (frequency[i] < min_freq[0]) {
 658                     min_freq[1] = min_freq[0];
 659                     smallest[1] = smallest[0];
 660                     min_freq[0] = frequency[i];
 661                     smallest[0] = i;
 662                 } else {
 663                     min_freq[1] = frequency[i];
 664                     smallest[1] = i;
 665                 }
 666             }
 667         }
 668         if (min_freq[1] == 256 * 256)
 669             break;
 670
 671         frequency[j]           = min_freq[0] + min_freq[1];
 672         flag[smallest[0]]      = 0;
 673         flag[smallest[1]]      = 1;
 674         up[smallest[0]]        =
 675         up[smallest[1]]        = j;
 676         frequency[smallest[0]] = frequency[smallest[1]] = 0;
 677     }
 678
 679     for (j = 0; j < 257; j++) {
 680         int node, len = 0, bits = 0;
 681
 682         for (node = j; up[node] != -1; node = up[node]) {
 683             bits += flag[node] << len;
 684             len++;
 685             if (len > 31)
 686                 // can this happen at all ?
 687                 av_log(f->avctx, AV_LOG_ERROR,
 688                        "vlc length overflow\n");
 689         }
 690
 691         bits_tab[j] = bits;
 692         len_tab[j]  = len;
 693     }
 694
 695     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
 696                  bits_tab, 4, 4, 0))
 697         return NULL;
 698
 699     return ptr;
 700 }
 701
 702 static int mix(int c0, int c1)
 703 {
 704     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
 705     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
 706     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
 707     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
 708 }
 709
 710 static int decode_i2_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
 711 {
 712     int x, y, x2, y2;
 713     const int width  = f->avctx->width;
 714     const int height = f->avctx->height;
 715     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
 716     uint16_t *dst    = (uint16_t*)frame->data[0];
 717     const int stride =            frame->linesize[0]>>1;
 718     const uint8_t *buf_end = buf + length;
 719     GetByteContext g3;
 720
 721     if (length < mbs * 8) {
 722         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 723         return AVERROR_INVALIDDATA;
 724     }
 725     bytestream2_init(&g3, buf, length);
 726
 727     for (y = 0; y < height; y += 16) {
 728         for (x = 0; x < width; x += 16) {
 729             unsigned int color[4] = { 0 }, bits;
 730             if (buf_end - buf < 8)
 731                 return -1;
 732             // warning following is purely guessed ...
 733             color[0] = bytestream2_get_le16u(&g3);
 734             color[1] = bytestream2_get_le16u(&g3);
 735
 736             if (color[0] & 0x8000)
 737                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
 738             if (color[1] & 0x8000)
 739                 av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
 740
 741             color[2] = mix(color[0], color[1]);
 742             color[3] = mix(color[1], color[0]);
 743
 744             bits = bytestream2_get_le32u(&g3);
 745             for (y2 = 0; y2 < 16; y2++) {
 746                 for (x2 = 0; x2 < 16; x2++) {
 747                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
 748                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
 749                 }
 750             }
 751             dst += 16;
 752         }
 753         dst += 16 * stride - x;
 754     }
 755
 756     return 0;
 757 }
 758
 759 static int decode_i_frame(FourXContext *f, AVFrame *frame, const uint8_t *buf, int length)
 760 {
 761     int x, y, ret;
 762     const int width  = f->avctx->width;
 763     const int height = f->avctx->height;
 764     const unsigned int bitstream_size = AV_RL32(buf);
 765     unsigned int prestream_size;
 766     const uint8_t *prestream;
 767
 768     if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
 769         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 770         return AVERROR_INVALIDDATA;
 771     }
 772
 773     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 774     prestream      =             buf + bitstream_size + 12;
 775
 776     if (prestream_size + bitstream_size + 12 != length
 777         || bitstream_size > (1 << 26)
 778         || prestream_size > (1 << 26)) {
 779         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 780                prestream_size, bitstream_size, length);
 781         return AVERROR_INVALIDDATA;
 782     }
 783
 784     prestream = read_huffman_tables(f, prestream, prestream_size);
 785     if (!prestream) {
 786         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
 787         return AVERROR_INVALIDDATA;
 788     }
 789
 790     av_assert0(prestream <= buf + length);
 791
 792     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 793
 794     prestream_size = length + buf - prestream;
 795
 796     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 797                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 798     if (!f->bitstream_buffer)
 799         return AVERROR(ENOMEM);
 800     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 801                      prestream_size / 4);
 802     memset((uint8_t*)f->bitstream_buffer + prestream_size,
 803            0, FF_INPUT_BUFFER_PADDING_SIZE);
 804     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
 805
 806     f->last_dc = 0 * 128 * 8 * 8;
 807
 808     for (y = 0; y < height; y += 16) {
 809         for (x = 0; x < width; x += 16) {
 810             if ((ret = decode_i_mb(f)) < 0)
 811                 return ret;
 812
 813             idct_put(f, frame, x, y);
 814         }
 815     }
 816
 817     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 818         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 819
 820     return 0;
 821 }
 822
 823 static int decode_frame(AVCodecContext *avctx, void *data,
 824                         int *got_frame, AVPacket *avpkt)
 825 {
 826     const uint8_t *buf    = avpkt->data;
 827     int buf_size          = avpkt->size;
 828     FourXContext *const f = avctx->priv_data;
 829     AVFrame *picture      = data;
 830     int i, frame_4cc, frame_size, ret;
 831
 832     if (buf_size < 20)
 833         return AVERROR_INVALIDDATA;
 834
 835     if (buf_size < AV_RL32(buf + 4) + 8) {
 836         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
 837                buf_size, AV_RL32(buf + 4));
 838         return AVERROR_INVALIDDATA;
 839     }
 840
 841     frame_4cc = AV_RL32(buf);
 842
 843     if (frame_4cc == AV_RL32("cfrm")) {
 844         int free_index       = -1;
 845         int id, whole_size;
 846         const int data_size  = buf_size - 20;
 847         CFrameBuffer *cfrm;
 848
 849         if (f->version <= 1) {
 850             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
 851             return AVERROR_INVALIDDATA;
 852         }
 853
 854         id         = AV_RL32(buf + 12);
 855         whole_size = AV_RL32(buf + 16);
 856
 857         if (data_size < 0 || whole_size < 0) {
 858             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
 859             return AVERROR_INVALIDDATA;
 860         }
 861
 862         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 863             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 864                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 865                        f->cfrm[i].id);
 866
 867         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 868             if (f->cfrm[i].id == id)
 869                 break;
 870             if (f->cfrm[i].size == 0)
 871                 free_index = i;
 872         }
 873
 874         if (i >= CFRAME_BUFFER_COUNT) {
 875             i             = free_index;
 876             f->cfrm[i].id = id;
 877         }
 878         cfrm = &f->cfrm[i];
 879
 880         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
 881             return AVERROR_INVALIDDATA;
 882
 883         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 884                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 885         // explicit check needed as memcpy below might not catch a NULL
 886         if (!cfrm->data) {
 887             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
 888             return AVERROR(ENOMEM);
 889         }
 890
 891         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 892         cfrm->size += data_size;
 893
 894         if (cfrm->size >= whole_size) {
 895             buf        = cfrm->data;
 896             frame_size = cfrm->size;
 897
 898             if (id != avctx->frame_number)
 899                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 900                        id, avctx->frame_number);
 901
 902             if (f->version <= 1)
 903                 return AVERROR_INVALIDDATA;
 904
 905             cfrm->size = cfrm->id = 0;
 906             frame_4cc  = AV_RL32("pfrm");
 907         } else
 908             return buf_size;
 909     } else {
 910         buf        = buf      + 12;
 911         frame_size = buf_size - 12;
 912     }
 913
 914     FFSWAP(AVFrame*, f->current_picture, f->last_picture);
 915
 916     // alternatively we would have to use our own buffer management
 917     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 918
 919     if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
 920         return ret;
 921
 922     if (frame_4cc == AV_RL32("ifr2")) {
 923         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
 924         if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
 925             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
 926             return ret;
 927         }
 928     } else if (frame_4cc == AV_RL32("ifrm")) {
 929         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
 930         if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
 931             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
 932             return ret;
 933         }
 934     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 935         f->current_picture->pict_type = AV_PICTURE_TYPE_P;
 936         if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
 937             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
 938             return ret;
 939         }
 940     } else if (frame_4cc == AV_RL32("snd_")) {
 941         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 942                buf_size);
 943     } else {
 944         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 945                buf_size);
 946     }
 947
 948     f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
 949
 950     if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
 951         return ret;
 952     *got_frame = 1;
 953
 954     emms_c();
 955
 956     return buf_size;
 957 }
 958
 959 static av_cold int decode_init(AVCodecContext *avctx)
 960 {
 961     FourXContext * const f = avctx->priv_data;
 962
 963     if (avctx->extradata_size != 4 || !avctx->extradata) {
 964         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 965         return AVERROR_INVALIDDATA;
 966     }
 967     if((avctx->width % 16) || (avctx->height % 16)) {
 968         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
 969         return AVERROR_INVALIDDATA;
 970     }
 971
 972     f->version = AV_RL32(avctx->extradata) >> 16;
 973     ff_dsputil_init(&f->dsp, avctx);
 974     f->avctx = avctx;
 975     init_vlcs(f);
 976
 977     if (f->version > 2)
 978         avctx->pix_fmt = AV_PIX_FMT_RGB565;
 979     else
 980         avctx->pix_fmt = AV_PIX_FMT_BGR555;
 981
 982     f->current_picture = av_frame_alloc();
 983     f->last_picture    = av_frame_alloc();
 984     if (!f->current_picture  || !f->last_picture)
 985         return AVERROR(ENOMEM);
 986
 987     return 0;
 988 }
 989
 990
 991 static av_cold int decode_end(AVCodecContext *avctx)
 992 {
 993     FourXContext * const f = avctx->priv_data;
 994     int i;
 995
 996     av_freep(&f->bitstream_buffer);
 997     f->bitstream_buffer_size = 0;
 998     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 999         av_freep(&f->cfrm[i].data);
1000         f->cfrm[i].allocated_size = 0;
1001     }
1002     ff_free_vlc(&f->pre_vlc);
1003     av_frame_free(&f->current_picture);
1004     av_frame_free(&f->last_picture);
1005
1006     return 0;
1007 }
1008
1009 AVCodec ff_fourxm_decoder = {
1010     .name           = "4xm",
1011     .type           = AVMEDIA_TYPE_VIDEO,
1012     .id             = AV_CODEC_ID_4XM,
1013     .priv_data_size = sizeof(FourXContext),
1014     .init           = decode_init,
1015     .close          = decode_end,
1016     .decode         = decode_frame,
1017     .capabilities   = CODEC_CAP_DR1,
1018     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1019 };