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