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] = { 0 };
 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(up, -1, sizeof(up));
 565
 566     start = *ptr++;
 567     end   = *ptr++;
 568     for (;;) {
 569         int i;
 570
 571         for (i = start; i <= end; i++)
 572             frequency[i] = *ptr++;
 573         start = *ptr++;
 574         if (start == 0)
 575             break;
 576
 577         end = *ptr++;
 578     }
 579     frequency[256] = 1;
 580
 581     while ((ptr - buf) & 3)
 582         ptr++; // 4byte align
 583
 584     for (j = 257; j < 512; j++) {
 585         int min_freq[2] = { 256 * 256, 256 * 256 };
 586         int smallest[2] = { 0, 0 };
 587         int i;
 588         for (i = 0; i < j; i++) {
 589             if (frequency[i] == 0)
 590                 continue;
 591             if (frequency[i] < min_freq[1]) {
 592                 if (frequency[i] < min_freq[0]) {
 593                     min_freq[1] = min_freq[0];
 594                     smallest[1] = smallest[0];
 595                     min_freq[0] = frequency[i];
 596                     smallest[0] = i;
 597                 } else {
 598                     min_freq[1] = frequency[i];
 599                     smallest[1] = i;
 600                 }
 601             }
 602         }
 603         if (min_freq[1] == 256 * 256)
 604             break;
 605
 606         frequency[j]           = min_freq[0] + min_freq[1];
 607         flag[smallest[0]]      = 0;
 608         flag[smallest[1]]      = 1;
 609         up[smallest[0]]        =
 610         up[smallest[1]]        = j;
 611         frequency[smallest[0]] = frequency[smallest[1]] = 0;
 612     }
 613
 614     for (j = 0; j < 257; j++) {
 615         int node, len = 0, bits = 0;
 616
 617         for (node = j; up[node] != -1; node = up[node]) {
 618             bits += flag[node] << len;
 619             len++;
 620             if (len > 31)
 621                 // can this happen at all ?
 622                 av_log(f->avctx, AV_LOG_ERROR,
 623                        "vlc length overflow\n");
 624         }
 625
 626         bits_tab[j] = bits;
 627         len_tab[j]  = len;
 628     }
 629
 630     if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
 631                  bits_tab, 4, 4, 0))
 632         return NULL;
 633
 634     return ptr;
 635 }
 636
 637 static int mix(int c0, int c1)
 638 {
 639     int blue  =  2 * (c0 & 0x001F) + (c1 & 0x001F);
 640     int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
 641     int red   =  2 * (c0 >> 10)    + (c1 >> 10);
 642     return red / 3 * 1024 + green / 3 * 32 + blue / 3;
 643 }
 644
 645 static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
 646 {
 647     int x, y, x2, y2;
 648     const int width  = f->avctx->width;
 649     const int height = f->avctx->height;
 650     const int mbs    = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
 651     uint16_t *dst    = (uint16_t*)f->current_picture.data[0];
 652     const int stride =            f->current_picture.linesize[0]>>1;
 653     GetByteContext g3;
 654
 655     if (length < mbs * 8) {
 656         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 657         return AVERROR_INVALIDDATA;
 658     }
 659     bytestream2_init(&g3, buf, length);
 660
 661     for (y = 0; y < height; y += 16) {
 662         for (x = 0; x < width; x += 16) {
 663             unsigned int color[4] = { 0 }, bits;
 664             // warning following is purely guessed ...
 665             color[0] = bytestream2_get_le16u(&g3);
 666             color[1] = bytestream2_get_le16u(&g3);
 667
 668             if (color[0] & 0x8000)
 669                 av_log(NULL, AV_LOG_ERROR, "unk bit 1\n");
 670             if (color[1] & 0x8000)
 671                 av_log(NULL, AV_LOG_ERROR, "unk bit 2\n");
 672
 673             color[2] = mix(color[0], color[1]);
 674             color[3] = mix(color[1], color[0]);
 675
 676             bits = bytestream2_get_le32u(&g3);
 677             for (y2 = 0; y2 < 16; y2++) {
 678                 for (x2 = 0; x2 < 16; x2++) {
 679                     int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
 680                     dst[y2 * stride + x2] = color[(bits >> index) & 3];
 681                 }
 682             }
 683             dst += 16;
 684         }
 685         dst += 16 * stride - x;
 686     }
 687
 688     return 0;
 689 }
 690
 691 static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
 692 {
 693     int x, y;
 694     const int width  = f->avctx->width;
 695     const int height = f->avctx->height;
 696     const unsigned int bitstream_size = AV_RL32(buf);
 697     int token_count av_unused;
 698     unsigned int prestream_size;
 699     const uint8_t *prestream;
 700
 701     if (length < bitstream_size + 12) {
 702         av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
 703         return AVERROR_INVALIDDATA;
 704     }
 705
 706     token_count    =     AV_RL32(buf + bitstream_size + 8);
 707     prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
 708     prestream      =             buf + bitstream_size + 12;
 709
 710     if (prestream_size + bitstream_size + 12 != length
 711         || bitstream_size > (1 << 26)
 712         || prestream_size > (1 << 26)) {
 713         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
 714                prestream_size, bitstream_size, length);
 715         return -1;
 716     }
 717
 718     prestream = read_huffman_tables(f, prestream);
 719
 720     init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
 721
 722     prestream_size = length + buf - prestream;
 723
 724     av_fast_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
 725                    prestream_size + FF_INPUT_BUFFER_PADDING_SIZE);
 726     if (!f->bitstream_buffer)
 727         return AVERROR(ENOMEM);
 728     f->dsp.bswap_buf(f->bitstream_buffer, (const uint32_t*)prestream,
 729                      prestream_size / 4);
 730     memset((uint8_t*)f->bitstream_buffer + prestream_size,
 731            0, FF_INPUT_BUFFER_PADDING_SIZE);
 732     init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
 733
 734     f->last_dc = 0 * 128 * 8 * 8;
 735
 736     for (y = 0; y < height; y += 16) {
 737         for (x = 0; x < width; x += 16) {
 738             if (decode_i_mb(f) < 0)
 739                 return -1;
 740
 741             idct_put(f, x, y);
 742         }
 743     }
 744
 745     if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
 746         av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
 747
 748     return 0;
 749 }
 750
 751 static int decode_frame(AVCodecContext *avctx, void *data,
 752                         int *data_size, AVPacket *avpkt)
 753 {
 754     const uint8_t *buf    = avpkt->data;
 755     int buf_size          = avpkt->size;
 756     FourXContext *const f = avctx->priv_data;
 757     AVFrame *picture      = data;
 758     AVFrame *p, temp;
 759     int i, frame_4cc, frame_size;
 760
 761     frame_4cc = AV_RL32(buf);
 762     if (buf_size != AV_RL32(buf + 4) + 8 || buf_size < 20)
 763         av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d\n",
 764                buf_size, AV_RL32(buf + 4));
 765
 766     if (frame_4cc == AV_RL32("cfrm")) {
 767         int free_index       = -1;
 768         const int data_size  = buf_size - 20;
 769         const int id         = AV_RL32(buf + 12);
 770         const int whole_size = AV_RL32(buf + 16);
 771         CFrameBuffer *cfrm;
 772
 773         for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
 774             if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
 775                 av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
 776                        f->cfrm[i].id);
 777
 778         for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 779             if (f->cfrm[i].id == id)
 780                 break;
 781             if (f->cfrm[i].size == 0)
 782                 free_index = i;
 783         }
 784
 785         if (i >= CFRAME_BUFFER_COUNT) {
 786             i             = free_index;
 787             f->cfrm[i].id = id;
 788         }
 789         cfrm = &f->cfrm[i];
 790
 791         cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
 792                                      cfrm->size + data_size + FF_INPUT_BUFFER_PADDING_SIZE);
 793         // explicit check needed as memcpy below might not catch a NULL
 794         if (!cfrm->data) {
 795             av_log(f->avctx, AV_LOG_ERROR, "realloc falure");
 796             return -1;
 797         }
 798
 799         memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
 800         cfrm->size += data_size;
 801
 802         if (cfrm->size >= whole_size) {
 803             buf        = cfrm->data;
 804             frame_size = cfrm->size;
 805
 806             if (id != avctx->frame_number)
 807                 av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
 808                        id, avctx->frame_number);
 809
 810             cfrm->size = cfrm->id = 0;
 811             frame_4cc  = AV_RL32("pfrm");
 812         } else
 813             return buf_size;
 814     } else {
 815         buf        = buf      + 12;
 816         frame_size = buf_size - 12;
 817     }
 818
 819     temp               = f->current_picture;
 820     f->current_picture = f->last_picture;
 821     f->last_picture    = temp;
 822
 823     p                  = &f->current_picture;
 824     avctx->coded_frame = p;
 825
 826     // alternatively we would have to use our own buffer management
 827     avctx->flags |= CODEC_FLAG_EMU_EDGE;
 828
 829     if (p->data[0])
 830         avctx->release_buffer(avctx, p);
 831
 832     p->reference = 1;
 833     if (avctx->get_buffer(avctx, p) < 0) {
 834         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 835         return -1;
 836     }
 837
 838     if (frame_4cc == AV_RL32("ifr2")) {
 839         p->pict_type = AV_PICTURE_TYPE_I;
 840         if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0)
 841             return -1;
 842     } else if (frame_4cc == AV_RL32("ifrm")) {
 843         p->pict_type = AV_PICTURE_TYPE_I;
 844         if (decode_i_frame(f, buf, frame_size) < 0)
 845             return -1;
 846     } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
 847         if (!f->last_picture.data[0]) {
 848             f->last_picture.reference = 1;
 849             if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
 850                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 851                 return -1;
 852             }
 853         }
 854
 855         p->pict_type = AV_PICTURE_TYPE_P;
 856         if (decode_p_frame(f, buf, frame_size) < 0)
 857             return -1;
 858     } else if (frame_4cc == AV_RL32("snd_")) {
 859         av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
 860                buf_size);
 861     } else {
 862         av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
 863                buf_size);
 864     }
 865
 866     p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;
 867
 868     *picture   = *p;
 869     *data_size = sizeof(AVPicture);
 870
 871     emms_c();
 872
 873     return buf_size;
 874 }
 875
 876
 877 static av_cold void common_init(AVCodecContext *avctx)
 878 {
 879     FourXContext * const f = avctx->priv_data;
 880
 881     ff_dsputil_init(&f->dsp, avctx);
 882
 883     f->avctx = avctx;
 884 }
 885
 886 static av_cold int decode_init(AVCodecContext *avctx)
 887 {
 888     FourXContext * const f = avctx->priv_data;
 889
 890     if (avctx->extradata_size != 4 || !avctx->extradata) {
 891         av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
 892         return 1;
 893     }
 894
 895     f->version = AV_RL32(avctx->extradata) >> 16;
 896     common_init(avctx);
 897     init_vlcs(f);
 898
 899     if (f->version > 2)
 900         avctx->pix_fmt = PIX_FMT_RGB565;
 901     else
 902         avctx->pix_fmt = PIX_FMT_BGR555;
 903
 904     return 0;
 905 }
 906
 907
 908 static av_cold int decode_end(AVCodecContext *avctx)
 909 {
 910     FourXContext * const f = avctx->priv_data;
 911     int i;
 912
 913     av_freep(&f->bitstream_buffer);
 914     f->bitstream_buffer_size = 0;
 915     for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
 916         av_freep(&f->cfrm[i].data);
 917         f->cfrm[i].allocated_size = 0;
 918     }
 919     ff_free_vlc(&f->pre_vlc);
 920     if (f->current_picture.data[0])
 921         avctx->release_buffer(avctx, &f->current_picture);
 922     if (f->last_picture.data[0])
 923         avctx->release_buffer(avctx, &f->last_picture);
 924
 925     return 0;
 926 }
 927
 928 AVCodec ff_fourxm_decoder = {
 929     .name           = "4xm",
 930     .type           = AVMEDIA_TYPE_VIDEO,
 931     .id             = CODEC_ID_4XM,
 932     .priv_data_size = sizeof(FourXContext),
 933     .init           = decode_init,
 934     .close          = decode_end,
 935     .decode         = decode_frame,
 936     .capabilities   = CODEC_CAP_DR1,
 937     .long_name      = NULL_IF_CONFIG_SMALL("4X Movie"),
 938 };