eamad.c 10.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * Electronic Arts Madcow Video Decoder
 * Copyright (c) 2007-2009 Peter Ross
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

/**
23
 * @file
24
 * Electronic Arts Madcow Video Decoder
25
 * @author Peter Ross <pross@xvid.org>
26
 *
27
 * @see technical details at
28 29 30 31 32 33
 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_MAD
 */

#include "avcodec.h"
#include "get_bits.h"
#include "aandcttab.h"
34
#include "eaidct.h"
35
#include "internal.h"
36 37
#include "mpeg12.h"
#include "mpeg12data.h"
38
#include "libavutil/imgutils.h"
39 40 41 42 43 44 45

#define EA_PREAMBLE_SIZE    8
#define MADk_TAG MKTAG('M', 'A', 'D', 'k')    /* MAD i-frame */
#define MADm_TAG MKTAG('M', 'A', 'D', 'm')    /* MAD p-frame */
#define MADe_TAG MKTAG('M', 'A', 'D', 'e')    /* MAD lqp-frame */

typedef struct MadContext {
46 47
    AVCodecContext *avctx;
    DSPContext dsp;
48
    AVFrame last_frame;
49
    GetBitContext gb;
50 51
    void *bitstream_buf;
    unsigned int bitstream_buf_size;
Diego Biurrun's avatar
Diego Biurrun committed
52
    DECLARE_ALIGNED(16, int16_t, block)[64];
53 54 55 56
    ScanTable scantable;
    uint16_t quant_matrix[64];
    int mb_x;
    int mb_y;
57 58 59 60
} MadContext;

static av_cold int decode_init(AVCodecContext *avctx)
{
61
    MadContext *s = avctx->priv_data;
62
    s->avctx = avctx;
63
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
64
    ff_dsputil_init(&s->dsp, avctx);
65
    ff_init_scantable_permutation(s->dsp.idct_permutation, FF_NO_IDCT_PERM);
66
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
67 68 69 70 71 72 73 74 75 76 77 78 79
    ff_mpeg12_init_vlcs();
    return 0;
}

static inline void comp(unsigned char *dst, int dst_stride,
                        unsigned char *src, int src_stride, int add)
{
    int j, i;
    for (j=0; j<8; j++)
        for (i=0; i<8; i++)
            dst[j*dst_stride + i] = av_clip_uint8(src[j*src_stride + i] + add);
}

80 81
static inline void comp_block(MadContext *t, AVFrame *frame,
                              int mb_x, int mb_y,
82 83 84
                              int j, int mv_x, int mv_y, int add)
{
    if (j < 4) {
85
        unsigned offset = (mb_y*16 + ((j&2)<<2) + mv_y)*t->last_frame.linesize[0] + mb_x*16 + ((j&1)<<3) + mv_x;
86
        if (offset >= (t->avctx->height - 7) * t->last_frame.linesize[0] - 7)
87
            return;
88 89
        comp(frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3),
             frame->linesize[0],
90
             t->last_frame.data[0] + offset,
91
             t->last_frame.linesize[0], add);
92
    } else if (!(t->avctx->flags & CODEC_FLAG_GRAY)) {
93
        int index = j - 3;
94
        unsigned offset = (mb_y * 8 + (mv_y/2))*t->last_frame.linesize[index] + mb_x * 8 + (mv_x/2);
95
        if (offset >= (t->avctx->height/2 - 7) * t->last_frame.linesize[index] - 7)
96
            return;
97 98
        comp(frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x * 8,
             frame->linesize[index],
99
             t->last_frame.data[index] + offset,
100 101 102 103
             t->last_frame.linesize[index], add);
    }
}

104 105
static inline void idct_put(MadContext *t, AVFrame *frame, int16_t *block,
                            int mb_x, int mb_y, int j)
106 107
{
    if (j < 4) {
108
        ff_ea_idct_put_c(
109 110
            frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3),
            frame->linesize[0], block);
111
    } else if (!(t->avctx->flags & CODEC_FLAG_GRAY)) {
112
        int index = j - 3;
113
        ff_ea_idct_put_c(
114 115
            frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x*8,
            frame->linesize[index], block);
116 117 118
    }
}

