[deb_ffmpeg.git] / ffmpeg / libavformat / mp3dec.c

/*
 * MP3 demuxer
 * Copyright (c) 2003 Fabrice Bellard
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/opt.h"
#include "libavutil/avstring.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/crc.h"
#include "libavutil/dict.h"
#include "libavutil/mathematics.h"
#include "avformat.h"
#include "internal.h"
#include "avio_internal.h"
#include "id3v2.h"
#include "id3v1.h"
#include "replaygain.h"

#include "libavcodec/mpegaudiodecheader.h"

#define XING_FLAG_FRAMES 0x01
#define XING_FLAG_SIZE   0x02
#define XING_FLAG_TOC    0x04
#define XING_FLAC_QSCALE 0x08

#define XING_TOC_COUNT 100

typedef struct {
    AVClass *class;
    int64_t filesize;
    int xing_toc;
    int start_pad;
    int end_pad;
    int usetoc;
    unsigned frames; /* Total number of frames in file */
    unsigned header_filesize;   /* Total number of bytes in the stream */
    int is_cbr;
} MP3DecContext;

/* mp3 read */

static int mp3_read_probe(AVProbeData *p)
{
    int max_frames, first_frames = 0;
    int fsize, frames, sample_rate;
    uint32_t header;
    const uint8_t *buf, *buf0, *buf2, *end;
    AVCodecContext avctx;

    buf0 = p->buf;
    end = p->buf + p->buf_size - sizeof(uint32_t);
    while(buf0 < end && !*buf0)
        buf0++;

    max_frames = 0;
    buf = buf0;

    for(; buf < end; buf= buf2+1) {
        buf2 = buf;
        if(ff_mpa_check_header(AV_RB32(buf2)))
            continue;

        for(frames = 0; buf2 < end; frames++) {
            header = AV_RB32(buf2);
            fsize = avpriv_mpa_decode_header(&avctx, header, &sample_rate, &sample_rate, &sample_rate, &sample_rate);
            if(fsize < 0)
                break;
            buf2 += fsize;
        }
        max_frames = FFMAX(max_frames, frames);
        if(buf == buf0)
            first_frames= frames;
    }
    // keep this in sync with ac3 probe, both need to avoid
    // issues with MPEG-files!
    if   (first_frames>=4) return AVPROBE_SCORE_EXTENSION + 1;
    else if(max_frames>200)return AVPROBE_SCORE_EXTENSION;
    else if(max_frames>=4 && max_frames >= p->buf_size/10000) return AVPROBE_SCORE_EXTENSION / 2;
    else if(ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)
                           return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;
    else if(max_frames>=1 && max_frames >= p->buf_size/10000) return 1;
    else                   return 0;
//mpegps_mp3_unrecognized_format.mpg has max_frames=3
}

static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
{
    int i;
    MP3DecContext *mp3 = s->priv_data;
    int fill_index = mp3->usetoc && duration > 0;

    if (!filesize &&
        !(filesize = avio_size(s->pb))) {
        av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
        fill_index = 0;
    }

    for (i = 0; i < XING_TOC_COUNT; i++) {
        uint8_t b = avio_r8(s->pb);
        if (fill_index)
            av_add_index_entry(s->streams[0],
                           av_rescale(b, filesize, 256),
                           av_rescale(i, duration, XING_TOC_COUNT),
                           0, 0, AVINDEX_KEYFRAME);
    }
    if (fill_index)
        mp3->xing_toc = 1;
}

