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