blob: f280faa5ccd0b9314697593fcbc33a3d93d41b31
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 MPCContext { |
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 | uint64_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 (size >= bs_end - bs + 2) |
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 | uint64_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 + AV_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, AV_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 (size < 0) { |
227 | av_log(s, AV_LOG_ERROR, "Invalid chunk length\n"); |
228 | return AVERROR_INVALIDDATA; |
229 | } |
230 | if(tag == TAG_STREAMHDR) |
231 | break; |
232 | mpc8_handle_chunk(s, tag, pos, size); |
233 | } |
234 | if(tag != TAG_STREAMHDR){ |
235 | av_log(s, AV_LOG_ERROR, "Stream header not found\n"); |
236 | return AVERROR_INVALIDDATA; |
237 | } |
238 | pos = avio_tell(pb); |
239 | avio_skip(pb, 4); //CRC |
240 | c->ver = avio_r8(pb); |
241 | if(c->ver != 8){ |
242 | avpriv_report_missing_feature(s, "Stream version %d", c->ver); |
243 | return AVERROR_PATCHWELCOME; |
244 | } |
245 | c->samples = ffio_read_varlen(pb); |
246 | ffio_read_varlen(pb); //silence samples at the beginning |
247 | |
248 | st = avformat_new_stream(s, NULL); |
249 | if (!st) |
250 | return AVERROR(ENOMEM); |
251 | st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; |
252 | st->codecpar->codec_id = AV_CODEC_ID_MUSEPACK8; |
253 | st->codecpar->bits_per_coded_sample = 16; |
254 | |
255 | if (ff_get_extradata(s, st->codecpar, pb, 2) < 0) |
256 | return AVERROR(ENOMEM); |
257 | |
258 | st->codecpar->channels = (st->codecpar->extradata[1] >> 4) + 1; |
259 | st->codecpar->sample_rate = mpc8_rate[st->codecpar->extradata[0] >> 5]; |
260 | avpriv_set_pts_info(st, 32, 1152 << (st->codecpar->extradata[1]&3)*2, st->codecpar->sample_rate); |
261 | st->start_time = 0; |
262 | st->duration = c->samples / (1152 << (st->codecpar->extradata[1]&3)*2); |
263 | size -= avio_tell(pb) - pos; |
264 | if (size > 0) |
265 | avio_skip(pb, size); |
266 | |
267 | if (pb->seekable & AVIO_SEEKABLE_NORMAL) { |
268 | int64_t pos = avio_tell(s->pb); |
269 | c->apetag_start = ff_ape_parse_tag(s); |
270 | avio_seek(s->pb, pos, SEEK_SET); |
271 | } |
272 | |
273 | return 0; |
274 | } |
275 | |
276 | static int mpc8_read_packet(AVFormatContext *s, AVPacket *pkt) |
277 | { |
278 | MPCContext *c = s->priv_data; |
279 | int tag; |
280 | int64_t pos, size; |
281 | |
282 | while(!avio_feof(s->pb)){ |
283 | pos = avio_tell(s->pb); |
284 | |
285 | /* don't return bogus packets with the ape tag data */ |
286 | if (c->apetag_start && pos >= c->apetag_start) |
287 | return AVERROR_EOF; |
288 | |
289 | mpc8_get_chunk_header(s->pb, &tag, &size); |
290 | if (size < 0) |
291 | return -1; |
292 | if(tag == TAG_AUDIOPACKET){ |
293 | if(av_get_packet(s->pb, pkt, size) < 0) |
294 | return AVERROR(ENOMEM); |
295 | pkt->stream_index = 0; |
296 | pkt->duration = 1; |
297 | return 0; |
298 | } |
299 | if(tag == TAG_STREAMEND) |
300 | return AVERROR(EIO); |
301 | mpc8_handle_chunk(s, tag, pos, size); |
302 | } |
303 | return AVERROR_EOF; |
304 | } |
305 | |
306 | static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) |
307 | { |
308 | AVStream *st = s->streams[stream_index]; |
309 | int index = av_index_search_timestamp(st, timestamp, flags); |
310 | |
311 | if(index < 0) return -1; |
312 | if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0) |
313 | return -1; |
314 | ff_update_cur_dts(s, st, st->index_entries[index].timestamp); |
315 | return 0; |
316 | } |
317 | |
318 | |
319 | AVInputFormat ff_mpc8_demuxer = { |
320 | .name = "mpc8", |
321 | .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"), |
322 | .priv_data_size = sizeof(MPCContext), |
323 | .read_probe = mpc8_probe, |
324 | .read_header = mpc8_read_header, |
325 | .read_packet = mpc8_read_packet, |
326 | .read_seek = mpc8_read_seek, |
327 | }; |
328 |