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, DCTELEM, 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(DCTELEM 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 -1;
 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, DCTELEM *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     DCTELEM (*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             DCTELEM *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 i;
 571
 572     f->dsp.clear_blocks(f->block[0]);
 573
 574     for (i = 0; i < 6; i++)
 575         if (decode_i_block(f, f->block[i]) < 0)
 576             return -1;
 577
 578     return 0;
 579 }
 580
 581 static const uint8_t *read_huffman_tables(FourXContext *f,
 582                                           const uint8_t * const buf, int buf_size)
 583 {
 584     int frequency[512] = { 0 };
 585     uint8_t flag[512];
 586     int up[512];
 587     uint8_t len_tab[257];
 588     int bits_tab[257];
 589     int start, end;
 590     const uint8_t *ptr = buf;
 591     const uint8_t *ptr_end = buf + buf_size;
 592     int j;
 593
 594     memset(up, -1, sizeof(up));
 595
 596     start = *ptr++;
 597     end   = *ptr++;
 598     for (;;) {
 599         int i;
 600
 601         if (start <= end && ptr_end - ptr < end - start + 1 + 1)
 602             return NULL;
 603         for (i = start; i <= end; i++)
 604             frequency[i] = *ptr++;
 605         start = *ptr++;
 606         if (start == 0)
 607             break;
 608
 609         end = *ptr++;
 610     }
 611     frequency[256] = 1;
 612
 613     while ((ptr - buf) & 3)
 614         ptr++; // 4byte align
 615
 616     for (j = 257; j < 512; j++) {
 617         int min_freq[2] = { 256 * 256, 256 * 256 };
 618         int smallest[2] = { 0, 0 };
 619         int i;
 620         for (i = 0; i < j; i++) {
 621             if (frequency[i] == 0)
 622                 continue;
 623             if (frequency[i] < min_freq[1]) {
 624                 if (frequency[i] < min_freq[0]) {
 625                     min_freq[1] = min_freq[0];
 626                     smallest[1] = smallest[0];
 627                     min_freq[0] = frequency[i];
 628                     smallest[0] = i;
 629                 } else {
 630                     min_freq[1] = frequency[i];
 631                     smallest[1] = i;
 632                 }
 633             }
 634         }
 635         if (min_freq[1] == 256 * 256)
 636             break;
 637
 638         frequency[j]           = min_freq[0] + min_freq[1];
 639         flag[smallest[0]]      = 0;
 640         flag[smallest[1]]      = 1;
 641         up[smallest[0]]        =
 642         up[smallest[1]]        = j;
 643         frequency[smallest[0]] = frequency[smallest[1]] = 0;
 644     }
 645
 646     for (j = 0; j < 257; j++) {
 647         int node, len = 0, bits = 0;
 648
 649         for (node = j; up[node] != -1; node = up[node]) {
 650             bits += flag[node] << len;
 651             len++;
 652             if (len > 31)
 653                 // can this happen at all ?
 654                 av_log(f->avctx, AV_LOG_ERROR,
 655                        "vlc length overflow\n");
 656         }
 657
 658         bits_tab[j] = bits;
 659         len_tab[j]  = len;
 660     }
 661
 662     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
 663                  bits_tab, 4, 4, 0))
 664         return NULL;
 665
 666     return ptr;
 667 }
 668
 669 static int mix(int c0, int c1)
 670 {
 671     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
 672     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
 673     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
 674     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
 675 }
 676
 677 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
 678 {
 679     int x, y, x2, y2;
 680     const int width  = f->avctx->width;
 681     const int height = f->avctx->height;
 682     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
 683     uint16_t *dst    = (uint16_t*)f->current_picture.data[0];
 684     const int stride =            f->current_picture.linesize[0]>>1;
 685     const uint8_t *buf_end = buf + length;
 686     GetByteContext g3;
 687
 688     if (length < mbs * 8) {
 689         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 690         return AVERROR_INVALIDDATA;
 691     }
 692     bytestream2_init(&g3, buf, length);
 693
 694     for (y = 0; y < height; y += 16) {
 695         for (x = 0; x < width; x += 16) {
 696             unsigned int color[4] = { 0 }, bits;
 697             if (buf_end - buf < 8)
 698                 return -1;
 699             // warning following is purely guessed ...
 700             color[0] = bytestream2_get_le16u(&g3);
 701             color[1] = bytestream2_get_le16u(&g3);
 702
 703             if (color[0] & 0x8000)
 704                 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
 705             if (color[1] & 0x8000)
 706                 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
 707
 708             color[2] = mix(color[0], color[1]);
 709             color[3] = mix(color[1], color[0]);
 710
 711             bits = bytestream2_get_le32u(&g3);
 712             for (y2 = 0; y2 < 16; y2++) {
 713                 for (x2 = 0; x2 < 16; x2++) {
 714                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
 715                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
 716                 }
 717             }
 718             dst += 16;
 719         }
 720         dst += 16 * stride - x;
 721     }
 722
 723     return 0;
 724 }
 725
 726 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
 727 {
 728     int x, y;
 729     const int width  = f->avctx->width;
 730     const int height = f->avctx->height;
 731     const unsigned int bitstream_size = AV_RL32(buf);
 732     unsigned int prestream_size;
 733     const uint8_t *prestream;
 734
 735     if (bitstream_size > (1<<26) || length < bitstream_size + 12) {
 736         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 737         return AVERROR_INVALIDDATA;
 738     }
 739
 740     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 741     prestream      =             buf + bitstream_size + 12;
 742
 743     if (prestream_size + bitstream_size + 12 != length
 744         || bitstream_size > (1 << 26)
 745         || prestream_size > (1 << 26)) {
 746         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 747                prestream_size, bitstream_size, length);
 748         return -1;
 749     }
 750
 751     prestream = read_huffman_tables(f, prestream, buf + length - prestream);
 752     if (!prestream)
 753         return -1;
 754
 755     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 756
 757     prestream_size = length + buf - prestream;
 758
 759     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 760                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 761     if (!f->bitstream_buffer)
 762         return AVERROR(ENOMEM);
 763     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 764                      prestream_size / 4);
 765     memset((uint8_t*)f->bitstream_buffer + prestream_size,
 766            0, FF_INPUT_BUFFER_PADDING_SIZE);
 767     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
 768
 769     f->last_dc = 0 * 128 * 8 * 8;
 770
 771     for (y = 0; y < height; y += 16) {
 772         for (x = 0; x < width; x += 16) {
 773             if (decode_i_mb(f) < 0)
 774                 return -1;
 775
 776             idct_put(f, x, y);
 777         }
 778     }
 779
 780     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 781         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 782
 783     return 0;
 784 }
 785
 786 static int decode_frame(AVCodecContext *avctx, void *data,
 787                         int *got_frame, AVPacket *avpkt)
 788 {
 789     const uint8_t *buf    = avpkt->data;
 790     int buf_size          = avpkt->size;
 791     FourXContext *const f = avctx->priv_data;
 792     AVFrame *picture      = data;
 793     AVFrame *p, temp;
 794     int i, frame_4cc, frame_size;
 795
 796     if (buf_size < 12)
 797         return AVERROR_INVALIDDATA;
 798     frame_4cc = AV_RL32(buf);
 799     if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
 800         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
 801                buf_size, AV_RL32(buf + 4));
 802
 803     if (frame_4cc == AV_RL32("cfrm")) {
 804         int free_index       = -1;
 805         const int data_size  = buf_size - 20;
 806         const int id         = AV_RL32(buf + 12);
 807         const int whole_size = AV_RL32(buf + 16);
 808         CFrameBuffer *cfrm;
 809
 810         if (data_size < 0 || whole_size < 0) {
 811             av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
 812             return AVERROR_INVALIDDATA;
 813         }
 814
 815         if (f->version <= 1) {
 816             av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
 817             return AVERROR_INVALIDDATA;
 818         }
 819
 820         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 821             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 822                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 823                        f->cfrm[i].id);
 824
 825         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 826             if (f->cfrm[i].id == id)
 827                 break;
 828             if (f->cfrm[i].size == 0)
 829                 free_index = i;
 830         }
 831
 832         if (i >= CFRAME_BUFFER_COUNT) {
 833             i             = free_index;
 834             f->cfrm[i].id = id;
 835         }
 836         cfrm = &f->cfrm[i];
 837
 838         if (data_size > UINT_MAX -  cfrm->size - FF_INPUT_BUFFER_PADDING_SIZE)
 839             return AVERROR_INVALIDDATA;
 840
 841         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 842                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 843         // explicit check needed as memcpy below might not catch a NULL
 844         if (!cfrm->data) {
 845             av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
 846             return -1;
 847         }
 848
 849         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 850         cfrm->size += data_size;
 851
 852         if (cfrm->size >= whole_size) {
 853             buf        = cfrm->data;
 854             frame_size = cfrm->size;
 855
 856             if (id != avctx->frame_number)
 857                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 858                        id, avctx->frame_number);
 859
 860             cfrm->size = cfrm->id = 0;
 861             frame_4cc  = AV_RL32("pfrm");
 862         } else
 863             return buf_size;
 864     } else {
 865         buf        = buf      + 12;
 866         frame_size = buf_size - 12;
 867     }
 868
 869     temp               = f->current_picture;
 870     f->current_picture = f->last_picture;
 871     f->last_picture    = temp;
 872
 873     p                  = &f->current_picture;
 874     avctx->coded_frame = p;
 875
 876     // alternatively we would have to use our own buffer management
 877     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 878
 879     p->reference= 3;
 880     if (avctx->reget_buffer(avctx, p) < 0) {
 881         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 882         return -1;
 883     }
 884
 885     if (frame_4cc == AV_RL32("ifr2")) {
 886         p->pict_type= AV_PICTURE_TYPE_I;
 887         if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0) {
 888             av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
 889             return -1;
 890         }
 891     } else if (frame_4cc == AV_RL32("ifrm")) {
 892         p->pict_type= AV_PICTURE_TYPE_I;
 893         if (decode_i_frame(f, buf, frame_size) < 0) {
 894             av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
 895             return -1;
 896         }
 897     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 898         if (!f->last_picture.data[0]) {
 899             f->last_picture.reference = 3;
 900             if (ff_get_buffer(avctx, &f->last_picture) < 0) {
 901                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 902                 return -1;
 903             }
 904             for (i=0; i<avctx->height; i++)
 905                 memset(f->last_picture.data[0] + i*f->last_picture.linesize[0], 0, 2*avctx->width);
 906         }
 907
 908         p->pict_type = AV_PICTURE_TYPE_P;
 909         if (decode_p_frame(f, buf, frame_size) < 0) {
 910             av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
 911             return -1;
 912         }
 913     } else if (frame_4cc == AV_RL32("snd_")) {
 914         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 915                buf_size);
 916     } else {
 917         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 918                buf_size);
 919     }
 920
 921     p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
 922
 923     *picture   = *p;
 924     *got_frame = 1;
 925
 926     emms_c();
 927
 928     return buf_size;
 929 }
 930
 931
 932 static av_cold void common_init(AVCodecContext *avctx)
 933 {
 934     FourXContext * const f = avctx->priv_data;
 935
 936     ff_dsputil_init(&f->dsp, avctx);
 937
 938     f->avctx = avctx;
 939 }
 940
 941 static av_cold int decode_init(AVCodecContext *avctx)
 942 {
 943     FourXContext * const f = avctx->priv_data;
 944
 945     if (avctx->extradata_size != 4 || !avctx->extradata) {
 946         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 947         return AVERROR_INVALIDDATA;
 948     }
 949     if((avctx->width % 16) || (avctx->height % 16)) {
 950         av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
 951         return AVERROR_INVALIDDATA;
 952     }
 953
 954     avcodec_get_frame_defaults(&f->current_picture);
 955     avcodec_get_frame_defaults(&f->last_picture);
 956     f->version = AV_RL32(avctx->extradata) >> 16;
 957     common_init(avctx);
 958     init_vlcs(f);
 959
 960     if (f->version > 2)
 961         avctx->pix_fmt = AV_PIX_FMT_RGB565;
 962     else
 963         avctx->pix_fmt = AV_PIX_FMT_BGR555;
 964
 965     return 0;
 966 }
 967
 968
 969 static av_cold int decode_end(AVCodecContext *avctx)
 970 {
 971     FourXContext * const f = avctx->priv_data;
 972     int i;
 973
 974     av_freep(&f->bitstream_buffer);
 975     f->bitstream_buffer_size = 0;
 976     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 977         av_freep(&f->cfrm[i].data);
 978         f->cfrm[i].allocated_size = 0;
 979     }
 980     ff_free_vlc(&f->pre_vlc);
 981     if (f->current_picture.data[0])
 982         avctx->release_buffer(avctx, &f->current_picture);
 983     if (f->last_picture.data[0])
 984         avctx->release_buffer(avctx, &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 };