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))
 770         return AVERROR_INVALIDDATA;
 771
 772     if (length < bitstream_size + 12) {
 773         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 774         return AVERROR_INVALIDDATA;
 775     }
 776
 777     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 778     prestream      =             buf + bitstream_size + 12;
 779
 780     if (prestream_size + bitstream_size + 12 != length
 781         || prestream_size > (1 << 26)) {
 782         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 783                prestream_size, bitstream_size, length);
 784         return AVERROR_INVALIDDATA;
 785     }
 786
 787     prestream = read_huffman_tables(f, prestream, prestream_size);
 788     if (!prestream) {
 789         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
 790         return AVERROR_INVALIDDATA;
 791     }
 792
 793     av_assert0(prestream <= buf + length);
 794
 795     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 796
 797     prestream_size = length + buf - prestream;
 798
 799     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 800                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 801     if (!f->bitstream_buffer)
 802         return AVERROR(ENOMEM);
 803     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 804                      prestream_size / 4);
 805     memset((uint8_t*)f->bitstream_buffer + prestream_size,
 806            0, FF_INPUT_BUFFER_PADDING_SIZE);
 807     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
 808
 809     f->last_dc = 0 * 128 * 8 * 8;
 810
 811     for (y = 0; y < height; y += 16) {
 812         for (x = 0; x < width; x += 16) {
 813             if ((ret = decode_i_mb(f)) < 0)
 814                 return ret;
 815
 816             idct_put(f, frame, x, y);
 817         }
 818     }
 819
 820     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 821         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 822
 823     return 0;
 824 }
 825
 826 static int decode_frame(AVCodecContext *avctx, void *data,
 827                         int *got_frame, AVPacket *avpkt)
 828 {
 829     const uint8_t *buf    = avpkt->data;
 830     int buf_size          = avpkt->size;
 831     FourXContext *const f = avctx->priv_data;
 832     AVFrame *picture      = data;
 833     int i, frame_4cc, frame_size, ret;
 834
 835     if (buf_size < 20)
 836         return AVERROR_INVALIDDATA;
 837
 838     if (buf_size < AV_RL32(buf + 4) + 8) {
 839         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
 840                buf_size, AV_RL32(buf + 4));
 841         return AVERROR_INVALIDDATA;
 842     }
 843
 844     frame_4cc = AV_RL32(buf);
 845
 846     if (frame_4cc == AV_RL32("cfrm")) {
 847         int free_index       = -1;
 848         int id, whole_size;
 849         const int data_size  = buf_size - 20;
 850         CFrameBuffer *cfrm;
 851
 852         if (f->version <= 1) {
 853             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
 854             return AVERROR_INVALIDDATA;
 855         }
 856
 857         id         = AV_RL32(buf + 12);
 858         whole_size = AV_RL32(buf + 16);
 859
 860         if (data_size < 0 || whole_size < 0) {
 861             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
 862             return AVERROR_INVALIDDATA;
 863         }
 864
 865         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 866             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 867                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 868                        f->cfrm[i].id);
 869
 870         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 871             if (f->cfrm[i].id == id)
 872                 break;
 873             if (f->cfrm[i].size == 0)
 874                 free_index = i;
 875         }
 876
 877         if (i >= CFRAME_BUFFER_COUNT) {
 878             i             = free_index;
 879             f->cfrm[i].id = id;
 880         }
 881         cfrm = &f->cfrm[i];
 882
 883         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
 884             return AVERROR_INVALIDDATA;
 885
 886         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 887                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 888         // explicit check needed as memcpy below might not catch a NULL
 889         if (!cfrm->data) {
 890             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
 891             return AVERROR(ENOMEM);
 892         }
 893
 894         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 895         cfrm->size += data_size;
 896
 897         if (cfrm->size >= whole_size) {
 898             buf        = cfrm->data;
 899             frame_size = cfrm->size;
 900
 901             if (id != avctx->frame_number)
 902                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 903                        id, avctx->frame_number);
 904
 905             if (f->version <= 1)
 906                 return AVERROR_INVALIDDATA;
 907
 908             cfrm->size = cfrm->id = 0;
 909             frame_4cc  = AV_RL32("pfrm");
 910         } else
 911             return buf_size;
 912     } else {
 913         buf        = buf      + 12;
 914         frame_size = buf_size - 12;
 915     }
 916
 917     FFSWAP(AVFrame*, f->current_picture, f->last_picture);
 918
 919     // alternatively we would have to use our own buffer management
 920     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 921
 922     if ((ret = ff_reget_buffer(avctx, f->current_picture)) < 0)
 923         return ret;
 924
 925     if (frame_4cc == AV_RL32("ifr2")) {
 926         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
 927         if ((ret = decode_i2_frame(f, f->current_picture, buf - 4, frame_size + 4)) < 0) {
 928             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
 929             return ret;
 930         }
 931     } else if (frame_4cc == AV_RL32("ifrm")) {
 932         f->current_picture->pict_type = AV_PICTURE_TYPE_I;
 933         if ((ret = decode_i_frame(f, f->current_picture, buf, frame_size)) < 0) {
 934             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
 935             return ret;
 936         }
 937     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 938         f->current_picture->pict_type = AV_PICTURE_TYPE_P;
 939         if ((ret = decode_p_frame(f, f->current_picture, buf, frame_size)) < 0) {
 940             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
 941             return ret;
 942         }
 943     } else if (frame_4cc == AV_RL32("snd_")) {
 944         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 945                buf_size);
 946     } else {
 947         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 948                buf_size);
 949     }
 950
 951     f->current_picture->key_frame = f->current_picture->pict_type == AV_PICTURE_TYPE_I;
 952
 953     if ((ret = av_frame_ref(picture, f->current_picture)) < 0)
 954         return ret;
 955     *got_frame = 1;
 956
 957     emms_c();
 958
 959     return buf_size;
 960 }
 961
 962 static av_cold int decode_init(AVCodecContext *avctx)
 963 {
 964     FourXContext * const f = avctx->priv_data;
 965
 966     if (avctx->extradata_size != 4 || !avctx->extradata) {
 967         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 968         return AVERROR_INVALIDDATA;
 969     }
 970     if((avctx->width % 16) || (avctx->height % 16)) {
 971         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
 972         return AVERROR_INVALIDDATA;
 973     }
 974
 975     f->version = AV_RL32(avctx->extradata) >> 16;
 976     ff_dsputil_init(&f->dsp, avctx);
 977     f->avctx = avctx;
 978     init_vlcs(f);
 979
 980     if (f->version > 2)
 981         avctx->pix_fmt = AV_PIX_FMT_RGB565;
 982     else
 983         avctx->pix_fmt = AV_PIX_FMT_BGR555;
 984
 985     f->current_picture = av_frame_alloc();
 986     f->last_picture    = av_frame_alloc();
 987     if (!f->current_picture  || !f->last_picture)
 988         return AVERROR(ENOMEM);
 989
 990     return 0;
 991 }
 992
 993
 994 static av_cold int decode_end(AVCodecContext *avctx)
 995 {
 996     FourXContext * const f = avctx->priv_data;
 997     int i;
 998
 999     av_freep(&f->bitstream_buffer);
1000     f->bitstream_buffer_size = 0;
1001     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
1002         av_freep(&f->cfrm[i].data);
1003         f->cfrm[i].allocated_size = 0;
1004     }
1005     ff_free_vlc(&f->pre_vlc);
1006     av_frame_free(&f->current_picture);
1007     av_frame_free(&f->last_picture);
1008
1009     return 0;
1010 }
1011
1012 AVCodec ff_fourxm_decoder = {
1013     .name           = "4xm",
1014     .type           = AVMEDIA_TYPE_VIDEO,
1015     .id             = AV_CODEC_ID_4XM,
1016     .priv_data_size = sizeof(FourXContext),
1017     .init           = decode_init,
1018     .close          = decode_end,
1019     .decode         = decode_frame,
1020     .capabilities   = CODEC_CAP_DR1,
1021     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1022 };