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