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;
}
int main (int argc, const char * argv[])
{
char* filePath = NULL;
bool overwrite = false;
ComponentDescription compDesc = {0, 0, 0, 0, 0};
AudioFileID inputFileID = 0;
AudioFileID outputFileID = 0;
CAStreamBasicDescription desc;
AudioUnit theUnit = 0;
setbuf (stdout, NULL);
for (int i = 1; i < argc; ++i)
{
if (strcmp (argv[i], "-u") == 0) {
if ( (i + 3) < argc ) {
compDesc.componentType = str2OSType (argv[i + 1]);
compDesc.componentSubType = str2OSType (argv[i + 2]);
compDesc.componentManufacturer = str2OSType (argv[i + 3]);
Component comp = FindNextComponent (NULL, &compDesc);
if (comp == NULL)
break;
OpenAComponent (comp, &theUnit);
i += 3;
} else {
printf ("Which Component:\n%s", usageStr);
return -1;
}
}
else if (strcmp (argv[i], "-f") == 0) {
filePath = const_cast<char*>(argv[++i]);
printf ("Input File:%s\n", filePath);
}
else if (strcmp (argv[i], "-o") == 0) {
overwrite = true;
}
else {
printf ("%s\n", usageStr);
return -1;
}
}
if (compDesc.componentType == 0) {
printf ("Must specify AU:\n%s\n", usageStr);
return -1;
}
if (theUnit == 0) {
printf ("Can't find specified unit\n");
return -1;
}
if (filePath == NULL) {
printf ("Must specify file to process:\n%s\n", usageStr);
return -1;
}
OSStatus result = 0;
if (result = InputFile (filePath, inputFileID)) {
printf ("Result = %ld, parsing input file, exit...\n", result);
return result;
}
UInt32 fileType;
UInt32 size = sizeof (fileType);
result = AudioFileGetProperty (inputFileID, kAudioFilePropertyFileFormat, &size, &fileType);
if (result) {
printf ("Error getting File Type of input file:%ld, exit...\n", result);
return result;
}
size = sizeof (desc);
result = AudioFileGetProperty (inputFileID, kAudioFilePropertyDataFormat, &size, &desc);
if (result) {
printf ("Error getting File Format of input file:%ld, exit...\n", result);
return result;
}
if (desc.IsPCM() == false) {
printf ("Only processing linear PCM file types and data:\n");
desc.Print();
return -1;
}
result = OutputFile (filePath, fileType, compDesc.componentSubType, overwrite, desc, outputFileID);
if (result) {
printf ("Error creating output file:%ld, exit...\n", result);
return result;
}
// at this point we're ready to process
return Process (theUnit, compDesc, inputFileID, desc, outputFileID);
}
int main(int argc, const char * argv[])
{
#if TARGET_OS_MAC
{
thread_extended_policy_data_t theFixedPolicy;
theFixedPolicy.timeshare = false; // set to true for a non-fixed thread
thread_policy_set(pthread_mach_thread_np(pthread_self()),
THREAD_EXTENDED_POLICY,
(thread_policy_t)&theFixedPolicy,
THREAD_EXTENDED_POLICY_COUNT);
// We keep a reference to the spawning thread's priority around (initialized in the constructor),
// and set the importance of the child thread relative to the spawning thread's priority.
thread_precedence_policy_data_t thePrecedencePolicy;
thePrecedencePolicy.importance = 63 - 36;
thread_policy_set(pthread_mach_thread_np(pthread_self()),
THREAD_PRECEDENCE_POLICY,
(thread_policy_t)&thePrecedencePolicy,
THREAD_PRECEDENCE_POLICY_COUNT);
}
#endif
// These are the variables that are set up from the input parsing
char* srcFilePath = NULL;
char* auPresetFile = NULL;
OSType manu, subType, type = 0;
UInt32 numFrames = 4096;
for (int i = 1; i < argc; ++i)
{
if (strcmp (argv[i], "-au") == 0) {
if ( (i + 3) < argc ) {
StrToOSType (argv[i + 1], type);
StrToOSType (argv[i + 2], subType);
StrToOSType (argv[i + 3], manu);
i += 3;
} else {
printf ("Which Audio Unit:\n%s", usageStr);
exit(1);
}
}
else if (strcmp (argv[i], "-i") == 0) {
srcFilePath = const_cast<char*>(argv[++i]);
}
else if (strcmp (argv[i], "-p") == 0) {
auPresetFile = const_cast<char*>(argv[++i]);
}
else if (strcmp (argv[i], "-f") == 0) {
sscanf(argv[++i], "%ld", &numFrames);
}
else {
printf ("%s\n", usageStr);
exit(1);
}
}
if (!type || !srcFilePath) {
printf ("%s\n", usageStr);
exit(1);
}
CAComponentDescription desc(type, subType, manu);
CFPropertyListRef presetDict = ReadPresetFromPresetFile(auPresetFile);
#pragma mark -
#pragma mark __ The driving code
#pragma mark -
try
{
CAComponent comp(desc);
// CAAUProcessor's constructor throws... so make sure the component is valid
if (comp.IsValid() == false) {
printf ("Can't Find Component\n");
desc.Print();
exit(1);
}
CAAUProcessor processor(comp);
processor.AU().Comp().Print();
CAAudioFile srcFile;
srcFile.Open(srcFilePath);
UInt64 numInputSamples = srcFile.GetNumberFrames();
Float64 inputSecs = (numInputSamples / srcFile.GetFileDataFormat().mSampleRate);
CAStreamBasicDescription procFormat (srcFile.GetFileDataFormat());
procFormat.SetCanonical (srcFile.GetFileDataFormat().NumberChannels(), false);
printf ("Processing file: %s, %.1f secs [proc: %ld frames]\n", srcFilePath, inputSecs, numFrames);
#if VERBOSE
printf("\t");
procFormat.Print();
#endif
srcFile.SetClientFormat (procFormat);
AUOutputBL outputList(procFormat);
// read the entire file into memory
ReadBuffer* readBuf = new ReadBuffer;
readBuf->readData = new AUOutputBL(procFormat);
readBuf->totalInputFrames = numInputSamples;
readBuf->readData->Allocate (numInputSamples);
readBuf->readData->Prepare();
UInt32 readSamps = (UInt32)numInputSamples;
srcFile.Read (readSamps, readBuf->readData->ABL());
AURenderCallbackStruct inputCallback;
inputCallback.inputProc = MemoryInputCallback;
inputCallback.inputProcRefCon = readBuf;
OSStatus result;
require_noerr (result = processor.EstablishInputCallback (inputCallback), home);
require_noerr (result = processor.SetMaxFramesPerRender (numFrames), home);
require_noerr (result = processor.Initialize (procFormat, numInputSamples), home);
if (presetDict) {
require_noerr (result = processor.SetAUPreset (presetDict), home);
CFRelease (presetDict);
}
// this does ALL of the preflighting.. could be specialise for an OfflineAU type
// to do this piecemeal and do a progress bar by using the OfflineAUPreflight method
readBuf->lastInputFrames = 0;
require_noerr (result = processor.Preflight (), home);
float mean;
// now do the processing....
{
const int kThrasherSize = 4000000;
char* thrasher = new char[kThrasherSize];
bool isDone = false;
UInt32 numMeasures = 0;
Float64 totalMSqrd = 0;
Float64 totalM = 0;
int i = 0;
int discardResults = 3;
// this is the render loop
while (!isDone)
{
bool isSilence, postProcess;
outputList.Prepare(); // have to do this every time...
readBuf->lastInputFrames = 0;
sLastReadTime = 0;
memset (thrasher, numMeasures, kThrasherSize);
UInt64 now = CAHostTimeBase::GetTheCurrentTime();
require_noerr (result = processor.Render (outputList.ABL(), numFrames, isSilence, &isDone, &postProcess), home);
UInt64 renderTime = (CAHostTimeBase::GetTheCurrentTime() - now);
if (i++ < discardResults) continue;
if (!readBuf->lastInputFrames) break;
Float64 renderTimeSecs = CAHostTimeBase::ConvertToNanos (renderTime - sLastReadTime) / 1.0e9;
Float64 cpuTime = (renderTimeSecs / (readBuf->lastInputFrames / procFormat.mSampleRate)) * 100.;
numMeasures++;
totalMSqrd += (cpuTime * cpuTime);
totalM += cpuTime;
if (cpuTime > sMaxTime)
sMaxTime = cpuTime;
if (cpuTime < sMinTime)
sMinTime = cpuTime;
#if VERBOSE
// printf ("current measure: %.2f\n", cpuTime);
if (numMeasures % 5 == 0) {
Float64 mean = totalM / numMeasures;
// stdDev = (sum of Xsquared -((sum of X)*(sum of X)/N)) / (N-1))
Float64 stdDev = sqrt ((totalMSqrd - ((totalM * totalM) / numMeasures)) / (numMeasures-1.0));
printf ("ave: %.2f, min: %.2f, max: %.2f, stdev: %.2f, numMeasures: %ld, current: %f\n",
mean, sMinTime, sMaxTime, stdDev, numMeasures, cpuTime);
}
#endif
}
delete [] thrasher;
mean = totalM / numMeasures;
// stdDev = (sum of Xsquared -((sum of X)*(sum of X)/N)) / (N-1))
Float64 stdDev = sqrt ((totalMSqrd - ((totalM * totalM) / numMeasures)) / (numMeasures-1.0));
printf ("ave: %.2f, min: %.2f, max: %.2f, sd: %.2f, sd / mean: %.2f%%\n",
mean, sMinTime, sMaxTime, stdDev, (stdDev / mean * 100.));
}
// we don't care about post-processing
home:
if (result) {
printf ("Exit with bad result:%ld\n", result);
exit(result);
}
if (readBuf) {
delete readBuf->readData;
delete readBuf;
}
CFStringRef str = comp.GetCompName();
UInt32 compNameLen = CFStringGetLength (str);
CFStringRef presetName = NULL;
if (auPresetFile) {
CFPropertyListRef dict;
if (processor.AU().GetAUPreset (dict) == noErr) {
presetName = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)dict, CFSTR("name"));
CFRelease (dict);
}
}
UInt32 presetLen = presetName ? CFStringGetLength(presetName) : 0;
UInt32 groupID = comp.Desc().componentSubType;
char* cstr = (char*)malloc (compNameLen + presetLen + 2 + 1);
CFStringGetCString (str, cstr, (CFStringGetLength (str) + 1), kCFStringEncodingASCII);
if (presetName) {
cstr[compNameLen] = ':';
cstr[compNameLen+1] = ':';
CFStringGetCString (presetName, cstr + compNameLen + 2, (CFStringGetLength (presetName) + 1), kCFStringEncodingASCII);
int len = strlen(cstr);
for (int i = 0; i < len; ++i)
groupID += cstr[i];
}
PerfResult("AU Profile", EndianU32_NtoB(groupID), cstr, mean, "%realtime");
free (cstr);
}
catch (CAXException &e) {
char buf[256];
printf("Error: %s (%s)\n", e.mOperation, e.FormatError(buf));
exit(1);
}
catch (...) {
printf("An unknown error occurred\n");
exit(1);
}
return 0;
}
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);
}
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);
}
int convertMain (int argc, char * const argv[])
{
#if TARGET_OS_WIN32
QTLicenseRef aacEncoderLicenseRef = nil;
QTLicenseRef amrEncoderLicenseRef = nil;
OSErr localerr;
#endif
int result = 0;
CFURLRef inputFileURL = NULL;
CFURLRef outputFileURL = NULL;
#if TARGET_OS_WIN32
InitializeQTML(0L);
{
OSErr localerr;
const char *licenseDesc = "AAC Encode License Verification";
const char *amrLicenseDesc = "AMR Encode License Verification";
localerr = QTRequestLicensedTechnology("com.apple.quicktimeplayer","com.apple.aacencoder",
(void *)licenseDesc,strlen(licenseDesc),&aacEncoderLicenseRef);
localerr = QTRequestLicensedTechnology("com.apple.quicktimeplayer","1D07EB75-3D5E-4DA6-B749-D497C92B06D8",
(void *)amrLicenseDesc,strlen(amrLicenseDesc),&amrEncoderLicenseRef);
}
#endif
try {
OSType format = 0;
Float64 sampleRate = 0;
AudioFileTypeID outputFileType = kAudioFileCAFType;
UInt32 outputBitRate = 0;
UInt32 outputBitDepth = 0;
ParseArgs (argc, argv, format, sampleRate, outputFileType, inputFileURL, outputFileURL, outputBitDepth, outputBitRate);
// printf ("args:%4.4s, sample rate:%.1f, outputFileType: %4.4s\n", (char*)&format, sampleRate, (char*)&outputFileType);
CAStreamBasicDescription inputFormat;
CAStreamBasicDescription outputFormat;
ConstructOutputFormatFromArgs (inputFileURL, outputFileType, format, sampleRate, inputFormat, outputBitDepth, outputFormat);
printf ("Source File format:\n\t"); inputFormat.Print();
printf ("Dest File format:\n\t"); outputFormat.Print();
result = ConvertFile (inputFileURL, inputFormat, outputFileURL, outputFileType, outputFormat, outputBitRate);
CFStringRef path = CFURLCopyPath(outputFileURL);
printf("done: "); fflush(stdout); CFShow(path);
if (path) CFRelease(path);
} catch (CAXException e) {
char buf[256];
fprintf(stderr, "Error in: %s\nException thrown: %s\n", e.mOperation, e.FormatError(buf));
result = 1;
} catch (...) {
fprintf(stderr, "Unspecified exception\n");
result = 1;
}
if (inputFileURL) CFRelease(inputFileURL);
if (outputFileURL) CFRelease(outputFileURL);
#if TARGET_OS_WIN32
TerminateQTML();
if (aacEncoderLicenseRef)
{
localerr = QTReleaseLicensedTechnology(aacEncoderLicenseRef);
aacEncoderLicenseRef = nil;
}
if(amrEncoderLicenseRef)
{
localerr = QTReleaseLicensedTechnology(amrEncoderLicenseRef);
amrEncoderLicenseRef = nil;
}
#endif
return result;
}
int main(int argc, const char * argv[])
{
setbuf (stdout, NULL);
#if TARGET_OS_MAC
{
thread_extended_policy_data_t theFixedPolicy;
theFixedPolicy.timeshare = false; // set to true for a non-fixed thread
thread_policy_set(pthread_mach_thread_np(pthread_self()),
THREAD_EXTENDED_POLICY,
(thread_policy_t)&theFixedPolicy,
THREAD_EXTENDED_POLICY_COUNT);
// We keep a reference to the spawning thread's priority around (initialized in the constructor),
// and set the importance of the child thread relative to the spawning thread's priority.
thread_precedence_policy_data_t thePrecedencePolicy;
thePrecedencePolicy.importance = 63 - 36;
thread_policy_set(pthread_mach_thread_np(pthread_self()),
THREAD_PRECEDENCE_POLICY,
(thread_policy_t)&thePrecedencePolicy,
THREAD_PRECEDENCE_POLICY_COUNT);
}
#endif
// These are the variables that are set up from the input parsing
char* srcFilePath = NULL;
char* destFilePath = NULL;
char* auPresetFile = NULL;
bool shortMemoryProfile = false;
OSType manu, subType, type = 0;
int userSetFrames = -1;
for (int i = 1; i < argc; ++i)
{
if (strcmp (argv[i], "-au") == 0) {
if ( (i + 3) < argc ) {
StrToOSType (argv[i + 1], type);
StrToOSType (argv[i + 2], subType);
StrToOSType (argv[i + 3], manu);
i += 3;
} else {
printf ("Which Audio Unit:\n%s", usageStr);
exit(1);
}
}
else if (strcmp (argv[i], "-i") == 0) {
srcFilePath = const_cast<char*>(argv[++i]);
}
else if (strcmp (argv[i], "-o") == 0) {
destFilePath = const_cast<char*>(argv[++i]);
}
else if (strcmp (argv[i], "-p") == 0) {
auPresetFile = const_cast<char*>(argv[++i]);
}
else if (strcmp (argv[i], "-m") == 0) {
shortMemoryProfile = true;
}
else if (strcmp (argv[i], "-f") == 0) {
sscanf(argv[++i], "%d", &userSetFrames);
}
else {
printf ("%s\n", usageStr);
exit(1);
}
}
if (!type || !srcFilePath) {
printf ("%s\n", usageStr);
exit(1);
}
if (!destFilePath) {
if (!shortMemoryProfile) {
printf ("%s\n", usageStr);
exit(1);
}
}
// delete pre-existing output file
if (!shortMemoryProfile) {
FSRef destFSRef;
if (FSPathMakeRef((UInt8 *)destFilePath, &destFSRef, NULL) == noErr) {
// output file exists - delete it
if (FSDeleteObject(&destFSRef)) {
printf ("Cannot Delete Output File\n");
exit(1);
}
}
}
CAComponentDescription desc(type, subType, manu);
CFPropertyListRef presetDict = ReadPresetFromPresetFile(auPresetFile);
// the num of frames to use when processing the file with the Render call
UInt32 maxFramesToUse = shortMemoryProfile ? 512 : 32768;
// not set from command line
if (userSetFrames > 0) {
maxFramesToUse = userSetFrames;
}
// in some settings (for instance a delay with 100% feedback) tail time is essentially infinite
// so you should safeguard the final OL render stage (post process) which is aimed at pulling the tail through
// if you want to bypass this completely, just set this to zero.
Float64 maxTailTimeSecs = 10.;
#pragma mark -
#pragma mark __ The driving code
#pragma mark -
try
{
CAComponent comp(desc);
// CAAUProcessor's constructor throws... so make sure the component is valid
if (comp.IsValid() == false) {
printf ("Can't Find Component\n");
desc.Print();
exit(1);
}
CAAUProcessor processor(comp);
processor.AU().Print();
CAAudioFile srcFile;
CAAudioFile destFile;
srcFile.Open(srcFilePath);
CAStreamBasicDescription procFormat (srcFile.GetFileDataFormat());
procFormat.SetCanonical (srcFile.GetFileDataFormat().NumberChannels(), false);
printf ("Processing Format:\n\t");
procFormat.Print();
if (!shortMemoryProfile) {
FSRef parentDir;
CFStringRef filename;
PosixPathToParentFSRefAndName(destFilePath, parentDir, filename);
destFile.CreateNew (parentDir, filename, 'AIFF', srcFile.GetFileDataFormat());
destFile.SetClientFormat (procFormat);
}
srcFile.SetClientFormat (procFormat);
AUOutputBL outputList(procFormat);
ReadBuffer* readBuf = NULL;
#if !CAAF_USE_EXTAUDIOFILE
UInt64 numInputSamples = srcFile.GetNumberPackets();
#else
UInt64 numInputSamples = srcFile.GetNumberFrames();
#endif
if (shortMemoryProfile) {
readBuf = new ReadBuffer;
readBuf->readData = new AUOutputBL(procFormat);
readBuf->readFrames = 0;
UInt32 numFrames = UInt32(procFormat.mSampleRate / 2);
readBuf->readData->Allocate (numFrames); // half a second of audio data
readBuf->readData->Prepare(); // half a second of audio data
// read 1/2 second of audio into this read buffer
srcFile.Read (numFrames, readBuf->readData->ABL());
sInputCallback.inputProc = MemoryInputCallback;
sInputCallback.inputProcRefCon = readBuf;
numInputSamples = numFrames;
}
else {
if (desc.IsFConv()) {
maxFramesToUse = userSetFrames == -1 ? 512 : maxFramesToUse;
// some format converter's can call you several times in small granularities
// so you can't use a large buffer to render or you won't return all of the input data
// this also lessens the final difference between what you should get and what you do
// converter units *really* should have a version that are offline AU's to
// handle this for you.
sInputCallback.inputProc = FConvInputCallback;
} else
sInputCallback.inputProc = InputCallback;
sInputCallback.inputProcRefCon = &srcFile;
}
OSStatus result;
require_noerr (result = processor.EstablishInputCallback (sInputCallback), home);
require_noerr (result = processor.SetMaxFramesPerRender (maxFramesToUse), home);
processor.SetMaxTailTime (maxTailTimeSecs);
require_noerr (result = processor.Initialize (procFormat, numInputSamples), home);
if (presetDict) {
require_noerr (result = processor.SetAUPreset (presetDict), home);
CFRelease (presetDict);
}
// this does ALL of the preflighting.. could be specialise for an OfflineAU type
// to do this piecemeal and do a progress bar by using the OfflineAUPreflight method
require_noerr (result = processor.Preflight (), home);
bool isDone; isDone = false;
bool needsPostProcessing;
bool isSilence;
UInt32 numFrames; numFrames = processor.MaxFramesPerRender();
#if CA_AU_PROFILE_TIME
sReadTime = 0;
sRenderTime = 0;
#endif
PRINT_MARKS();
// this is the render loop
while (!isDone)
{
#if CA_AU_PROFILE_TIME
UInt64 now = CAHostTimeBase::GetTheCurrentTime();
#endif
outputList.Prepare(); // have to do this every time...
require_noerr (result = processor.Render (outputList.ABL(), numFrames, isSilence, &isDone,
&needsPostProcessing), home);
#if CA_AU_PROFILE_TIME
sRenderTime += (CAHostTimeBase::GetTheCurrentTime() - now);
#endif
if (!shortMemoryProfile)
PRINT_PROGRESS(processor.GetOLPercentComplete());
else
PRINT_PROGRESS(((processor.SampleTime() / numInputSamples) * 100.));
if (numFrames && !shortMemoryProfile)
destFile.Write (numFrames, outputList.ABL());
}
// this is the postprocessing if needed
if (!shortMemoryProfile && needsPostProcessing)
{
isDone = false;
numFrames = processor.MaxFramesPerRender();
while (!isDone) {
outputList.Prepare(); // have to do this every time...
#if CA_AU_PROFILE_TIME
UInt64 now = CAHostTimeBase::GetTheCurrentTime();
#endif
require_noerr (result = processor.PostProcess (outputList.ABL(), numFrames,
isSilence, isDone), home);
#if CA_AU_PROFILE_TIME
sRenderTime += (CAHostTimeBase::GetTheCurrentTime() - now);
#endif
PRINT_PROGRESS(processor.GetOLPercentComplete());
if (numFrames && !shortMemoryProfile)
destFile.Write (numFrames, outputList.ABL());
}
}
printf ("\n");
home:
if (result) {
printf ("Exit with bad result:%ld\n", result);
exit(result);
}
if (readBuf) {
delete readBuf->readData;
delete readBuf;
}
#if CA_AU_PROFILE_TIME
if (!shortMemoryProfile) {
// this flushes any remaing data to be written to the disk.
// the source file is closed in its destructor of course
destFile.Close();
// open the file again, to get stats about it for profiling
destFile.Open(destFilePath);
}
SInt64 numWritten;
if (shortMemoryProfile)
numWritten = 0;
else {
#if !CAAF_USE_EXTAUDIOFILE
numWritten = destFile.GetNumberPackets();
#else
numWritten = destFile.GetNumberFrames();
#endif
}
printf ("Read File Time:%.2f secs for %lld packets (%.1f secs), wrote %lld packets\n",
(CAHostTimeBase::ConvertToNanos (sReadTime) / 1.0e9),
numInputSamples,
(numInputSamples / procFormat.mSampleRate),
numWritten);
if (!shortMemoryProfile)
{
#if !CAAF_USE_EXTAUDIOFILE
UInt64 numOutputSamples = destFile.GetNumberPackets();
#else
UInt64 numOutputSamples = destFile.GetNumberFrames();
#endif
if (numOutputSamples == numInputSamples) {
printf ("\tWrote the same number of packets as read\n");
} else {
bool expectationMet = !desc.IsOffline(); // we don't have any expectations for offline AU's
if (processor.LatencySampleCount() || processor.TailSampleCount()) {
if (numOutputSamples - numInputSamples == processor.TailSampleCount())
expectationMet = true;
if (expectationMet)
printf ("Correctly wrote \'Read Size + Tail\'. ");
printf ("AU reports (samples): %ld latency, %ld tail\n",
processor.LatencySampleCount(), processor.TailSampleCount());
}
if (expectationMet == false)
{
if (numOutputSamples > numInputSamples) {
printf ("\tWrote %lld packets (%.2f secs) more than read\n",
(numOutputSamples - numInputSamples),
((numOutputSamples - numInputSamples) / procFormat.mSampleRate));
} else {
printf ("\tRead %lld packets (%.2f secs) more than wrote\n",
(numInputSamples - numOutputSamples),
((numInputSamples - numOutputSamples) / procFormat.mSampleRate));
}
}
}
}
Float64 renderTimeSecs = CAHostTimeBase::ConvertToNanos (sRenderTime - sReadTime) / 1.0e9;
printf ("Total Render Time:%.2f secs, using render slice size of %ld frames\n",
renderTimeSecs, maxFramesToUse);
Float64 cpuUsage;
if (shortMemoryProfile)
cpuUsage = (renderTimeSecs / 0.5) * 100.;
else
cpuUsage = (renderTimeSecs / (numInputSamples / procFormat.mSampleRate)) * 100.;
printf ("CPU Usage for Render Time:%.2f%%\n", cpuUsage);
CFStringRef str = comp.GetCompName();
UInt32 compNameLen = CFStringGetLength (str);
CFStringRef presetName = NULL;
if (auPresetFile) {
CFPropertyListRef dict;
if (processor.AU().GetAUPreset (dict) == noErr) {
presetName = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)dict, CFSTR("name"));
CFRelease (dict);
}
}
UInt32 presetLen = presetName ? CFStringGetLength(presetName) : 0;
char* cstr = (char*)malloc (compNameLen + presetLen + 2 + 1);
CFStringGetCString (str, cstr, (CFStringGetLength (str) + 1), kCFStringEncodingASCII);
if (presetName) {
cstr[compNameLen] = ':';
cstr[compNameLen+1] = ':';
CFStringGetCString (presetName, cstr + compNameLen + 2, (CFStringGetLength (presetName) + 1), kCFStringEncodingASCII);
}
PerfResult("AudioUnitProcess", EndianU32_NtoB(comp.Desc().componentSubType), cstr, cpuUsage, "%realtime");
free (cstr);
#endif
}
catch (CAXException &e) {
char buf[256];
printf("Error: %s (%s)\n", e.mOperation, e.FormatError(buf));
exit(1);
}
catch (...) {
printf("An unknown error occurred\n");
exit(1);
}
return 0;
}
