CoreAudioReadStream::~CoreAudioReadStream()
{
// cerr << "CoreAudioReadStream::~CoreAudioReadStream" << std::endl;
if (m_channelCount) {
ExtAudioFileDispose(m_d->file);
}
m_channelCount = 0;
delete m_d;
}
void ExtAudioFileAudioSource::close()
{
RPRINT("closing...\n");
BufferedAudioSource::close();
if(mAudioFile)
{
ExtAudioFileDispose(mAudioFile);
mAudioFile = 0;
}
if(mpBufferList)
{
free (mpBufferList);
mpBufferList = 0;
}
RPRINT("done closing.\n");
}
int main(int argc, const char *argv[])
{
MyAudioConverterSettings audioConverterSettings = {0};
// open the input with ExtAudioFile
CFURLRef inputFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, kInputFileLocation, kCFURLPOSIXPathStyle, false);
CheckResult(ExtAudioFileOpenURL(inputFileURL,
&audioConverterSettings.inputFile),
"ExtAudioFileOpenURL failed");
// define the ouput format. AudioConverter requires that one of the data formats be LPCM
audioConverterSettings.outputFormat.mSampleRate = 44100.0;
audioConverterSettings.outputFormat.mFormatID = kAudioFormatLinearPCM;
audioConverterSettings.outputFormat.mFormatFlags = kAudioFormatFlagIsBigEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
audioConverterSettings.outputFormat.mBytesPerPacket = 4;
audioConverterSettings.outputFormat.mFramesPerPacket = 1;
audioConverterSettings.outputFormat.mBytesPerFrame = 4;
audioConverterSettings.outputFormat.mChannelsPerFrame = 2;
audioConverterSettings.outputFormat.mBitsPerChannel = 16;
// create output file
CFURLRef outputFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR("output.aif"), kCFURLPOSIXPathStyle, false);
CheckResult (AudioFileCreateWithURL(outputFileURL, kAudioFileAIFFType, &audioConverterSettings.outputFormat, kAudioFileFlags_EraseFile, &audioConverterSettings.outputFile),
"AudioFileCreateWithURL failed");
CFRelease(outputFileURL);
// set the PCM format as the client format on the input ext audio file
CheckResult(ExtAudioFileSetProperty(audioConverterSettings.inputFile,
kExtAudioFileProperty_ClientDataFormat,
sizeof (AudioStreamBasicDescription),
&audioConverterSettings.outputFormat),
"Couldn't set client data format on input ext file");
fprintf(stdout, "Converting...\n");
Convert(&audioConverterSettings);
cleanup:
// AudioFileClose(audioConverterSettings.inputFile);
ExtAudioFileDispose(audioConverterSettings.inputFile);
AudioFileClose(audioConverterSettings.outputFile);
return 0;
}
bool SFB::Audio::CoreAudioDecoder::_Close(CFErrorRef */*error*/)
{
// Close the output file
if(mExtAudioFile) {
OSStatus result = ExtAudioFileDispose(mExtAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "ExtAudioFileDispose failed: " << result);
mExtAudioFile = nullptr;
}
if(mAudioFile) {
OSStatus result = AudioFileClose(mAudioFile);
if(noErr != result)
LOGGER_NOTICE("org.sbooth.AudioEngine.Decoder.CoreAudio", "AudioFileClose failed: " << result);
mAudioFile = nullptr;
}
return true;
}
int snd_convert(snd_t *snd)
{
NSString *pp = @"/Volumes/Macintosh HD/Users/kainjow/Desktop/ext.aif";
ExtAudioFileRef audioFile;
OSStatus status;
AudioStreamBasicDescription stream = {0};
stream.mSampleRate = 22000;
stream.mFormatID = kAudioFormatLinearPCM;
stream.mFormatFlags = 0;
stream.mBytesPerPacket = 1;
stream.mFramesPerPacket = 1;
stream.mBytesPerFrame = 1;
stream.mChannelsPerFrame = 1;
stream.mBitsPerChannel = 8;
status = ExtAudioFileCreateWithURL((CFURLRef)[NSURL fileURLWithPath:pp], kAudioFileWAVEType/*kAudioFileAIFFType*/, &stream, NULL, kAudioFileFlags_EraseFile, &audioFile);
if (status == noErr) {
UInt32 numFrames = (sndSize - 50);
AudioBufferList buffer;
buffer.mNumberBuffers = 1;
buffer.mBuffers[0].mNumberChannels = 1;
buffer.mBuffers[0].mDataByteSize = numFrames;
buffer.mBuffers[0].mData = (char *)snd + 50;
#if 0
UInt8 *t = (UInt8 *)buffer.mBuffers[0].mData;
for (UInt32 i=0; i<numFrames; i++) {
*t ^= 0x80;
t++;
}
#endif
status = ExtAudioFileWrite(audioFile, numFrames, &buffer);
if (status == noErr) {
printf("SUCCESS\n");
} else {
printf("FAILED: %ld\n", status);
}
ExtAudioFileDispose(audioFile);
} else {
printf("Couldn't create ext audio file: %ld\n", (long)status);
}
}
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 */
SoundSourceCoreAudio::~SoundSourceCoreAudio() {
ExtAudioFileDispose(m_audioFile);
}
AudioDecoderCoreAudio::~AudioDecoderCoreAudio() {
ExtAudioFileDispose(m_audioFile);
}
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;
}
void DoAQOfflineRender(CFURLRef sourceURL, CFURLRef destinationURL)
{
// main audio queue code
try {
AQTestInfo myInfo;
myInfo.mDone = false;
myInfo.mFlushed = false;
myInfo.mCurrentPacket = 0;
// get the source file
XThrowIfError(AudioFileOpenURL(sourceURL, 0x01/*fsRdPerm*/, 0/*inFileTypeHint*/, &myInfo.mAudioFile), "AudioFileOpen failed");
UInt32 size = sizeof(myInfo.mDataFormat);
XThrowIfError(AudioFileGetProperty(myInfo.mAudioFile, kAudioFilePropertyDataFormat, &size, &myInfo.mDataFormat), "couldn't get file's data format");
printf ("File format: "); myInfo.mDataFormat.Print();
// create a new audio queue output
XThrowIfError(AudioQueueNewOutput(&myInfo.mDataFormat, // The data format of the audio to play. For linear PCM, only interleaved formats are supported.
AQTestBufferCallback, // A callback function to use with the playback audio queue.
&myInfo, // A custom data structure for use with the callback function.
CFRunLoopGetCurrent(), // The event loop on which the callback function pointed to by the inCallbackProc parameter is to be called.
// If you specify NULL, the callback is invoked on one of the audio queue’s internal threads.
kCFRunLoopCommonModes, // The run loop mode in which to invoke the callback function specified in the inCallbackProc parameter.
0, // Reserved for future use. Must be 0.
&myInfo.mQueue), // On output, the newly created playback audio queue object.
"AudioQueueNew failed");
UInt32 bufferByteSize;
// we need to calculate how many packets we read at a time and how big a buffer we need
// we base this on the size of the packets in the file and an approximate duration for each buffer
{
bool isFormatVBR = (myInfo.mDataFormat.mBytesPerPacket == 0 || myInfo.mDataFormat.mFramesPerPacket == 0);
// first check to see what the max size of a packet is - if it is bigger
// than our allocation default size, that needs to become larger
UInt32 maxPacketSize;
size = sizeof(maxPacketSize);
XThrowIfError(AudioFileGetProperty(myInfo.mAudioFile, kAudioFilePropertyPacketSizeUpperBound, &size, &maxPacketSize), "couldn't get file's max packet size");
// adjust buffer size to represent about a second of audio based on this format
CalculateBytesForTime(myInfo.mDataFormat, maxPacketSize, 1.0/*seconds*/, &bufferByteSize, &myInfo.mNumPacketsToRead);
if (isFormatVBR) {
myInfo.mPacketDescs = new AudioStreamPacketDescription [myInfo.mNumPacketsToRead];
} else {
myInfo.mPacketDescs = NULL; // we don't provide packet descriptions for constant bit rate formats (like linear PCM)
}
printf ("Buffer Byte Size: %d, Num Packets to Read: %d\n", (int)bufferByteSize, (int)myInfo.mNumPacketsToRead);
}
// if the file has a magic cookie, we should get it and set it on the AQ
size = sizeof(UInt32);
OSStatus result = AudioFileGetPropertyInfo (myInfo.mAudioFile, kAudioFilePropertyMagicCookieData, &size, NULL);
if (!result && size) {
char* cookie = new char [size];
XThrowIfError (AudioFileGetProperty (myInfo.mAudioFile, kAudioFilePropertyMagicCookieData, &size, cookie), "get cookie from file");
XThrowIfError (AudioQueueSetProperty(myInfo.mQueue, kAudioQueueProperty_MagicCookie, cookie, size), "set cookie on queue");
delete [] cookie;
}
// channel layout?
OSStatus err = AudioFileGetPropertyInfo(myInfo.mAudioFile, kAudioFilePropertyChannelLayout, &size, NULL);
AudioChannelLayout *acl = NULL;
if (err == noErr && size > 0) {
acl = (AudioChannelLayout *)malloc(size);
XThrowIfError(AudioFileGetProperty(myInfo.mAudioFile, kAudioFilePropertyChannelLayout, &size, acl), "get audio file's channel layout");
XThrowIfError(AudioQueueSetProperty(myInfo.mQueue, kAudioQueueProperty_ChannelLayout, acl, size), "set channel layout on queue");
}
//allocate the input read buffer
XThrowIfError(AudioQueueAllocateBuffer(myInfo.mQueue, bufferByteSize, &myInfo.mBuffer), "AudioQueueAllocateBuffer");
// prepare a canonical interleaved capture format
CAStreamBasicDescription captureFormat;
captureFormat.mSampleRate = myInfo.mDataFormat.mSampleRate;
captureFormat.SetAUCanonical(myInfo.mDataFormat.mChannelsPerFrame, true); // interleaved
XThrowIfError(AudioQueueSetOfflineRenderFormat(myInfo.mQueue, &captureFormat, acl), "set offline render format");
ExtAudioFileRef captureFile;
// prepare a 16-bit int file format, sample channel count and sample rate
CAStreamBasicDescription dstFormat;
dstFormat.mSampleRate = myInfo.mDataFormat.mSampleRate;
dstFormat.mChannelsPerFrame = myInfo.mDataFormat.mChannelsPerFrame;
dstFormat.mFormatID = kAudioFormatLinearPCM;
dstFormat.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger; // little-endian
dstFormat.mBitsPerChannel = 16;
dstFormat.mBytesPerPacket = dstFormat.mBytesPerFrame = 2 * dstFormat.mChannelsPerFrame;
dstFormat.mFramesPerPacket = 1;
// create the capture file
XThrowIfError(ExtAudioFileCreateWithURL(destinationURL, kAudioFileCAFType, &dstFormat, acl, kAudioFileFlags_EraseFile, &captureFile), "ExtAudioFileCreateWithURL");
// set the capture file's client format to be the canonical format from the queue
XThrowIfError(ExtAudioFileSetProperty(captureFile, kExtAudioFileProperty_ClientDataFormat, sizeof(AudioStreamBasicDescription), &captureFormat), "set ExtAudioFile client format");
// allocate the capture buffer, just keep it at half the size of the enqueue buffer
// we don't ever want to pull any faster than we can push data in for render
// this 2:1 ratio keeps the AQ Offline Render happy
const UInt32 captureBufferByteSize = bufferByteSize / 2;
AudioQueueBufferRef captureBuffer;
AudioBufferList captureABL;
XThrowIfError(AudioQueueAllocateBuffer(myInfo.mQueue, captureBufferByteSize, &captureBuffer), "AudioQueueAllocateBuffer");
captureABL.mNumberBuffers = 1;
captureABL.mBuffers[0].mData = captureBuffer->mAudioData;
captureABL.mBuffers[0].mNumberChannels = captureFormat.mChannelsPerFrame;
// lets start playing now - stop is called in the AQTestBufferCallback when there's
// no more to read from the file
XThrowIfError(AudioQueueStart(myInfo.mQueue, NULL), "AudioQueueStart failed");
AudioTimeStamp ts;
ts.mFlags = kAudioTimeStampSampleTimeValid;
ts.mSampleTime = 0;
// we need to call this once asking for 0 frames
XThrowIfError(AudioQueueOfflineRender(myInfo.mQueue, &ts, captureBuffer, 0), "AudioQueueOfflineRender");
// we need to enqueue a buffer after the queue has started
AQTestBufferCallback(&myInfo, myInfo.mQueue, myInfo.mBuffer);
while (true) {
UInt32 reqFrames = captureBufferByteSize / captureFormat.mBytesPerFrame;
XThrowIfError(AudioQueueOfflineRender(myInfo.mQueue, &ts, captureBuffer, reqFrames), "AudioQueueOfflineRender");
captureABL.mBuffers[0].mData = captureBuffer->mAudioData;
captureABL.mBuffers[0].mDataByteSize = captureBuffer->mAudioDataByteSize;
UInt32 writeFrames = captureABL.mBuffers[0].mDataByteSize / captureFormat.mBytesPerFrame;
printf("t = %.f: AudioQueueOfflineRender: req %d fr/%d bytes, got %ld fr/%d bytes\n", ts.mSampleTime, (int)reqFrames, (int)captureBufferByteSize, writeFrames, (int)captureABL.mBuffers[0].mDataByteSize);
XThrowIfError(ExtAudioFileWrite(captureFile, writeFrames, &captureABL), "ExtAudioFileWrite");
if (myInfo.mFlushed) break;
ts.mSampleTime += writeFrames;
}
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1, false);
XThrowIfError(AudioQueueDispose(myInfo.mQueue, true), "AudioQueueDispose(true) failed");
XThrowIfError(AudioFileClose(myInfo.mAudioFile), "AudioQueueDispose(false) failed");
XThrowIfError(ExtAudioFileDispose(captureFile), "ExtAudioFileDispose failed");
if (myInfo.mPacketDescs) delete [] myInfo.mPacketDescs;
if (acl) free(acl);
}
catch (CAXException e) {
char buf[256];
fprintf(stderr, "Error: %s (%s)\n", e.mOperation, e.FormatError(buf));
}
return;
}
void SoundSourceCoreAudio::close() {
ExtAudioFileDispose(m_audioFile);
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
void WriteOutputFile (const char* outputFilePath,
OSType dataFormat,
Float64 srate,
MusicTimeStamp sequenceLength,
bool shouldPrint,
AUGraph inGraph,
UInt32 numFrames,
MusicPlayer player)
{
// delete existing output file
TestFile (outputFilePath, true);
OSStatus result = 0;
UInt32 size;
CAStreamBasicDescription outputFormat;
outputFormat.mChannelsPerFrame = 2;
outputFormat.mSampleRate = srate;
outputFormat.mFormatID = dataFormat;
AudioFileTypeID destFileType;
CAAudioFileFormats::Instance()->InferFileFormatFromFilename (outputFilePath, destFileType);
if (dataFormat == kAudioFormatLinearPCM) {
outputFormat.mBytesPerPacket = outputFormat.mChannelsPerFrame * 2;
outputFormat.mFramesPerPacket = 1;
outputFormat.mBytesPerFrame = outputFormat.mBytesPerPacket;
outputFormat.mBitsPerChannel = 16;
if (destFileType == kAudioFileWAVEType)
outputFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
else
outputFormat.mFormatFlags = kLinearPCMFormatFlagIsBigEndian
| kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
} else {
// use AudioFormat API to fill out the rest.
size = sizeof(outputFormat);
require_noerr (result = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, 0, NULL, &size, &outputFormat), fail);
}
if (shouldPrint) {
printf ("Writing to file: %s with format:\n* ", outputFilePath);
outputFormat.Print();
}
FSRef parentDir;
CFStringRef destFileName;
require_noerr (result = PosixPathToParentFSRefAndName(outputFilePath, parentDir, destFileName), fail);
ExtAudioFileRef outfile;
result = ExtAudioFileCreateNew (&parentDir, destFileName, destFileType, &outputFormat, NULL, &outfile);
CFRelease (destFileName);
require_noerr (result, fail);
AudioUnit outputUnit;
UInt32 nodeCount;
require_noerr (result = AUGraphGetNodeCount (inGraph, &nodeCount), fail);
for (UInt32 i = 0; i < nodeCount; ++i)
{
AUNode node;
require_noerr (result = AUGraphGetIndNode(inGraph, i, &node), fail);
ComponentDescription desc;
require_noerr (result = AUGraphNodeInfo(inGraph, node, &desc, NULL), fail);
if (desc.componentType == kAudioUnitType_Output)
{
require_noerr (result = AUGraphNodeInfo(inGraph, node, 0, &outputUnit), fail);
break;
}
}
{
CAStreamBasicDescription clientFormat;
size = sizeof(clientFormat);
require_noerr (result = AudioUnitGetProperty (outputUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output, 0,
&clientFormat, &size), fail);
size = sizeof(clientFormat);
require_noerr (result = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat), fail);
{
MusicTimeStamp currentTime;
AUOutputBL outputBuffer (clientFormat, numFrames);
AudioTimeStamp tStamp;
memset (&tStamp, 0, sizeof(AudioTimeStamp));
tStamp.mFlags = kAudioTimeStampSampleTimeValid;
int i = 0;
int numTimesFor10Secs = (int)(10. / (numFrames / srate));
do {
outputBuffer.Prepare();
AudioUnitRenderActionFlags actionFlags = 0;
require_noerr (result = AudioUnitRender (outputUnit, &actionFlags, &tStamp, 0, numFrames, outputBuffer.ABL()), fail);
tStamp.mSampleTime += numFrames;
require_noerr (result = ExtAudioFileWrite(outfile, numFrames, outputBuffer.ABL()), fail);
require_noerr (result = MusicPlayerGetTime (player, ¤tTime), fail);
if (shouldPrint && (++i % numTimesFor10Secs == 0))
printf ("current time: %6.2f beats\n", currentTime);
} while (currentTime < sequenceLength);
}
}
// close
ExtAudioFileDispose(outfile);
return;
fail:
printf ("Problem: %ld\n", result);
exit(1);
}
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;
}
/**
* @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;
}
~CoreAudioReader()
{
ExtAudioFileDispose (audioFileRef);
AudioFileClose (audioFileID);
}
void WriteOutputFile (const char* outputFilePath,
OSType dataFormat,
Float64 srate,
MusicTimeStamp sequenceLength,
bool shouldPrint,
AUGraph inGraph,
UInt32 numFrames,
MusicPlayer player)
{
OSStatus result = 0;
UInt32 size;
CAStreamBasicDescription outputFormat;
outputFormat.mChannelsPerFrame = 2;
outputFormat.mSampleRate = srate;
outputFormat.mFormatID = dataFormat;
AudioFileTypeID destFileType;
CAAudioFileFormats::Instance()->InferFileFormatFromFilename (outputFilePath, destFileType);
if (dataFormat == kAudioFormatLinearPCM) {
outputFormat.mBytesPerPacket = outputFormat.mChannelsPerFrame * 2;
outputFormat.mFramesPerPacket = 1;
outputFormat.mBytesPerFrame = outputFormat.mBytesPerPacket;
outputFormat.mBitsPerChannel = 16;
if (destFileType == kAudioFileWAVEType)
outputFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
else
outputFormat.mFormatFlags = kLinearPCMFormatFlagIsBigEndian
| kLinearPCMFormatFlagIsSignedInteger
| kLinearPCMFormatFlagIsPacked;
} else {
// use AudioFormat API to fill out the rest.
size = sizeof(outputFormat);
FailIf ((result = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, 0, NULL, &size, &outputFormat)), fail, "");
}
if (shouldPrint) {
printf ("Writing to file: %s with format:\n* ", outputFilePath);
outputFormat.Print();
}
CFURLRef url; url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8*)outputFilePath, strlen(outputFilePath), false);
// create output file, delete existing file
ExtAudioFileRef outfile;
result = ExtAudioFileCreateWithURL(url, destFileType, &outputFormat, NULL, kAudioFileFlags_EraseFile, &outfile);
if (url) CFRelease (url);
FailIf (result, fail, "ExtAudioFileCreateWithURL");
AudioUnit outputUnit; outputUnit = NULL;
UInt32 nodeCount;
FailIf ((result = AUGraphGetNodeCount (inGraph, &nodeCount)), fail, "AUGraphGetNodeCount");
for (UInt32 i = 0; i < nodeCount; ++i)
{
AUNode node;
FailIf ((result = AUGraphGetIndNode(inGraph, i, &node)), fail, "AUGraphGetIndNode");
AudioComponentDescription desc;
FailIf ((result = AUGraphNodeInfo(inGraph, node, &desc, NULL)), fail, "AUGraphNodeInfo");
if (desc.componentType == kAudioUnitType_Output)
{
FailIf ((result = AUGraphNodeInfo(inGraph, node, 0, &outputUnit)), fail, "AUGraphNodeInfo");
break;
}
}
FailIf ((result = (outputUnit == NULL)), fail, "outputUnit == NULL");
{
CAStreamBasicDescription clientFormat = CAStreamBasicDescription();
size = sizeof(clientFormat);
FailIf ((result = AudioUnitGetProperty (outputUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Output, 0,
&clientFormat, &size)), fail, "AudioUnitGetProperty: kAudioUnitProperty_StreamFormat");
size = sizeof(clientFormat);
FailIf ((result = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat)), fail, "ExtAudioFileSetProperty: kExtAudioFileProperty_ClientDataFormat");
{
MusicTimeStamp currentTime;
AUOutputBL outputBuffer (clientFormat, numFrames);
AudioTimeStamp tStamp;
memset (&tStamp, 0, sizeof(AudioTimeStamp));
tStamp.mFlags = kAudioTimeStampSampleTimeValid;
int i = 0;
int numTimesFor10Secs = (int)(10. / (numFrames / srate));
do {
outputBuffer.Prepare();
AudioUnitRenderActionFlags actionFlags = 0;
FailIf ((result = AudioUnitRender (outputUnit, &actionFlags, &tStamp, 0, numFrames, outputBuffer.ABL())), fail, "AudioUnitRender");
tStamp.mSampleTime += numFrames;
FailIf ((result = ExtAudioFileWrite(outfile, numFrames, outputBuffer.ABL())), fail, "ExtAudioFileWrite");
FailIf ((result = MusicPlayerGetTime (player, ¤tTime)), fail, "MusicPlayerGetTime");
if (shouldPrint && (++i % numTimesFor10Secs == 0))
printf ("current time: %6.2f beats\n", currentTime);
} while (currentTime < sequenceLength);
}
}
// close
ExtAudioFileDispose(outfile);
return;
fail:
printf ("Problem: %ld\n", (long)result);
exit(1);
}