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