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 "blockdsp.h"

33 #include "bytestream.h"

34 #include "bswapdsp.h"

35 #include "get_bits.h"

36 #include "aandcttab.h"

37 #include "eaidct.h"

38 #include "idctdsp.h"

39 #include "internal.h"

40 #include "mpeg12data.h"

41 #include "mpeg12vlc.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 & AV_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 & AV_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, AV_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 = AV_CODEC_CAP_DR1,

352 };

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:3212

GetByteContext

Definition: bytestream.h:33

const char * s

Definition: avisynth_c.h:631

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:181

GET_RL_VLC

#define GET_RL_VLC

Definition: get_bits.h:708

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

blockdsp.h

BlockDSPContext::clear_block

void(* clear_block)(int16_t *block)

Definition: blockdsp.h:35

ff_eamad_decoder

AVCodec ff_eamad_decoder

Definition: eamad.c:342

MadContext::quant_matrix

uint16_t quant_matrix[64]

Definition: eamad.c:59

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:260

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

ff_mpeg12_init_vlcs

av_cold void ff_mpeg12_init_vlcs(void)

Definition: mpeg12.c:145

comp_block

static void comp_block(MadContext *t, AVFrame *frame, int mb_x, int mb_y, int j, int mv_x, int mv_y, int add)

Definition: eamad.c:92

AV_CODEC_ID_MAD

Definition: avcodec.h:236

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:209

BswapDSPContext::bswap16_buf

void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)

Definition: bswapdsp.h:26

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

MadContext::bdsp

BlockDSPContext bdsp

Definition: eamad.c:50

ScanTable

Scantable.

Definition: idctdsp.h:29

mpeg12vlc.h

MPEG1/2 VLC.

AVRational::num

int num

numerator

Definition: rational.h:44

AVPacket::size

int size

Definition: avcodec.h:1468

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem.h:53

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1752

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:119

MadContext

Definition: eamad.c:48

ScanTable::permutated

uint8_t permutated[64]

Definition: idctdsp.h:31

run

uint8_t run

Definition: svq3.c:149

AVCodec

AVCodec.

Definition: avcodec.h:3392

RLTable

RLTable.

Definition: rl.h:38

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:245

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:141

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:375

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

get_bits.h

bitstream reader API header.

FF_IDCT_PERM_NONE

Definition: idctdsp.h:36

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:762

calc_quant_matrix

static void calc_quant_matrix(MadContext *s, int qscale)

Definition: eamad.c:238

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

MadContext::avctx

AVCodecContext * avctx

Definition: eamad.c:49

MadContext::idsp

IDCTDSPContext idsp

Definition: eamad.c:52

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:173

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVERROR

#define AVERROR(e)

Definition: error.h:43

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:164

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:154

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:176

bytestream2_get_bytes_left

static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:154

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1627

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

decode_end

static av_cold int decode_end(AVCodecContext *avctx)

Definition: eamad.c:334

decode_block_intra

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

Definition: eamad.c:131

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

CLOSE_READER

#define CLOSE_READER(name, gb)

Definition: get_bits.h:144

#define SKIP_BITS(name, gb, num)

Definition: get_bits.h:188

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

ff_init_scantable_permutation

av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)

Definition: idctdsp.c:50

MadContext::scantable

ScanTable scantable

Definition: eamad.c:58

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

value

GLsizei GLboolean const GLfloat * value

Definition: opengl_enc.c:109

ff_rl_mpeg1

RLTable ff_rl_mpeg1

Definition: mpeg12data.c:166

MadContext::block

int16_t block[64]

Definition: eamad.c:57

decode_frame

static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: eamad.c:247

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:194

BlockDSPContext

Definition: blockdsp.h:34

IDCTDSPContext::idct_permutation

uint8_t idct_permutation[64]

IDCT input permutation.

Definition: idctdsp.h:94

src

#define src

Definition: vp9dsp.c:530

AVCodecContext::height

int height

Definition: avcodec.h:1711

RLTable::rl_vlc

RL_VLC_ELEM * rl_vlc[32]

decoding only

Definition: rl.h:47

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:206

decode210

static int decode210(GetBitContext *gb)

Definition: get_bits.h:599

bytestream2_tell

static av_always_inline int bytestream2_tell(GetByteContext *g)

Definition: bytestream.h:188

MadContext::gb

GetBitContext gb

Definition: eamad.c:54

MADe_TAG

#define MADe_TAG

Definition: eamad.c:46

avcodec.h

Libavcodec external API header.

idct_put

static void idct_put(MadContext *t, AVFrame *frame, int16_t *block, int mb_x, int mb_y, int j)

Definition: eamad.c:116

ff_blockdsp_init

av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)

Definition: blockdsp.c:58

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

ff_inv_aanscales

const uint16_t ff_inv_aanscales[64]

Definition: aandcttab.c:38

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

mpeg12data.h

MPEG1/2 tables.

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: utils.c:894

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:133

decode_motion

static int decode_motion(GetBitContext *gb)

Definition: eamad.c:197

BswapDSPContext

Definition: bswapdsp.h:24

buf

void * buf

Definition: avisynth_c.h:553

MadContext::mb_y

int mb_y

Definition: eamad.c:61

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:312

height

BYTE int const BYTE int int int height

Definition: avisynth_c.h:676

index

int index

Definition: gxfenc.c:89

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:418

ff_mpeg1_default_intra_matrix

const uint16_t ff_mpeg1_default_intra_matrix[256]

Definition: mpeg12data.c:30

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:98

IDCTDSPContext

Definition: idctdsp.h:51

MadContext::bbdsp

BswapDSPContext bbdsp

Definition: eamad.c:51

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:474

MADm_TAG

#define MADm_TAG

Definition: eamad.c:45

aandcttab.h

AAN (Arai, Agui and Nakajima) (I)DCT tables.

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

level

uint8_t level

Definition: svq3.c:150

ff_ea_idct_put_c

void ff_ea_idct_put_c(uint8_t *dest, int linesize, int16_t *block)

Definition: eaidct.c:80

decode

static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)

Definition: ccaption_dec.c:572

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:207

AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:63

GetBitContext

Definition: get_bits.h:54

internal.h

common internal api header.

TEX_VLC_BITS

#define TEX_VLC_BITS

Definition: dv.h:93

MadContext::bitstream_buf

void * bitstream_buf

Definition: eamad.c:55

AVRational::den

int den

denominator

Definition: rational.h:45

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Required number of additionally allocated bytes at the end of the input bitstream for decoding...

Definition: avcodec.h:635

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

float re

Definition: fft-test.c:73

ff_init_scantable

av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)

Definition: idctdsp.c:29

ff_idctdsp_init

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)

Definition: idctdsp.c:241

decode_mb

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

Definition: eamad.c:208

bswapdsp.h

MadContext::mb_x

int mb_x

Definition: eamad.c:60

av_uninit

#define av_uninit(x)

Definition: attributes.h:149

AVFrame::height

int height

Definition: frame.h:230

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

comp

static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)

Definition: eamad.c:83

MadContext::last_frame

AVFrame * last_frame

Definition: eamad.c:53

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

MadContext::bitstream_buf_size

unsigned int bitstream_buf_size

Definition: eamad.c:56

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:1241

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:856

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: eamad.c:64

width

static int width

Definition: demuxing_decoding.c:39

block

static int16_t block[64]

Definition: dct-test.c:112

Generated on Mon Feb 15 2016 15:20:37 for FFmpeg by doxygen 1.8.6