cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/AU/AUPublic/AUEffectBase/AUEffectBase.cpp

@@ -0,0 +1,463 @@
+/*
+     File: AUEffectBase.cpp 
+ Abstract:  AUEffectBase.h  
+  Version: 1.01 
+  
+ 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) 2012 Apple Inc. All Rights Reserved. 
+  
+*/
+#include "AUEffectBase.h"
+
+/* 
+	This class does not deal as well as it should with N-M effects...
+	
+	The problem areas are (if the channels don't match):
+		ProcessInPlace if the channels don't match - there will be problems if InputChan != OutputChan
+		Bypass - its just passing the buffers through when not processing them
+
+	This will be fixed in a future update...
+*/
+
+//_____________________________________________________________________________
+//
+AUEffectBase::AUEffectBase(	AudioComponentInstance	audioUnit,
+							bool					inProcessesInPlace ) :
+	AUBase(audioUnit, 1, 1),		// 1 in bus, 1 out bus
+	mBypassEffect(false),
+	mParamSRDep (false),
+	mProcessesInPlace(inProcessesInPlace),
+	mMainOutput(NULL), mMainInput(NULL)
+#if TARGET_OS_IPHONE
+	, mOnlyOneKernel(false)
+#endif
+{
+}
+
+//_____________________________________________________________________________
+//
+AUEffectBase::~AUEffectBase()
+{
+	Cleanup();
+}
+
+//_____________________________________________________________________________
+//
+void AUEffectBase::Cleanup()
+{
+	for (KernelList::iterator it = mKernelList.begin(); it != mKernelList.end(); ++it)
+		delete *it;
+		
+	mKernelList.clear();
+	mMainOutput = NULL;
+	mMainInput = NULL;
+}
+
+
+//_____________________________________________________________________________
+//
+OSStatus AUEffectBase::Initialize()
+{
+		// get our current numChannels for input and output
+	SInt16 auNumInputs = (SInt16) GetInput(0)->GetStreamFormat().mChannelsPerFrame;
+	SInt16 auNumOutputs = (SInt16) GetOutput(0)->GetStreamFormat().mChannelsPerFrame;
+
+		// does the unit publish specific information about channel configurations?
+    const AUChannelInfo *auChannelConfigs = NULL;
+    UInt32 numIOconfigs = SupportedNumChannels(&auChannelConfigs);
+
+    if ((numIOconfigs > 0) && (auChannelConfigs != NULL))
+    {
+        bool foundMatch = false;
+        for (UInt32 i = 0; (i < numIOconfigs) && !foundMatch; ++i)
+        {
+            SInt16 configNumInputs = auChannelConfigs[i].inChannels;
+            SInt16 configNumOutputs = auChannelConfigs[i].outChannels;
+            if ((configNumInputs < 0) && (configNumOutputs < 0))
+            {
+					// unit accepts any number of channels on input and output
+                if (((configNumInputs == -1) && (configNumOutputs == -2)) 
+					|| ((configNumInputs == -2) && (configNumOutputs == -1)))
+                {
+				    foundMatch = true;
+					// unit accepts any number of channels on input and output IFF they are the same number on both scopes
+                }
+				else if (((configNumInputs == -1) && (configNumOutputs == -1)) && (auNumInputs == auNumOutputs))
+                {
+				    foundMatch = true;
+					// unit has specified a particular number of channels on both scopes
+                }
+				else
+                    continue;
+            }
+            else
+            {
+					// the -1 case on either scope is saying that the unit doesn't care about the 
+					// number of channels on that scope
+                bool inputMatch = (auNumInputs == configNumInputs) || (configNumInputs == -1);
+                bool outputMatch = (auNumOutputs == configNumOutputs) || (configNumOutputs == -1);
+                if (inputMatch && outputMatch)
+                    foundMatch = true;
+            }
+        }
+        if (!foundMatch)
+            return kAudioUnitErr_FormatNotSupported;
+    }
+    else
+    {
+			// there is no specifically published channel info
+			// so for those kinds of effects, the assumption is that the channels (whatever their number)
+			// should match on both scopes
+        if ((auNumOutputs != auNumInputs) || (auNumOutputs == 0))
+		{
+		    return kAudioUnitErr_FormatNotSupported;
+		}
+    }
+
+    MaintainKernels();
+	
+	mMainOutput = GetOutput(0);
+	mMainInput = GetInput(0);
+	
+	const CAStreamBasicDescription& format = GetStreamFormat(kAudioUnitScope_Output, 0);
+	format.IdentifyCommonPCMFormat(mCommonPCMFormat, NULL);
+	mBytesPerFrame = format.mBytesPerFrame;
+	
+    return noErr;
+}
+
+OSStatus			AUEffectBase::Reset(		AudioUnitScope 		inScope,
+								 				AudioUnitElement 	inElement)
+{
+	for (KernelList::iterator it = mKernelList.begin(); it != mKernelList.end(); ++it) {
+		AUKernelBase *kernel = *it;
+		if (kernel != NULL)
+			kernel->Reset();
+	}
+	
+	return AUBase::Reset(inScope, inElement);
+}
+
+OSStatus			AUEffectBase::GetPropertyInfo (AudioUnitPropertyID	inID,
+												AudioUnitScope					inScope,
+												AudioUnitElement				inElement,
+												UInt32 &						outDataSize,
+												Boolean &						outWritable)
+{
+	if (inScope == kAudioUnitScope_Global) {
+		switch (inID) {
+			case kAudioUnitProperty_BypassEffect:
+				outWritable = true;
+				outDataSize = sizeof (UInt32);
+				return noErr;
+			case kAudioUnitProperty_InPlaceProcessing:
+				outWritable = true;
+				outDataSize = sizeof (UInt32);
+				return noErr;
+		}
+	}
+	return AUBase::GetPropertyInfo (inID, inScope, inElement, outDataSize, outWritable);
+}
+
+
+OSStatus			AUEffectBase::GetProperty (AudioUnitPropertyID 		inID,
+									  AudioUnitScope 					inScope,
+									  AudioUnitElement			 		inElement,
+									  void *							outData)
+{
+	if (inScope == kAudioUnitScope_Global) {
+		switch (inID) {
+			case kAudioUnitProperty_BypassEffect:
+				*((UInt32*)outData) = (IsBypassEffect() ? 1 : 0);
+				return noErr;
+			case kAudioUnitProperty_InPlaceProcessing:
+				*((UInt32*)outData) = (mProcessesInPlace ? 1 : 0);
+				return noErr;
+		}
+	}
+	return AUBase::GetProperty (inID, inScope, inElement, outData);
+}
+
+
+OSStatus			AUEffectBase::SetProperty(		AudioUnitPropertyID inID,
+									   AudioUnitScope 		inScope,
+									   AudioUnitElement 	inElement,
+									   const void *			inData,
+									   UInt32 				inDataSize)
+{
+	if (inScope == kAudioUnitScope_Global) {
+		switch (inID) {
+			case kAudioUnitProperty_BypassEffect:
+			{
+				if (inDataSize < sizeof(UInt32))
+					return kAudioUnitErr_InvalidPropertyValue;
+					
+				bool tempNewSetting = *((UInt32*)inData) != 0;
+					// we're changing the state of bypass
+				if (tempNewSetting != IsBypassEffect()) 
+				{
+					if (!tempNewSetting && IsBypassEffect() && IsInitialized()) // turning bypass off and we're initialized
+						Reset(0, 0);
+					SetBypassEffect (tempNewSetting);
+				}
+				return noErr;
+			}
+			case kAudioUnitProperty_InPlaceProcessing:
+				mProcessesInPlace = (*((UInt32*)inData) != 0);
+				return noErr;
+		}
+	}
+	return AUBase::SetProperty (inID, inScope, inElement, inData, inDataSize);
+}
+ 
+
+void	AUEffectBase::MaintainKernels()
+{
+#if TARGET_OS_IPHONE
+	UInt32 nKernels = mOnlyOneKernel ? 1 : GetNumberOfChannels();
+#else 
+	UInt32 nKernels = GetNumberOfChannels();
+#endif
+	
+	if (mKernelList.size() < nKernels) {
+		mKernelList.reserve(nKernels);
+		for (UInt32 i = mKernelList.size(); i < nKernels; ++i)
+			mKernelList.push_back(NewKernel());
+	} else {
+		while (mKernelList.size() > nKernels) {
+			AUKernelBase *kernel = mKernelList.back();
+			delete kernel;
+			mKernelList.pop_back();
+		}
+	}
+	
+	for(unsigned int i = 0; i < nKernels; i++ )
+	{
+		if(mKernelList[i]) {
+			mKernelList[i]->SetChannelNum (i);
+		}
+	}
+}
+
+bool		AUEffectBase::StreamFormatWritable(	AudioUnitScope					scope,
+												AudioUnitElement				element)
+{
+	return IsInitialized() ? false : true;
+}
+
+OSStatus			AUEffectBase::ChangeStreamFormat(	AudioUnitScope				inScope,
+														AudioUnitElement			inElement,
+														const CAStreamBasicDescription & inPrevFormat,
+														const CAStreamBasicDescription & inNewFormat)
+{
+	OSStatus result = AUBase::ChangeStreamFormat(inScope, inElement, inPrevFormat, inNewFormat);
+	if (result == noErr)
+	{	
+		// for the moment this only dependency we know about
+		// where a parameter's range may change is with the sample rate
+		// and effects are only publishing parameters in the global scope!
+		if (GetParamHasSampleRateDependency() && fnotequal(inPrevFormat.mSampleRate, inNewFormat.mSampleRate))
+			PropertyChanged(kAudioUnitProperty_ParameterList, kAudioUnitScope_Global, 0);
+	}
+
+	return result;
+}
+
+
+// ____________________________________________________________________________
+//
+//	This method is called (potentially repeatedly) by ProcessForScheduledParams()
+//	in order to perform the actual DSP required for this portion of the entire buffer
+//	being processed.  The entire buffer can be divided up into smaller "slices"
+//	according to the timestamps on the scheduled parameters...
+//
+OSStatus		AUEffectBase::ProcessScheduledSlice(	void				*inUserData,
+														UInt32				inStartFrameInBuffer,
+														UInt32				inSliceFramesToProcess,
+														UInt32				inTotalBufferFrames )
+{
+	ScheduledProcessParams	&sliceParams = *((ScheduledProcessParams*)inUserData);
+	
+	AudioUnitRenderActionFlags 	&actionFlags = *sliceParams.actionFlags;
+	AudioBufferList 			&inputBufferList = *sliceParams.inputBufferList;
+	AudioBufferList 			&outputBufferList = *sliceParams.outputBufferList;
+	
+	UInt32 channelSize = inSliceFramesToProcess * mBytesPerFrame;
+		// fix the size of the buffer we're operating on before we render this slice of time
+	for(unsigned int i = 0; i < inputBufferList.mNumberBuffers; i++ ) {
+		inputBufferList.mBuffers[i].mDataByteSize = inputBufferList.mBuffers[i].mNumberChannels * channelSize;
+	}
+
+	for(unsigned int i = 0; i < outputBufferList.mNumberBuffers; i++ ) {
+		outputBufferList.mBuffers[i].mDataByteSize = outputBufferList.mBuffers[i].mNumberChannels * channelSize;
+	}
+		// process the buffer
+	OSStatus result = ProcessBufferLists(actionFlags, inputBufferList, outputBufferList, inSliceFramesToProcess );
+
+		// we just partially processed the buffers, so increment the data pointers to the next part of the buffer to process
+	for(unsigned int i = 0; i < inputBufferList.mNumberBuffers; i++ ) {
+		inputBufferList.mBuffers[i].mData = 
+			(char *)inputBufferList.mBuffers[i].mData + inputBufferList.mBuffers[i].mNumberChannels * channelSize;
+	}
+	
+	for(unsigned int i = 0; i < outputBufferList.mNumberBuffers; i++ ) {
+		outputBufferList.mBuffers[i].mData = 
+			(char *)outputBufferList.mBuffers[i].mData + outputBufferList.mBuffers[i].mNumberChannels * channelSize;
+	}
+	
+	return result;
+}
+
+// ____________________________________________________________________________
+//
+
+OSStatus 	AUEffectBase::Render(	AudioUnitRenderActionFlags &ioActionFlags,
+											const AudioTimeStamp &		inTimeStamp,
+											UInt32						nFrames)
+{
+	if (!HasInput(0))
+		return kAudioUnitErr_NoConnection;
+
+	OSStatus result = noErr;
+
+	result = mMainInput->PullInput(ioActionFlags, inTimeStamp, 0 /* element */, nFrames);
+	
+	if (result == noErr)
+	{
+		if(ProcessesInPlace() && mMainOutput->WillAllocateBuffer())
+		{
+			mMainOutput->SetBufferList(mMainInput->GetBufferList() );
+		}
+
+		if (ShouldBypassEffect())
+		{
+			// leave silence bit alone
+			
+			if(!ProcessesInPlace() )
+			{
+				mMainInput->CopyBufferContentsTo (mMainOutput->GetBufferList());
+			}
+		}
+		else
+		{
+			if(mParamList.size() == 0 )
+			{
+				// this will read/write silence bit
+				result = ProcessBufferLists(ioActionFlags, mMainInput->GetBufferList(), mMainOutput->GetBufferList(), nFrames);
+			}
+			else
+			{
+				// deal with scheduled parameters...
+				
+				AudioBufferList &inputBufferList = mMainInput->GetBufferList();
+				AudioBufferList &outputBufferList = mMainOutput->GetBufferList();
+				
+				ScheduledProcessParams processParams;
+				processParams.actionFlags = &ioActionFlags;
+				processParams.inputBufferList = &inputBufferList;
+				processParams.outputBufferList = &outputBufferList;
+	
+				// divide up the buffer into slices according to scheduled params then
+				// do the DSP for each slice (ProcessScheduledSlice() called for each slice)
+				result = ProcessForScheduledParams(	mParamList,
+													nFrames,
+													&processParams );
+	
+				
+				// fixup the buffer pointers to how they were before we started
+				UInt32 channelSize = nFrames * mBytesPerFrame;
+				for(unsigned int i = 0; i < inputBufferList.mNumberBuffers; i++ ) {
+					UInt32 size = inputBufferList.mBuffers[i].mNumberChannels * channelSize;
+					inputBufferList.mBuffers[i].mData = (char *)inputBufferList.mBuffers[i].mData - size;
+					inputBufferList.mBuffers[i].mDataByteSize = size;
+				}
+				
+				for(unsigned int i = 0; i < outputBufferList.mNumberBuffers; i++ ) {
+					UInt32 size = outputBufferList.mBuffers[i].mNumberChannels * channelSize;
+					outputBufferList.mBuffers[i].mData = (char *)outputBufferList.mBuffers[i].mData - size;
+					outputBufferList.mBuffers[i].mDataByteSize = size;
+				}
+			}
+		}
+	
+		if ( (ioActionFlags & kAudioUnitRenderAction_OutputIsSilence) && !ProcessesInPlace() )
+		{
+			AUBufferList::ZeroBuffer(mMainOutput->GetBufferList() );
+		}
+	}
+	
+	return result;
+}
+
+
+OSStatus	AUEffectBase::ProcessBufferLists(
+									AudioUnitRenderActionFlags &	ioActionFlags,
+									const AudioBufferList &			inBuffer,
+									AudioBufferList &				outBuffer,
+									UInt32							inFramesToProcess )
+{
+	// interleaved (or mono)
+	switch (mCommonPCMFormat) {
+		case CAStreamBasicDescription::kPCMFormatFloat32 :
+			ProcessBufferListsT<Float32>(ioActionFlags, inBuffer, outBuffer, inFramesToProcess);
+			break;
+		case CAStreamBasicDescription::kPCMFormatFixed824 :
+			ProcessBufferListsT<SInt32>(ioActionFlags, inBuffer, outBuffer, inFramesToProcess);
+			break;
+		case CAStreamBasicDescription::kPCMFormatInt16 :
+			ProcessBufferListsT<SInt16>(ioActionFlags, inBuffer, outBuffer, inFramesToProcess);
+			break;
+		default :
+			throw CAException(kAudio_UnimplementedError);
+	}
+	
+	return noErr;
+}
+
+Float64		AUEffectBase::GetSampleRate()
+{
+	return GetOutput(0)->GetStreamFormat().mSampleRate;
+}
+
+UInt32		AUEffectBase::GetNumberOfChannels()
+{
+	return GetOutput(0)->GetStreamFormat().mChannelsPerFrame;
+}
+