/*
Parse voice header chunk.
*/
static status ParseVHDR (AFfilehandle file, AFvirtualfile *fh, uint32_t type,
size_t size)
{
_Track *track;
uint32_t oneShotSamples, repeatSamples, samplesPerRepeat;
uint16_t sampleRate;
uint8_t octaves, compression;
uint32_t volume;
assert(!memcmp(&type, "VHDR", 4));
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_read_uint32_be(&oneShotSamples, fh);
af_read_uint32_be(&repeatSamples, fh);
af_read_uint32_be(&samplesPerRepeat, fh);
af_read_uint16_be(&sampleRate, fh);
af_read_uint8(&octaves, fh);
af_read_uint8(&compression, fh);
af_read_uint32_be(&volume, fh);
track->f.sampleWidth = 8;
track->f.sampleRate = sampleRate;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
track->f.channelCount = 1;
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
/*
Parse voice header chunk.
*/
status IFFFile::parseVHDR(const Tag &type, size_t size)
{
assert(type == "VHDR");
Track *track = getTrack();
uint32_t oneShotSamples, repeatSamples, samplesPerRepeat;
uint16_t sampleRate;
uint8_t octaves, compression;
uint32_t volume;
readU32(&oneShotSamples);
readU32(&repeatSamples);
readU32(&samplesPerRepeat);
readU16(&sampleRate);
readU8(&octaves);
readU8(&compression);
readU32(&volume);
track->f.sampleWidth = 8;
track->f.sampleRate = sampleRate;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
track->f.channelCount = 1;
track->f.framesPerPacket = 1;
track->f.computeBytesPerPacketPCM();
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
AFfilesetup CAFFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "CAF file must have 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = &setup->tracks[0];
if (track->sampleFormatSet)
{
if (track->f.isUnsigned())
{
_af_error(AF_BAD_FILEFMT, "CAF format does not support unsigned data");
return AF_NULL_FILESETUP;
}
}
else
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP,
track->f.sampleWidth);
if (track->f.isSigned() && (track->f.sampleWidth < 1 || track->f.sampleWidth > 32))
{
_af_error(AF_BAD_WIDTH,
"invalid sample width %d for CAF file (must be 1-32)",
track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
if (!track->byteOrderSet)
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
if (track->f.compressionType != AF_COMPRESSION_NONE &&
track->f.compressionType != AF_COMPRESSION_G711_ULAW &&
track->f.compressionType != AF_COMPRESSION_G711_ALAW &&
track->f.compressionType != AF_COMPRESSION_IMA)
{
_af_error(AF_BAD_COMPTYPE,
"compression format %d not supported in CAF file",
track->f.compressionType);
return AF_NULL_FILESETUP;
}
if (track->markersSet && track->markerCount)
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "CAF does not yet support markers");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &cafDefaultFileSetup, true);
}
AFfilesetup SampleVisionFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "SampleVision file must have 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = &setup->tracks[0];
if (track->sampleFormatSet)
{
if (!track->f.isSigned() || track->f.sampleWidth != 16)
{
_af_error(AF_BAD_SAMPFMT,
"SampleVision format supports only 16-bit signed integer audio data");
return AF_NULL_FILESETUP;
}
}
else
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP,
track->f.sampleWidth);
if (track->byteOrderSet && track->f.byteOrder != AF_BYTEORDER_LITTLEENDIAN)
{
// Treat error as correctable.
_af_error(AF_BAD_BYTEORDER, "SampleVision supports only little-endian data");
}
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
if (track->compressionSet && !track->f.isUncompressed())
{
_af_error(AF_BAD_COMPTYPE, "SampleVision does not support compressed audio data");
return AF_NULL_FILESETUP;
}
if (track->markersSet && track->markerCount)
{
_af_error(AF_BAD_NUMMARKS, "SampleVision does not support markers");
return AF_NULL_FILESETUP;
}
if (track->aesDataSet)
{
_af_error(AF_BAD_FILESETUP, "SampleVision does not support AES data");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &sSampleVisionDefaultFileSetup, true);
}
void afInitSampleFormat (AFfilesetup setup, int trackid, int sampfmt, int sampwidth)
{
if (!_af_filesetup_ok(setup))
return;
TrackSetup *track = setup->getTrack(trackid);
if (!track)
return;
_af_set_sample_format(&track->f, sampfmt, sampwidth);
track->sampleFormatSet = true;
track->sampleWidthSet = true;
}
TrackSetup *_af_tracksetup_new (int trackCount)
{
TrackSetup *tracks;
if (trackCount == 0)
return NULL;
tracks = (TrackSetup *) _af_calloc(trackCount, sizeof (TrackSetup));
if (tracks == NULL)
return NULL;
for (int i=0; i<trackCount; i++)
{
tracks[i] = _af_default_tracksetup;
tracks[i].id = AF_DEFAULT_TRACK + i;
/* XXXmpruett deal with compression */
_af_set_sample_format(&tracks[i].f, tracks[i].f.sampleFormat,
tracks[i].f.sampleWidth);
if (tracks[i].markerCount == 0)
tracks[i].markers = NULL;
else
{
tracks[i].markers = (MarkerSetup *) _af_calloc(tracks[i].markerCount,
sizeof (MarkerSetup));
if (tracks[i].markers == NULL)
return NULL;
for (int j=0; j<tracks[i].markerCount; j++)
{
tracks[i].markers[j].id = j+1;
tracks[i].markers[j].name = _af_strdup("");
if (tracks[i].markers[j].name == NULL)
return NULL;
tracks[i].markers[j].comment = _af_strdup("");
if (tracks[i].markers[j].comment == NULL)
return NULL;
}
}
}
return tracks;
}
int afSetVirtualSampleFormat (AFfilehandle file, int trackid,
int sampleFormat, int sampleWidth)
{
if (!_af_filehandle_ok(file))
return -1;
Track *track = file->getTrack(trackid);
if (!track)
return -1;
if (_af_set_sample_format(&track->v, sampleFormat, sampleWidth) == AF_FAIL)
return -1;
track->ms->setDirty();
return 0;
}
status CAFFile::parseDescription(const Tag &, int64_t)
{
double sampleRate;
Tag formatID;
uint32_t formatFlags;
uint32_t bytesPerPacket;
uint32_t framesPerPacket;
uint32_t channelsPerFrame;
uint32_t bitsPerChannel;
if (!readDouble(&sampleRate) ||
!readTag(&formatID) ||
!readU32(&formatFlags) ||
!readU32(&bytesPerPacket) ||
!readU32(&framesPerPacket) ||
!readU32(&channelsPerFrame) ||
!readU32(&bitsPerChannel))
return AF_FAIL;
if (!channelsPerFrame)
{
_af_error(AF_BAD_CHANNELS, "invalid file with 0 channels");
return AF_FAIL;
}
Track *track = getTrack();
track->f.channelCount = channelsPerFrame;
track->f.sampleWidth = bitsPerChannel;
track->f.sampleRate = sampleRate;
track->f.framesPerPacket = 1;
if (formatID == "lpcm")
{
track->f.compressionType = AF_COMPRESSION_NONE;
if (formatFlags & kCAFLinearPCMFormatFlagIsFloat)
{
if (bitsPerChannel != 32 && bitsPerChannel != 64)
{
_af_error(AF_BAD_WIDTH, "invalid bits per sample %d for floating-point audio data", bitsPerChannel);
return AF_FAIL;
}
track->f.sampleFormat = bitsPerChannel == 32 ? AF_SAMPFMT_FLOAT :
AF_SAMPFMT_DOUBLE;
}
else
{
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
track->f.byteOrder = (formatFlags & kCAFLinearPCMFormatFlagIsLittleEndian) ?
AF_BYTEORDER_LITTLEENDIAN : AF_BYTEORDER_BIGENDIAN;
if (_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth) == AF_FAIL)
return AF_FAIL;
track->f.computeBytesPerPacketPCM();
return AF_SUCCEED;
}
else if (formatID == "ulaw")
{
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
track->f.bytesPerPacket = channelsPerFrame;
return AF_SUCCEED;
}
else if (formatID == "alaw")
{
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
track->f.bytesPerPacket = channelsPerFrame;
return AF_SUCCEED;
}
else if (formatID == "ima4")
{
track->f.compressionType = AF_COMPRESSION_IMA;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
initIMACompressionParams();
return AF_SUCCEED;
}
else
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "Compression type %s not supported",
formatID.name().c_str());
return AF_FAIL;
}
}
/*
Parse common data chunks, which contain information regarding the
sampling rate, the number of sample frames, and the number of
sound channels.
*/
static status ParseCOMM (AFfilehandle file, AFvirtualfile *fh, u_int32_t type,
size_t size)
{
_Track *track;
u_int16_t numChannels;
u_int32_t numSampleFrames;
u_int16_t sampleSize;
unsigned char sampleRate[10];
assert(!memcmp(&type, "COMM", 4));
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_fread(&numChannels, sizeof (u_int16_t), 1, fh);
track->f.channelCount = BENDIAN_TO_HOST_INT16(numChannels);
af_fread(&numSampleFrames, sizeof (u_int32_t), 1, fh);
track->totalfframes = BENDIAN_TO_HOST_INT32(numSampleFrames);
af_fread(&sampleSize, sizeof (u_int16_t), 1, fh);
track->f.sampleWidth = BENDIAN_TO_HOST_INT16(sampleSize);
af_fread(sampleRate, 10, 1, fh);
track->f.sampleRate = _af_convert_from_ieee_extended(sampleRate);
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
if (file->fileFormat == AF_FILE_AIFFC)
{
u_int8_t compressionID[4];
/* Pascal strings are at most 255 bytes long. */
unsigned char compressionName[256];
unsigned char compressionNameLength;
af_fread(compressionID, 4, 1, fh);
/* Read the Pascal-style string containing the name. */
af_fread(&compressionNameLength, 1, 1, fh);
af_fread(compressionName, compressionNameLength, 1, fh);
compressionName[compressionNameLength] = '\0';
if (!memcmp(compressionID, "NONE", 4))
track->f.compressionType = AF_COMPRESSION_NONE;
else if (!memcmp(compressionID, "ACE2", 4) ||
!memcmp(compressionID, "ACE8", 4) ||
!memcmp(compressionID, "MAC3", 4) ||
!memcmp(compressionID, "MAC6", 4))
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "AIFF-C format does not support Apple's proprietary %s compression format", compressionName);
return AF_FAIL;
}
else if (!memcmp(compressionID, "ulaw", 4) ||
!memcmp(compressionID, "ULAW", 4))
{
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
}
else if (!memcmp(compressionID, "alaw", 4) ||
!memcmp(compressionID, "ALAW", 4))
{
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
}
else if (!memcmp(compressionID, "fl32", 4) ||
!memcmp(compressionID, "FL32", 4))
{
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
track->f.sampleWidth = 32;
track->f.compressionType = AF_COMPRESSION_NONE;
}
else if (!memcmp(compressionID, "fl64", 4) ||
!memcmp(compressionID, "FL64", 4))
{
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
track->f.sampleWidth = 64;
track->f.compressionType = AF_COMPRESSION_NONE;
}
else if (!memcmp(compressionID, "sowt", 4))
{
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
}
else
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "AIFF-C compression type '%c%c%c%c' not currently supported",
compressionID[0],
compressionID[1],
compressionID[2],
compressionID[3]);
return AF_FAIL;
}
}
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
AFfilesetup IFFFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "IFF/8SVX file must have 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = setup->getTrack();
if (!track)
return AF_NULL_FILESETUP;
if (track->sampleFormatSet &&
track->f.sampleFormat != AF_SAMPFMT_TWOSCOMP)
{
_af_error(AF_BAD_SAMPFMT,
"IFF/8SVX format supports only two's complement integer data");
return AF_NULL_FILESETUP;
}
if (track->sampleFormatSet && track->f.sampleWidth != 8)
{
_af_error(AF_BAD_WIDTH,
"IFF/8SVX file allows only 8 bits per sample "
"(%d bits requested)", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
if (track->channelCountSet && track->f.channelCount != 1)
{
_af_error(AF_BAD_CHANNELS,
"invalid channel count (%d) for IFF/8SVX format "
"(only 1 channel supported)",
track->f.channelCount);
return AF_NULL_FILESETUP;
}
if (track->f.compressionType != AF_COMPRESSION_NONE)
{
_af_error(AF_BAD_COMPRESSION,
"IFF/8SVX does not support compression");
return AF_NULL_FILESETUP;
}
/* Ignore requested byte order since samples are only one byte. */
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
/* Either one channel was requested or no request was made. */
track->f.channelCount = 1;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 8);
if (track->markersSet && track->markerCount != 0)
{
_af_error(AF_BAD_NUMMARKS,
"IFF/8SVX format does not support markers");
return AF_NULL_FILESETUP;
}
if (track->aesDataSet)
{
_af_error(AF_BAD_FILESETUP, "IFF/8SVX format does not support AES data");
return AF_NULL_FILESETUP;
}
if (setup->instrumentSet && setup->instrumentCount != 0)
{
_af_error(AF_BAD_NUMINSTS,
"IFF/8SVX format does not support instruments");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &iffDefaultFileSetup, true);
}
AFfilesetup _af_aiff_complete_setup (AFfilesetup setup)
{
_TrackSetup *track;
bool isAIFF = setup->fileFormat == AF_FILE_AIFF;
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "AIFF/AIFF-C file must have 1 track");
return AF_NULL_FILESETUP;
}
track = &setup->tracks[0];
if (track->sampleFormatSet)
{
if (track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
{
_af_error(AF_BAD_FILEFMT, "AIFF/AIFF-C format does not support unsigned data");
return AF_NULL_FILESETUP;
}
else if (isAIFF && track->f.sampleFormat != AF_SAMPFMT_TWOSCOMP)
{
_af_error(AF_BAD_FILEFMT, "AIFF format supports only two's complement integer data");
return AF_NULL_FILESETUP;
}
}
else
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP,
track->f.sampleWidth);
/* Check sample width if writing two's complement. Otherwise ignore. */
if (track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP &&
(track->f.sampleWidth < 1 || track->f.sampleWidth > 32))
{
_af_error(AF_BAD_WIDTH,
"invalid sample width %d for AIFF/AIFF-C file "
"(must be 1-32)", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
if (isAIFF && track->f.compressionType != AF_COMPRESSION_NONE)
{
_af_error(AF_BAD_FILESETUP,
"AIFF does not support compression; use AIFF-C");
return AF_NULL_FILESETUP;
}
/* XXXmpruett handle compression here */
if (track->byteOrderSet &&
track->f.byteOrder != AF_BYTEORDER_BIGENDIAN &&
track->f.sampleWidth > 8)
{
_af_error(AF_BAD_BYTEORDER,
"AIFF/AIFF-C format supports only big-endian data");
}
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
if (setup->instrumentSet)
{
if (setup->instrumentCount != 0 && setup->instrumentCount != 1)
{
_af_error(AF_BAD_NUMINSTS, "AIFF/AIFF-C file must have 0 or 1 instrument chunk");
return AF_NULL_FILESETUP;
}
if (setup->instruments != 0 &&
setup->instruments[0].loopCount != 2)
{
_af_error(AF_BAD_NUMLOOPS, "AIFF/AIFF-C file with instrument must also have 2 loops");
return AF_NULL_FILESETUP;
}
}
if (setup->miscellaneousSet)
{
int i;
for (i=0; i<setup->miscellaneousCount; i++)
{
switch (setup->miscellaneous[i].type)
{
case AF_MISC_COPY:
case AF_MISC_AUTH:
case AF_MISC_NAME:
case AF_MISC_ANNO:
case AF_MISC_APPL:
case AF_MISC_MIDI:
break;
default:
_af_error(AF_BAD_MISCTYPE, "invalid miscellaneous type %d for AIFF/AIFF-C file", setup->miscellaneous[i].type);
return AF_NULL_FILESETUP;
}
}
}
return _af_filesetup_copy(setup, &_af_aiff_default_filesetup, AF_TRUE);
}
status NISTFile::readInit(AFfilesetup setup)
{
char header[NIST_SPHERE_HEADER_LENGTH + 1];
int intval;
char strval[NIST_SPHERE_MAX_FIELD_LENGTH];
int sample_n_bytes;
m_fh->seek(0, File::SeekFromBeginning);
if (m_fh->read(header, NIST_SPHERE_HEADER_LENGTH) != NIST_SPHERE_HEADER_LENGTH)
{
_af_error(AF_BAD_READ, "Could not read NIST SPHERE file header");
return AF_FAIL;
}
header[NIST_SPHERE_HEADER_LENGTH] = '\0';
if (memcmp(header, "NIST_1A\n 1024\n", 16) != 0)
{
_af_error(AF_BAD_FILEFMT, "Bad NIST SPHERE file header");
return AF_FAIL;
}
Track *track = allocateTrack();
if (!track)
return AF_FAIL;
// Read channel count.
if (nist_header_read_int(header, "channel_count", &intval))
{
if (intval < 1)
{
_af_error(AF_BAD_CHANNELS, "invalid number of channels %d",
intval);
return AF_FAIL;
}
track->f.channelCount = intval;
}
else
{
_af_error(AF_BAD_HEADER, "number of channels not specified");
return AF_FAIL;
}
// Read number of bytes per sample.
if (!nist_header_read_int(header, "sample_n_bytes", &sample_n_bytes))
{
_af_error(AF_BAD_HEADER, "bytes per sample not specified");
return AF_FAIL;
}
track->f.framesPerPacket = 1;
/*
Since some older NIST SPHERE files lack a sample_coding
field, if sample_n_bytes is 1, assume mu-law;
otherwise assume linear PCM.
*/
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
if (sample_n_bytes == 1)
{
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
track->f.sampleWidth = 16;
track->f.bytesPerPacket = track->f.channelCount;
}
else
{
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.sampleWidth = sample_n_bytes * 8;
track->f.computeBytesPerPacketPCM();
}
if (nist_header_read_string(header, "sample_coding", &intval, strval))
{
if (strcmp(strval, "pcm") == 0)
;
else if (strcmp(strval, "ulaw") == 0 || strcmp(strval, "mu-law") == 0)
{
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
track->f.sampleWidth = 16;
}
else if (strcmp(strval, "alaw") == 0)
{
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
track->f.sampleWidth = 16;
}
else
{
_af_error(AF_BAD_SAMPFMT,
"unrecognized NIST SPHERE sample format %s", strval);
return AF_FAIL;
}
}
// Read string representing byte order.
if (nist_header_read_string(header, "sample_byte_format", &intval, strval))
{
if (intval > 1)
{
if (strncmp(strval, "01", 2) == 0)
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
else
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
}
else
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
}
else
{
/*
Fail if this field is not present and sample
width is more than one byte.
*/
if (track->f.compressionType == AF_COMPRESSION_NONE &&
track->f.sampleWidth > 8)
{
_af_error(AF_BAD_HEADER, "sample byte order not specified");
return AF_FAIL;
}
}
// Read significant bits per sample.
if (nist_header_read_int(header, "sample_sig_bits", &intval))
{
if (intval < 1 || intval > 32)
{
_af_error(AF_BAD_WIDTH, "invalid sample width %d bits\n",
intval);
return AF_FAIL;
}
/*
Use specified significant bits value as the
sample width for uncompressed data as long
as the number of bytes per sample remains
unchanged.
*/
if (track->f.compressionType == AF_COMPRESSION_NONE &&
(intval + 7) / 8 == sample_n_bytes)
{
track->f.sampleWidth = intval;
}
}
// Read sample rate.
if (nist_header_read_int(header, "sample_rate", &intval))
{
if (intval <= 0)
{
_af_error(AF_BAD_RATE, "invalid sample rate %d Hz\n", intval);
return AF_FAIL;
}
track->f.sampleRate = intval;
}
else
{
_af_error(AF_BAD_HEADER, "sample rate not specified");
return AF_FAIL;
}
// Read sample count.
if (nist_header_read_int(header, "sample_count", &intval))
{
track->totalfframes = intval;
}
else
{
_af_error(AF_BAD_HEADER, "number of samples not specified");
return AF_FAIL;
}
if (_af_set_sample_format(&track->f, track->f.sampleFormat,
track->f.sampleWidth) == AF_FAIL)
{
return AF_FAIL;
}
track->fpos_first_frame = NIST_SPHERE_HEADER_LENGTH;
track->data_size = m_fh->length() - NIST_SPHERE_HEADER_LENGTH;
track->nextfframe = 0;
track->fpos_next_frame = track->fpos_first_frame;
return AF_SUCCEED;
}
AFfilesetup _af_iff_complete_setup (AFfilesetup setup)
{
_TrackSetup *track;
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "IFF/8SVX file must have 1 track");
return AF_NULL_FILESETUP;
}
track = &setup->tracks[0];
if (track->sampleFormatSet &&
track->f.sampleFormat != AF_SAMPFMT_TWOSCOMP)
{
_af_error(AF_BAD_SAMPFMT,
"IFF/8SVX format supports only two's complement integer data");
return AF_NULL_FILESETUP;
}
if (track->sampleFormatSet && track->f.sampleWidth != 8)
{
_af_error(AF_BAD_WIDTH,
"IFF/8SVX file allows only 8 bits per sample "
"(%d bits requested)", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
if (track->channelCountSet && track->f.channelCount != 1)
{
_af_error(AF_BAD_CHANNELS,
"invalid channel count (%d) for IFF/8SVX format "
"(only 1 channel supported)",
track->f.channelCount);
return AF_NULL_FILESETUP;
}
if (track->f.compressionType != AF_COMPRESSION_NONE)
{
_af_error(AF_BAD_COMPRESSION,
"IFF/8SVX does not support compression");
return AF_NULL_FILESETUP;
}
/* Ignore requested byte order since samples are only one byte. */
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
/* Either one channel was requested or no request was made. */
track->f.channelCount = 1;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 8);
if (track->markersSet && track->markerCount != 0)
{
_af_error(AF_BAD_NUMMARKS,
"IFF/8SVX format does not support markers");
return AF_NULL_FILESETUP;
}
if (setup->instrumentSet && setup->instrumentCount != 0)
{
_af_error(AF_BAD_NUMINSTS,
"IFF/8SVX format does not support instruments");
return AF_NULL_FILESETUP;
}
if (setup->miscellaneousSet && setup->miscellaneousCount != 0)
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "IFF/8SVX format does not "
"currently support miscellaneous chunks");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &_af_iff_default_filesetup, AF_TRUE);
}
status SampleVisionFile::readInit(AFfilesetup)
{
m_fh->seek(0, File::SeekFromBeginning);
char magic[kSMPMagicLength];
if (m_fh->read(magic, kSMPMagicLength) != (ssize_t) kSMPMagicLength)
return AF_FAIL;
if (strncmp(magic, kSMPMagic, kSMPMagicLength) != 0)
return AF_FAIL;
char version[kSMPVersionLength];
if (m_fh->read(version, kSMPVersionLength) != (ssize_t) kSMPVersionLength)
return AF_FAIL;
if (strncmp(version, kSMPVersion, kSMPVersionLength) != 0)
return AF_FAIL;
Track *track = allocateTrack();
char name[kSMPNameLength + 1];
m_fh->read(name, kSMPNameLength);
name[kSMPNameLength] = '\0';
trimTrailingSpaces(name);
if (strlen(name) > 0)
addMiscellaneous(AF_MISC_NAME, name);
char comment[kSMPCommentLength + 1];
m_fh->read(comment, kSMPCommentLength);
comment[kSMPCommentLength] = '\0';
trimTrailingSpaces(comment);
if (strlen(comment) > 0)
addMiscellaneous(AF_MISC_COMMENT, comment);
uint32_t frameCount;
readU32(&frameCount);
track->totalfframes = frameCount;
track->fpos_first_frame = m_fh->tell();
track->data_size = 2 * frameCount;
m_fh->seek(track->data_size, File::SeekFromCurrent);
uint16_t reserved;
readU16(&reserved);
parseLoops();
parseMarkers();
uint8_t midiNote;
uint32_t sampleRate;
uint32_t smpteOffset;
uint32_t cycleLength;
readU8(&midiNote);
readU32(&sampleRate);
readU32(&smpteOffset);
readU32(&cycleLength);
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
track->f.sampleRate = sampleRate;
track->f.channelCount = 1;
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.framesPerPacket = 1;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
track->f.computeBytesPerPacketPCM();
return AF_SUCCEED;
}
AFfilesetup VOCFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "VOC file must have 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = setup->getTrack();
if (!track)
return AF_NULL_FILESETUP;
if (track->sampleFormatSet)
{
if (!track->f.isInteger())
{
_af_error(AF_BAD_SAMPFMT,
"VOC format supports only integer audio data");
return AF_NULL_FILESETUP;
}
if ((track->f.isSigned() && track->f.sampleWidth != 16) ||
(track->f.isUnsigned() && track->f.sampleWidth != 8))
{
_af_error(AF_BAD_SAMPFMT,
"VOC format supports only 16-bit signed or 8-bit unsigned data");
return AF_NULL_FILESETUP;
}
}
else
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP,
track->f.sampleWidth);
if (track->f.isUncompressed() &&
track->byteOrderSet &&
track->f.byteOrder != AF_BYTEORDER_LITTLEENDIAN &&
track->f.isByteOrderSignificant())
{
_af_error(AF_BAD_BYTEORDER, "VOC supports only little-endian data");
return AF_NULL_FILESETUP;
}
if (track->f.isUncompressed())
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
if (track->f.compressionType != AF_COMPRESSION_NONE &&
track->f.compressionType != AF_COMPRESSION_G711_ULAW &&
track->f.compressionType != AF_COMPRESSION_G711_ALAW)
{
_af_error(AF_BAD_COMPTYPE,
"compression format %d not supported in VOC file",
track->f.compressionType);
return AF_NULL_FILESETUP;
}
if (track->markersSet && track->markerCount)
{
_af_error(AF_BAD_NUMMARKS, "VOC does not support markers");
return AF_NULL_FILESETUP;
}
if (track->aesDataSet)
{
_af_error(AF_BAD_FILESETUP, "VOC does not support AES data");
return AF_NULL_FILESETUP;
}
if (setup->instrumentSet && setup->instrumentCount)
{
_af_error(AF_BAD_FILESETUP, "VOC does not support instruments");
return AF_NULL_FILESETUP;
}
if (setup->miscellaneousSet && setup->miscellaneousCount)
{
_af_error(AF_BAD_FILESETUP, "VOC does not support miscellaneous data");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &vocDefaultFileSetup, true);
}
status WAVEFile::parseFormat(const Tag &id, uint32_t size)
{
Track *track = getTrack();
uint16_t formatTag;
readU16(&formatTag);
uint16_t channelCount;
readU16(&channelCount);
uint32_t sampleRate;
readU32(&sampleRate);
uint32_t averageBytesPerSecond;
readU32(&averageBytesPerSecond);
uint16_t blockAlign;
readU16(&blockAlign);
track->f.channelCount = channelCount;
track->f.sampleRate = sampleRate;
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
/* Default to uncompressed audio data. */
track->f.compressionType = AF_COMPRESSION_NONE;
switch (formatTag)
{
case WAVE_FORMAT_PCM:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
track->f.sampleWidth = bitsPerSample;
if (bitsPerSample == 0 || bitsPerSample > 32)
{
_af_error(AF_BAD_WIDTH,
"bad sample width of %d bits",
bitsPerSample);
return AF_FAIL;
}
if (bitsPerSample <= 8)
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
else
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
break;
case WAVE_FORMAT_MULAW:
case IBM_FORMAT_MULAW:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
break;
case WAVE_FORMAT_ALAW:
case IBM_FORMAT_ALAW:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
break;
case WAVE_FORMAT_IEEE_FLOAT:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
if (bitsPerSample == 64)
{
track->f.sampleWidth = 64;
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
}
else
{
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
}
}
break;
case WAVE_FORMAT_ADPCM:
{
uint16_t bitsPerSample, extraByteCount,
samplesPerBlock, numCoefficients;
if (track->f.channelCount != 1 &&
track->f.channelCount != 2)
{
_af_error(AF_BAD_CHANNELS,
"WAVE file with MS ADPCM compression "
"must have 1 or 2 channels");
}
readU16(&bitsPerSample);
readU16(&extraByteCount);
readU16(&samplesPerBlock);
readU16(&numCoefficients);
/* numCoefficients should be at least 7. */
assert(numCoefficients >= 7 && numCoefficients <= 255);
for (int i=0; i<numCoefficients; i++)
{
int16_t a0, a1;
readS16(&a0);
readS16(&a1);
msadpcmCoefficients[i][0] = a0;
msadpcmCoefficients[i][1] = a1;
}
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_MS_ADPCM;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
/* Create the parameter list. */
long l;
void *v;
AUpvlist pv = AUpvnew(4);
AUpvsetparam(pv, 0, _AF_MS_ADPCM_NUM_COEFFICIENTS);
AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
l = numCoefficients;
AUpvsetval(pv, 0, &l);
AUpvsetparam(pv, 1, _AF_MS_ADPCM_COEFFICIENTS);
AUpvsetvaltype(pv, 1, AU_PVTYPE_PTR);
v = msadpcmCoefficients;
AUpvsetval(pv, 1, &v);
AUpvsetparam(pv, 2, _AF_FRAMES_PER_BLOCK);
AUpvsetvaltype(pv, 2, AU_PVTYPE_LONG);
l = samplesPerBlock;
AUpvsetval(pv, 2, &l);
AUpvsetparam(pv, 3, _AF_BLOCK_SIZE);
AUpvsetvaltype(pv, 3, AU_PVTYPE_LONG);
l = blockAlign;
AUpvsetval(pv, 3, &l);
track->f.compressionParams = pv;
}
break;
case WAVE_FORMAT_DVI_ADPCM:
{
uint16_t bitsPerSample, extraByteCount, samplesPerBlock;
readU16(&bitsPerSample);
readU16(&extraByteCount);
readU16(&samplesPerBlock);
if (bitsPerSample != 4)
{
_af_error(AF_BAD_NOT_IMPLEMENTED,
"IMA ADPCM compression supports only 4 bits per sample");
}
int bytesPerBlock = (samplesPerBlock + 14) / 8 * 4 * channelCount;
if (bytesPerBlock > blockAlign || (samplesPerBlock % 8) != 1)
{
_af_error(AF_BAD_CODEC_CONFIG,
"Invalid samples per block for IMA ADPCM compression");
}
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_IMA;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
/* Create the parameter list. */
long l;
AUpvlist pv = AUpvnew(2);
AUpvsetparam(pv, 0, _AF_FRAMES_PER_BLOCK);
AUpvsetvaltype(pv, 0, AU_PVTYPE_LONG);
l = samplesPerBlock;
AUpvsetval(pv, 0, &l);
AUpvsetparam(pv, 1, _AF_BLOCK_SIZE);
AUpvsetvaltype(pv, 1, AU_PVTYPE_LONG);
l = blockAlign;
AUpvsetval(pv, 1, &l);
track->f.compressionParams = pv;
}
break;
case WAVE_FORMAT_EXTENSIBLE:
{
uint16_t bitsPerSample;
readU16(&bitsPerSample);
uint16_t extraByteCount;
readU16(&extraByteCount);
uint16_t reserved;
readU16(&reserved);
uint32_t channelMask;
readU32(&channelMask);
UUID subformat;
readUUID(&subformat);
if (subformat == _af_wave_guid_pcm)
{
track->f.sampleWidth = bitsPerSample;
if (bitsPerSample == 0 || bitsPerSample > 32)
{
_af_error(AF_BAD_WIDTH,
"bad sample width of %d bits",
bitsPerSample);
return AF_FAIL;
}
// Use valid bits per sample if bytes per sample is the same.
if (reserved <= bitsPerSample &&
(reserved + 7) / 8 == (bitsPerSample + 7) / 8)
track->f.sampleWidth = reserved;
if (bitsPerSample <= 8)
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
else
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
else if (subformat == _af_wave_guid_ieee_float)
{
if (bitsPerSample == 64)
{
track->f.sampleWidth = 64;
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
}
else
{
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
}
}
else if (subformat == _af_wave_guid_alaw ||
subformat == _af_wave_guid_ulaw)
{
track->f.compressionType = subformat == _af_wave_guid_alaw ?
AF_COMPRESSION_G711_ALAW : AF_COMPRESSION_G711_ULAW;
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
}
else
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE extensible data format %s is not currently supported", subformat.name().c_str());
return AF_FAIL;
}
}
break;
case WAVE_FORMAT_YAMAHA_ADPCM:
case WAVE_FORMAT_OKI_ADPCM:
case WAVE_FORMAT_CREATIVE_ADPCM:
case IBM_FORMAT_ADPCM:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE ADPCM data format 0x%x is not currently supported", formatTag);
return AF_FAIL;
break;
case WAVE_FORMAT_MPEG:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG data format is not supported");
return AF_FAIL;
break;
case WAVE_FORMAT_MPEGLAYER3:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE MPEG layer 3 data format is not supported");
return AF_FAIL;
break;
default:
_af_error(AF_BAD_NOT_IMPLEMENTED, "WAVE file data format 0x%x not currently supported != 0xfffe ? %d, != EXTENSIBLE? %d", formatTag, formatTag != 0xfffe, formatTag != WAVE_FORMAT_EXTENSIBLE);
return AF_FAIL;
break;
}
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
return AF_SUCCEED;
}
AFfilesetup NeXTFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "NeXT files must have exactly 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = setup->getTrack();
if (!track)
return AF_NULL_FILESETUP;
if (track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
{
_af_error(AF_BAD_FILEFMT, "NeXT format does not support unsigned data");
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, track->f.sampleWidth);
}
if (track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP)
{
if (track->f.sampleWidth != 8 &&
track->f.sampleWidth != 16 &&
track->f.sampleWidth != 24 &&
track->f.sampleWidth != 32)
{
_af_error(AF_BAD_WIDTH, "invalid sample width %d for NeXT file (only 8-, 16-, 24-, and 32-bit data are allowed)");
return AF_NULL_FILESETUP;
}
}
if (track->f.compressionType != AF_COMPRESSION_NONE &&
track->f.compressionType != AF_COMPRESSION_G711_ULAW &&
track->f.compressionType != AF_COMPRESSION_G711_ALAW)
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "compression format not implemented for NeXT files");
return AF_NULL_FILESETUP;
}
if (track->f.byteOrder != AF_BYTEORDER_BIGENDIAN && track->byteOrderSet)
{
_af_error(AF_BAD_BYTEORDER, "NeXT format supports only big-endian data");
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
}
if (track->aesDataSet)
{
_af_error(AF_BAD_FILESETUP, "NeXT files cannot have AES data");
return AF_NULL_FILESETUP;
}
if (track->markersSet && track->markerCount != 0)
{
_af_error(AF_BAD_FILESETUP, "NeXT format does not support markers");
return AF_NULL_FILESETUP;
}
if (setup->instrumentSet && setup->instrumentCount != 0)
{
_af_error(AF_BAD_FILESETUP, "NeXT format does not support instruments");
return AF_NULL_FILESETUP;
}
if (setup->miscellaneousSet && setup->miscellaneousCount != 0)
{
_af_error(AF_BAD_FILESETUP, "NeXT format does not support miscellaneous data");
return AF_NULL_FILESETUP;
}
return _af_filesetup_copy(setup, &next_default_filesetup, false);
}
status NeXTFile::readInit(AFfilesetup setup)
{
uint32_t id, offset, length, encoding, sampleRate, channelCount;
fh->seek(0, File::SeekFromBeginning);
fh->read(&id, 4);
assert(!memcmp(&id, ".snd", 4));
readU32(&offset);
readU32(&length);
readU32(&encoding);
readU32(&sampleRate);
readU32(&channelCount);
#ifdef DEBUG
printf("id, offset, length, encoding, sampleRate, channelCount:\n"
" %d %d %d %d %d %d\n",
id, offset, length, encoding, sampleRate, channelCount);
#endif
Track *track = allocateTrack();
if (!track)
return AF_FAIL;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
/* Override the compression type later if necessary. */
track->f.compressionType = AF_COMPRESSION_NONE;
track->fpos_first_frame = offset;
off_t lengthAvailable = fh->length() - offset;
if (length == _AU_LENGTH_UNSPECIFIED || static_cast<off_t>(length) > lengthAvailable)
length = lengthAvailable;
track->data_size = length;
switch (encoding)
{
case _AU_FORMAT_MULAW_8:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
break;
case _AU_FORMAT_ALAW_8:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
break;
case _AU_FORMAT_LINEAR_8:
track->f.sampleWidth = 8;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
break;
case _AU_FORMAT_LINEAR_16:
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
break;
case _AU_FORMAT_LINEAR_24:
track->f.sampleWidth = 24;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
break;
case _AU_FORMAT_LINEAR_32:
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
break;
case _AU_FORMAT_FLOAT:
track->f.sampleWidth = 32;
track->f.sampleFormat = AF_SAMPFMT_FLOAT;
break;
case _AU_FORMAT_DOUBLE:
track->f.sampleWidth = 64;
track->f.sampleFormat = AF_SAMPFMT_DOUBLE;
break;
default:
/*
This encoding method is not recognized.
*/
_af_error(AF_BAD_SAMPFMT, "bad sample format");
return AF_FAIL;
}
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
track->f.sampleRate = sampleRate;
track->f.channelCount = channelCount;
int frameSize = _af_format_frame_size(&track->f, false);
track->totalfframes = length / frameSize;
#ifdef DEBUG
printf("_af_next_read_init\n");
_af_print_filehandle(file);
#endif
/* The file has been parsed successfully. */
return AF_SUCCEED;
}
status AVRFile::readInit(AFfilesetup setup)
{
uint32_t magic;
char name[8];
uint16_t mono, resolution, sign, loop, midi;
uint32_t rate, size, loopStart, loopEnd;
char reserved[26];
char user[64];
m_fh->seek(0, File::SeekFromBeginning);
if (m_fh->read(&magic, 4) != 4)
{
_af_error(AF_BAD_READ, "could not read AVR file header");
return AF_FAIL;
}
if (memcmp(&magic, "2BIT", 4) != 0)
{
_af_error(AF_BAD_FILEFMT, "file is not AVR format");
return AF_FAIL;
}
/* Read name. */
m_fh->read(name, 8);
readU16(&mono);
readU16(&resolution);
readU16(&sign);
readU16(&loop);
readU16(&midi);
readU32(&rate);
readU32(&size);
readU32(&loopStart);
readU32(&loopEnd);
m_fh->read(reserved, 26);
m_fh->read(user, 64);
Track *track = allocateTrack();
if (!track)
return AF_FAIL;
/* Use only low-order three bytes of sample rate. */
track->f.sampleRate = rate & 0xffffff;
if (sign == 0)
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
else if (sign == 0xffff)
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
else
{
_af_error(AF_BAD_SAMPFMT, "bad sample format in AVR file");
return AF_FAIL;
}
if (resolution != 8 && resolution != 16)
{
_af_error(AF_BAD_WIDTH, "bad sample width %d in AVR file",
resolution);
return AF_FAIL;
}
track->f.sampleWidth = resolution;
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
if (mono == 0)
track->f.channelCount = 1;
else if (mono == 0xffff)
track->f.channelCount = 2;
else
{
_af_error(AF_BAD_CHANNELS,
"invalid number of channels in AVR file");
return AF_FAIL;
}
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.framesPerPacket = 1;
track->f.computeBytesPerPacketPCM();
_af_set_sample_format(&track->f, track->f.sampleFormat, track->f.sampleWidth);
track->fpos_first_frame = m_fh->tell();
track->totalfframes = size;
track->data_size = track->totalfframes * track->f.bytesPerFrame(false);
track->nextfframe = 0;
track->fpos_next_frame = track->fpos_first_frame;
/* The file has been parsed successfully. */
return AF_SUCCEED;
}
AFfilesetup WAVEFile::completeSetup(AFfilesetup setup)
{
if (setup->trackSet && setup->trackCount != 1)
{
_af_error(AF_BAD_NUMTRACKS, "WAVE file must have 1 track");
return AF_NULL_FILESETUP;
}
TrackSetup *track = setup->getTrack();
if (track->sampleFormatSet)
{
switch (track->f.sampleFormat)
{
case AF_SAMPFMT_FLOAT:
if (track->sampleWidthSet &&
track->f.sampleWidth != 32)
{
_af_error(AF_BAD_WIDTH,
"Warning: invalid sample width for floating-point WAVE file: %d (must be 32 bits)\n",
track->f.sampleWidth);
_af_set_sample_format(&track->f, AF_SAMPFMT_FLOAT, 32);
}
break;
case AF_SAMPFMT_DOUBLE:
if (track->sampleWidthSet &&
track->f.sampleWidth != 64)
{
_af_error(AF_BAD_WIDTH,
"Warning: invalid sample width for double-precision floating-point WAVE file: %d (must be 64 bits)\n",
track->f.sampleWidth);
_af_set_sample_format(&track->f, AF_SAMPFMT_DOUBLE, 64);
}
break;
case AF_SAMPFMT_UNSIGNED:
if (track->sampleWidthSet)
{
if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
{
_af_error(AF_BAD_WIDTH, "invalid sample width for WAVE file: %d (must be 1-32 bits)\n", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
if (track->f.sampleWidth > 8)
{
_af_error(AF_BAD_SAMPFMT, "WAVE integer data of more than 8 bits must be two's complement signed");
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, track->f.sampleWidth);
}
}
else
/*
If the sample width is not set but the user requests
unsigned data, set the width to 8 bits.
*/
_af_set_sample_format(&track->f, track->f.sampleFormat, 8);
break;
case AF_SAMPFMT_TWOSCOMP:
if (track->sampleWidthSet)
{
if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
{
_af_error(AF_BAD_WIDTH, "invalid sample width %d for WAVE file (must be 1-32)", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
else if (track->f.sampleWidth <= 8)
{
_af_error(AF_BAD_SAMPFMT, "Warning: WAVE format integer data of 1-8 bits must be unsigned; setting sample format to unsigned");
_af_set_sample_format(&track->f, AF_SAMPFMT_UNSIGNED, track->f.sampleWidth);
}
}
else
/*
If no sample width was specified, we default to 16 bits
for signed integer data.
*/
_af_set_sample_format(&track->f, track->f.sampleFormat, 16);
break;
}
}
/*
Otherwise set the sample format depending on the sample
width or set completely to default.
*/
else
{
if (!track->sampleWidthSet)
{
track->f.sampleWidth = 16;
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
}
else
{
if (track->f.sampleWidth < 1 || track->f.sampleWidth > 32)
{
_af_error(AF_BAD_WIDTH, "invalid sample width %d for WAVE file (must be 1-32)", track->f.sampleWidth);
return AF_NULL_FILESETUP;
}
else if (track->f.sampleWidth > 8)
/* Here track->f.sampleWidth is in {1..32}. */
track->f.sampleFormat = AF_SAMPFMT_TWOSCOMP;
else
/* Here track->f.sampleWidth is in {1..8}. */
track->f.sampleFormat = AF_SAMPFMT_UNSIGNED;
}
}
if (track->f.compressionType != AF_COMPRESSION_NONE &&
track->f.compressionType != AF_COMPRESSION_G711_ULAW &&
track->f.compressionType != AF_COMPRESSION_G711_ALAW)
{
_af_error(AF_BAD_NOT_IMPLEMENTED, "compression format not supported in WAVE format");
return AF_NULL_FILESETUP;
}
if (track->byteOrderSet &&
track->f.byteOrder != AF_BYTEORDER_LITTLEENDIAN &&
track->f.compressionType == AF_COMPRESSION_NONE)
{
_af_error(AF_BAD_BYTEORDER, "WAVE format only supports little-endian data");
return AF_NULL_FILESETUP;
}
if (track->f.compressionType == AF_COMPRESSION_NONE)
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
else
track->f.byteOrder = AF_BYTEORDER_BIGENDIAN;
if (track->aesDataSet)
{
_af_error(AF_BAD_FILESETUP, "WAVE files cannot have AES data");
return AF_NULL_FILESETUP;
}
if (setup->instrumentSet)
{
if (setup->instrumentCount > 1)
{
_af_error(AF_BAD_NUMINSTS, "WAVE files can have 0 or 1 instrument");
return AF_NULL_FILESETUP;
}
else if (setup->instrumentCount == 1)
{
if (setup->instruments[0].loopSet &&
setup->instruments[0].loopCount > 0 &&
(!track->markersSet || track->markerCount == 0))
{
_af_error(AF_BAD_NUMMARKS, "WAVE files with loops must contain at least 1 marker");
return AF_NULL_FILESETUP;
}
}
}
/* Make sure the miscellaneous data is of an acceptable type. */
if (setup->miscellaneousSet)
{
for (int i=0; i<setup->miscellaneousCount; i++)
{
switch (setup->miscellaneous[i].type)
{
case AF_MISC_COPY:
case AF_MISC_AUTH:
case AF_MISC_NAME:
case AF_MISC_ICRD:
case AF_MISC_ISFT:
case AF_MISC_ICMT:
break;
default:
_af_error(AF_BAD_MISCTYPE, "illegal miscellaneous type [%d] for WAVE file", setup->miscellaneous[i].type);
return AF_NULL_FILESETUP;
}
}
}
/*
Allocate an AFfilesetup and make all the unset fields correct.
*/
AFfilesetup newsetup = _af_filesetup_copy(setup, &wave_default_filesetup, false);
/* Make sure we do not copy loops if they are not specified in setup. */
if (setup->instrumentSet && setup->instrumentCount > 0 &&
setup->instruments[0].loopSet)
{
free(newsetup->instruments[0].loops);
newsetup->instruments[0].loopCount = 0;
}
return newsetup;
}
status VOCFile::readInit(AFfilesetup)
{
m_fh->seek(20, File::SeekFromBeginning);
uint16_t dataOffset, version, checksum;
readU16(&dataOffset);
readU16(&version);
readU16(&checksum);
Track *track = allocateTrack();
bool hasExtendedInfo = false;
bool foundSoundData = false;
off_t position = m_fh->tell();
off_t fileLength = m_fh->length();
while (position < fileLength)
{
uint32_t blockHeader;
if (!readU32(&blockHeader))
break;
uint8_t blockType = blockHeader & 0xff;
uint32_t blockSize = blockHeader >> 8;
if (blockType == kVOCSoundData)
{
if (foundSoundData)
{
_af_error(AF_BAD_HEADER, "VOC file contains multiple sound data blocks");
return AF_FAIL;
}
foundSoundData = true;
uint8_t frequencyDivisor, codec;
readU8(&frequencyDivisor);
readU8(&codec);
if (!hasExtendedInfo)
{
track->f.channelCount = 1;
track->f.sampleRate = 1000000 / (256 - frequencyDivisor);
}
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
track->f.framesPerPacket = 1;
if (codec == kVOCFormatU8)
{
_af_set_sample_format(&track->f, AF_SAMPFMT_UNSIGNED, 8);
track->f.computeBytesPerPacketPCM();
}
else if (codec == kVOCFormatCreativeADPCM4_8 ||
codec == kVOCFormatCreativeADPCM3_8 ||
codec == kVOCFormatCreativeADPCM2_8)
{
_af_error(AF_BAD_NOT_IMPLEMENTED,
"Creative ADPCM compression is not currently suppported");
return AF_FAIL;
}
else
{
_af_error(AF_BAD_CODEC_TYPE,
"VOC file contains unrecognized codec type %d", codec);
return AF_FAIL;
}
track->fpos_first_frame = m_fh->tell();
track->data_size = m_fh->length() - 1 - track->fpos_first_frame;
track->computeTotalFileFrames();
}
else if (blockType == kVOCExtendedInfo)
{
if (foundSoundData)
{
_af_error(AF_BAD_HEADER, "VOC extended information found after sound data");
return AF_FAIL;
}
hasExtendedInfo = true;
uint16_t frequencyDivisor;
uint8_t bitsPerSample;
uint8_t isStereo;
readU16(&frequencyDivisor);
readU8(&bitsPerSample);
readU8(&isStereo);
track->f.sampleWidth = bitsPerSample;
track->f.channelCount = isStereo ? 2 : 1;
uint32_t frequencyDividend = 256000000 / (isStereo ? 2 : 1);
track->f.sampleRate = frequencyDividend / (65536 - frequencyDivisor);
}
else if (blockType == kVOCSoundDataNew)
{
if (foundSoundData)
{
_af_error(AF_BAD_HEADER, "VOC file contains multiple sound data blocks");
return AF_FAIL;
}
foundSoundData = true;
uint32_t sampleRate;
uint8_t bitsPerSample, channels;
uint16_t format;
uint32_t pad;
readU32(&sampleRate);
readU8(&bitsPerSample);
readU8(&channels);
readU16(&format);
readU32(&pad);
if (!channels)
{
_af_error(AF_BAD_CHANNELS, "invalid file with 0 channels");
return AF_FAIL;
}
track->fpos_first_frame = m_fh->tell();
track->data_size = blockSize - 12;
track->f.compressionType = AF_COMPRESSION_NONE;
track->f.byteOrder = AF_BYTEORDER_LITTLEENDIAN;
track->f.sampleRate = sampleRate;
track->f.channelCount = channels;
track->f.framesPerPacket = 1;
if (format == kVOCFormatU8)
{
_af_set_sample_format(&track->f, AF_SAMPFMT_UNSIGNED, 8);
track->f.computeBytesPerPacketPCM();
}
else if (format == kVOCFormatS16)
{
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
track->f.computeBytesPerPacketPCM();
}
else if (format == kVOCFormatAlaw)
{
track->f.compressionType = AF_COMPRESSION_G711_ALAW;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.bytesPerPacket = track->f.channelCount;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
}
else if (format == kVOCFormatUlaw)
{
track->f.compressionType = AF_COMPRESSION_G711_ULAW;
track->f.byteOrder = _AF_BYTEORDER_NATIVE;
track->f.bytesPerPacket = track->f.channelCount;
_af_set_sample_format(&track->f, AF_SAMPFMT_TWOSCOMP, 16);
}
else if (format == kVOCFormatCreativeADPCM4_8 ||
format == kVOCFormatCreativeADPCM3_8 ||
format == kVOCFormatCreativeADPCM2_8 ||
format == kVOCFormatCreativeADPCM4_16)
{
_af_error(AF_BAD_NOT_IMPLEMENTED,
"Creative ADPCM compression is not currently supported");
return AF_FAIL;
}
else
{
_af_error(AF_BAD_CODEC_TYPE,
"VOC file contains unrecognized codec type %d", format);
return AF_FAIL;
}
track->computeTotalFileFrames();
}
position += 4 + blockSize;
m_fh->seek(position, File::SeekFromBeginning);
}
return AF_SUCCEED;
}
