void CAAudioFileConverter::WriteCAFInfo()
{
FSRef fsref;
AudioFileID afid = 0;
CAFSourceInfo info;
UInt32 size;
try {
XThrowIfError(FSPathMakeRef((UInt8 *)mParams.input.filePath, &fsref, NULL), "couldn't locate input file");
XThrowIfError(AudioFileOpen(&fsref, fsRdPerm, 0, &afid), "couldn't open input file");
size = sizeof(AudioFileTypeID);
XThrowIfError(AudioFileGetProperty(afid, kAudioFilePropertyFileFormat, &size, &info.filetype), "couldn't get input file's format");
AudioFileClose(afid);
afid = 0;
XThrowIfError(FSPathMakeRef((UInt8 *)mOutName, &fsref, NULL), "couldn't locate output file");
XThrowIfError(AudioFileOpen(&fsref, fsRdWrPerm, 0, &afid), "couldn't open output file");
const char *srcFilename = strrchr(mParams.input.filePath, '/');
if (srcFilename++ == NULL) srcFilename = mParams.input.filePath;
ASBD_NtoB(&mSrcFormat, (AudioStreamBasicDescription *)info.asbd);
int namelen = std::min(kMaxFilename-1, (int)strlen(srcFilename));
memcpy(info.filename, srcFilename, namelen);
info.filename[namelen++] = 0;
info.filetype = EndianU32_NtoB(info.filetype);
XThrowIfError(AudioFileSetUserData(afid, 'srcI', 0, offsetof(CAFSourceInfo, filename) + namelen, &info), "couldn't set CAF file's source info chunk");
AudioFileClose(afid);
}
catch (...) {
if (afid)
AudioFileClose(afid);
throw;
}
}
int main(int argc, const char *argv[])
{
MyAudioConverterSettings audioConverterSettings = {0};
// open the input audio file
CFURLRef inputFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, kInputFileLocation, kCFURLPOSIXPathStyle, false);
CheckResult (AudioFileOpenURL(inputFileURL, kAudioFileReadPermission , 0, &audioConverterSettings.inputFile),
"AudioFileOpenURL failed");
CFRelease(inputFileURL);
// get the audio data format from the file
UInt32 propSize = sizeof(audioConverterSettings.inputFormat);
CheckResult (AudioFileGetProperty(audioConverterSettings.inputFile, kAudioFilePropertyDataFormat, &propSize, &audioConverterSettings.inputFormat),
"couldn't get file's data format");
// get the total number of packets in the file
propSize = sizeof(audioConverterSettings.inputFilePacketCount);
CheckResult (AudioFileGetProperty(audioConverterSettings.inputFile, kAudioFilePropertyAudioDataPacketCount, &propSize, &audioConverterSettings.inputFilePacketCount),
"couldn't get file's packet count");
// get size of the largest possible packet
propSize = sizeof(audioConverterSettings.inputFilePacketMaxSize);
CheckResult(AudioFileGetProperty(audioConverterSettings.inputFile, kAudioFilePropertyMaximumPacketSize, &propSize, &audioConverterSettings.inputFilePacketMaxSize),
"couldn't get file's max packet size");
// 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
// KEVIN: TODO: this fails if file exists. isn't there an overwrite flag we can use?
CFURLRef outputFileURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR("output.aif"), kCFURLPOSIXPathStyle, false);
CheckResult (AudioFileCreateWithURL(outputFileURL, kAudioFileAIFFType, &audioConverterSettings.outputFormat, kAudioFileFlags_EraseFile, &audioConverterSettings.outputFile),
"AudioFileCreateWithURL failed");
CFRelease(outputFileURL);
fprintf(stdout, "Converting...\n");
Convert(&audioConverterSettings);
cleanup:
AudioFileClose(audioConverterSettings.inputFile);
AudioFileClose(audioConverterSettings.outputFile);
printf("Done\r");
return 0;
}
bool ofxAudioUnitFilePlayer::setFile(const std::string &filePath) {
CFURLRef fileURL;
fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)filePath.c_str(),
filePath.length(),
NULL);
if(_fileID[0]) {
AudioFileClose(_fileID[0]);
_fileID[0] = NULL;
}
OSStatus s = AudioFileOpenURL(fileURL, kAudioFileReadPermission, 0, _fileID);
CFRelease(fileURL);
_primed = false;
if(s != noErr) {
cout << "Error " << s << " while opening file at " << filePath << endl;
return false;
} else {
// setting the file ID now since it seems to have some overhead.
// Doing it now ensures you'll get sound pretty much instantly after
// calling play() (subsequent calls don't have the overhead)
OFXAU_RET_BOOL(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFileIDs,
kAudioUnitScope_Global,
0,
_fileID,
sizeof(_fileID)),
"setting file player's file ID");
}
}
DiskInUGenInternal::~DiskInUGenInternal() throw()
{
if(audioFile_)
AudioFileClose(audioFile_);
free(audioData);
}
OSStatus LoadTrack(const char* inFilePath, Boolean inAddToQueue, Boolean inLoadAtOnce)
{
BG_FileInfo *fileInfo = new BG_FileInfo;
fileInfo->mFilePath = inFilePath;
OSStatus result = LoadFileDataInfo(fileInfo->mFilePath, fileInfo->mAFID, fileInfo->mFileFormat, fileInfo->mFileDataSize);
AssertNoError("Error getting file data info", fail);
fileInfo->mLoadAtOnce = inLoadAtOnce;
fileInfo->mFileDataInQueue = false;
// if not adding to the queue, clear the current file vector
if (!inAddToQueue)
mBGFileInfo.clear();
mBGFileInfo.push_back(fileInfo);
// setup the queue if this is the first (or only) file
if (mBGFileInfo.size() == 1)
{
result = SetupQueue(fileInfo);
AssertNoError("Error setting up queue", fail);
result = SetupBuffers(fileInfo);
AssertNoError("Error setting up queue buffers", fail);
}
// if this is just part of the playlist, close the file for now
else
{
result = AudioFileClose(fileInfo->mAFID);
AssertNoError("Error closing file", fail);
}
return result;
fail:
if (fileInfo)
delete fileInfo;
return result;
}
void AudioEnginePropertyListenerProc (void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID) {
//We are only interested in the property kAudioQueueProperty_IsRunning
if (inID != kAudioQueueProperty_IsRunning) return;
struct myAQStruct *myInfo = (struct myAQStruct *)inUserData;
/* Get the current status of the AQ, running or stopped */
UInt32 isQueueRunning = false;
UInt32 size = sizeof(isQueueRunning);
AudioQueueGetProperty(myInfo->mQueue, kAudioQueueProperty_IsRunning, &isQueueRunning, &size);
/* The callback event is the start of the queue */
if (isQueueRunning) {
/* reset current packet counter */
myInfo->mCurrentPacket = 0;
for (int i = 0; i < 3; i++) {
/*
* For the first time allocate buffers for this AQ.
* Buffers are reused in turns until the AQ stops
*/
AudioQueueAllocateBuffer(myInfo->mQueue, bufferSizeInSamples * 4, &myInfo->mBuffers[i]);
UInt32 bytesRead = bufferSizeInSamples * 4;
UInt32 packetsRead = bufferSizeInSamples;
/*
* Read data from audio source into the buffer of AQ
* supplied in this callback event. Buffers are used in turns
* to hide the latency
*/
AudioFileReadPacketData(
myInfo->mAudioFile,
false, /* isUseCache, set to false */
&bytesRead,
NULL,
myInfo->mCurrentPacket,
&packetsRead,
myInfo->mBuffers[i]->mAudioData);
/* in case the buffer size is smaller than bytes requestd to read */
myInfo->mBuffers[i]->mAudioDataByteSize = bytesRead;
myInfo->mCurrentPacket += packetsRead;
AudioQueueEnqueueBuffer(myInfo->mQueue, myInfo->mBuffers[i], 0, NULL);
}
} else {
/* The callback event is the state of AQ changed to not running */
if (myInfo->mAudioFile != NULL) {
AudioQueueStop(myInfo->mQueue, false);
AudioFileClose(myInfo->mAudioFile);
myInfo->mAudioFile = NULL;
for (int i = 0; i < 3; i++) {
AudioQueueFreeBuffer(myInfo->mQueue, myInfo->mBuffers[i]);
myInfo->mBuffers[i] = NULL;
}
CFRunLoopStop(CFRunLoopGetCurrent());
}
}
}
void HLAudioFile::Close()
{
if(mOpenCount > 0)
{
// only close the file if it is open
// decrement the open count
--mOpenCount;
if(mOpenCount == 0)
{
// no one wants the file open, so really close it
OSStatus theError = 0;
if(mAudioFileID != 0)
{
theError = AudioFileClose(mAudioFileID);
mAudioFileID = 0;
}
// clear the permissions
mOpenForReading = false;
mOpenForWriting = false;
// check for errors
ThrowIfError(theError, CAException(theError), "HLAudioFile::Close: couldn't close the fork");
}
}
}
HLFileSystemObject* HLAudioFileFactory::Create(const FSRef& inParentFSRef, CFStringRef inName, const void* inData, UInt32 inDataSize)
{
HLFile* theFile = NULL;
// the data for an HLAudioFile is a stream descption
ThrowIf(inDataSize != sizeof(AudioStreamBasicDescription), CAException(paramErr), "HLAudioFileFactory::Create: the data is supposed to be an AudioStreamBasicDescription");
const AudioStreamBasicDescription* theFormat = reinterpret_cast<const AudioStreamBasicDescription*>(inData);
// create the file on disk
FSRef theFSRef;
AudioFileID theAudioFileID = 0;
OSStatus theError = AudioFileCreate(&inParentFSRef, inName, mObjectType, theFormat, 0, &theFSRef, &theAudioFileID);
if(theError == 0)
{
AudioFileClose(theAudioFileID);
// make the object
theFile = CreateObject(theFSRef);
theFile->Prepare();
}
else
{
ThrowIfError(theError, CAException(theError), "HLAudioFileFactory::Create: AudioFileCreate failed");
}
return theFile;
}
void free_aqData() {
AudioQueueDispose (aqData.mQueue, true);
AudioFileClose (aqData.mAudioFile);
free (aqData.mPacketDescs);
}
void CAAudioFileConverter::ReadCAFInfo()
{
FSRef fsref;
AudioFileID afid = 0;
CAFSourceInfo info;
UInt32 size;
OSStatus err;
try {
XThrowIfError(FSPathMakeRef((UInt8 *)mParams.input.filePath, &fsref, NULL), "couldn't locate input file");
XThrowIfError(AudioFileOpen(&fsref, fsRdPerm, 0, &afid), "couldn't open input file");
size = sizeof(AudioFileTypeID);
XThrowIfError(AudioFileGetProperty(afid, kAudioFilePropertyFileFormat, &size, &info.filetype), "couldn't get input file's format");
if (info.filetype == kAudioFileCAFType) {
size = sizeof(info);
err = AudioFileGetUserData(afid, 'srcI', 0, &size, &info);
if (!err) {
// restore the following from the original file info:
// filetype
// data format
// filename
AudioStreamBasicDescription destfmt;
ASBD_BtoN((AudioStreamBasicDescription *)info.asbd, &destfmt);
mParams.output.dataFormat = destfmt;
mParams.output.fileType = EndianU32_BtoN(info.filetype);
if (mParams.output.filePath == NULL) {
int len = strlen(mParams.input.filePath) + strlen(info.filename) + 2;
char *newname = (char *)malloc(len); // $$$ leaked
const char *dir = dirname(mParams.input.filePath);
if (dir && (dir[0] !='.' && dir[1] != '/'))
sprintf(newname, "%s/%s", dir, info.filename);
else
strcpy(newname, info.filename);
mParams.output.filePath = newname;
mParams.flags = (mParams.flags & ~kOpt_OverwriteOutputFile) | kOpt_NoSanitizeOutputFormat;
}
}
}
AudioFileClose(afid);
}
catch (...) {
if (afid)
AudioFileClose(afid);
throw;
}
}
// ----------------------------------------------------------
bool ofxAudioUnitFilePlayer::setFile(std::string filePath)
// ----------------------------------------------------------
{
CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(const UInt8 *)filePath.c_str(),
filePath.length(),
NULL);
if(fileID[0]) AudioFileClose(fileID[0]);
OSStatus s = AudioFileOpenURL(fileURL, kAudioFileReadPermission, 0, fileID);
CFRelease(fileURL);
if(s != noErr)
{
if(s == fnfErr)
{
cout << "File not found : " << filePath << endl;
}
else
{
cout << "Error " << s << " while opening file at " << filePath << endl;
}
return false;
}
UInt64 numPackets = 0;
UInt32 dataSize = sizeof(numPackets);
AudioFileGetProperty(fileID[0], kAudioFilePropertyAudioDataPacketCount, &dataSize, &numPackets);
AudioStreamBasicDescription asbd = {0};
dataSize = sizeof(asbd);
AudioFileGetProperty(fileID[0], kAudioFilePropertyDataFormat, &dataSize, &asbd);
// defining a region which basically says "play the whole file"
memset(®ion, 0, sizeof(region));
region.mTimeStamp.mFlags = kAudioTimeStampSampleTimeValid;
region.mTimeStamp.mSampleTime = 0;
region.mCompletionProc = NULL;
region.mCompletionProcUserData = NULL;
region.mAudioFile = fileID[0];
region.mLoopCount = 0;
region.mStartFrame = 0;
region.mFramesToPlay = numPackets * asbd.mFramesPerPacket;
// setting the file ID now since it seems to have some overhead.
// Doing it now ensures you'll get sound pretty much instantly after
// calling play()
return ERR_CHK_BOOL(AudioUnitSetProperty(*_unit,
kAudioUnitProperty_ScheduledFileIDs,
kAudioUnitScope_Global,
0,
fileID,
sizeof(fileID)),
"setting file player's file ID");
}
void
CoreAudio_ShutDown()
{
AUGraphStop(theGraph);
AUGraphUninitialize(theGraph);
AudioFileClose(audioFile);
AUGraphClose(theGraph);
}
int main (int argc, char * const argv[])
{
char inputFile[]="blip.mp3";
static const double threshold=0.50;
int hardware=macbookpro;
double x,y,z,prev_x,prev_y,prev_z;
AudioFileID audioFile;
CFURLRef theURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8*)inputFile, strlen(inputFile), false);
XThrowIfError (AudioFileOpenURL (theURL, kAudioFileReadPermission, 0, &audioFile), "AudioFileOpenURL");
// get the number of channels of the file
CAStreamBasicDescription fileFormat;
UInt32 propsize = sizeof(CAStreamBasicDescription);
XThrowIfError (AudioFileGetProperty(audioFile, kAudioFilePropertyDataFormat, &propsize, &fileFormat), "AudioFileGetProperty");
// lets set up our playing state now
AUGraph theGraph;
CAAudioUnit fileAU;
// this makes the graph, the file AU and sets it all up for playing
MakeSimpleGraph (theGraph, fileAU, fileFormat, audioFile);
// now we load the file contents up for playback before we start playing
// this has to be done the AU is initialized and anytime it is reset or uninitialized
Float64 fileDuration = PrepareFileAU (fileAU, fileFormat, audioFile);
printf ("file duration: %f secs\n", fileDuration);
read_sms_real(hardware,&x,&y,&z);
prev_x=x;
prev_y=y;
prev_z=z;
for(;;) {
read_sms_real(hardware,&x,&y,&z);
//printf("x: %f y: %f z: %f\n",x,y,z);
if(isDelta(threshold,x,y,z,prev_x,prev_y,prev_z))
XThrowIfError (AUGraphStart (theGraph), "AUGraphStart");
prev_x=x;
prev_y=y;
prev_z=z;
}
// sleep until the file is finished
//usleep ((int)(fileDuration * 1000. * 1000.));
// lets clean up
XThrowIfError (AUGraphStop (theGraph), "AUGraphStop");
XThrowIfError (AUGraphUninitialize (theGraph), "AUGraphUninitialize");
XThrowIfError (AudioFileClose (audioFile), "AudioFileClose");
XThrowIfError (AUGraphClose (theGraph), "AUGraphClose");
return 0;
}
void Teardown()
{
if (mQueue)
AudioQueueDispose(mQueue, true);
for (UInt32 i=0; i < mBGFileInfo.size(); i++)
if (mBGFileInfo[i]->mAFID)
AudioFileClose(mBGFileInfo[i]->mAFID);
if (mPacketDescs)
delete mPacketDescs;
}
AudioFileReader::~AudioFileReader()
{
if (m_extAudioFileRef)
ExtAudioFileDispose(m_extAudioFileRef);
m_extAudioFileRef = 0;
if (m_audioFileID)
AudioFileClose(m_audioFileID);
m_audioFileID = 0;
}
void StateDestroy(State *state)
{
if (state->audioQueue) {
AudioQueueDispose(state->audioQueue, false);
}
if (state->audioFile) {
AudioFileClose(state->audioFile);
}
free(state);
}
static void CoreAudio_close(Sound_Sample *sample)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
free(core_audio_file_container->outputFormat);
ExtAudioFileDispose(core_audio_file_container->extAudioFileRef);
AudioFileClose(*core_audio_file_container->audioFileID);
free(core_audio_file_container->audioFileID);
free(core_audio_file_container);
} /* CoreAudio_close */
OSStatus LoadFileData(const char *inFilePath, void* &outData, UInt32 &outDataSize, ALuint &outBufferID)
{
AudioFileID theAFID = 0;
OSStatus result = noErr;
UInt64 theFileSize = 0;
AudioStreamBasicDescription theFileFormat;
result = LoadFileDataInfo(inFilePath, theAFID, theFileFormat, theFileSize);
outDataSize = (UInt32)theFileSize;
AssertNoError("Error loading file info", fail)
outData = malloc(outDataSize);
result = AudioFileReadBytes(theAFID, false, 0, &outDataSize, outData);
AssertNoError("Error reading file data", fail)
if (!TestAudioFormatNativeEndian(theFileFormat) && (theFileFormat.mBitsPerChannel > 8))
return kSoundEngineErrInvalidFileFormat;
alGenBuffers(1, &outBufferID);
AssertNoOALError("Error generating buffer\n", fail);
alBufferDataStaticProc(outBufferID, GetALFormat(theFileFormat), outData, outDataSize, theFileFormat.mSampleRate);
AssertNoOALError("Error attaching data to buffer\n", fail);
AudioFileClose(theAFID);
return result;
fail:
if (theAFID)
AudioFileClose(theAFID);
if (outData)
{
free(outData);
outData = NULL;
}
return result;
}
void DiskOutUGenInternal::checkBufferSize(const int requiredBufferSize) throw()
{
if(audioData && requiredBufferSize > allocatedBlockSize)
{
allocatedBlockSize = requiredBufferSize;
allocatedBlockSizeInBytes = allocatedBlockSize * bytesPerFrame;
audioData = realloc(audioData, allocatedBlockSizeInBytes + 4); // pad a litte for 24 bit
if(!audioData)
{
AudioFileClose(audioFile_);
audioFile_ = 0;
}
}
}
BEGIN_UGEN_NAMESPACE
#include "ugen_iPhoneAudioFileDiskIn.h"
#include "ugen_NSUtilities.h"
DiskInUGenInternal::DiskInUGenInternal(AudioFileID audioFile,
AudioStreamBasicDescription const& format,
const bool loopFlag,
const double startTime,
const UGen::DoneAction doneAction) throw()
: ProxyOwnerUGenInternal(0, format.mChannelsPerFrame - 1),
audioFile_(audioFile),
numChannels_(format.mChannelsPerFrame),
loopFlag_(loopFlag),
startTime_(startTime),
packetCount(0),
currentPacket(0),
allocatedBlockSize(0),
audioData(0),
numPackets(0),
bytesPerFrame(format.mBytesPerFrame),
fileSampleRate(format.mSampleRate),
reciprocalSampleRate(1.0/fileSampleRate),
doneAction_(doneAction),
shouldDeleteValue(doneAction_ == UGen::DeleteWhenDone)
{
OSStatus result;
UInt32 dataSize;
if(audioFile_)
{
dataSize = sizeof(packetCount);
result = AudioFileGetProperty(audioFile, kAudioFilePropertyAudioDataPacketCount, &dataSize, &packetCount);
if (result != noErr)
{
printf("DiskIn: error: Could not get packet count: ID=%p err=%d\n", audioFile_, (int)result);
AudioFileClose(audioFile_);
audioFile_ = 0;
}
else
{
currentPacket = ugen::max(0.0, startTime) * fileSampleRate;
if(currentPacket >= packetCount)
currentPacket = 0;
allocatedBlockSize = UGen::getEstimatedBlockSize();
audioData = malloc(bytesPerFrame * allocatedBlockSize);
}
}
}
void Recorder::stop()
{
AudioQueueStop ( // 6
aqData.mQueue, // 7
true // 8
);
aqData.mIsRunning = false; // 9
AudioQueueDispose ( // 1
aqData.mQueue, // 2
true // 3
);
AudioFileClose (aqData.mAudioFile); // 4
}
//-----------------------------------------------------------------------------
bool AudioFile::IsVarid()
{
#if MAC
AudioFileID mAudioFileID;
FSRef ref;
Boolean isDirectory=false;
FSPathMakeRef((const UInt8*)GetFilePath(), &ref, &isDirectory);
OSStatus err = AudioFileOpen(&ref, fsRdPerm, 0, &mAudioFileID);
if (err == noErr) {
AudioFileClose(mAudioFileID);
return true;
}
#endif
return false;
}
music_obj<audio_queue_driver>::~music_obj()
{
if (is_playing())
{
AudioQueueStop(queue_, true);
}
AudioQueueDispose(queue_, true);
AudioFileClose(audio_file_);
if(packet_descriptions_ != NULL)
{
free(packet_descriptions_);
}
}
~AudioPlayerOsx() {
OSStatus status;
status = AudioQueueDispose ( // 1
aqData.mQueue, // 2
true // 3
);
checkStatus(status);
status = AudioFileClose(aqData.mAudioFile);
checkStatus(status);
free (aqData.mPacketDescs); // 5
}
SoundRecorder::~SoundRecorder(void)
{
/* Destroy the audio queue: */
if(active)
{
/* Stop the audio queue: */
AudioQueueStop(queue,true);
/* Set the audio file's magic cookie: */
setAudioFileMagicCookie();
}
AudioQueueDispose(queue,true);
/* Destroy the audio file: */
AudioFileClose(audioFile);
}
NNTDECL_SIGNALS_END
void Buffer::close()
{
# ifdef NNT_MACH
if (stm)
{
AudioFileClose(stm);
stm = NULL;
}
d_ptr->clear_buffers();
packets = 0;
# endif
}
bool AudioQueueStreamOut::Close()
{
bool bRes = true;
if(mInfo.mQueue)
{
mInfo.mDone = TRUE;
AudioQueueStop(mInfo.mQueue, true);
AudioQueueDispose(mInfo.mQueue, true);
mInfo.mQueue = NULL;
}
if(mInfo.mAudioFile)
{
AudioFileClose(mInfo.mAudioFile);
mInfo.mAudioFile = NULL;
}
delete [] mInfo.mPacketDescs;
mInfo.mPacketDescs = NULL;
return bRes;
}
void DiskOutUGenInternal::writeBuffer(const int bufferSize) throw()
{
UInt32 ioNumPackets = bufferSize;
OSStatus status = AudioFileWritePackets(audioFile_, false,
allocatedBlockSizeInBytes, NULL,
currentPacket,&ioNumPackets,
audioData);
if((status != noErr) || (ioNumPackets == 0))
{
printf("DiskOut: error: writing file\n");
AudioFileClose(audioFile_);
audioFile_ = 0;
}
else
{
currentPacket += ioNumPackets;
}
}
void HLAudioFile::Prepare()
{
// open the file
AudioFileID theAudioFileID = 0;
OSStatus theError = AudioFileOpen(&mFSRef, fsRdPerm, 0, &theAudioFileID);
ThrowIfError(theError, CAException(theError), "HLAudioFile::Prepare: couldn't open the file");
// get the format
UInt32 theSize = sizeof(AudioStreamBasicDescription);
theError = AudioFileGetProperty(theAudioFileID, kAudioFilePropertyDataFormat, &theSize, &mFormat);
// close the file before we might throw an exception
AudioFileClose(theAudioFileID);
// check the error
ThrowIfError(theError, CAException(theError), "HLAudioFile::Prepare: couldn't get the format");
HLFile::Prepare();
}
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;
}
