2 * Monkey's Audio APE demuxer
3 * Copyright (c) 2007 Benjamin Zores <ben@geexbox.org>
4 * based upon libdemac from Dave Chapman.
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 #include "libavutil/intreadwrite.h"
30 /* The earliest and latest file formats supported by this library */
31 #define APE_MIN_VERSION 3800
32 #define APE_MAX_VERSION 3990
34 #define MAC_FORMAT_FLAG_8_BIT 1 // is 8-bit [OBSOLETE]
35 #define MAC_FORMAT_FLAG_CRC 2 // uses the new CRC32 error detection [OBSOLETE]
36 #define MAC_FORMAT_FLAG_HAS_PEAK_LEVEL 4 // uint32 nPeakLevel after the header [OBSOLETE]
37 #define MAC_FORMAT_FLAG_24_BIT 8 // is 24-bit [OBSOLETE]
38 #define MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS 16 // has the number of seek elements after the peak level
39 #define MAC_FORMAT_FLAG_CREATE_WAV_HEADER 32 // create the wave header on decompression (not stored)
41 #define APE_EXTRADATA_SIZE 6
55 uint32_t totalsamples
;
59 /* Info from Descriptor Block */
63 uint32_t descriptorlength
;
64 uint32_t headerlength
;
65 uint32_t seektablelength
;
66 uint32_t wavheaderlength
;
67 uint32_t audiodatalength
;
68 uint32_t audiodatalength_high
;
69 uint32_t wavtaillength
;
72 /* Info from Header Block */
73 uint16_t compressiontype
;
75 uint32_t blocksperframe
;
76 uint32_t finalframeblocks
;
87 static int ape_probe(AVProbeData
* p
)
89 int version
= AV_RL16(p
->buf
+4);
90 if (AV_RL32(p
->buf
) != MKTAG('M', 'A', 'C', ' '))
93 if (version
< APE_MIN_VERSION
|| version
> APE_MAX_VERSION
)
94 return AVPROBE_SCORE_MAX
/4;
96 return AVPROBE_SCORE_MAX
;
99 static void ape_dumpinfo(AVFormatContext
* s
, APEContext
* ape_ctx
)
104 av_log(s
, AV_LOG_DEBUG
, "Descriptor Block:\n\n");
105 av_log(s
, AV_LOG_DEBUG
, "magic = \"%c%c%c%c\"\n", ape_ctx
->magic
[0], ape_ctx
->magic
[1], ape_ctx
->magic
[2], ape_ctx
->magic
[3]);
106 av_log(s
, AV_LOG_DEBUG
, "fileversion = %"PRId16
"\n", ape_ctx
->fileversion
);
107 av_log(s
, AV_LOG_DEBUG
, "descriptorlength = %"PRIu32
"\n", ape_ctx
->descriptorlength
);
108 av_log(s
, AV_LOG_DEBUG
, "headerlength = %"PRIu32
"\n", ape_ctx
->headerlength
);
109 av_log(s
, AV_LOG_DEBUG
, "seektablelength = %"PRIu32
"\n", ape_ctx
->seektablelength
);
110 av_log(s
, AV_LOG_DEBUG
, "wavheaderlength = %"PRIu32
"\n", ape_ctx
->wavheaderlength
);
111 av_log(s
, AV_LOG_DEBUG
, "audiodatalength = %"PRIu32
"\n", ape_ctx
->audiodatalength
);
112 av_log(s
, AV_LOG_DEBUG
, "audiodatalength_high = %"PRIu32
"\n", ape_ctx
->audiodatalength_high
);
113 av_log(s
, AV_LOG_DEBUG
, "wavtaillength = %"PRIu32
"\n", ape_ctx
->wavtaillength
);
114 av_log(s
, AV_LOG_DEBUG
, "md5 = ");
115 for (i
= 0; i
< 16; i
++)
116 av_log(s
, AV_LOG_DEBUG
, "%02x", ape_ctx
->md5
[i
]);
117 av_log(s
, AV_LOG_DEBUG
, "\n");
119 av_log(s
, AV_LOG_DEBUG
, "\nHeader Block:\n\n");
121 av_log(s
, AV_LOG_DEBUG
, "compressiontype = %"PRIu16
"\n", ape_ctx
->compressiontype
);
122 av_log(s
, AV_LOG_DEBUG
, "formatflags = %"PRIu16
"\n", ape_ctx
->formatflags
);
123 av_log(s
, AV_LOG_DEBUG
, "blocksperframe = %"PRIu32
"\n", ape_ctx
->blocksperframe
);
124 av_log(s
, AV_LOG_DEBUG
, "finalframeblocks = %"PRIu32
"\n", ape_ctx
->finalframeblocks
);
125 av_log(s
, AV_LOG_DEBUG
, "totalframes = %"PRIu32
"\n", ape_ctx
->totalframes
);
126 av_log(s
, AV_LOG_DEBUG
, "bps = %"PRIu16
"\n", ape_ctx
->bps
);
127 av_log(s
, AV_LOG_DEBUG
, "channels = %"PRIu16
"\n", ape_ctx
->channels
);
128 av_log(s
, AV_LOG_DEBUG
, "samplerate = %"PRIu32
"\n", ape_ctx
->samplerate
);
130 av_log(s
, AV_LOG_DEBUG
, "\nSeektable\n\n");
131 if ((ape_ctx
->seektablelength
/ sizeof(uint32_t)) != ape_ctx
->totalframes
) {
132 av_log(s
, AV_LOG_DEBUG
, "No seektable\n");
134 for (i
= 0; i
< ape_ctx
->seektablelength
/ sizeof(uint32_t); i
++) {
135 if (i
< ape_ctx
->totalframes
- 1) {
136 av_log(s
, AV_LOG_DEBUG
, "%8d %"PRIu32
" (%"PRIu32
" bytes)",
137 i
, ape_ctx
->seektable
[i
],
138 ape_ctx
->seektable
[i
+ 1] - ape_ctx
->seektable
[i
]);
139 if (ape_ctx
->bittable
)
140 av_log(s
, AV_LOG_DEBUG
, " + %2d bits\n",
141 ape_ctx
->bittable
[i
]);
142 av_log(s
, AV_LOG_DEBUG
, "\n");
144 av_log(s
, AV_LOG_DEBUG
, "%8d %"PRIu32
"\n", i
, ape_ctx
->seektable
[i
]);
149 av_log(s
, AV_LOG_DEBUG
, "\nFrames\n\n");
150 for (i
= 0; i
< ape_ctx
->totalframes
; i
++)
151 av_log(s
, AV_LOG_DEBUG
, "%8d %8"PRId64
" %8d (%d samples)\n", i
,
152 ape_ctx
->frames
[i
].pos
, ape_ctx
->frames
[i
].size
,
153 ape_ctx
->frames
[i
].nblocks
);
155 av_log(s
, AV_LOG_DEBUG
, "\nCalculated information:\n\n");
156 av_log(s
, AV_LOG_DEBUG
, "junklength = %"PRIu32
"\n", ape_ctx
->junklength
);
157 av_log(s
, AV_LOG_DEBUG
, "firstframe = %"PRIu32
"\n", ape_ctx
->firstframe
);
158 av_log(s
, AV_LOG_DEBUG
, "totalsamples = %"PRIu32
"\n", ape_ctx
->totalsamples
);
162 static int ape_read_header(AVFormatContext
* s
)
164 AVIOContext
*pb
= s
->pb
;
165 APEContext
*ape
= s
->priv_data
;
169 int total_blocks
, final_size
= 0;
170 int64_t pts
, file_size
;
172 /* Skip any leading junk such as id3v2 tags */
173 ape
->junklength
= avio_tell(pb
);
176 if (tag
!= MKTAG('M', 'A', 'C', ' '))
177 return AVERROR_INVALIDDATA
;
179 ape
->fileversion
= avio_rl16(pb
);
181 if (ape
->fileversion
< APE_MIN_VERSION
|| ape
->fileversion
> APE_MAX_VERSION
) {
182 av_log(s
, AV_LOG_ERROR
, "Unsupported file version - %d.%02d\n",
183 ape
->fileversion
/ 1000, (ape
->fileversion
% 1000) / 10);
184 return AVERROR_PATCHWELCOME
;
187 if (ape
->fileversion
>= 3980) {
188 ape
->padding1
= avio_rl16(pb
);
189 ape
->descriptorlength
= avio_rl32(pb
);
190 ape
->headerlength
= avio_rl32(pb
);
191 ape
->seektablelength
= avio_rl32(pb
);
192 ape
->wavheaderlength
= avio_rl32(pb
);
193 ape
->audiodatalength
= avio_rl32(pb
);
194 ape
->audiodatalength_high
= avio_rl32(pb
);
195 ape
->wavtaillength
= avio_rl32(pb
);
196 avio_read(pb
, ape
->md5
, 16);
198 /* Skip any unknown bytes at the end of the descriptor.
199 This is for future compatibility */
200 if (ape
->descriptorlength
> 52)
201 avio_skip(pb
, ape
->descriptorlength
- 52);
203 /* Read header data */
204 ape
->compressiontype
= avio_rl16(pb
);
205 ape
->formatflags
= avio_rl16(pb
);
206 ape
->blocksperframe
= avio_rl32(pb
);
207 ape
->finalframeblocks
= avio_rl32(pb
);
208 ape
->totalframes
= avio_rl32(pb
);
209 ape
->bps
= avio_rl16(pb
);
210 ape
->channels
= avio_rl16(pb
);
211 ape
->samplerate
= avio_rl32(pb
);
213 ape
->descriptorlength
= 0;
214 ape
->headerlength
= 32;
216 ape
->compressiontype
= avio_rl16(pb
);
217 ape
->formatflags
= avio_rl16(pb
);
218 ape
->channels
= avio_rl16(pb
);
219 ape
->samplerate
= avio_rl32(pb
);
220 ape
->wavheaderlength
= avio_rl32(pb
);
221 ape
->wavtaillength
= avio_rl32(pb
);
222 ape
->totalframes
= avio_rl32(pb
);
223 ape
->finalframeblocks
= avio_rl32(pb
);
225 if (ape
->formatflags
& MAC_FORMAT_FLAG_HAS_PEAK_LEVEL
) {
226 avio_skip(pb
, 4); /* Skip the peak level */
227 ape
->headerlength
+= 4;
230 if (ape
->formatflags
& MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS
) {
231 ape
->seektablelength
= avio_rl32(pb
);
232 ape
->headerlength
+= 4;
233 ape
->seektablelength
*= sizeof(int32_t);
235 ape
->seektablelength
= ape
->totalframes
* sizeof(int32_t);
237 if (ape
->formatflags
& MAC_FORMAT_FLAG_8_BIT
)
239 else if (ape
->formatflags
& MAC_FORMAT_FLAG_24_BIT
)
244 if (ape
->fileversion
>= 3950)
245 ape
->blocksperframe
= 73728 * 4;
246 else if (ape
->fileversion
>= 3900 || (ape
->fileversion
>= 3800 && ape
->compressiontype
>= 4000))
247 ape
->blocksperframe
= 73728;
249 ape
->blocksperframe
= 9216;
251 /* Skip any stored wav header */
252 if (!(ape
->formatflags
& MAC_FORMAT_FLAG_CREATE_WAV_HEADER
))
253 avio_skip(pb
, ape
->wavheaderlength
);
256 if(!ape
->totalframes
){
257 av_log(s
, AV_LOG_ERROR
, "No frames in the file!\n");
258 return AVERROR(EINVAL
);
260 if(ape
->totalframes
> UINT_MAX
/ sizeof(APEFrame
)){
261 av_log(s
, AV_LOG_ERROR
, "Too many frames: %"PRIu32
"\n",
263 return AVERROR_INVALIDDATA
;
265 if (ape
->seektablelength
/ sizeof(*ape
->seektable
) < ape
->totalframes
) {
266 av_log(s
, AV_LOG_ERROR
,
267 "Number of seek entries is less than number of frames: %"SIZE_SPECIFIER
" vs. %"PRIu32
"\n",
268 ape
->seektablelength
/ sizeof(*ape
->seektable
), ape
->totalframes
);
269 return AVERROR_INVALIDDATA
;
271 ape
->frames
= av_malloc(ape
->totalframes
* sizeof(APEFrame
));
273 return AVERROR(ENOMEM
);
274 ape
->firstframe
= ape
->junklength
+ ape
->descriptorlength
+ ape
->headerlength
+ ape
->seektablelength
+ ape
->wavheaderlength
;
275 if (ape
->fileversion
< 3810)
276 ape
->firstframe
+= ape
->totalframes
;
277 ape
->currentframe
= 0;
280 ape
->totalsamples
= ape
->finalframeblocks
;
281 if (ape
->totalframes
> 1)
282 ape
->totalsamples
+= ape
->blocksperframe
* (ape
->totalframes
- 1);
284 if (ape
->seektablelength
> 0) {
285 ape
->seektable
= av_mallocz(ape
->seektablelength
);
287 return AVERROR(ENOMEM
);
288 for (i
= 0; i
< ape
->seektablelength
/ sizeof(uint32_t) && !pb
->eof_reached
; i
++)
289 ape
->seektable
[i
] = avio_rl32(pb
);
290 if (ape
->fileversion
< 3810) {
291 ape
->bittable
= av_mallocz(ape
->totalframes
);
293 return AVERROR(ENOMEM
);
294 for (i
= 0; i
< ape
->totalframes
&& !pb
->eof_reached
; i
++)
295 ape
->bittable
[i
] = avio_r8(pb
);
298 av_log(s
, AV_LOG_WARNING
, "File truncated\n");
301 ape
->frames
[0].pos
= ape
->firstframe
;
302 ape
->frames
[0].nblocks
= ape
->blocksperframe
;
303 ape
->frames
[0].skip
= 0;
304 for (i
= 1; i
< ape
->totalframes
; i
++) {
305 ape
->frames
[i
].pos
= ape
->seektable
[i
] + ape
->junklength
;
306 ape
->frames
[i
].nblocks
= ape
->blocksperframe
;
307 ape
->frames
[i
- 1].size
= ape
->frames
[i
].pos
- ape
->frames
[i
- 1].pos
;
308 ape
->frames
[i
].skip
= (ape
->frames
[i
].pos
- ape
->frames
[0].pos
) & 3;
310 ape
->frames
[ape
->totalframes
- 1].nblocks
= ape
->finalframeblocks
;
311 /* calculate final packet size from total file size, if available */
312 file_size
= avio_size(pb
);
314 final_size
= file_size
- ape
->frames
[ape
->totalframes
- 1].pos
-
316 final_size
-= final_size
& 3;
318 if (file_size
<= 0 || final_size
<= 0)
319 final_size
= ape
->finalframeblocks
* 8;
320 ape
->frames
[ape
->totalframes
- 1].size
= final_size
;
322 for (i
= 0; i
< ape
->totalframes
; i
++) {
323 if(ape
->frames
[i
].skip
){
324 ape
->frames
[i
].pos
-= ape
->frames
[i
].skip
;
325 ape
->frames
[i
].size
+= ape
->frames
[i
].skip
;
327 ape
->frames
[i
].size
= (ape
->frames
[i
].size
+ 3) & ~3;
329 if (ape
->fileversion
< 3810) {
330 for (i
= 0; i
< ape
->totalframes
; i
++) {
331 if (i
< ape
->totalframes
- 1 && ape
->bittable
[i
+ 1])
332 ape
->frames
[i
].size
+= 4;
333 ape
->frames
[i
].skip
<<= 3;
334 ape
->frames
[i
].skip
+= ape
->bittable
[i
];
338 ape_dumpinfo(s
, ape
);
340 av_log(s
, AV_LOG_DEBUG
, "Decoding file - v%d.%02d, compression level %"PRIu16
"\n",
341 ape
->fileversion
/ 1000, (ape
->fileversion
% 1000) / 10,
342 ape
->compressiontype
);
344 /* now we are ready: build format streams */
345 st
= avformat_new_stream(s
, NULL
);
347 return AVERROR(ENOMEM
);
349 total_blocks
= (ape
->totalframes
== 0) ? 0 : ((ape
->totalframes
- 1) * ape
->blocksperframe
) + ape
->finalframeblocks
;
351 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
352 st
->codec
->codec_id
= AV_CODEC_ID_APE
;
353 st
->codec
->codec_tag
= MKTAG('A', 'P', 'E', ' ');
354 st
->codec
->channels
= ape
->channels
;
355 st
->codec
->sample_rate
= ape
->samplerate
;
356 st
->codec
->bits_per_coded_sample
= ape
->bps
;
358 st
->nb_frames
= ape
->totalframes
;
360 st
->duration
= total_blocks
;
361 avpriv_set_pts_info(st
, 64, 1, ape
->samplerate
);
363 if (ff_alloc_extradata(st
->codec
, APE_EXTRADATA_SIZE
))
364 return AVERROR(ENOMEM
);
365 AV_WL16(st
->codec
->extradata
+ 0, ape
->fileversion
);
366 AV_WL16(st
->codec
->extradata
+ 2, ape
->compressiontype
);
367 AV_WL16(st
->codec
->extradata
+ 4, ape
->formatflags
);
370 for (i
= 0; i
< ape
->totalframes
; i
++) {
371 ape
->frames
[i
].pts
= pts
;
372 av_add_index_entry(st
, ape
->frames
[i
].pos
, ape
->frames
[i
].pts
, 0, 0, AVINDEX_KEYFRAME
);
373 pts
+= ape
->blocksperframe
;
376 /* try to read APE tags */
379 avio_seek(pb
, 0, SEEK_SET
);
385 static int ape_read_packet(AVFormatContext
* s
, AVPacket
* pkt
)
389 APEContext
*ape
= s
->priv_data
;
390 uint32_t extra_size
= 8;
392 if (avio_feof(s
->pb
))
394 if (ape
->currentframe
>= ape
->totalframes
)
397 if (avio_seek(s
->pb
, ape
->frames
[ape
->currentframe
].pos
, SEEK_SET
) < 0)
400 /* Calculate how many blocks there are in this frame */
401 if (ape
->currentframe
== (ape
->totalframes
- 1))
402 nblocks
= ape
->finalframeblocks
;
404 nblocks
= ape
->blocksperframe
;
406 if (ape
->frames
[ape
->currentframe
].size
<= 0 ||
407 ape
->frames
[ape
->currentframe
].size
> INT_MAX
- extra_size
) {
408 av_log(s
, AV_LOG_ERROR
, "invalid packet size: %d\n",
409 ape
->frames
[ape
->currentframe
].size
);
414 if (av_new_packet(pkt
, ape
->frames
[ape
->currentframe
].size
+ extra_size
) < 0)
415 return AVERROR(ENOMEM
);
417 AV_WL32(pkt
->data
, nblocks
);
418 AV_WL32(pkt
->data
+ 4, ape
->frames
[ape
->currentframe
].skip
);
419 ret
= avio_read(s
->pb
, pkt
->data
+ extra_size
, ape
->frames
[ape
->currentframe
].size
);
425 pkt
->pts
= ape
->frames
[ape
->currentframe
].pts
;
426 pkt
->stream_index
= 0;
428 /* note: we need to modify the packet size here to handle the last
430 pkt
->size
= ret
+ extra_size
;
437 static int ape_read_close(AVFormatContext
* s
)
439 APEContext
*ape
= s
->priv_data
;
441 av_freep(&ape
->frames
);
442 av_freep(&ape
->seektable
);
443 av_freep(&ape
->bittable
);
447 static int ape_read_seek(AVFormatContext
*s
, int stream_index
, int64_t timestamp
, int flags
)
449 AVStream
*st
= s
->streams
[stream_index
];
450 APEContext
*ape
= s
->priv_data
;
451 int index
= av_index_search_timestamp(st
, timestamp
, flags
);
456 if (avio_seek(s
->pb
, st
->index_entries
[index
].pos
, SEEK_SET
) < 0)
458 ape
->currentframe
= index
;
462 AVInputFormat ff_ape_demuxer
= {
464 .long_name
= NULL_IF_CONFIG_SMALL("Monkey's Audio"),
465 .priv_data_size
= sizeof(APEContext
),
466 .read_probe
= ape_probe
,
467 .read_header
= ape_read_header
,
468 .read_packet
= ape_read_packet
,
469 .read_close
= ape_read_close
,
470 .read_seek
= ape_read_seek
,
471 .extensions
= "ape,apl,mac",