mirror of
https://github.com/vgmstream/vgmstream.git
synced 2024-12-13 23:31:05 +01:00
b95f41a330
git-svn-id: https://vgmstream.svn.sourceforge.net/svnroot/vgmstream@276 51a99a44-fe44-0410-b1ba-c3e57ba2b86b
306 lines
10 KiB
C
306 lines
10 KiB
C
#include "meta.h"
|
|
#include "../layout/layout.h"
|
|
#include "../util.h"
|
|
|
|
/* Audio Interchange File Format AIFF-C */
|
|
/* also plain AIFF, for good measure */
|
|
|
|
/* Included primarily for 3DO */
|
|
|
|
/* for reading integers inexplicably packed into 80 bit floats */
|
|
uint32_t read80bitSANE(off_t offset, STREAMFILE *streamFile) {
|
|
uint8_t buf[10];
|
|
int32_t exponent;
|
|
int32_t mantissa;
|
|
int i;
|
|
|
|
if (read_streamfile(buf,offset,10,streamFile) != 10) return 0;
|
|
|
|
exponent = ((buf[0]<<8)|(buf[1]))&0x7fff;
|
|
exponent -= 16383;
|
|
|
|
mantissa = 0;
|
|
for (i=0;i<8;i++) {
|
|
int32_t shift = exponent-7-i*8;
|
|
if (shift >= 0)
|
|
mantissa |= buf[i+2] << shift;
|
|
else if (shift > -8)
|
|
mantissa |= buf[i+2] >> -shift;
|
|
}
|
|
|
|
return mantissa*((buf[0]&0x80)?-1:1);
|
|
}
|
|
|
|
uint32_t find_marker(STREAMFILE *streamFile, off_t MarkerChunkOffset,
|
|
int marker_id) {
|
|
uint16_t marker_count;
|
|
int i;
|
|
off_t marker_offset;
|
|
|
|
marker_count = read_16bitBE(MarkerChunkOffset+8,streamFile);
|
|
marker_offset = MarkerChunkOffset+10;
|
|
for (i=0;i<marker_count;i++) {
|
|
int name_length;
|
|
|
|
if (read_16bitBE(marker_offset,streamFile) == marker_id)
|
|
return read_32bitBE(marker_offset+2,streamFile);
|
|
|
|
name_length = (uint8_t)read_8bit(marker_offset+6,streamFile) + 1;
|
|
if (name_length % 2) name_length++;
|
|
marker_offset += 6 + name_length;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
VGMSTREAM * init_vgmstream_aifc(STREAMFILE *streamFile) {
|
|
VGMSTREAM * vgmstream = NULL;
|
|
char filename[260];
|
|
|
|
off_t file_size = -1;
|
|
int channel_count = 0;
|
|
int sample_count = 0;
|
|
int sample_size = 0;
|
|
int sample_rate = 0;
|
|
int coding_type = -1;
|
|
off_t start_offset = -1;
|
|
int interleave = -1;
|
|
|
|
int loop_flag = 0;
|
|
int32_t loop_start = -1;
|
|
int32_t loop_end = -1;
|
|
|
|
int AIFFext = 0;
|
|
int AIFCext = 0;
|
|
int AIFF = 0;
|
|
int AIFC = 0;
|
|
int FormatVersionChunkFound = 0;
|
|
int CommonChunkFound = 0;
|
|
int SoundDataChunkFound = 0;
|
|
int MarkerChunkFound = 0;
|
|
off_t MarkerChunkOffset = -1;
|
|
int InstrumentChunkFound =0;
|
|
off_t InstrumentChunkOffset = -1;
|
|
|
|
/* check extension, case insensitive */
|
|
streamFile->get_name(streamFile,filename,sizeof(filename));
|
|
if (!strcasecmp("aifc",filename_extension(filename)) ||
|
|
!strcasecmp("afc",filename_extension(filename)) ||
|
|
!strcasecmp("aifcl",filename_extension(filename)))
|
|
{
|
|
AIFCext = 1;
|
|
}
|
|
else if (!strcasecmp("aiff",filename_extension(filename)) ||
|
|
!strcasecmp("aif",filename_extension(filename)) ||
|
|
!strcasecmp("aiffl",filename_extension(filename)))
|
|
{
|
|
AIFFext = 1;
|
|
}
|
|
else goto fail;
|
|
|
|
/* check header */
|
|
if ((uint32_t)read_32bitBE(0,streamFile)==0x464F524D && /* "FORM" */
|
|
/* check that file = header (8) + data */
|
|
(uint32_t)read_32bitBE(4,streamFile)+8==get_streamfile_size(streamFile))
|
|
{
|
|
if ((uint32_t)read_32bitBE(8,streamFile)==0x41494643) /* "AIFC" */
|
|
{
|
|
if (!AIFCext) goto fail;
|
|
AIFC = 1;
|
|
}
|
|
else if ((uint32_t)read_32bitBE(8,streamFile)==0x41494646) /* "AIFF" */
|
|
{
|
|
if (!AIFFext) goto fail;
|
|
AIFF = 1;
|
|
}
|
|
else goto fail;
|
|
} else goto fail;
|
|
|
|
file_size = get_streamfile_size(streamFile);
|
|
|
|
/* read through chunks to verify format and find metadata */
|
|
{
|
|
off_t current_chunk = 0xc; /* start with first chunk within FORM */
|
|
|
|
while (current_chunk < file_size) {
|
|
uint32_t chunk_type = read_32bitBE(current_chunk,streamFile);
|
|
off_t chunk_size = read_32bitBE(current_chunk+4,streamFile);
|
|
|
|
/* chunks must be padded to an even number of bytes but chunk
|
|
* size does not include that padding */
|
|
if (chunk_size % 2) chunk_size++;
|
|
|
|
if (current_chunk+8+chunk_size > file_size) goto fail;
|
|
|
|
switch(chunk_type) {
|
|
case 0x46564552: /* FVER */
|
|
/* only one per file */
|
|
if (FormatVersionChunkFound) goto fail;
|
|
/* plain AIFF shouldn't have */
|
|
if (AIFF) goto fail;
|
|
FormatVersionChunkFound = 1;
|
|
|
|
/* specific size */
|
|
if (chunk_size != 4) goto fail;
|
|
|
|
/* Version 1 of AIFF-C spec timestamp */
|
|
if ((uint32_t)read_32bitBE(current_chunk+8,streamFile) !=
|
|
0xA2805140) goto fail;
|
|
break;
|
|
case 0x434F4D4D: /* COMM */
|
|
/* only one per file */
|
|
if (CommonChunkFound) goto fail;
|
|
CommonChunkFound = 1;
|
|
|
|
channel_count = read_16bitBE(current_chunk+8,streamFile);
|
|
if (channel_count <= 0) goto fail;
|
|
|
|
sample_count = (uint32_t)read_32bitBE(current_chunk+0xa,streamFile);
|
|
|
|
sample_size = read_16bitBE(current_chunk+0xe,streamFile);
|
|
|
|
sample_rate = read80bitSANE(current_chunk+0x10,streamFile);
|
|
|
|
if (AIFC) {
|
|
switch (read_32bitBE(current_chunk+0x1a,streamFile)) {
|
|
case 0x53445832: /* SDX2 */
|
|
coding_type = coding_SDX2;
|
|
interleave = 1;
|
|
break;
|
|
case 0x41445034: /* ADP4 */
|
|
coding_type = coding_DVI_IMA;
|
|
/* don't know how stereo DVI is laid out */
|
|
if (channel_count != 1) break;
|
|
break;
|
|
default:
|
|
/* we should probably support uncompressed here */
|
|
goto fail;
|
|
}
|
|
} else if (AIFF) {
|
|
switch (sample_size) {
|
|
case 8:
|
|
coding_type = coding_PCM8;
|
|
interleave = 1;
|
|
break;
|
|
case 16:
|
|
coding_type = coding_PCM16BE;
|
|
interleave = 2;
|
|
break;
|
|
/* 32 is a possibility, but we don't see it and I
|
|
* don't have a reader for it yet */
|
|
default:
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
/* we don't check the human-readable portion of AIFF-C*/
|
|
|
|
break;
|
|
case 0x53534E44: /* SSND */
|
|
/* at most one per file */
|
|
if (SoundDataChunkFound) goto fail;
|
|
SoundDataChunkFound = 1;
|
|
|
|
start_offset = current_chunk + 16 + read_32bitBE(current_chunk+8,streamFile);
|
|
break;
|
|
case 0x4D41524B: /* MARK */
|
|
if (MarkerChunkFound) goto fail;
|
|
MarkerChunkFound = 1;
|
|
MarkerChunkOffset = current_chunk;
|
|
break;
|
|
case 0x494E5354: /* INST */
|
|
if (InstrumentChunkFound) goto fail;
|
|
InstrumentChunkFound = 1;
|
|
InstrumentChunkOffset = current_chunk;
|
|
break;
|
|
default:
|
|
/* spec says we can skip unrecognized chunks */
|
|
break;
|
|
}
|
|
|
|
current_chunk += 8+chunk_size;
|
|
}
|
|
}
|
|
|
|
if (AIFC) {
|
|
if (!FormatVersionChunkFound || !CommonChunkFound || !SoundDataChunkFound)
|
|
goto fail;
|
|
} else if (AIFF) {
|
|
if (!CommonChunkFound || !SoundDataChunkFound)
|
|
goto fail;
|
|
}
|
|
|
|
/* read loop points */
|
|
if (InstrumentChunkFound && MarkerChunkFound) {
|
|
int start_marker;
|
|
int end_marker;
|
|
/* use the sustain loop */
|
|
/* if playMode=ForwardLooping */
|
|
if (read_16bitBE(InstrumentChunkOffset+16,streamFile) == 1) {
|
|
start_marker = read_16bitBE(InstrumentChunkOffset+18,streamFile);
|
|
end_marker = read_16bitBE(InstrumentChunkOffset+20,streamFile);
|
|
/* check for sustain markers != 0 (invalid marker no) */
|
|
if (start_marker && end_marker) {
|
|
/* find start marker */
|
|
loop_start = find_marker(streamFile,MarkerChunkOffset,start_marker);
|
|
loop_end = find_marker(streamFile,MarkerChunkOffset,end_marker);
|
|
|
|
/* find_marker is type uint32_t as the spec says that's the type
|
|
* of the position value, but it returns a -1 on error, and the
|
|
* loop_start and loop_end variables are int32_t, so the error
|
|
* will become apparent.
|
|
* We shouldn't have a loop point that overflows an int32_t
|
|
* anyway. */
|
|
loop_flag = 1;
|
|
if (loop_start==loop_end) loop_flag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* build the VGMSTREAM */
|
|
|
|
vgmstream = allocate_vgmstream(channel_count,loop_flag);
|
|
if (!vgmstream) goto fail;
|
|
|
|
/* fill in the vital statistics */
|
|
vgmstream->num_samples = sample_count;
|
|
vgmstream->sample_rate = sample_rate;
|
|
|
|
vgmstream->coding_type = coding_type;
|
|
if (channel_count > 1)
|
|
vgmstream->layout_type = layout_interleave;
|
|
else
|
|
vgmstream->layout_type = layout_none;
|
|
vgmstream->interleave_block_size = interleave;
|
|
vgmstream->loop_start_sample = loop_start;
|
|
vgmstream->loop_end_sample = loop_end;
|
|
|
|
if (AIFC)
|
|
vgmstream->meta_type = meta_AIFC;
|
|
else if (AIFF)
|
|
vgmstream->meta_type = meta_AIFF;
|
|
|
|
/* open the file, set up each channel */
|
|
{
|
|
int i;
|
|
|
|
vgmstream->ch[0].streamfile = streamFile->open(streamFile,filename,
|
|
STREAMFILE_DEFAULT_BUFFER_SIZE);
|
|
if (!vgmstream->ch[0].streamfile) goto fail;
|
|
|
|
for (i=0;i<channel_count;i++) {
|
|
vgmstream->ch[i].streamfile = vgmstream->ch[0].streamfile;
|
|
vgmstream->ch[i].offset = vgmstream->ch[i].channel_start_offset =
|
|
start_offset+i*interleave;
|
|
}
|
|
}
|
|
|
|
|
|
return vgmstream;
|
|
|
|
/* clean up anything we may have opened */
|
|
fail:
|
|
if (vgmstream) close_vgmstream(vgmstream);
|
|
return NULL;
|
|
}
|