eamad.c 10.1 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 34
 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_MAD
 */

#include "avcodec.h"
#include "get_bits.h"
#include "dsputil.h"
#include "aandcttab.h"
35
#include "eaidct.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 49
    AVFrame frame;
    AVFrame last_frame;
50
    GetBitContext gb;
51 52
    void *bitstream_buf;
    unsigned int bitstream_buf_size;
53
    DECLARE_ALIGNED(16, DCTELEM, block)[64];
54 55 56 57
    ScanTable scantable;
    uint16_t quant_matrix[64];
    int mb_x;
    int mb_y;
58 59 60 61
} MadContext;

static av_cold int decode_init(AVCodecContext *avctx)
{
62
    MadContext *s = avctx->priv_data;
63 64
    s->avctx = avctx;
    avctx->pix_fmt = PIX_FMT_YUV420P;
65
    ff_dsputil_init(&s->dsp, avctx);
66
    ff_init_scantable_permutation(s->dsp.idct_permutation, FF_NO_IDCT_PERM);
67
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
    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);
}

static inline void comp_block(MadContext *t, int mb_x, int mb_y,
                              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(t->frame.data[0] + (mb_y*16 + ((j&2)<<2))*t->frame.linesize[0] + mb_x*16 + ((j&1)<<3),
             t->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(t->frame.data[index] + (mb_y*8)*t->frame.linesize[index] + mb_x * 8,
             t->frame.linesize[index],
99
             t->last_frame.data[index] + offset,
100 101 102 103 104 105 106
             t->last_frame.linesize[index], add);
    }
}

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

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

    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 */
129
    i = 0;
130 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
    {
        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);
168
                return -1;
169 170 171 172 173 174
            }

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

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;
}

189
static int decode_mb(MadContext *s, int inter)
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
{
    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);
207 208
            if (s->last_frame.data[0])
                comp_block(s, s->mb_x, s->mb_y, j, mv_x, mv_y, add);
209
        } else {
210
            s->dsp.clear_block(s->block);
211
            if(decode_block_intra(s, s->block) < 0)
212
                return -1;
213
            idct_put(s, s->block, s->mb_x, s->mb_y, j);
214 215
        }
    }
216
    return 0;
217 218
}

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

223 224 225
    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;
226 227 228 229 230 231 232 233 234
}

static int decode_frame(AVCodecContext *avctx,
                        void *data, int *data_size,
                        AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    const uint8_t *buf_end = buf+buf_size;
235 236
    MadContext *s     = avctx->priv_data;
    int width, height;
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
    int chunk_type;
    int inter;

    if (buf_size < 17) {
        av_log(avctx, AV_LOG_ERROR, "Input buffer too small\n");
        *data_size = 0;
        return -1;
    }

    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);

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

258
    if (avctx->width != width || avctx->height != height) {
259
        if((width * height)/2048*7 > buf_end-buf)
260
            return -1;
261
        if (av_image_check_size(width, height, 0, avctx) < 0)
262
            return -1;
263 264 265
        avcodec_set_dimensions(avctx, width, height);
        if (s->frame.data[0])
            avctx->release_buffer(avctx, &s->frame);
266 267
        if (s->last_frame.data[0])
            avctx->release_buffer(avctx, &s->last_frame);
268 269
    }

270
    s->frame.reference = 3;
271 272
    if (!s->frame.data[0]) {
        if (avctx->get_buffer(avctx, &s->frame) < 0) {
273 274 275 276 277
            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
            return -1;
        }
    }

278 279
    av_fast_malloc(&s->bitstream_buf, &s->bitstream_buf_size, (buf_end-buf) + FF_INPUT_BUFFER_PADDING_SIZE);
    if (!s->bitstream_buf)
280
        return AVERROR(ENOMEM);
281
    s->dsp.bswap16_buf(s->bitstream_buf, (const uint16_t*)buf, (buf_end-buf)/2);
282
    memset((uint8_t*)s->bitstream_buf + (buf_end-buf), 0, FF_INPUT_BUFFER_PADDING_SIZE);
283
    init_get_bits(&s->gb, s->bitstream_buf, 8*(buf_end-buf));
284 285 286

    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++)
287
            if(decode_mb(s, inter) < 0)
288
                return -1;
289 290

    *data_size = sizeof(AVFrame);
291
    *(AVFrame*)data = s->frame;
292 293

    if (chunk_type != MADe_TAG)
294
        FFSWAP(AVFrame, s->frame, s->last_frame);
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309

    return buf_size;
}

static av_cold int decode_end(AVCodecContext *avctx)
{
    MadContext *t = avctx->priv_data;
    if (t->frame.data[0])
        avctx->release_buffer(avctx, &t->frame);
    if (t->last_frame.data[0])
        avctx->release_buffer(avctx, &t->last_frame);
    av_free(t->bitstream_buf);
    return 0;
}

310
AVCodec ff_eamad_decoder = {
311 312
    .name           = "eamad",
    .type           = AVMEDIA_TYPE_VIDEO,
313
    .id             = AV_CODEC_ID_MAD,
314 315 316 317 318
    .priv_data_size = sizeof(MadContext),
    .init           = decode_init,
    .close          = decode_end,
    .decode         = decode_frame,
    .capabilities   = CODEC_CAP_DR1,
319
    .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video")
320
};