119
static inline int decode_block_intra(MadContext *s, int16_t * block)
120 121 122
{
    int level, i, j, run;
    RLTable *rl = &ff_rl_mpeg1;
123 124
    const uint8_t *scantable = s->scantable.permutated;
    int16_t *quant_matrix = s->quant_matrix;
125 126 127 128 129

    block[0] = (128 + get_sbits(&s->gb, 8)) * quant_matrix[0];

    /* The RL decoder is derived from mpeg1_decode_block_intra;
       Escaped level and run values a decoded differently */
130
    i = 0;
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
    {
        OPEN_READER(re, &s->gb);
        /* now quantify & encode AC coefficients */
        for (;;) {
            UPDATE_CACHE(re, &s->gb);
            GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);

            if (level == 127) {
                break;
            } else if (level != 0) {
                i += run;
                j = scantable[i];
                level = (level*quant_matrix[j]) >> 4;
                level = (level-1)|1;
                level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
                LAST_SKIP_BITS(re, &s->gb, 1);
            } else {
                /* escape */
                UPDATE_CACHE(re, &s->gb);
                level = SHOW_SBITS(re, &s->gb, 10); SKIP_BITS(re, &s->gb, 10);

                UPDATE_CACHE(re, &s->gb);
                run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);

                i += run;
                j = scantable[i];
                if (level < 0) {
                    level = -level;
                    level = (level*quant_matrix[j]) >> 4;
                    level = (level-1)|1;
                    level = -level;
                } else {
                    level = (level*quant_matrix[j]) >> 4;
                    level = (level-1)|1;
                }
            }
            if (i > 63) {
                av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
169
                return -1;
170 171 172 173 174 175
            }

            block[j] = level;
        }
        CLOSE_READER(re, &s->gb);
    }
176
    return 0;
177 178 179 180 181 182 183 184 185 186 187 188 189
}

static int decode_motion(GetBitContext *gb)
{
    int value = 0;
    if (get_bits1(gb)) {
        if (get_bits1(gb))
            value = -17;
        value += get_bits(gb, 4) + 1;
    }
    return value;
}

190
static int decode_mb(MadContext *s, AVFrame *frame, int inter)
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
{
    int mv_map = 0;
    int mv_x, mv_y;
    int j;

    if (inter) {
        int v = decode210(&s->gb);
        if (v < 2) {
            mv_map = v ? get_bits(&s->gb, 6) : 63;
            mv_x = decode_motion(&s->gb);
            mv_y = decode_motion(&s->gb);
        }
    }

    for (j=0; j<6; j++) {
        if (mv_map & (1<<j)) {  // mv_x and mv_y are guarded by mv_map
            int add = 2*decode_motion(&s->gb);
208
            if (s->last_frame.data[0])
209
                comp_block(s, frame, s->mb_x, s->mb_y, j, mv_x, mv_y, add);
210
        } else {
211
            s->dsp.clear_block(s->block);
212
            if(decode_block_intra(s, s->block) < 0)
213
                return -1;
214
            idct_put(s, frame, s->block, s->mb_x, s->mb_y, j);
215 216
        }
    }
217
    return 0;
218 219
}

220
static void calc_quant_matrix(MadContext *s, int qscale)
221 222 223
{
    int i;

224 225 226
    s->quant_matrix[0] = (ff_inv_aanscales[0]*ff_mpeg1_default_intra_matrix[0]) >> 11;
    for (i=1; i<64; i++)
        s->quant_matrix[i] = (ff_inv_aanscales[i]*ff_mpeg1_default_intra_matrix[i]*qscale + 32) >> 10;
227 228 229
}

