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