CoreAudioReader (InputStream* const inp)
: AudioFormatReader (inp, TRANS (coreAudioFormatName)),
ok (false), lastReadPosition (0)
{
usesFloatingPointData = true;
bitsPerSample = 32;
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;
}
}
}
}
bool nuiAudioDecoder::ReadInfo()
{
if (!mpPrivate)
return false;
AudioStreamBasicDescription FileDesc;
AudioStreamBasicDescription ClientDesc;
UInt32 PropDataSize;
OSStatus res;
// #FIXME: the value given by this function is sometimes wrong:
// with some m4a files and with Mac OS 10.5, SampleFrames will be 16x too big
// get length
SInt64 SampleFrames = 0;
PropDataSize = sizeof(SampleFrames);
res = ExtAudioFileGetProperty(mpPrivate->mExtAudioFileRef, kExtAudioFileProperty_FileLengthFrames, &PropDataSize, &SampleFrames);
if (res != noErr)
return false;
PropDataSize = sizeof(FileDesc);
res = ExtAudioFileGetProperty(mpPrivate->mExtAudioFileRef, kExtAudioFileProperty_FileDataFormat, &PropDataSize, &FileDesc);
if (res != noErr)
return false;
double SampleRate = FileDesc.mSampleRate;
uint32 channels = FileDesc.mChannelsPerFrame;
uint32 BitsPerSample = 32;
ClientDesc.mSampleRate = SampleRate;
ClientDesc.mChannelsPerFrame = channels;
ClientDesc.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked | kAudioFormatFlagIsNonInterleaved;
ClientDesc.mFormatID = kAudioFormatLinearPCM;
ClientDesc.mFramesPerPacket = 1;
ClientDesc.mBitsPerChannel = BitsPerSample;
ClientDesc.mBytesPerFrame = BitsPerSample / 8;
ClientDesc.mBytesPerPacket = BitsPerSample / 8;
PropDataSize = sizeof(ClientDesc);
res = ExtAudioFileSetProperty(mpPrivate->mExtAudioFileRef, kExtAudioFileProperty_ClientDataFormat, PropDataSize, &ClientDesc);
if (res != noErr)
return false;
mInfo.SetSampleFrames(SampleFrames);
mInfo.SetSampleRate(SampleRate);
mInfo.SetChannels(channels);
mInfo.SetBitsPerSample(BitsPerSample);
mInfo.SetFileFormat(eAudioCompressed);
mInfo.SetStartFrame(0);
mInfo.SetStopFrame(mInfo.GetSampleFrames());
return true;
}
bool refresh()
{
OSStatus sta;
AudioStreamBasicDescription& fmt = d_owner->format;
UInt32 size = sizeof(fmt);
// get input audio format.
{
sta = ExtAudioFileGetProperty(extstm,
kExtAudioFileProperty_FileDataFormat,
&size,
&fmt);
if (sta != 0)
return false;
}
// set output format.
{
ofmt.mSampleRate = fmt.mSampleRate;
ofmt.mChannelsPerFrame = fmt.mChannelsPerFrame;
ofmt.mFormatID = kAudioFormatLinearPCM;
ofmt.mBytesPerPacket = 2 * ofmt.mChannelsPerFrame;
ofmt.mFramesPerPacket = 1;
ofmt.mBytesPerFrame = 2 * ofmt.mChannelsPerFrame;
ofmt.mBitsPerChannel = 16;
ofmt.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
sta = ExtAudioFileSetProperty(extstm,
kExtAudioFileProperty_ClientDataFormat,
sizeof(ofmt),
&ofmt);
if (sta)
return false;
}
// get data.
{
SInt64 count;
size = sizeof(count);
sta = ExtAudioFileGetProperty(extstm,
kExtAudioFileProperty_FileLengthFrames,
&size,
&count);
if (sta)
return false;
frames = count;
}
return true;
}
void ExtAudioFile::convert(Bytes& data, ALenum& format, ALsizei& frequency) {
OSStatus err;
// Read in the original file format.
AudioStreamBasicDescription in_format;
UInt32 in_format_size = sizeof(AudioStreamBasicDescription);
err = ExtAudioFileGetProperty(_id, kExtAudioFileProperty_FileDataFormat, &in_format_size,
&in_format);
check_os_err(err, "ExtAudioFileGetProperty");
frequency = in_format.mSampleRate;
if (in_format.mChannelsPerFrame == 1) {
format = AL_FORMAT_MONO16;
} else if (in_format.mChannelsPerFrame == 2) {
format = AL_FORMAT_STEREO16;
} else {
throw Exception("audio file has more than two channels");
}
// Convert to 16-bit native-endian linear PCM. Preserve the frequency and channel count
// of the original format.
AudioStreamBasicDescription out_format = in_format;
out_format.mFormatID = kAudioFormatLinearPCM;
out_format.mBytesPerPacket = 2 * out_format.mChannelsPerFrame;
out_format.mFramesPerPacket = 1;
out_format.mBytesPerFrame = 2 * out_format.mChannelsPerFrame;
out_format.mBitsPerChannel = 16;
out_format.mFormatFlags = kAudioFormatFlagsNativeEndian
| kAudioFormatFlagIsPacked
| kAudioFormatFlagIsSignedInteger;
err = ExtAudioFileSetProperty(_id, kExtAudioFileProperty_ClientDataFormat,
sizeof(AudioStreamBasicDescription), &out_format);
check_os_err(err, "ExtAudioFileSetProperty");
// Get the number of frames.
SInt64 frame_count;
UInt32 frame_count_size = sizeof(int64_t);
err = ExtAudioFileGetProperty(_id, kExtAudioFileProperty_FileLengthFrames, &frame_count_size,
&frame_count);
check_os_err(err, "ExtAudioFileGetProperty");
// Read the converted frames into memory.
UInt32 frame_count_32 = frame_count;
data.resize(frame_count * out_format.mBytesPerFrame);
AudioBufferList data_buffer;
data_buffer.mNumberBuffers = 1;
data_buffer.mBuffers[0].mDataByteSize = data.size();
data_buffer.mBuffers[0].mNumberChannels = out_format.mChannelsPerFrame;
data_buffer.mBuffers[0].mData = data.data();
err = ExtAudioFileRead(_id, &frame_count_32, &data_buffer);
check_os_err(err, "ExtAudioFileRead");
}
bool ExtAudioFileAudioSource::init(const RString& path, bool loadIntoMemory)
{
if(mLoadedInMemory && loadIntoMemory)
return true;
// FIXME: query the file to find out how many channels instead of hardcoding.
CFURLRef path_url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault,
(const UInt8*)path.data(),
path.length(),
false
);
OSStatus err = ExtAudioFileOpenURL(path_url, &mAudioFile);
if(err)
{
printCode("ExtAudioFileOpenURL: ", err);
return false;
}
UInt32 propSize = sizeof(mClientFormat);
err = ExtAudioFileGetProperty(mAudioFile, kExtAudioFileProperty_FileDataFormat, &propSize, &mClientFormat);
propSize = sizeof(mTotalFrames);
err = ExtAudioFileGetProperty(mAudioFile, kExtAudioFileProperty_FileLengthFrames, &propSize, &mTotalFrames);
// Setup output format
FillOutASBDForLPCM(mFormat, getSampleRate(), getNumChannels(), 32, 32, true, false,true);
err = ExtAudioFileSetProperty(mAudioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(mFormat), &mFormat);
if(err)
{
printCode("ExtAudioFileSetProperty: ", err);
return false;
}
// Allocate our buffer list with NUM_CHANNELS buffers in it.
mpBufferList = (AudioBufferList *)malloc(sizeof(AudioBufferList) + (getNumChannels() - 1) * sizeof(AudioBuffer));
mpBufferList->mNumberBuffers = getNumChannels();
return BufferedAudioSource::init(path, loadIntoMemory);
}
SInt64 SFB::Audio::CoreAudioDecoder::_GetTotalFrames() const
{
SInt64 totalFrames = -1;
UInt32 dataSize = sizeof(totalFrames);
OSStatus result = ExtAudioFileGetProperty(mExtAudioFile, kExtAudioFileProperty_FileLengthFrames, &dataSize, &totalFrames);
if(noErr != result)
LOGGER_ERR("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileGetProperty (kExtAudioFileProperty_FileLengthFrames) failed: " << result);
return totalFrames;
}
void init()
{
// Streaming starts at beginning
position_ = 0;
// Unless overridden later, assume that the index into seek() is 0-based
seekOffset_ = 0;
AudioStreamBasicDescription desc;
UInt32 sizeOfProperty = sizeof desc;
CHECK_OS(ExtAudioFileGetProperty(file_, kExtAudioFileProperty_FileDataFormat,
&sizeOfProperty, &desc));
// Sample rate for OpenAL
sampleRate_ = desc.mSampleRate;
// Sanity checks
if (desc.mFormatFlags & kAudioFormatFlagIsNonInterleaved)
throw std::runtime_error("Non-interleaved formats are unsupported");
// Easy formats
format_ = 0;
if (desc.mChannelsPerFrame == 1)
{
/*if (desc.mBitsPerChannel == 8)
format_ = AL_FORMAT_MONO8;
else*/ if (desc.mBitsPerChannel == 16)
format_ = AL_FORMAT_MONO16;
}
else if (desc.mChannelsPerFrame == 2)
{
/*if (desc.mBitsPerChannel == 8)
format_ = AL_FORMAT_STEREO8;
else */if (desc.mBitsPerChannel == 16)
format_ = AL_FORMAT_STEREO16;
}
if (format_ == 0 ||
// If format not native for OpenAL, set client data format
// to enable conversion
desc.mFormatFlags & kAudioFormatFlagIsBigEndian ||
desc.mFormatFlags & kAudioFormatFlagIsFloat ||
!(desc.mFormatFlags & kAudioFormatFlagIsSignedInteger))
initClientFormatBasedOn(desc);
else
// Just set the old format as the client format so
// ExtAudioFileSeek will work for us.
CHECK_OS(ExtAudioFileSetProperty(file_,
kExtAudioFileProperty_ClientDataFormat,
sizeof desc, &desc));
}
OSStatus setUpExtAudioFile (MyStreamPlayer* player) {
CFURLRef streamFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
STREAM_PATH,
kCFURLPOSIXPathStyle,
false);
// describe the client format - AL needs mono
memset(&player->dataFormat, 0, sizeof(player->dataFormat));
player->dataFormat.mFormatID = kAudioFormatLinearPCM;
player->dataFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
player->dataFormat.mSampleRate = 44100.0;
player->dataFormat.mChannelsPerFrame = 1;
player->dataFormat.mFramesPerPacket = 1;
player->dataFormat.mBitsPerChannel = 16;
player->dataFormat.mBytesPerFrame = 2;
player->dataFormat.mBytesPerPacket = 2;
CheckError (ExtAudioFileOpenURL(streamFileURL, &player->extAudioFile),
"Couldn't open ExtAudioFile for reading");
// tell extAudioFile about our format
CheckError(ExtAudioFileSetProperty(player->extAudioFile,
kExtAudioFileProperty_ClientDataFormat,
sizeof (AudioStreamBasicDescription),
&player->dataFormat),
"Couldn't set client format on ExtAudioFile");
// figure out how big file is
UInt32 propSize = sizeof (player->fileLengthFrames);
ExtAudioFileGetProperty(player->extAudioFile,
kExtAudioFileProperty_FileLengthFrames,
&propSize,
&player->fileLengthFrames);
printf ("fileLengthFrames = %lld frames\n", player->fileLengthFrames);
player->bufferSizeBytes = BUFFER_DURATION_SECONDS *
player->dataFormat.mSampleRate *
player->dataFormat.mBytesPerFrame;
printf ("bufferSizeBytes = %d\n", player->bufferSizeBytes);
printf ("Bottom of setUpExtAudioFile\n");
return noErr;
}
core_audio_sound* CCoreAudioSoundManager::LoadSoundFromFile(const CStdString& fileName)
{
FSRef fileRef;
UInt32 size = 0;
ExtAudioFileRef audioFile;
OSStatus ret = FSPathMakeRef((const UInt8*) fileName.c_str(), &fileRef, false);
ret = ExtAudioFileOpen(&fileRef, &audioFile);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to open source file (%s). Error = 0x%08x (%4.4s)", fileName.c_str(), ret, CONVERT_OSSTATUS(ret));
return NULL;
}
core_audio_sound* pSound = new core_audio_sound;
// Retrieve the format of the source file
AudioStreamBasicDescription inputFormat;
size = sizeof(inputFormat);
ret = ExtAudioFileGetProperty(audioFile, kExtAudioFileProperty_FileDataFormat, &size, &inputFormat);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to fetch source file format. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));
delete pSound;
return NULL;
}
// Set up format conversion. This is the format that will be produced by Read/Write calls.
// Here we use the same format provided to the output AudioUnit
ret = ExtAudioFileSetProperty(audioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(AudioStreamBasicDescription), &m_OutputFormat);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to set conversion format. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));
delete pSound;
return NULL;
}
// Retrieve the file size (in terms of the file's sample-rate, not the output sample-rate)
UInt64 totalFrames;
size = sizeof(totalFrames);
ret = ExtAudioFileGetProperty(audioFile, kExtAudioFileProperty_FileLengthFrames, &size, &totalFrames);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to fetch source file size. Error = 0x%08x (%4.4s)", ret, CONVERT_OSSTATUS(ret));
delete pSound;
return NULL;
}
// Calculate the total number of converted frames to be read
totalFrames *= (float)m_OutputFormat.mSampleRate / (float)inputFormat.mSampleRate; // TODO: Verify the accuracy of this
// Allocate AudioBuffers
UInt32 channelCount = m_OutputFormat.mChannelsPerFrame;
pSound->buffer_list = (AudioBufferList*)calloc(1, sizeof(AudioBufferList) + sizeof(AudioBuffer) * (channelCount - kVariableLengthArray));
pSound->buffer_list->mNumberBuffers = channelCount; // One buffer per channel for deinterlaced pcm
float* buffers = (float*)calloc(1, sizeof(float) * totalFrames * channelCount);
for(int i = 0; i < channelCount; i++)
{
pSound->buffer_list->mBuffers[i].mNumberChannels = 1; // One channel per buffer for deinterlaced pcm
pSound->buffer_list->mBuffers[i].mData = buffers + (totalFrames * i);
pSound->buffer_list->mBuffers[i].mDataByteSize = totalFrames * sizeof(float);
}
// Read the entire file
// TODO: Should we limit the total file length?
UInt32 readFrames = totalFrames;
ret = ExtAudioFileRead(audioFile, &readFrames, pSound->buffer_list);
if (ret)
{
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to read from file (%s). Error = 0x%08x (%4.4s)", fileName.c_str(), ret, CONVERT_OSSTATUS(ret));
delete pSound;
return NULL;
}
pSound->total_frames = readFrames; // Store the actual number of frames read from the file. Rounding errors in calcuating the converted number of frames can truncate the read.
// TODO: What do we do with files with more than 2 channels. Currently we just copy the first two and dump the rest.
if (inputFormat.mChannelsPerFrame == 1) // Copy Left channel into Right if the source file is Mono
memcpy(pSound->buffer_list->mBuffers[1].mData, pSound->buffer_list->mBuffers[0].mData, pSound->buffer_list->mBuffers[0].mDataByteSize);
ret = ExtAudioFileDispose(audioFile); // Close the file. We have what we need. Not a lot to be done on failure.
if (ret)
CLog::Log(LOGERROR, "CCoreAudioSoundManager::LoadSoundFromFile: Unable to close file (%s). Error = 0x%08x (%4.4s)", fileName.c_str(), ret, CONVERT_OSSTATUS(ret));
pSound->ref_count = 1; // The caller holds a reference to this object now
pSound->play_count = 0;
return pSound;
}
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;
}
int AudioDecoderCoreAudio::open() {
//Open the audio file.
OSStatus err;
/** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */
/*CFStringRef urlStr = CFStringCreateWithCharacters(0,
reinterpret_cast<const UniChar *>(
//qurlStr.unicode()), qurlStr.size());
m_filename.data()), m_filename.size());
*/
CFStringRef urlStr = CFStringCreateWithCString(kCFAllocatorDefault,
m_filename.c_str(),
kCFStringEncodingUTF8);
//CFStringGetSystemEncoding());
CFURLRef urlRef = CFURLCreateWithFileSystemPath(NULL, urlStr, kCFURLPOSIXPathStyle, false);
err = ExtAudioFileOpenURL(urlRef, &m_audioFile);
CFRelease(urlStr);
CFRelease(urlRef);
/** TODO: Use FSRef for compatibility with 10.4 Tiger.
Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain
both code paths if someone finishes this part of the code.
FSRef fsRef;
CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
err = ExtAudioFileOpen(&fsRef, &m_audioFile);
*/
if (err != noErr)
{
std::cerr << "AudioDecoderCoreAudio: Error opening file." << std::endl;
return AUDIODECODER_ERROR;
}
// get the input file format
CAStreamBasicDescription inputFormat;
UInt32 size = sizeof(inputFormat);
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileDataFormat, &size, &inputFormat);
if (err != noErr)
{
std::cerr << "AudioDecoderCoreAudio: Error getting file format." << std::endl;
return AUDIODECODER_ERROR;
}
m_inputFormat = inputFormat;
// create the output format
CAStreamBasicDescription outputFormat;
bzero(&outputFormat, sizeof(AudioStreamBasicDescription));
outputFormat.mFormatID = kAudioFormatLinearPCM;
outputFormat.mSampleRate = inputFormat.mSampleRate;
outputFormat.mChannelsPerFrame = 2;
outputFormat.mFormatFlags = kAudioFormatFlagsCanonical;
//kAudioFormatFlagsCanonical means Native endian, float, packed on Mac OS X,
//but signed int for iOS instead.
//Note iPhone/iOS only supports signed integers supposedly:
outputFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger;
//Debugging:
//printf ("Source File format: "); inputFormat.Print();
//printf ("Dest File format: "); outputFormat.Print();
/*
switch(inputFormat.mBitsPerChannel) {
case 16:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_16BitSourceData;
break;
case 20:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_20BitSourceData;
break;
case 24:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_24BitSourceData;
break;
case 32:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_32BitSourceData;
break;
}*/
// get and set the client format - it should be lpcm
CAStreamBasicDescription clientFormat = outputFormat; //We're always telling the OS to do the conversion to floats for us now
clientFormat.mChannelsPerFrame = 2;
clientFormat.mBytesPerFrame = sizeof(SAMPLE)*clientFormat.mChannelsPerFrame;
clientFormat.mBitsPerChannel = sizeof(SAMPLE)*8; //16 for signed int, 32 for float;
clientFormat.mFramesPerPacket = 1;
clientFormat.mBytesPerPacket = clientFormat.mBytesPerFrame*clientFormat.mFramesPerPacket;
clientFormat.mReserved = 0;
m_clientFormat = clientFormat;
size = sizeof(clientFormat);
err = ExtAudioFileSetProperty(m_audioFile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat);
if (err != noErr)
{
//qDebug() << "SSCA: Error setting file property";
std::cerr << "AudioDecoderCoreAudio: Error setting file property." << std::endl;
return AUDIODECODER_ERROR;
}
//Set m_iChannels and m_iNumSamples;
m_iChannels = clientFormat.NumberChannels();
//get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47
UInt32 dataSize;
SInt64 totalFrameCount;
dataSize = sizeof(totalFrameCount); //XXX: This looks sketchy to me - Albert
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileLengthFrames, &dataSize, &totalFrameCount);
if (err != noErr)
{
std::cerr << "AudioDecoderCoreAudio: Error getting number of frames." << std::endl;
return AUDIODECODER_ERROR;
}
//
// WORKAROUND for bug in ExtFileAudio
//
AudioConverterRef acRef;
UInt32 acrsize=sizeof(AudioConverterRef);
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_AudioConverter, &acrsize, &acRef);
//_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err);
AudioConverterPrimeInfo primeInfo;
UInt32 piSize=sizeof(AudioConverterPrimeInfo);
memset(&primeInfo, 0, piSize);
err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize, &primeInfo);
if(err != kAudioConverterErr_PropertyNotSupported) // Only if decompressing
{
//_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err);
m_headerFrames=primeInfo.leadingFrames;
}
m_iNumSamples = (totalFrameCount/*-m_headerFrames*/)*m_iChannels;
m_iSampleRate = inputFormat.mSampleRate;
m_fDuration = m_iNumSamples / static_cast<float>(m_iSampleRate * m_iChannels);
//Convert mono files into stereo
if (inputFormat.NumberChannels() == 1)
{
SInt32 channelMap[2] = {0, 0}; // array size should match the number of output channels
AudioConverterSetProperty(acRef, kAudioConverterChannelMap,
sizeof(channelMap), channelMap);
}
//Seek to position 0, which forces us to skip over all the header frames.
//This makes sure we're ready to just let the Analyser rip and it'll
//get the number of samples it expects (ie. no header frames).
seek(0);
return AUDIODECODER_OK;
}
// soundsource overrides
int SoundSourceCoreAudio::open() {
//m_file.open(QIODevice::ReadOnly);
//Open the audio file.
OSStatus err;
//QUrl blah(m_qFilename);
QString qurlStr = m_qFilename;//blah.toString();
qDebug() << qurlStr;
/** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */
CFStringRef urlStr = CFStringCreateWithCharacters(0,
reinterpret_cast<const UniChar *>(
qurlStr.unicode()), qurlStr.size());
CFURLRef urlRef = CFURLCreateWithFileSystemPath(NULL, urlStr, kCFURLPOSIXPathStyle, false);
err = ExtAudioFileOpenURL(urlRef, &m_audioFile);
CFRelease(urlStr);
CFRelease(urlRef);
/** TODO: Use FSRef for compatibility with 10.4 Tiger.
Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain
both code paths if someone finishes this part of the code.
FSRef fsRef;
CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
err = ExtAudioFileOpen(&fsRef, &m_audioFile);
*/
if (err != noErr)
{
qDebug() << "SSCA: Error opening file.";
return ERR;
}
// get the input file format
CAStreamBasicDescription inputFormat;
UInt32 size = sizeof(inputFormat);
m_inputFormat = inputFormat;
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileDataFormat, &size, &inputFormat);
if (err != noErr)
{
qDebug() << "SSCA: Error getting file format";
return ERR;
}
//Debugging:
//printf ("Source File format: "); inputFormat.Print();
//printf ("Dest File format: "); outputFormat.Print();
// create the output format
CAStreamBasicDescription outputFormat;
bzero(&outputFormat, sizeof(AudioStreamBasicDescription));
outputFormat.mFormatID = kAudioFormatLinearPCM;
outputFormat.mSampleRate = inputFormat.mSampleRate;
outputFormat.mChannelsPerFrame = 2;
outputFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger;
/*
switch(inputFormat.mBitsPerChannel) {
case 16:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_16BitSourceData;
break;
case 20:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_20BitSourceData;
break;
case 24:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_24BitSourceData;
break;
case 32:
outputFormat.mFormatFlags = kAppleLosslessFormatFlag_32BitSourceData;
break;
}*/
// get and set the client format - it should be lpcm
CAStreamBasicDescription clientFormat = (inputFormat.mFormatID == kAudioFormatLinearPCM ? inputFormat : outputFormat);
clientFormat.mBytesPerPacket = 4;
clientFormat.mFramesPerPacket = 1;
clientFormat.mBytesPerFrame = 4;
clientFormat.mChannelsPerFrame = 2;
clientFormat.mBitsPerChannel = 16;
clientFormat.mReserved = 0;
m_clientFormat = clientFormat;
size = sizeof(clientFormat);
err = ExtAudioFileSetProperty(m_audioFile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat);
if (err != noErr)
{
qDebug() << "SSCA: Error setting file property";
return ERR;
}
//Set m_iChannels and m_samples;
m_iChannels = clientFormat.NumberChannels();
//get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47
UInt32 dataSize;
SInt64 totalFrameCount;
dataSize = sizeof(totalFrameCount); //XXX: This looks sketchy to me - Albert
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileLengthFrames, &dataSize, &totalFrameCount);
if (err != noErr)
{
qDebug() << "SSCA: Error getting number of frames";
return ERR;
}
//
// WORKAROUND for bug in ExtFileAudio
//
AudioConverterRef acRef;
UInt32 acrsize=sizeof(AudioConverterRef);
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_AudioConverter, &acrsize, &acRef);
//_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err);
AudioConverterPrimeInfo primeInfo;
UInt32 piSize=sizeof(AudioConverterPrimeInfo);
memset(&primeInfo, 0, piSize);
err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize, &primeInfo);
if(err != kAudioConverterErr_PropertyNotSupported) // Only if decompressing
{
//_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err);
m_headerFrames=primeInfo.leadingFrames;
}
m_samples = (totalFrameCount/*-m_headerFrames*/)*m_iChannels;
m_iDuration = m_samples / (inputFormat.mSampleRate * m_iChannels);
m_iSampleRate = inputFormat.mSampleRate;
qDebug() << m_samples << totalFrameCount << m_iChannels;
//Seek to position 0, which forces us to skip over all the header frames.
//This makes sure we're ready to just let the Analyser rip and it'll
//get the number of samples it expects (ie. no header frames).
seek(0);
return OK;
}
static void* GetOpenALAudioData( KLAL* p,
CFURLRef fileURL, ALsizei* dataSize, ALenum* dataFormat, ALsizei *sampleRate)
{
OSStatus err;
UInt32 size;
UInt32 bufferSize;
void* data = NULL;
AudioBufferList dataBuffer;
// オーディオファイルを開く
ExtAudioFileRef audioFile;
err = ExtAudioFileOpenURL(fileURL, &audioFile);
if (err)
{
KLLog("[KLAL] GetOpenALAudioData(A):%d\n",(int)err);
goto Exit;
}
//CFRelease(fileURL);
// オーディオデータフォーマットを取得する
AudioStreamBasicDescription fileFormat;
size = sizeof(fileFormat);
err = ExtAudioFileGetProperty(audioFile, kExtAudioFileProperty_FileDataFormat, &size, &fileFormat);
if (err)
{
KLLog("[KLAL] GetOpenALAudioData(B):%d\n",(int)err);
goto Exit;
}
// アウトプットフォーマットを設定する
AudioStreamBasicDescription outputFormat;
outputFormat.mSampleRate = fileFormat.mSampleRate;
outputFormat.mChannelsPerFrame = fileFormat.mChannelsPerFrame;
outputFormat.mFormatID = kAudioFormatLinearPCM;
outputFormat.mBytesPerPacket = 2 * outputFormat.mChannelsPerFrame;
outputFormat.mFramesPerPacket = 1;
outputFormat.mBytesPerFrame = 2 * outputFormat.mChannelsPerFrame;
outputFormat.mBitsPerChannel = 16;//fileFormat.mBitsPerChannel;
outputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
p->wav.channel = outputFormat.mChannelsPerFrame;
p->wav.bit = fileFormat.mBitsPerChannel;
p->wav.freq = fileFormat.mSampleRate;
err = ExtAudioFileSetProperty(
audioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(outputFormat), &outputFormat);
if (err)
{
KLLog("[KLAL] GetOpenALAudioData(C):%d\n",(int)err);
goto Exit;
}
// フレーム数を取得する
SInt64 fileLengthFrames = 0;
size = sizeof(fileLengthFrames);
err = ExtAudioFileGetProperty(
audioFile, kExtAudioFileProperty_FileLengthFrames, &size, &fileLengthFrames);
if (err)
{
KLLog("[KLAL] GetOpenALAudioData(D):%d\n",(int)err);
goto Exit;
}
// バッファを用意する
bufferSize = (UInt32) fileLengthFrames * (UInt32) outputFormat.mBytesPerFrame;
data = Malloc(bufferSize);
dataBuffer.mNumberBuffers = 1;
dataBuffer.mBuffers[0].mDataByteSize = bufferSize;
dataBuffer.mBuffers[0].mNumberChannels = outputFormat.mChannelsPerFrame;
dataBuffer.mBuffers[0].mData = data;
p->wav.sz = bufferSize;
// バッファにデータを読み込む
err = ExtAudioFileRead(audioFile, (UInt32*)&fileLengthFrames, &dataBuffer);
if (err)
{
KLLog("[KLAL] GetOpenALAudioData(E):%d\n",(int)err);
sfree(data);
goto Exit;
}
// 出力値を設定する
*dataSize = (ALsizei)bufferSize;
*dataFormat = (outputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
*sampleRate = (ALsizei)outputFormat.mSampleRate;
Exit:
// オーディオファイルを破棄する
if (audioFile)
{
ExtAudioFileDispose(audioFile);
}
return data;
}
void* MyGetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei* outSampleRate)
{
OSStatus err = noErr;
SInt64 theFileLengthInFrames = 0;
AudioStreamBasicDescription theFileFormat;
UInt32 thePropertySize = sizeof(theFileFormat);
ExtAudioFileRef extRef = NULL;
void* theData = NULL;
AudioStreamBasicDescription theOutputFormat;
// Open a file with ExtAudioFileOpen()
err = ExtAudioFileOpenURL(inFileURL, &extRef);
if(err) { printf("MyGetOpenALAudioData: ExtAudioFileOpenURL FAILED, Error = %ld\n", err); goto Exit; }
// Get the audio data format
err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileDataFormat, &thePropertySize, &theFileFormat);
if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) FAILED, Error = %ld\n", err); goto Exit; }
if (theFileFormat.mChannelsPerFrame > 2) { printf("MyGetOpenALAudioData - Unsupported Format, channel count is greater than stereo\n"); goto Exit;}
// Set the client format to 16 bit signed integer (native-endian) data
// Maintain the channel count and sample rate of the original source format
theOutputFormat.mSampleRate = theFileFormat.mSampleRate;
theOutputFormat.mChannelsPerFrame = theFileFormat.mChannelsPerFrame;
theOutputFormat.mFormatID = kAudioFormatLinearPCM;
theOutputFormat.mBytesPerPacket = 2 * theOutputFormat.mChannelsPerFrame;
theOutputFormat.mFramesPerPacket = 1;
theOutputFormat.mBytesPerFrame = 2 * theOutputFormat.mChannelsPerFrame;
theOutputFormat.mBitsPerChannel = 16;
theOutputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
// Set the desired client (output) data format
err = ExtAudioFileSetProperty(extRef, kExtAudioFileProperty_ClientDataFormat, sizeof(theOutputFormat), &theOutputFormat);
if(err) { printf("MyGetOpenALAudioData: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) FAILED, Error = %ld\n", err); goto Exit; }
// Get the total frame count
thePropertySize = sizeof(theFileLengthInFrames);
err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileLengthFrames, &thePropertySize, &theFileLengthInFrames);
if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileLengthFrames) FAILED, Error = %ld\n", err); goto Exit; }
// Read all the data into memory
UInt32 dataSize = theFileLengthInFrames * theOutputFormat.mBytesPerFrame;;
theData = malloc(dataSize);
if (theData)
{
AudioBufferList theDataBuffer;
theDataBuffer.mNumberBuffers = 1;
theDataBuffer.mBuffers[0].mDataByteSize = dataSize;
theDataBuffer.mBuffers[0].mNumberChannels = theOutputFormat.mChannelsPerFrame;
theDataBuffer.mBuffers[0].mData = theData;
// Read the data into an AudioBufferList
err = ExtAudioFileRead(extRef, (UInt32*)&theFileLengthInFrames, &theDataBuffer);
if(err == noErr)
{
// success
*outDataSize = (ALsizei)dataSize;
*outDataFormat = (theOutputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
*outSampleRate = (ALsizei)theOutputFormat.mSampleRate;
}
else
{
// failure
free (theData);
theData = NULL; // make sure to return NULL
printf("MyGetOpenALAudioData: ExtAudioFileRead FAILED, Error = %ld\n", err); goto Exit;
}
}
Exit:
// Dispose the ExtAudioFileRef, it is no longer needed
if (extRef) ExtAudioFileDispose(extRef);
return theData;
}
OSStatus DoConvertFile(CFURLRef sourceURL, CFURLRef destinationURL, OSType outputFormat, Float64 outputSampleRate)
{
ExtAudioFileRef sourceFile = 0;
ExtAudioFileRef destinationFile = 0;
Boolean canResumeFromInterruption = true; // we can continue unless told otherwise
OSStatus error = noErr;
// in this sample we should never be on the main thread here
assert(![NSThread isMainThread]);
// transition thread state to kStateRunning before continuing
ThreadStateSetRunning();
printf("DoConvertFile\n");
try {
CAStreamBasicDescription srcFormat, dstFormat;
// open the source file
XThrowIfError(ExtAudioFileOpenURL(sourceURL, &sourceFile), "ExtAudioFileOpenURL failed");
// get the source data format
UInt32 size = sizeof(srcFormat);
XThrowIfError(ExtAudioFileGetProperty(sourceFile, kExtAudioFileProperty_FileDataFormat, &size, &srcFormat), "couldn't get source data format");
printf("\nSource file format: "); srcFormat.Print();
// setup the output file format
dstFormat.mSampleRate = (outputSampleRate == 0 ? srcFormat.mSampleRate : outputSampleRate); // set sample rate
if (outputFormat == kAudioFormatLinearPCM) {
// if PCM was selected as the destination format, create a 16-bit int PCM file format description
dstFormat.mFormatID = outputFormat;
dstFormat.mChannelsPerFrame = srcFormat.NumberChannels();
dstFormat.mBitsPerChannel = 16;
dstFormat.mBytesPerPacket = dstFormat.mBytesPerFrame = 2 * dstFormat.mChannelsPerFrame;
dstFormat.mFramesPerPacket = 1;
dstFormat.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger; // little-endian
} else {
// compressed format - need to set at least format, sample rate and channel fields for kAudioFormatProperty_FormatInfo
dstFormat.mFormatID = outputFormat;
dstFormat.mChannelsPerFrame = (outputFormat == kAudioFormatiLBC ? 1 : srcFormat.NumberChannels()); // for iLBC num channels must be 1
// use AudioFormat API to fill out the rest of the description
size = sizeof(dstFormat);
XThrowIfError(AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, 0, NULL, &size, &dstFormat), "couldn't create destination data format");
}
printf("\nDestination file format: "); dstFormat.Print();
// create the destination file
XThrowIfError(ExtAudioFileCreateWithURL(destinationURL, kAudioFileCAFType, &dstFormat, NULL, kAudioFileFlags_EraseFile, &destinationFile), "ExtAudioFileCreateWithURL failed!");
// set the client format - The format must be linear PCM (kAudioFormatLinearPCM)
// You must set this in order to encode or decode a non-PCM file data format
// You may set this on PCM files to specify the data format used in your calls to read/write
CAStreamBasicDescription clientFormat;
if (outputFormat == kAudioFormatLinearPCM) {
clientFormat = dstFormat;
} else {
clientFormat.SetCanonical(srcFormat.NumberChannels(), true);
clientFormat.mSampleRate = srcFormat.mSampleRate;
}
printf("\nClient data format: "); clientFormat.Print();
printf("\n");
size = sizeof(clientFormat);
XThrowIfError(ExtAudioFileSetProperty(sourceFile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat), "couldn't set source client format");
size = sizeof(clientFormat);
XThrowIfError(ExtAudioFileSetProperty(destinationFile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat), "couldn't set destination client format");
// can the audio converter (which in this case is owned by an ExtAudioFile object) resume conversion after an interruption?
AudioConverterRef audioConverter;
size = sizeof(audioConverter);
XThrowIfError(ExtAudioFileGetProperty(destinationFile, kExtAudioFileProperty_AudioConverter, &size, &audioConverter), "Couldn't get Audio Converter!");
// this property may be queried at any time after construction of the audio converter (which in this case is owned by an ExtAudioFile object)
// after setting the output format -- there's no clear reason to prefer construction time, interruption time, or potential resumption time but we prefer
// construction time since it means less code to execute during or after interruption time
UInt32 canResume = 0;
size = sizeof(canResume);
error = AudioConverterGetProperty(audioConverter, kAudioConverterPropertyCanResumeFromInterruption, &size, &canResume);
if (noErr == error) {
// we recieved a valid return value from the GetProperty call
// if the property's value is 1, then the codec CAN resume work following an interruption
// if the property's value is 0, then interruptions destroy the codec's state and we're done
if (0 == canResume) canResumeFromInterruption = false;
printf("Audio Converter %s continue after interruption!\n", (canResumeFromInterruption == 0 ? "CANNOT" : "CAN"));
} else {
// if the property is unimplemented (kAudioConverterErr_PropertyNotSupported, or paramErr returned in the case of PCM),
// then the codec being used is not a hardware codec so we're not concerned about codec state
// we are always going to be able to resume conversion after an interruption
if (kAudioConverterErr_PropertyNotSupported == error) {
printf("kAudioConverterPropertyCanResumeFromInterruption property not supported!\n");
} else {
printf("AudioConverterGetProperty kAudioConverterPropertyCanResumeFromInterruption result %ld\n", error);
}
error = noErr;
}
// set up buffers
UInt32 bufferByteSize = 32768;
char srcBuffer[bufferByteSize];
// keep track of the source file offset so we know where to reset the source for
// reading if interrupted and input was not consumed by the audio converter
SInt64 sourceFrameOffset = 0;
//***** do the read and write - the conversion is done on and by the write call *****//
printf("Converting...\n");
while (1) {
AudioBufferList fillBufList;
fillBufList.mNumberBuffers = 1;
fillBufList.mBuffers[0].mNumberChannels = clientFormat.NumberChannels();
fillBufList.mBuffers[0].mDataByteSize = bufferByteSize;
fillBufList.mBuffers[0].mData = srcBuffer;
// client format is always linear PCM - so here we determine how many frames of lpcm
// we can read/write given our buffer size
UInt32 numFrames;
if (clientFormat.mBytesPerFrame > 0) // rids bogus analyzer div by zero warning mBytesPerFrame can't be 0 and is protected by an Assert
numFrames = clientFormat.BytesToFrames(bufferByteSize); // (bufferByteSize / clientFormat.mBytesPerFrame);
XThrowIfError(ExtAudioFileRead(sourceFile, &numFrames, &fillBufList), "ExtAudioFileRead failed!");
if (!numFrames) {
// this is our termination condition
error = noErr;
break;
}
sourceFrameOffset += numFrames;
// this will block if we're interrupted
Boolean wasInterrupted = ThreadStatePausedCheck();
if ((error || wasInterrupted) && (false == canResumeFromInterruption)) {
// this is our interruption termination condition
// an interruption has occured but the audio converter cannot continue
error = kMyAudioConverterErr_CannotResumeFromInterruptionError;
break;
}
error = ExtAudioFileWrite(destinationFile, numFrames, &fillBufList);
// if interrupted in the process of the write call, we must handle the errors appropriately
if (error) {
if (kExtAudioFileError_CodecUnavailableInputConsumed == error) {
printf("ExtAudioFileWrite kExtAudioFileError_CodecUnavailableInputConsumed error %ld\n", error);
/*
Returned when ExtAudioFileWrite was interrupted. You must stop calling
ExtAudioFileWrite. If the underlying audio converter can resume after an
interruption (see kAudioConverterPropertyCanResumeFromInterruption), you must
wait for an EndInterruption notification from AudioSession, then activate the session
before resuming. In this situation, the buffer you provided to ExtAudioFileWrite was successfully
consumed and you may proceed to the next buffer
*/
} else if (kExtAudioFileError_CodecUnavailableInputNotConsumed == error) {
printf("ExtAudioFileWrite kExtAudioFileError_CodecUnavailableInputNotConsumed error %ld\n", error);
/*
Returned when ExtAudioFileWrite was interrupted. You must stop calling
ExtAudioFileWrite. If the underlying audio converter can resume after an
interruption (see kAudioConverterPropertyCanResumeFromInterruption), you must
wait for an EndInterruption notification from AudioSession, then activate the session
before resuming. In this situation, the buffer you provided to ExtAudioFileWrite was not
successfully consumed and you must try to write it again
*/
// seek back to last offset before last read so we can try again after the interruption
sourceFrameOffset -= numFrames;
XThrowIfError(ExtAudioFileSeek(sourceFile, sourceFrameOffset), "ExtAudioFileSeek failed!");
} else {
XThrowIfError(error, "ExtAudioFileWrite error!");
}
} // if
} // while
}
catch (CAXException e) {
char buf[256];
fprintf(stderr, "Error: %s (%s)\n", e.mOperation, e.FormatError(buf));
error = e.mError;
}
// close
if (destinationFile) ExtAudioFileDispose(destinationFile);
if (sourceFile) ExtAudioFileDispose(sourceFile);
// transition thread state to kStateDone before continuing
ThreadStateSetDone();
return error;
}
// soundsource overrides
Result SoundSourceCoreAudio::open() {
//Open the audio file.
OSStatus err;
/** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */
CFStringRef urlStr = CFStringCreateWithCharacters(
0, reinterpret_cast<const UniChar *>(getFilename().unicode()), getFilename().size());
CFURLRef urlRef = CFURLCreateWithFileSystemPath(NULL, urlStr, kCFURLPOSIXPathStyle, false);
err = ExtAudioFileOpenURL(urlRef, &m_audioFile);
CFRelease(urlStr);
CFRelease(urlRef);
/** TODO: Use FSRef for compatibility with 10.4 Tiger.
Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain
both code paths if someone finishes this part of the code.
FSRef fsRef;
CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
err = ExtAudioFileOpen(&fsRef, &m_audioFile);
*/
if (err != noErr) {
qDebug() << "SSCA: Error opening file " << getFilename();
return ERR;
}
// get the input file format
CAStreamBasicDescription inputFormat;
UInt32 size = sizeof(inputFormat);
m_inputFormat = inputFormat;
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileDataFormat, &size, &inputFormat);
if (err != noErr) {
qDebug() << "SSCA: Error getting file format (" << getFilename() << ")";
return ERR;
}
//Debugging:
//printf ("Source File format: "); inputFormat.Print();
//printf ("Dest File format: "); outputFormat.Print();
// create the output format
m_outputFormat = CAStreamBasicDescription(
inputFormat.mSampleRate, 2,
CAStreamBasicDescription::kPCMFormatInt16, true);
// set the client format
err = ExtAudioFileSetProperty(m_audioFile, kExtAudioFileProperty_ClientDataFormat,
sizeof(m_outputFormat), &m_outputFormat);
if (err != noErr) {
qDebug() << "SSCA: Error setting file property";
return ERR;
}
setChannels(m_outputFormat.NumberChannels());
//get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47
UInt32 dataSize;
SInt64 totalFrameCount;
dataSize = sizeof(totalFrameCount); //XXX: This looks sketchy to me - Albert
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileLengthFrames, &dataSize, &totalFrameCount);
if (err != noErr) {
qDebug() << "SSCA: Error getting number of frames";
return ERR;
}
//
// WORKAROUND for bug in ExtFileAudio
//
AudioConverterRef acRef;
UInt32 acrsize=sizeof(AudioConverterRef);
err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_AudioConverter, &acrsize, &acRef);
//_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err);
AudioConverterPrimeInfo primeInfo;
UInt32 piSize=sizeof(AudioConverterPrimeInfo);
memset(&primeInfo, 0, piSize);
err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize, &primeInfo);
if (err != kAudioConverterErr_PropertyNotSupported) { // Only if decompressing
//_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err);
m_headerFrames=primeInfo.leadingFrames;
}
m_samples = (totalFrameCount/* - m_headerFrames*/) * getChannels();
setDuration(m_samples / (inputFormat.mSampleRate * getChannels()));
setSampleRate(inputFormat.mSampleRate);
qDebug() << m_samples << totalFrameCount << getChannels();
//Seek to position 0, which forces us to skip over all the header frames.
//This makes sure we're ready to just let the Analyser rip and it'll
//get the number of samples it expects (ie. no header frames).
seek(0);
return OK;
}
int ConvertFile (CFURLRef inputFileURL,
CAStreamBasicDescription &inputFormat,
CFURLRef outputFileURL,
AudioFileTypeID outputFileType,
CAStreamBasicDescription &outputFormat,
UInt32 outputBitRate)
{
ExtAudioFileRef infile, outfile;
// first open the input file
OSStatus err = ExtAudioFileOpenURL (inputFileURL, &infile);
XThrowIfError (err, "ExtAudioFileOpen");
// if outputBitRate is specified, this can change the sample rate of the output file
// so we let this "take care of itself"
if (outputBitRate)
outputFormat.mSampleRate = 0.;
// create the output file (this will erase an exsiting file)
err = ExtAudioFileCreateWithURL (outputFileURL, outputFileType, &outputFormat, NULL, kAudioFileFlags_EraseFile, &outfile);
XThrowIfError (err, "ExtAudioFileCreateNew");
// get and set the client format - it should be lpcm
CAStreamBasicDescription clientFormat = (inputFormat.mFormatID == kAudioFormatLinearPCM ? inputFormat : outputFormat);
UInt32 size = sizeof(clientFormat);
err = ExtAudioFileSetProperty(infile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat);
XThrowIfError (err, "ExtAudioFileSetProperty inFile, kExtAudioFileProperty_ClientDataFormat");
size = sizeof(clientFormat);
err = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat);
XThrowIfError (err, "ExtAudioFileSetProperty outFile, kExtAudioFileProperty_ClientDataFormat");
if( outputBitRate > 0 ) {
printf ("Dest bit rate: %d\n", (int)outputBitRate);
AudioConverterRef outConverter;
size = sizeof(outConverter);
err = ExtAudioFileGetProperty(outfile, kExtAudioFileProperty_AudioConverter, &size, &outConverter);
XThrowIfError (err, "ExtAudioFileGetProperty outFile, kExtAudioFileProperty_AudioConverter");
err = AudioConverterSetProperty(outConverter, kAudioConverterEncodeBitRate,
sizeof(outputBitRate), &outputBitRate);
XThrowIfError (err, "AudioConverterSetProperty, kAudioConverterEncodeBitRate");
// we have changed the converter, so we should do this in case
// setting a converter property changes the converter used by ExtAF in some manner
CFArrayRef config = NULL;
err = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ConverterConfig, sizeof(config), &config);
XThrowIfError (err, "ExtAudioFileSetProperty outFile, kExtAudioFileProperty_ConverterConfig");
}
// set up buffers
char srcBuffer[kSrcBufSize];
// do the read and write - the conversion is done on and by the write call
while (1)
{
AudioBufferList fillBufList;
fillBufList.mNumberBuffers = 1;
fillBufList.mBuffers[0].mNumberChannels = inputFormat.mChannelsPerFrame;
fillBufList.mBuffers[0].mDataByteSize = kSrcBufSize;
fillBufList.mBuffers[0].mData = srcBuffer;
// client format is always linear PCM - so here we determine how many frames of lpcm
// we can read/write given our buffer size
UInt32 numFrames = (kSrcBufSize / clientFormat.mBytesPerFrame);
// printf("test %d\n", numFrames);
err = ExtAudioFileRead (infile, &numFrames, &fillBufList);
XThrowIfError (err, "ExtAudioFileRead");
if (!numFrames) {
// this is our termination condition
break;
}
err = ExtAudioFileWrite(outfile, numFrames, &fillBufList);
XThrowIfError (err, "ExtAudioFileWrite");
}
// close
ExtAudioFileDispose(outfile);
ExtAudioFileDispose(infile);
return 0;
}
void *GetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei *outSampleRate)
{
OSStatus err = noErr;
ExtAudioFileRef extRef = NULL;
err = ExtAudioFileOpenURL(inFileURL, &extRef);
if (err != noErr)
{
printf("GetOpenALAudioData: ExtAudioFileOpenURL FAILED, Error = %ld\n", err);
return NULL;
}
AudioStreamBasicDescription theFileFormat;
UInt32 thePropertySize = sizeof(theFileFormat);
err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileDataFormat, &thePropertySize, &theFileFormat);
if (err != noErr)
{
printf("GetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) FAILED, Error = %ld\n", err);
ExtAudioFileDispose(extRef);
return NULL;
}
if (theFileFormat.mChannelsPerFrame > 2)
{
printf("GetOpenALAudioData: Unsupported format, channel count is greater than stereo\n");
ExtAudioFileDispose(extRef);
return NULL;
}
// Set the output format to 16 bit signed integer (native-endian) data
// Maintain the channel count and sample rate of the original source format
AudioStreamBasicDescription theOutputFormat;
theOutputFormat.mSampleRate = theFileFormat.mSampleRate;
theOutputFormat.mChannelsPerFrame = theFileFormat.mChannelsPerFrame;
theOutputFormat.mFormatID = kAudioFormatLinearPCM;
theOutputFormat.mBytesPerPacket = 2 * theOutputFormat.mChannelsPerFrame;
theOutputFormat.mFramesPerPacket = 1;
theOutputFormat.mBytesPerFrame = 2 * theOutputFormat.mChannelsPerFrame;
theOutputFormat.mBitsPerChannel = 16;
theOutputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
err = ExtAudioFileSetProperty(extRef, kExtAudioFileProperty_ClientDataFormat, sizeof(theOutputFormat), &theOutputFormat);
if (err != noErr)
{
printf("GetOpenALAudioData: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) FAILED, Error = %ld\n", err);
ExtAudioFileDispose(extRef);
return NULL;
}
SInt64 theFileLengthInFrames = 0;
thePropertySize = sizeof(theFileLengthInFrames);
err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileLengthFrames, &thePropertySize, &theFileLengthInFrames);
if (err != noErr)
{
printf("GetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileLengthFrames) FAILED, Error = %ld\n", err);
ExtAudioFileDispose(extRef);
return NULL;
}
UInt32 dataSize = theFileLengthInFrames * theOutputFormat.mBytesPerFrame;
void *theData = malloc(dataSize);
if (theData == NULL)
{
printf("GetOpenALAudioData: malloc FAILED\n");
ExtAudioFileDispose(extRef);
return NULL;
}
AudioBufferList theDataBuffer;
theDataBuffer.mNumberBuffers = 1;
theDataBuffer.mBuffers[0].mDataByteSize = dataSize;
theDataBuffer.mBuffers[0].mNumberChannels = theOutputFormat.mChannelsPerFrame;
theDataBuffer.mBuffers[0].mData = theData;
err = ExtAudioFileRead(extRef, (UInt32 *)&theFileLengthInFrames, &theDataBuffer);
if (err != noErr)
{
printf("GetOpenALAudioData: ExtAudioFileRead FAILED, Error = %ld\n", err);
free(theData);
ExtAudioFileDispose(extRef);
return NULL;
}
*outDataSize = (ALsizei)dataSize;
*outDataFormat = (theOutputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
*outSampleRate = (ALsizei)theOutputFormat.mSampleRate;
ExtAudioFileDispose(extRef);
return theData;
}
aubio_source_apple_audio_t * new_aubio_source_apple_audio(char_t * path, uint_t samplerate, uint_t block_size)
{
aubio_source_apple_audio_t * s = AUBIO_NEW(aubio_source_apple_audio_t);
s->path = path;
s->block_size = block_size;
OSStatus err = noErr;
UInt32 propSize;
// open the resource url
CFURLRef fileURL = getURLFromPath(path);
err = ExtAudioFileOpenURL(fileURL, &s->audioFile);
if (err) { AUBIO_ERR("error when trying to access %s, in ExtAudioFileOpenURL, %d\n", s->path, (int)err); goto beach;}
// create an empty AudioStreamBasicDescription
AudioStreamBasicDescription fileFormat;
propSize = sizeof(fileFormat);
memset(&fileFormat, 0, sizeof(AudioStreamBasicDescription));
// fill it with the file description
err = ExtAudioFileGetProperty(s->audioFile,
kExtAudioFileProperty_FileDataFormat, &propSize, &fileFormat);
if (err) { AUBIO_ERROR("error in ExtAudioFileGetProperty, %d\n", (int)err); goto beach;}
if (samplerate == 0) {
samplerate = fileFormat.mSampleRate;
//AUBIO_DBG("sampling rate set to 0, automagically adjusting to %d\n", samplerate);
}
s->samplerate = samplerate;
s->source_samplerate = fileFormat.mSampleRate;
s->channels = fileFormat.mChannelsPerFrame;
AudioStreamBasicDescription clientFormat;
propSize = sizeof(clientFormat);
memset(&clientFormat, 0, sizeof(AudioStreamBasicDescription));
clientFormat.mFormatID = kAudioFormatLinearPCM;
clientFormat.mSampleRate = (Float64)(s->samplerate);
clientFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
clientFormat.mChannelsPerFrame = s->channels;
clientFormat.mBitsPerChannel = sizeof(short) * 8;
clientFormat.mFramesPerPacket = 1;
clientFormat.mBytesPerFrame = clientFormat.mBitsPerChannel * clientFormat.mChannelsPerFrame / 8;
clientFormat.mBytesPerPacket = clientFormat.mFramesPerPacket * clientFormat.mBytesPerFrame;
clientFormat.mReserved = 0;
// set the client format description
err = ExtAudioFileSetProperty(s->audioFile, kExtAudioFileProperty_ClientDataFormat,
propSize, &clientFormat);
if (err) {
AUBIO_ERROR("error in ExtAudioFileSetProperty, %d\n", (int)err);
#if 1
// print client and format descriptions
AUBIO_DBG("Opened %s\n", s->path);
AUBIO_DBG("file/client Format.mFormatID: : %3c%c%c%c / %c%c%c%c\n",
(int)RT_BYTE4(fileFormat.mFormatID), (int)RT_BYTE3(fileFormat.mFormatID), (int)RT_BYTE2(fileFormat.mFormatID), (int)RT_BYTE1(fileFormat.mFormatID),
(int)RT_BYTE4(clientFormat.mFormatID), (int)RT_BYTE3(clientFormat.mFormatID), (int)RT_BYTE2(clientFormat.mFormatID), (int)RT_BYTE1(clientFormat.mFormatID)
);
AUBIO_DBG("file/client Format.mSampleRate : %6.0f / %.0f\n", fileFormat.mSampleRate , clientFormat.mSampleRate);
AUBIO_DBG("file/client Format.mFormatFlags : %6d / %d\n", (int)fileFormat.mFormatFlags , (int)clientFormat.mFormatFlags);
AUBIO_DBG("file/client Format.mChannelsPerFrame : %6d / %d\n", (int)fileFormat.mChannelsPerFrame, (int)clientFormat.mChannelsPerFrame);
AUBIO_DBG("file/client Format.mBitsPerChannel : %6d / %d\n", (int)fileFormat.mBitsPerChannel , (int)clientFormat.mBitsPerChannel);
AUBIO_DBG("file/client Format.mFramesPerPacket : %6d / %d\n", (int)fileFormat.mFramesPerPacket , (int)clientFormat.mFramesPerPacket);
AUBIO_DBG("file/client Format.mBytesPerFrame : %6d / %d\n", (int)fileFormat.mBytesPerFrame , (int)clientFormat.mBytesPerFrame);
AUBIO_DBG("file/client Format.mBytesPerPacket : %6d / %d\n", (int)fileFormat.mBytesPerPacket , (int)clientFormat.mBytesPerPacket);
AUBIO_DBG("file/client Format.mReserved : %6d / %d\n", (int)fileFormat.mReserved , (int)clientFormat.mReserved);
#endif
goto beach;
}
// compute the size of the segments needed to read the input file
UInt32 samples = s->block_size * clientFormat.mChannelsPerFrame;
Float64 rateRatio = clientFormat.mSampleRate / fileFormat.mSampleRate;
uint_t segmentSize= (uint_t)(samples * rateRatio + .5);
if (rateRatio < 1.) {
segmentSize = (uint_t)(samples / rateRatio + .5);
} else if (rateRatio > 1.) {
AUBIO_WRN("up-sampling %s from %0.2fHz to %0.2fHz\n", s->path, fileFormat.mSampleRate, clientFormat.mSampleRate);
} else {
assert ( segmentSize == samples );
//AUBIO_DBG("not resampling, segmentSize %d, block_size %d\n", segmentSize, s->block_size);
}
// allocate the AudioBufferList
if (createAubioBufferList(&s->bufferList, s->channels, segmentSize)) err = -1;
return s;
beach:
AUBIO_FREE(s);
return NULL;
}
OSStatus loadLoopIntoBuffer(MyLoopPlayer* player) {
CFURLRef loopFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
LOOP_PATH,
kCFURLPOSIXPathStyle,
false);
// describe the client format - AL needs mono
memset(&player->dataFormat, 0, sizeof(player->dataFormat));
player->dataFormat.mFormatID = kAudioFormatLinearPCM;
player->dataFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
player->dataFormat.mSampleRate = 44100.0;
player->dataFormat.mChannelsPerFrame = 1;
player->dataFormat.mFramesPerPacket = 1;
player->dataFormat.mBitsPerChannel = 16;
player->dataFormat.mBytesPerFrame = 2;
player->dataFormat.mBytesPerPacket = 2;
ExtAudioFileRef extAudioFile;
CheckError (ExtAudioFileOpenURL(loopFileURL, &extAudioFile),
"Couldn't open ExtAudioFile for reading");
// tell extAudioFile about our format
CheckError(ExtAudioFileSetProperty(extAudioFile,
kExtAudioFileProperty_ClientDataFormat,
sizeof (AudioStreamBasicDescription),
&player->dataFormat),
"Couldn't set client format on ExtAudioFile");
// figure out how big a buffer we need
SInt64 fileLengthFrames;
UInt32 propSize = sizeof (fileLengthFrames);
ExtAudioFileGetProperty(extAudioFile,
kExtAudioFileProperty_FileLengthFrames,
&propSize,
&fileLengthFrames);
printf ("plan on reading %lld frames\n", fileLengthFrames);
player->bufferSizeBytes = fileLengthFrames * player->dataFormat.mBytesPerFrame;
AudioBufferList *buffers;
UInt32 ablSize = offsetof(AudioBufferList, mBuffers[0]) + (sizeof(AudioBuffer) * 1); // 1 channel
buffers = malloc (ablSize);
// allocate sample buffer
player->sampleBuffer = malloc(sizeof(UInt16) * player->bufferSizeBytes); // 4/18/11 - fix 1
buffers->mNumberBuffers = 1;
buffers->mBuffers[0].mNumberChannels = 1;
buffers->mBuffers[0].mDataByteSize = player->bufferSizeBytes;
buffers->mBuffers[0].mData = player->sampleBuffer;
printf ("created AudioBufferList\n");
// loop reading into the ABL until buffer is full
UInt32 totalFramesRead = 0;
do {
UInt32 framesRead = fileLengthFrames - totalFramesRead;
buffers->mBuffers[0].mData = player->sampleBuffer + (totalFramesRead * (sizeof(UInt16)));
CheckError(ExtAudioFileRead(extAudioFile,
&framesRead,
buffers),
"ExtAudioFileRead failed");
totalFramesRead += framesRead;
printf ("read %d frames\n", framesRead);
} while (totalFramesRead < fileLengthFrames);
// can free the ABL; still have samples in sampleBuffer
free(buffers);
return noErr;
}
PassOwnPtr<AudioBus> AudioFileReader::createBus(float sampleRate, bool mixToMono)
{
if (!m_extAudioFileRef)
return nullptr;
// Get file's data format
UInt32 size = sizeof(m_fileDataFormat);
OSStatus result = ExtAudioFileGetProperty(m_extAudioFileRef, kExtAudioFileProperty_FileDataFormat, &size, &m_fileDataFormat);
if (result != noErr)
return nullptr;
// Number of channels
size_t numberOfChannels = m_fileDataFormat.mChannelsPerFrame;
// Number of frames
SInt64 numberOfFrames64 = 0;
size = sizeof(numberOfFrames64);
result = ExtAudioFileGetProperty(m_extAudioFileRef, kExtAudioFileProperty_FileLengthFrames, &size, &numberOfFrames64);
if (result != noErr)
return nullptr;
// Sample-rate
double fileSampleRate = m_fileDataFormat.mSampleRate;
// Make client format same number of channels as file format, but tweak a few things.
// Client format will be linear PCM (canonical), and potentially change sample-rate.
m_clientDataFormat = m_fileDataFormat;
m_clientDataFormat.mFormatID = kAudioFormatLinearPCM;
m_clientDataFormat.mFormatFlags = kAudioFormatFlagsCanonical;
m_clientDataFormat.mBitsPerChannel = 8 * sizeof(AudioSampleType);
m_clientDataFormat.mChannelsPerFrame = numberOfChannels;
m_clientDataFormat.mFramesPerPacket = 1;
m_clientDataFormat.mBytesPerPacket = sizeof(AudioSampleType);
m_clientDataFormat.mBytesPerFrame = sizeof(AudioSampleType);
m_clientDataFormat.mFormatFlags |= kAudioFormatFlagIsNonInterleaved;
if (sampleRate)
m_clientDataFormat.mSampleRate = sampleRate;
result = ExtAudioFileSetProperty(m_extAudioFileRef, kExtAudioFileProperty_ClientDataFormat, sizeof(AudioStreamBasicDescription), &m_clientDataFormat);
if (result != noErr)
return nullptr;
// Change numberOfFrames64 to destination sample-rate
numberOfFrames64 = numberOfFrames64 * (m_clientDataFormat.mSampleRate / fileSampleRate);
size_t numberOfFrames = static_cast<size_t>(numberOfFrames64);
size_t busChannelCount = mixToMono ? 1 : numberOfChannels;
// Create AudioBus where we'll put the PCM audio data
OwnPtr<AudioBus> audioBus = adoptPtr(new AudioBus(busChannelCount, numberOfFrames));
audioBus->setSampleRate(narrowPrecisionToFloat(m_clientDataFormat.mSampleRate)); // save for later
// Only allocated in the mixToMono case
AudioFloatArray bufL;
AudioFloatArray bufR;
float* bufferL = 0;
float* bufferR = 0;
// Setup AudioBufferList in preparation for reading
AudioBufferList* bufferList = createAudioBufferList(numberOfChannels);
if (mixToMono && numberOfChannels == 2) {
bufL.allocate(numberOfFrames);
bufR.allocate(numberOfFrames);
bufferL = bufL.data();
bufferR = bufR.data();
bufferList->mBuffers[0].mNumberChannels = 1;
bufferList->mBuffers[0].mDataByteSize = numberOfFrames * sizeof(float);
bufferList->mBuffers[0].mData = bufferL;
bufferList->mBuffers[1].mNumberChannels = 1;
bufferList->mBuffers[1].mDataByteSize = numberOfFrames * sizeof(float);
bufferList->mBuffers[1].mData = bufferR;
} else {
ASSERT(!mixToMono || numberOfChannels == 1);
// for True-stereo (numberOfChannels == 4)
for (size_t i = 0; i < numberOfChannels; ++i) {
bufferList->mBuffers[i].mNumberChannels = 1;
bufferList->mBuffers[i].mDataByteSize = numberOfFrames * sizeof(float);
bufferList->mBuffers[i].mData = audioBus->channel(i)->mutableData();
}
}
// Read from the file (or in-memory version)
UInt32 framesToRead = numberOfFrames;
result = ExtAudioFileRead(m_extAudioFileRef, &framesToRead, bufferList);
if (result != noErr) {
destroyAudioBufferList(bufferList);
return nullptr;
}
if (mixToMono && numberOfChannels == 2) {
// Mix stereo down to mono
float* destL = audioBus->channel(0)->mutableData();
for (size_t i = 0; i < numberOfFrames; i++)
destL[i] = 0.5f * (bufferL[i] + bufferR[i]);
}
// Cleanup
destroyAudioBufferList(bufferList);
return audioBus.release();
}
/**
* @note This function returns by reference an open file reference (ExtAudioFileRef). You are responsbile for releasing this
* this reference yourself when you are finished with it by calling ExtAudioFileDispose().
*/
ExtAudioFileRef MyGetExtAudioFileRef(CFURLRef file_url, AudioStreamBasicDescription* audio_description)
{
OSStatus error_status = noErr;
AudioStreamBasicDescription file_format;
UInt32 property_size = sizeof(file_format);
ExtAudioFileRef ext_file_ref = NULL;
AudioStreamBasicDescription output_format;
/* Open a file with ExtAudioFileOpen() */
error_status = ExtAudioFileOpenURL(file_url, &ext_file_ref);
if(noErr != error_status)
{
printf("MyGetExtAudioFileRef: ExtAudioFileOpenURL failed, Error = %ld\n", error_status);
if(NULL != ext_file_ref)
{
ExtAudioFileDispose(ext_file_ref);
}
return NULL;
}
/* Get the audio data format */
error_status = ExtAudioFileGetProperty(ext_file_ref, kExtAudioFileProperty_FileDataFormat, &property_size, &file_format);
if(noErr != error_status)
{
printf("MyGetExtAudioFileRef: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) failed, Error = %ld\n", error_status);
ExtAudioFileDispose(ext_file_ref);
return NULL;
}
/* Don't know how to handle sounds with more than 2 channels (i.e. stereo)
* Remember that OpenAL sound effects must be mono to be spatialized anyway.
*/
if(file_format.mChannelsPerFrame > 2)
{
printf("MyGetExtAudioFileRef: Unsupported Format, channel count (=%d) is greater than stereo\n", file_format.mChannelsPerFrame);
ExtAudioFileDispose(ext_file_ref);
return NULL;
}
/* 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 = file_format.mSampleRate; // preserve the original sample rate
output_format.mChannelsPerFrame = file_format.mChannelsPerFrame; // preserve the number of channels
output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | 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
/* Set the desired client (output) data format */
error_status = ExtAudioFileSetProperty(ext_file_ref, kExtAudioFileProperty_ClientDataFormat, sizeof(output_format), &output_format);
if(noErr != error_status)
{
printf("MyGetExtAudioFileRef: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) failed, Error = %ld\n", error_status);
ExtAudioFileDispose(ext_file_ref);
return NULL;
}
/* Copy the output format to the audio_description that was passed in so the
* info will be returned to the user.
*/
memcpy(audio_description, &output_format, sizeof(output_format));
return ext_file_ref;
}
static bool Audio_openAndStart(Audio *audio, const char *alias, char *file)
{
UInt32 size;
OSStatus err1;
OSErr err2;
ComponentResult err3;
char *buff;
FSRef path;
AudioStreamBasicDescription format;
ComponentDescription findComp;
Component comp;
AURenderCallbackStruct input;
buff = MMDAgent_pathdup(file);
/* convert file name */
err1 = FSPathMakeRef ((const UInt8 *) buff, &path, NULL);
free(buff);
if(err1) {
return false;
}
/* open audio file */
err1 = ExtAudioFileOpen(&path, &audio->file);
if(err1) {
return false;
}
/* get audio file format */
size = sizeof(AudioStreamBasicDescription);
err1 = ExtAudioFileGetProperty(audio->file, kExtAudioFileProperty_FileDataFormat, &size, &format);
if(err1) {
ExtAudioFileDispose(audio->file);
return false;
}
/* convert audio format to pcm (32bit stereo with the same sampling rate) */
format.mSampleRate = format.mSampleRate;
format.mFormatID = kAudioFormatLinearPCM;
format.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
format.mBytesPerPacket = 4 * 2;
format.mFramesPerPacket = 1;
format.mBytesPerFrame = 4 * 2;
format.mChannelsPerFrame = 2;
format.mBitsPerChannel = 32;
format.mReserved = format.mReserved;
size = sizeof(AudioStreamBasicDescription);
err1 = ExtAudioFileSetProperty(audio->file, kExtAudioFileProperty_ClientDataFormat, size, &format);
if(err1) {
ExtAudioFileDispose(audio->file);
return false;
}
/* open audio device */
findComp.componentType = kAudioUnitType_Output;
findComp.componentSubType = kAudioUnitSubType_DefaultOutput;
findComp.componentManufacturer = kAudioUnitManufacturer_Apple;
findComp.componentFlags = 0;
findComp.componentFlagsMask = 0;
comp = FindNextComponent(NULL, &findComp);
if(comp == 0) {
ExtAudioFileDispose(audio->file);
return false;
}
err2 = OpenAComponent(comp, &audio->device);
if(err2) {
ExtAudioFileDispose(audio->file);
return false;
}
/* set callback func. */
input.inputProc = renderCallback;
input.inputProcRefCon = audio;
size = sizeof(AURenderCallbackStruct);
err3 = AudioUnitSetProperty(audio->device, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &input, size);
if(err3) {
CloseComponent(audio->device);
ExtAudioFileDispose(audio->file);
return false;
}
/* prepare audio device */
err3 = AudioUnitInitialize(audio->device);
if(err3) {
CloseComponent(audio->device);
ExtAudioFileDispose(audio->file);
return false;
}
/* start */
err3 = AudioOutputUnitStart(audio->device);
if(err3) {
AudioUnitUninitialize(audio->device);
CloseComponent(audio->device);
ExtAudioFileDispose(audio->file);
return false;
}
return true;
}
// soundsource overrides
Result SoundSourceCoreAudio::tryOpen(const AudioSourceConfig& audioSrcCfg) {
const QString fileName(getLocalFileName());
//Open the audio file.
OSStatus err;
/** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */
CFStringRef urlStr = CFStringCreateWithCharacters(0,
reinterpret_cast<const UniChar *>(fileName.unicode()),
fileName.size());
CFURLRef urlRef = CFURLCreateWithFileSystemPath(NULL, urlStr,
kCFURLPOSIXPathStyle, false);
err = ExtAudioFileOpenURL(urlRef, &m_audioFile);
CFRelease(urlStr);
CFRelease(urlRef);
/** TODO: Use FSRef for compatibility with 10.4 Tiger.
Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain
both code paths if someone finishes this part of the code.
FSRef fsRef;
CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
err = ExtAudioFileOpen(&fsRef, &m_audioFile);
*/
if (err != noErr) {
qDebug() << "SSCA: Error opening file " << fileName;
return ERR;
}
// get the input file format
UInt32 inputFormatSize = sizeof(m_inputFormat);
err = ExtAudioFileGetProperty(m_audioFile,
kExtAudioFileProperty_FileDataFormat, &inputFormatSize,
&m_inputFormat);
if (err != noErr) {
qDebug() << "SSCA: Error getting file format (" << fileName << ")";
return ERR;
}
m_bFileIsMp3 = m_inputFormat.mFormatID == kAudioFormatMPEGLayer3;
// create the output format
const UInt32 numChannels =
(kChannelCountZero < audioSrcCfg.channelCountHint) ? audioSrcCfg.channelCountHint : 2;
m_outputFormat = CAStreamBasicDescription(m_inputFormat.mSampleRate,
numChannels, CAStreamBasicDescription::kPCMFormatFloat32, true);
// set the client format
err = ExtAudioFileSetProperty(m_audioFile,
kExtAudioFileProperty_ClientDataFormat, sizeof(m_outputFormat),
&m_outputFormat);
if (err != noErr) {
qDebug() << "SSCA: Error setting file property";
return ERR;
}
//get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47
SInt64 totalFrameCount;
UInt32 totalFrameCountSize = sizeof(totalFrameCount);
err = ExtAudioFileGetProperty(m_audioFile,
kExtAudioFileProperty_FileLengthFrames, &totalFrameCountSize,
&totalFrameCount);
if (err != noErr) {
qDebug() << "SSCA: Error getting number of frames";
return ERR;
}
//
// WORKAROUND for bug in ExtFileAudio
//
AudioConverterRef acRef;
UInt32 acrsize = sizeof(AudioConverterRef);
err = ExtAudioFileGetProperty(m_audioFile,
kExtAudioFileProperty_AudioConverter, &acrsize, &acRef);
//_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err);
AudioConverterPrimeInfo primeInfo;
UInt32 piSize = sizeof(AudioConverterPrimeInfo);
memset(&primeInfo, 0, piSize);
err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize,
&primeInfo);
if (err != kAudioConverterErr_PropertyNotSupported) { // Only if decompressing
//_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err);
m_headerFrames = primeInfo.leadingFrames;
} else {
m_headerFrames = 0;
}
setChannelCount(m_outputFormat.NumberChannels());
setFrameRate(m_inputFormat.mSampleRate);
// NOTE(uklotzde): This is what I found when migrating
// the code from SoundSource (sample-oriented) to the new
// AudioSource (frame-oriented) API. It is not documented
// when m_headerFrames > 0 and what the consequences are.
setFrameCount(totalFrameCount/* - m_headerFrames*/);
//Seek to position 0, which forces us to skip over all the header frames.
//This makes sure we're ready to just let the Analyser rip and it'll
//get the number of samples it expects (ie. no header frames).
seekSampleFrame(0);
return OK;
}
CoreAudioReadStream::CoreAudioReadStream(string path) :
m_path(path),
m_d(new D)
{
m_channelCount = 0;
m_sampleRate = 0;
if (!QFile(m_path).exists()) {
throw FileNotFound(m_path);
}
QByteArray ba = m_path.toLocal8Bit();
CFURLRef url = CFURLCreateFromFileSystemRepresentation
(kCFAllocatorDefault,
(const UInt8 *)ba.data(),
(CFIndex)ba.length(),
false);
//!!! how do we find out if the file open fails because of DRM protection?
#if (MACOSX_DEPLOYMENT_TARGET <= 1040 && MAC_OS_X_VERSION_MIN_REQUIRED <= 1040)
FSRef fsref;
if (!CFURLGetFSRef(url, &fsref)) { // returns Boolean, not error code
m_error = "CoreAudioReadStream: Error looking up FS ref (file not found?)";
throw FileReadFailed(m_path);
}
m_d->err = ExtAudioFileOpen(&fsref, &m_d->file);
#else
m_d->err = ExtAudioFileOpenURL(url, &m_d->file);
#endif
CFRelease(url);
if (m_d->err) {
m_error = "CoreAudioReadStream: Error opening file: code " + codestr(m_d->err);
throw InvalidFileFormat(path, "failed to open audio file");
}
if (!m_d->file) {
m_error = "CoreAudioReadStream: Failed to open file, but no error reported!";
throw InvalidFileFormat(path, "failed to open audio file");
}
UInt32 propsize = sizeof(AudioStreamBasicDescription);
m_d->err = ExtAudioFileGetProperty
(m_d->file, kExtAudioFileProperty_FileDataFormat, &propsize, &m_d->asbd);
if (m_d->err) {
m_error = "CoreAudioReadStream: Error in getting basic description: code " + codestr(m_d->err);
ExtAudioFileDispose(m_d->file);
throw FileOperationFailed(m_path, "get basic description", codestr(m_d->err));
}
m_channelCount = m_d->asbd.mChannelsPerFrame;
m_sampleRate = m_d->asbd.mSampleRate;
cerr << "CoreAudioReadStream: " << m_channelCount << " channels, " << m_sampleRate << " Hz" << std::endl;
m_d->asbd.mSampleRate = getSampleRate();
m_d->asbd.mFormatID = kAudioFormatLinearPCM;
m_d->asbd.mFormatFlags =
kAudioFormatFlagIsFloat |
kAudioFormatFlagIsPacked |
kAudioFormatFlagsNativeEndian;
m_d->asbd.mBitsPerChannel = sizeof(float) * 8;
m_d->asbd.mBytesPerFrame = sizeof(float) * m_channelCount;
m_d->asbd.mBytesPerPacket = sizeof(float) * m_channelCount;
m_d->asbd.mFramesPerPacket = 1;
m_d->asbd.mReserved = 0;
m_d->err = ExtAudioFileSetProperty
(m_d->file, kExtAudioFileProperty_ClientDataFormat, propsize, &m_d->asbd);
if (m_d->err) {
m_error = "CoreAudioReadStream: Error in setting client format: code " + codestr(m_d->err);
throw FileOperationFailed(m_path, "set client format", codestr(m_d->err));
}
m_d->buffer.mNumberBuffers = 1;
m_d->buffer.mBuffers[0].mNumberChannels = m_channelCount;
m_d->buffer.mBuffers[0].mDataByteSize = 0;
m_d->buffer.mBuffers[0].mData = 0;
}