Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 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; |
||
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 | avio_read(s->pb, buf, size); |
||
160 | init_get_bits(&gb, buf, size * 8); |
||
161 | size = gb_get_v(&gb); |
||
162 | if(size > UINT_MAX/4 || size > c->samples/1152){ |
||
163 | av_log(s, AV_LOG_ERROR, "Seek table is too big\n"); |
||
164 | return; |
||
165 | } |
||
166 | seekd = get_bits(&gb, 4); |
||
167 | for(i = 0; i < 2; i++){ |
||
168 | pos = gb_get_v(&gb) + c->header_pos; |
||
169 | ppos[1 - i] = pos; |
||
170 | av_add_index_entry(s->streams[0], pos, i, 0, 0, AVINDEX_KEYFRAME); |
||
171 | } |
||
172 | for(; i < size; i++){ |
||
173 | t = get_unary(&gb, 1, 33) << 12; |
||
174 | t += get_bits(&gb, 12); |
||
175 | if(t & 1) |
||
176 | t = -(t & ~1); |
||
177 | pos = (t >> 1) + ppos[0]*2 - ppos[1]; |
||
178 | av_add_index_entry(s->streams[0], pos, i << seekd, 0, 0, AVINDEX_KEYFRAME); |
||
179 | ppos[1] = ppos[0]; |
||
180 | ppos[0] = pos; |
||
181 | } |
||
182 | av_free(buf); |
||
183 | } |
||
184 | |||
185 | static void mpc8_handle_chunk(AVFormatContext *s, int tag, int64_t chunk_pos, int64_t size) |
||
186 | { |
||
187 | AVIOContext *pb = s->pb; |
||
188 | int64_t pos, off; |
||
189 | |||
190 | switch(tag){ |
||
191 | case TAG_SEEKTBLOFF: |
||
192 | pos = avio_tell(pb) + size; |
||
193 | off = ffio_read_varlen(pb); |
||
194 | mpc8_parse_seektable(s, chunk_pos + off); |
||
195 | avio_seek(pb, pos, SEEK_SET); |
||
196 | break; |
||
197 | default: |
||
198 | avio_skip(pb, size); |
||
199 | } |
||
200 | } |
||
201 | |||
202 | static int mpc8_read_header(AVFormatContext *s) |
||
203 | { |
||
204 | MPCContext *c = s->priv_data; |
||
205 | AVIOContext *pb = s->pb; |
||
206 | AVStream *st; |
||
207 | int tag = 0; |
||
208 | int64_t size, pos; |
||
209 | |||
210 | c->header_pos = avio_tell(pb); |
||
211 | if(avio_rl32(pb) != TAG_MPCK){ |
||
212 | av_log(s, AV_LOG_ERROR, "Not a Musepack8 file\n"); |
||
213 | return AVERROR_INVALIDDATA; |
||
214 | } |
||
215 | |||
216 | while(!url_feof(pb)){ |
||
217 | pos = avio_tell(pb); |
||
218 | mpc8_get_chunk_header(pb, &tag, &size); |
||
219 | if(tag == TAG_STREAMHDR) |
||
220 | break; |
||
221 | mpc8_handle_chunk(s, tag, pos, size); |
||
222 | } |
||
223 | if(tag != TAG_STREAMHDR){ |
||
224 | av_log(s, AV_LOG_ERROR, "Stream header not found\n"); |
||
225 | return AVERROR_INVALIDDATA; |
||
226 | } |
||
227 | pos = avio_tell(pb); |
||
228 | avio_skip(pb, 4); //CRC |
||
229 | c->ver = avio_r8(pb); |
||
230 | if(c->ver != 8){ |
||
231 | av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver); |
||
232 | return AVERROR_PATCHWELCOME; |
||
233 | } |
||
234 | c->samples = ffio_read_varlen(pb); |
||
235 | ffio_read_varlen(pb); //silence samples at the beginning |
||
236 | |||
237 | st = avformat_new_stream(s, NULL); |
||
238 | if (!st) |
||
239 | return AVERROR(ENOMEM); |
||
240 | st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
||
241 | st->codec->codec_id = AV_CODEC_ID_MUSEPACK8; |
||
242 | st->codec->bits_per_coded_sample = 16; |
||
243 | |||
244 | if (ff_alloc_extradata(st->codec, 2)) |
||
245 | return AVERROR(ENOMEM); |
||
246 | avio_read(pb, st->codec->extradata, st->codec->extradata_size); |
||
247 | |||
248 | st->codec->channels = (st->codec->extradata[1] >> 4) + 1; |
||
249 | st->codec->sample_rate = mpc8_rate[st->codec->extradata[0] >> 5]; |
||
250 | avpriv_set_pts_info(st, 32, 1152 << (st->codec->extradata[1]&3)*2, st->codec->sample_rate); |
||
251 | st->start_time = 0; |
||
252 | st->duration = c->samples / (1152 << (st->codec->extradata[1]&3)*2); |
||
253 | size -= avio_tell(pb) - pos; |
||
254 | if (size > 0) |
||
255 | avio_skip(pb, size); |
||
256 | |||
257 | if (pb->seekable) { |
||
258 | int64_t pos = avio_tell(s->pb); |
||
259 | c->apetag_start = ff_ape_parse_tag(s); |
||
260 | avio_seek(s->pb, pos, SEEK_SET); |
||
261 | } |
||
262 | |||
263 | return 0; |
||
264 | } |
||
265 | |||
266 | static int mpc8_read_packet(AVFormatContext *s, AVPacket *pkt) |
||
267 | { |
||
268 | MPCContext *c = s->priv_data; |
||
269 | int tag; |
||
270 | int64_t pos, size; |
||
271 | |||
272 | while(!url_feof(s->pb)){ |
||
273 | pos = avio_tell(s->pb); |
||
274 | |||
275 | /* don't return bogus packets with the ape tag data */ |
||
276 | if (c->apetag_start && pos >= c->apetag_start) |
||
277 | return AVERROR_EOF; |
||
278 | |||
279 | mpc8_get_chunk_header(s->pb, &tag, &size); |
||
280 | if (size < 0) |
||
281 | return -1; |
||
282 | if(tag == TAG_AUDIOPACKET){ |
||
283 | if(av_get_packet(s->pb, pkt, size) < 0) |
||
284 | return AVERROR(ENOMEM); |
||
285 | pkt->stream_index = 0; |
||
286 | pkt->duration = 1; |
||
287 | return 0; |
||
288 | } |
||
289 | if(tag == TAG_STREAMEND) |
||
290 | return AVERROR(EIO); |
||
291 | mpc8_handle_chunk(s, tag, pos, size); |
||
292 | } |
||
293 | return AVERROR_EOF; |
||
294 | } |
||
295 | |||
296 | static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) |
||
297 | { |
||
298 | AVStream *st = s->streams[stream_index]; |
||
299 | int index = av_index_search_timestamp(st, timestamp, flags); |
||
300 | |||
301 | if(index < 0) return -1; |
||
302 | if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0) |
||
303 | return -1; |
||
304 | ff_update_cur_dts(s, st, st->index_entries[index].timestamp); |
||
305 | return 0; |
||
306 | } |
||
307 | |||
308 | |||
309 | AVInputFormat ff_mpc8_demuxer = { |
||
310 | .name = "mpc8", |
||
311 | .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"), |
||
312 | .priv_data_size = sizeof(MPCContext), |
||
313 | .read_probe = mpc8_probe, |
||
314 | .read_header = mpc8_read_header, |
||
315 | .read_packet = mpc8_read_packet, |
||
316 | .read_seek = mpc8_read_seek, |
||
317 | };>>>>><>><>><>><>>>=0)>=><=>=><=>>>>>>>>=><=>><> |