AUEffectBase.cpp

/*!
	@file		AudioUnitSDK/AUEffectBase.cpp
	@copyright	© 2000-2021 Apple Inc. All rights reserved.
*/
#include <AudioUnitSDK/AUEffectBase.h>

#include <cstddef>

/*
	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
*/

namespace ausdk {

//_____________________________________________________________________________
//
AUEffectBase::AUEffectBase(AudioComponentInstance audioUnit, bool inProcessesInPlace)
	: AUBase(audioUnit, 1, 1), // 1 in bus, 1 out bus
	  mProcessesInPlace(inProcessesInPlace)
#if TARGET_OS_IPHONE
	  ,
	  mOnlyOneKernel(false)
#endif
{
}

//_____________________________________________________________________________
//
void AUEffectBase::Cleanup()
{
	mKernelList.clear();
	mMainOutput = nullptr;
	mMainInput = nullptr;
}


//_____________________________________________________________________________
//
OSStatus AUEffectBase::Initialize()
{
	// get our current numChannels for input and output
	const auto auNumInputs = static_cast<SInt16>(Input(0).GetStreamFormat().mChannelsPerFrame);
	const auto auNumOutputs = static_cast<SInt16>(Output(0).GetStreamFormat().mChannelsPerFrame);

	// does the unit publish specific information about channel configurations?
	const AUChannelInfo* auChannelConfigs = nullptr;
	const UInt32 numIOconfigs = SupportedNumChannels(&auChannelConfigs);

	if ((numIOconfigs > 0) && (auChannelConfigs != nullptr)) {
		bool foundMatch = false;
		for (UInt32 i = 0; (i < numIOconfigs) && !foundMatch; ++i) {
			const SInt16 configNumInputs = auChannelConfigs[i].inChannels;   // NOLINT
			const SInt16 configNumOutputs = auChannelConfigs[i].outChannels; // NOLINT
			if ((configNumInputs < 0) && (configNumOutputs < 0)) {
				// unit accepts any number of channels on input and output
				if (((configNumInputs == -1) && (configNumOutputs == -2)) ||
					((configNumInputs == -2) &&
						(configNumOutputs == -1))) { // NOLINT repeated branch below
					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
				const bool inputMatch = (auNumInputs == configNumInputs) || (configNumInputs == -1);
				const 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 = &Output(0);
	mMainInput = &Input(0);

	const AudioStreamBasicDescription format = GetStreamFormat(kAudioUnitScope_Output, 0);
	mBytesPerFrame = format.mBytesPerFrame;

	return noErr;
}

OSStatus AUEffectBase::Reset(AudioUnitScope inScope, AudioUnitElement inElement)
{
	for (auto& kernel : mKernelList) {
		if (kernel) {
			kernel->Reset();
		}
	}

	return AUBase::Reset(inScope, inElement);
}

OSStatus AUEffectBase::GetPropertyInfo(AudioUnitPropertyID inID, AudioUnitScope inScope,
	AudioUnitElement inElement, UInt32& outDataSize, bool& outWritable)
{
	if (inScope == kAudioUnitScope_Global) {
		switch (inID) {
		case kAudioUnitProperty_BypassEffect:
		case kAudioUnitProperty_InPlaceProcessing:
			outWritable = true;
			outDataSize = sizeof(UInt32);
			return noErr;
		default:
			break;
		}
	}
	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:
			*static_cast<UInt32*>(outData) = (IsBypassEffect() ? 1 : 0); // NOLINT
			return noErr;
		case kAudioUnitProperty_InPlaceProcessing:
			*static_cast<UInt32*>(outData) = (mProcessesInPlace ? 1 : 0); // NOLINT
			return noErr;
		default:
			break;
		}
	}
	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;
			}

			const bool tempNewSetting = *static_cast<const 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(kAudioUnitScope_Global, 0);
				}
				SetBypassEffect(tempNewSetting);
			}
			return noErr;
		}
		case kAudioUnitProperty_InPlaceProcessing:
			mProcessesInPlace = *static_cast<const UInt32*>(inData) != 0;
			return noErr;
		default:
			break;
		}
	}
	return AUBase::SetProperty(inID, inScope, inElement, inData, inDataSize);
}


void AUEffectBase::MaintainKernels()
{
#if TARGET_OS_IPHONE
	const UInt32 nKernels = mOnlyOneKernel ? 1 : GetNumberOfChannels();
#else
	const UInt32 nKernels = GetNumberOfChannels();
#endif

	if (mKernelList.size() < nKernels) {
		mKernelList.reserve(nKernels);
		for (auto i = static_cast<UInt32>(mKernelList.size()); i < nKernels; ++i) {
			mKernelList.push_back(NewKernel());
		}
	} else {
		while (mKernelList.size() > nKernels) {
			mKernelList.pop_back();
		}
	}

	for (UInt32 i = 0; i < nKernels; i++) {
		if (mKernelList[i]) {
			mKernelList[i]->SetChannelNum(i);
		}
	}
}

