blob: 2ef9386edb84e4914d1179de88200e6555df8d91
1 | /* |
2 | * AIFF/AIFF-C demuxer |
3 | * Copyright (c) 2006 Patrick Guimond |
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/intreadwrite.h" |
23 | #include "libavutil/mathematics.h" |
24 | #include "libavutil/dict.h" |
25 | #include "avformat.h" |
26 | #include "internal.h" |
27 | #include "pcm.h" |
28 | #include "aiff.h" |
29 | #include "isom.h" |
30 | #include "id3v2.h" |
31 | #include "mov_chan.h" |
32 | |
33 | #define AIFF 0 |
34 | #define AIFF_C_VERSION1 0xA2805140 |
35 | |
36 | typedef struct AIFFInputContext { |
37 | int64_t data_end; |
38 | int block_duration; |
39 | } AIFFInputContext; |
40 | |
41 | static enum AVCodecID aiff_codec_get_id(int bps) |
42 | { |
43 | if (bps <= 8) |
44 | return AV_CODEC_ID_PCM_S8; |
45 | if (bps <= 16) |
46 | return AV_CODEC_ID_PCM_S16BE; |
47 | if (bps <= 24) |
48 | return AV_CODEC_ID_PCM_S24BE; |
49 | if (bps <= 32) |
50 | return AV_CODEC_ID_PCM_S32BE; |
51 | |
52 | /* bigger than 32 isn't allowed */ |
53 | return AV_CODEC_ID_NONE; |
54 | } |
55 | |
56 | /* returns the size of the found tag */ |
57 | static int get_tag(AVIOContext *pb, uint32_t * tag) |
58 | { |
59 | int size; |
60 | |
61 | if (avio_feof(pb)) |
62 | return AVERROR(EIO); |
63 | |
64 | *tag = avio_rl32(pb); |
65 | size = avio_rb32(pb); |
66 | |
67 | if (size < 0) |
68 | size = 0x7fffffff; |
69 | |
70 | return size; |
71 | } |
72 | |
73 | /* Metadata string read */ |
74 | static void get_meta(AVFormatContext *s, const char *key, int size) |
75 | { |
76 | uint8_t *str = av_malloc(size+1); |
77 | |
78 | if (str) { |
79 | int res = avio_read(s->pb, str, size); |
80 | if (res < 0){ |
81 | av_free(str); |
82 | return; |
83 | } |
84 | size += (size&1)-res; |
85 | str[res] = 0; |
86 | av_dict_set(&s->metadata, key, str, AV_DICT_DONT_STRDUP_VAL); |
87 | }else |
88 | size+= size&1; |
89 | |
90 | avio_skip(s->pb, size); |
91 | } |
92 | |
93 | /* Returns the number of sound data frames or negative on error */ |
94 | static int get_aiff_header(AVFormatContext *s, int size, |
95 | unsigned version) |
96 | { |
97 | AVIOContext *pb = s->pb; |
98 | AVCodecParameters *par = s->streams[0]->codecpar; |
99 | AIFFInputContext *aiff = s->priv_data; |
100 | int exp; |
101 | uint64_t val; |
102 | int sample_rate; |
103 | unsigned int num_frames; |
104 | |
105 | if (size & 1) |
106 | size++; |
107 | par->codec_type = AVMEDIA_TYPE_AUDIO; |
108 | par->channels = avio_rb16(pb); |
109 | num_frames = avio_rb32(pb); |
110 | par->bits_per_coded_sample = avio_rb16(pb); |
111 | |
112 | exp = avio_rb16(pb) - 16383 - 63; |
113 | val = avio_rb64(pb); |
114 | if (exp <-63 || exp >63) { |
115 | av_log(s, AV_LOG_ERROR, "exp %d is out of range\n", exp); |
116 | return AVERROR_INVALIDDATA; |
117 | } |
118 | if (exp >= 0) |
119 | sample_rate = val << exp; |
120 | else |
121 | sample_rate = (val + (1ULL<<(-exp-1))) >> -exp; |
122 | par->sample_rate = sample_rate; |
123 | size -= 18; |
124 | |
125 | /* get codec id for AIFF-C */ |
126 | if (size < 4) { |
127 | version = AIFF; |
128 | } else if (version == AIFF_C_VERSION1) { |
129 | par->codec_tag = avio_rl32(pb); |
130 | par->codec_id = ff_codec_get_id(ff_codec_aiff_tags, par->codec_tag); |
131 | if (par->codec_id == AV_CODEC_ID_NONE) |
132 | avpriv_request_sample(s, "unknown or unsupported codec tag: %s", |
133 | av_fourcc2str(par->codec_tag)); |
134 | size -= 4; |
135 | } |
136 | |
137 | if (version != AIFF_C_VERSION1 || par->codec_id == AV_CODEC_ID_PCM_S16BE) { |
138 | par->codec_id = aiff_codec_get_id(par->bits_per_coded_sample); |
139 | par->bits_per_coded_sample = av_get_bits_per_sample(par->codec_id); |
140 | aiff->block_duration = 1; |
141 | } else { |
142 | switch (par->codec_id) { |
143 | case AV_CODEC_ID_PCM_F32BE: |
144 | case AV_CODEC_ID_PCM_F64BE: |
145 | case AV_CODEC_ID_PCM_S16LE: |
146 | case AV_CODEC_ID_PCM_ALAW: |
147 | case AV_CODEC_ID_PCM_MULAW: |
148 | aiff->block_duration = 1; |
149 | break; |
150 | case AV_CODEC_ID_ADPCM_IMA_QT: |
151 | par->block_align = 34 * par->channels; |
152 | break; |
153 | case AV_CODEC_ID_MACE3: |
154 | par->block_align = 2 * par->channels; |
155 | break; |
156 | case AV_CODEC_ID_ADPCM_G726LE: |
157 | par->bits_per_coded_sample = 5; |
158 | case AV_CODEC_ID_ADPCM_IMA_WS: |
159 | case AV_CODEC_ID_ADPCM_G722: |
160 | case AV_CODEC_ID_MACE6: |
161 | case AV_CODEC_ID_SDX2_DPCM: |
162 | par->block_align = 1 * par->channels; |
163 | break; |
164 | case AV_CODEC_ID_GSM: |
165 | par->block_align = 33; |
166 | break; |
167 | default: |
168 | aiff->block_duration = 1; |
169 | break; |
170 | } |
171 | if (par->block_align > 0) |
172 | aiff->block_duration = av_get_audio_frame_duration2(par, |
173 | par->block_align); |
174 | } |
175 | |
176 | /* Block align needs to be computed in all cases, as the definition |
177 | * is specific to applications -> here we use the WAVE format definition */ |
178 | if (!par->block_align) |
179 | par->block_align = (av_get_bits_per_sample(par->codec_id) * par->channels) >> 3; |
180 | |
181 | if (aiff->block_duration) { |
182 | par->bit_rate = (int64_t)par->sample_rate * (par->block_align << 3) / |
183 | aiff->block_duration; |
184 | } |
185 | |
186 | /* Chunk is over */ |
187 | if (size) |
188 | avio_skip(pb, size); |
189 | |
190 | return num_frames; |
191 | } |
192 | |
193 | static int aiff_probe(AVProbeData *p) |
194 | { |
195 | /* check file header */ |
196 | if (p->buf[0] == 'F' && p->buf[1] == 'O' && |
197 | p->buf[2] == 'R' && p->buf[3] == 'M' && |
198 | p->buf[8] == 'A' && p->buf[9] == 'I' && |
199 | p->buf[10] == 'F' && (p->buf[11] == 'F' || p->buf[11] == 'C')) |
200 | return AVPROBE_SCORE_MAX; |
201 | else |
202 | return 0; |
203 | } |
204 | |
205 | /* aiff input */ |
206 | static int aiff_read_header(AVFormatContext *s) |
207 | { |
208 | int ret, size, filesize; |
209 | int64_t offset = 0, position; |
210 | uint32_t tag; |
211 | unsigned version = AIFF_C_VERSION1; |
212 | AVIOContext *pb = s->pb; |
213 | AVStream * st; |
214 | AIFFInputContext *aiff = s->priv_data; |
215 | ID3v2ExtraMeta *id3v2_extra_meta = NULL; |
216 | |
217 | /* check FORM header */ |
218 | filesize = get_tag(pb, &tag); |
219 | if (filesize < 0 || tag != MKTAG('F', 'O', 'R', 'M')) |
220 | return AVERROR_INVALIDDATA; |
221 | |
222 | /* AIFF data type */ |
223 | tag = avio_rl32(pb); |
224 | if (tag == MKTAG('A', 'I', 'F', 'F')) /* Got an AIFF file */ |
225 | version = AIFF; |
226 | else if (tag != MKTAG('A', 'I', 'F', 'C')) /* An AIFF-C file then */ |
227 | return AVERROR_INVALIDDATA; |
228 | |
229 | filesize -= 4; |
230 | |
231 | st = avformat_new_stream(s, NULL); |
232 | if (!st) |
233 | return AVERROR(ENOMEM); |
234 | |
235 | while (filesize > 0) { |
236 | /* parse different chunks */ |
237 | size = get_tag(pb, &tag); |
238 | |
239 | if (size == AVERROR_EOF && offset > 0 && st->codecpar->block_align) { |
240 | av_log(s, AV_LOG_WARNING, "header parser hit EOF\n"); |
241 | goto got_sound; |
242 | } |
243 | if (size < 0) |
244 | return size; |
245 | |
246 | filesize -= size + 8; |
247 | |
248 | switch (tag) { |
249 | case MKTAG('C', 'O', 'M', 'M'): /* Common chunk */ |
250 | /* Then for the complete header info */ |
251 | st->nb_frames = get_aiff_header(s, size, version); |
252 | if (st->nb_frames < 0) |
253 | return st->nb_frames; |
254 | if (offset > 0) // COMM is after SSND |
255 | goto got_sound; |
256 | break; |
257 | case MKTAG('I', 'D', '3', ' '): |
258 | position = avio_tell(pb); |
259 | ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, size); |
260 | if (id3v2_extra_meta) |
261 | if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0) { |
262 | ff_id3v2_free_extra_meta(&id3v2_extra_meta); |
263 | return ret; |
264 | } |
265 | ff_id3v2_free_extra_meta(&id3v2_extra_meta); |
266 | if (position + size > avio_tell(pb)) |
267 | avio_skip(pb, position + size - avio_tell(pb)); |
268 | break; |
269 | case MKTAG('F', 'V', 'E', 'R'): /* Version chunk */ |
270 | version = avio_rb32(pb); |
271 | break; |
272 | case MKTAG('N', 'A', 'M', 'E'): /* Sample name chunk */ |
273 | get_meta(s, "title" , size); |
274 | break; |
275 | case MKTAG('A', 'U', 'T', 'H'): /* Author chunk */ |
276 | get_meta(s, "author" , size); |
277 | break; |
278 | case MKTAG('(', 'c', ')', ' '): /* Copyright chunk */ |
279 | get_meta(s, "copyright", size); |
280 | break; |
281 | case MKTAG('A', 'N', 'N', 'O'): /* Annotation chunk */ |
282 | get_meta(s, "comment" , size); |
283 | break; |
284 | case MKTAG('S', 'S', 'N', 'D'): /* Sampled sound chunk */ |
285 | aiff->data_end = avio_tell(pb) + size; |
286 | offset = avio_rb32(pb); /* Offset of sound data */ |
287 | avio_rb32(pb); /* BlockSize... don't care */ |
288 | offset += avio_tell(pb); /* Compute absolute data offset */ |
289 | if (st->codecpar->block_align && !(pb->seekable & AVIO_SEEKABLE_NORMAL)) /* Assume COMM already parsed */ |
290 | goto got_sound; |
291 | if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) { |
292 | av_log(s, AV_LOG_ERROR, "file is not seekable\n"); |
293 | return -1; |
294 | } |
295 | avio_skip(pb, size - 8); |
296 | break; |
297 | case MKTAG('w', 'a', 'v', 'e'): |
298 | if ((uint64_t)size > (1<<30)) |
299 | return -1; |
300 | if (ff_get_extradata(s, st->codecpar, pb, size) < 0) |
301 | return AVERROR(ENOMEM); |
302 | if ( (st->codecpar->codec_id == AV_CODEC_ID_QDMC || st->codecpar->codec_id == AV_CODEC_ID_QDM2) |
303 | && size>=12*4 && !st->codecpar->block_align) { |
304 | st->codecpar->block_align = AV_RB32(st->codecpar->extradata+11*4); |
305 | aiff->block_duration = AV_RB32(st->codecpar->extradata+9*4); |
306 | } else if (st->codecpar->codec_id == AV_CODEC_ID_QCELP) { |
307 | char rate = 0; |
308 | if (size >= 25) |
309 | rate = st->codecpar->extradata[24]; |
310 | switch (rate) { |
311 | case 'H': // RATE_HALF |
312 | st->codecpar->block_align = 17; |
313 | break; |
314 | case 'F': // RATE_FULL |
315 | default: |
316 | st->codecpar->block_align = 35; |
317 | } |
318 | aiff->block_duration = 160; |
319 | st->codecpar->bit_rate = (int64_t)st->codecpar->sample_rate * (st->codecpar->block_align << 3) / |
320 | aiff->block_duration; |
321 | } |
322 | break; |
323 | case MKTAG('C','H','A','N'): |
324 | if(ff_mov_read_chan(s, pb, st, size) < 0) |
325 | return AVERROR_INVALIDDATA; |
326 | break; |
327 | case 0: |
328 | if (offset > 0 && st->codecpar->block_align) // COMM && SSND |
329 | goto got_sound; |
330 | default: /* Jump */ |
331 | avio_skip(pb, size); |
332 | } |
333 | |
334 | /* Skip required padding byte for odd-sized chunks. */ |
335 | if (size & 1) { |
336 | filesize--; |
337 | avio_skip(pb, 1); |
338 | } |
339 | } |
340 | |
341 | got_sound: |
342 | if (!st->codecpar->block_align && st->codecpar->codec_id == AV_CODEC_ID_QCELP) { |
343 | av_log(s, AV_LOG_WARNING, "qcelp without wave chunk, assuming full rate\n"); |
344 | st->codecpar->block_align = 35; |
345 | } else if (!st->codecpar->block_align) { |
346 | av_log(s, AV_LOG_ERROR, "could not find COMM tag or invalid block_align value\n"); |
347 | return -1; |
348 | } |
349 | |
350 | /* Now positioned, get the sound data start and end */ |
351 | avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate); |
352 | st->start_time = 0; |
353 | st->duration = st->nb_frames * aiff->block_duration; |
354 | |
355 | /* Position the stream at the first block */ |
356 | avio_seek(pb, offset, SEEK_SET); |
357 | |
358 | return 0; |
359 | } |
360 | |
361 | #define MAX_SIZE 4096 |
362 | |
363 | static int aiff_read_packet(AVFormatContext *s, |
364 | AVPacket *pkt) |
365 | { |
366 | AVStream *st = s->streams[0]; |
367 | AIFFInputContext *aiff = s->priv_data; |
368 | int64_t max_size; |
369 | int res, size; |
370 | |
371 | /* calculate size of remaining data */ |
372 | max_size = aiff->data_end - avio_tell(s->pb); |
373 | if (max_size <= 0) |
374 | return AVERROR_EOF; |
375 | |
376 | if (!st->codecpar->block_align) { |
377 | av_log(s, AV_LOG_ERROR, "block_align not set\n"); |
378 | return AVERROR_INVALIDDATA; |
379 | } |
380 | |
381 | /* Now for that packet */ |
382 | switch (st->codecpar->codec_id) { |
383 | case AV_CODEC_ID_ADPCM_IMA_QT: |
384 | case AV_CODEC_ID_GSM: |
385 | case AV_CODEC_ID_QDM2: |
386 | case AV_CODEC_ID_QCELP: |
387 | size = st->codecpar->block_align; |
388 | break; |
389 | default: |
390 | size = st->codecpar->block_align ? (MAX_SIZE / st->codecpar->block_align) * st->codecpar->block_align : MAX_SIZE; |
391 | } |
392 | size = FFMIN(max_size, size); |
393 | res = av_get_packet(s->pb, pkt, size); |
394 | if (res < 0) |
395 | return res; |
396 | |
397 | if (size >= st->codecpar->block_align) |
398 | pkt->flags &= ~AV_PKT_FLAG_CORRUPT; |
399 | /* Only one stream in an AIFF file */ |
400 | pkt->stream_index = 0; |
401 | pkt->duration = (res / st->codecpar->block_align) * aiff->block_duration; |
402 | return 0; |
403 | } |
404 | |
405 | AVInputFormat ff_aiff_demuxer = { |
406 | .name = "aiff", |
407 | .long_name = NULL_IF_CONFIG_SMALL("Audio IFF"), |
408 | .priv_data_size = sizeof(AIFFInputContext), |
409 | .read_probe = aiff_probe, |
410 | .read_header = aiff_read_header, |
411 | .read_packet = aiff_read_packet, |
412 | .read_seek = ff_pcm_read_seek, |
413 | .codec_tag = (const AVCodecTag* const []){ ff_codec_aiff_tags, 0 }, |
414 | }; |
415 |