static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
                               MPADecodeHeader *c, uint32_t spf)
{
#define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))

    uint16_t crc;
    uint32_t v;

    char version[10];

    uint32_t peak   = 0;
    int32_t  r_gain = INT32_MIN, a_gain = INT32_MIN;

    MP3DecContext *mp3 = s->priv_data;
    static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
    uint64_t fsize = avio_size(s->pb);

    /* Check for Xing / Info tag */
    avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);
    v = avio_rb32(s->pb);
    mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
    if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)
        return;

    v = avio_rb32(s->pb);
    if (v & XING_FLAG_FRAMES)
        mp3->frames = avio_rb32(s->pb);
    if (v & XING_FLAG_SIZE)
        mp3->header_filesize = avio_rb32(s->pb);
    if (fsize && mp3->header_filesize) {
        uint64_t min, delta;
        min = FFMIN(fsize, mp3->header_filesize);
        delta = FFMAX(fsize, mp3->header_filesize) - min;
        if (fsize > mp3->header_filesize && delta > min >> 4) {
            mp3->frames = 0;
        } else if (delta > min >> 4) {
            av_log(s, AV_LOG_WARNING,
                   "filesize and duration do not match (growing file?)\n");
        }
    }
    if (v & XING_FLAG_TOC)
        read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,
                                       (AVRational){spf, c->sample_rate},
                                       st->time_base));
    /* VBR quality */
    if (v & XING_FLAC_QSCALE)
        avio_rb32(s->pb);

    /* Encoder short version string */
    memset(version, 0, sizeof(version));
    avio_read(s->pb, version, 9);

    /* Info Tag revision + VBR method */
    avio_r8(s->pb);

    /* Lowpass filter value */
    avio_r8(s->pb);

    /* ReplayGain peak */
    v    = avio_rb32(s->pb);
    peak = av_rescale(v, 100000, 1 << 23);

    /* Radio ReplayGain */
    v = avio_rb16(s->pb);

    if (MIDDLE_BITS(v, 13, 15) == 1) {
        r_gain = MIDDLE_BITS(v, 0, 8) * 10000;

        if (v & (1 << 9))
            r_gain *= -1;
    }

    /* Audiophile ReplayGain */
    v = avio_rb16(s->pb);

    if (MIDDLE_BITS(v, 13, 15) == 2) {
        a_gain = MIDDLE_BITS(v, 0, 8) * 10000;

        if (v & (1 << 9))
            a_gain *= -1;
    }

    /* Encoding flags + ATH Type */
    avio_r8(s->pb);

    /* if ABR {specified bitrate} else {minimal bitrate} */
    avio_r8(s->pb);

    /* Encoder delays */
    v= avio_rb24(s->pb);
    if(AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')
        || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')
        || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'c')
    ) {

        mp3->start_pad = v>>12;
        mp3->  end_pad = v&4095;
        st->skip_samples = mp3->start_pad + 528 + 1;
        if (mp3->frames) {
            st->first_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;
            st->last_discard_sample = mp3->frames * (int64_t)spf;
        }
        if (!st->start_time)
            st->start_time = av_rescale_q(st->skip_samples,
                                            (AVRational){1, c->sample_rate},
                                            st->time_base);
        av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3->  end_pad);
    }

    /* Misc */
    avio_r8(s->pb);

    /* MP3 gain */
    avio_r8(s->pb);

    /* Preset and surround info */
    avio_rb16(s->pb);

    /* Music length */
    avio_rb32(s->pb);

    /* Music CRC */
    avio_rb16(s->pb);

    /* Info Tag CRC */
    crc = ffio_get_checksum(s->pb);
    v   = avio_rb16(s->pb);

    if (v == crc) {
        ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);
        av_dict_set(&st->metadata, "encoder", version, 0);
    }
}

static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)
{
    uint32_t v;
    MP3DecContext *mp3 = s->priv_data;

    /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
    avio_seek(s->pb, base + 4 + 32, SEEK_SET);
    v = avio_rb32(s->pb);
    if (v == MKBETAG('V', 'B', 'R', 'I')) {
        /* Check tag version */
        if (avio_rb16(s->pb) == 1) {
            /* skip delay and quality */
            avio_skip(s->pb, 4);
            mp3->header_filesize = avio_rb32(s->pb);
            mp3->frames = avio_rb32(s->pb);
        }
    }
}

/**
 * Try to find Xing/Info/VBRI tags and compute duration from info therein
 */
static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
{
    uint32_t v, spf;
    MPADecodeHeader c;
    int vbrtag_size = 0;
    MP3DecContext *mp3 = s->priv_data;

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

    v = avio_rb32(s->pb);
    if(ff_mpa_check_header(v) < 0)
      return -1;

    if (avpriv_mpegaudio_decode_header(&c, v) == 0)
        vbrtag_size = c.frame_size;
    if(c.layer != 3)
        return -1;

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

    mp3->frames = 0;
    mp3->header_filesize   = 0;

    mp3_parse_info_tag(s, st, &c, spf);
    mp3_parse_vbri_tag(s, st, base);

    if (!mp3->frames && !mp3->header_filesize)
        return -1;

    /* Skip the vbr tag frame */
    avio_seek(s->pb, base + vbrtag_size, SEEK_SET);

    if (mp3->frames)
        st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},
                                    st->time_base);
    if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)
        st->codec->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);

    return 0;
}

