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 <inttypes.h>
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/frame.h"
  31 #include "libavutil/imgutils.h"
  32 #include "libavutil/intreadwrite.h"
  33 #include "avcodec.h"
  34 #include "bytestream.h"
  35 #include "dsputil.h"
  36 #include "get_bits.h"
  37 #include "internal.h"
  38
  39
  40 #define BLOCK_TYPE_VLC_BITS 5
  41 #define ACDC_VLC_BITS 9
  42
  43 #define CFRAME_BUFFER_COUNT 100
  44
  45 static const uint8_t block_type_tab[2][4][8][2] = {
  46     {
  47         {    // { 8, 4, 2 } x { 8, 4, 2}
  48             { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
  49         }, { // { 8, 4 } x 1
  50             { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
  51         }, { // 1 x { 8, 4 }
  52             { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
  53         }, { // 1 x 2, 2 x 1
  54             { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
  55         }
  56     }, {
  57         {   // { 8, 4, 2 } x { 8, 4, 2}
  58             { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  59         }, {// { 8, 4 } x 1
  60             { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  61         }, {// 1 x { 8, 4 }
  62             { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
  63         }, {// 1 x 2, 2 x 1
  64             { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
  65       }
  66     }
  67 };
  68
  69 static const uint8_t size2index[4][4] = {
  70     { -1, 3, 1, 1 },
  71     {  3, 0, 0, 0 },
  72     {  2, 0, 0, 0 },
  73     {  2, 0, 0, 0 },
  74 };
  75
  76 static const int8_t mv[256][2] = {
  77     {   0,   0 }, {   0,  -1 }, {  -1,   0 }, {   1,   0 }, {   0,   1 }, {  -1,  -1 }, {   1,  -1 }, {  -1,   1 },
  78     {   1,   1 }, {   0,  -2 }, {  -2,   0 }, {   2,   0 }, {   0,   2 }, {  -1,  -2 }, {   1,  -2 }, {  -2,  -1 },
  79     {   2,  -1 }, {  -2,   1 }, {   2,   1 }, {  -1,   2 }, {   1,   2 }, {  -2,  -2 }, {   2,  -2 }, {  -2,   2 },
  80     {   2,   2 }, {   0,  -3 }, {  -3,   0 }, {   3,   0 }, {   0,   3 }, {  -1,  -3 }, {   1,  -3 }, {  -3,  -1 },
  81     {   3,  -1 }, {  -3,   1 }, {   3,   1 }, {  -1,   3 }, {   1,   3 }, {  -2,  -3 }, {   2,  -3 }, {  -3,  -2 },
  82     {   3,  -2 }, {  -3,   2 }, {   3,   2 }, {  -2,   3 }, {   2,   3 }, {   0,  -4 }, {  -4,   0 }, {   4,   0 },
  83     {   0,   4 }, {  -1,  -4 }, {   1,  -4 }, {  -4,  -1 }, {   4,  -1 }, {   4,   1 }, {  -1,   4 }, {   1,   4 },
  84     {  -3,  -3 }, {  -3,   3 }, {   3,   3 }, {  -2,  -4 }, {  -4,  -2 }, {   4,  -2 }, {  -4,   2 }, {  -2,   4 },
  85     {   2,   4 }, {  -3,  -4 }, {   3,  -4 }, {   4,  -3 }, {  -5,   0 }, {  -4,   3 }, {  -3,   4 }, {   3,   4 },
  86     {  -1,  -5 }, {  -5,  -1 }, {  -5,   1 }, {  -1,   5 }, {  -2,  -5 }, {   2,  -5 }, {   5,  -2 }, {   5,   2 },
  87     {  -4,  -4 }, {  -4,   4 }, {  -3,  -5 }, {  -5,  -3 }, {  -5,   3 }, {   3,   5 }, {  -6,   0 }, {   0,   6 },
  88     {  -6,  -1 }, {  -6,   1 }, {   1,   6 }, {   2,  -6 }, {  -6,   2 }, {   2,   6 }, {  -5,  -4 }, {   5,   4 },
  89     {   4,   5 }, {  -6,  -3 }, {   6,   3 }, {  -7,   0 }, {  -1,  -7 }, {   5,  -5 }, {  -7,   1 }, {  -1,   7 },
  90     {   4,  -6 }, {   6,   4 }, {  -2,  -7 }, {  -7,   2 }, {  -3,  -7 }, {   7,  -3 }, {   3,   7 }, {   6,  -5 },
  91     {   0,  -8 }, {  -1,  -8 }, {  -7,  -4 }, {  -8,   1 }, {   4,   7 }, {   2,  -8 }, {  -2,   8 }, {   6,   6 },
  92     {  -8,   3 }, {   5,  -7 }, {  -5,   7 }, {   8,  -4 }, {   0,  -9 }, {  -9,  -1 }, {   1,   9 }, {   7,  -6 },
  93     {  -7,   6 }, {  -5,  -8 }, {  -5,   8 }, {  -9,   3 }, {   9,  -4 }, {   7,  -7 }, {   8,  -6 }, {   6,   8 },
  94     {  10,   1 }, { -10,   2 }, {   9,  -5 }, {  10,  -3 }, {  -8,  -7 }, { -10,  -4 }, {   6,  -9 }, { -11,   0 },
  95     {  11,   1 }, { -11,  -2 }, {  -2,  11 }, {   7,  -9 }, {  -7,   9 }, {  10,   6 }, {  -4,  11 }, {   8,  -9 },
  96     {   8,   9 }, {   5,  11 }, {   7, -10 }, {  12,  -3 }, {  11,   6 }, {  -9,  -9 }, {   8,  10 }, {   5,  12 },
  97     { -11,   7 }, {  13,   2 }, {   6, -12 }, {  10,   9 }, { -11,   8 }, {  -7,  12 }, {   0,  14 }, {  14,  -2 },
  98     {  -9,  11 }, {  -6,  13 }, { -14,  -4 }, {  -5, -14 }, {   5,  14 }, { -15,  -1 }, { -14,  -6 }, {   3, -15 },
  99     {  11, -11 }, {  -7,  14 }, {  -5,  15 }, {   8, -14 }, {  15,   6 }, {   3,  16 }, {   7, -15 }, { -16,   5 },
 100     {   0,  17 }, { -16,  -6 }, { -10,  14 }, { -16,   7 }, {  12,  13 }, { -16,   8 }, { -17,   6 }, { -18,   3 },
 101     {  -7,  17 }, {  15,  11 }, {  16,  10 }, {   2, -19 }, {   3, -19 }, { -11, -16 }, { -18,   8 }, { -19,  -6 },
 102     {   2, -20 }, { -17, -11 }, { -10, -18 }, {   8,  19 }, { -21,  -1 }, { -20,   7 }, {  -4,  21 }, {  21,   5 },
 103     {  15,  16 }, {   2, -22 }, { -10, -20 }, { -22,   5 }, {  20, -11 }, {  -7, -22 }, { -12,  20 }, {  23,  -5 },
 104     {  13, -20 }, {  24,  -2 }, { -15,  19 }, { -11,  22 }, {  16,  19 }, {  23, -10 }, { -18, -18 }, {  -9, -24 },
 105     {  24, -10 }, {  -3,  26 }, { -23,  13 }, { -18, -20 }, {  17,  21 }, {  -4,  27 }, {  27,   6 }, {   1, -28 },
 106     { -11,  26 }, { -17, -23 }, {   7,  28 }, {  11, -27 }, {  29,   5 }, { -23, -19 }, { -28, -11 }, { -21,  22 },
 107     { -30,   7 }, { -17,  26 }, { -27,  16 }, {  13,  29 }, {  19, -26 }, {  10, -31 }, { -14, -30 }, {  20, -27 },
 108     { -29,  18 }, { -16, -31 }, { -28, -22 }, {  21, -30 }, { -25,  28 }, {  26, -29 }, {  25, -32 }, { -32, -32 }
 109 };
 110
 111 /* This is simply the scaled down elementwise product of the standard JPEG
 112  * quantizer table and the AAN premul table. */
 113 static const uint8_t dequant_table[64] = {
 114     16, 15, 13, 19, 24, 31, 28, 17,
 115     17, 23, 25, 31, 36, 63, 45, 21,
 116     18, 24, 27, 37, 52, 59, 49, 20,
 117     16, 28, 34, 40, 60, 80, 51, 20,
 118     18, 31, 48, 66, 68, 86, 56, 21,
 119     19, 38, 56, 59, 64, 64, 48, 20,
 120     27, 48, 55, 55, 56, 51, 35, 15,
 121     20, 35, 34, 32, 31, 22, 15,  8,
 122 };
 123
 124 static VLC block_type_vlc[2][4];
 125
 126
 127 typedef struct CFrameBuffer {
 128     unsigned int allocated_size;
 129     unsigned int size;
 130     int id;
 131     uint8_t *data;
 132 } CFrameBuffer;
 133
 134 typedef struct FourXContext {
 135     AVCodecContext *avctx;
 136     DSPContext dsp;
 137     uint16_t *frame_buffer;
 138     uint16_t *last_frame_buffer;
 139     GetBitContext pre_gb;          ///< ac/dc prefix
 140     GetBitContext gb;
 141     GetByteContext g;
 142     GetByteContext g2;
 143     int mv[256];
 144     VLC pre_vlc;
 145     int last_dc;
 146     DECLARE_ALIGNED(16, int16_t, block)[6][64];
 147     void *bitstream_buffer;
 148     unsigned int bitstream_buffer_size;
 149     int version;
 150     CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
 151 } FourXContext;
 152
 153
 154 #define FIX_1_082392200  70936
 155 #define FIX_1_414213562  92682
 156 #define FIX_1_847759065 121095
 157 #define FIX_2_613125930 171254
 158
 159 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
 160
 161 static void idct(int16_t block[64])
 162 {
 163     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 164     int tmp10, tmp11, tmp12, tmp13;
 165     int z5, z10, z11, z12, z13;
 166     int i;
 167     int temp[64];
 168
 169     for (i = 0; i < 8; i++) {
 170         tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
 171         tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
 172
 173         tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
 174         tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
 175
 176         tmp0 = tmp10 + tmp13;
 177         tmp3 = tmp10 - tmp13;
 178         tmp1 = tmp11 + tmp12;
 179         tmp2 = tmp11 - tmp12;
 180
 181         z13 = block[8 * 5 + i] + block[8 * 3 + i];
 182         z10 = block[8 * 5 + i] - block[8 * 3 + i];
 183         z11 = block[8 * 1 + i] + block[8 * 7 + i];
 184         z12 = block[8 * 1 + i] - block[8 * 7 + i];
 185
 186         tmp7  =          z11 + z13;
 187         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 188
 189         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
 190         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
 191         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
 192
 193         tmp6 = tmp12 - tmp7;
 194         tmp5 = tmp11 - tmp6;
 195         tmp4 = tmp10 + tmp5;
 196
 197         temp[8 * 0 + i] = tmp0 + tmp7;
 198         temp[8 * 7 + i] = tmp0 - tmp7;
 199         temp[8 * 1 + i] = tmp1 + tmp6;
 200         temp[8 * 6 + i] = tmp1 - tmp6;
 201         temp[8 * 2 + i] = tmp2 + tmp5;
 202         temp[8 * 5 + i] = tmp2 - tmp5;
 203         temp[8 * 4 + i] = tmp3 + tmp4;
 204         temp[8 * 3 + i] = tmp3 - tmp4;
 205     }
 206
 207     for (i = 0; i < 8 * 8; i += 8) {
 208         tmp10 = temp[0 + i] + temp[4 + i];
 209         tmp11 = temp[0 + i] - temp[4 + i];
 210
 211         tmp13 = temp[2 + i] + temp[6 + i];
 212         tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
 213
 214         tmp0 = tmp10 + tmp13;
 215         tmp3 = tmp10 - tmp13;
 216         tmp1 = tmp11 + tmp12;
 217         tmp2 = tmp11 - tmp12;
 218
 219         z13 = temp[5 + i] + temp[3 + i];
 220         z10 = temp[5 + i] - temp[3 + i];
 221         z11 = temp[1 + i] + temp[7 + i];
 222         z12 = temp[1 + i] - temp[7 + i];
 223
 224         tmp7  = z11 + z13;
 225         tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
 226
 227         z5    = MULTIPLY(z10 + z12, FIX_1_847759065);
 228         tmp10 = MULTIPLY(z12,  FIX_1_082392200) - z5;
 229         tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
 230
 231         tmp6 = tmp12 - tmp7;
 232         tmp5 = tmp11 - tmp6;
 233         tmp4 = tmp10 + tmp5;
 234
 235         block[0 + i] = (tmp0 + tmp7) >> 6;
 236         block[7 + i] = (tmp0 - tmp7) >> 6;
 237         block[1 + i] = (tmp1 + tmp6) >> 6;
 238         block[6 + i] = (tmp1 - tmp6) >> 6;
 239         block[2 + i] = (tmp2 + tmp5) >> 6;
 240         block[5 + i] = (tmp2 - tmp5) >> 6;
 241         block[4 + i] = (tmp3 + tmp4) >> 6;
 242         block[3 + i] = (tmp3 - tmp4) >> 6;
 243     }
 244 }
 245
 246 static av_cold void init_vlcs(FourXContext *f)
 247 {
 248     static VLC_TYPE table[2][4][32][2];
 249     int i, j;
 250
 251     for (i = 0; i < 2; i++) {
 252         for (j = 0; j < 4; j++) {
 253             block_type_vlc[i][j].table           = table[i][j];
 254             block_type_vlc[i][j].table_allocated = 32;
 255             init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
 256                      &block_type_tab[i][j][0][1], 2, 1,
 257                      &block_type_tab[i][j][0][0], 2, 1,
 258                      INIT_VLC_USE_NEW_STATIC);
 259         }
 260     }
 261 }
 262
 263 static void init_mv(FourXContext *f, int linesize)
 264 {
 265     int i;
 266
 267     for (i = 0; i < 256; i++) {
 268         if (f->version > 1)
 269             f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
 270         else
 271             f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
 272     }
 273 }
 274
 275 #if HAVE_BIGENDIAN
 276 #define LE_CENTRIC_MUL(dst, src, scale, dc)             \
 277     {                                                   \
 278         unsigned tmpval = AV_RN32(src);                 \
 279         tmpval = (tmpval << 16) | (tmpval >> 16);       \
 280         tmpval = tmpval * (scale) + (dc);               \
 281         tmpval = (tmpval << 16) | (tmpval >> 16);       \
 282         AV_WN32A(dst, tmpval);                          \
 283     }
 284 #else
 285 #define LE_CENTRIC_MUL(dst, src, scale, dc)              \
 286     {                                                    \
 287         unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
 288         AV_WN32A(dst, tmpval);                           \
 289     }
 290 #endif
 291
 292 static inline void mcdc(uint16_t *dst, const uint16_t *src, int log2w,
 293                         int h, int stride, int scale, unsigned dc)
 294 {
 295     int i;
 296     dc *= 0x10001;
 297
 298     switch (log2w) {
 299     case 0:
 300         for (i = 0; i < h; i++) {
 301             dst[0] = scale * src[0] + dc;
 302             if (scale)
 303                 src += stride;
 304             dst += stride;
 305         }
 306         break;
 307     case 1:
 308         for (i = 0; i < h; i++) {
 309             LE_CENTRIC_MUL(dst, src, scale, dc);
 310             if (scale)
 311                 src += stride;
 312             dst += stride;
 313         }
 314         break;
 315     case 2:
 316         for (i = 0; i < h; i++) {
 317             LE_CENTRIC_MUL(dst, src, scale, dc);
 318             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
 319             if (scale)
 320                 src += stride;
 321             dst += stride;
 322         }
 323         break;
 324     case 3:
 325         for (i = 0; i < h; i++) {
 326             LE_CENTRIC_MUL(dst,     src,     scale, dc);
 327             LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
 328             LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
 329             LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
 330             if (scale)
 331                 src += stride;
 332             dst += stride;
 333         }
 334         break;
 335     default:
 336         av_assert0(0);
 337     }
 338 }
 339
 340 static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src,
 341                           int log2w, int log2h, int stride)
 342 {
 343     const int index = size2index[log2h][log2w];
 344     const int h     = 1 << log2h;
 345     int code        = get_vlc2(&f->gb,
 346                                block_type_vlc[1 - (f->version > 1)][index].table,
 347                                BLOCK_TYPE_VLC_BITS, 1);
 348     uint16_t *start = f->last_frame_buffer;
 349     uint16_t *end   = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
 350     int ret;
 351     int scale   = 1;
 352     unsigned dc = 0;
 353
 354     av_assert0(code >= 0 && code <= 6 && log2w >= 0);
 355
 356     if (code == 1) {
 357         log2h--;
 358         if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
 359             return ret;
 360         return decode_p_block(f, dst + (stride << log2h),
 361                               src + (stride << log2h),
 362                               log2w, log2h, stride);
 363     } else if (code == 2) {
 364         log2w--;
 365         if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
 366             return ret;
 367         return decode_p_block(f, dst + (1 << log2w),
 368                               src + (1 << log2w),
 369                               log2w, log2h, stride);
 370     } else if (code == 6) {
 371         if (bytestream2_get_bytes_left(&f->g2) < 4) {
 372             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 373             return AVERROR_INVALIDDATA;
 374         }
 375         if (log2w) {
 376             dst[0]      = bytestream2_get_le16u(&f->g2);
 377             dst[1]      = bytestream2_get_le16u(&f->g2);
 378         } else {
 379             dst[0]      = bytestream2_get_le16u(&f->g2);
 380             dst[stride] = bytestream2_get_le16u(&f->g2);
 381         }
 382         return 0;
 383     }
 384
 385     if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
 386         av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
 387         return AVERROR_INVALIDDATA;
 388     }
 389
 390     if (code == 0) {
 391         src  += f->mv[bytestream2_get_byte(&f->g)];
 392     } else if (code == 3 && f->version >= 2) {
 393         return 0;
 394     } else if (code == 4) {
 395         src  += f->mv[bytestream2_get_byte(&f->g)];
 396         if (bytestream2_get_bytes_left(&f->g2) < 2){
 397             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 398             return AVERROR_INVALIDDATA;
 399         }
 400         dc    = bytestream2_get_le16(&f->g2);
 401     } else if (code == 5) {
 402         if (bytestream2_get_bytes_left(&f->g2) < 2){
 403             av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
 404             return AVERROR_INVALIDDATA;
 405         }
 406         av_assert0(start <= src && src <= end);
 407         scale = 0;
 408         dc    = bytestream2_get_le16(&f->g2);
 409     }
 410
 411     if (start > src || src > end) {
 412         av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
 413         return AVERROR_INVALIDDATA;
 414     }
 415
 416     mcdc(dst, src, log2w, h, stride, scale, dc);
 417
 418     return 0;
 419 }
 420
 421 static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
 422 {
 423     int x, y;
 424     const int width  = f->avctx->width;
 425     const int height = f->avctx->height;
 426     uint16_t *dst    = f->frame_buffer;
 427     uint16_t *src;
 428     unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
 429                  bytestream_offset, wordstream_offset;
 430     int ret;
 431
 432     src = f->last_frame_buffer;
 433
 434     if (f->version > 1) {
 435         extra           = 20;
 436         if (length < extra)
 437             return AVERROR_INVALIDDATA;
 438         bitstream_size  = AV_RL32(buf + 8);
 439         wordstream_size = AV_RL32(buf + 12);
 440         bytestream_size = AV_RL32(buf + 16);
 441     } else {
 442         extra           = 0;
 443         bitstream_size  = AV_RL16(buf - 4);
 444         wordstream_size = AV_RL16(buf - 2);
 445         bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
 446     }
 447
 448     if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
 449         bytestream_size > length - bitstream_size ||
 450         wordstream_size > length - bytestream_size - bitstream_size ||
 451         extra > length - bytestream_size - bitstream_size - wordstream_size) {
 452         av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
 453         bitstream_size+ bytestream_size+ wordstream_size - length);
 454         return AVERROR_INVALIDDATA;
 455     }
 456
 457     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 458                           bitstream_size);
 459     if (!f->bitstream_buffer)
 460         return AVERROR(ENOMEM);
 461     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)(buf + extra),
 462                      bitstream_size / 4);
 463     init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
 464
 465     wordstream_offset = extra + bitstream_size;
 466     bytestream_offset = extra + bitstream_size + wordstream_size;
 467     bytestream2_init(&f->g2, buf + wordstream_offset,
 468                      length - wordstream_offset);
 469     bytestream2_init(&f->g, buf + bytestream_offset,
 470                      length - bytestream_offset);
 471
 472     init_mv(f, width * 2);
 473
 474     for (y = 0; y < height; y += 8) {
 475         for (x = 0; x < width; x += 8)
 476             if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
 477                 return ret;
 478         src += 8 * width;
 479         dst += 8 * width;
 480     }
 481
 482     return 0;
 483 }
 484
 485 /**
 486  * decode block and dequantize.
 487  * Note this is almost identical to MJPEG.
 488  */
 489 static int decode_i_block(FourXContext *f, int16_t *block)
 490 {
 491     int code, i, j, level, val;
 492
 493     if (get_bits_left(&f->gb) < 2){
 494         av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
 495         return -1;
 496     }
 497
 498     /* DC coef */
 499     val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 500     if (val >> 4) {
 501         av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
 502         return AVERROR_INVALIDDATA;
 503     }
 504
 505     if (val)
 506         val = get_xbits(&f->gb, val);
 507
 508     val        = val * dequant_table[0] + f->last_dc;
 509     f->last_dc = block[0] = val;
 510     /* AC coefs */
 511     i = 1;
 512     for (;;) {
 513         code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
 514
 515         /* EOB */
 516         if (code == 0)
 517             break;
 518         if (code == 0xf0) {
 519             i += 16;
 520         } else {
 521             if (code & 0xf) {
 522                 level = get_xbits(&f->gb, code & 0xf);
 523             } else {
 524                 av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
 525                 return AVERROR_INVALIDDATA;
 526             }
 527             i    += code >> 4;
 528             if (i >= 64) {
 529                 av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
 530                 return 0;
 531             }
 532
 533             j = ff_zigzag_direct[i];
 534             block[j] = level * dequant_table[j];
 535             i++;
 536             if (i >= 64)
 537                 break;
 538         }
 539     }
 540
 541     return 0;
 542 }
 543
 544 static inline void idct_put(FourXContext *f, int x, int y)
 545 {
 546     int16_t (*block)[64] = f->block;
 547     int stride           = f->avctx->width;
 548     int i;
 549     uint16_t *dst = f->frame_buffer + y * stride + x;
 550
 551     for (i = 0; i < 4; i++) {
 552         block[i][0] += 0x80 * 8 * 8;
 553         idct(block[i]);
 554     }
 555
 556     if (!(f->avctx->flags & CODEC_FLAG_GRAY)) {
 557         for (i = 4; i < 6; i++)
 558             idct(block[i]);
 559     }
 560
 561     /* Note transform is:
 562      * y  = ( 1b + 4g + 2r) / 14
 563      * cb = ( 3b - 2g - 1r) / 14
 564      * cr = (-1b - 4g + 5r) / 14 */
 565     for (y = 0; y < 8; y++) {
 566         for (x = 0; x < 8; x++) {
 567             int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +
 568                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
 569             int cb = block[4][x + 8 * y];
 570             int cr = block[5][x + 8 * y];
 571             int cg = (cb + cr) >> 1;
 572             int y;
 573
 574             cb += cb;
 575
 576             y               = temp[0];
 577             dst[0]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 578             y               = temp[1];
 579             dst[1]          = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 580             y               = temp[8];
 581             dst[stride]     = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 582             y               = temp[9];
 583             dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
 584             dst            += 2;
 585         }
 586         dst += 2 * stride - 2 * 8;
 587     }
 588 }
 589
 590 static int decode_i_mb(FourXContext *f)
 591 {
 592     int ret;
 593     int i;
 594
 595     f->dsp.clear_blocks(f->block[0]);
 596
 597     for (i = 0; i < 6; i++)
 598         if ((ret = decode_i_block(f, f->block[i])) < 0)
 599             return ret;
 600
 601     return 0;
 602 }
 603
 604 static const uint8_t *read_huffman_tables(FourXContext *f,
 605                                           const uint8_t * const buf,
 606                                           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
 630         for (i = start; i <= end; i++)
 631             frequency[i] = *ptr++;
 632         start = *ptr++;
 633         if (start == 0)
 634             break;
 635
 636         end = *ptr++;
 637     }
 638     frequency[256] = 1;
 639
 640     while ((ptr - buf) & 3)
 641         ptr++; // 4byte align
 642
 643     if (ptr > ptr_end) {
 644         av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
 645         return NULL;
 646     }
 647
 648     for (j = 257; j < 512; j++) {
 649         int min_freq[2] = { 256 * 256, 256 * 256 };
 650         int smallest[2] = { 0, 0 };
 651         int i;
 652         for (i = 0; i < j; i++) {
 653             if (frequency[i] == 0)
 654                 continue;
 655             if (frequency[i] < min_freq[1]) {
 656                 if (frequency[i] < min_freq[0]) {
 657                     min_freq[1] = min_freq[0];
 658                     smallest[1] = smallest[0];
 659                     min_freq[0] = frequency[i];
 660                     smallest[0] = i;
 661                 } else {
 662                     min_freq[1] = frequency[i];
 663                     smallest[1] = i;
 664                 }
 665             }
 666         }
 667         if (min_freq[1] == 256 * 256)
 668             break;
 669
 670         frequency[j]           = min_freq[0] + min_freq[1];
 671         flag[smallest[0]]      = 0;
 672         flag[smallest[1]]      = 1;
 673         up[smallest[0]]        =
 674         up[smallest[1]]        = j;
 675         frequency[smallest[0]] = frequency[smallest[1]] = 0;
 676     }
 677
 678     for (j = 0; j < 257; j++) {
 679         int node, len = 0, bits = 0;
 680
 681         for (node = j; up[node] != -1; node = up[node]) {
 682             bits += flag[node] << len;
 683             len++;
 684             if (len > 31)
 685                 // can this happen at all ?
 686                 av_log(f->avctx, AV_LOG_ERROR,
 687                        "vlc length overflow\n");
 688         }
 689
 690         bits_tab[j] = bits;
 691         len_tab[j]  = len;
 692     }
 693
 694     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
 695                  bits_tab, 4, 4, 0))
 696         return NULL;
 697
 698     return ptr;
 699 }
 700
 701 static int mix(int c0, int c1)
 702 {
 703     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
 704     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
 705     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
 706     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
 707 }
 708
 709 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
 710 {
 711     int x, y, x2, y2;
 712     const int width  = f->avctx->width;
 713     const int height = f->avctx->height;
 714     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
 715     uint16_t *dst    = f->frame_buffer;
 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 * width + x2] = color[(bits >> index) & 3];
 747                 }
 748             }
 749             dst += 16;
 750         }
 751         dst += 16 * width - x;
 752     }
 753
 754     return 0;
 755 }
 756
 757 static int decode_i_frame(FourXContext *f, 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))
 767         return AVERROR_INVALIDDATA;
 768
 769     if (length < bitstream_size + 12) {
 770         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 771         return AVERROR_INVALIDDATA;
 772     }
 773
 774     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 775     prestream      =             buf + bitstream_size + 12;
 776
 777     if (prestream_size + bitstream_size + 12 != length
 778         || prestream_size > (1 << 26)) {
 779         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 780                prestream_size, bitstream_size, length);
 781         return AVERROR_INVALIDDATA;
 782     }
 783
 784     prestream = read_huffman_tables(f, prestream, prestream_size);
 785     if (!prestream) {
 786         av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
 787         return AVERROR_INVALIDDATA;
 788     }
 789
 790     av_assert0(prestream <= buf + length);
 791
 792     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 793
 794     prestream_size = length + buf - prestream;
 795
 796     av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 797                           prestream_size);
 798     if (!f->bitstream_buffer)
 799         return AVERROR(ENOMEM);
 800     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 801                      prestream_size / 4);
 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, 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 < 20)
 831         return AVERROR_INVALIDDATA;
 832
 833     av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
 834
 835     if (buf_size < AV_RL32(buf + 4) + 8) {
 836         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
 837                buf_size, AV_RL32(buf + 4));
 838         return AVERROR_INVALIDDATA;
 839     }
 840
 841     frame_4cc = AV_RL32(buf);
 842
 843     if (frame_4cc == AV_RL32("cfrm")) {
 844         int free_index       = -1;
 845         int id, whole_size;
 846         const int data_size  = buf_size - 20;
 847         CFrameBuffer *cfrm;
 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         id         = AV_RL32(buf + 12);
 855         whole_size = AV_RL32(buf + 16);
 856
 857         if (data_size < 0 || whole_size < 0) {
 858             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
 859             return AVERROR_INVALIDDATA;
 860         }
 861
 862         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 863             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 864                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 865                        f->cfrm[i].id);
 866
 867         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 868             if (f->cfrm[i].id == id)
 869                 break;
 870             if (f->cfrm[i].size == 0)
 871                 free_index = i;
 872         }
 873
 874         if (i >= CFRAME_BUFFER_COUNT) {
 875             i             = free_index;
 876             f->cfrm[i].id = id;
 877         }
 878         cfrm = &f->cfrm[i];
 879
 880         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
 881             return AVERROR_INVALIDDATA;
 882
 883         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 884                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 885         // explicit check needed as memcpy below might not catch a NULL
 886         if (!cfrm->data) {
 887             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
 888             return AVERROR(ENOMEM);
 889         }
 890
 891         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 892         cfrm->size += data_size;
 893
 894         if (cfrm->size >= whole_size) {
 895             buf        = cfrm->data;
 896             frame_size = cfrm->size;
 897
 898             if (id != avctx->frame_number)
 899                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 900                        id, avctx->frame_number);
 901
 902             if (f->version <= 1)
 903                 return AVERROR_INVALIDDATA;
 904
 905             cfrm->size = cfrm->id = 0;
 906             frame_4cc  = AV_RL32("pfrm");
 907         } else
 908             return buf_size;
 909     } else {
 910         buf        = buf      + 12;
 911         frame_size = buf_size - 12;
 912     }
 913
 914     if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
 915         return ret;
 916
 917     if (frame_4cc == AV_RL32("ifr2")) {
 918         picture->pict_type = AV_PICTURE_TYPE_I;
 919         if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
 920             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
 921             return ret;
 922         }
 923     } else if (frame_4cc == AV_RL32("ifrm")) {
 924         picture->pict_type = AV_PICTURE_TYPE_I;
 925         if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
 926             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
 927             return ret;
 928         }
 929     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 930         picture->pict_type = AV_PICTURE_TYPE_P;
 931         if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
 932             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
 933             return ret;
 934         }
 935     } else if (frame_4cc == AV_RL32("snd_")) {
 936         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 937                buf_size);
 938     } else {
 939         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 940                buf_size);
 941     }
 942
 943     picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
 944
 945     av_image_copy_plane(picture->data[0], picture->linesize[0],
 946                         (const uint8_t*)f->frame_buffer,  avctx->width * 2,
 947                         avctx->width * 2, avctx->height);
 948     FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
 949
 950     *got_frame = 1;
 951
 952     emms_c();
 953
 954     return buf_size;
 955 }
 956
 957 static av_cold int decode_end(AVCodecContext *avctx)
 958 {
 959     FourXContext * const f = avctx->priv_data;
 960     int i;
 961
 962     av_freep(&f->frame_buffer);
 963     av_freep(&f->last_frame_buffer);
 964     av_freep(&f->bitstream_buffer);
 965     f->bitstream_buffer_size = 0;
 966     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 967         av_freep(&f->cfrm[i].data);
 968         f->cfrm[i].allocated_size = 0;
 969     }
 970     ff_free_vlc(&f->pre_vlc);
 971
 972     return 0;
 973 }
 974
 975 static av_cold int decode_init(AVCodecContext *avctx)
 976 {
 977     FourXContext * const f = avctx->priv_data;
 978     int ret;
 979
 980     if (avctx->extradata_size != 4 || !avctx->extradata) {
 981         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 982         return AVERROR_INVALIDDATA;
 983     }
 984     if((avctx->width % 16) || (avctx->height % 16)) {
 985         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
 986         return AVERROR_INVALIDDATA;
 987     }
 988
 989     ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
 990     if (ret < 0)
 991         return ret;
 992
 993     f->frame_buffer      = av_mallocz(avctx->width * avctx->height * 2);
 994     f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
 995     if (!f->frame_buffer || !f->last_frame_buffer) {
 996         decode_end(avctx);
 997         return AVERROR(ENOMEM);
 998     }
 999
1000     f->version = AV_RL32(avctx->extradata) >> 16;
1001     ff_dsputil_init(&f->dsp, avctx);
1002     f->avctx = avctx;
1003     init_vlcs(f);
1004
1005     if (f->version > 2)
1006         avctx->pix_fmt = AV_PIX_FMT_RGB565;
1007     else
1008         avctx->pix_fmt = AV_PIX_FMT_BGR555;
1009
1010     return 0;
1011 }
1012
1013 AVCodec ff_fourxm_decoder = {
1014     .name           = "4xm",
1015     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
1016     .type           = AVMEDIA_TYPE_VIDEO,
1017     .id             = AV_CODEC_ID_4XM,
1018     .priv_data_size = sizeof(FourXContext),
1019     .init           = decode_init,
1020     .close          = decode_end,
1021     .decode         = decode_frame,
1022     .capabilities   = CODEC_CAP_DR1,
1023 };