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