FFmpeg: libavformat/mp3dec.c Source File

FFmpeg

[フレーム]

libavformat

mp3dec.c

Go to the documentation of this file.

1 /*

2 * MP3 demuxer

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 Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include "libavutil/opt.h"

23 #include "libavutil/avstring.h"

24 #include "libavutil/intreadwrite.h"

25 #include "libavutil/crc.h"

26 #include "libavutil/dict.h"

27 #include "libavutil/mathematics.h"

28 #include "avformat.h"

29 #include "internal.h"

30 #include "avio_internal.h"

31 #include "id3v2.h"

32 #include "id3v1.h"

33 #include "replaygain.h"

35 #include "libavcodec/avcodec.h"

36 #include "libavcodec/mpegaudiodecheader.h"

38 #define XING_FLAG_FRAMES 0x01

39 #define XING_FLAG_SIZE 0x02

40 #define XING_FLAG_TOC 0x04

41 #define XING_FLAC_QSCALE 0x08

43 #define XING_TOC_COUNT 100

45 #define SAME_HEADER_MASK \

46 (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))

48 typedef struct {

49 AVClass *class;

50 int64_t filesize;

51 int xing_toc;

52 int start_pad;

53 int end_pad;

54 int usetoc;

55 unsigned frames; /* Total number of frames in file */

56 unsigned header_filesize; /* Total number of bytes in the stream */

57 int is_cbr;

58 } MP3DecContext;

60 static int check(AVIOContext *pb, int64_t pos, uint32_t *header);

62 /* mp3 read */

64 static int mp3_read_probe(AVProbeData *p)

65 {

66 int max_frames, first_frames = 0;

67 int frames, ret;

68 uint32_t header;

69 const uint8_t *buf, *buf0, *buf2, *end;

71 buf0 = p->buf;

72 end = p->buf + p->buf_size - sizeof(uint32_t);

73 while(buf0 < end && !*buf0)

74 buf0++;

76 max_frames = 0;

77 buf = buf0;

79 for(; buf < end; buf= buf2+1) {

80 buf2 = buf;

81 for(frames = 0; buf2 < end; frames++) {

82 MPADecodeHeader h;

84 header = AV_RB32(buf2);

85 ret = avpriv_mpegaudio_decode_header(&h, header);

86 if (ret != 0)

87 break;

88 buf2 += h.frame_size;

89 }

90 max_frames = FFMAX(max_frames, frames);

91 if(buf == buf0)

92 first_frames= frames;

93 }

94 // keep this in sync with ac3 probe, both need to avoid

95 // issues with MPEG-files!

96 if (first_frames>=7) return AVPROBE_SCORE_EXTENSION + 1;

97 else if(max_frames>200)return AVPROBE_SCORE_EXTENSION;

98 else if(max_frames>=4 && max_frames >= p->buf_size/10000) return AVPROBE_SCORE_EXTENSION / 2;

99 else if(ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)

100 return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;

101 else if(max_frames>=1 && max_frames >= p->buf_size/10000) return 1;

102 else return 0;

103 //mpegps_mp3_unrecognized_format.mpg has max_frames=3

104 }

105

106 static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)

107 {

108 int i;

109 MP3DecContext *mp3 = s->priv_data;

110 int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;

111 int fill_index = (mp3->usetoc || fast_seek) && duration > 0;

112

113 if (!filesize &&

114 !(filesize = avio_size(s->pb))) {

115 av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");

116 fill_index = 0;

117 }

118

119 for (i = 0; i < XING_TOC_COUNT; i++) {

120 uint8_t b = avio_r8(s->pb);

121 if (fill_index)

122 av_add_index_entry(s->streams[0],

123 av_rescale(b, filesize, 256),

124 av_rescale(i, duration, XING_TOC_COUNT),

125 0, 0, AVINDEX_KEYFRAME);

126 }

127 if (fill_index)

128 mp3->xing_toc = 1;

129 }

130

131 static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,

132 MPADecodeHeader *c, uint32_t spf)

133 {

134 #define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))

135 #define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))

136

137 uint16_t crc;

138 uint32_t v;

139

140 char version[10];

141

142 uint32_t peak = 0;

143 int32_t r_gain = INT32_MIN, a_gain = INT32_MIN;

144

145 MP3DecContext *mp3 = s->priv_data;

146 static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};

