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

/*
 * Musepack SV8 demuxer
 * Copyright (c) 2007 Konstantin Shishkov
 *
 * 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 "libavcodec/get_bits.h"
#include "libavcodec/unary.h"
#include "apetag.h"
#include "avformat.h"
#include "internal.h"
#include "avio_internal.h"

/// Two-byte MPC tag
#define MKMPCTAG(a, b) (a | (b << 8))

#define TAG_MPCK MKTAG('M','P','C','K')

/// Reserved MPC tags
enum MPCPacketTags{
    TAG_STREAMHDR   = MKMPCTAG('S','H'),
    TAG_STREAMEND   = MKMPCTAG('S','E'),

    TAG_AUDIOPACKET = MKMPCTAG('A','P'),

    TAG_SEEKTBLOFF  = MKMPCTAG('S','O'),
    TAG_SEEKTABLE   = MKMPCTAG('S','T'),

    TAG_REPLAYGAIN  = MKMPCTAG('R','G'),
    TAG_ENCINFO     = MKMPCTAG('E','I'),
};

static const int mpc8_rate[8] = { 44100, 48000, 37800, 32000, -1, -1, -1, -1 };

typedef struct {
    int ver;
    int64_t header_pos;
    int64_t samples;

    int64_t apetag_start;
} MPCContext;

static inline int64_t bs_get_v(const uint8_t **bs)
{
    int64_t v = 0;
    int br = 0;
    int c;

    do {
        c = **bs; (*bs)++;
        v <<= 7;
        v |= c & 0x7F;
        br++;
        if (br > 10)
            return -1;
    } while (c & 0x80);

    return v - br;
}

static int mpc8_probe(AVProbeData *p)
{
    const uint8_t *bs = p->buf + 4;
    const uint8_t *bs_end = bs + p->buf_size;
    int64_t size;

    if (p->buf_size < 16)
        return 0;
    if (AV_RL32(p->buf) != TAG_MPCK)
        return 0;
    while (bs < bs_end + 3) {
        int header_found = (bs[0] == 'S' && bs[1] == 'H');
        if (bs[0] < 'A' || bs[0] > 'Z' || bs[1] < 'A' || bs[1] > 'Z')
            return 0;
        bs += 2;
        size = bs_get_v(&bs);
        if (size < 2)
            return 0;
        if (bs + size - 2 >= bs_end)
            return AVPROBE_SCORE_EXTENSION - 1; // seems to be valid MPC but no header yet
        if (header_found) {
            if (size < 11 || size > 28)
                return 0;
            if (!AV_RL32(bs)) //zero CRC is invalid
                return 0;
            return AVPROBE_SCORE_MAX;
        } else {
            bs += size - 2;
        }
    }
    return 0;
}

static inline int64_t gb_get_v(GetBitContext *gb)
{
    int64_t v = 0;
    int bits = 0;
    while(get_bits1(gb) && bits < 64-7){
        v <<= 7;
        v |= get_bits(gb, 7);
        bits += 7;
    }
    v <<= 7;
    v |= get_bits(gb, 7);

    return v;
}

static void mpc8_get_chunk_header(AVIOContext *pb, int *tag, int64_t *size)
{
    int64_t pos;
    pos = avio_tell(pb);
    *tag = avio_rl16(pb);
    *size = ffio_read_varlen(pb);
    *size -= avio_tell(pb) - pos;
}

static void mpc8_parse_seektable(AVFormatContext *s, int64_t off)
{
    MPCContext *c = s->priv_data;
    int tag;
    int64_t size, pos, ppos[2];
    uint8_t *buf;
    int i, t, seekd, ret;
    GetBitContext gb;

    if (s->nb_streams == 0) {
        av_log(s, AV_LOG_ERROR, "No stream added before parsing seek table\n");
        return;
    }

    avio_seek(s->pb, off, SEEK_SET);
    mpc8_get_chunk_header(s->pb, &tag, &size);
    if(tag != TAG_SEEKTABLE){
        av_log(s, AV_LOG_ERROR, "No seek table at given position\n");
        return;
    }
    if (size > INT_MAX/10 || size<=0) {
        av_log(s, AV_LOG_ERROR, "Bad seek table size\n");
        return;
    }
    if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE)))
        return;
    ret = avio_read(s->pb, buf, size);
    if (ret != size) {
        av_log(s, AV_LOG_ERROR, "seek table truncated\n");
        av_free(buf);
        return;
    }
    memset(buf+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

    init_get_bits(&gb, buf, size * 8);
    size = gb_get_v(&gb);
    if(size > UINT_MAX/4 || size > c->samples/1152){
        av_log(s, AV_LOG_ERROR, "Seek table is too big\n");
        return;
    }
    seekd = get_bits(&gb, 4);
    for(i = 0; i < 2; i++){
        pos = gb_get_v(&gb) + c->header_pos;
        ppos[1 - i] = pos;
        av_add_index_entry(s->streams[0], pos, i, 0, 0, AVINDEX_KEYFRAME);
    }
    for(; i < size; i++){
        t = get_unary(&gb, 1, 33) << 12;
        t += get_bits(&gb, 12);
        if(t & 1)
            t = -(t & ~1);
        pos = (t >> 1) + ppos[0]*2 - ppos[1];
        av_add_index_entry(s->streams[0], pos, i << seekd, 0, 0, AVINDEX_KEYFRAME);
        ppos[1] = ppos[0];
        ppos[0] = pos;
    }
    av_free(buf);
}

static void mpc8_handle_chunk(AVFormatContext *s, int tag, int64_t chunk_pos, int64_t size)
{
    AVIOContext *pb = s->pb;
    int64_t pos, off;

    switch(tag){
    case TAG_SEEKTBLOFF:
        pos = avio_tell(pb) + size;
        off = ffio_read_varlen(pb);
        mpc8_parse_seektable(s, chunk_pos + off);
        avio_seek(pb, pos, SEEK_SET);
        break;
    default:
        avio_skip(pb, size);
    }
}

static int mpc8_read_header(AVFormatContext *s)
{
    MPCContext *c = s->priv_data;
    AVIOContext *pb = s->pb;
    AVStream *st;
    int tag = 0;
    int64_t size, pos;

    c->header_pos = avio_tell(pb);
    if(avio_rl32(pb) != TAG_MPCK){
        av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n");
        return AVERROR_INVALIDDATA;
    }

    while(!avio_feof(pb)){
        pos = avio_tell(pb);
        mpc8_get_chunk_header(pb, &tag, &size);
        if(tag == TAG_STREAMHDR)
            break;
        mpc8_handle_chunk(s, tag, pos, size);
    }
    if(tag != TAG_STREAMHDR){
        av_log(s, AV_LOG_ERROR, "Stream header not found\n");
        return AVERROR_INVALIDDATA;
    }
    pos = avio_tell(pb);
    avio_skip(pb, 4); //CRC
    c->ver = avio_r8(pb);
    if(c->ver != 8){
        av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);
        return AVERROR_PATCHWELCOME;
    }
    c->samples = ffio_read_varlen(pb);
    ffio_read_varlen(pb); //silence samples at the beginning

    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_MUSEPACK8;
    st->codec->bits_per_coded_sample = 16;

    if (ff_get_extradata(st->codec, pb, 2) < 0)
        return AVERROR(ENOMEM);

    st->codec->channels = (st->codec->extradata[1] >> 4) + 1;
    st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];
    avpriv_set_pts_info(st, 32, 1152  << (st->codec->extradata[1]&3)*2, st->codec->sample_rate);
    st->start_time = 0;
    st->duration = c->samples / (1152 << (st->codec->extradata[1]&3)*2);
    size -= avio_tell(pb) - pos;
    if (size > 0)
        avio_skip(pb, size);

    if (pb->seekable) {
        int64_t pos = avio_tell(s->pb);
        c->apetag_start = ff_ape_parse_tag(s);
        avio_seek(s->pb, pos, SEEK_SET);
    }

    return 0;
}

static int mpc8_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    MPCContext *c = s->priv_data;
    int tag;
    int64_t pos, size;

    while(!avio_feof(s->pb)){
        pos = avio_tell(s->pb);

        /* don't return bogus packets with the ape tag data */
        if (c->apetag_start && pos >= c->apetag_start)
            return AVERROR_EOF;

        mpc8_get_chunk_header(s->pb, &tag, &size);
        if (size < 0)
            return -1;
        if(tag == TAG_AUDIOPACKET){
            if(av_get_packet(s->pb, pkt, size) < 0)
                return AVERROR(ENOMEM);
            pkt->stream_index = 0;
            pkt->duration     = 1;
            return 0;
        }
        if(tag == TAG_STREAMEND)
            return AVERROR(EIO);
        mpc8_handle_chunk(s, tag, pos, size);
    }
    return AVERROR_EOF;
}