static int mp3_read_header(AVFormatContext *s)
{
    MP3DecContext *mp3 = s->priv_data;
    AVStream *st;
    int64_t off;
    int ret;

    st = avformat_new_stream(s, NULL);
    if (!st)
        return AVERROR(ENOMEM);

    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
    st->codec->codec_id = AV_CODEC_ID_MP3;
    st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
    st->start_time = 0;

    // lcm of all mp3 sample rates
    avpriv_set_pts_info(st, 64, 1, 14112000);

    s->pb->maxsize = -1;
    off = avio_tell(s->pb);

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

    if(s->pb->seekable)
        mp3->filesize = avio_size(s->pb);

    if (mp3_parse_vbr_tags(s, st, off) < 0)
        avio_seek(s->pb, off, SEEK_SET);

    ret = ff_replaygain_export(st, s->metadata);
    if (ret < 0)
        return ret;

    /* the parameters will be extracted from the compressed bitstream */
    return 0;
}

#define MP3_PACKET_SIZE 1024

static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    MP3DecContext *mp3 = s->priv_data;
    int ret, size;
    int64_t pos;

    size= MP3_PACKET_SIZE;
    pos = avio_tell(s->pb);
    if(mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
        size= FFMIN(size, mp3->filesize - pos);

    ret= av_get_packet(s->pb, pkt, size);
    if (ret <= 0) {
        if(ret<0)
            return ret;
        return AVERROR_EOF;
    }

    pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
    pkt->stream_index = 0;

    if (ret >= ID3v1_TAG_SIZE &&
        memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0)
        ret -= ID3v1_TAG_SIZE;

    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
    return ret;
}

static int check(AVFormatContext *s, int64_t pos)
{
    int64_t ret = avio_seek(s->pb, pos, SEEK_SET);
    unsigned header;
    MPADecodeHeader sd;
    if (ret < 0)
        return ret;
    header = avio_rb32(s->pb);
    if (ff_mpa_check_header(header) < 0)
        return -1;
    if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
        return -1;
    return sd.frame_size;
}

static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
                    int flags)
{
    MP3DecContext *mp3 = s->priv_data;
    AVIndexEntry *ie, ie1;
    AVStream *st = s->streams[0];
    int64_t ret  = av_index_search_timestamp(st, timestamp, flags);
    int i, j;
    int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
    int64_t best_pos;
    int best_score;

    if (   mp3->is_cbr
        && st->duration > 0
        && mp3->header_filesize > s->data_offset
        && mp3->frames) {
        int64_t filesize = avio_size(s->pb);
        int64_t duration;
        if (filesize <= s->data_offset)
            filesize = mp3->header_filesize;
        filesize -= s->data_offset;
        duration = av_rescale(st->duration, filesize, mp3->header_filesize - s->data_offset);
        ie = &ie1;
        timestamp = av_clip64(timestamp, 0, duration);
        ie->timestamp = timestamp;
        ie->pos       = av_rescale(timestamp, filesize, duration) + s->data_offset;
    } else if (mp3->xing_toc) {
        if (ret < 0)
            return ret;

        ie = &st->index_entries[ret];
    } else {
        st->skip_samples = timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;

        return -1;
    }

    avio_seek(s->pb, FFMAX(ie->pos - 4096, 0), SEEK_SET);
    ret = avio_seek(s->pb, ie->pos, SEEK_SET);
    if (ret < 0)
        return ret;

#define MIN_VALID 3
    best_pos = ie->pos;
    best_score = 999;
    for(i=0; i<4096; i++) {
        int64_t pos = ie->pos + (dir > 0 ? i - 1024 : -i);
        int64_t candidate = -1;
        int score = 999;

        if (pos < 0)
            continue;

        for(j=0; j<MIN_VALID; j++) {
            ret = check(s, pos);
            if(ret < 0)
                break;
            if ((ie->pos - pos)*dir <= 0 && abs(MIN_VALID/2-j) < score) {
                candidate = pos;
                score = abs(MIN_VALID/2-j);
            }
            pos += ret;
        }
        if (best_score > score && j == MIN_VALID) {
            best_pos = candidate;
            best_score = score;
            if(score == 0)
                break;
        }
    }

    ret = avio_seek(s->pb, best_pos, SEEK_SET);
    if (ret < 0)
        return ret;
    ff_update_cur_dts(s, st, ie->timestamp);
    st->skip_samples = ie->timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;
    return 0;
}