147 uint64_t fsize = avio_size(s->pb);

148 fsize = fsize >= avio_tell(s->pb) ? fsize - avio_tell(s->pb) : 0;

149

150 /* Check for Xing / Info tag */

151 avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);

152 v = avio_rb32(s->pb);

153 mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');

154 if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)

155 return;

156

157 v = avio_rb32(s->pb);

158 if (v & XING_FLAG_FRAMES)

159 mp3->frames = avio_rb32(s->pb);

160 if (v & XING_FLAG_SIZE)

161 mp3->header_filesize = avio_rb32(s->pb);

162 if (fsize && mp3->header_filesize) {

163 uint64_t min, delta;

164 min = FFMIN(fsize, mp3->header_filesize);

165 delta = FFMAX(fsize, mp3->header_filesize) - min;

166 if (fsize > mp3->header_filesize && delta > min >> 4) {

167 mp3->frames = 0;

168 av_log(s, AV_LOG_WARNING,

169 "invalid concatenated file detected - using bitrate for duration\n");

170 } else if (delta > min >> 4) {

171 av_log(s, AV_LOG_WARNING,

172 "filesize and duration do not match (growing file?)\n");

173 }

174 }

175 if (v & XING_FLAG_TOC)

176 read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,

177 (AVRational){spf, c->sample_rate},

178 st->time_base));

179 /* VBR quality */

180 if (v & XING_FLAC_QSCALE)

181 avio_rb32(s->pb);

182

183 /* Encoder short version string */

184 memset(version, 0, sizeof(version));

185 avio_read(s->pb, version, 9);

186

187 /* Info Tag revision + VBR method */

188 avio_r8(s->pb);

189

190 /* Lowpass filter value */

191 avio_r8(s->pb);

192

193 /* ReplayGain peak */

194 v = avio_rb32(s->pb);

195 peak = av_rescale(v, 100000, 1 << 23);

196

197 /* Radio ReplayGain */

198 v = avio_rb16(s->pb);

199

200 if (MIDDLE_BITS(v, 13, 15) == 1) {

201 r_gain = MIDDLE_BITS(v, 0, 8) * 10000;

202

203 if (v & (1 << 9))

204 r_gain *= -1;

205 }

206

207 /* Audiophile ReplayGain */

208 v = avio_rb16(s->pb);

209

210 if (MIDDLE_BITS(v, 13, 15) == 2) {

211 a_gain = MIDDLE_BITS(v, 0, 8) * 10000;

212

213 if (v & (1 << 9))

214 a_gain *= -1;

215 }

216

217 /* Encoding flags + ATH Type */

218 avio_r8(s->pb);

219

220 /* if ABR {specified bitrate} else {minimal bitrate} */

221 avio_r8(s->pb);

222

223 /* Encoder delays */

224 v= avio_rb24(s->pb);

225 if(AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')

226 || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')

227 || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'c')

228 ) {

229

230 mp3->start_pad = v>>12;

231 mp3-> end_pad = v&4095;

232 st->start_skip_samples = mp3->start_pad + 528 + 1;

233 if (mp3->frames) {

234 st->first_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;

235 st->last_discard_sample = mp3->frames * (int64_t)spf;

236 }

237 if (!st->start_time)

238 st->start_time = av_rescale_q(st->start_skip_samples,

239 (AVRational){1, c->sample_rate},

240 st->time_base);

241 av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3-> end_pad);

242 }

243

244 /* Misc */

245 avio_r8(s->pb);

246

247 /* MP3 gain */

248 avio_r8(s->pb);

249

250 /* Preset and surround info */

251 avio_rb16(s->pb);

252

253 /* Music length */

254 avio_rb32(s->pb);

255

256 /* Music CRC */

257 avio_rb16(s->pb);

258

259 /* Info Tag CRC */

260 crc = ffio_get_checksum(s->pb);

261 v = avio_rb16(s->pb);

262

263 if (v == crc) {

264 ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);

265 av_dict_set(&st->metadata, "encoder", version, 0);

266 }

267 }

268

269 static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)

