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