1/* 2 * Electronic Arts Madcow Video Decoder 3 * Copyright (c) 2007-2009 Peter Ross 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 St, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file 24 * Electronic Arts Madcow Video Decoder 25 * @author Peter Ross <pross@xvid.org> 26 * 27 * @see technical details at 28 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_MAD 29 */ 30 31#include "avcodec.h" 32#include "bswapdsp.h" 33#include "get_bits.h" 34#include "aandcttab.h" 35#include "eaidct.h" 36#include "idctdsp.h" 37#include "internal.h" 38#include "mpeg12.h" 39#include "mpeg12data.h" 40#include "libavutil/imgutils.h" 41 42#define EA_PREAMBLE_SIZE 8 43#define MADk_TAG MKTAG('M', 'A', 'D', 'k') /* MAD i-frame */ 44#define MADm_TAG MKTAG('M', 'A', 'D', 'm') /* MAD p-frame */ 45#define MADe_TAG MKTAG('M', 'A', 'D', 'e') /* MAD lqp-frame */ 46 47typedef struct MadContext { 48 AVCodecContext *avctx; 49 BlockDSPContext bdsp; 50 BswapDSPContext bbdsp; 51 IDCTDSPContext idsp; 52 AVFrame *last_frame; 53 GetBitContext gb; 54 void *bitstream_buf; 55 unsigned int bitstream_buf_size; 56 DECLARE_ALIGNED(16, int16_t, block)[64]; 57 ScanTable scantable; 58 uint16_t quant_matrix[64]; 59 int mb_x; 60 int mb_y; 61} MadContext; 62 63static av_cold int decode_init(AVCodecContext *avctx) 64{ 65 MadContext *s = avctx->priv_data; 66 s->avctx = avctx; 67 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 68 ff_blockdsp_init(&s->bdsp, avctx); 69 ff_bswapdsp_init(&s->bbdsp); 70 ff_idctdsp_init(&s->idsp, avctx); 71 ff_init_scantable_permutation(s->idsp.idct_permutation, FF_NO_IDCT_PERM); 72 ff_init_scantable(s->idsp.idct_permutation, &s->scantable, ff_zigzag_direct); 73 ff_mpeg12_init_vlcs(); 74 75 s->last_frame = av_frame_alloc(); 76 if (!s->last_frame) 77 return AVERROR(ENOMEM); 78 79 return 0; 80} 81 82static inline void comp(unsigned char *dst, int dst_stride, 83 unsigned char *src, int src_stride, int add) 84{ 85 int j, i; 86 for (j=0; j<8; j++) 87 for (i=0; i<8; i++) 88 dst[j*dst_stride + i] = av_clip_uint8(src[j*src_stride + i] + add); 89} 90 91static inline void comp_block(MadContext *t, AVFrame *frame, 92 int mb_x, int mb_y, 93 int j, int mv_x, int mv_y, int add) 94{ 95 if (j < 4) { 96 unsigned offset = (mb_y*16 + ((j&2)<<2) + mv_y)*t->last_frame->linesize[0] + mb_x*16 + ((j&1)<<3) + mv_x; 97 if (offset >= (t->avctx->height - 7) * t->last_frame->linesize[0] - 7) 98 return; 99 comp(frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3), 100 frame->linesize[0], 101 t->last_frame->data[0] + offset, 102 t->last_frame->linesize[0], add); 103 } else if (!(t->avctx->flags & CODEC_FLAG_GRAY)) { 104 int index = j - 3; 105 unsigned offset = (mb_y * 8 + (mv_y/2))*t->last_frame->linesize[index] + mb_x * 8 + (mv_x/2); 106 if (offset >= (t->avctx->height/2 - 7) * t->last_frame->linesize[index] - 7) 107 return; 108 comp(frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x * 8, 109 frame->linesize[index], 110 t->last_frame->data[index] + offset, 111 t->last_frame->linesize[index], add); 112 } 113} 114 115static inline void idct_put(MadContext *t, AVFrame *frame, int16_t *block, 116 int mb_x, int mb_y, int j) 117{ 118 if (j < 4) { 119 ff_ea_idct_put_c( 120 frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3), 121 frame->linesize[0], block); 122 } else if (!(t->avctx->flags & CODEC_FLAG_GRAY)) { 123 int index = j - 3; 124 ff_ea_idct_put_c( 125 frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x*8, 126 frame->linesize[index], block); 127 } 128} 129 130static inline int decode_block_intra(MadContext *s, int16_t * block) 131{ 132 int level, i, j, run; 133 RLTable *rl = &ff_rl_mpeg1; 134 const uint8_t *scantable = s->scantable.permutated; 135 int16_t *quant_matrix = s->quant_matrix; 136 137 block[0] = (128 + get_sbits(&s->gb, 8)) * quant_matrix[0]; 138 139 /* The RL decoder is derived from mpeg1_decode_block_intra; 140 Escaped level and run values a decoded differently */ 141 i = 0; 142 { 143 OPEN_READER(re, &s->gb); 144 /* now quantify & encode AC coefficients */ 145 for (;;) { 146 UPDATE_CACHE(re, &s->gb); 147 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0); 148 149 if (level == 127) { 150 break; 151 } else if (level != 0) { 152 i += run; 153 j = scantable[i]; 154 level = (level*quant_matrix[j]) >> 4; 155 level = (level-1)|1; 156 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 157 LAST_SKIP_BITS(re, &s->gb, 1); 158 } else { 159 /* escape */ 160 UPDATE_CACHE(re, &s->gb); 161 level = SHOW_SBITS(re, &s->gb, 10); SKIP_BITS(re, &s->gb, 10); 162 163 UPDATE_CACHE(re, &s->gb); 164 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6); 165 166 i += run; 167 j = scantable[i]; 168 if (level < 0) { 169 level = -level; 170 level = (level*quant_matrix[j]) >> 4; 171 level = (level-1)|1; 172 level = -level; 173 } else { 174 level = (level*quant_matrix[j]) >> 4; 175 level = (level-1)|1; 176 } 177 } 178 if (i > 63) { 179 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 180 return -1; 181 } 182 183 block[j] = level; 184 } 185 CLOSE_READER(re, &s->gb); 186 } 187 return 0; 188} 189 190static int decode_motion(GetBitContext *gb) 191{ 192 int value = 0; 193 if (get_bits1(gb)) { 194 if (get_bits1(gb)) 195 value = -17; 196 value += get_bits(gb, 4) + 1; 197 } 198 return value; 199} 200 201static int decode_mb(MadContext *s, AVFrame *frame, int inter) 202{ 203 int mv_map = 0; 204 int av_uninit(mv_x), av_uninit(mv_y); 205 int j; 206 207 if (inter) { 208 int v = decode210(&s->gb); 209 if (v < 2) { 210 mv_map = v ? get_bits(&s->gb, 6) : 63; 211 mv_x = decode_motion(&s->gb); 212 mv_y = decode_motion(&s->gb); 213 } 214 } 215 216 for (j=0; j<6; j++) { 217 if (mv_map & (1<<j)) { // mv_x and mv_y are guarded by mv_map 218 int add = 2*decode_motion(&s->gb); 219 if (s->last_frame->data[0]) 220 comp_block(s, frame, s->mb_x, s->mb_y, j, mv_x, mv_y, add); 221 } else { 222 s->bdsp.clear_block(s->block); 223 if(decode_block_intra(s, s->block) < 0) 224 return -1; 225 idct_put(s, frame, s->block, s->mb_x, s->mb_y, j); 226 } 227 } 228 return 0; 229} 230 231static void calc_quant_matrix(MadContext *s, int qscale) 232{ 233 int i; 234 235 s->quant_matrix[0] = (ff_inv_aanscales[0]*ff_mpeg1_default_intra_matrix[0]) >> 11; 236 for (i=1; i<64; i++) 237 s->quant_matrix[i] = (ff_inv_aanscales[i]*ff_mpeg1_default_intra_matrix[i]*qscale + 32) >> 10; 238} 239 240static int decode_frame(AVCodecContext *avctx, 241 void *data, int *got_frame, 242 AVPacket *avpkt) 243{ 244 const uint8_t *buf = avpkt->data; 245 int buf_size = avpkt->size; 246 const uint8_t *buf_end = buf+buf_size; 247 MadContext *s = avctx->priv_data; 248 AVFrame *frame = data; 249 int width, height; 250 int chunk_type; 251 int inter, ret; 252 253 if (buf_size < 26) { 254 av_log(avctx, AV_LOG_ERROR, "Input buffer too small\n"); 255 *got_frame = 0; 256 return AVERROR_INVALIDDATA; 257 } 258 259 chunk_type = AV_RL32(&buf[0]); 260 inter = (chunk_type == MADm_TAG || chunk_type == MADe_TAG); 261 buf += 8; 262 263 av_reduce(&avctx->time_base.num, &avctx->time_base.den, 264 AV_RL16(&buf[6]), 1000, 1<<30); 265 266 width = AV_RL16(&buf[8]); 267 height = AV_RL16(&buf[10]); 268 calc_quant_matrix(s, buf[13]); 269 buf += 16; 270 271 if (width < 16 || height < 16) { 272 av_log(avctx, AV_LOG_ERROR, "Dimensions too small\n"); 273 return AVERROR_INVALIDDATA; 274 } 275 276 if (avctx->width != width || avctx->height != height) { 277 av_frame_unref(s->last_frame); 278 if((width * height)/2048*7 > buf_end-buf) 279 return AVERROR_INVALIDDATA; 280 if ((ret = ff_set_dimensions(avctx, width, height)) < 0) 281 return ret; 282 } 283 284 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0) 285 return ret; 286 287 if (inter && !s->last_frame->data[0]) { 288 av_log(avctx, AV_LOG_WARNING, "Missing reference frame.\n"); 289 ret = ff_get_buffer(avctx, s->last_frame, AV_GET_BUFFER_FLAG_REF); 290 if (ret < 0) 291 return ret; 292 memset(s->last_frame->data[0], 0, s->last_frame->height * 293 s->last_frame->linesize[0]); 294 memset(s->last_frame->data[1], 0x80, s->last_frame->height / 2 * 295 s->last_frame->linesize[1]); 296 memset(s->last_frame->data[2], 0x80, s->last_frame->height / 2 * 297 s->last_frame->linesize[2]); 298 } 299 300 av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size, 301 buf_end - buf); 302 if (!s->bitstream_buf) 303 return AVERROR(ENOMEM); 304 s->bbdsp.bswap16_buf(s->bitstream_buf, (const uint16_t *) buf, 305 (buf_end - buf) / 2); 306 memset((uint8_t*)s->bitstream_buf + (buf_end-buf), 0, FF_INPUT_BUFFER_PADDING_SIZE); 307 init_get_bits(&s->gb, s->bitstream_buf, 8*(buf_end-buf)); 308 309 for (s->mb_y=0; s->mb_y < (avctx->height+15)/16; s->mb_y++) 310 for (s->mb_x=0; s->mb_x < (avctx->width +15)/16; s->mb_x++) 311 if(decode_mb(s, frame, inter) < 0) 312 return AVERROR_INVALIDDATA; 313 314 *got_frame = 1; 315 316 if (chunk_type != MADe_TAG) { 317 av_frame_unref(s->last_frame); 318 if ((ret = av_frame_ref(s->last_frame, frame)) < 0) 319 return ret; 320 } 321 322 return buf_size; 323} 324 325static av_cold int decode_end(AVCodecContext *avctx) 326{ 327 MadContext *t = avctx->priv_data; 328 av_frame_free(&t->last_frame); 329 av_free(t->bitstream_buf); 330 return 0; 331} 332 333AVCodec ff_eamad_decoder = { 334 .name = "eamad", 335 .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video"), 336 .type = AVMEDIA_TYPE_VIDEO, 337 .id = AV_CODEC_ID_MAD, 338 .priv_data_size = sizeof(MadContext), 339 .init = decode_init, 340 .close = decode_end, 341 .decode = decode_frame, 342 .capabilities = CODEC_CAP_DR1, 343}; 344