270 {

271 uint32_t v;

272 MP3DecContext *mp3 = s->priv_data;

273

274 /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */

275 avio_seek(s->pb, base + 4 + 32, SEEK_SET);

276 v = avio_rb32(s->pb);

277 if (v == MKBETAG('V', 'B', 'R', 'I')) {

278 /* Check tag version */

279 if (avio_rb16(s->pb) == 1) {

280 /* skip delay and quality */

281 avio_skip(s->pb, 4);

282 mp3->header_filesize = avio_rb32(s->pb);

283 mp3->frames = avio_rb32(s->pb);

284 }

285 }

286 }

287

288 /**

289 * Try to find Xing/Info/VBRI tags and compute duration from info therein

290 */

291 static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)

292 {

293 uint32_t v, spf;

294 MPADecodeHeader c;

295 int vbrtag_size = 0;

296 MP3DecContext *mp3 = s->priv_data;

297 int ret;

298

299 ffio_init_checksum(s->pb, ff_crcA001_update, 0);

300

301 v = avio_rb32(s->pb);

302

303 ret = avpriv_mpegaudio_decode_header(&c, v);

304 if (ret < 0)

305 return ret;

306 else if (ret == 0)

307 vbrtag_size = c.frame_size;

308 if(c.layer != 3)

309 return -1;

310

311 spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */

312

313 mp3->frames = 0;

314 mp3->header_filesize = 0;

315

316 mp3_parse_info_tag(s, st, &c, spf);

317 mp3_parse_vbri_tag(s, st, base);

318

319 if (!mp3->frames && !mp3->header_filesize)

320 return -1;

321

322 /* Skip the vbr tag frame */

323 avio_seek(s->pb, base + vbrtag_size, SEEK_SET);

324

325 if (mp3->frames)

326 st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},

327 st->time_base);

328 if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)

329 st->codec->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);

330

331 return 0;

332 }

333

334 static int mp3_read_header(AVFormatContext *s)

335 {

336 MP3DecContext *mp3 = s->priv_data;

337 AVStream *st;

338 int64_t off;

339 int ret;

340 int i;

341

342 st = avformat_new_stream(s, NULL);

343 if (!st)

344 return AVERROR(ENOMEM);

345

346 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

347 st->codec->codec_id = AV_CODEC_ID_MP3;

348 st->need_parsing = AVSTREAM_PARSE_FULL_RAW;

349 st->start_time = 0;

350

351 // lcm of all mp3 sample rates

352 avpriv_set_pts_info(st, 64, 1, 14112000);

353

354 s->pb->maxsize = -1;

355 off = avio_tell(s->pb);

356

357 if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))

358 ff_id3v1_read(s);

359

360 if(s->pb->seekable)

361 mp3->filesize = avio_size(s->pb);

362

363 if (mp3_parse_vbr_tags(s, st, off) < 0)

364 avio_seek(s->pb, off, SEEK_SET);

365

366 ret = ff_replaygain_export(st, s->metadata);

367 if (ret < 0)

368 return ret;

369

370 off = avio_tell(s->pb);

371 for (i = 0; i < 64 * 1024; i++) {

372 uint32_t header, header2;

373 int frame_size;

374 if (!(i&1023))

375 ffio_ensure_seekback(s->pb, i + 1024 + 4);

376 frame_size = check(s->pb, off + i, &header);

377 if (frame_size > 0) {

378 avio_seek(s->pb, off, SEEK_SET);

379 ffio_ensure_seekback(s->pb, i + 1024 + frame_size + 4);

380 if (check(s->pb, off + i + frame_size, &header2) >= 0 &&

381 (header & SAME_HEADER_MASK) == (header2 & SAME_HEADER_MASK))

382 {

383 av_log(s, AV_LOG_INFO, "Skipping %d bytes of junk at %"PRId64".\n", i, off);

384 avio_seek(s->pb, off + i, SEEK_SET);

385 break;

386 }

387 }

388 avio_seek(s->pb, off, SEEK_SET);

389 }

390

391 // the seek index is relative to the end of the xing vbr headers

392 for (i = 0; i < st->nb_index_entries; i++)

393 st->index_entries[i].pos += avio_tell(s->pb);

394

395 /* the parameters will be extracted from the compressed bitstream */

396 return 0;

397 }

398

399 #define MP3_PACKET_SIZE 1024

400

401 static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)

