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 /* mp3 read */
33 
35 {
36  int max_frames, first_frames = 0;
37  int fsize, frames, sample_rate;
38  uint32_t header;
39  uint8_t *buf, *buf0, *buf2, *end;
40  AVCodecContext avctx;
41 
42  buf0 = p->buf;
43  end = p->buf + p->buf_size - sizeof(uint32_t);
44  while(buf0 < end && !*buf0)
45  buf0++;
46 
47  max_frames = 0;
48  buf = buf0;
49 
50  for(; buf < end; buf= buf2+1) {
51  buf2 = buf;
52 
53  for(frames = 0; buf2 < end; frames++) {
54  header = AV_RB32(buf2);
55  fsize = avpriv_mpa_decode_header(&avctx, header, &sample_rate, &sample_rate, &sample_rate, &sample_rate);
56  if(fsize < 0)
57  break;
58  buf2 += fsize;
59  }
60  max_frames = FFMAX(max_frames, frames);
61  if(buf == buf0)
62  first_frames= frames;
63  }
64  // keep this in sync with ac3 probe, both need to avoid
65  // issues with MPEG-files!
66  if (first_frames>=4) return AVPROBE_SCORE_MAX/2+1;
67  else if(max_frames>500)return AVPROBE_SCORE_MAX/2;
68  else if(max_frames>=4) return AVPROBE_SCORE_MAX/4;
69  else if(max_frames>=1) return 1;
70  else return 0;
71 //mpegps_mp3_unrecognized_format.mpg has max_frames=3
72 }
73 
77 static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
78 {
79  uint32_t v, spf;
80  unsigned frames = 0; /* Total number of frames in file */
81  unsigned size = 0; /* Total number of bytes in the stream */
82  const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
84  int vbrtag_size = 0;
85 
86  v = avio_rb32(s->pb);
87  if(ff_mpa_check_header(v) < 0)
88  return -1;
89 
90  if (avpriv_mpegaudio_decode_header(&c, v) == 0)
91  vbrtag_size = c.frame_size;
92  if(c.layer != 3)
93  return -1;
94 
95  /* Check for Xing / Info tag */
96  avio_skip(s->pb, xing_offtbl[c.lsf == 1][c.nb_channels == 1]);
97  v = avio_rb32(s->pb);
98  if(v == MKBETAG('X', 'i', 'n', 'g') || v == MKBETAG('I', 'n', 'f', 'o')) {
99  v = avio_rb32(s->pb);
100  if(v & 0x1)
101  frames = avio_rb32(s->pb);
102  if(v & 0x2)
103  size = avio_rb32(s->pb);
104  }
105 
106  /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
107  avio_seek(s->pb, base + 4 + 32, SEEK_SET);
108  v = avio_rb32(s->pb);
109  if(v == MKBETAG('V', 'B', 'R', 'I')) {
110  /* Check tag version */
111  if(avio_rb16(s->pb) == 1) {
112  /* skip delay and quality */
113  avio_skip(s->pb, 4);
114  frames = avio_rb32(s->pb);
115  size = avio_rb32(s->pb);
116  }
117  }
118 
119  if(!frames && !size)
120  return -1;
121 
122  /* Skip the vbr tag frame */
123  avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
124 
125  spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
126  if(frames)
127  st->duration = av_rescale_q(frames, (AVRational){spf, c.sample_rate},
128  st->time_base);
129  if(size && frames)
130  st->codec->bit_rate = av_rescale(size, 8 * c.sample_rate, frames * (int64_t)spf);
131 
132  return 0;
133 }
134 
136  AVFormatParameters *ap)
137 {
138  AVStream *st;
139  int64_t off;
140 
141  st = avformat_new_stream(s, NULL);
142  if (!st)
143  return AVERROR(ENOMEM);
144 
146  st->codec->codec_id = CODEC_ID_MP3;
148  st->start_time = 0;
149 
150  // lcm of all mp3 sample rates
151  avpriv_set_pts_info(st, 64, 1, 14112000);
152 
153  off = avio_tell(s->pb);
154 
156  ff_id3v1_read(s);
157 
158  if (mp3_parse_vbr_tags(s, st, off) < 0)
159  avio_seek(s->pb, off, SEEK_SET);
160 
161  /* the parameters will be extracted from the compressed bitstream */
162  return 0;
163 }
164 
165 #define MP3_PACKET_SIZE 1024
166 
168 {
169  int ret, size;
170  // AVStream *st = s->streams[0];
171 
172  size= MP3_PACKET_SIZE;
173 
174  ret= av_get_packet(s->pb, pkt, size);
175 
176  pkt->stream_index = 0;
177  if (ret <= 0) {
178  return AVERROR(EIO);
179  }
180 
181  if (ret > ID3v1_TAG_SIZE &&
182  memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0)
183  ret -= ID3v1_TAG_SIZE;
184 
185  /* note: we need to modify the packet size here to handle the last
186  packet */
187  pkt->size = ret;
188  return ret;
189 }
190 
192  .name = "mp3",
193  .long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
194  .read_probe = mp3_read_probe,
195  .read_header = mp3_read_header,
196  .read_packet = mp3_read_packet,
197  .flags= AVFMT_GENERIC_INDEX,
198  .extensions = "mp2,mp3,m2a", /* XXX: use probe */
199 };
int size
AV_WL32 AV_WL24 AV_WL16 AV_RB32
Definition: bytestream.h:89
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the pts for a given stream.
Definition: utils.c:3828
void ff_id3v1_read(AVFormatContext *s)
Read an ID3v1 tag.
Definition: id3v1.c:227
int size
Definition: avcodec.h:909
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:211
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:754
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:27
#define v(n)
Definition: regs.h:34
Format I/O context.
Definition: avformat.h:863
Public dictionary API.
static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3dec.c:167
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:769
enum AVStreamParseType need_parsing
Definition: avformat.h:815
uint8_t * data
Definition: avcodec.h:908
int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
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:269
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:492
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:132
AVDictionary * metadata
Definition: avformat.h:1085
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2776
static int ff_mpa_check_header(uint32_t header)
#define FFMAX(a, b)
Definition: common.h:53
int off
Definition: dsputil_bfin.c:28
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
Definition: avformat.h:623
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:342
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:341
int bit_rate
the average bitrate
Definition: avcodec.h:1340
static int max_frames[4]
Definition: ffmpeg.c:136
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:128
#define MP3_PACKET_SIZE
Definition: mp3dec.c:165
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: avio.h:483
Stream structure.
Definition: avformat.h:620
static int mp3_read_probe(AVProbeData *p)
Definition: mp3dec.c:34
NULL
Definition: eval.c:50
enum AVMediaType codec_type
Definition: avcodec.h:1574
AVIOContext * pb
Definition: avformat.h:896
main external API structure.
Definition: avcodec.h:1329
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:376
rational number numerator/denominator
Definition: rational.h:43
static int mp3_read_header(AVFormatContext *s, AVFormatParameters *ap)
Definition: mp3dec.c:135
This structure contains the data a format has to probe a file.
Definition: avformat.h:339
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:684
#define AVPROBE_SCORE_MAX
maximum score, half of that is used for file-extension-based detection
Definition: avformat.h:345
MPEG Audio header decoder.
full parsing and repack
Definition: avformat.h:581
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:677
AVInputFormat ff_mp3_demuxer
Definition: mp3dec.c:191
#define MKBETAG(a, b, c, d)
Definition: common.h:232
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:77
#define ID3v1_TAG_SIZE
Definition: id3v1.h:27
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:460
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
int stream_index
Definition: avcodec.h:910
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:652
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:336
enum CodecID codec_id
Definition: avcodec.h:1575