static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{
    AVStream *st = s->streams[stream_index];
    int index = av_index_search_timestamp(st, timestamp, flags);

    if(index < 0) return -1;
    if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)
        return -1;
    ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
    return 0;
}


AVInputFormat ff_mpc8_demuxer = {
    .name           = "mpc8",
    .long_name      = NULL_IF_CONFIG_SMALL("Musepack SV8"),
    .priv_data_size = sizeof(MPCContext),
    .read_probe     = mpc8_probe,
    .read_header    = mpc8_read_header,
    .read_packet    = mpc8_read_packet,
    .read_seek      = mpc8_read_seek,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Musepack SV8 demuxer
	3	* Copyright (c) 2007 Konstantin Shishkov
	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 "libavcodec/get_bits.h"
	23	#include "libavcodec/unary.h"
	24	#include "apetag.h"
	25	#include "avformat.h"
	26	#include "internal.h"
	27	#include "avio_internal.h"
	28
	29	/// Two-byte MPC tag
	30	#define MKMPCTAG(a, b) (a \| (b << 8))
	31
	32	#define TAG_MPCK MKTAG('M','P','C','K')
	33
	34	/// Reserved MPC tags
	35	enum MPCPacketTags{
	36	TAG_STREAMHDR = MKMPCTAG('S','H'),
	37	TAG_STREAMEND = MKMPCTAG('S','E'),
	38
	39	TAG_AUDIOPACKET = MKMPCTAG('A','P'),
	40
	41	TAG_SEEKTBLOFF = MKMPCTAG('S','O'),
	42	TAG_SEEKTABLE = MKMPCTAG('S','T'),
	43
	44	TAG_REPLAYGAIN = MKMPCTAG('R','G'),
	45	TAG_ENCINFO = MKMPCTAG('E','I'),
	46	};
	47
	48	static const int mpc8_rate[8] = { 44100, 48000, 37800, 32000, -1, -1, -1, -1 };
	49
	50	typedef struct {
	51	int ver;
	52	int64_t header_pos;
	53	int64_t samples;
	54
	55	int64_t apetag_start;
	56	} MPCContext;
	57
	58	static inline int64_t bs_get_v(const uint8_t **bs)
	59	{
	60	int64_t v = 0;
	61	int br = 0;
	62	int c;
	63
	64	do {
65	c = *bs; (bs)++;
66	v <<= 7;
67	v \|= c & 0x7F;
68	br++;
69	if (br > 10)
70	return -1;
71	} while (c & 0x80);
72
73	return v - br;
74	}
75
76	static int mpc8_probe(AVProbeData *p)
77	{
78	const uint8_t *bs = p->buf + 4;
79	const uint8_t *bs_end = bs + p->buf_size;
80	int64_t size;
81
82	if (p->buf_size < 16)
83	return 0;
84	if (AV_RL32(p->buf) != TAG_MPCK)
85	return 0;
86	while (bs < bs_end + 3) {
87	int header_found = (bs[0] == 'S' && bs[1] == 'H');
88	if (bs[0] < 'A' \|\| bs[0] > 'Z' \|\| bs[1] < 'A' \|\| bs[1] > 'Z')
89	return 0;
90	bs += 2;
91	size = bs_get_v(&bs);
92	if (size < 2)
93	return 0;
94	if (bs + size - 2 >= bs_end)
95	return AVPROBE_SCORE_EXTENSION - 1; // seems to be valid MPC but no header yet
96	if (header_found) {
97	if (size < 11 \|\| size > 28)
98	return 0;
99	if (!AV_RL32(bs)) //zero CRC is invalid
100	return 0;
101	return AVPROBE_SCORE_MAX;
102	} else {
103	bs += size - 2;
104	}
105	}
106	return 0;
107	}
108
109	static inline int64_t gb_get_v(GetBitContext *gb)
110	{
111	int64_t v = 0;
112	int bits = 0;
113	while(get_bits1(gb) && bits < 64-7){
114	v <<= 7;
115	v \|= get_bits(gb, 7);
116	bits += 7;
117	}
118	v <<= 7;
119	v \|= get_bits(gb, 7);
120
121	return v;
122	}
123
124	static void mpc8_get_chunk_header(AVIOContext pb, int tag, int64_t *size)
125	{
126	int64_t pos;
127	pos = avio_tell(pb);
128	*tag = avio_rl16(pb);
129	*size = ffio_read_varlen(pb);
130	*size -= avio_tell(pb) - pos;
131	}
132
133	static void mpc8_parse_seektable(AVFormatContext *s, int64_t off)
134	{
135	MPCContext *c = s->priv_data;
136	int tag;
137	int64_t size, pos, ppos[2];
138	uint8_t *buf;
139	int i, t, seekd, ret;
140	GetBitContext gb;
141
142	if (s->nb_streams == 0) {
143	av_log(s, AV_LOG_ERROR, "No stream added before parsing seek table\n");
144	return;
145	}
146
147	avio_seek(s->pb, off, SEEK_SET);
148	mpc8_get_chunk_header(s->pb, &tag, &size);
149	if(tag != TAG_SEEKTABLE){
150	av_log(s, AV_LOG_ERROR, "No seek table at given position\n");
151	return;
152	}
153	if (size > INT_MAX/10 \|\| size<=0) {
154	av_log(s, AV_LOG_ERROR, "Bad seek table size\n");
155	return;
156	}
157	if(!(buf = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE)))
158	return;
159	ret = avio_read(s->pb, buf, size);
160	if (ret != size) {
161	av_log(s, AV_LOG_ERROR, "seek table truncated\n");
162	av_free(buf);
163	return;
164	}
165	memset(buf+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
166
167	init_get_bits(&gb, buf, size * 8);
168	size = gb_get_v(&gb);
169	if(size > UINT_MAX/4 \|\| size > c->samples/1152){
170	av_log(s, AV_LOG_ERROR, "Seek table is too big\n");
171	return;
172	}
173	seekd = get_bits(&gb, 4);
174	for(i = 0; i < 2; i++){
175	pos = gb_get_v(&gb) + c->header_pos;
176	ppos[1 - i] = pos;
177	av_add_index_entry(s->streams[0], pos, i, 0, 0, AVINDEX_KEYFRAME);
178	}
179	for(; i < size; i++){
180	t = get_unary(&gb, 1, 33) << 12;
181	t += get_bits(&gb, 12);
182	if(t & 1)
183	t = -(t & ~1);
184	pos = (t >> 1) + ppos[0]*2 - ppos[1];
185	av_add_index_entry(s->streams[0], pos, i << seekd, 0, 0, AVINDEX_KEYFRAME);
186	ppos[1] = ppos[0];
187	ppos[0] = pos;
188	}
189	av_free(buf);
190	}
191
192	static void mpc8_handle_chunk(AVFormatContext *s, int tag, int64_t chunk_pos, int64_t size)
193	{
194	AVIOContext *pb = s->pb;
195	int64_t pos, off;
196
197	switch(tag){
198	case TAG_SEEKTBLOFF:
199	pos = avio_tell(pb) + size;
200	off = ffio_read_varlen(pb);
201	mpc8_parse_seektable(s, chunk_pos + off);
202	avio_seek(pb, pos, SEEK_SET);
203	break;
204	default:
205	avio_skip(pb, size);
206	}
207	}
208
209	static int mpc8_read_header(AVFormatContext *s)
210	{
211	MPCContext *c = s->priv_data;
212	AVIOContext *pb = s->pb;
213	AVStream *st;
214	int tag = 0;
215	int64_t size, pos;
216
217	c->header_pos = avio_tell(pb);
218	if(avio_rl32(pb) != TAG_MPCK){
219	av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n");
220	return AVERROR_INVALIDDATA;
221	}
222
223	while(!avio_feof(pb)){
224	pos = avio_tell(pb);
225	mpc8_get_chunk_header(pb, &tag, &size);
226	if(tag == TAG_STREAMHDR)
227	break;
228	mpc8_handle_chunk(s, tag, pos, size);
229	}
230	if(tag != TAG_STREAMHDR){
231	av_log(s, AV_LOG_ERROR, "Stream header not found\n");
232	return AVERROR_INVALIDDATA;
233	}
234	pos = avio_tell(pb);
235	avio_skip(pb, 4); //CRC
236	c->ver = avio_r8(pb);
237	if(c->ver != 8){
238	av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);
239	return AVERROR_PATCHWELCOME;
240	}
241	c->samples = ffio_read_varlen(pb);
242	ffio_read_varlen(pb); //silence samples at the beginning
243
244	st = avformat_new_stream(s, NULL);
245	if (!st)
246	return AVERROR(ENOMEM);
247	st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
248	st->codec->codec_id = AV_CODEC_ID_MUSEPACK8;
249	st->codec->bits_per_coded_sample = 16;
250
251	if (ff_get_extradata(st->codec, pb, 2) < 0)
252	return AVERROR(ENOMEM);
253
254	st->codec->channels = (st->codec->extradata[1] >> 4) + 1;
255	st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5];
256	avpriv_set_pts_info(st, 32, 1152 << (st->codec->extradata[1]&3)*2, st->codec->sample_rate);
257	st->start_time = 0;
258	st->duration = c->samples / (1152 << (st->codec->extradata[1]&3)*2);
259	size -= avio_tell(pb) - pos;
260	if (size > 0)
261	avio_skip(pb, size);
262
263	if (pb->seekable) {
264	int64_t pos = avio_tell(s->pb);
265	c->apetag_start = ff_ape_parse_tag(s);
266	avio_seek(s->pb, pos, SEEK_SET);
267	}
268
269	return 0;
270	}
271
272	static int mpc8_read_packet(AVFormatContext s, AVPacket pkt)
273	{
274	MPCContext *c = s->priv_data;
275	int tag;
276	int64_t pos, size;
277
278	while(!avio_feof(s->pb)){
279	pos = avio_tell(s->pb);
280
281	/* don't return bogus packets with the ape tag data */
282	if (c->apetag_start && pos >= c->apetag_start)
283	return AVERROR_EOF;
284
285	mpc8_get_chunk_header(s->pb, &tag, &size);
286	if (size < 0)
287	return -1;
288	if(tag == TAG_AUDIOPACKET){
289	if(av_get_packet(s->pb, pkt, size) < 0)
290	return AVERROR(ENOMEM);
291	pkt->stream_index = 0;
292	pkt->duration = 1;
293	return 0;
294	}
295	if(tag == TAG_STREAMEND)
296	return AVERROR(EIO);
297	mpc8_handle_chunk(s, tag, pos, size);
298	}
299	return AVERROR_EOF;
300	}
301
302	static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
303	{
304	AVStream *st = s->streams[stream_index];
305	int index = av_index_search_timestamp(st, timestamp, flags);
306
307	if(index < 0) return -1;
308	if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)
309	return -1;
310	ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
311	return 0;
312	}
313
314
315	AVInputFormat ff_mpc8_demuxer = {
316	.name = "mpc8",
317	.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
318	.priv_data_size = sizeof(MPCContext),
319	.read_probe = mpc8_probe,
320	.read_header = mpc8_read_header,
321	.read_packet = mpc8_read_packet,
322	.read_seek = mpc8_read_seek,
323	};