402 {

403 MP3DecContext *mp3 = s->priv_data;

404 int ret, size;

405 int64_t pos;

406

407 size= MP3_PACKET_SIZE;

408 pos = avio_tell(s->pb);

409 if(mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)

410 size= FFMIN(size, mp3->filesize - pos);

411

412 ret= av_get_packet(s->pb, pkt, size);

413 if (ret <= 0) {

414 if(ret<0)

415 return ret;

416 return AVERROR_EOF;

417 }

418

419 pkt->flags &= ~AV_PKT_FLAG_CORRUPT;

420 pkt->stream_index = 0;

421

422 return ret;

423 }

424

425 #define SEEK_WINDOW 4096

426

427 static int check(AVIOContext *pb, int64_t pos, uint32_t *ret_header)

428 {

429 int64_t ret = avio_seek(pb, pos, SEEK_SET);

430 unsigned header;

431 MPADecodeHeader sd;

432 if (ret < 0)

433 return ret;

434

435 header = avio_rb32(pb);

436 if (ff_mpa_check_header(header) < 0)

437 return -1;

438 if (avpriv_mpegaudio_decode_header(&sd, header) == 1)

439 return -1;

440

441 if (ret_header)

442 *ret_header = header;

443 return sd.frame_size;

444 }

445

446 static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)

447 {

448 int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;

449 int64_t best_pos;

450 int best_score, i, j;

451 int64_t ret;

452

453 avio_seek(s->pb, FFMAX(target_pos - SEEK_WINDOW, 0), SEEK_SET);

454 ret = avio_seek(s->pb, target_pos, SEEK_SET);

455 if (ret < 0)

456 return ret;

457

458 #define MIN_VALID 3

459 best_pos = target_pos;

460 best_score = 999;

461 for(i=0; i<SEEK_WINDOW; i++) {

462 int64_t pos = target_pos + (dir > 0 ? i - SEEK_WINDOW/4 : -i);

463 int64_t candidate = -1;

464 int score = 999;

465

466 if (pos < 0)

467 continue;

468

469 for(j=0; j<MIN_VALID; j++) {

470 ret = check(s->pb, pos, NULL);

471 if(ret < 0)

472 break;

473 if ((target_pos - pos)*dir <= 0 && abs(MIN_VALID/2-j) < score) {

474 candidate = pos;

475 score = abs(MIN_VALID/2-j);

476 }

477 pos += ret;

478 }

479 if (best_score > score && j == MIN_VALID) {

480 best_pos = candidate;

481 best_score = score;

482 if(score == 0)

483 break;

484 }

485 }

486

487 return avio_seek(s->pb, best_pos, SEEK_SET);

488 }

489

490 static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,

491 int flags)

492 {

493 MP3DecContext *mp3 = s->priv_data;

494 AVIndexEntry *ie, ie1;

495 AVStream *st = s->streams[0];

496 int64_t best_pos;

497 int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;

498 int64_t filesize = mp3->header_filesize;

499

500 if (filesize <= 0) {

501 int64_t size = avio_size(s->pb);

502 if (size > 0 && size > s->internal->data_offset)

503 filesize = size - s->internal->data_offset;

504 }

505

506 if (mp3->xing_toc && (mp3->usetoc || (fast_seek && !mp3->is_cbr))) {

507 int64_t ret = av_index_search_timestamp(st, timestamp, flags);

508

509 // NOTE: The MP3 TOC is not a precise lookup table. Accuracy is worse

510 // for bigger files.

511 av_log(s, AV_LOG_WARNING, "Using MP3 TOC to seek; may be imprecise.\n");

512

513 if (ret < 0)

514 return ret;

515

516 ie = &st->index_entries[ret];

517 } else if (fast_seek && st->duration > 0 && filesize > 0) {

518 if (!mp3->is_cbr)

519 av_log(s, AV_LOG_WARNING, "Using scaling to seek VBR MP3; may be imprecise.\n");

520

521 ie = &ie1;

522 timestamp = av_clip64(timestamp, 0, st->duration);

523 ie->timestamp = timestamp;

524 ie->pos = av_rescale(timestamp, filesize, st->duration) + s->internal->data_offset;

525 } else {

526 return -1; // generic index code

527 }

528

529 best_pos = mp3_sync(s, ie->pos, flags);

530 if (best_pos < 0)

531 return best_pos;

532

533 if (mp3->is_cbr && ie == &ie1 && mp3->frames) {

534 int frame_duration = av_rescale(st->duration, 1, mp3->frames);

535 ie1.timestamp = frame_duration * av_rescale(best_pos - s->internal->data_offset, mp3->frames, mp3->header_filesize);

536 }

537

538 ff_update_cur_dts(s, st, ie->timestamp);

539 return 0;

540 }

