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 | }; |