Merge commit 'fbd8e042107ec63e0ddf155588c59dcb76007641'
[ffmpeg.git] / libavformat / mp3dec.c
1 /*
2  * MP3 demuxer
3  * Copyright (c) 2003 Fabrice Bellard
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  */
21
22 #include "libavutil/opt.h"
23 #include "libavutil/avstring.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/dict.h"
26 #include "libavutil/mathematics.h"
27 #include "avformat.h"
28 #include "internal.h"
29 #include "id3v2.h"
30 #include "id3v1.h"
31 #include "replaygain.h"
32
33 #include "libavcodec/mpegaudiodecheader.h"
34
35 #define XING_FLAG_FRAMES 0x01
36 #define XING_FLAG_SIZE   0x02
37 #define XING_FLAG_TOC    0x04
38
39 #define XING_TOC_COUNT 100
40
41 typedef struct {
42     AVClass *class;
43     int64_t filesize;
44     int xing_toc;
45     int start_pad;
46     int end_pad;
47     int usetoc;
48     unsigned frames; /* Total number of frames in file */
49     unsigned header_filesize;   /* Total number of bytes in the stream */
50     int is_cbr;
51 } MP3DecContext;
52
53 /* mp3 read */
54
55 static int mp3_read_probe(AVProbeData *p)
56 {
57     int max_frames, first_frames = 0;
58     int fsize, frames, sample_rate;
59     uint32_t header;
60     const uint8_t *buf, *buf0, *buf2, *end;
61     AVCodecContext avctx;
62
63     buf0 = p->buf;
64     end = p->buf + p->buf_size - sizeof(uint32_t);
65     while(buf0 < end && !*buf0)
66         buf0++;
67
68     max_frames = 0;
69     buf = buf0;
70
71     for(; buf < end; buf= buf2+1) {
72         buf2 = buf;
73         if(ff_mpa_check_header(AV_RB32(buf2)))
74             continue;
75
76         for(frames = 0; buf2 < end; frames++) {
77             header = AV_RB32(buf2);
78             fsize = avpriv_mpa_decode_header(&avctx, header, &sample_rate, &sample_rate, &sample_rate, &sample_rate);
79             if(fsize < 0)
80                 break;
81             buf2 += fsize;
82         }
83         max_frames = FFMAX(max_frames, frames);
84         if(buf == buf0)
85             first_frames= frames;
86     }
87     // keep this in sync with ac3 probe, both need to avoid
88     // issues with MPEG-files!
89     if   (first_frames>=4) return AVPROBE_SCORE_EXTENSION + 1;
90     else if(max_frames>200)return AVPROBE_SCORE_EXTENSION;
91     else if(max_frames>=4) return AVPROBE_SCORE_EXTENSION / 2;
92     else if(ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)
93                            return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;
94     else if(max_frames>=1) return 1;
95     else                   return 0;
96 //mpegps_mp3_unrecognized_format.mpg has max_frames=3
97 }
98
99 static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
100 {
101     int i;
102     MP3DecContext *mp3 = s->priv_data;
103     int fill_index = mp3->usetoc && duration > 0;
104
105     if (!filesize &&
106         !(filesize = avio_size(s->pb))) {
107         av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
108         fill_index = 0;
109     }
110
111     for (i = 0; i < XING_TOC_COUNT; i++) {
112         uint8_t b = avio_r8(s->pb);
113         if (fill_index)
114             av_add_index_entry(s->streams[0],
115                            av_rescale(b, filesize, 256),
116                            av_rescale(i, duration, XING_TOC_COUNT),
117                            0, 0, AVINDEX_KEYFRAME);
118     }
119     if (fill_index)
120         mp3->xing_toc = 1;
121 }
122
123
124 static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
125                                MPADecodeHeader *c, uint32_t spf)
126 {
127     uint32_t v;
128     MP3DecContext *mp3 = s->priv_data;
129     static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
130
131     /* Check for Xing / Info tag */
132     avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);
133     v = avio_rb32(s->pb);
134     mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
135     if (v == MKBETAG('X', 'i', 'n', 'g') || mp3->is_cbr) {
136         v = avio_rb32(s->pb);
137         if (v & XING_FLAG_FRAMES)
138             mp3->frames = avio_rb32(s->pb);
139         if (v & XING_FLAG_SIZE)
140             mp3->header_filesize = avio_rb32(s->pb);
141         if (v & XING_FLAG_TOC)
142             read_xing_toc(s, mp3->header_filesize,
143                           av_rescale_q(mp3->frames,
144                                        (AVRational){spf, c->sample_rate},
145                                        st->time_base));
146         if(v & 8)
147             avio_skip(s->pb, 4);
148
149         v = avio_rb32(s->pb);
150         if(v == MKBETAG('L', 'A', 'M', 'E') || v == MKBETAG('L', 'a', 'v', 'f')) {
151             avio_skip(s->pb, 21-4);
152             v= avio_rb24(s->pb);
153             mp3->start_pad = v>>12;
154             mp3->  end_pad = v&4095;
155             st->skip_samples = mp3->start_pad + 528 + 1;
156             if (!st->start_time)
157                 st->start_time = av_rescale_q(st->skip_samples,
158                                               (AVRational){1, c->sample_rate},
159                                               st->time_base);
160             av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3->  end_pad);
161         }
162     }
163 }
164
165 static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)
166 {
167     uint32_t v;
168     MP3DecContext *mp3 = s->priv_data;
169
170     /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
171     avio_seek(s->pb, base + 4 + 32, SEEK_SET);
172     v = avio_rb32(s->pb);
173     if (v == MKBETAG('V', 'B', 'R', 'I')) {
174         /* Check tag version */
175         if (avio_rb16(s->pb) == 1) {
176             /* skip delay and quality */
177             avio_skip(s->pb, 4);
178             mp3->header_filesize = avio_rb32(s->pb);
179             mp3->frames = avio_rb32(s->pb);
180         }
181     }
182 }
183
184 /**
185  * Try to find Xing/Info/VBRI tags and compute duration from info therein
186  */
187 static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
188 {
189     uint32_t v, spf;
190     MPADecodeHeader c;
191     int vbrtag_size = 0;
192     MP3DecContext *mp3 = s->priv_data;
193
194     v = avio_rb32(s->pb);
195     if(ff_mpa_check_header(v) < 0)
196       return -1;
197
198     if (avpriv_mpegaudio_decode_header(&c, v) == 0)
199         vbrtag_size = c.frame_size;
200     if(c.layer != 3)
201         return -1;
202
203     spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
204
205     mp3->frames = 0;
206     mp3->header_filesize   = 0;
207
208     mp3_parse_info_tag(s, st, &c, spf);
209     mp3_parse_vbri_tag(s, st, base);
210
211     if (!mp3->frames && !mp3->header_filesize)
212         return -1;
213
214     /* Skip the vbr tag frame */
215     avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
216
217     if (mp3->frames)
218         st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},
219                                     st->time_base);
220     if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)
221         st->codec->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);
222
223     return 0;
224 }
225
226 static int mp3_read_header(AVFormatContext *s)
227 {
228     MP3DecContext *mp3 = s->priv_data;
229     AVStream *st;
230     int64_t off;
231     int ret;
232
233     st = avformat_new_stream(s, NULL);
234     if (!st)
235         return AVERROR(ENOMEM);
236
237     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
238     st->codec->codec_id = AV_CODEC_ID_MP3;
239     st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
240     st->start_time = 0;
241
242     // lcm of all mp3 sample rates
243     avpriv_set_pts_info(st, 64, 1, 14112000);
244
245     s->pb->maxsize = -1;
246     off = avio_tell(s->pb);
247
248     if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
249         ff_id3v1_read(s);
250
251     if(s->pb->seekable)
252         mp3->filesize = avio_size(s->pb);
253
254     if (mp3_parse_vbr_tags(s, st, off) < 0)
255         avio_seek(s->pb, off, SEEK_SET);
256
257     ret = ff_replaygain_export(st, s->metadata);
258     if (ret < 0)
259         return ret;
260
261     /* the parameters will be extracted from the compressed bitstream */
262     return 0;
263 }
264
265 #define MP3_PACKET_SIZE 1024
266
267 static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
268 {
269     MP3DecContext *mp3 = s->priv_data;
270     int ret, size;
271     int64_t pos;
272
273     size= MP3_PACKET_SIZE;
274     pos = avio_tell(s->pb);
275     if(mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
276         size= FFMIN(size, mp3->filesize - pos);
277
278     ret= av_get_packet(s->pb, pkt, size);
279     if (ret <= 0) {
280         if(ret<0)
281             return ret;
282         return AVERROR_EOF;
283     }
284
285     pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
286     pkt->stream_index = 0;
287
288     if (ret >= ID3v1_TAG_SIZE &&
289         memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0)
290         ret -= ID3v1_TAG_SIZE;
291
292     /* note: we need to modify the packet size here to handle the last
293        packet */
294     pkt->size = ret;
295     return ret;
296 }
297
298 static int check(AVFormatContext *s, int64_t pos)
299 {
300     int64_t ret = avio_seek(s->pb, pos, SEEK_SET);
301     unsigned header;
302     MPADecodeHeader sd;
303     if (ret < 0)
304         return ret;
305     header = avio_rb32(s->pb);
306     if (ff_mpa_check_header(header) < 0)
307         return -1;
308     if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
309         return -1;
310     return sd.frame_size;
311 }
312
313 static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
314                     int flags)
315 {
316     MP3DecContext *mp3 = s->priv_data;
317     AVIndexEntry *ie, ie1;
318     AVStream *st = s->streams[0];
319     int64_t ret  = av_index_search_timestamp(st, timestamp, flags);
320     int i, j;
321     int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
322
323     if (mp3->is_cbr && st->duration > 0 && mp3->header_filesize > s->data_offset) {
324         int64_t filesize = avio_size(s->pb);
325         int64_t duration;
326         if (filesize <= s->data_offset)
327             filesize = mp3->header_filesize;
328         filesize -= s->data_offset;
329         duration = av_rescale(st->duration, filesize, mp3->header_filesize - s->data_offset);
330         ie = &ie1;
331         timestamp = av_clip64(timestamp, 0, duration);
332         ie->timestamp = timestamp;
333         ie->pos       = av_rescale(timestamp, filesize, duration) + s->data_offset;
334     } else if (mp3->xing_toc) {
335         if (ret < 0)
336             return ret;
337
338         ie = &st->index_entries[ret];
339     } else {
340         st->skip_samples = timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;
341
342         return -1;
343     }
344
345     if (dir < 0)
346         avio_seek(s->pb, FFMAX(ie->pos - 4096, 0), SEEK_SET);
347     ret = avio_seek(s->pb, ie->pos, SEEK_SET);
348     if (ret < 0)
349         return ret;
350
351 #define MIN_VALID 3
352     for(i=0; i<4096; i++) {
353         int64_t pos = ie->pos + i*dir;
354         for(j=0; j<MIN_VALID; j++) {
355             ret = check(s, pos);
356             if(ret < 0)
357                 break;
358             pos += ret;
359         }
360         if(j==MIN_VALID)
361             break;
362     }
363     if(j!=MIN_VALID)
364         i=0;
365
366     ret = avio_seek(s->pb, ie->pos + i*dir, SEEK_SET);
367     if (ret < 0)
368         return ret;
369     ff_update_cur_dts(s, st, ie->timestamp);
370     st->skip_samples = ie->timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;
371     return 0;
372 }
373
374 static const AVOption options[] = {
375     { "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
376     { NULL },
377 };
378
379 static const AVClass demuxer_class = {
380     .class_name = "mp3",
381     .item_name  = av_default_item_name,
382     .option     = options,
383     .version    = LIBAVUTIL_VERSION_INT,
384     .category   = AV_CLASS_CATEGORY_DEMUXER,
385 };
386
387 AVInputFormat ff_mp3_demuxer = {
388     .name           = "mp3",
389     .long_name      = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
390     .read_probe     = mp3_read_probe,
391     .read_header    = mp3_read_header,
392     .read_packet    = mp3_read_packet,
393     .read_seek      = mp3_seek,
394     .priv_data_size = sizeof(MP3DecContext),
395     .flags          = AVFMT_GENERIC_INDEX,
396     .extensions     = "mp2,mp3,m2a,mpa", /* XXX: use probe */
397     .priv_class     = &demuxer_class,
398 };