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