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