bool AUEffectBase::StreamFormatWritable(AudioUnitScope /*scope*/, AudioUnitElement /*element*/)
{
	return !IsInitialized();
}

OSStatus AUEffectBase::ChangeStreamFormat(AudioUnitScope inScope, AudioUnitElement inElement,
	const AudioStreamBasicDescription& inPrevFormat, const AudioStreamBasicDescription& inNewFormat)
{
	const 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() &&
			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*/)
{
	const ScheduledProcessParams& sliceParams = *static_cast<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 (UInt32 i = 0; i < inputBufferList.mNumberBuffers; i++) {
		inputBufferList.mBuffers[i].mDataByteSize =                    // NOLINT
			inputBufferList.mBuffers[i].mNumberChannels * channelSize; // NOLINT
	}

	for (UInt32 i = 0; i < outputBufferList.mNumberBuffers; i++) {
		outputBufferList.mBuffers[i].mDataByteSize =                    // NOLINT
			outputBufferList.mBuffers[i].mNumberChannels * channelSize; // NOLINT
	}
	// process the buffer
	const 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 (UInt32 i = 0; i < inputBufferList.mNumberBuffers; i++) {
		inputBufferList.mBuffers[i].mData =                              // NOLINT
			static_cast<std::byte*>(inputBufferList.mBuffers[i].mData) + // NOLINT
			inputBufferList.mBuffers[i].mNumberChannels * channelSize;   // NOLINT
	}

	for (UInt32 i = 0; i < outputBufferList.mNumberBuffers; i++) {
		outputBufferList.mBuffers[i].mData =                              // NOLINT
			static_cast<std::byte*>(outputBufferList.mBuffers[i].mData) + // NOLINT
			outputBufferList.mBuffers[i].mNumberChannels * channelSize;   // NOLINT
	}

	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 {
			auto& paramEventList = GetParamEventList();

			if (paramEventList.empty()) {
				// 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{ .actionFlags = &ioActionFlags,
					.inputBufferList = &inputBufferList,
					.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(paramEventList, nFrames, &processParams);


				// fixup the buffer pointers to how they were before we started
				const UInt32 channelSize = nFrames * mBytesPerFrame;
				for (UInt32 i = 0; i < inputBufferList.mNumberBuffers; i++) {
					const UInt32 size =
						inputBufferList.mBuffers[i].mNumberChannels * channelSize;         // NOLINT
					inputBufferList.mBuffers[i].mData =                                    // NOLINT
						static_cast<std::byte*>(inputBufferList.mBuffers[i].mData) - size; // NOLINT
					inputBufferList.mBuffers[i].mDataByteSize = size;                      // NOLINT
				}

				for (UInt32 i = 0; i < outputBufferList.mNumberBuffers; i++) {
					const UInt32 size =
						outputBufferList.mBuffers[i].mNumberChannels * channelSize; // NOLINT
					outputBufferList.mBuffers[i].mData =                            // NOLINT
						static_cast<std::byte*>(outputBufferList.mBuffers[i].mData) -
						size;                                          // NOLINT
					outputBufferList.mBuffers[i].mDataByteSize = size; // NOLINT
				}
			}
		}

		if (((ioActionFlags & kAudioUnitRenderAction_OutputIsSilence) != 0u) &&
			!ProcessesInPlace()) {
			AUBufferList::ZeroBuffer(mMainOutput->GetBufferList());
		}
	}

	return result;
}


OSStatus AUEffectBase::ProcessBufferLists(AudioUnitRenderActionFlags& ioActionFlags,
	const AudioBufferList& inBuffer, AudioBufferList& outBuffer, UInt32 inFramesToProcess)
{
	if (ShouldBypassEffect()) {
		return noErr;
	}

	bool ioSilence = false;

	const bool silentInput = IsInputSilent(ioActionFlags, inFramesToProcess);
	ioActionFlags |= kAudioUnitRenderAction_OutputIsSilence;

	for (UInt32 channel = 0; channel < mKernelList.size(); ++channel) {
		auto& kernel = mKernelList[channel];

		if (!kernel) {
			continue;
		}

		ioSilence = silentInput;
		const AudioBuffer* const srcBuffer = &inBuffer.mBuffers[channel]; // NOLINT subscript
		AudioBuffer* const destBuffer = &outBuffer.mBuffers[channel];     // NOLINT subscript

		kernel->Process(static_cast<const Float32*>(srcBuffer->mData),
			static_cast<Float32*>(destBuffer->mData), inFramesToProcess, ioSilence);

		if (!ioSilence) {
			ioActionFlags &= ~kAudioUnitRenderAction_OutputIsSilence;
		}
	}

	return noErr;
}

Float64 AUEffectBase::GetSampleRate() { return Output(0).GetStreamFormat().mSampleRate; }

UInt32 AUEffectBase::GetNumberOfChannels() { return Output(0).GetStreamFormat().mChannelsPerFrame; }

} // namespace ausdk