Libav
mp3dec.c
Go to the documentation of this file.
1 /*
2  * MP3 demuxer
3  * Copyright (c) 2003 Fabrice Bellard
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 Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avstring.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/mathematics.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "id3v2.h"
29 #include "id3v1.h"
31 
32 #define XING_FLAG_FRAMES 0x01
33 #define XING_FLAG_SIZE 0x02
34 #define XING_FLAG_TOC 0x04
35 
36 #define XING_TOC_COUNT 100
37 
38 typedef struct MP3DecContext {
39  int xing_toc;
41 
42 /* mp3 read */
43 
45 {
46  int max_frames, first_frames = 0;
47  int fsize, frames, sample_rate;
48  uint32_t header;
49  uint8_t *buf, *buf0, *buf2, *end;
50  AVCodecContext avctx;
51 
52  buf0 = p->buf;
53  end = p->buf + p->buf_size - sizeof(uint32_t);
54  while(buf0 < end && !*buf0)
55  buf0++;
56 
57  max_frames = 0;
58  buf = buf0;
59 
60  for(; buf < end; buf= buf2+1) {
61  buf2 = buf;
62 
63  for(frames = 0; buf2 < end; frames++) {
64  header = AV_RB32(buf2);
65  fsize = avpriv_mpa_decode_header(&avctx, header, &sample_rate, &sample_rate, &sample_rate, &sample_rate);
66  if(fsize < 0)
67  break;
68  buf2 += fsize;
69  }
70  max_frames = FFMAX(max_frames, frames);
71  if(buf == buf0)
72  first_frames= frames;
73  }
74  // keep this in sync with ac3 probe, both need to avoid
75  // issues with MPEG-files!
76  if (first_frames >= 4) return AVPROBE_SCORE_EXTENSION + 1;
77 
78  if (max_frames) {
79  int pes = 0, i;
80  unsigned int code = -1;
81 
82 #define VIDEO_ID 0x000001e0
83 #define AUDIO_ID 0x000001c0
84  /* do a search for mpegps headers to be able to properly bias
85  * towards mpegps if we detect this stream as both. */
86  for (i = 0; i<p->buf_size; i++) {
87  code = (code << 8) + p->buf[i];
88  if ((code & 0xffffff00) == 0x100) {
89  if ((code & 0x1f0) == VIDEO_ID) pes++;
90  else if((code & 0x1e0) == AUDIO_ID) pes++;
91  }
92  }
93 
94  if (pes)
95  max_frames = (max_frames + pes - 1) / pes;
96  }
97  if (max_frames > 500) return AVPROBE_SCORE_EXTENSION;
98  else if (max_frames >= 4) return AVPROBE_SCORE_EXTENSION / 2;
99  else if (max_frames >= 1) return 1;
100  else return 0;
101 //mpegps_mp3_unrecognized_format.mpg has max_frames=3
102 }
103 
104 static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
105 {
106  int i;
107  MP3DecContext *mp3 = s->priv_data;
108 
109  if (!filesize &&
110  !(filesize = avio_size(s->pb))) {
111  av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
112  return;
113  }
114 
115  for (i = 0; i < XING_TOC_COUNT; i++) {
116  uint8_t b = avio_r8(s->pb);
117 
119  av_rescale(b, filesize, 256),
120  av_rescale(i, duration, XING_TOC_COUNT),
121  0, 0, AVINDEX_KEYFRAME);
122  }
123  mp3->xing_toc = 1;
124 }
125 
129 static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
130 {
131  uint32_t v, spf;
132  unsigned frames = 0; /* Total number of frames in file */
133  unsigned size = 0; /* Total number of bytes in the stream */
134  const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
135  MPADecodeHeader c;
136  int vbrtag_size = 0;
137  int is_cbr;
138 
139  v = avio_rb32(s->pb);
140  if(ff_mpa_check_header(v) < 0)
141  return -1;
142 
143  if (avpriv_mpegaudio_decode_header(&c, v) == 0)
144  vbrtag_size = c.frame_size;
145  if(c.layer != 3)
146  return -1;
147 
148  spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
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  is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
154  if (v == MKBETAG('X', 'i', 'n', 'g') || is_cbr) {
155  v = avio_rb32(s->pb);
156  if(v & XING_FLAG_FRAMES)
157  frames = avio_rb32(s->pb);
158  if(v & XING_FLAG_SIZE)
159  size = avio_rb32(s->pb);
160  if (v & XING_FLAG_TOC && frames)
161  read_xing_toc(s, size, av_rescale_q(frames, (AVRational){spf, c.sample_rate},
162  st->time_base));
163  }
164 
165  /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
166  avio_seek(s->pb, base + 4 + 32, SEEK_SET);
167  v = avio_rb32(s->pb);
168  if(v == MKBETAG('V', 'B', 'R', 'I')) {
169  /* Check tag version */
170  if(avio_rb16(s->pb) == 1) {
171  /* skip delay and quality */
172  avio_skip(s->pb, 4);
173  size = avio_rb32(s->pb);
174  frames = avio_rb32(s->pb);
175  }
176  }
177 
178  if(!frames && !size)
179  return -1;
180 
181  /* Skip the vbr tag frame */
182  avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
183 
184  if(frames)
185  st->duration = av_rescale_q(frames, (AVRational){spf, c.sample_rate},
186  st->time_base);
187  if (size && frames && !is_cbr)
188  st->codec->bit_rate = av_rescale(size, 8 * c.sample_rate, frames * (int64_t)spf);
189 
190  return 0;
191 }
192 
194 {
195  AVStream *st;
196  int64_t off;
197 
198  st = avformat_new_stream(s, NULL);
199  if (!st)
200  return AVERROR(ENOMEM);
201 
205  st->start_time = 0;
206 
207  // lcm of all mp3 sample rates
208  avpriv_set_pts_info(st, 64, 1, 14112000);
209 
210  off = avio_tell(s->pb);
211 
213  ff_id3v1_read(s);
214 
215  if (mp3_parse_vbr_tags(s, st, off) < 0)
216  avio_seek(s->pb, off, SEEK_SET);
217 
218  /* the parameters will be extracted from the compressed bitstream */
219  return 0;
220 }
221 
222 #define MP3_PACKET_SIZE 1024
223 
225 {
226  int ret;
227 
228  ret = av_get_packet(s->pb, pkt, MP3_PACKET_SIZE);
229  if (ret < 0)
230  return ret;
231 
232  pkt->stream_index = 0;
233 
234  if (ret > ID3v1_TAG_SIZE &&
235  memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0)
236  ret -= ID3v1_TAG_SIZE;
237 
238  /* note: we need to modify the packet size here to handle the last
239  packet */
240  pkt->size = ret;
241  return ret;
242 }
243 
244 static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
245  int flags)
246 {
247  MP3DecContext *mp3 = s->priv_data;
248  AVIndexEntry *ie;
249  AVStream *st = s->streams[0];
250  int64_t ret = av_index_search_timestamp(st, timestamp, flags);
251  uint32_t header = 0;
252 
253  if (!mp3->xing_toc)
254  return AVERROR(ENOSYS);
255 
256  if (ret < 0)
257  return ret;
258 
259  ie = &st->index_entries[ret];
260  ret = avio_seek(s->pb, ie->pos, SEEK_SET);
261  if (ret < 0)
262  return ret;
263 
264  while (!s->pb->eof_reached) {
265  header = (header << 8) + avio_r8(s->pb);
266  if (ff_mpa_check_header(header) >= 0) {
267  ff_update_cur_dts(s, st, ie->timestamp);
268  ret = avio_seek(s->pb, -4, SEEK_CUR);
269  return (ret >= 0) ? 0 : ret;
270  }
271  }
272 
273  return AVERROR_EOF;
274 }
275 
277  .name = "mp3",
278  .long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
279  .read_probe = mp3_read_probe,
280  .read_header = mp3_read_header,
281  .read_packet = mp3_read_packet,
282  .read_seek = mp3_seek,
283  .priv_data_size = sizeof(MP3DecContext),
285  .extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */
286 };
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:241
int size
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:1312
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
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:3208
int64_t pos
Definition: avformat.h:644
void ff_id3v1_read(AVFormatContext *s)
Read an ID3v1 tag.
Definition: id3v1.c:227
int size
Definition: avcodec.h:974
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:186
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:827
static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
Definition: mp3dec.c:104
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:574
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
static int64_t duration
Definition: avplay.c:246
Format I/O context.
Definition: avformat.h:871
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:1235
Public dictionary API.
static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3dec.c:224
uint8_t
#define XING_FLAG_SIZE
Definition: mp3dec.c:33
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:589
static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: mp3dec.c:244
#define AV_RB32
Definition: intreadwrite.h:130
enum AVStreamParseType need_parsing
Definition: avformat.h:816
#define b
Definition: input.c:52
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:935
uint8_t * data
Definition: avcodec.h:973
int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
static int flags
Definition: log.c:44
static const uint8_t xing_offtbl[2][2]
Definition: mp3enc.c:109
#define AVERROR_EOF
End of file.
Definition: error.h:51
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:118
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:219
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:122
#define VIDEO_ID
#define AVINDEX_KEYFRAME
Definition: avformat.h:646
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1064
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:1353
#define AVERROR(e)
Definition: error.h:43
int64_t timestamp
Definition: avformat.h:645
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
static int mp3_read_header(AVFormatContext *s)
Definition: mp3dec.c:193
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:369
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2662
static int ff_mpa_check_header(uint32_t header)
#define FFMAX(a, b)
Definition: common.h:55
int off
Definition: dsputil_bfin.c:29
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:437
int avpriv_mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bit_rate)
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:702
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:391
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:390
int bit_rate
the average bitrate
Definition: avcodec.h:1112
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:110
#define MP3_PACKET_SIZE
Definition: mp3dec.c:222
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: avio.h:210
int xing_toc
Definition: mp3dec.c:39
if(ac->has_optimized_func)
Stream structure.
Definition: avformat.h:683
static int mp3_read_probe(AVProbeData *p)
Definition: mp3dec.c:44
NULL
Definition: eval.c:55
enum AVMediaType codec_type
Definition: avcodec.h:1062
enum AVCodecID codec_id
Definition: avcodec.h:1065
AVIOContext * pb
I/O context.
Definition: avformat.h:913
main external API structure.
Definition: avcodec.h:1054
#define XING_FLAG_FRAMES
Definition: mp3dec.c:32
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:408
rational number numerator/denominator
Definition: rational.h:43
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:394
This structure contains the data a format has to probe a file.
Definition: avformat.h:388
#define AUDIO_ID
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:734
MPEG Audio header decoder.
full parsing and repack
Definition: avformat.h:637
Main libavformat public API header.
int64_t start_time
Decoding: pts of the first frame of the stream, in stream time base.
Definition: avformat.h:727
AVInputFormat ff_mp3_demuxer
Definition: mp3dec.c:276
#define MKBETAG(a, b, c, d)
Definition: common.h:239
#define XING_FLAG_TOC
Definition: mp3dec.c:34
int eof_reached
true if eof reached
Definition: avio.h:96
void * priv_data
Format private data.
Definition: avformat.h:899
#define XING_TOC_COUNT
Definition: mp3dec.c:36
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:129
#define ID3v1_TAG_SIZE
Definition: id3v1.h:27
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:516
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
int stream_index
Definition: avcodec.h:975
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:719
This structure stores compressed data.
Definition: avcodec.h:950