FFmpeg: libavcodec/eamad.c Source File

FFmpeg

[フレーム]

libavcodec

eamad.c

Go to the documentation of this file.

1 /*

2 * Electronic Arts Madcow Video Decoder

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 */

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 */

31 #include "avcodec.h"

32 #include "bytestream.h"

33 #include "bswapdsp.h"

34 #include "get_bits.h"

35 #include "aandcttab.h"

36 #include "eaidct.h"

37 #include "idctdsp.h"

38 #include "internal.h"

39 #include "mpeg12.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;

50 BlockDSPContext bdsp;

51 BswapDSPContext bbdsp;

52 IDCTDSPContext idsp;

53 AVFrame *last_frame;

54 GetBitContext gb;

55 void *bitstream_buf;

56 unsigned int bitstream_buf_size;

57 DECLARE_ALIGNED(16, int16_t, block)[64];

58 ScanTable scantable;

59 uint16_t quant_matrix[64];

60 int mb_x;

61 int mb_y;

62 } MadContext;

64 static av_cold int decode_init(AVCodecContext *avctx)

65 {

66 MadContext *s = avctx->priv_data;

67 s->avctx = avctx;

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

77 if (!s->last_frame)

78 return AVERROR(ENOMEM);

80 return 0;

81 }

83 static inline void comp(unsigned char *dst, int dst_stride,

84 unsigned char *src, int src_stride, int add)

85 {

86 int j, i;

87 for (j=0; j<8; j++)

88 for (i=0; i<8; i++)

89 dst[j*dst_stride + i] = av_clip_uint8(src[j*src_stride + i] + add);

90 }

92 static inline void comp_block(MadContext *t, AVFrame *frame,

93 int mb_x, int mb_y,

94 int j, int mv_x, int mv_y, int add)

95 {

96 if (j < 4) {

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)

99 return;

100 comp(frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3),

101 frame->linesize[0],

102 t->last_frame->data[0] + offset,

103 t->last_frame->linesize[0], add);

104 } else if (!(t->avctx->flags & CODEC_FLAG_GRAY)) {

105 int index = j - 3;

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)

108 return;

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

113 }

114 }

115

116 static inline void idct_put(MadContext *t, AVFrame *frame, int16_t *block,

117 int mb_x, int mb_y, int j)

