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