2 * Electronic Arts Madcow Video Decoder
3 * Copyright (c) 2007-2009 Peter Ross
5 * This file is part of FFmpeg.
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.
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.
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
24 * Electronic Arts Madcow Video Decoder
25 * @author Peter Ross <pross@xvid.org>
27 * @see technical details at
28 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_MAD
32 #include "bytestream.h"
35 #include "aandcttab.h"
40 #include "mpeg12data.h"
41 #include "libavutil/imgutils.h"
43 #define EA_PREAMBLE_SIZE 8
44 #define MADk_TAG MKTAG('M', 'A', 'D', 'k') /* MAD i-frame */
45 #define MADm_TAG MKTAG('M', 'A', 'D', 'm') /* MAD p-frame */
46 #define MADe_TAG MKTAG('M', 'A', 'D', 'e') /* MAD lqp-frame */
48 typedef struct MadContext
{
49 AVCodecContext
*avctx
;
51 BswapDSPContext bbdsp
;
56 unsigned int bitstream_buf_size
;
57 DECLARE_ALIGNED(16, int16_t, block
)[64];
59 uint16_t quant_matrix
[64];
64 static av_cold
int decode_init(AVCodecContext
*avctx
)
66 MadContext
*s
= avctx
->priv_data
;
68 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
69 ff_blockdsp_init(&s
->bdsp
, avctx
);
70 ff_bswapdsp_init(&s
->bbdsp
);
71 ff_idctdsp_init(&s
->idsp
, avctx
);
72 ff_init_scantable_permutation(s
->idsp
.idct_permutation
, FF_IDCT_PERM_NONE
);
73 ff_init_scantable(s
->idsp
.idct_permutation
, &s
->scantable
, ff_zigzag_direct
);
74 ff_mpeg12_init_vlcs();
76 s
->last_frame
= av_frame_alloc();
78 return AVERROR(ENOMEM
);
83 static inline void comp(unsigned char *dst
, int dst_stride
,
84 unsigned char *src
, int src_stride
, int add
)
89 dst
[j
*dst_stride
+ i
] = av_clip_uint8(src
[j
*src_stride
+ i
] + add
);
92 static inline void comp_block(MadContext
*t
, AVFrame
*frame
,
94 int j
, int mv_x
, int mv_y
, int add
)
97 unsigned offset
= (mb_y
*16 + ((j
&2)<<2) + mv_y
)*t
->last_frame
->linesize
[0] + mb_x
*16 + ((j
&1)<<3) + mv_x
;
98 if (offset
>= (t
->avctx
->height
- 7) * t
->last_frame
->linesize
[0] - 7)
100 comp(frame
->data
[0] + (mb_y
*16 + ((j
&2)<<2))*frame
->linesize
[0] + mb_x
*16 + ((j
&1)<<3),
102 t
->last_frame
->data
[0] + offset
,
103 t
->last_frame
->linesize
[0], add
);
104 } else if (!(t
->avctx
->flags
& CODEC_FLAG_GRAY
)) {
106 unsigned offset
= (mb_y
* 8 + (mv_y
/2))*t
->last_frame
->linesize
[index
] + mb_x
* 8 + (mv_x
/2);
107 if (offset
>= (t
->avctx
->height
/2 - 7) * t
->last_frame
->linesize
[index
] - 7)
109 comp(frame
->data
[index
] + (mb_y
*8)*frame
->linesize
[index
] + mb_x
* 8,
110 frame
->linesize
[index
],
111 t
->last_frame
->data
[index
] + offset
,
112 t
->last_frame
->linesize
[index
], add
);
116 static inline void idct_put(MadContext
*t
, AVFrame
*frame
, int16_t *block
,
117 int mb_x
, int mb_y
, int j
)
121 frame
->data
[0] + (mb_y
*16 + ((j
&2)<<2))*frame
->linesize
[0] + mb_x
*16 + ((j
&1)<<3),
122 frame
->linesize
[0], block
);
123 } else if (!(t
->avctx
->flags
& CODEC_FLAG_GRAY
)) {
126 frame
->data
[index
] + (mb_y
*8)*frame
->linesize
[index
] + mb_x
*8,
127 frame
->linesize
[index
], block
);
131 static inline int decode_block_intra(MadContext
*s
, int16_t * block
)
133 int level
, i
, j
, run
;
134 RLTable
*rl
= &ff_rl_mpeg1
;
135 const uint8_t *scantable
= s
->scantable
.permutated
;
136 int16_t *quant_matrix
= s
->quant_matrix
;
138 block
[0] = (128 + get_sbits(&s
->gb
, 8)) * quant_matrix
[0];
140 /* The RL decoder is derived from mpeg1_decode_block_intra;
141 Escaped level and run values a decoded differently */
144 OPEN_READER(re
, &s
->gb
);
145 /* now quantify & encode AC coefficients */
147 UPDATE_CACHE(re
, &s
->gb
);
148 GET_RL_VLC(level
, run
, re
, &s
->gb
, rl
->rl_vlc
[0], TEX_VLC_BITS
, 2, 0);
152 } else if (level
!= 0) {
155 level
= (level
*quant_matrix
[j
]) >> 4;
157 level
= (level
^ SHOW_SBITS(re
, &s
->gb
, 1)) - SHOW_SBITS(re
, &s
->gb
, 1);
158 LAST_SKIP_BITS(re
, &s
->gb
, 1);
161 UPDATE_CACHE(re
, &s
->gb
);
162 level
= SHOW_SBITS(re
, &s
->gb
, 10); SKIP_BITS(re
, &s
->gb
, 10);
164 UPDATE_CACHE(re
, &s
->gb
);
165 run
= SHOW_UBITS(re
, &s
->gb
, 6)+1; LAST_SKIP_BITS(re
, &s
->gb
, 6);
171 level
= (level
*quant_matrix
[j
]) >> 4;
175 level
= (level
*quant_matrix
[j
]) >> 4;
180 av_log(s
->avctx
, AV_LOG_ERROR
, "ac-tex damaged at %d %d\n", s
->mb_x
, s
->mb_y
);
186 CLOSE_READER(re
, &s
->gb
);
191 static int decode_motion(GetBitContext
*gb
)
197 value
+= get_bits(gb
, 4) + 1;
202 static int decode_mb(MadContext
*s
, AVFrame
*frame
, int inter
)
205 int av_uninit(mv_x
), av_uninit(mv_y
);
209 int v
= decode210(&s
->gb
);
211 mv_map
= v
? get_bits(&s
->gb
, 6) : 63;
212 mv_x
= decode_motion(&s
->gb
);
213 mv_y
= decode_motion(&s
->gb
);
217 for (j
=0; j
<6; j
++) {
218 if (mv_map
& (1<<j
)) { // mv_x and mv_y are guarded by mv_map
219 int add
= 2*decode_motion(&s
->gb
);
220 if (s
->last_frame
->data
[0])
221 comp_block(s
, frame
, s
->mb_x
, s
->mb_y
, j
, mv_x
, mv_y
, add
);
223 s
->bdsp
.clear_block(s
->block
);
224 if(decode_block_intra(s
, s
->block
) < 0)
226 idct_put(s
, frame
, s
->block
, s
->mb_x
, s
->mb_y
, j
);
232 static void calc_quant_matrix(MadContext
*s
, int qscale
)
236 s
->quant_matrix
[0] = (ff_inv_aanscales
[0]*ff_mpeg1_default_intra_matrix
[0]) >> 11;
238 s
->quant_matrix
[i
] = (ff_inv_aanscales
[i
]*ff_mpeg1_default_intra_matrix
[i
]*qscale
+ 32) >> 10;
241 static int decode_frame(AVCodecContext
*avctx
,
242 void *data
, int *got_frame
,
245 const uint8_t *buf
= avpkt
->data
;
246 int buf_size
= avpkt
->size
;
247 MadContext
*s
= avctx
->priv_data
;
248 AVFrame
*frame
= data
;
254 bytestream2_init(&gb
, buf
, buf_size
);
256 chunk_type
= bytestream2_get_le32(&gb
);
257 inter
= (chunk_type
== MADm_TAG
|| chunk_type
== MADe_TAG
);
258 bytestream2_skip(&gb
, 10);
260 av_reduce(&avctx
->framerate
.den
, &avctx
->framerate
.num
,
261 bytestream2_get_le16(&gb
), 1000, 1<<30);
263 width
= bytestream2_get_le16(&gb
);
264 height
= bytestream2_get_le16(&gb
);
265 bytestream2_skip(&gb
, 1);
266 calc_quant_matrix(s
, bytestream2_get_byte(&gb
));
267 bytestream2_skip(&gb
, 2);
269 if (bytestream2_get_bytes_left(&gb
) < 2) {
270 av_log(avctx
, AV_LOG_ERROR
, "Input data too small\n");
271 return AVERROR_INVALIDDATA
;
274 if (width
< 16 || height
< 16) {
275 av_log(avctx
, AV_LOG_ERROR
, "Dimensions too small\n");
276 return AVERROR_INVALIDDATA
;
279 if (avctx
->width
!= width
|| avctx
->height
!= height
) {
280 av_frame_unref(s
->last_frame
);
281 if((width
* height
)/2048*7 > bytestream2_get_bytes_left(&gb
))
282 return AVERROR_INVALIDDATA
;
283 if ((ret
= ff_set_dimensions(avctx
, width
, height
)) < 0)
287 if ((ret
= ff_get_buffer(avctx
, frame
, AV_GET_BUFFER_FLAG_REF
)) < 0)
290 if (inter
&& !s
->last_frame
->data
[0]) {
291 av_log(avctx
, AV_LOG_WARNING
, "Missing reference frame.\n");
292 ret
= ff_get_buffer(avctx
, s
->last_frame
, AV_GET_BUFFER_FLAG_REF
);
295 memset(s
->last_frame
->data
[0], 0, s
->last_frame
->height
*
296 s
->last_frame
->linesize
[0]);
297 memset(s
->last_frame
->data
[1], 0x80, s
->last_frame
->height
/ 2 *
298 s
->last_frame
->linesize
[1]);
299 memset(s
->last_frame
->data
[2], 0x80, s
->last_frame
->height
/ 2 *
300 s
->last_frame
->linesize
[2]);
303 av_fast_padded_malloc(&s
->bitstream_buf
, &s
->bitstream_buf_size
,
304 bytestream2_get_bytes_left(&gb
));
305 if (!s
->bitstream_buf
)
306 return AVERROR(ENOMEM
);
307 s
->bbdsp
.bswap16_buf(s
->bitstream_buf
, (const uint16_t *)(buf
+ bytestream2_tell(&gb
)),
308 bytestream2_get_bytes_left(&gb
) / 2);
309 memset((uint8_t*)s
->bitstream_buf
+ bytestream2_get_bytes_left(&gb
), 0, FF_INPUT_BUFFER_PADDING_SIZE
);
310 init_get_bits(&s
->gb
, s
->bitstream_buf
, 8*(bytestream2_get_bytes_left(&gb
)));
312 for (s
->mb_y
=0; s
->mb_y
< (avctx
->height
+15)/16; s
->mb_y
++)
313 for (s
->mb_x
=0; s
->mb_x
< (avctx
->width
+15)/16; s
->mb_x
++)
314 if(decode_mb(s
, frame
, inter
) < 0)
315 return AVERROR_INVALIDDATA
;
319 if (chunk_type
!= MADe_TAG
) {
320 av_frame_unref(s
->last_frame
);
321 if ((ret
= av_frame_ref(s
->last_frame
, frame
)) < 0)
328 static av_cold
int decode_end(AVCodecContext
*avctx
)
330 MadContext
*t
= avctx
->priv_data
;
331 av_frame_free(&t
->last_frame
);
332 av_freep(&t
->bitstream_buf
);
336 AVCodec ff_eamad_decoder
= {
338 .long_name
= NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video"),
339 .type
= AVMEDIA_TYPE_VIDEO
,
340 .id
= AV_CODEC_ID_MAD
,
341 .priv_data_size
= sizeof(MadContext
),
344 .decode
= decode_frame
,
345 .capabilities
= CODEC_CAP_DR1
,