118 {

119 if (j < 4) {

120 ff_ea_idct_put_c(

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

124 int index = j - 3;

125 ff_ea_idct_put_c(

126 frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x*8,

127 frame->linesize[index], block);

128 }

129 }

130

131 static inline int decode_block_intra(MadContext *s, int16_t * block)

132 {

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;

137

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

139

140 /* The RL decoder is derived from mpeg1_decode_block_intra;

141 Escaped level and run values a decoded differently */

142 i = 0;

143 {

144 OPEN_READER(re, &s->gb);

145 /* now quantify & encode AC coefficients */

146 for (;;) {

147 UPDATE_CACHE(re, &s->gb);

148 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);

149

150 if (level == 127) {

151 break;

152 } else if (level != 0) {

153 i += run;

154 if (i > 63) {

155 av_log(s->avctx, AV_LOG_ERROR,

156 "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

157 return -1;

158 }

159 j = scantable[i];

160 level = (level*quant_matrix[j]) >> 4;

161 level = (level-1)|1;

162 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

163 LAST_SKIP_BITS(re, &s->gb, 1);

164 } else {

165 /* escape */

166 UPDATE_CACHE(re, &s->gb);

167 level = SHOW_SBITS(re, &s->gb, 10); SKIP_BITS(re, &s->gb, 10);

168

169 UPDATE_CACHE(re, &s->gb);

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

171

172 i += run;

173 if (i > 63) {

174 av_log(s->avctx, AV_LOG_ERROR,

175 "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

176 return -1;

177 }

178 j = scantable[i];

179 if (level < 0) {

180 level = -level;

181 level = (level*quant_matrix[j]) >> 4;

182 level = (level-1)|1;

183 level = -level;

184 } else {

185 level = (level*quant_matrix[j]) >> 4;

186 level = (level-1)|1;

187 }

188 }

189

190 block[j] = level;

191 }

192 CLOSE_READER(re, &s->gb);

193 }

194 return 0;

195 }

196

197 static int decode_motion(GetBitContext *gb)

198 {

199 int value = 0;

200 if (get_bits1(gb)) {

201 if (get_bits1(gb))

202 value = -17;

203 value += get_bits(gb, 4) + 1;

204 }

205 return value;

206 }

207

208 static int decode_mb(MadContext *s, AVFrame *frame, int inter)

209 {

210 int mv_map = 0;

211 int av_uninit(mv_x), av_uninit(mv_y);

212 int j;

213

214 if (inter) {

215 int v = decode210(&s->gb);

216 if (v < 2) {

217 mv_map = v ? get_bits(&s->gb, 6) : 63;

218 mv_x = decode_motion(&s->gb);

219 mv_y = decode_motion(&s->gb);

220 }

221 }

222

223 for (j=0; j<6; j++) {

224 if (mv_map & (1<<j)) { // mv_x and mv_y are guarded by mv_map

225 int add = 2*decode_motion(&s->gb);

226 if (s->last_frame->data[0])

227 comp_block(s, frame, s->mb_x, s->mb_y, j, mv_x, mv_y, add);

228 } else {

229 s->bdsp.clear_block(s->block);

230 if(decode_block_intra(s, s->block) < 0)

231 return -1;

232 idct_put(s, frame, s->block, s->mb_x, s->mb_y, j);

233 }

234 }

235 return 0;

236 }

237

238 static void calc_quant_matrix(MadContext *s, int qscale)

239 {

240 int i;

241

242 s->quant_matrix[0] = (ff_inv_aanscales[0]*ff_mpeg1_default_intra_matrix[0]) >> 11;

243 for (i=1; i<64; i++)

244 s->quant_matrix[i] = (ff_inv_aanscales[i]*ff_mpeg1_default_intra_matrix[i]*qscale + 32) >> 10;

245 }

246

247 static int decode_frame(AVCodecContext *avctx,

248 void *data, int *got_frame,

249 AVPacket *avpkt)

250 {

251 const uint8_t *buf = avpkt->data;

252 int buf_size = avpkt->size;

253 MadContext *s = avctx->priv_data;

254 AVFrame *frame = data;

255 GetByteContext gb;

256 int width, height;

257 int chunk_type;

258 int inter, ret;

259

260 bytestream2_init(&gb, buf, buf_size);

261

262 chunk_type = bytestream2_get_le32(&gb);

263 inter = (chunk_type == MADm_TAG || chunk_type == MADe_TAG);

264 bytestream2_skip(&gb, 10);

265

266 av_reduce(&avctx->framerate.den, &avctx->framerate.num,

267 bytestream2_get_le16(&gb), 1000, 1<<30);

268

269 width = bytestream2_get_le16(&gb);

270 height = bytestream2_get_le16(&gb);

271 bytestream2_skip(&gb, 1);

272 calc_quant_matrix(s, bytestream2_get_byte(&gb));

273 bytestream2_skip(&gb, 2);

274

275 if (bytestream2_get_bytes_left(&gb) < 2) {

276 av_log(avctx, AV_LOG_ERROR, "Input data too small\n");

277 return AVERROR_INVALIDDATA;

278 }

279

280 if (width < 16 || height < 16) {

281 av_log(avctx, AV_LOG_ERROR, "Dimensions too small\n");

282 return AVERROR_INVALIDDATA;

283 }

284

285 if (avctx->width != width || avctx->height != height) {

286 av_frame_unref(s->last_frame);

287 if((width * height)/2048*7 > bytestream2_get_bytes_left(&gb))

288 return AVERROR_INVALIDDATA;

289 if ((ret = ff_set_dimensions(avctx, width, height)) < 0)

290 return ret;

291 }

292

293 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

294 return ret;

295

296 if (inter && !s->last_frame->data[0]) {

297 av_log(avctx, AV_LOG_WARNING, "Missing reference frame.\n");

298 ret = ff_get_buffer(avctx, s->last_frame, AV_GET_BUFFER_FLAG_REF);

299 if (ret < 0)

300 return ret;

301 memset(s->last_frame->data[0], 0, s->last_frame->height *

302 s->last_frame->linesize[0]);

303 memset(s->last_frame->data[1], 0x80, s->last_frame->height / 2 *

304 s->last_frame->linesize[1]);

305 memset(s->last_frame->data[2], 0x80, s->last_frame->height / 2 *

306 s->last_frame->linesize[2]);

307 }

308

309 av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size,

310 bytestream2_get_bytes_left(&gb));

311 if (!s->bitstream_buf)

312 return AVERROR(ENOMEM);

313 s->bbdsp.bswap16_buf(s->bitstream_buf, (const uint16_t *)(buf + bytestream2_tell(&gb)),

314 bytestream2_get_bytes_left(&gb) / 2);

315 memset((uint8_t*)s->bitstream_buf + bytestream2_get_bytes_left(&gb), 0, FF_INPUT_BUFFER_PADDING_SIZE);

316 init_get_bits(&s->gb, s->bitstream_buf, 8*(bytestream2_get_bytes_left(&gb)));

317

318 for (s->mb_y=0; s->mb_y < (avctx->height+15)/16; s->mb_y++)

319 for (s->mb_x=0; s->mb_x < (avctx->width +15)/16; s->mb_x++)

320 if(decode_mb(s, frame, inter) < 0)

321 return AVERROR_INVALIDDATA;

322

323 *got_frame = 1;

324

325 if (chunk_type != MADe_TAG) {

326 av_frame_unref(s->last_frame);

327 if ((ret = av_frame_ref(s->last_frame, frame)) < 0)

328 return ret;

329 }

330

331 return buf_size;

332 }

333

334 static av_cold int decode_end(AVCodecContext *avctx)

335 {

336 MadContext *t = avctx->priv_data;

337 av_frame_free(&t->last_frame);

338 av_freep(&t->bitstream_buf);

339 return 0;

340 }

341

342 AVCodec ff_eamad_decoder = {

343 .name = "eamad",

344 .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video"),

345 .type = AVMEDIA_TYPE_VIDEO,

346 .id = AV_CODEC_ID_MAD,

347 .priv_data_size = sizeof(MadContext),

348 .init = decode_init,

349 .close = decode_end,

350 .decode = decode_frame,

351 .capabilities = CODEC_CAP_DR1,

352 };

Generated on Sun Mar 8 2015 02:34:51 for FFmpeg by doxygen 1.8.2