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_MAX / 2 + 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_MAX / 2;
98  else if (max_frames >= 4) return AVPROBE_SCORE_MAX / 4;
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", /* XXX: use probe */
286 };