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