git.sesse.net Git - ffmpeg/blob - libavcodec/4xm.c

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