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