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