CoreAudioReader (InputStream* const inp)
: AudioFormatReader (inp, coreAudioFormatName),
ok (false), lastReadPosition (0)
{
usesFloatingPointData = true;
bitsPerSample = 32;
if (input != nullptr)
CoreAudioFormatMetatdata::read (*input, metadataValues);
OSStatus status = AudioFileOpenWithCallbacks (this,
&readCallback,
nullptr, // write needs to be null to avoid permisisions errors
&getSizeCallback,
nullptr, // setSize needs to be null to avoid permisisions errors
0, // AudioFileTypeID inFileTypeHint
&audioFileID);
if (status == noErr)
{
status = ExtAudioFileWrapAudioFileID (audioFileID, false, &audioFileRef);
if (status == noErr)
{
AudioStreamBasicDescription sourceAudioFormat;
UInt32 audioStreamBasicDescriptionSize = sizeof (AudioStreamBasicDescription);
ExtAudioFileGetProperty (audioFileRef,
kExtAudioFileProperty_FileDataFormat,
&audioStreamBasicDescriptionSize,
&sourceAudioFormat);
numChannels = sourceAudioFormat.mChannelsPerFrame;
sampleRate = sourceAudioFormat.mSampleRate;
UInt32 sizeOfLengthProperty = sizeof (int64);
ExtAudioFileGetProperty (audioFileRef,
kExtAudioFileProperty_FileLengthFrames,
&sizeOfLengthProperty,
&lengthInSamples);
destinationAudioFormat.mSampleRate = sampleRate;
destinationAudioFormat.mFormatID = kAudioFormatLinearPCM;
destinationAudioFormat.mFormatFlags = kLinearPCMFormatFlagIsFloat | kLinearPCMFormatFlagIsNonInterleaved | kAudioFormatFlagsNativeEndian;
destinationAudioFormat.mBitsPerChannel = sizeof (float) * 8;
destinationAudioFormat.mChannelsPerFrame = numChannels;
destinationAudioFormat.mBytesPerFrame = sizeof (float);
destinationAudioFormat.mFramesPerPacket = 1;
destinationAudioFormat.mBytesPerPacket = destinationAudioFormat.mFramesPerPacket * destinationAudioFormat.mBytesPerFrame;
status = ExtAudioFileSetProperty (audioFileRef,
kExtAudioFileProperty_ClientDataFormat,
sizeof (AudioStreamBasicDescription),
&destinationAudioFormat);
if (status == noErr)
{
bufferList.malloc (1, sizeof (AudioBufferList) + numChannels * sizeof (AudioBuffer));
bufferList->mNumberBuffers = numChannels;
ok = true;
}
}
}
}
AudioFile::AudioFile(const BytesSlice& data)
: _data(data) {
OSStatus err = AudioFileOpenWithCallbacks(
this, read_proc, NULL, get_size_proc, NULL, kAudioFileAIFFType, &_id);
check_os_err(err, "AudioFileOpenWithCallbacks");
}
sfx_obj<audio_queue_driver>::sfx_obj(const boost::shared_ptr<ifdstream>& ifd, bool loop, float pitch, float volume)
: ifd_(ifd)
, volume_(volume)
{
OSStatus res = AudioFileOpenWithCallbacks(this, &sfx_obj::af_read_cb, &sfx_obj::af_write_cb,
&sfx_obj::af_get_size_cb, &sfx_obj::af_set_size_cb,
kAudioFileCAFType, &audio_file_);
if(res)
{
throw sys_exception("audio_queue_driver: couldn't open SFX file in liverpool fs. AudioFileOpen returned "
+ boost::lexical_cast<std::string>(res));
}
UInt32 size = sizeof(data_format_);
AudioFileGetProperty(audio_file_, kAudioFilePropertyDataFormat, &size, &data_format_);
if (res != 0)
{
throw sys_exception("audio_queue_driver: couldn't load SFX file from liverpool fs. AudioFileReadBytes returned "
+ boost::lexical_cast<std::string>(res));
}
alGenBuffers(NUM_BUFFERS, buffers_);
alGenSources(1, &source_);
alSource3f(source_, AL_POSITION, 0.0, 0.0, 0.0);
alSource3f(source_, AL_VELOCITY, 0.0, 0.0, 0.0);
alSource3f(source_, AL_DIRECTION, 0.0, 0.0, 0.0);
alSourcef(source_, AL_PITCH, pitch);
alSourcef(source_, AL_GAIN, volume_);
alSourcei(source_, AL_LOOPING, loop?AL_TRUE:AL_FALSE);
alSourcef(source_, AL_ROLLOFF_FACTOR, 0.0);
alSourcei(source_, AL_SOURCE_RELATIVE, AL_TRUE);
if (data_format_.mBytesPerPacket == 0 || data_format_.mFramesPerPacket == 0)
{
LOG("Variable bitrate SFX");
size = sizeof(max_packet_size_);
AudioFileGetProperty(audio_file_, kAudioFilePropertyPacketSizeUpperBound, &size, &max_packet_size_);
if (max_packet_size_ > BUFFER_SIZE_BYTES)
{
max_packet_size_ = BUFFER_SIZE_BYTES;
}
num_packets_to_read_ = BUFFER_SIZE_BYTES / max_packet_size_;
}
else
{
LOG("Constant bitrate SFX");
num_packets_to_read_ = BUFFER_SIZE_BYTES / data_format_.mBytesPerPacket;
}
UInt32 offset = 0;
std::vector<unsigned char> dat;
for( int i=0; i<NUM_BUFFERS; ++i)
{
UInt32 packets = num_packets_to_read_;
dat.resize(BUFFER_SIZE_BYTES);
res = AudioFileReadPackets (audio_file_, false, &size, NULL, offset, &packets, &dat.at(0));
if(res != noErr)
{
throw sys_exception("AudioFileReadPackets returned error: " + boost::lexical_cast<std::string>(res));
}
if (size == 0)
{
LOG("All buffered into %d buffers total.", i+1);
break; // done
}
dat.resize(size);
LOG("Read %d bytes", size);
LOG("Buffering data.. size is %d", dat.size());
alBufferData(buffers_[i], AL_FORMAT_STEREO16, &dat.at(0), dat.size(), 44100);
alSourcei(source_, AL_BUFFER, buffers_[i]);
offset += packets;
}
AudioFileClose(audio_file_);
}
ExtAFSource::ExtAFSource(const std::shared_ptr<FILE> &fp)
: m_fp(fp)
{
AudioFileID afid;
void *ctx = reinterpret_cast<void*>(fileno(fp.get()));
CHECKCA(AudioFileOpenWithCallbacks(ctx, audiofile::read, 0,
audiofile::size, 0, 0, &afid));
m_af.attach(afid, true);
ExtAudioFileRef eaf;
CHECKCA(ExtAudioFileWrapAudioFileID(m_af, false, &eaf));
m_eaf.attach(eaf, true);
std::vector<AudioFormatListItem> aflist;
m_af.getFormatList(&aflist);
m_iasbd = aflist[0].mASBD;
if (m_iasbd.mFormatID != 'lpcm' && m_iasbd.mFormatID != 'alac' &&
m_iasbd.mFormatID != '.mp3')
throw std::runtime_error("Not supported input format");
uint32_t fcc = m_af.getFileFormat();
if (m_iasbd.mFormatID == 'lpcm') {
bool isfloat = m_iasbd.mFormatFlags & kAudioFormatFlagIsFloat;
uint32_t bits = m_iasbd.mBytesPerFrame / m_iasbd.mChannelsPerFrame * 8;
m_asbd = cautil::buildASBDForPCM2(m_iasbd.mSampleRate,
m_iasbd.mChannelsPerFrame,
m_iasbd.mBitsPerChannel,
isfloat ? bits : 32,
isfloat ? kAudioFormatFlagIsFloat
: kAudioFormatFlagIsSignedInteger);
} else if (m_iasbd.mFormatID == 'alac') {
unsigned bits_per_channel;
{
unsigned tab[] = { 16, 20, 24, 32 };
unsigned index = (m_iasbd.mFormatFlags - 1) & 0x3;
bits_per_channel = tab[index];
}
m_asbd = cautil::buildASBDForPCM2(m_iasbd.mSampleRate,
m_iasbd.mChannelsPerFrame,
bits_per_channel, 32,
kAudioFormatFlagIsSignedInteger);
} else {
m_asbd = cautil::buildASBDForPCM2(m_iasbd.mSampleRate,
m_iasbd.mChannelsPerFrame, 32, 32,
kAudioFormatFlagIsFloat);
}
m_eaf.setClientDataFormat(m_asbd);
std::shared_ptr<AudioChannelLayout> acl;
try {
m_af.getChannelLayout(&acl);
chanmap::getChannels(acl.get(), &m_chanmap);
} catch (...) {}
/* Let AudioFile scan the file and generate index in case of MP3.
* Take up about 1s for 35min MP3 in my environment, but this is
* mandatory to obtain sample accurate information.
*/
m_af.getMaximumPacketSize();
int64_t length = m_af.getAudioDataPacketCount() * m_iasbd.mFramesPerPacket;
if (fcc == kAudioFileAIFFType || fcc == kAudioFileAIFCType)
ID3::fetchAiffID3Tags(fileno(m_fp.get()), &m_tags);
else if (fcc == kAudioFileMP3Type)
ID3::fetchMPEGID3Tags(fileno(m_fp.get()), &m_tags);
else {
try {
audiofile::fetchTags(m_af, m_fp.get(), &m_tags);
} catch (...) {}
}
try {
AudioFilePacketTableInfo ptinfo = { 0 };
m_af.getPacketTableInfo(&ptinfo);
int64_t total =
ptinfo.mNumberValidFrames + ptinfo.mPrimingFrames +
ptinfo.mRemainderFrames;
length = (total == length / 2) ? ptinfo.mNumberValidFrames * 2
: ptinfo.mNumberValidFrames;
} catch (CoreAudioException &e) {
if (!e.isNotSupportedError())
throw;
}
m_length = length;
}
static int CoreAudio_open(Sound_Sample *sample, const char *ext)
{
CoreAudioFileContainer* core_audio_file_container;
AudioFileID* audio_file_id;
OSStatus error_result;
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
AudioStreamBasicDescription actual_format;
AudioStreamBasicDescription output_format;
Float64 estimated_duration;
UInt32 format_size;
core_audio_file_container = (CoreAudioFileContainer*)malloc(sizeof(CoreAudioFileContainer));
BAIL_IF_MACRO(core_audio_file_container == NULL, ERR_OUT_OF_MEMORY, 0);
audio_file_id = (AudioFileID*)malloc(sizeof(AudioFileID));
BAIL_IF_MACRO(audio_file_id == NULL, ERR_OUT_OF_MEMORY, 0);
error_result = AudioFileOpenWithCallbacks(
internal->rw,
CoreAudio_ReadCallback,
NULL,
CoreAudio_SizeCallback,
NULL,
CoreAudio_GetAudioTypeForExtension(ext),
audio_file_id
);
if (error_result != noErr)
{
AudioFileClose(*audio_file_id);
free(audio_file_id);
free(core_audio_file_container);
SNDDBG(("Core Audio: can't grok data. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
BAIL_MACRO("Core Audio: Not valid audio data.", 0);
} /* if */
format_size = sizeof(actual_format);
error_result = AudioFileGetProperty(
*audio_file_id,
kAudioFilePropertyDataFormat,
&format_size,
&actual_format
);
if (error_result != noErr)
{
AudioFileClose(*audio_file_id);
free(audio_file_id);
free(core_audio_file_container);
SNDDBG(("Core Audio: AudioFileGetProperty failed. reason: [%s]", CoreAudio_FourCCToString(error_result)));
BAIL_MACRO("Core Audio: Not valid audio data.", 0);
} /* if */
format_size = sizeof(estimated_duration);
error_result = AudioFileGetProperty(
*audio_file_id,
kAudioFilePropertyEstimatedDuration,
&format_size,
&estimated_duration
);
if (error_result != noErr)
{
AudioFileClose(*audio_file_id);
free(audio_file_id);
free(core_audio_file_container);
SNDDBG(("Core Audio: AudioFileGetProperty failed. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
BAIL_MACRO("Core Audio: Not valid audio data.", 0);
} /* if */
core_audio_file_container->audioFileID = audio_file_id;
internal->decoder_private = core_audio_file_container;
sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
sample->actual.rate = (UInt32) actual_format.mSampleRate;
sample->actual.channels = (UInt8)actual_format.mChannelsPerFrame;
internal->total_time = (SInt32)(estimated_duration * 1000.0 + 0.5);
#if 0
/* FIXME: Both Core Audio and SDL 1.3 support float and 32-bit formats */
if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
{
if(16 == actual_format.mBitsPerChannel)
{
if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
{
sample->actual.format = AUDIO_S16MSB;
}
else
{
sample->actual.format = AUDIO_U16MSB;
}
}
else if(8 == actual_format.mBitsPerChannel)
{
if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
{
sample->actual.format = AUDIO_S8;
}
else
{
sample->actual.format = AUDIO_U8;
}
}
else // might be 0 for undefined?
{
// This case seems to come up a lot for me. Maybe for file types like .m4a?
sample->actual.format = AUDIO_S16SYS;
SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
}
}
else // little endian
{
if(16 == actual_format.mBitsPerChannel)
{
if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
{
sample->actual.format = AUDIO_S16LSB;
}
else
{
sample->actual.format = AUDIO_U16LSB;
}
}
else if(8 == actual_format.mBitsPerChannel)
{
if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
{
sample->actual.format = AUDIO_S8;
}
else
{
sample->actual.format = AUDIO_U8;
}
}
else // might be 0 for undefined?
{
sample->actual.format = AUDIO_S16SYS;
SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
}
}
#else
/*
* I want to use Core Audio to do conversion and decoding for performance reasons.
* This is particularly important on mobile devices like iOS.
* Taking from the Ogg Vorbis decode, I pretend the "actual" format is the same
* as the desired format.
*/
sample->actual.format = (sample->desired.format == 0) ?
AUDIO_S16SYS : sample->desired.format;
#endif
SNDDBG(("CoreAudio: channels == (%d).\n", sample->actual.channels));
SNDDBG(("CoreAudio: sampling rate == (%d).\n",sample->actual.rate));
SNDDBG(("CoreAudio: total seconds of sample == (%d).\n", internal->total_time));
SNDDBG(("CoreAudio: sample->actual.format == (%d).\n", sample->actual.format));
error_result = ExtAudioFileWrapAudioFileID(*audio_file_id,
false, // set to false for read-only
&core_audio_file_container->extAudioFileRef
);
if(error_result != noErr)
{
AudioFileClose(*audio_file_id);
free(audio_file_id);
free(core_audio_file_container);
SNDDBG(("Core Audio: can't wrap data. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
BAIL_MACRO("Core Audio: Failed to wrap data.", 0);
} /* if */
/* The output format must be linear PCM because that's the only type OpenAL knows how to deal with.
* Set the client format to 16 bit signed integer (native-endian) data because that is the most
* optimal format on iPhone/iPod Touch hardware.
* Maintain the channel count and sample rate of the original source format.
*/
output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
if(sample->desired.format == 0)
{
// do AUDIO_S16SYS
output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
output_format.mBitsPerChannel = 16; // We know we want 16-bit
}
else
{
output_format.mFormatFlags = 0; // clear flags
output_format.mFormatFlags |= kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
// Mask against bitsize
if(0xFF & sample->desired.format)
{
output_format.mBitsPerChannel = 16; /* 16-bit */
}
else
{
output_format.mBitsPerChannel = 8; /* 8-bit */
}
// Mask for signed/unsigned
if((1<<15) & sample->desired.format)
{
output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsSignedInteger;
}
else
{
// no flag set for unsigned
}
// Mask for big/little endian
if((1<<12) & sample->desired.format)
{
output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsBigEndian;
}
else
{
// no flag set for little endian
}
}
output_format.mBytesPerPacket = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // e.g. 16-bits/8 * channels => so 2-bytes per channel per frame
output_format.mBytesPerFrame = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
/*
output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
// output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger;
output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
output_format.mBitsPerChannel = 16; // We know we want 16-bit
output_format.mBytesPerPacket = 2 * output_format.mChannelsPerFrame; // We know we are using 16-bit, so 2-bytes per channel per frame
output_format.mBytesPerFrame = 2 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
*/
SNDDBG(("output_format: mSampleRate: %lf\n", output_format.mSampleRate));
SNDDBG(("output_format: mChannelsPerFrame: %d\n", output_format.mChannelsPerFrame));
SNDDBG(("output_format: mFormatID: %d\n", output_format.mFormatID));
SNDDBG(("output_format: mFormatFlags: %d\n", output_format.mFormatFlags));
SNDDBG(("output_format: mFramesPerPacket: %d\n", output_format.mFramesPerPacket));
SNDDBG(("output_format: mBitsPerChannel: %d\n", output_format.mBitsPerChannel));
SNDDBG(("output_format: mBytesPerPacket: %d\n", output_format.mBytesPerPacket));
SNDDBG(("output_format: mBytesPerFrame: %d\n", output_format.mBytesPerFrame));
/* Set the desired client (output) data format */
error_result = ExtAudioFileSetProperty(core_audio_file_container->extAudioFileRef, kExtAudioFileProperty_ClientDataFormat, sizeof(output_format), &output_format);
if(noErr != error_result)
{
ExtAudioFileDispose(core_audio_file_container->extAudioFileRef);
AudioFileClose(*audio_file_id);
free(audio_file_id);
free(core_audio_file_container);
SNDDBG(("Core Audio: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) failed, reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
BAIL_MACRO("Core Audio: Not valid audio data.", 0);
}
core_audio_file_container->outputFormat = (AudioStreamBasicDescription*)malloc(sizeof(AudioStreamBasicDescription));
BAIL_IF_MACRO(core_audio_file_container->outputFormat == NULL, ERR_OUT_OF_MEMORY, 0);
/* Copy the output format to the audio_description that was passed in so the
* info will be returned to the user.
*/
memcpy(core_audio_file_container->outputFormat, &output_format, sizeof(AudioStreamBasicDescription));
return(1);
} /* CoreAudio_open */
bool SFB::Audio::CoreAudioDecoder::_Open(CFErrorRef *error)
{
// Open the input file
OSStatus result = AudioFileOpenWithCallbacks(this, myAudioFile_ReadProc, nullptr, myAudioFile_GetSizeProc, nullptr, 0, &mAudioFile);
if(noErr != result) {
LOGGER_CRIT("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileOpenWithCallbacks failed: " << result);
if(error) {
SFB::CFString description = CFCopyLocalizedString(CFSTR("The format of the file “%@” was not recognized."), "");
SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("File Format Not Recognized"), "");
SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
return false;
}
result = ExtAudioFileWrapAudioFileID(mAudioFile, false, &mExtAudioFile);
if(noErr != result) {
LOGGER_CRIT("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileWrapAudioFileID failed: " << result);
if(error) {
SFB::CFString description = CFCopyLocalizedString(CFSTR("The format of the file “%@” was not recognized."), "");
SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("File Format Not Recognized"), "");
SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(Decoder::ErrorDomain, Decoder::InputOutputError, description, mInputSource->GetURL(), failureReason, recoverySuggestion);
}
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
return false;
}
// Query file format
UInt32 dataSize = sizeof(mSourceFormat);
result = ExtAudioFileGetProperty(mExtAudioFile, kExtAudioFileProperty_FileDataFormat, &dataSize, &mSourceFormat);
if(noErr != result) {
LOGGER_CRIT("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileGetProperty (kExtAudioFileProperty_FileDataFormat) failed: " << result);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
// Tell the ExtAudioFile the format in which we'd like our data
// For Linear PCM formats, leave the data untouched
if(kAudioFormatLinearPCM == mSourceFormat.mFormatID)
mFormat = mSourceFormat;
// For Apple Lossless, convert to high-aligned signed ints in 32 bits
else if(kAudioFormatAppleLossless == mSourceFormat.mFormatID) {
mFormat.mFormatID = kAudioFormatLinearPCM;
mFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsAlignedHigh;
mFormat.mSampleRate = mSourceFormat.mSampleRate;
mFormat.mChannelsPerFrame = mSourceFormat.mChannelsPerFrame;
if(kAppleLosslessFormatFlag_16BitSourceData == mSourceFormat.mFormatFlags)
mFormat.mBitsPerChannel = 16;
else if(kAppleLosslessFormatFlag_20BitSourceData == mSourceFormat.mFormatFlags)
mFormat.mBitsPerChannel = 20;
else if(kAppleLosslessFormatFlag_24BitSourceData == mSourceFormat.mFormatFlags)
mFormat.mBitsPerChannel = 24;
else if(kAppleLosslessFormatFlag_32BitSourceData == mSourceFormat.mFormatFlags)
mFormat.mBitsPerChannel = 32;
mFormat.mBytesPerPacket = 4 * mFormat.mChannelsPerFrame;
mFormat.mFramesPerPacket = 1;
mFormat.mBytesPerFrame = mFormat.mBytesPerPacket * mFormat.mFramesPerPacket;
mFormat.mReserved = 0;
}
// For all other formats convert to the canonical Core Audio format
else {
mFormat.mFormatID = kAudioFormatLinearPCM;
mFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
mFormat.mSampleRate = mSourceFormat.mSampleRate;
mFormat.mChannelsPerFrame = mSourceFormat.mChannelsPerFrame;
mFormat.mBitsPerChannel = 32;
mFormat.mBytesPerPacket = (mFormat.mBitsPerChannel / 8);
mFormat.mFramesPerPacket = 1;
mFormat.mBytesPerFrame = mFormat.mBytesPerPacket * mFormat.mFramesPerPacket;
mFormat.mReserved = 0;
}
result = ExtAudioFileSetProperty(mExtAudioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(mFormat), &mFormat);
if(noErr != result) {
LOGGER_CRIT("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileSetProperty (kExtAudioFileProperty_ClientDataFormat) failed: " << result);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
// Setup the channel layout
// There is a bug in EAF where if the underlying AF doesn't return a channel layout it returns an empty struct
// result = ExtAudioFileGetPropertyInfo(mExtAudioFile, kExtAudioFileProperty_FileChannelLayout, &dataSize, nullptr);
result = AudioFileGetPropertyInfo(mAudioFile, kAudioFilePropertyChannelLayout, &dataSize, nullptr);
if(noErr == result) {
auto channelLayout = (AudioChannelLayout *)malloc(dataSize);
// result = ExtAudioFileGetProperty(mExtAudioFile, kExtAudioFileProperty_FileChannelLayout, &dataSize, mChannelLayout);
result = AudioFileGetProperty(mAudioFile, kAudioFilePropertyChannelLayout, &dataSize, channelLayout);
if(noErr != result) {
// LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileGetProperty (kExtAudioFileProperty_FileChannelLayout) failed: " << result);
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileGetProperty (kAudioFilePropertyChannelLayout) failed: " << result);
free(channelLayout);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
mChannelLayout = channelLayout;
free(channelLayout);
}
else
// LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileGetPropertyInfo (kExtAudioFileProperty_FileChannelLayout) failed: " << result);
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileGetPropertyInfo (kAudioFilePropertyChannelLayout) failed: " << result);
// Work around bugs in ExtAudioFile: http://lists.apple.com/archives/coreaudio-api/2009/Nov/msg00119.html
// Synopsis: ExtAudioFileTell() and ExtAudioFileSeek() are broken for m4a files
AudioFileID audioFile;
dataSize = sizeof(audioFile);
result = ExtAudioFileGetProperty(mExtAudioFile, kExtAudioFileProperty_AudioFile, &dataSize, &audioFile);
if(noErr != result) {
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileGetProperty (kExtAudioFileProperty_AudioFile) failed: " << result);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
AudioFileTypeID fileFormat;
dataSize = sizeof(fileFormat);
result = AudioFileGetProperty(audioFile, kAudioFilePropertyFileFormat, &dataSize, &fileFormat);
if(noErr != result) {
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileGetProperty (kAudioFilePropertyFileFormat) failed: " << result);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
if(kAudioFileM4AType == fileFormat || kAudioFileMPEG4Type == fileFormat || kAudioFileAAC_ADTSType == fileFormat)
mUseM4AWorkarounds = true;
#if 0
// This was supposed to determine if ExtAudioFile had been fixed, but even though
// it passes on 10.6.2 things are not behaving properly
SInt64 currentFrame = -1;
result = ExtAudioFileTell(mExtAudioFile, ¤tFrame);
if(noErr != result) {
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileTell failed: " << result);
result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
mExtAudioFile = nullptr;
return false;
}
if(0 > currentFrame)
mUseM4AWorkarounds = true;
#endif
return true;
}
