Main Page
Related Pages
Modules
Data Structures
Files
Examples
File List
Globals
libavformat
ape.c
Go to the documentation of this file.
1
/*
2
* Monkey's Audio APE demuxer
3
* Copyright (c) 2007 Benjamin Zores <ben@geexbox.org>
4
* based upon libdemac from Dave Chapman.
5
*
6
* This file is part of Libav.
7
*
8
* Libav 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.
12
*
13
* Libav 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.
17
*
18
* You should have received a copy of the GNU Lesser General Public
19
* License along with Libav; if not, write to the Free Software
20
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
*/
22
23
#include <stdio.h>
24
25
#include "
libavutil/intreadwrite.h
"
26
#include "
avformat.h
"
27
#include "
internal.h
"
28
#include "
apetag.h
"
29
30
/* The earliest and latest file formats supported by this library */
31
#define APE_MIN_VERSION 3950
32
#define APE_MAX_VERSION 3990
33
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)
40
41
#define MAC_SUBFRAME_SIZE 4608
42
43
#define APE_EXTRADATA_SIZE 6
44
45
typedef
struct
{
46
int64_t
pos
;
47
int
nblocks
;
48
int
size
;
49
int
skip
;
50
int64_t
pts
;
51
}
APEFrame
;
52
53
typedef
struct
{
54
/* Derived fields */
55
uint32_t
junklength
;
56
uint32_t
firstframe
;
57
uint32_t
totalsamples
;
58
int
currentframe
;
59
APEFrame
*
frames
;
60
61
/* Info from Descriptor Block */
62
char
magic[4];
63
int16_t
fileversion
;
64
int16_t
padding1
;
65
uint32_t
descriptorlength
;
66
uint32_t
headerlength
;
67
uint32_t
seektablelength
;
68
uint32_t
wavheaderlength
;
69
uint32_t
audiodatalength
;
70
uint32_t
audiodatalength_high
;
71
uint32_t
wavtaillength
;
72
uint8_t md5[16];
73
74
/* Info from Header Block */
75
uint16_t
compressiontype
;
76
uint16_t
formatflags
;
77
uint32_t
blocksperframe
;
78
uint32_t
finalframeblocks
;
79
uint32_t
totalframes
;
80
uint16_t
bps
;
81
uint16_t
channels
;
82
uint32_t
samplerate
;
83
84
/* Seektable */
85
uint32_t *
seektable
;
86
}
APEContext
;
87
88
static
int
ape_probe
(
AVProbeData
* p)
89
{
90
if
(p->
buf
[0] ==
'M'
&& p->
buf
[1] ==
'A'
&& p->
buf
[2] ==
'C'
&& p->
buf
[3] ==
' '
)
91
return
AVPROBE_SCORE_MAX
;
92
93
return
0;
94
}
95
96
static
void
ape_dumpinfo
(
AVFormatContext
* s,
APEContext
* ape_ctx)
97
{
98
#ifdef DEBUG
99
int
i;
100
101
av_log
(s,
AV_LOG_DEBUG
,
"Descriptor Block:\n\n"
);
102
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]);
103
av_log
(s,
AV_LOG_DEBUG
,
"fileversion = %"
PRId16
"\n"
, ape_ctx->
fileversion
);
104
av_log
(s,
AV_LOG_DEBUG
,
"descriptorlength = %"
PRIu32
"\n"
, ape_ctx->
descriptorlength
);
105
av_log
(s,
AV_LOG_DEBUG
,
"headerlength = %"
PRIu32
"\n"
, ape_ctx->
headerlength
);
106
av_log
(s,
AV_LOG_DEBUG
,
"seektablelength = %"
PRIu32
"\n"
, ape_ctx->
seektablelength
);
107
av_log
(s,
AV_LOG_DEBUG
,
"wavheaderlength = %"
PRIu32
"\n"
, ape_ctx->
wavheaderlength
);
108
av_log
(s,
AV_LOG_DEBUG
,
"audiodatalength = %"
PRIu32
"\n"
, ape_ctx->
audiodatalength
);
109
av_log
(s,
AV_LOG_DEBUG
,
"audiodatalength_high = %"
PRIu32
"\n"
, ape_ctx->
audiodatalength_high
);
110
av_log
(s,
AV_LOG_DEBUG
,
"wavtaillength = %"
PRIu32
"\n"
, ape_ctx->
wavtaillength
);
111
av_log
(s,
AV_LOG_DEBUG
,
"md5 = "
);
112
for
(i = 0; i < 16; i++)
113
av_log
(s,
AV_LOG_DEBUG
,
"%02x"
, ape_ctx->
md5
[i]);
114
av_log
(s,
AV_LOG_DEBUG
,
"\n"
);
115
116
av_log
(s,
AV_LOG_DEBUG
,
"\nHeader Block:\n\n"
);
117
118
av_log
(s,
AV_LOG_DEBUG
,
"compressiontype = %"
PRIu16
"\n"
, ape_ctx->
compressiontype
);
119
av_log
(s,
AV_LOG_DEBUG
,
"formatflags = %"
PRIu16
"\n"
, ape_ctx->
formatflags
);
120
av_log
(s,
AV_LOG_DEBUG
,
"blocksperframe = %"
PRIu32
"\n"
, ape_ctx->
blocksperframe
);
121
av_log
(s,
AV_LOG_DEBUG
,
"finalframeblocks = %"
PRIu32
"\n"
, ape_ctx->
finalframeblocks
);
122
av_log
(s,
AV_LOG_DEBUG
,
"totalframes = %"
PRIu32
"\n"
, ape_ctx->
totalframes
);
123
av_log
(s,
AV_LOG_DEBUG
,
"bps = %"
PRIu16
"\n"
, ape_ctx->
bps
);
124
av_log
(s,
AV_LOG_DEBUG
,
"channels = %"
PRIu16
"\n"
, ape_ctx->
channels
);
125
av_log
(s,
AV_LOG_DEBUG
,
"samplerate = %"
PRIu32
"\n"
, ape_ctx->
samplerate
);
126
127
av_log
(s,
AV_LOG_DEBUG
,
"\nSeektable\n\n"
);
128
if
((ape_ctx->
seektablelength
/
sizeof
(uint32_t)) != ape_ctx->
totalframes
) {
129
av_log
(s,
AV_LOG_DEBUG
,
"No seektable\n"
);
130
}
else
{
131
for
(i = 0; i < ape_ctx->
seektablelength
/
sizeof
(uint32_t); i++) {
132
if
(i < ape_ctx->totalframes - 1) {
133
av_log
(s,
AV_LOG_DEBUG
,
"%8d %"
PRIu32
" (%"
PRIu32
" bytes)\n"
,
134
i, ape_ctx->
seektable
[i],
135
ape_ctx->
seektable
[i + 1] - ape_ctx->
seektable
[i]);
136
}
else
{
137
av_log
(s,
AV_LOG_DEBUG
,
"%8d %"
PRIu32
"\n"
, i, ape_ctx->
seektable
[i]);
138
}
139
}
140
}
141
142
av_log
(s,
AV_LOG_DEBUG
,
"\nFrames\n\n"
);
143
for
(i = 0; i < ape_ctx->
totalframes
; i++)
144
av_log
(s,
AV_LOG_DEBUG
,
"%8d %8"
PRId64
" %8d (%d samples)\n"
, i,
145
ape_ctx->
frames
[i].
pos
, ape_ctx->
frames
[i].
size
,
146
ape_ctx->
frames
[i].
nblocks
);
147
148
av_log
(s,
AV_LOG_DEBUG
,
"\nCalculated information:\n\n"
);
149
av_log
(s,
AV_LOG_DEBUG
,
"junklength = %"
PRIu32
"\n"
, ape_ctx->
junklength
);
150
av_log
(s,
AV_LOG_DEBUG
,
"firstframe = %"
PRIu32
"\n"
, ape_ctx->
firstframe
);
151
av_log
(s,
AV_LOG_DEBUG
,
"totalsamples = %"
PRIu32
"\n"
, ape_ctx->
totalsamples
);
152
#endif
153
}
154
155
static
int
ape_read_header
(
AVFormatContext
* s,
AVFormatParameters
* ap)
156
{
157
AVIOContext
*pb = s->
pb
;
158
APEContext
*ape = s->
priv_data
;
159
AVStream
*st;
160
uint32_t
tag
;
161
int
i;
162
int
total_blocks;
163
int64_t pts;
164
165
/* Skip any leading junk such as id3v2 tags */
166
ape->
junklength
=
avio_tell
(pb);
167
168
tag =
avio_rl32
(pb);
169
if
(tag !=
MKTAG
(
'M'
,
'A'
,
'C'
,
' '
))
170
return
-1;
171
172
ape->
fileversion
=
avio_rl16
(pb);
173
174
if
(ape->
fileversion
<
APE_MIN_VERSION
|| ape->
fileversion
>
APE_MAX_VERSION
) {
175
av_log
(s,
AV_LOG_ERROR
,
"Unsupported file version - %d.%02d\n"
,
176
ape->
fileversion
/ 1000, (ape->
fileversion
% 1000) / 10);
177
return
-1;
178
}
179
180
if
(ape->
fileversion
>= 3980) {
181
ape->
padding1
=
avio_rl16
(pb);
182
ape->
descriptorlength
=
avio_rl32
(pb);
183
ape->
headerlength
=
avio_rl32
(pb);
184
ape->
seektablelength
=
avio_rl32
(pb);
185
ape->
wavheaderlength
=
avio_rl32
(pb);
186
ape->
audiodatalength
=
avio_rl32
(pb);
187
ape->
audiodatalength_high
=
avio_rl32
(pb);
188
ape->
wavtaillength
=
avio_rl32
(pb);
189
avio_read
(pb, ape->
md5
, 16);
190
191
/* Skip any unknown bytes at the end of the descriptor.
192
This is for future compatibility */
193
if
(ape->
descriptorlength
> 52)
194
avio_skip
(pb, ape->
descriptorlength
- 52);
195
196
/* Read header data */
197
ape->
compressiontype
=
avio_rl16
(pb);
198
ape->
formatflags
=
avio_rl16
(pb);
199
ape->
blocksperframe
=
avio_rl32
(pb);
200
ape->
finalframeblocks
=
avio_rl32
(pb);
201
ape->
totalframes
=
avio_rl32
(pb);
202
ape->
bps
=
avio_rl16
(pb);
203
ape->
channels
=
avio_rl16
(pb);
204
ape->
samplerate
=
avio_rl32
(pb);
205
}
else
{
206
ape->
descriptorlength
= 0;
207
ape->
headerlength
= 32;
208
209
ape->
compressiontype
=
avio_rl16
(pb);
210
ape->
formatflags
=
avio_rl16
(pb);
211
ape->
channels
=
avio_rl16
(pb);
212
ape->
samplerate
=
avio_rl32
(pb);
213
ape->
wavheaderlength
=
avio_rl32
(pb);
214
ape->
wavtaillength
=
avio_rl32
(pb);
215
ape->
totalframes
=
avio_rl32
(pb);
216
ape->
finalframeblocks
=
avio_rl32
(pb);
217
218
if
(ape->
formatflags
&
MAC_FORMAT_FLAG_HAS_PEAK_LEVEL
) {
219
avio_skip
(pb, 4);
/* Skip the peak level */
220
ape->
headerlength
+= 4;
221
}
222
223
if
(ape->
formatflags
&
MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS
) {
224
ape->
seektablelength
=
avio_rl32
(pb);
225
ape->
headerlength
+= 4;
226
ape->
seektablelength
*=
sizeof
(int32_t);
227
}
else
228
ape->
seektablelength
= ape->
totalframes
*
sizeof
(int32_t);
229
230
if
(ape->
formatflags
&
MAC_FORMAT_FLAG_8_BIT
)
231
ape->
bps
= 8;
232
else
if
(ape->
formatflags
&
MAC_FORMAT_FLAG_24_BIT
)
233
ape->
bps
= 24;
234
else
235
ape->
bps
= 16;
236
237
if
(ape->
fileversion
>= 3950)
238
ape->
blocksperframe
= 73728 * 4;
239
else
if
(ape->
fileversion
>= 3900 || (ape->
fileversion
>= 3800 && ape->
compressiontype
>= 4000))
240
ape->
blocksperframe
= 73728;
241
else
242
ape->
blocksperframe
= 9216;
243
244
/* Skip any stored wav header */
245
if (!(ape->
formatflags
&
MAC_FORMAT_FLAG_CREATE_WAV_HEADER
))
246
avio_skip
(pb, ape->
wavheaderlength
);
247
}
248
249
if
(!ape->
totalframes
){
250
av_log
(s,
AV_LOG_ERROR
,
"No frames in the file!\n"
);
251
return
AVERROR
(EINVAL);
252
}
253
if
(ape->
totalframes
> UINT_MAX /
sizeof
(
APEFrame
)){
254
av_log
(s,
AV_LOG_ERROR
,
"Too many frames: %"
PRIu32
"\n"
,
255
ape->
totalframes
);
256
return
-1;
257
}
258
if
(ape->
seektablelength
/
sizeof
(*ape->
seektable
) < ape->
totalframes
) {
259
av_log
(s,
AV_LOG_ERROR
,
260
"Number of seek entries is less than number of frames: %zu vs. %"
PRIu32
"\n"
,
261
ape->
seektablelength
/
sizeof
(*ape->
seektable
), ape->
totalframes
);
262
return
AVERROR_INVALIDDATA
;
263
}
264
ape->
frames
=
av_malloc
(ape->
totalframes
*
sizeof
(
APEFrame
));
265
if
(!ape->
frames
)
266
return
AVERROR
(ENOMEM);
267
ape->
firstframe
= ape->
junklength
+ ape->
descriptorlength
+ ape->
headerlength
+ ape->
seektablelength
+ ape->
wavheaderlength
;
268
ape->
currentframe
= 0;
269
270
271
ape->
totalsamples
= ape->
finalframeblocks
;
272
if
(ape->
totalframes
> 1)
273
ape->
totalsamples
+= ape->
blocksperframe
* (ape->
totalframes
- 1);
274
275
if
(ape->
seektablelength
> 0) {
276
ape->
seektable
=
av_malloc
(ape->
seektablelength
);
277
if
(!ape->
seektable
)
278
return
AVERROR
(ENOMEM);
279
for
(i = 0;
280
i < ape->
seektablelength
/
sizeof
(uint32_t) && !pb->
eof_reached
;
281
i++)
282
ape->
seektable
[i] =
avio_rl32
(pb);
283
}
284
285
ape->
frames
[0].
pos
= ape->
firstframe
;
286
ape->
frames
[0].
nblocks
= ape->
blocksperframe
;
287
ape->
frames
[0].
skip
= 0;
288
for
(i = 1; i < ape->
totalframes
; i++) {
289
ape->
frames
[i].
pos
= ape->
seektable
[i] + ape->
junklength
;
290
ape->
frames
[i].
nblocks
= ape->
blocksperframe
;
291
ape->
frames
[i - 1].
size
= ape->
frames
[i].
pos
- ape->
frames
[i - 1].
pos
;
292
ape->
frames
[i].
skip
= (ape->
frames
[i].
pos
- ape->
frames
[0].
pos
) & 3;
293
}
294
ape->
frames
[ape->
totalframes
- 1].
size
= ape->
finalframeblocks
* 4;
295
ape->
frames
[ape->
totalframes
- 1].
nblocks
= ape->
finalframeblocks
;
296
297
for
(i = 0; i < ape->
totalframes
; i++) {
298
if
(ape->
frames
[i].
skip
){
299
ape->
frames
[i].
pos
-= ape->
frames
[i].
skip
;
300
ape->
frames
[i].
size
+= ape->
frames
[i].
skip
;
301
}
302
ape->
frames
[i].
size
= (ape->
frames
[i].
size
+ 3) & ~3;
303
}
304
305
306
ape_dumpinfo
(s, ape);
307
308
/* try to read APE tags */
309
if
(pb->
seekable
) {
310
ff_ape_parse_tag
(s);
311
avio_seek
(pb, 0, SEEK_SET);
312
}
313
314
av_log
(s,
AV_LOG_DEBUG
,
"Decoding file - v%d.%02d, compression level %"
PRIu16
"\n"
,
315
ape->
fileversion
/ 1000, (ape->
fileversion
% 1000) / 10,
316
ape->
compressiontype
);
317
318
/* now we are ready: build format streams */
319
st =
avformat_new_stream
(s,
NULL
);
320
if
(!st)
321
return
-1;
322
323
total_blocks = (ape->
totalframes
== 0) ? 0 : ((ape->
totalframes
- 1) * ape->
blocksperframe
) + ape->
finalframeblocks
;
324
325
st->
codec
->
codec_type
=
AVMEDIA_TYPE_AUDIO
;
326
st->
codec
->
codec_id
=
CODEC_ID_APE
;
327
st->
codec
->
codec_tag
=
MKTAG
(
'A'
,
'P'
,
'E'
,
' '
);
328
st->
codec
->
channels
= ape->
channels
;
329
st->
codec
->
sample_rate
= ape->
samplerate
;
330
st->
codec
->
bits_per_coded_sample
= ape->
bps
;
331
st->
codec
->
frame_size
=
MAC_SUBFRAME_SIZE
;
332
333
st->
nb_frames
= ape->
totalframes
;
334
st->
start_time
= 0;
335
st->
duration
= total_blocks /
MAC_SUBFRAME_SIZE
;
336
avpriv_set_pts_info
(st, 64,
MAC_SUBFRAME_SIZE
, ape->
samplerate
);
337
338
st->
codec
->
extradata
=
av_malloc
(
APE_EXTRADATA_SIZE
);
339
st->
codec
->
extradata_size
=
APE_EXTRADATA_SIZE
;
340
AV_WL16
(st->
codec
->
extradata
+ 0, ape->
fileversion
);
341
AV_WL16
(st->
codec
->
extradata
+ 2, ape->
compressiontype
);
342
AV_WL16
(st->
codec
->
extradata
+ 4, ape->
formatflags
);
343
344
pts = 0;
345
for
(i = 0; i < ape->
totalframes
; i++) {
346
ape->
frames
[i].
pts
= pts;
347
av_add_index_entry
(st, ape->
frames
[i].
pos
, ape->
frames
[i].
pts
, 0, 0,
AVINDEX_KEYFRAME
);
348
pts += ape->
blocksperframe
/
MAC_SUBFRAME_SIZE
;
349
}
350
351
return
0;
352
}
353
354
static
int
ape_read_packet
(
AVFormatContext
* s,
AVPacket
* pkt)
355
{
356
int
ret;
357
int
nblocks;
358
APEContext
*ape = s->
priv_data
;
359
uint32_t
extra_size
= 8;
360
361
if
(s->
pb
->
eof_reached
)
362
return
AVERROR
(EIO);
363
if
(ape->
currentframe
> ape->
totalframes
)
364
return
AVERROR
(EIO);
365
366
avio_seek
(s->
pb
, ape->
frames
[ape->
currentframe
].
pos
, SEEK_SET);
367
368
/* Calculate how many blocks there are in this frame */
369
if
(ape->
currentframe
== (ape->
totalframes
- 1))
370
nblocks = ape->
finalframeblocks
;
371
else
372
nblocks = ape->
blocksperframe
;
373
374
if
(
av_new_packet
(pkt, ape->
frames
[ape->
currentframe
].
size
+ extra_size) < 0)
375
return
AVERROR
(ENOMEM);
376
377
AV_WL32
(pkt->
data
, nblocks);
378
AV_WL32
(pkt->
data
+ 4, ape->
frames
[ape->
currentframe
].
skip
);
379
ret =
avio_read
(s->
pb
, pkt->
data
+ extra_size, ape->
frames
[ape->
currentframe
].
size
);
380
381
pkt->
pts
= ape->
frames
[ape->
currentframe
].
pts
;
382
pkt->
stream_index
= 0;
383
384
/* note: we need to modify the packet size here to handle the last
385
packet */
386
pkt->
size
= ret +
extra_size
;
387
388
ape->
currentframe
++;
389
390
return
0;
391
}
392
393
static
int
ape_read_close
(
AVFormatContext
* s)
394
{
395
APEContext
*ape = s->
priv_data
;
396
397
av_freep
(&ape->
frames
);
398
av_freep
(&ape->
seektable
);
399
return
0;
400
}
401
402
static
int
ape_read_seek
(
AVFormatContext
*s,
int
stream_index, int64_t timestamp,
int
flags
)
403
{
404
AVStream
*st = s->
streams
[stream_index];
405
APEContext
*ape = s->
priv_data
;
406
int
index
=
av_index_search_timestamp
(st, timestamp, flags);
407
408
if
(index < 0)
409
return
-1;
410
411
ape->
currentframe
=
index
;
412
return
0;
413
}
414
415
AVInputFormat
ff_ape_demuxer
= {
416
.
name
=
"ape"
,
417
.long_name =
NULL_IF_CONFIG_SMALL
(
"Monkey's Audio"
),
418
.priv_data_size =
sizeof
(
APEContext
),
419
.
read_probe
=
ape_probe
,
420
.
read_header
=
ape_read_header
,
421
.
read_packet
=
ape_read_packet
,
422
.
read_close
=
ape_read_close
,
423
.
read_seek
=
ape_read_seek
,
424
.extensions =
"ape,apl,mac"
425
};