541

542 static const AVOption options[] = {

543 { "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM},

544 { NULL },

545 };

546

547 static const AVClass demuxer_class = {

548 .class_name = "mp3",

549 .item_name = av_default_item_name,

550 .option = options,

551 .version = LIBAVUTIL_VERSION_INT,

552 .category = AV_CLASS_CATEGORY_DEMUXER,

553 };

554

555 AVInputFormat ff_mp3_demuxer = {

556 .name = "mp3",

557 .long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),

558 .read_probe = mp3_read_probe,

559 .read_header = mp3_read_header,

560 .read_packet = mp3_read_packet,

561 .read_seek = mp3_seek,

562 .priv_data_size = sizeof(MP3DecContext),

563 .flags = AVFMT_GENERIC_INDEX,

564 .extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */

565 .priv_class = &demuxer_class,

566 };

AVSEEK_FLAG_BACKWARD

#define AVSEEK_FLAG_BACKWARD

Definition: avformat.h:2348

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:631

AVIOContext

Bytestream IO Context.

Definition: avio.h:111

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:287

Definition: vp9dsp_template.c:2093

AVOption

AVOption.

Definition: opt.h:245

av_add_index_entry

int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)

Add an index entry into a sorted list.

Definition: utils.c:1778

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:70

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: utils.c:4149

AVIndexEntry::pos

int64_t pos

Definition: avformat.h:817

AVFormatInternal::data_offset

int64_t data_offset

offset of the first packet

Definition: internal.h:80

ff_id3v1_read

void ff_id3v1_read(AVFormatContext *s)

Read an ID3v1 tag.

Definition: id3v1.c:235

const char * b

Definition: vf_curves.c:109

ID3v2_DEFAULT_MAGIC

#define ID3v2_DEFAULT_MAGIC

Default magic bytes for ID3v2 header: "ID3".

Definition: id3v2.h:35

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:208

AVStream::index_entries

AVIndexEntry * index_entries

Only used if the format does not support seeking natively.

Definition: avformat.h:1080

AVFormatContext::internal

AVFormatInternal * internal

An opaque field for libavformat internal usage.

Definition: avformat.h:1741

read_xing_toc

static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)

Definition: mp3dec.c:106

avio_skip

int64_t avio_skip(AVIOContext *s, int64_t offset)

Skip given number of bytes forward.

Definition: aviobuf.c:282

version

int version

Definition: avisynth_c.h:629

frames

int frames

Definition: movenc-test.c:65

AVInputFormat

Definition: avformat.h:656

avstring.h

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

avio_rb16

unsigned int avio_rb16(AVIOContext *s)

Definition: aviobuf.c:683

PROBE_BUF_MAX

#define PROBE_BUF_MAX

Definition: internal.h:32

AVIOContext::maxsize

int64_t maxsize

max filesize, used to limit allocations This field is internal to libavformat and access from outside...

Definition: avio.h:213

MP3DecContext::frames

unsigned frames

Definition: mp3dec.c:55

AVFormatContext

Format I/O context.

Definition: avformat.h:1314

mathematics.h

ff_update_cur_dts

void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)

Update cur_dts of all streams based on the given timestamp and AVStream.

Definition: utils.c:1692

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

dict.h

Public dictionary API.

mp3_read_packet

static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: mp3dec.c:401

id3v1.h

uint8_t

Definition: audio_convert.c:194

MP3DecContext::usetoc

int usetoc

Definition: mp3dec.c:54

XING_FLAG_SIZE

#define XING_FLAG_SIZE

Definition: mp3dec.c:39

delta

float delta

Definition: vorbis_enc_data.h:457

opt.h

AVOptions.

avio_rb32

unsigned int avio_rb32(AVIOContext *s)

Definition: aviobuf.c:698

mp3_seek

static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

Definition: mp3dec.c:490

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

AVStream::need_parsing