static int decode_frame(AVCodecContext *avctx,
230
                        void *data, int *got_frame,
231 232 233 234 235
                        AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    const uint8_t *buf_end = buf+buf_size;
236
    MadContext *s     = avctx->priv_data;
237
    AVFrame *frame    = data;
238
    int width, height;
239
    int chunk_type;
240
    int inter, ret;
241

242
    if (buf_size < 26) {
243
        av_log(avctx, AV_LOG_ERROR, "Input buffer too small\n");
244
        *got_frame = 0;
245
        return AVERROR_INVALIDDATA;
246 247 248 249 250 251 252 253 254
    }

    chunk_type = AV_RL32(&buf[0]);
    inter = (chunk_type == MADm_TAG || chunk_type == MADe_TAG);
    buf += 8;

    av_reduce(&avctx->time_base.num, &avctx->time_base.den,
              AV_RL16(&buf[6]), 1000, 1<<30);

255 256 257
    width  = AV_RL16(&buf[8]);
    height = AV_RL16(&buf[10]);
    calc_quant_matrix(s, buf[13]);
258 259
    buf += 16;

260 261 262 263 264
    if (width < 16 || height < 16) {
        av_log(avctx, AV_LOG_ERROR, "Dimensions too small\n");
        return AVERROR_INVALIDDATA;
    }

265
    if (avctx->width != width || avctx->height != height) {
266
        if((width * height)/2048*7 > buf_end-buf)
267 268 269
            return AVERROR_INVALIDDATA;
        if ((ret = av_image_check_size(width, height, 0, avctx)) < 0)
            return ret;
270
        avcodec_set_dimensions(avctx, width, height);
271
        av_frame_unref(&s->last_frame);
272 273
    }

274
    if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
275
        return ret;
276

277 278 279 280 281 282 283 284 285 286 287 288 289
    if (inter && !s->last_frame.data[0]) {
        av_log(avctx, AV_LOG_WARNING, "Missing reference frame.\n");
        ret = ff_get_buffer(avctx, &s->last_frame, AV_GET_BUFFER_FLAG_REF);
        if (ret < 0)
            return ret;
        memset(s->last_frame.data[0], 0, s->last_frame.height *
               s->last_frame.linesize[0]);
        memset(s->last_frame.data[1], 0x80, s->last_frame.height / 2 *
               s->last_frame.linesize[1]);
        memset(s->last_frame.data[2], 0x80, s->last_frame.height / 2 *
               s->last_frame.linesize[2]);
    }

290 291
    av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size,
                          buf_end - buf);
292
    if (!s->bitstream_buf)
293
        return AVERROR(ENOMEM);
294
    s->dsp.bswap16_buf(s->bitstream_buf, (const uint16_t*)buf, (buf_end-buf)/2);
295
    memset((uint8_t*)s->bitstream_buf + (buf_end-buf), 0, FF_INPUT_BUFFER_PADDING_SIZE);
296
    init_get_bits(&s->gb, s->bitstream_buf, 8*(buf_end-buf));
297 298 299

    for (s->mb_y=0; s->mb_y < (avctx->height+15)/16; s->mb_y++)
        for (s->mb_x=0; s->mb_x < (avctx->width +15)/16; s->mb_x++)
300
            if(decode_mb(s, frame, inter) < 0)
301
                return AVERROR_INVALIDDATA;
302

303
    *got_frame = 1;
304

305 306 307 308 309
    if (chunk_type != MADe_TAG) {
        av_frame_unref(&s->last_frame);
        if ((ret = av_frame_ref(&s->last_frame, frame)) < 0)
            return ret;
    }
310 311 312 313 314 315 316

    return buf_size;
}

static av_cold int decode_end(AVCodecContext *avctx)
{
    MadContext *t = avctx->priv_data;
317
    av_frame_unref(&t->last_frame);
318 319 320 321
    av_free(t->bitstream_buf);
    return 0;
}

322
AVCodec ff_eamad_decoder = {
323 324
    .name           = "eamad",
    .type           = AVMEDIA_TYPE_VIDEO,
325
    .id             = AV_CODEC_ID_MAD,
326 327 328 329 330
    .priv_data_size = sizeof(MadContext),
    .init           = decode_init,
    .close          = decode_end,
    .decode         = decode_frame,
    .capabilities   = CODEC_CAP_DR1,
331
    .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video")
332
};