13
0
livetrax/libs/appleutility/CoreAudio/PublicUtility/CAAUProcessor.cpp

708 lines
24 KiB
C++
Raw Normal View History

/*
File: CAAUProcessor.cpp
Abstract: CAAUProcessor.h
Version: 1.1
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
Inc. ("Apple") in consideration of your agreement to the following
terms, and your use, installation, modification or redistribution of
this Apple software constitutes acceptance of these terms. If you do
not agree with these terms, please do not use, install, modify or
redistribute this Apple software.
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software.
Neither the name, trademarks, service marks or logos of Apple Inc. may
be used to endorse or promote products derived from the Apple Software
without specific prior written permission from Apple. Except as
expressly stated in this notice, no other rights or licenses, express or
implied, are granted by Apple herein, including but not limited to any
patent rights that may be infringed by your derivative works or by other
works in which the Apple Software may be incorporated.
The Apple Software is provided by Apple on an "AS IS" basis. APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Copyright (C) 2014 Apple Inc. All Rights Reserved.
*/
#include "CAAUProcessor.h"
#include "CAXException.h"
static OSStatus SilenceInputCallback (void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData)
{
AudioBuffer *buf = ioData->mBuffers;
for (UInt32 i = ioData->mNumberBuffers; i--; ++buf)
memset((Byte *)buf->mData, 0, buf->mDataByteSize);
//provide a hint that our input data is silent.
*ioActionFlags &= kAudioUnitRenderAction_OutputIsSilence;
return noErr;
}
static AURenderCallbackStruct sSilentCallback = { SilenceInputCallback, NULL };
CAAUProcessor::CAAUProcessor (const CAComponent& inComp)
: mPreflightABL(NULL)
{
OSStatus result = CAAudioUnit::Open (inComp, mUnit);
if (result)
throw result;
memset (&mUserCallback, 0, sizeof (AURenderCallbackStruct));
mMaxTailTime = 10.;
}
CAAUProcessor::~CAAUProcessor ()
{
if (mPreflightABL)
delete mPreflightABL;
}
inline OSStatus SetInputCallback (CAAudioUnit &inUnit, AURenderCallbackStruct &inInputCallback)
{
return inUnit.SetProperty (kAudioUnitProperty_SetRenderCallback,
kAudioUnitScope_Input,
0,
&inInputCallback,
sizeof(inInputCallback));
}
static AURenderCallbackStruct sRenderCallback;
static OSStatus PrerollRenderProc ( void * /*inRefCon*/,
AudioUnitRenderActionFlags * /*inActionFlags*/,
const AudioTimeStamp * /*inTimeStamp*/,
UInt32 /*inBusNumber*/,
UInt32 /*inNumFrames*/,
AudioBufferList *ioData)
{
AudioBuffer *buf = ioData->mBuffers;
for (UInt32 i = ioData->mNumberBuffers; i--; ++buf)
memset((Byte *)buf->mData, 0, buf->mDataByteSize);
return noErr;
}
OSStatus Preroll (CAAudioUnit & inAU, UInt32 inFrameSize)
{
CAStreamBasicDescription desc;
OSStatus result = inAU.GetFormat (kAudioUnitScope_Input, 0, desc);
bool hasInput = false;
//we have input
if (result == noErr)
{
sRenderCallback.inputProc = PrerollRenderProc;
sRenderCallback.inputProcRefCon = 0;
result = inAU.SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
0, &sRenderCallback, sizeof(sRenderCallback));
if (result) return result;
hasInput = true;
}
AudioUnitRenderActionFlags flags = 0;
AudioTimeStamp time;
memset (&time, 0, sizeof(time));
time.mFlags = kAudioTimeStampSampleTimeValid;
CAStreamBasicDescription outputFormat;
ca_require_noerr (result = inAU.GetFormat (kAudioUnitScope_Output, 0, outputFormat), home);
{
AUOutputBL list (outputFormat, inFrameSize);
list.Prepare ();
result = inAU.Render (&flags, &time, 0, inFrameSize, list.ABL());
if (result) { printf("A result %d\n", (int)result); goto home; }
}
home:
if (hasInput) {
// remove our installed callback
sRenderCallback.inputProc = 0;
sRenderCallback.inputProcRefCon = 0;
inAU.SetProperty (kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
0, &sRenderCallback, sizeof(sRenderCallback));
}
return result;
}
OSStatus CAAUProcessor::EstablishInputCallback (AURenderCallbackStruct &inInputCallback)
{
OSStatus result = SetInputCallback (mUnit, inInputCallback);
if (!result)
memcpy (&mUserCallback, &inInputCallback, sizeof(AURenderCallbackStruct));
else
memset (&mUserCallback, 0, sizeof (AURenderCallbackStruct));
return result;
}
OSStatus CAAUProcessor::SetAUPreset (CFPropertyListRef inPreset)
{
return mUnit.SetProperty (kAudioUnitProperty_ClassInfo,
kAudioUnitScope_Global,
0,
&inPreset,
sizeof(inPreset));
}
OSStatus CAAUProcessor::SetAUPresetIndex (SInt32 inPresetIndex)
{
AUPreset aup;
aup.presetName = NULL;
aup.presetNumber = inPresetIndex;
return mUnit.SetPresentPreset(aup);
}
OSStatus CAAUProcessor::SetParameter (AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
Float32 value, UInt32 bufferOffsetFrames)
{
return mUnit.SetParameter(inID, scope, element, value, bufferOffsetFrames);
}
UInt32 CAAUProcessor::MaxFramesPerRender () const
{
UInt32 maxFrames;
UInt32 propSize = sizeof (maxFrames);
if (mUnit.GetProperty (kAudioUnitProperty_MaximumFramesPerSlice,
kAudioUnitScope_Global, 0, &maxFrames, &propSize))
{
return 0;
}
return maxFrames;
}
OSStatus CAAUProcessor::SetMaxFramesPerRender (UInt32 inMaxFrames)
{
return mUnit.SetProperty (kAudioUnitProperty_MaximumFramesPerSlice,
kAudioUnitScope_Global, 0, &inMaxFrames, sizeof(inMaxFrames));
}
OSStatus CAAUProcessor::Initialize (const CAStreamBasicDescription &inInputDesc,
const CAStreamBasicDescription &inOutputDesc,
UInt64 inNumInputSamples)
{
return DoInitialisation (inInputDesc, inOutputDesc, inNumInputSamples, MaxFramesPerRender());
}
OSStatus CAAUProcessor::Reinitialize (UInt32 inNewMaxFrames)
{
OSStatus result;
CAStreamBasicDescription inputDesc, outputDesc;
ca_require_noerr (result = mUnit.GetFormat (kAudioUnitScope_Input, 0, inputDesc), home);
ca_require_noerr (result = mUnit.GetFormat (kAudioUnitScope_Output, 0, outputDesc), home);
ca_require_noerr (result = DoInitialisation (inputDesc, outputDesc, mNumInputSamples, inNewMaxFrames), home);
home:
return result;
}
OSStatus CAAUProcessor::DoInitialisation (const CAStreamBasicDescription &inInputFormat,
const CAStreamBasicDescription &inOutputFormat,
UInt64 inNumInputSamples,
UInt32 inMaxFrames)
{
OSStatus result;
if (inNumInputSamples == 0 && IsOfflineAU())
return kAudioUnitErr_InvalidOfflineRender;
mNumInputSamples = inNumInputSamples;
// first check that we can do this number of channels
if (mUnit.CanDo (inInputFormat.NumberChannels(), inOutputFormat.NumberChannels()) == false)
ca_require_noerr (result = kAudioUnitErr_FailedInitialization, home);
// just uninitialise the AU as a matter of course
ca_require_noerr (result = mUnit.Uninitialize(), home);
ca_require_noerr (result = mUnit.SetFormat (kAudioUnitScope_Input, 0, inInputFormat), home);
ca_require_noerr (result = mUnit.SetFormat (kAudioUnitScope_Output, 0, inOutputFormat), home);
ca_require_noerr (result = SetMaxFramesPerRender (inMaxFrames), home);
#if !TARGET_OS_IPHONE
// if we're any AU but an offline AU, we should tell it that we've processing offline
if (!IsOfflineAU()) {
UInt32 isOffline = (IsOfflineContext() ? 1 : 0);
// don't care whether this succeeds of fails as many AU's don't care about this
// but the ones that do its important that they are told their render context
mUnit.SetProperty (kAudioUnitProperty_OfflineRender, kAudioUnitScope_Global, 0, &isOffline, sizeof(isOffline));
} else {
// tell the offline unit how many input samples we wish to process...
mUnit.SetProperty (kAudioUnitOfflineProperty_InputSize,
kAudioUnitScope_Global, 0,
&mNumInputSamples, sizeof(mNumInputSamples));
}
#endif
ca_require_noerr (result = mUnit.Initialize(), home);
ca_require_noerr (result = SetInputCallback (mUnit, mUserCallback), home);
// finally reset our time stamp
// the time stamp we use with the AU Render - only sample count is valid
memset (&mRenderTimeStamp, 0, sizeof(mRenderTimeStamp));
mRenderTimeStamp.mFlags = kAudioTimeStampSampleTimeValid;
// now, if we're NOT an offline AU, preflighting is not required
// if we are an offline AU, we should preflight.. an offline AU will tell us when its preflighting is done
mPreflightDone = false;
if (mPreflightABL) {
delete mPreflightABL;
mPreflightABL = NULL;
}
mPreflightABL = new AUOutputBL (inOutputFormat);
mLastPercentReported = 0;
home:
return result;
}
void CAAUProcessor::CalculateRemainderSamples (Float64 inSampleRate)
{
mLatencySamples = 0;
mTailSamplesToProcess = 0;
mTailSamples = 0;
mTailSamplesRemaining = 0;
return;
// nothing to do because we're not processing offline
if (IsOfflineContext() == false) return;
// because an offline unit has some indeterminancy about what it does with the input samples
// it is *required* to deal internally with both latency and tail
if (!IsOfflineAU())
{
// when offline we need to deal with both latency and tail
// if the AU has latency - how many samples at the start will be zero?
// we'll end up chucking these away.
Float64 renderTimeProps;
UInt32 propSize = sizeof (renderTimeProps);
OSStatus result = mUnit.GetProperty (kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0,
&renderTimeProps, &propSize);
Float64 latencySamples = 0;
if (result == noErr) // we have latency to deal with - its reported in seconds
latencySamples = renderTimeProps * inSampleRate;
// AU tail
// if the AU has a tail - we'll pull that many zeroes through at the end to flush
// out this tail - think of a decaying digital delay or reverb...
result = mUnit.GetProperty (kAudioUnitProperty_TailTime, kAudioUnitScope_Global, 0,
&renderTimeProps, &propSize);
if (renderTimeProps > mMaxTailTime)
renderTimeProps = mMaxTailTime;
Float64 tailSamples = 0;
if (result == noErr)
tailSamples = renderTimeProps * inSampleRate;
// this dictates how many samples at the end we need to pull through...
// we add latency to tail because we throw the latency samples away from the start of the rendering
// and we have to pull that many samples after the end of course to get the last of the original data
// then to that is added the tail of the effect...
mTailSamplesToProcess = UInt32(tailSamples + latencySamples);
mTailSamples = UInt32(tailSamples);
mLatencySamples = UInt32(latencySamples);
}
}
#if !TARGET_OS_IPHONE
CFStringRef CAAUProcessor::GetOLPreflightName () const
{
if (OfflineAUNeedsPreflight())
{
CFStringRef str;
UInt32 size = sizeof(str);
OSStatus result = mUnit.GetProperty (kAudioUnitOfflineProperty_PreflightName,
kAudioUnitScope_Global, 0,
&str, &size);
return result ? NULL : str;
}
return NULL; // says NO to preflighting
}
bool CAAUProcessor::OfflineAUNeedsPreflight () const
{
if (IsOfflineAU()) {
UInt32 preflightRequirements;
UInt32 size = sizeof(preflightRequirements);
OSStatus result = mUnit.GetProperty (kAudioUnitOfflineProperty_PreflightRequirements,
kAudioUnitScope_Global, 0,
&preflightRequirements, &size);
if (result)
return false;
return preflightRequirements;
}
return false;
}
#endif
OSStatus CAAUProcessor::Preflight (bool inProcessPreceedingTail)
{
printf(">>>>CAAUProcessor::Preflight\n");
//we're preflighting again, so reset ourselves
if (mPreflightDone) {
mPreflightDone = false;
// the time stamp we use with the AU Render - only sample count is valid
memset (&mRenderTimeStamp, 0, sizeof(mRenderTimeStamp));
mRenderTimeStamp.mFlags = kAudioTimeStampSampleTimeValid;
mUnit.GlobalReset();
}
Float64 sampleRate;
OSStatus result = mUnit.GetSampleRate (kAudioUnitScope_Output, 0, sampleRate);
CalculateRemainderSamples (sampleRate);
UInt32 numFrames = MaxFramesPerRender();
if (numFrames == 0)
return kAudioUnitErr_InvalidProperty;
if (!IsOfflineAU())
{
if ((IsOfflineContext() == false && inProcessPreceedingTail) || IsOfflineContext())
{
// re-establish the user's input callback
ca_require_noerr (result = SetInputCallback (mUnit, mUserCallback), home);
// Consume the number of input samples indicated by the AU's latency or tail
// based on whether the AU is being used in an offline context or not.
UInt32 latSamps = IsOfflineContext() ? mLatencySamples : mTailSamples;
printf("latSamps %d\n", (int)latSamps);
latSamps = 0;
while (latSamps > 0)
{
if (latSamps < numFrames)
numFrames = latSamps;
// process the samples (the unit's input callback will read the samples
// from the file and convert them to float for processing
AudioUnitRenderActionFlags renderFlags = 0;
mPreflightABL->Prepare();
result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, numFrames, mPreflightABL->ABL());
if (result) { printf("B result %d\n", (int)result); goto home; }
mRenderTimeStamp.mSampleTime += numFrames;
latSamps -= numFrames;
}
if (IsOfflineContext())
mRenderTimeStamp.mSampleTime = mLatencySamples;
}
else
{
// processing real-time but not processing preceeding tail, so we should preroll the AU
ca_require_noerr (result = Preroll(mUnit, numFrames), home);
// re-establish the user's input callback
ca_require_noerr (result = SetInputCallback (mUnit, mUserCallback), home);
mRenderTimeStamp.mSampleTime = 0;
}
}
#if !TARGET_OS_IPHONE
else
{
// re-establish the user's input callback
ca_require_noerr (result = SetInputCallback (mUnit, mUserCallback), home);
UInt32 preflightRequirements;
UInt32 size; size = sizeof(preflightRequirements);
ca_require_noerr (result = mUnit.GetProperty (kAudioUnitOfflineProperty_PreflightRequirements,
kAudioUnitScope_Global, 0,
&preflightRequirements, &size), home);
// 0 indicates none, otherwise optional or required -> we do it for either
if (preflightRequirements)
{
for (;;) {
// here we need to do the preflight loop - we don't expect any data back, but have to
// give the offline unit all of its input data to allow it to prepare its processing
AudioUnitRenderActionFlags renderFlags = kAudioOfflineUnitRenderAction_Preflight;
mPreflightABL->Prepare();
result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, numFrames, mPreflightABL->ABL());
if (result) { printf("C result %d\n", (int)result); goto home; }
mRenderTimeStamp.mSampleTime += numFrames;
if (renderFlags & kAudioOfflineUnitRenderAction_Complete)
break;
}
}
// the time stamp we use with the AU Render - only sample count is valid
mRenderTimeStamp.mSampleTime = 0;
}
#endif
if (result == noErr) {
mPreflightDone = true;
}
home:
printf("<<<<CAAUProcessor::Preflight\n");
return result;
}
#if !TARGET_OS_IPHONE
OSStatus CAAUProcessor::OfflineAUPreflight (UInt32 inNumFrames, bool &outIsDone)
{
if (!IsOfflineAU())
return -50/*paramErr*/;
if (mNumInputSamples == 0)
return -50/*paramErr*/;
UInt32 preflightRequirements;
UInt32 size = sizeof(preflightRequirements);
OSStatus result;
ca_require_noerr (result = mUnit.GetProperty (kAudioUnitOfflineProperty_PreflightRequirements,
kAudioUnitScope_Global, 0,
&preflightRequirements, &size), home);
// 0 indicates none, otherwise optional or required -> we do it for either
if (preflightRequirements)
{
AudioUnitRenderActionFlags renderFlags = kAudioOfflineUnitRenderAction_Preflight;
mPreflightABL->Prepare();
result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, inNumFrames, mPreflightABL->ABL());
if (result) { printf("D result %d\n", (int)result); goto home; }
mRenderTimeStamp.mSampleTime += inNumFrames;
if (renderFlags & kAudioOfflineUnitRenderAction_Complete) {
outIsDone = true;
mRenderTimeStamp.mSampleTime = 0;
mPreflightDone = true;
mLastPercentReported = 0;
}
}
else
{
outIsDone = true;
mRenderTimeStamp.mSampleTime = 0;
mPreflightDone = true;
mLastPercentReported = 0;
}
home:
return result;
}
#endif
void SetBufferListToNumFrames (AudioBufferList &list, UInt32 inNumFrames)
{
for (unsigned int i = 0; i < list.mNumberBuffers; ++i) {
AudioBuffer &buf = list.mBuffers[i];
if (buf.mDataByteSize > 0)
buf.mDataByteSize = inNumFrames * sizeof (Float32);
}
}
OSStatus CAAUProcessor::Render (AudioBufferList *ioData,
UInt32 &ioNumFrames,
bool &outIsSilence,
bool *outOLCompleted,
bool *outOLRequiresPostProcess)
{
if (IsOfflineContext())
{
if (!mPreflightDone)
return kAudioUnitErr_InvalidOfflineRender;
// YES - this is correct!!! you have to provide both if rendering in an offline Context
*outOLCompleted = false;
*outOLRequiresPostProcess = false;
if (!IsOfflineAU() && !mUnit.Comp().Desc().IsFConv())
{
// have we processed the input we expect too?
// in an offline case, we want to create output that matches the input
// for an OfflineAU type, it manages this internally, so we don't have to do anything
// for a FormatConverter AU, we don't know and can't tell, so we can't do anything here
// for any other AU type (effect, instrument) the Prime assumption is that it will
// ask for the same number of frames of input as it is asked to output
// so we can ask what it is doing, and get a sample accurate output (which is input + tail time)
if (mRenderTimeStamp.mSampleTime + ioNumFrames >= InputSampleCount())
{
// if we fall into here, we have just a partial number of input samples left
// (less input less than what we've been asked to produce output for.
*outOLCompleted = true;
// we require post processing if we've got some tail (or latency) samples to flush through
*outOLRequiresPostProcess = mTailSamplesToProcess > 0;
if (InputSampleCount() > mRenderTimeStamp.mSampleTime) {
ioNumFrames = (UInt32)(InputSampleCount() - mRenderTimeStamp.mSampleTime);
} else {
ioNumFrames = 0;
}
mTailSamplesRemaining = mTailSamplesToProcess;
// we've got no input samples to process this time.
SetBufferListToNumFrames (*ioData, ioNumFrames);
if (ioNumFrames == 0) {
if (*outOLRequiresPostProcess)
SetInputCallback (mUnit, sSilentCallback);
else
mUnit.GlobalReset (); //flush this out, as we're done with this phase
return noErr;
}
}
}
AudioUnitRenderActionFlags renderFlags = IsOfflineAU() ? kAudioOfflineUnitRenderAction_Render : 0;
OSStatus result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, ioNumFrames, ioData);
if (result) { printf("E result %d\n", (int)result); }
if (result) {
if (mUnit.Comp().Desc().IsFConv()) {
// this is the only way we can tell we're done with a FormatConverter AU
// - ie. client returns an error from input
result = noErr;
*outOLCompleted = true;
*outOLRequiresPostProcess = mTailSamplesToProcess > 0;
ioNumFrames = 0;
SetBufferListToNumFrames (*ioData, ioNumFrames);
} else
return result;
}
// for (UInt32 i = 0; i < ioNumFrames; ++i) {
// union {
// float f;
// unsigned char c[4];
// } u;
// u.f = ((float*)(ioData->mBuffers[0].mData))[i];
// printf("aup out %4d %14.10f %02X %02X %02X %02X\n", (int)i, u.f, u.c[0], u.c[1], u.c[2], u.c[3]);
// }
mRenderTimeStamp.mSampleTime += ioNumFrames;
outIsSilence = (renderFlags & kAudioUnitRenderAction_OutputIsSilence);
// if we're an Offline AU type, it will set this flag on completion of its processing
if (renderFlags & kAudioOfflineUnitRenderAction_Complete) {
// we now need to calculate how many frames we rendered.
// as we're dealing with PCM non-interleaved buffers, we can calculate the numFrames simply
ioNumFrames = ioData->mBuffers[0].mDataByteSize / sizeof(Float32);
*outOLCompleted = true;
*outOLRequiresPostProcess = false;
mUnit.GlobalReset (); //flush this out, as we're done with this phase
} else {
if (*outOLCompleted) {
if (*outOLRequiresPostProcess)
result = SetInputCallback (mUnit, sSilentCallback);
else
mUnit.GlobalReset (); //flush this out, as we're done with this phase
}
}
return result;
}
// rendering in a RT context:
AudioUnitRenderActionFlags renderFlags = 0;
OSStatus result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, ioNumFrames, ioData);
if (result) { printf("F result %d\n", (int)result); }
if (!result) {
mRenderTimeStamp.mSampleTime += ioNumFrames;
outIsSilence = (renderFlags & kAudioUnitRenderAction_OutputIsSilence);
}
// for (UInt32 i = 0; i < ioNumFrames; ++i) {
// union {
// float f;
// unsigned char c[4];
// } u;
// u.f = ((float*)(ioData->mBuffers[0].mData))[i];
// printf("aup out %4d %14.10f %02X %02X %02X %02X\n", (int)i, u.f, u.c[0], u.c[1], u.c[2], u.c[3]);
// }
return result;
}
OSStatus CAAUProcessor::PostProcess (AudioBufferList *ioData,
UInt32 &ioNumFrames,
bool &outIsSilence,
bool &outDone)
{
if (IsOfflineAU() || !IsOfflineContext())
return kAudioUnitErr_CannotDoInCurrentContext;
outDone = false;
// we've got less samples to process than we've been asked to process
if (mTailSamplesRemaining <= SInt32(ioNumFrames)) {
outDone = true;
ioNumFrames = mTailSamplesRemaining > 0 ? mTailSamplesRemaining : 0;
SetBufferListToNumFrames (*ioData, ioNumFrames);
if (ioNumFrames == 0)
return noErr;
}
AudioUnitRenderActionFlags renderFlags = 0;
OSStatus result;
result = mUnit.Render (&renderFlags, &mRenderTimeStamp, 0, ioNumFrames, ioData);
if (result) { printf("G result %d\n", (int)result); goto home; }
mRenderTimeStamp.mSampleTime += ioNumFrames;
mTailSamplesRemaining -= ioNumFrames;
outIsSilence = (renderFlags & kAudioUnitRenderAction_OutputIsSilence);
if (outDone) {
ca_require_noerr (result = SetInputCallback (mUnit, mUserCallback), home);
mUnit.GlobalReset (); //flush this out, as we're done with this phase
}
home:
return result;
}
#if !TARGET_OS_IPHONE
Float32 CAAUProcessor::GetOLPercentComplete ()
{
if (!IsOfflineContext())
return 0;
Float32 percentDone = mLastPercentReported;
if (IsOfflineAU())
{
// we get the output size every time, as this can change as parameters are changed
UInt64 numOutputSamples = mNumInputSamples;
UInt32 propSize = sizeof(numOutputSamples);
mUnit.GetProperty (kAudioUnitOfflineProperty_OutputSize,
kAudioUnitScope_Global, 0, &numOutputSamples, &propSize);
percentDone = (mRenderTimeStamp.mSampleTime / Float64(numOutputSamples)) * 100.;
}
else
{
percentDone = (mRenderTimeStamp.mSampleTime / Float64(mNumInputSamples + mTailSamples)) * 100.;
}
if (percentDone > mLastPercentReported)
mLastPercentReported = percentDone;
return mLastPercentReported;
}
#endif