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