enum AVStreamParseType need_parsing

Definition: avformat.h:1069

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: utils.c:3805

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:87

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1382

crc.h

avio_internal.h

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:39

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1425

avpriv_mpegaudio_decode_header

int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)

Definition: mpegaudiodecheader.c:36

xing_offtbl

static const uint8_t xing_offtbl[2][2]

Definition: mp3enc.c:124

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

av_get_packet

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)

Allocate and read the payload of a packet and initialize its fields with default values.

Definition: utils.c:252

size

ptrdiff_t size

Definition: opengl_enc.c:101

avio_tell

static av_always_inline int64_t avio_tell(AVIOContext *s)

ftell() equivalent for AVIOContext.

Definition: avio.h:442

header

static const uint8_t header[24]

Definition: sdr2.c:67

ff_replaygain_export

int ff_replaygain_export(AVStream *st, AVDictionary *metadata)

Parse replaygain tags and export them as per-stream side data.

Definition: replaygain.c:91

AVSTREAM_PARSE_FULL_RAW

full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...

Definition: avformat.h:811

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:545

MP3DecContext::filesize

int64_t filesize

Definition: mp3dec.c:50

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

AV_CLASS_CATEGORY_DEMUXER

Definition: log.h:34

AVINDEX_KEYFRAME

#define AVINDEX_KEYFRAME

Definition: avformat.h:824

AVFormatContext::metadata

AVDictionary * metadata

Metadata that applies to the whole file.

Definition: avformat.h:1528

av_index_search_timestamp

int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)

Get the index for a specific timestamp.

Definition: utils.c:1877

av_default_item_name

Definition: libopenh264enc.c:68

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVIndexEntry::timestamp

int64_t timestamp

Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...

Definition: avformat.h:818

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

mp3_read_header

static int mp3_read_header(AVFormatContext *s)

Definition: mp3dec.c:334

SAME_HEADER_MASK

#define SAME_HEADER_MASK

Definition: mp3dec.c:45

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AV_CODEC_ID_MP3

preferred ID for decoding MPEG audio layer 1, 2 or 3

Definition: avcodec.h:420

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:194

internal.h

ff_mpa_check_header

static int ff_mpa_check_header(uint32_t header)

Definition: mpegaudiodecheader.h:66

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: avcodec.h:1473

avio_r8

int avio_r8(AVIOContext *s)

Definition: aviobuf.c:536

AVStream::codec

AVCodecContext * codec

Codec context associated with this stream.

Definition: avformat.h:896

AVProbeData::buf_size

int buf_size

Size of buf except extra allocated bytes.

Definition: avformat.h:463

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:462

SEEK_WINDOW

#define SEEK_WINDOW

Definition: mp3dec.c:425

ffio_init_checksum

void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)

Definition: aviobuf.c:524

AVIOContext::seekable

int seekable

A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.

Definition: avio.h:207

avio_rb24

unsigned int avio_rb24(AVIOContext *s)

Definition: aviobuf.c:691

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

MP3_PACKET_SIZE

#define MP3_PACKET_SIZE

Definition: mp3dec.c:399

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

intreadwrite.h

check

static int check(AVIOContext *pb, int64_t pos, uint32_t *header)

Definition: mp3dec.c:427

MP3DecContext::end_pad

int end_pad

Definition: mp3dec.c:53

AVIndexEntry

Definition: avformat.h:816

mp3_parse_info_tag

static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st, MPADecodeHeader *c, uint32_t spf)

Definition: mp3dec.c:131

int32_t

Definition: audio_convert.c:194

AV_OPT_TYPE_BOOL

Definition: opt.h:239

duration

int64_t duration

Definition: movenc-test.c:63

MP3DecContext

Definition: mp3dec.c:48

mp3_sync

static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)

Definition: mp3dec.c:446

MP3DecContext::xing_toc

int xing_toc

Definition: mp3dec.c:51

ff_crcA001_update

unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf, unsigned int len)

Definition: aviobuf.c:510

mp3_parse_vbri_tag

static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)

Definition: mp3dec.c:269

MIN_VALID

#define MIN_VALID

AVStream

Stream structure.

Definition: avformat.h:877

mp3_read_probe

static int mp3_read_probe(AVProbeData *p)

Definition: mp3dec.c:64

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

