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