2 * Core Audio Format demuxer
3 * Copyright (c) 2007 Justin Ruggles
4 * Copyright (c) 2009 Peter Ross
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * Core Audio Format demuxer
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/intfloat.h"
36 #include "libavutil/dict.h"
40 int bytes_per_packet
; ///< bytes in a packet, or 0 if variable
41 int frames_per_packet
; ///< frames in a packet, or 0 if variable
42 int64_t num_bytes
; ///< total number of bytes in stream
44 int64_t packet_cnt
; ///< packet counter
45 int64_t frame_cnt
; ///< frame counter
47 int64_t data_start
; ///< data start position, in bytes
48 int64_t data_size
; ///< raw data size, in bytes
51 static int probe(AVProbeData
*p
)
53 if (AV_RB32(p
->buf
) == MKBETAG('c','a','f','f') && AV_RB16(&p
->buf
[4]) == 1)
54 return AVPROBE_SCORE_MAX
;
58 /** Read audio description chunk */
59 static int read_desc_chunk(AVFormatContext
*s
)
61 AVIOContext
*pb
= s
->pb
;
62 CafContext
*caf
= s
->priv_data
;
66 /* new audio stream */
67 st
= avformat_new_stream(s
, NULL
);
69 return AVERROR(ENOMEM
);
71 /* parse format description */
72 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
73 st
->codec
->sample_rate
= av_int2double(avio_rb64(pb
));
74 st
->codec
->codec_tag
= avio_rl32(pb
);
75 flags
= avio_rb32(pb
);
76 caf
->bytes_per_packet
= avio_rb32(pb
);
77 st
->codec
->block_align
= caf
->bytes_per_packet
;
78 caf
->frames_per_packet
= avio_rb32(pb
);
79 st
->codec
->channels
= avio_rb32(pb
);
80 st
->codec
->bits_per_coded_sample
= avio_rb32(pb
);
82 /* calculate bit rate for constant size packets */
83 if (caf
->frames_per_packet
> 0 && caf
->bytes_per_packet
> 0) {
84 st
->codec
->bit_rate
= (uint64_t)st
->codec
->sample_rate
* (uint64_t)caf
->bytes_per_packet
* 8
85 / (uint64_t)caf
->frames_per_packet
;
87 st
->codec
->bit_rate
= 0;
91 if (st
->codec
->codec_tag
== MKTAG('l','p','c','m'))
92 st
->codec
->codec_id
= ff_mov_get_lpcm_codec_id(st
->codec
->bits_per_coded_sample
, (flags
^ 0x2) | 0x4);
94 st
->codec
->codec_id
= ff_codec_get_id(ff_codec_caf_tags
, st
->codec
->codec_tag
);
98 /** Read magic cookie chunk */
99 static int read_kuki_chunk(AVFormatContext
*s
, int64_t size
)
101 AVIOContext
*pb
= s
->pb
;
102 AVStream
*st
= s
->streams
[0];
104 if (size
< 0 || size
> INT_MAX
- FF_INPUT_BUFFER_PADDING_SIZE
)
107 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
) {
108 /* The magic cookie format for AAC is an mp4 esds atom.
109 The lavc AAC decoder requires the data from the codec specific
110 description as extradata input. */
113 strt
= avio_tell(pb
);
114 ff_mov_read_esds(s
, pb
);
115 skip
= size
- (avio_tell(pb
) - strt
);
116 if (skip
< 0 || !st
->codec
->extradata
||
117 st
->codec
->codec_id
!= AV_CODEC_ID_AAC
) {
118 av_log(s
, AV_LOG_ERROR
, "invalid AAC magic cookie\n");
119 return AVERROR_INVALIDDATA
;
122 } else if (st
->codec
->codec_id
== AV_CODEC_ID_ALAC
) {
123 #define ALAC_PREAMBLE 12
124 #define ALAC_HEADER 36
125 #define ALAC_NEW_KUKI 24
126 uint8_t preamble
[12];
127 if (size
< ALAC_NEW_KUKI
) {
128 av_log(s
, AV_LOG_ERROR
, "invalid ALAC magic cookie\n");
130 return AVERROR_INVALIDDATA
;
132 avio_read(pb
, preamble
, ALAC_PREAMBLE
);
134 if (ff_alloc_extradata(st
->codec
, ALAC_HEADER
))
135 return AVERROR(ENOMEM
);
137 /* For the old style cookie, we skip 12 bytes, then read 36 bytes.
138 * The new style cookie only contains the last 24 bytes of what was
139 * 36 bytes in the old style cookie, so we fabricate the first 12 bytes
140 * in that case to maintain compatibility. */
141 if (!memcmp(&preamble
[4], "frmaalac", 8)) {
142 if (size
< ALAC_PREAMBLE
+ ALAC_HEADER
) {
143 av_log(s
, AV_LOG_ERROR
, "invalid ALAC magic cookie\n");
144 av_freep(&st
->codec
->extradata
);
145 return AVERROR_INVALIDDATA
;
147 avio_read(pb
, st
->codec
->extradata
, ALAC_HEADER
);
148 avio_skip(pb
, size
- ALAC_PREAMBLE
- ALAC_HEADER
);
150 AV_WB32(st
->codec
->extradata
, 36);
151 memcpy(&st
->codec
->extradata
[4], "alac", 4);
152 AV_WB32(&st
->codec
->extradata
[8], 0);
153 memcpy(&st
->codec
->extradata
[12], preamble
, 12);
154 avio_read(pb
, &st
->codec
->extradata
[24], ALAC_NEW_KUKI
- 12);
155 avio_skip(pb
, size
- ALAC_NEW_KUKI
);
158 if (ff_get_extradata(st
->codec
, pb
, size
) < 0)
159 return AVERROR(ENOMEM
);
165 /** Read packet table chunk */
166 static int read_pakt_chunk(AVFormatContext
*s
, int64_t size
)
168 AVIOContext
*pb
= s
->pb
;
169 AVStream
*st
= s
->streams
[0];
170 CafContext
*caf
= s
->priv_data
;
171 int64_t pos
= 0, ccount
, num_packets
;
174 ccount
= avio_tell(pb
);
176 num_packets
= avio_rb64(pb
);
177 if (num_packets
< 0 || INT32_MAX
/ sizeof(AVIndexEntry
) < num_packets
)
178 return AVERROR_INVALIDDATA
;
180 st
->nb_frames
= avio_rb64(pb
); /* valid frames */
181 st
->nb_frames
+= avio_rb32(pb
); /* priming frames */
182 st
->nb_frames
+= avio_rb32(pb
); /* remainder frames */
185 for (i
= 0; i
< num_packets
; i
++) {
186 av_add_index_entry(s
->streams
[0], pos
, st
->duration
, 0, 0, AVINDEX_KEYFRAME
);
187 pos
+= caf
->bytes_per_packet
? caf
->bytes_per_packet
: ff_mp4_read_descr_len(pb
);
188 st
->duration
+= caf
->frames_per_packet
? caf
->frames_per_packet
: ff_mp4_read_descr_len(pb
);
191 if (avio_tell(pb
) - ccount
> size
) {
192 av_log(s
, AV_LOG_ERROR
, "error reading packet table\n");
193 return AVERROR_INVALIDDATA
;
195 avio_skip(pb
, ccount
+ size
- avio_tell(pb
));
197 caf
->num_bytes
= pos
;
201 /** Read information chunk */
202 static void read_info_chunk(AVFormatContext
*s
, int64_t size
)
204 AVIOContext
*pb
= s
->pb
;
206 unsigned int nb_entries
= avio_rb32(pb
);
207 for (i
= 0; i
< nb_entries
&& !avio_feof(pb
); i
++) {
210 avio_get_str(pb
, INT_MAX
, key
, sizeof(key
));
211 avio_get_str(pb
, INT_MAX
, value
, sizeof(value
));
212 av_dict_set(&s
->metadata
, key
, value
, 0);
216 static int read_header(AVFormatContext
*s
)
218 AVIOContext
*pb
= s
->pb
;
219 CafContext
*caf
= s
->priv_data
;
225 avio_skip(pb
, 8); /* magic, version, file flags */
227 /* audio description chunk */
228 if (avio_rb32(pb
) != MKBETAG('d','e','s','c')) {
229 av_log(s
, AV_LOG_ERROR
, "desc chunk not present\n");
230 return AVERROR_INVALIDDATA
;
232 size
= avio_rb64(pb
);
234 return AVERROR_INVALIDDATA
;
236 ret
= read_desc_chunk(s
);
241 /* parse each chunk */
243 while (!avio_feof(pb
)) {
245 /* stop at data chunk if seeking is not supported or
246 data chunk size is unknown */
247 if (found_data
&& (caf
->data_size
< 0 || !pb
->seekable
))
251 size
= avio_rb64(pb
);
257 case MKBETAG('d','a','t','a'):
258 avio_skip(pb
, 4); /* edit count */
259 caf
->data_start
= avio_tell(pb
);
260 caf
->data_size
= size
< 0 ? -1 : size
- 4;
261 if (caf
->data_size
> 0 && pb
->seekable
)
262 avio_skip(pb
, caf
->data_size
);
266 case MKBETAG('c','h','a','n'):
267 if ((ret
= ff_mov_read_chan(s
, s
->pb
, st
, size
)) < 0)
271 /* magic cookie chunk */
272 case MKBETAG('k','u','k','i'):
273 if (read_kuki_chunk(s
, size
))
274 return AVERROR_INVALIDDATA
;
277 /* packet table chunk */
278 case MKBETAG('p','a','k','t'):
279 if (read_pakt_chunk(s
, size
))
280 return AVERROR_INVALIDDATA
;
283 case MKBETAG('i','n','f','o'):
284 read_info_chunk(s
, size
);
288 #define _(x) ((x) >= ' ' ? (x) : ' ')
289 av_log(s
, AV_LOG_WARNING
,
290 "skipping CAF chunk: %08"PRIX32
" (%c%c%c%c), size %"PRId64
"\n",
291 tag
, _(tag
>>24), _((tag
>>16)&0xFF), _((tag
>>8)&0xFF), _(tag
&0xFF), size
);
293 case MKBETAG('f','r','e','e'):
295 return AVERROR_INVALIDDATA
;
300 if (pos
> INT64_MAX
- size
)
301 return AVERROR_INVALIDDATA
;
302 avio_skip(pb
, FFMAX(0, pos
+ size
- avio_tell(pb
)));
307 return AVERROR_INVALIDDATA
;
309 if (caf
->bytes_per_packet
> 0 && caf
->frames_per_packet
> 0) {
310 if (caf
->data_size
> 0)
311 st
->nb_frames
= (caf
->data_size
/ caf
->bytes_per_packet
) * caf
->frames_per_packet
;
312 } else if (st
->nb_index_entries
&& st
->duration
> 0) {
313 st
->codec
->bit_rate
= st
->codec
->sample_rate
* caf
->data_size
* 8 /
316 av_log(s
, AV_LOG_ERROR
, "Missing packet table. It is required when "
317 "block size or frame size are variable.\n");
318 return AVERROR_INVALIDDATA
;
321 avpriv_set_pts_info(st
, 64, 1, st
->codec
->sample_rate
);
324 /* position the stream at the start of data */
325 if (caf
->data_size
>= 0)
326 avio_seek(pb
, caf
->data_start
, SEEK_SET
);
331 #define CAF_MAX_PKT_SIZE 4096
333 static int read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
335 AVIOContext
*pb
= s
->pb
;
336 AVStream
*st
= s
->streams
[0];
337 CafContext
*caf
= s
->priv_data
;
338 int res
, pkt_size
= 0, pkt_frames
= 0;
339 int64_t left
= CAF_MAX_PKT_SIZE
;
344 /* don't read past end of data chunk */
345 if (caf
->data_size
> 0) {
346 left
= (caf
->data_start
+ caf
->data_size
) - avio_tell(pb
);
353 pkt_frames
= caf
->frames_per_packet
;
354 pkt_size
= caf
->bytes_per_packet
;
356 if (pkt_size
> 0 && pkt_frames
== 1) {
357 pkt_size
= (CAF_MAX_PKT_SIZE
/ pkt_size
) * pkt_size
;
358 pkt_size
= FFMIN(pkt_size
, left
);
359 pkt_frames
= pkt_size
/ caf
->bytes_per_packet
;
360 } else if (st
->nb_index_entries
) {
361 if (caf
->packet_cnt
< st
->nb_index_entries
- 1) {
362 pkt_size
= st
->index_entries
[caf
->packet_cnt
+ 1].pos
- st
->index_entries
[caf
->packet_cnt
].pos
;
363 pkt_frames
= st
->index_entries
[caf
->packet_cnt
+ 1].timestamp
- st
->index_entries
[caf
->packet_cnt
].timestamp
;
364 } else if (caf
->packet_cnt
== st
->nb_index_entries
- 1) {
365 pkt_size
= caf
->num_bytes
- st
->index_entries
[caf
->packet_cnt
].pos
;
366 pkt_frames
= st
->duration
- st
->index_entries
[caf
->packet_cnt
].timestamp
;
372 if (pkt_size
== 0 || pkt_frames
== 0 || pkt_size
> left
)
375 res
= av_get_packet(pb
, pkt
, pkt_size
);
380 pkt
->stream_index
= 0;
381 pkt
->dts
= pkt
->pts
= caf
->frame_cnt
;
384 caf
->frame_cnt
+= pkt_frames
;
389 static int read_seek(AVFormatContext
*s
, int stream_index
,
390 int64_t timestamp
, int flags
)
392 AVStream
*st
= s
->streams
[0];
393 CafContext
*caf
= s
->priv_data
;
394 int64_t pos
, packet_cnt
, frame_cnt
;
396 timestamp
= FFMAX(timestamp
, 0);
398 if (caf
->frames_per_packet
> 0 && caf
->bytes_per_packet
> 0) {
399 /* calculate new byte position based on target frame position */
400 pos
= caf
->bytes_per_packet
* (timestamp
/ caf
->frames_per_packet
);
401 if (caf
->data_size
> 0)
402 pos
= FFMIN(pos
, caf
->data_size
);
403 packet_cnt
= pos
/ caf
->bytes_per_packet
;
404 frame_cnt
= caf
->frames_per_packet
* packet_cnt
;
405 } else if (st
->nb_index_entries
) {
406 packet_cnt
= av_index_search_timestamp(st
, timestamp
, flags
);
407 frame_cnt
= st
->index_entries
[packet_cnt
].timestamp
;
408 pos
= st
->index_entries
[packet_cnt
].pos
;
413 if (avio_seek(s
->pb
, pos
+ caf
->data_start
, SEEK_SET
) < 0)
416 caf
->packet_cnt
= packet_cnt
;
417 caf
->frame_cnt
= frame_cnt
;
422 AVInputFormat ff_caf_demuxer
= {
424 .long_name
= NULL_IF_CONFIG_SMALL("Apple CAF (Core Audio Format)"),
425 .priv_data_size
= sizeof(CafContext
),
427 .read_header
= read_header
,
428 .read_packet
= read_packet
,
429 .read_seek
= read_seek
,
430 .codec_tag
= (const AVCodecTag
* const []){ ff_codec_caf_tags
, 0 },