MPADecodeHeader

Definition: mpegaudiodecheader.h:46

frame_size

int frame_size

Definition: mxfenc.c:1821

avcodec.h

Libavcodec external API header.

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:1540

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1549

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1356

replaygain.h

XING_FLAG_FRAMES

#define XING_FLAG_FRAMES

Definition: mp3dec.c:38

buf

void * buf

Definition: avisynth_c.h:553

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:69

AVStream::nb_index_entries

int nb_index_entries

Definition: avformat.h:1082

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

options

static const AVOption options[]

Definition: mp3dec.c:542

AVFMT_GENERIC_INDEX

#define AVFMT_GENERIC_INDEX

Use generic index building code.

Definition: avformat.h:486

AVRational

rational number numerator/denominator

Definition: rational.h:43

AV_OPT_FLAG_DECODING_PARAM

#define AV_OPT_FLAG_DECODING_PARAM

a generic parameter which can be set by the user for demuxing or decoding

Definition: opt.h:276

XING_FLAC_QSCALE

#define XING_FLAC_QSCALE

Definition: mp3dec.c:41

ffio_get_checksum

unsigned long ffio_get_checksum(AVIOContext *s)

Definition: aviobuf.c:516

AVPROBE_SCORE_EXTENSION

#define AVPROBE_SCORE_EXTENSION

score for file extension

Definition: avformat.h:470

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:460

flags

static int flags

Definition: cpu.c:47

ffio_ensure_seekback

int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)

Ensures that the requested seekback buffer size will be available.

Definition: aviobuf.c:823

AVStream::duration

int64_t duration

Decoding: duration of the stream, in stream time base.

Definition: avformat.h:936

mpegaudiodecheader.h

MPEG Audio header decoder.

MP3DecContext::is_cbr

int is_cbr

Definition: mp3dec.c:57

avformat.h

Main libavformat public API header.

MP3DecContext::header_filesize

unsigned header_filesize

Definition: mp3dec.c:56

demuxer_class

static const AVClass demuxer_class

Definition: mp3dec.c:547

ff_id3v2_match

int ff_id3v2_match(const uint8_t *buf, const char *magic)

Detect ID3v2 Header.

Definition: id3v2.c:141

ff_replaygain_export_raw

int ff_replaygain_export_raw(AVStream *st, int32_t tg, uint32_t tp, int32_t ag, uint32_t ap)

Export already decoded replaygain values as per-stream side data.

Definition: replaygain.c:70

AVStream::start_time

int64_t start_time

Decoding: pts of the first frame of the stream in presentation order, in stream time base...

Definition: avformat.h:929

ff_mp3_demuxer

AVInputFormat ff_mp3_demuxer

Definition: mp3dec.c:555

static double c[64]

Definition: vsrc_mptestsrc.c:87

AV_PKT_FLAG_CORRUPT

#define AV_PKT_FLAG_CORRUPT

The packet content is corrupted.

Definition: avcodec.h:1500

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: common.h:343

XING_FLAG_TOC

#define XING_FLAG_TOC

Definition: mp3dec.c:40

MIDDLE_BITS

#define MIDDLE_BITS(k, m, n)

AVFMT_FLAG_FAST_SEEK

#define AVFMT_FLAG_FAST_SEEK

Enable fast, but inaccurate seeks for some formats.

Definition: avformat.h:1447

ff_id3v2_tag_len

int ff_id3v2_tag_len(const uint8_t *buf)

Get the length of an ID3v2 tag.

Definition: id3v2.c:154

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1342

XING_TOC_COUNT

#define XING_TOC_COUNT

Definition: mp3dec.c:43

mp3_parse_vbr_tags

static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)

Try to find Xing/Info/VBRI tags and compute duration from info therein.

Definition: mp3dec.c:291

ID3v1_TAG_SIZE

#define ID3v1_TAG_SIZE

Definition: id3v1.h:27

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:661

AV_DICT_IGNORE_SUFFIX

#define AV_DICT_IGNORE_SUFFIX

Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.

Definition: dict.h:72

MP3DecContext::start_pad

int start_pad

Definition: mp3dec.c:52

AVPacket::stream_index

int stream_index

Definition: avcodec.h:1469

id3v2.h

min

float min

Definition: vorbis_enc_data.h:456

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

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