static const AVOption options[] = {
    { "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
    { NULL },
};

static const AVClass demuxer_class = {
    .class_name = "mp3",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
    .category   = AV_CLASS_CATEGORY_DEMUXER,
};

AVInputFormat ff_mp3_demuxer = {
    .name           = "mp3",
    .long_name      = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
    .read_probe     = mp3_read_probe,
    .read_header    = mp3_read_header,
    .read_packet    = mp3_read_packet,
    .read_seek      = mp3_seek,
    .priv_data_size = sizeof(MP3DecContext),
    .flags          = AVFMT_GENERIC_INDEX,
    .extensions     = "mp2,mp3,m2a,mpa", /* XXX: use probe */
    .priv_class     = &demuxer_class,
};
Commit	Line	Data
2ba45a60 DM	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/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"
	34
	35	#include "libavcodec/mpegaudiodecheader.h"
	36
	37	#define XING_FLAG_FRAMES 0x01
	38	#define XING_FLAG_SIZE 0x02
	39	#define XING_FLAG_TOC 0x04
f6fa7814	40	#define XING_FLAC_QSCALE 0x08
2ba45a60 DM	41
	42	#define XING_TOC_COUNT 100
	43
	44	typedef struct {
	45	AVClass *class;
	46	int64_t filesize;
	47	int xing_toc;
	48	int start_pad;
	49	int end_pad;
	50	int usetoc;
	51	unsigned frames; /* Total number of frames in file */
	52	unsigned header_filesize; /* Total number of bytes in the stream */
	53	int is_cbr;
	54	} MP3DecContext;
	55
	56	/* mp3 read */
	57
	58	static int mp3_read_probe(AVProbeData *p)
	59	{
	60	int max_frames, first_frames = 0;
	61	int fsize, frames, sample_rate;
	62	uint32_t header;
	63	const uint8_t buf, buf0, buf2, end;
	64	AVCodecContext avctx;
	65
	66	buf0 = p->buf;
	67	end = p->buf + p->buf_size - sizeof(uint32_t);
	68	while(buf0 < end && !*buf0)
	69	buf0++;
	70
	71	max_frames = 0;
	72	buf = buf0;
	73
	74	for(; buf < end; buf= buf2+1) {
	75	buf2 = buf;
	76	if(ff_mpa_check_header(AV_RB32(buf2)))
	77	continue;
	78
	79	for(frames = 0; buf2 < end; frames++) {
	80	header = AV_RB32(buf2);
	81	fsize = avpriv_mpa_decode_header(&avctx, header, &sample_rate, &sample_rate, &sample_rate, &sample_rate);
	82	if(fsize < 0)
	83	break;
	84	buf2 += fsize;
	85	}
	86	max_frames = FFMAX(max_frames, frames);
	87	if(buf == buf0)
	88	first_frames= frames;
	89	}
	90	// keep this in sync with ac3 probe, both need to avoid
	91	// issues with MPEG-files!
	92	if (first_frames>=4) return AVPROBE_SCORE_EXTENSION + 1;
	93	else if(max_frames>200)return AVPROBE_SCORE_EXTENSION;
	94	else if(max_frames>=4 && max_frames >= p->buf_size/10000) return AVPROBE_SCORE_EXTENSION / 2;
	95	else if(ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)
	96	return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;
	97	else if(max_frames>=1 && max_frames >= p->buf_size/10000) return 1;
	98	else return 0;
	99	//mpegps_mp3_unrecognized_format.mpg has max_frames=3
	100	}
	101
	102	static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
	103	{
	104	int i;
105	MP3DecContext *mp3 = s->priv_data;
106	int fill_index = mp3->usetoc && duration > 0;
107
108	if (!filesize &&
109	!(filesize = avio_size(s->pb))) {
110	av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
111	fill_index = 0;
112	}
113
114	for (i = 0; i < XING_TOC_COUNT; i++) {
115	uint8_t b = avio_r8(s->pb);
116	if (fill_index)
117	av_add_index_entry(s->streams[0],
118	av_rescale(b, filesize, 256),
119	av_rescale(i, duration, XING_TOC_COUNT),
120	0, 0, AVINDEX_KEYFRAME);
121	}
122	if (fill_index)
123	mp3->xing_toc = 1;
124	}
125
126	static void mp3_parse_info_tag(AVFormatContext s, AVStream st,
127	MPADecodeHeader *c, uint32_t spf)
128	{
129	#define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
130	#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))
131
132	uint16_t crc;
133	uint32_t v;
134
135	char version[10];
136
137	uint32_t peak = 0;
138	int32_t r_gain = INT32_MIN, a_gain = INT32_MIN;
139
140	MP3DecContext *mp3 = s->priv_data;
141	static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
142	uint64_t fsize = avio_size(s->pb);
143
144	/* Check for Xing / Info tag */
145	avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);
146	v = avio_rb32(s->pb);
147	mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
148	if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)
149	return;
150
151	v = avio_rb32(s->pb);
152	if (v & XING_FLAG_FRAMES)
153	mp3->frames = avio_rb32(s->pb);
154	if (v & XING_FLAG_SIZE)
155	mp3->header_filesize = avio_rb32(s->pb);
156	if (fsize && mp3->header_filesize) {
157	uint64_t min, delta;
158	min = FFMIN(fsize, mp3->header_filesize);
159	delta = FFMAX(fsize, mp3->header_filesize) - min;
160	if (fsize > mp3->header_filesize && delta > min >> 4) {
161	mp3->frames = 0;
162	} else if (delta > min >> 4) {
163	av_log(s, AV_LOG_WARNING,
164	"filesize and duration do not match (growing file?)\n");
165	}
166	}
167	if (v & XING_FLAG_TOC)
168	read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,
169	(AVRational){spf, c->sample_rate},
170	st->time_base));
171	/* VBR quality */
f6fa7814 DM	172	if (v & XING_FLAC_QSCALE)
f6fa7814 DM	173	avio_rb32(s->pb);
2ba45a60 DM	174
	175	/* Encoder short version string */
	176	memset(version, 0, sizeof(version));
	177	avio_read(s->pb, version, 9);
	178
	179	/* Info Tag revision + VBR method */
	180	avio_r8(s->pb);
	181
	182	/* Lowpass filter value */
	183	avio_r8(s->pb);
	184
	185	/* ReplayGain peak */
	186	v = avio_rb32(s->pb);
	187	peak = av_rescale(v, 100000, 1 << 23);
	188
	189	/* Radio ReplayGain */
	190	v = avio_rb16(s->pb);
	191
	192	if (MIDDLE_BITS(v, 13, 15) == 1) {
	193	r_gain = MIDDLE_BITS(v, 0, 8) * 10000;
	194
	195	if (v & (1 << 9))
	196	r_gain *= -1;
	197	}
	198
	199	/* Audiophile ReplayGain */
	200	v = avio_rb16(s->pb);
	201
	202	if (MIDDLE_BITS(v, 13, 15) == 2) {
	203	a_gain = MIDDLE_BITS(v, 0, 8) * 10000;
	204
	205	if (v & (1 << 9))
	206	a_gain *= -1;
	207	}
	208
	209	/* Encoding flags + ATH Type */
	210	avio_r8(s->pb);
	211
	212	/* if ABR {specified bitrate} else {minimal bitrate} */
	213	avio_r8(s->pb);
	214
	215	/* Encoder delays */
	216	v= avio_rb24(s->pb);
	217	if(AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')
f6fa7814 DM	218	\|\| AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')
	219	\|\| AV_RB32(version) == MKBETAG('L', 'a', 'v', 'c')
	220	) {
2ba45a60 DM	221
	222	mp3->start_pad = v>>12;
	223	mp3-> end_pad = v&4095;
	224	st->skip_samples = mp3->start_pad + 528 + 1;
f6fa7814 DM	225	if (mp3->frames) {
	226	st->first_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;
	227	st->last_discard_sample = mp3->frames * (int64_t)spf;
	228	}
2ba45a60 DM	229	if (!st->start_time)
	230	st->start_time = av_rescale_q(st->skip_samples,
	231	(AVRational){1, c->sample_rate},
	232	st->time_base);
	233	av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3-> end_pad);
	234	}
	235
	236	/* Misc */
	237	avio_r8(s->pb);
	238
	239	/* MP3 gain */
	240	avio_r8(s->pb);
	241
	242	/* Preset and surround info */
	243	avio_rb16(s->pb);
	244
	245	/* Music length */
	246	avio_rb32(s->pb);
	247
	248	/* Music CRC */
	249	avio_rb16(s->pb);
	250
	251	/* Info Tag CRC */
	252	crc = ffio_get_checksum(s->pb);
	253	v = avio_rb16(s->pb);
	254
	255	if (v == crc) {
	256	ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);
	257	av_dict_set(&st->metadata, "encoder", version, 0);
	258	}
	259	}
	260
	261	static void mp3_parse_vbri_tag(AVFormatContext s, AVStream st, int64_t base)
	262	{
	263	uint32_t v;
	264	MP3DecContext *mp3 = s->priv_data;
	265
	266	/* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
	267	avio_seek(s->pb, base + 4 + 32, SEEK_SET);
	268	v = avio_rb32(s->pb);
	269	if (v == MKBETAG('V', 'B', 'R', 'I')) {
	270	/* Check tag version */
	271	if (avio_rb16(s->pb) == 1) {
	272	/* skip delay and quality */
	273	avio_skip(s->pb, 4);
	274	mp3->header_filesize = avio_rb32(s->pb);
	275	mp3->frames = avio_rb32(s->pb);
	276	}
	277	}
	278	}
	279
	280	/**
	281	* Try to find Xing/Info/VBRI tags and compute duration from info therein
	282	*/
	283	static int mp3_parse_vbr_tags(AVFormatContext s, AVStream st, int64_t base)
	284	{
	285	uint32_t v, spf;
	286	MPADecodeHeader c;
	287	int vbrtag_size = 0;
	288	MP3DecContext *mp3 = s->priv_data;
	289
	290	ffio_init_checksum(s->pb, ff_crcA001_update, 0);
	291
	292	v = avio_rb32(s->pb);
293	if(ff_mpa_check_header(v) < 0)
294	return -1;
295
296	if (avpriv_mpegaudio_decode_header(&c, v) == 0)
297	vbrtag_size = c.frame_size;
298	if(c.layer != 3)
299	return -1;
300
301	spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
302
303	mp3->frames = 0;
304	mp3->header_filesize = 0;
305
306	mp3_parse_info_tag(s, st, &c, spf);
307	mp3_parse_vbri_tag(s, st, base);
308
309	if (!mp3->frames && !mp3->header_filesize)
310	return -1;
311
312	/* Skip the vbr tag frame */
313	avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
314
315	if (mp3->frames)
316	st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},
317	st->time_base);
318	if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)
319	st->codec->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);
320
321	return 0;
322	}
323
324	static int mp3_read_header(AVFormatContext *s)
325	{
326	MP3DecContext *mp3 = s->priv_data;
327	AVStream *st;
328	int64_t off;
329	int ret;
330
331	st = avformat_new_stream(s, NULL);
332	if (!st)
333	return AVERROR(ENOMEM);
334
335	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
336	st->codec->codec_id = AV_CODEC_ID_MP3;
337	st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
338	st->start_time = 0;
339
340	// lcm of all mp3 sample rates
341	avpriv_set_pts_info(st, 64, 1, 14112000);
342
343	s->pb->maxsize = -1;
344	off = avio_tell(s->pb);
345
346	if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
347	ff_id3v1_read(s);
348
349	if(s->pb->seekable)
350	mp3->filesize = avio_size(s->pb);
351
352	if (mp3_parse_vbr_tags(s, st, off) < 0)
353	avio_seek(s->pb, off, SEEK_SET);
354
355	ret = ff_replaygain_export(st, s->metadata);
356	if (ret < 0)
357	return ret;
358
359	/* the parameters will be extracted from the compressed bitstream */
360	return 0;
361	}
362
363	#define MP3_PACKET_SIZE 1024
364
365	static int mp3_read_packet(AVFormatContext s, AVPacket pkt)
366	{
367	MP3DecContext *mp3 = s->priv_data;
368	int ret, size;
369	int64_t pos;
370
371	size= MP3_PACKET_SIZE;
372	pos = avio_tell(s->pb);
373	if(mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
374	size= FFMIN(size, mp3->filesize - pos);
375
376	ret= av_get_packet(s->pb, pkt, size);
377	if (ret <= 0) {
378	if(ret<0)
379	return ret;
380	return AVERROR_EOF;
381	}
382
383	pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
384	pkt->stream_index = 0;
385
386	if (ret >= ID3v1_TAG_SIZE &&
387	memcmp(&pkt->data[ret - ID3v1_TAG_SIZE], "TAG", 3) == 0)
388	ret -= ID3v1_TAG_SIZE;
389
390	/* note: we need to modify the packet size here to handle the last
391	packet */
392	pkt->size = ret;
393	return ret;
394	}
395
396	static int check(AVFormatContext *s, int64_t pos)
397	{
398	int64_t ret = avio_seek(s->pb, pos, SEEK_SET);
399	unsigned header;
400	MPADecodeHeader sd;
401	if (ret < 0)
402	return ret;
403	header = avio_rb32(s->pb);
404	if (ff_mpa_check_header(header) < 0)
405	return -1;
406	if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
407	return -1;
408	return sd.frame_size;
409	}
410
411	static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
412	int flags)
413	{
414	MP3DecContext *mp3 = s->priv_data;
415	AVIndexEntry *ie, ie1;
416	AVStream *st = s->streams[0];
417	int64_t ret = av_index_search_timestamp(st, timestamp, flags);
418	int i, j;
419	int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
420	int64_t best_pos;
421	int best_score;
422
423	if ( mp3->is_cbr
424	&& st->duration > 0
425	&& mp3->header_filesize > s->data_offset
426	&& mp3->frames) {
427	int64_t filesize = avio_size(s->pb);
428	int64_t duration;
429	if (filesize <= s->data_offset)
430	filesize = mp3->header_filesize;
431	filesize -= s->data_offset;
432	duration = av_rescale(st->duration, filesize, mp3->header_filesize - s->data_offset);
433	ie = &ie1;
434	timestamp = av_clip64(timestamp, 0, duration);
435	ie->timestamp = timestamp;
436	ie->pos = av_rescale(timestamp, filesize, duration) + s->data_offset;
437	} else if (mp3->xing_toc) {
438	if (ret < 0)
439	return ret;
440
441	ie = &st->index_entries[ret];
442	} else {
443	st->skip_samples = timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;
444
445	return -1;
446	}
447
448	avio_seek(s->pb, FFMAX(ie->pos - 4096, 0), SEEK_SET);
449	ret = avio_seek(s->pb, ie->pos, SEEK_SET);
450	if (ret < 0)
451	return ret;
452
453	#define MIN_VALID 3
454	best_pos = ie->pos;
455	best_score = 999;
456	for(i=0; i<4096; i++) {
457	int64_t pos = ie->pos + (dir > 0 ? i - 1024 : -i);
458	int64_t candidate = -1;
459	int score = 999;
f6fa7814 DM	460
	461	if (pos < 0)
	462	continue;
	463
2ba45a60 DM	464	for(j=0; j<MIN_VALID; j++) {
	465	ret = check(s, pos);
	466	if(ret < 0)
	467	break;
	468	if ((ie->pos - pos)*dir <= 0 && abs(MIN_VALID/2-j) < score) {
	469	candidate = pos;
	470	score = abs(MIN_VALID/2-j);
	471	}
	472	pos += ret;
	473	}
	474	if (best_score > score && j == MIN_VALID) {
	475	best_pos = candidate;
	476	best_score = score;
	477	if(score == 0)
	478	break;
	479	}
	480	}
	481
	482	ret = avio_seek(s->pb, best_pos, SEEK_SET);
	483	if (ret < 0)
	484	return ret;
	485	ff_update_cur_dts(s, st, ie->timestamp);
	486	st->skip_samples = ie->timestamp <= 0 ? mp3->start_pad + 528 + 1 : 0;
	487	return 0;
	488	}
	489
	490	static const AVOption options[] = {
	491	{ "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
	492	{ NULL },
	493	};
	494
	495	static const AVClass demuxer_class = {
	496	.class_name = "mp3",
	497	.item_name = av_default_item_name,
	498	.option = options,
	499	.version = LIBAVUTIL_VERSION_INT,
	500	.category = AV_CLASS_CATEGORY_DEMUXER,
	501	};
	502
	503	AVInputFormat ff_mp3_demuxer = {
	504	.name = "mp3",
	505	.long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
	506	.read_probe = mp3_read_probe,
	507	.read_header = mp3_read_header,
	508	.read_packet = mp3_read_packet,
	509	.read_seek = mp3_seek,
	510	.priv_data_size = sizeof(MP3DecContext),
	511	.flags = AVFMT_GENERIC_INDEX,
	512	.extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */
	513	.priv_class = &demuxer_class,
	514	};