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