izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
37ee46717bee40f62400428e2c17408cddc167ec
UnrealEngineUWP/Engine/Source/Runtime/SignalProcessing/Private/BufferVectorOperations.cpp
Maxwell Hayes 5afd6b944c Making clear distinction between GetAbsoluteAverageAmplitude and GetAverageAmplitude in buffer vector ops. 
#jira nojira
#rb Phil.Popp

[CL 15187887 by Maxwell Hayes in ue5-main branch]
2021-01-25 17:26:35 -04:00

2125 lines
100 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "DSP/BufferVectorOperations.h"
#define AUDIO_USE_SIMD 1
namespace Audio
{
static void RestrictedPtrAliasCheck(const float* RESTRICT Ptr1, const float* RESTRICT Ptr2, uint32 NumFloatsInArray)
{
checkf(static_cast<uint32>(FMath::Abs(Ptr1 - Ptr2)) >= NumFloatsInArray,
TEXT("Using this function as an in-place operation will result in undefined behavior!"));
}
/* Sets a values to zero if value is denormal. Denormal numbers significantly slow down floating point operations. */
void BufferUnderflowClampFast(FAlignedFloatBuffer& InOutBuffer)
{
BufferUnderflowClampFast(InOutBuffer.GetData(), InOutBuffer.Num());
}
/* Sets a values to zero if value is denormal. Denormal numbers significantly slow down floating point operations. */
void BufferUnderflowClampFast(float* RESTRICT InOutBuffer, const int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<float*>(InOutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
const VectorRegister VFMIN = MakeVectorRegister(FLT_MIN, FLT_MIN, FLT_MIN, FLT_MIN);
const VectorRegister VNFMIN = MakeVectorRegister(-FLT_MIN, -FLT_MIN, -FLT_MIN, -FLT_MIN);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister VInOut = VectorLoadAligned(&InOutBuffer[i]);
// Create mask of denormal numbers.
VectorRegister Mask = VectorBitwiseAnd(VectorCompareGT(VInOut, VNFMIN), VectorCompareLT(VInOut, VFMIN));
// Choose between zero or original number based upon mask.
VInOut = VectorSelect(Mask, GlobalVectorConstants::FloatZero, VInOut);
VectorStoreAligned(VInOut, &InOutBuffer[i]);
}
}
/* Clamps values in the buffer to be between InMinValue and InMaxValue */
void BufferRangeClampFast(AlignedFloatBuffer& InOutBuffer, float InMinValue, float InMaxValue)
{
return BufferRangeClampFast(InOutBuffer.GetData(), InOutBuffer.Num(), InMinValue, InMaxValue);
}
/* Clamps values in the buffer to be between InMinValue and InMaxValue */
void BufferRangeClampFast(float* RESTRICT InOutBuffer, const int32 InNum, float InMinValue, float InMaxValue)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<float*>(InOutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
const VectorRegister VMinVal = MakeVectorRegister(InMinValue, InMinValue, InMinValue, InMinValue);
const VectorRegister VMaxVal = MakeVectorRegister(InMaxValue, InMaxValue, InMaxValue, InMaxValue);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister VInOut = VectorLoadAligned(&InOutBuffer[i]);
// Create masks to flag elements outside of range.
VectorRegister MinMask = VectorCompareLT(VInOut, VMinVal);
VectorRegister MaxMask = VectorCompareGT(VInOut, VMaxVal);
// Choose between range extremes or original number based on masks.
VInOut = VectorSelect(MinMask, VMinVal, VInOut);
VInOut = VectorSelect(MaxMask, VMaxVal, VInOut);
VectorStoreAligned(VInOut, &InOutBuffer[i]);
}
}
void BufferMultiplyByConstant(const FAlignedFloatBuffer& InFloatBuffer, float InValue, FAlignedFloatBuffer& OutFloatBuffer)
{
check(InFloatBuffer.Num() >= 4);
// Prepare output buffer
OutFloatBuffer.Reset();
OutFloatBuffer.AddUninitialized(InFloatBuffer.Num());
check(InFloatBuffer.Num() == OutFloatBuffer.Num());
const int32 NumSamples = InFloatBuffer.Num();
// Get ptrs to audio buffers to avoid bounds check in non-shipping builds
const float* InBufferPtr = InFloatBuffer.GetData();
float* OutBufferPtr = OutFloatBuffer.GetData();
BufferMultiplyByConstant(InBufferPtr, InValue, OutBufferPtr, NumSamples);
}
void BufferMultiplyByConstant(const float* RESTRICT InFloatBuffer, float InValue, float* RESTRICT OutFloatBuffer, const int32 InNumSamples)
{
check(InNumSamples >= 4);
RestrictedPtrAliasCheck(InFloatBuffer, OutFloatBuffer, InNumSamples);
#if !AUDIO_USE_SIMD
for (int32 i = 0; i < InNumSamples; ++i)
{
OutFloatBuffer[i] = InValue * InFloatBuffer[i];
}
#else
// Can only SIMD on multiple of 4 buffers, we'll do normal multiples on last bit
const int32 NumSamplesRemaining = InNumSamples % 4;
const int32 NumSamplesToSimd = InNumSamples - NumSamplesRemaining;
// Load the single value we want to multiply all values by into a vector register
const VectorRegister MultiplyValue = VectorLoadFloat1(&InValue);
for (int32 i = 0; i < NumSamplesToSimd; i += 4)
{
// Load the next 4 samples of the input buffer into a register
VectorRegister InputBufferRegister = VectorLoadAligned(&InFloatBuffer[i]);
// Perform the multiply
VectorRegister Temp = VectorMultiply(InputBufferRegister, MultiplyValue);
// Store results into the output buffer
VectorStoreAligned(Temp, &OutFloatBuffer[i]);
}
// Perform remaining non-simd values left over
for (int32 i = 0; i < NumSamplesRemaining; ++i)
{
OutFloatBuffer[NumSamplesToSimd + i] = InValue * InFloatBuffer[NumSamplesToSimd + i];
}
#endif
}
void MultiplyBufferByConstantInPlace(AlignedFloatBuffer& InBuffer, float InGain)
{
MultiplyBufferByConstantInPlace(InBuffer.GetData(), InBuffer.Num(), InGain);
}
void MultiplyBufferByConstantInPlace(float* RESTRICT InBuffer, int32 NumSamples, float InGain)
{
const VectorRegister Gain = VectorLoadFloat1(&InGain);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&InBuffer[i]);
Output = VectorMultiply(Output, Gain);
VectorStoreAligned(Output, &InBuffer[i]);
}
}
// Adds a constant to a buffer (useful for DC offset removal)
void AddConstantToBufferInplace(AlignedFloatBuffer& InBuffer, float InConstant)
{
AddConstantToBufferInplace(InBuffer.GetData(), InBuffer.Num(), InConstant);
}
void AddConstantToBufferInplace(float* RESTRICT InBuffer, int32 NumSamples, float InConstant)
{
const VectorRegister Constant = VectorLoadFloat1(&InConstant);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&InBuffer[i]);
Output = VectorAdd(Output, Constant);
VectorStoreAligned(Output, &InBuffer[i]);
}
}
void BufferSetToConstantInplace(AlignedFloatBuffer& InBuffer, float InConstant)
{
BufferSetToConstantInplace(InBuffer.GetData(), InBuffer.Num(), InConstant);
}
void BufferSetToConstantInplace(float* RESTRICT InBuffer, int32 NumSamples, float InConstant)
{
const VectorRegister Constant = VectorLoadFloat1(&InConstant);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorStoreAligned(Constant, &InBuffer[i]);
}
}
/* Performs an element-wise weighted sum OutputBuffer = (InBuffer1 x InGain1) + (InBuffer2 x InGain2) */
void BufferWeightedSumFast(const FAlignedFloatBuffer& InBuffer1, float InGain1, const FAlignedFloatBuffer& InBuffer2, float InGain2, FAlignedFloatBuffer& OutBuffer)
{
checkf(InBuffer1.Num() == InBuffer2.Num(), TEXT("Buffers must be equal length"));
OutBuffer.Reset();
OutBuffer.AddUninitialized(InBuffer1.Num());
BufferWeightedSumFast(InBuffer1.GetData(), InGain1, InBuffer2.GetData(), InGain2, OutBuffer.GetData(), InBuffer1.Num());
}
/* Performs an element-wise weighted sum OutputBuffer = (InBuffer1 x InGain1) + InBuffer2 */
void BufferWeightedSumFast(const FAlignedFloatBuffer& InBuffer1, float InGain1, const FAlignedFloatBuffer& InBuffer2, FAlignedFloatBuffer& OutBuffer)
{
checkf(InBuffer1.Num() == InBuffer2.Num(), TEXT("Buffers must be equal length"));
OutBuffer.Reset();
OutBuffer.AddUninitialized(InBuffer1.Num());
BufferWeightedSumFast(InBuffer1.GetData(), InGain1, InBuffer2.GetData(), OutBuffer.GetData(), InBuffer1.Num());
}
/* Performs an element-wise weighted sum OutputBuffer = (InBuffer1 x InGain1) + (InBuffer2 x InGain2) */
void BufferWeightedSumFast(const float* RESTRICT InBuffer1, float InGain1, const float* RESTRICT InBuffer2, float InGain2, float* RESTRICT OutBuffer, int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InBuffer1, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InBuffer2, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InBuffer1, OutBuffer, InNum);
RestrictedPtrAliasCheck(InBuffer2, OutBuffer, InNum);
VectorRegister Gain1Vector = VectorLoadFloat1(&InGain1);
VectorRegister Gain2Vector = VectorLoadFloat1(&InGain2);
for (int32 i = 0; i < InNum; i += 4)
{
// InBuffer1 x InGain1
VectorRegister Input1 = VectorLoadAligned(&InBuffer1[i]);
VectorRegister Weighted1 = VectorMultiply(Input1, Gain1Vector);
// InBuffer2 x InGain2
VectorRegister Input2 = VectorLoadAligned(&InBuffer2[i]);
VectorRegister Weighted2 = VectorMultiply(Input2, Gain2Vector);
VectorRegister Output = VectorAdd(Weighted1, Weighted2);
VectorStoreAligned(Output, &OutBuffer[i]);
}
}
/* Performs an element-wise weighted sum OutputBuffer = (InBuffer1 x InGain1) + InBuffer2 */
void BufferWeightedSumFast(const float* RESTRICT InBuffer1, float InGain1, const float* RESTRICT InBuffer2, float* RESTRICT OutBuffer, int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InBuffer1, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InBuffer2, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InBuffer1, OutBuffer, InNum);
RestrictedPtrAliasCheck(InBuffer2, OutBuffer, InNum);
VectorRegister Gain1Vector = VectorLoadFloat1(&InGain1);
for (int32 i = 0; i < InNum; i += 4)
{
// InBuffer1 x InGain1
VectorRegister Input1 = VectorLoadAligned(&InBuffer1[i]);
VectorRegister Weighted1 = VectorMultiply(Input1, Gain1Vector);
VectorRegister Input2 = VectorLoadAligned(&InBuffer2[i]);
VectorRegister Output = VectorAdd(Weighted1, Input2);
VectorStoreAligned(Output, &OutBuffer[i]);
}
}
void FadeBufferFast(AlignedFloatBuffer& OutFloatBuffer, const float StartValue, const float EndValue)
{
FadeBufferFast(OutFloatBuffer.GetData(), OutFloatBuffer.Num(), StartValue, EndValue);
}
void FadeBufferFast(float* RESTRICT OutFloatBuffer, int32 NumSamples, const float StartValue, const float EndValue)
{
checkf(IsAligned<float*>(OutFloatBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
#if !AUDIO_USE_SIMD
float Gain = StartValue;
if (FMath::IsNearlyEqual(StartValue, EndValue))
{
// No need to do anything if start and end values are both 0.0
if (StartValue == 0.0f)
{
FMemory::Memset(OutFloatBuffer, 0, sizeof(float)*NumSamples);
}
else
{
// Only need to do a buffer multiply if start and end values are the same
for (int32 i = 0; i < NumSamples; ++i)
{
OutFloatBuffer[i] = OutFloatBuffer[i] * Gain;
}
}
}
else
{
// Do a fade from start to end
const float DeltaValue = ((EndValue - StartValue) / NumSamples);
for (int32 i = 0; i < NumSamples; ++i)
{
OutFloatBuffer[i] = OutFloatBuffer[i] * Gain;
Gain += DeltaValue;
}
}
#else
const int32 NumIterations = NumSamples / 4;
if (FMath::IsNearlyEqual(StartValue, EndValue))
{
// No need to do anything if start and end values are both 0.0
if (StartValue == 0.0f)
{
FMemory::Memset(OutFloatBuffer, 0, sizeof(float)*NumSamples);
}
else
{
VectorRegister Gain = VectorLoadFloat1(&StartValue);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&OutFloatBuffer[i]);
Output = VectorMultiply(Output, Gain);
VectorStoreAligned(Output, &OutFloatBuffer[i]);
}
}
}
else
{
const float DeltaValue = ((EndValue - StartValue) / NumIterations);
VectorRegister Gain = VectorLoadFloat1(&StartValue);
VectorRegister Delta = VectorLoadFloat1(&DeltaValue);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&OutFloatBuffer[i]);
Output = VectorMultiply(Output, Gain);
Gain = VectorAdd(Gain, Delta);
VectorStoreAligned(Output, &OutFloatBuffer[i]);
}
}
#endif
}
void MixInBufferFast(const FAlignedFloatBuffer& InFloatBuffer, FAlignedFloatBuffer& BufferToSumTo, const float Gain)
{
MixInBufferFast(InFloatBuffer.GetData(), BufferToSumTo.GetData(), InFloatBuffer.Num(), Gain);
}
void MixInBufferFast(const float* RESTRICT InFloatBuffer, float* RESTRICT BufferToSumTo, int32 NumSamples, const float Gain)
{
checkf(IsAligned<const float*>(InFloatBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(BufferToSumTo, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
RestrictedPtrAliasCheck(InFloatBuffer, BufferToSumTo, NumSamples);
#if !AUDIO_USE_SIMD
for (int32 i = 0; i < NumSamples; ++i)
{
BufferToSumTo[i] += InFloatBuffer[i] * Gain;
}
#else
VectorRegister GainVector = VectorLoadFloat1(&Gain);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&BufferToSumTo[i]);
VectorRegister Input = VectorLoadAligned(&InFloatBuffer[i]);
Output = VectorMultiplyAdd(Input, GainVector, Output);
VectorStoreAligned(Output, &BufferToSumTo[i]);
}
#endif
}
void MixInBufferFast(const FAlignedFloatBuffer& InFloatBuffer, FAlignedFloatBuffer& BufferToSumTo)
{
checkf(InFloatBuffer.Num() == BufferToSumTo.Num(), TEXT("Buffers must be equal size"));
MixInBufferFast(InFloatBuffer.GetData(), BufferToSumTo.GetData(), InFloatBuffer.Num());
}
void MixInBufferFast(const float* RESTRICT InFloatBuffer, float* RESTRICT BufferToSumTo, int32 NumSamples)
{
checkf(IsAligned<const float*>(InFloatBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(BufferToSumTo, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
RestrictedPtrAliasCheck(InFloatBuffer, BufferToSumTo, NumSamples);
#if !AUDIO_USE_SIMD
for (int32 i = 0; i < NumSamples; ++i)
{
BufferToSumTo[i] += InFloatBuffer[i];
}
#else
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Output = VectorLoadAligned(&BufferToSumTo[i]);
VectorRegister Input = VectorLoadAligned(&InFloatBuffer[i]);
Output = VectorAdd(Input, Output);
VectorStoreAligned(Output, &BufferToSumTo[i]);
}
#endif
}
void MixInBufferFast(const FAlignedFloatBuffer& InFloatBuffer, FAlignedFloatBuffer& BufferToSumTo, const float StartGain, const float EndGain)
{
MixInBufferFast(InFloatBuffer.GetData(), BufferToSumTo.GetData(), InFloatBuffer.Num(), StartGain, EndGain);
}
void MixInBufferFast(const float* RESTRICT InFloatBuffer, float* RESTRICT BufferToSumTo, int32 NumSamples, const float StartGain, const float EndGain)
{
checkf(IsAligned<const float*>(InFloatBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(BufferToSumTo, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
RestrictedPtrAliasCheck(InFloatBuffer, BufferToSumTo, NumSamples);
const int32 NumIterations = NumSamples / 4;
if (FMath::IsNearlyEqual(StartGain, EndGain))
{
// No need to do anything if start and end values are both 0.0
if (StartGain == 0.0f)
{
return;
}
else
{
VectorRegister Gain = VectorLoadFloat1(&StartGain);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input = VectorLoadAligned(&InFloatBuffer[i]);
VectorRegister Output = VectorLoadAligned(&BufferToSumTo[i]);
Input = VectorMultiply(Input, Gain);
Output = VectorAdd(Input, Output);
VectorStoreAligned(Output, &BufferToSumTo[i]);
}
}
}
else
{
const float DeltaValue = ((EndGain - StartGain) / NumIterations);
VectorRegister Gain = VectorLoadFloat1(&StartGain);
VectorRegister Delta = VectorLoadFloat1(&DeltaValue);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input = VectorLoadAligned(&InFloatBuffer[i]);
VectorRegister Output = VectorLoadAligned(&BufferToSumTo[i]);
Input = VectorMultiply(Input, Gain);
Output = VectorAdd(Input, Output);
VectorStoreAligned(Output, &BufferToSumTo[i]);
Gain = VectorAdd(Gain, Delta);
}
}
}
/* Subtracts two buffers together element-wise. */
void BufferSubtractFast(const FAlignedFloatBuffer& InMinuend, const FAlignedFloatBuffer& InSubtrahend, FAlignedFloatBuffer& OutputBuffer)
{
const int32 InNum = InMinuend.Num();
OutputBuffer.Reset(InNum);
OutputBuffer.AddUninitialized(InNum);
checkf(InMinuend.Num() == InSubtrahend.Num(), TEXT("Input buffers must be equal length"));
BufferSubtractFast(InMinuend.GetData(), InSubtrahend.GetData(), OutputBuffer.GetData(), OutputBuffer.Num());
}
/* Subtracts two buffers together element-wise. */
void BufferSubtractFast(const float* RESTRICT InMinuend, const float* RESTRICT InSubtrahend, float* RESTRICT OutBuffer, int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InMinuend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InSubtrahend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InMinuend, OutBuffer, InNum);
RestrictedPtrAliasCheck(InSubtrahend, OutBuffer, InNum);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister Input1 = VectorLoadAligned(&InMinuend[i]);
VectorRegister Input2 = VectorLoadAligned(&InSubtrahend[i]);
VectorRegister Output = VectorSubtract(Input1, Input2);
VectorStoreAligned(Output, &OutBuffer[i]);
}
}
/* Performs element-wise in-place subtraction placing the result in the subtrahend. InOutSubtrahend = InMinuend - InOutSubtrahend */
void BufferSubtractInPlace1Fast(const FAlignedFloatBuffer& InMinuend, FAlignedFloatBuffer& InOutSubtrahend)
{
checkf(InMinuend.Num() == InOutSubtrahend.Num(), TEXT("Input buffers must be equal length"));
BufferSubtractInPlace1Fast(InMinuend.GetData(), InOutSubtrahend.GetData(), InMinuend.Num());
}
/* Performs element-wise in-place subtraction placing the result in the subtrahend. InOutSubtrahend = InMinuend - InOutSubtrahend */
void BufferSubtractInPlace1Fast(const float* RESTRICT InMinuend, float* RESTRICT InOutSubtrahend, int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InMinuend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InOutSubtrahend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InMinuend, InOutSubtrahend, InNum);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister Input1 = VectorLoadAligned(&InMinuend[i]);
VectorRegister Input2 = VectorLoadAligned(&InOutSubtrahend[i]);
VectorRegister Output = VectorSubtract(Input1, Input2);
VectorStoreAligned(Output, &InOutSubtrahend[i]);
}
}
/* Performs element-wise in-place subtraction placing the result in the minuend. InOutMinuend = InOutMinuend - InSubtrahend */
void BufferSubtractInPlace2Fast(AlignedFloatBuffer& InOutMinuend, const FAlignedFloatBuffer& InSubtrahend)
{
checkf(InOutMinuend.Num() == InSubtrahend.Num(), TEXT("Input buffers must be equal length"));
BufferSubtractInPlace2Fast(InOutMinuend.GetData(), InSubtrahend.GetData(), InOutMinuend.Num());
}
/* Performs element-wise in-place subtraction placing the result in the minuend. InOutMinuend = InOutMinuend - InSubtrahend */
void BufferSubtractInPlace2Fast(float* RESTRICT InOutMinuend, const float* RESTRICT InSubtrahend, int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InOutMinuend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InSubtrahend, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InOutMinuend, InSubtrahend, InNum);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister Input1 = VectorLoadAligned(&InOutMinuend[i]);
VectorRegister Input2 = VectorLoadAligned(&InSubtrahend[i]);
VectorRegister Output = VectorSubtract(Input1, Input2);
VectorStoreAligned(Output, &InOutMinuend[i]);
}
}
void SumBuffers(const FAlignedFloatBuffer& InFloatBuffer1, const FAlignedFloatBuffer& InFloatBuffer2, FAlignedFloatBuffer& OutputBuffer)
{
checkf(InFloatBuffer1.Num() == InFloatBuffer2.Num(), TEXT("Input buffers must be equal length"));
const int32 InNum = InFloatBuffer1.Num();
OutputBuffer.Reset(InNum);
OutputBuffer.AddUninitialized(InNum);
SumBuffers(InFloatBuffer1.GetData(), InFloatBuffer2.GetData(), OutputBuffer.GetData(), InNum);
}
void SumBuffers(const float* RESTRICT InFloatBuffer1, const float* RESTRICT InFloatBuffer2, float* RESTRICT OutputBuffer, int32 NumSamples)
{
checkf(IsAligned<const float*>(InFloatBuffer1, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InFloatBuffer2, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutputBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
RestrictedPtrAliasCheck(InFloatBuffer1, OutputBuffer, NumSamples);
RestrictedPtrAliasCheck(InFloatBuffer2, OutputBuffer, NumSamples);
#if !AUDIO_USE_SIMD
for (int32 i = 0; i < NumSamples; ++i)
{
OutputBuffer[i] = InFloatBuffer1[i] + InFloatBuffer2[i];
}
#else
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input1 = VectorLoadAligned(&InFloatBuffer1[i]);
VectorRegister Input2 = VectorLoadAligned(&InFloatBuffer2[i]);
VectorRegister Output = VectorAdd(Input1, Input2);
VectorStoreAligned(Output, &OutputBuffer[i]);
}
#endif
}
void MultiplyBuffersInPlace(const FAlignedFloatBuffer& InFloatBuffer, FAlignedFloatBuffer& BufferToMultiply)
{
MultiplyBuffersInPlace(InFloatBuffer.GetData(), BufferToMultiply.GetData(), BufferToMultiply.Num());
}
void MultiplyBuffersInPlace(const float* RESTRICT InFloatBuffer, float* RESTRICT BufferToMultiply, int32 NumSamples)
{
checkf(IsAligned<const float*>(InFloatBuffer, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(BufferToMultiply, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
RestrictedPtrAliasCheck(InFloatBuffer, BufferToMultiply, NumSamples);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input1 = VectorLoadAligned(&InFloatBuffer[i]);
VectorRegister Output = VectorLoadAligned(&BufferToMultiply[i]);
Output = VectorMultiply(Input1, Output);
VectorStoreAligned(Output, &BufferToMultiply[i]);
}
}
float GetMagnitude(const FAlignedFloatBuffer& Buffer)
{
return GetMagnitude(Buffer.GetData(), Buffer.Num());
}
float GetMagnitude(const float* RESTRICT Buffer, int32 NumSamples)
{
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
#if !AUDIO_USE_SIMD
float Sum = 0.0f;
for (int32 i = 0; i < NumSamples; ++i)
{
Sum += Buffer[i] * Buffer[i];
}
return FMath::Sqrt(Sum);
#else
VectorRegister Sum = VectorZero();
const float Exponent = 2.0f;
VectorRegister ExponentVector = VectorLoadFloat1(&Exponent);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input = VectorPow(VectorLoadAligned(&Buffer[i]), ExponentVector);
Sum = VectorAdd(Sum, Input);
}
float PartionedSums[4];
VectorStoreAligned(Sum, PartionedSums);
return FMath::Sqrt(PartionedSums[0] + PartionedSums[1] + PartionedSums[2] + PartionedSums[3]);
#endif
}
float BufferGetAverageValue(const FAlignedFloatBuffer& Buffer)
{
checkf(Buffer.Num() % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
return BufferGetAverageValue(Buffer.GetData(), Buffer.Num());
}
float BufferGetAverageValue(const float* RESTRICT Buffer, int32 NumSamples)
{
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
#if !AUDIO_USE_SIMD
float Sum = 0.0f;
for (int32 i = 0; i < NumSamples; ++i)
{
Sum += Buffer[i];
}
return Sum / NumSamples;
#else
VectorRegister Sum = VectorZero();
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input = VectorLoadAligned(&Buffer[i]);
Sum = VectorAdd(Sum, Input);
}
float PartionedSums[4];
VectorStore(Sum, PartionedSums);
return (PartionedSums[0] + PartionedSums[1] + PartionedSums[2] + PartionedSums[3]) / NumSamples;
#endif
}
float BufferGetAverageAbsValue(const FAlignedFloatBuffer& Buffer)
{
checkf(Buffer.Num() % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
return BufferGetAverageAbsValue(Buffer.GetData(), Buffer.Num());
}
float BufferGetAverageAbsValue(const float* RESTRICT Buffer, int32 NumSamples)
{
checkf(NumSamples % 4 == 0, TEXT("Please use a buffer size that is a multiple of 4."));
#if !AUDIO_USE_SIMD
float Sum = 0.0f;
for (int32 i = 0; i < NumSamples; ++i)
{
Sum += FMath::Abs(Buffer[i]);
}
return Sum / NumSamples;
#else
VectorRegister Sum = VectorZero();
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Input = VectorAbs(VectorLoadAligned(&Buffer[i]));
Sum = VectorAdd(Sum, Input);
}
float PartionedSums[4];
VectorStore(Sum, PartionedSums);
return (PartionedSums[0] + PartionedSums[1] + PartionedSums[2] + PartionedSums[3]) / NumSamples;
#endif
}
/**
* CHANNEL MIXING OPERATIONS:
* To understand these functions, it's best that you have prior experience reading SIMD code.
* These functions are all variations on component-wise matrix multiplies.
* There are two types of functions below:
*
* Apply[N]ChannelGain:
* These are all in-place multiplies of an N-length gain vector and an N-length frame.
* There are two flavors of every variant of this function: The non-interpolating form (which takes a single gain matrix)
* And the interpolating form (which takes a start gain matrix and interpolates to the end gain matrix over the given number of frames).
* All non-interpolating forms of these functions use the following steps:
* 1. Create a const GainVector, or series of GainVectors, that maps to the multiplies required for each iteration.
* 2. In a loop:
* i. load a frame or number of frames into a vector register or series of vector registers (these are named Result).
* ii. perform a vector multiply on result with the corresponding gain vector.
* iii. store the result vector in the same position in the buffer we loaded from.
*
* The interpolating forms of these functions use the following steps:
* 1. Initialize a non-const GainVector, or series of GainVectors, from StartGains, that maps to the multiplies required for each iteration.
* 2. Compute the amount we add to GainVector for each iteration to reach Destination Gains and store it in the const GainDeltasVector.
* 3. In a loop:
* i. load a frame or number of frames into a vector register or series of vector registers (these are named Result).
* ii. perform a vector multiply on result with the corresponding gain vector.
* iii. store the result vector in the same position in the buffer we loaded from.
* iv. increment each GainVector by it's corresponding GainDeltasVector.
*
*
* MixMonoTo[N]ChannelsFast and Mix2ChannelsTo[N]ChannelsFast:
* These, like Apply[N]ChannelGain, all have non-interpolating and interpolating forms.
* All non-interpolating forms of these functions use the following steps:
* 1. Create a const GainVector, or series of GainVectors, that maps to the multiplies required for each input channel for each iteration.
* 2. In a loop:
* i. load a frame or number of frames into a const vector register or series of const vector registers (these are named Input).
* ii. perform a vector multiply on input with the corresponding gain vector and store the result in a new vector or series of vectors named Result.
* iii. if there is a second input channel, store the results of the following MultiplyAdd operation to Results: (Gain Vectors for second channel) * (Input vectors for second channel) + (Result vectors from step ii).
*
* Interpolating forms of these functions use the following steps:
* 1. Initialize a non-const GainVector, or series of GainVectors, from StartGains, that maps to the multiplies required for each input channel for each iteration.
* 2. Compute the amount we add to each GainVector for each iteration to reach the vector's corresponding DestinationGains and store it in a corresponding GainDeltaVector.
* 3. In a loop:
* i. load a frame or number of frames into a const vector register or series of const vector registers (these are named Input).
* ii. perform a vector multiply on input with the corresponding gain vector and store the result in a new vector or series of vectors named Result.
* iii. if there is a second input channel, store the results of the following MultiplyAdd operation to Results: (Gain Vectors for second channel) * (Input vectors for second channel) + (Result vectors from step ii).
* iv. increment each GainVector by it's corresponding GainDeltasVector.
*
* DETERMINING THE VECTOR LAYOUT FOR EACH FUNCTION:
* For every variant of Mix[N]ChannelsTo[N]ChannelsFast, we use the least common multiple of the number of output channels and the SIMD vector length (4) to calulate the length of our matrix.
* For example, MixMonoTo4ChannelsFast can use a single VectorRegister for each variable. GainVector's values are [g0, g1, g2, g3], input channels are mapped to [i0, i0, i0, i0], and output channels are mapped to [o0, o1, o2, o3].
* MixMonoTo8ChannelsFast has an LCM of 8, so we use two VectorRegister for each variable. This results in the following layout:
* GainVector1: [g0, g1, g2, g3] GainVector2: [g4, g5, g6, g7]
* InputVector1: [i0, i0, i0, i0] InputVector2: [i0, i0, i0, i0]
* ResultVector1: [o0, o1, o2, o3] ResultVector2: [o4, o5, o6, o7]
*
* The general naming convention for vector variables is [Name]Vector[VectorIndex] for MixMonoTo[N]ChannelsFast functions.
* For Mix2ChannelsTo[N]ChannelsFast functions, the naming convention for vector variables is [Name]Vector[VectorIndex][InputChannelIndex].
*
* For clarity, the layout of vectors for each function variant is given in a block comment above that function.
*/
void Apply2ChannelGain(AlignedFloatBuffer& StereoBuffer, const float* RESTRICT Gains)
{
Apply2ChannelGain(StereoBuffer.GetData(), StereoBuffer.Num(), Gains);
}
void Apply2ChannelGain(float* RESTRICT StereoBuffer, int32 NumSamples, const float* RESTRICT Gains)
{
const VectorRegister GainVector = VectorLoadFloat2(Gains);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Result = VectorLoadAligned(&StereoBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &StereoBuffer[i]);
}
}
void Apply2ChannelGain(AlignedFloatBuffer& StereoBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Apply2ChannelGain(StereoBuffer.GetData(), StereoBuffer.Num(), StartGains, EndGains);
}
void Apply2ChannelGain(float* RESTRICT StereoBuffer, int32 NumSamples, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
// Initialize GainVector at StartGains and compute GainDeltasVector:
VectorRegister GainVector = VectorLoadFloat2(StartGains);
const VectorRegister DestinationVector = VectorLoadFloat2(EndGains);
const VectorRegister NumFramesVector = VectorSetFloat1(NumSamples / 4.0f);
const VectorRegister GainDeltasVector = VectorDivide(VectorSubtract(DestinationVector, GainVector), NumFramesVector);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Result = VectorLoadAligned(&StereoBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &StereoBuffer[i]);
GainVector = VectorAdd(GainVector, GainDeltasVector);
}
}
void MixMonoTo2ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
MixMonoTo2ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 2, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain | g0 | g1 | g0 | g1 |
* | | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void MixMonoTo2ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector = VectorLoadFloat2(Gains);
for (int32 i = 0; i < NumFrames; i += 2)
{
VectorRegister Result = VectorSet(MonoBuffer[i], MonoBuffer[i], MonoBuffer[i + 1], MonoBuffer[i + 1]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &DestinationBuffer[i*2]);
}
}
void MixMonoTo2ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
MixMonoTo2ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 2, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain | g0 | g1 | g0 | g1 |
* | | * | * | * | * |
* | Input | i0 | i0 | i1 | i1 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void MixMonoTo2ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
// Initialize GainVector at StartGains and compute GainDeltasVector:
VectorRegister GainVector = VectorLoadFloat2(StartGains);
const VectorRegister DestinationVector = VectorLoadFloat2(EndGains);
const VectorRegister NumFramesVector = VectorSetFloat1(NumFrames / 2.0f);
const VectorRegister GainDeltasVector = VectorDivide(VectorSubtract(DestinationVector, GainVector), NumFramesVector);
// To help with stair stepping, we initialize the second frame in GainVector to be half a GainDeltas vector higher than the first frame.
const VectorRegister VectorOfHalf = VectorSet(0.5f, 0.5f, 1.0f, 1.0f);
const VectorRegister HalfOfDeltaVector = VectorMultiply(GainDeltasVector, VectorOfHalf);
GainVector = VectorAdd(GainVector, HalfOfDeltaVector);
for (int32 i = 0; i < NumFrames; i += 2)
{
VectorRegister Result = VectorSet(MonoBuffer[i], MonoBuffer[i], MonoBuffer[i + 1], MonoBuffer[i + 1]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &DestinationBuffer[i*2]);
GainVector = VectorAdd(GainVector, GainDeltasVector);
}
}
void MixMonoTo2ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer)
{
MixMonoTo2ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), MonoBuffer.Num());
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Input | i0 | i0 | i1 | i1 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void MixMonoTo2ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 InNumFrames)
{
checkf(InNumFrames >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNumFrames % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(MonoBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(DestinationBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
int32 OutPos = 0;
for (int32 i = 0; i < InNumFrames; i += 4)
{
VectorRegister Input = VectorLoadAligned(&MonoBuffer[i]);
VectorRegister Output = VectorSwizzle(Input, 0, 0, 1, 1);
VectorStoreAligned(Output, &DestinationBuffer[OutPos]);
OutPos += 4;
Output = VectorSwizzle(Input, 2, 2, 3, 3);
VectorStoreAligned(Output, &DestinationBuffer[OutPos]);
OutPos += 4;
}
}
void Mix2ChannelsTo2ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
Mix2ChannelsTo2ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 2, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain1 | g0 | g1 | g0 | g1 |
* | | * | * | * | * |
* | Input1 | i0 | i0 | i2 | i2 |
* | | + | + | + | + |
* | Gain2 | g2 | g3 | g2 | g3 |
* | | * | * | * | * |
* | Input2 | i1 | i1 | i3 | i3 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void Mix2ChannelsTo2ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadFloat2(Gains);
const VectorRegister GainVector2 = VectorLoadFloat2(Gains + 2);
for (int32 i = 0; i < NumFrames; i += 2)
{
const VectorRegister Input1 = VectorSet(SourceBuffer[i * 2], SourceBuffer[i * 2], SourceBuffer[i * 2 + 2], SourceBuffer[i * 2 + 2]);
const VectorRegister Input2 = VectorSet(SourceBuffer[i * 2 + 1], SourceBuffer[i * 2 + 1], SourceBuffer[i * 2 + 3], SourceBuffer[i * 2 + 3]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
Result = VectorMultiplyAdd(Input2, GainVector2, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 2]);
}
}
void Mix2ChannelsTo2ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Mix2ChannelsTo2ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 2, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain1 | g0 | g1 | g0 | g1 |
* | | * | * | * | * |
* | Input1 | i0 | i0 | i2 | i2 |
* | | + | + | + | + |
* | Gain2 | g2 | g3 | g2 | g3 |
* | | * | * | * | * |
* | Input2 | i1 | i1 | i3 | i3 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void Mix2ChannelsTo2ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1(NumFrames / 2.0f);
VectorRegister GainVector1 = VectorLoadFloat2(StartGains);
const VectorRegister DestinationVector1 = VectorLoadFloat2(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
// To help with stair stepping, we initialize the second frame in GainVector to be half a GainDeltas vector higher than the first frame.
const VectorRegister VectorOfHalf = VectorSet(0.5f, 0.5f, 1.0f, 1.0f);
const VectorRegister HalfOfDeltaVector1 = VectorMultiply(GainDeltasVector1, VectorOfHalf);
GainVector1 = VectorAdd(GainVector1, HalfOfDeltaVector1);
VectorRegister GainVector2 = VectorLoadFloat2(StartGains + 2);
const VectorRegister DestinationVector2 = VectorLoadFloat2(EndGains + 2);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
const VectorRegister HalfOfDeltaVector2 = VectorMultiply(GainDeltasVector2, VectorOfHalf);
GainVector2 = VectorAdd(GainVector2, HalfOfDeltaVector2);
for (int32 i = 0; i < NumFrames; i += 2)
{
const VectorRegister Input1 = VectorSet(SourceBuffer[i * 2], SourceBuffer[i * 2], SourceBuffer[i * 2 + 2], SourceBuffer[i * 2 + 2]);
const VectorRegister Input2 = VectorSet(SourceBuffer[i * 2 + 1], SourceBuffer[i * 2 + 1], SourceBuffer[i * 2 + 3], SourceBuffer[i * 2 + 3]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
Result = VectorMultiplyAdd(Input2, GainVector2, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 2]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
}
}
void Apply4ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT Gains)
{
Apply4ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), Gains);
}
void Apply4ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT Gains)
{
const VectorRegister GainVector = VectorLoadAligned(Gains);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
}
}
void Apply4ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Apply4ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), StartGains, EndGains);
}
void Apply4ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
// Initialize GainVector at StartGains and compute GainDeltasVector:
VectorRegister GainVector = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector = VectorLoadAligned(EndGains);
const VectorRegister NumFramesVector = VectorSetFloat1(NumSamples / 4.0f);
const VectorRegister GainDeltasVector = VectorDivide(VectorSubtract(DestinationVector, GainVector), NumFramesVector);
for (int32 i = 0; i < NumSamples; i += 4)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
GainVector = VectorAdd(GainVector, GainDeltasVector);
}
}
void MixMonoTo4ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
MixMonoTo4ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 4, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frame per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain | g0 | g1 | g2 | g3 |
* | | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void MixMonoTo4ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector = VectorLoadAligned(Gains);
for (int32 i = 0; i < NumFrames; i++)
{
VectorRegister Result = VectorLoadFloat1(&MonoBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &DestinationBuffer[i*4]);
}
}
void MixMonoTo4ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
MixMonoTo4ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 4, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frame per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain | g0 | g1 | g2 | g3 |
* | | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void MixMonoTo4ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
VectorRegister GainVector = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector = VectorLoadAligned(EndGains);
const VectorRegister NumFramesVector = VectorSetFloat1((float) NumFrames);
const VectorRegister GainDeltasVector = VectorDivide(VectorSubtract(DestinationVector, GainVector), NumFramesVector);
for (int32 i = 0; i < NumFrames; i++)
{
VectorRegister Result = VectorLoadFloat1(&MonoBuffer[i]);
Result = VectorMultiply(Result, GainVector);
VectorStoreAligned(Result, &DestinationBuffer[i * 4]);
GainVector = VectorAdd(GainVector, GainDeltasVector);
}
}
void Mix2ChannelsTo4ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
Mix2ChannelsTo4ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 4, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frame per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain1 | g0 | g1 | g2 | g3 |
* | | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 |
* | | + | + | + | + |
* | Gain2 | g4 | g5 | g6 | g7 |
* | | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void Mix2ChannelsTo4ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadAligned(Gains);
const VectorRegister GainVector2 = VectorLoadAligned(Gains + 4);
for (int32 i = 0; i < NumFrames; i++)
{
const VectorRegister Input1 = VectorLoadFloat1(&SourceBuffer[i * 2]);
const VectorRegister Input2 = VectorLoadFloat1(&SourceBuffer[i * 2 + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
Result = VectorMultiplyAdd(Input2, GainVector2, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 4]);
}
}
void Mix2ChannelsTo4ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Mix2ChannelsTo4ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 4, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frame per iteration:
* +------------+---------+---------+---------+---------+
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 |
* +------------+---------+---------+---------+---------+
* | Gain1 | g0 | g1 | g2 | g3 |
* | | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 |
* | | + | + | + | + |
* | Gain2 | g4 | g5 | g6 | g7 |
* | | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 |
* | | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 |
* +------------+---------+---------+---------+---------+
*/
void Mix2ChannelsTo4ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1((float) NumFrames);
VectorRegister GainVector1 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector1 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
VectorRegister GainVector2 = VectorLoadAligned(StartGains + 4);
const VectorRegister DestinationVector2 = VectorLoadAligned(EndGains + 4);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
for (int32 i = 0; i < NumFrames; i++)
{
const VectorRegister Input1 = VectorLoadFloat1(&SourceBuffer[i * 2]);
const VectorRegister Input2 = VectorLoadFloat1(&SourceBuffer[i * 2 + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
Result = VectorMultiplyAdd(Input2, GainVector2, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 4]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
}
}
void Apply6ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT Gains)
{
Apply6ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), Gains);
}
void Apply6ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadAligned(Gains);
const VectorRegister GainVector2 = VectorSet(Gains[4], Gains[5], Gains[0], Gains[1]);
const VectorRegister GainVector3 = VectorLoad(&Gains[2]);
for (int32 i = 0; i < NumSamples; i += 12)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector1);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
Result = VectorLoadAligned(&InterleavedBuffer[i + 4]);
Result = VectorMultiply(Result, GainVector2);
VectorStoreAligned(Result, &InterleavedBuffer[i + 4]);
Result = VectorLoadAligned(&InterleavedBuffer[i + 8]);
Result = VectorMultiply(Result, GainVector3);
VectorStoreAligned(Result, &InterleavedBuffer[i + 8]);
}
}
void Apply6ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Apply6ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), StartGains, EndGains);
}
void Apply6ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1(NumSamples / 12.0f);
VectorRegister GainVector1 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector1 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
VectorRegister GainVector2 = VectorSet(StartGains[4], StartGains[5], StartGains[0], StartGains[1]);
const VectorRegister DestinationVector2 = VectorSet(EndGains[4], EndGains[5], EndGains[0], EndGains[1]);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
VectorRegister GainVector3 = VectorLoad(&StartGains[2]);
const VectorRegister DestinationVector3 = VectorLoad(&EndGains[2]);
const VectorRegister GainDeltasVector3 = VectorDivide(VectorSubtract(DestinationVector3, GainVector3), NumFramesVector);
for (int32 i = 0; i < NumSamples; i += 12)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector1);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
Result = VectorLoadAligned(&InterleavedBuffer[i + 4]);
Result = VectorMultiply(Result, GainVector2);
VectorStoreAligned(Result, &InterleavedBuffer[i + 4]);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
Result = VectorLoadAligned(&InterleavedBuffer[i + 8]);
Result = VectorMultiply(Result, GainVector3);
VectorStoreAligned(Result, &InterleavedBuffer[i + 8]);
GainVector3 = VectorAdd(GainVector3, GainDeltasVector3);
}
}
void MixMonoTo6ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
MixMonoTo6ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 6, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 |
* | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 | i0 | i0 | i1 | i1 | i1 | i1 | i1 | i1 |
* | | = | = | = | = | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
*/
void MixMonoTo6ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadAligned(Gains);
const VectorRegister GainVector2 = VectorSet(Gains[4], Gains[5], Gains[0], Gains[1]);
const VectorRegister GainVector3 = VectorLoad(&Gains[2]);
for (int32 i = 0; i < NumFrames; i += 2)
{
const VectorRegister Input1 = VectorLoadFloat1(&MonoBuffer[i]);
const VectorRegister Input2 = VectorSet(MonoBuffer[i], MonoBuffer[i], MonoBuffer[i + 1], MonoBuffer[i + 1]);
const VectorRegister Input3 = VectorLoadFloat1(&MonoBuffer[i + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
VectorStoreAligned(Result, &DestinationBuffer[i * 6]);
Result = VectorMultiply(Input2, GainVector2);
VectorStoreAligned(Result, &DestinationBuffer[i * 6 + 4]);
Result = VectorMultiply(Input3, GainVector3);
VectorStoreAligned(Result, &DestinationBuffer[i * 6 + 8]);
}
}
void MixMonoTo6ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
MixMonoTo6ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 6, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 |
* | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 | i0 | i0 | i1 | i1 | i1 | i1 | i1 | i1 |
* | | = | = | = | = | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
*/
void MixMonoTo6ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1(NumFrames / 2.0f);
VectorRegister GainVector1 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector1 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
VectorRegister GainVector2 = VectorSet(StartGains[4], StartGains[5], StartGains[0], StartGains[1]);
const VectorRegister DestinationVector2 = VectorSet(EndGains[4], EndGains[5], EndGains[0], EndGains[1]);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
VectorRegister GainVector3 = VectorLoad(&StartGains[2]);
const VectorRegister DestinationVector3 = VectorLoad(&EndGains[2]);
const VectorRegister GainDeltasVector3 = VectorDivide(VectorSubtract(DestinationVector3, GainVector3), NumFramesVector);
for (int32 i = 0; i < NumFrames; i += 2)
{
const VectorRegister Input1 = VectorLoadFloat1(&MonoBuffer[i]);
const VectorRegister Input2 = VectorSet(MonoBuffer[i], MonoBuffer[i], MonoBuffer[i + 1], MonoBuffer[i + 1]);
const VectorRegister Input3 = VectorLoadFloat1(&MonoBuffer[i + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector1);
VectorStoreAligned(Result, &DestinationBuffer[i * 6]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
Result = VectorMultiply(Input2, GainVector2);
VectorStoreAligned(Result, &DestinationBuffer[i * 6 + 4]);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
Result = VectorMultiply(Input3, GainVector3);
VectorStoreAligned(Result, &DestinationBuffer[i * 6 + 8]);
GainVector3 = VectorAdd(GainVector3, GainDeltasVector3);
}
}
void Mix2ChannelsTo6ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
Mix2ChannelsTo6ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 6, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 |
* | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i2 | i2 | i2 | i2 | i2 | i2 |
* | | + | + | + | + | + | + | + | + | + | + | + | + |
* | Gain2 | g6 | g7 | g8 | g9 | g10 | g11 | g6 | g7 | g8 | g9 | g10 | g11 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i3 | i3 | i3 | i3 | i3 |
* | | = | = | = | = | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
*/
void Mix2ChannelsTo6ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector11 = VectorLoadAligned(Gains);
const VectorRegister GainVector21 = VectorSet(Gains[4], Gains[5], Gains[0], Gains[1]);
const VectorRegister GainVector31 = VectorLoad(&Gains[2]);
const VectorRegister GainVector12 = VectorLoad(Gains + 6);
const VectorRegister GainVector22 = VectorSet(Gains[10], Gains[11], Gains[6], Gains[7]);
const VectorRegister GainVector32 = VectorLoadAligned(&Gains[8]);
for (int32 FrameIndex = 0; FrameIndex < NumFrames; FrameIndex += 2)
{
const int32 InputIndex = FrameIndex * 2;
const int32 OutputIndex = FrameIndex * 6;
const VectorRegister Input11 = VectorLoadFloat1(&SourceBuffer[InputIndex]);
const VectorRegister Input21 = VectorSet(SourceBuffer[InputIndex], SourceBuffer[InputIndex], SourceBuffer[InputIndex + 2], SourceBuffer[InputIndex + 2]);
const VectorRegister Input31 = VectorLoadFloat1(&SourceBuffer[InputIndex + 2]);
const VectorRegister Input12 = VectorLoadFloat1(&SourceBuffer[InputIndex + 1]);
const VectorRegister Input22 = VectorSet(SourceBuffer[InputIndex + 1], SourceBuffer[InputIndex + 1], SourceBuffer[InputIndex + 3], SourceBuffer[InputIndex + 3]);
const VectorRegister Input32 = VectorLoadFloat1(&SourceBuffer[InputIndex + 3]);
VectorRegister Result = VectorMultiply(Input11, GainVector11);
Result = VectorMultiplyAdd(Input12, GainVector12, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex]);
Result = VectorMultiply(Input21, GainVector21);
Result = VectorMultiplyAdd(Input22, GainVector22, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex + 4]);
Result = VectorMultiply(Input31, GainVector31);
Result = VectorMultiplyAdd(Input32, GainVector32, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex + 8]);
}
}
void Mix2ChannelsTo6ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Mix2ChannelsTo6ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 6, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 2 frames per iteration:
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Vector 1 | | | | Vector 2 | | | | Vector 3 | | | |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 | Index 8 | Index 9 | Index 10 | Index 11 |
* | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g0 | g1 | g2 | g3 | g4 | g5 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i2 | i2 | i2 | i2 | i2 | i2 |
* | | + | + | + | + | + | + | + | + | + | + | + | + |
* | Gain2 | g6 | g7 | g8 | g9 | g10 | g11 | g6 | g7 | g8 | g9 | g10 | g11 |
* | | * | * | * | * | * | * | * | * | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i3 | i3 | i3 | i3 | i3 | i3 |
* | | = | = | = | = | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 | o8 | o9 | o10 | o11 |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+----------+---------+----------+----------+
*/
void Mix2ChannelsTo6ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1(NumFrames / 2.0f);
VectorRegister GainVector11 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector11 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector11 = VectorDivide(VectorSubtract(DestinationVector11, GainVector11), NumFramesVector);
VectorRegister GainVector21 = VectorSet(StartGains[4], StartGains[5], StartGains[0], StartGains[1]);
const VectorRegister DestinationVector21 = VectorSet(EndGains[4], EndGains[5], EndGains[0], EndGains[1]);
const VectorRegister GainDeltasVector21 = VectorDivide(VectorSubtract(DestinationVector21, GainVector21), NumFramesVector);
// In order to ease stair stepping, we ensure that the second frame is initialized to half the GainDelta more than the first frame.
// This gives us a consistent increment across every frame.
const VectorRegister DeltaHalf21 = VectorSet(0.0f, 0.0f, 0.5f, 0.5f);
const VectorRegister InitializedDelta21 = VectorMultiply(GainDeltasVector21, DeltaHalf21);
GainVector21 = VectorAdd(GainVector21, InitializedDelta21);
VectorRegister GainVector31 = VectorLoad(&StartGains[2]);
const VectorRegister DestinationVector31 = VectorLoad(&EndGains[2]);
const VectorRegister GainDeltasVector31 = VectorDivide(VectorSubtract(DestinationVector31, GainVector31), NumFramesVector);
const VectorRegister DeltaHalf31 = VectorSetFloat1(0.5f);
const VectorRegister InitializedDelta31 = VectorMultiply(GainDeltasVector31, DeltaHalf31);
GainVector31 = VectorAdd(GainVector31, InitializedDelta31);
VectorRegister GainVector12 = VectorLoad(StartGains + 6);
const VectorRegister DestinationVector12 = VectorLoad(EndGains + 6);
const VectorRegister GainDeltasVector12 = VectorDivide(VectorSubtract(DestinationVector12, GainVector12), NumFramesVector);
VectorRegister GainVector22 = VectorSet(StartGains[10], StartGains[11], StartGains[6], StartGains[7]);
const VectorRegister DestinationVector22 = VectorSet(EndGains[10], EndGains[11], EndGains[6], EndGains[7]);
const VectorRegister GainDeltasVector22 = VectorDivide(VectorSubtract(DestinationVector22, GainVector22), NumFramesVector);
const VectorRegister DeltaHalf22 = VectorSet(0.0f, 0.0f, 0.5f, 0.5f);
const VectorRegister InitializedDelta22 = VectorMultiply(GainDeltasVector22, DeltaHalf22);
GainVector22 = VectorAdd(GainVector22, InitializedDelta22);
VectorRegister GainVector32 = VectorLoadAligned(StartGains + 8);
const VectorRegister DestinationVector32 = VectorLoadAligned(EndGains + 8);
const VectorRegister GainDeltasVector32 = VectorDivide(VectorSubtract(DestinationVector32, GainVector32), NumFramesVector);
const VectorRegister DeltaHalf32 = VectorSetFloat1(0.5f);
const VectorRegister InitializedDelta32 = VectorMultiply(GainDeltasVector32, DeltaHalf32);
GainVector32 = VectorAdd(GainVector32, InitializedDelta32);
for (int32 FrameIndex = 0; FrameIndex < NumFrames; FrameIndex += 2)
{
const int32 InputIndex = FrameIndex * 2;
const int32 OutputIndex = FrameIndex * 6;
const VectorRegister Input11 = VectorLoadFloat1(&SourceBuffer[InputIndex]);
const VectorRegister Input21 = VectorSet(SourceBuffer[InputIndex], SourceBuffer[InputIndex], SourceBuffer[InputIndex + 2], SourceBuffer[InputIndex + 2]);
const VectorRegister Input31 = VectorLoadFloat1(&SourceBuffer[InputIndex + 2]);
const VectorRegister Input12 = VectorLoadFloat1(&SourceBuffer[InputIndex + 1]);
const VectorRegister Input22 = VectorSet(SourceBuffer[InputIndex + 1], SourceBuffer[InputIndex + 1], SourceBuffer[InputIndex + 3], SourceBuffer[InputIndex + 3]);
const VectorRegister Input32 = VectorLoadFloat1(&SourceBuffer[InputIndex + 3]);
VectorRegister Result = VectorMultiply(Input11, GainVector11);
Result = VectorMultiplyAdd(Input12, GainVector12, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex]);
GainVector11 = VectorAdd(GainVector11, GainDeltasVector11);
GainVector12 = VectorAdd(GainVector12, GainDeltasVector12);
Result = VectorMultiply(Input21, GainVector21);
Result = VectorMultiplyAdd(Input22, GainVector22, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex + 4]);
GainVector21 = VectorAdd(GainVector21, GainDeltasVector21);
GainVector22 = VectorAdd(GainVector22, GainDeltasVector22);
Result = VectorMultiply(Input31, GainVector31);
Result = VectorMultiplyAdd(Input32, GainVector31, Result);
VectorStoreAligned(Result, &DestinationBuffer[OutputIndex + 8]);
GainVector31 = VectorAdd(GainVector31, GainDeltasVector31);
GainVector32 = VectorAdd(GainVector32, GainDeltasVector32);
}
}
void Apply8ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT Gains)
{
Apply8ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), Gains);
}
void Apply8ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadAligned(Gains);
const VectorRegister GainVector2 = VectorLoadAligned(Gains + 4);
for (int32 i = 0; i < NumSamples; i += 8)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector1);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
Result = VectorLoadAligned(&InterleavedBuffer[i + 4]);
Result = VectorMultiply(Result, GainVector2);
VectorStoreAligned(Result, &InterleavedBuffer[i + 4]);
}
}
void Apply8ChannelGain(AlignedFloatBuffer& InterleavedBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Apply8ChannelGain(InterleavedBuffer.GetData(), InterleavedBuffer.Num(), StartGains, EndGains);
}
void Apply8ChannelGain(float* RESTRICT InterleavedBuffer, int32 NumSamples, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1(NumSamples / 8.0f);
VectorRegister GainVector1 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector1 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
VectorRegister GainVector2 = VectorLoadAligned(StartGains + 4);
const VectorRegister DestinationVector2 = VectorLoadAligned(EndGains + 4);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
for (int32 i = 0; i < NumSamples; i += 8)
{
VectorRegister Result = VectorLoadAligned(&InterleavedBuffer[i]);
Result = VectorMultiply(Result, GainVector1);
VectorStoreAligned(Result, &InterleavedBuffer[i]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
Result = VectorLoadAligned(&InterleavedBuffer[i + 4]);
Result = VectorMultiply(Result, GainVector2);
VectorStoreAligned(Result, &InterleavedBuffer[i + 4]);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
}
}
void MixMonoTo8ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
MixMonoTo8ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 8, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frames per iteration:
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Vector 1 | | | | Vector 2 | | | |
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 |
* | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 |
* | | * | * | * | * | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 |
* | | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+
*/
void MixMonoTo8ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector1 = VectorLoadAligned(Gains);
const VectorRegister GainVector2 = VectorLoadAligned(Gains + 4);
for (int32 i = 0; i < NumFrames; i++)
{
VectorRegister Result = VectorLoadFloat1(&MonoBuffer[i]);
Result = VectorMultiply(Result, GainVector1);
VectorStoreAligned(Result, &DestinationBuffer[i * 8]);
Result = VectorLoadFloat1(&MonoBuffer[i]);
Result = VectorMultiply(Result, GainVector2);
VectorStoreAligned(Result, &DestinationBuffer[i * 8 + 4]);
}
}
void MixMonoTo8ChannelsFast(const FAlignedFloatBuffer& MonoBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
MixMonoTo8ChannelsFast(MonoBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 8, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frames per iteration:
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Vector 1 | | | | Vector 2 | | | |
* | VectorName | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 |
* | Gain | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 |
* | | * | * | * | * | * | * | * | * |
* | Input | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 |
* | | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 |
* +------------+----------+---------+---------+---------+----------+---------+---------+---------+
*/
void MixMonoTo8ChannelsFast(const float* RESTRICT MonoBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1((float) NumFrames);
VectorRegister GainVector1 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector1 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector1 = VectorDivide(VectorSubtract(DestinationVector1, GainVector1), NumFramesVector);
VectorRegister GainVector2 = VectorLoadAligned(StartGains + 4);
const VectorRegister DestinationVector2 = VectorLoadAligned(EndGains + 4);
const VectorRegister GainDeltasVector2 = VectorDivide(VectorSubtract(DestinationVector2, GainVector2), NumFramesVector);
for (int32 i = 0; i < NumFrames; i++)
{
const VectorRegister Input = VectorLoadFloat1(&MonoBuffer[i]);
VectorRegister Result = VectorMultiply(Input, GainVector1);
VectorStoreAligned(Result, &DestinationBuffer[i * 8]);
GainVector1 = VectorAdd(GainVector1, GainDeltasVector1);
Result = VectorMultiply(Input, GainVector2);
VectorStoreAligned(Result, &DestinationBuffer[i * 8 + 4]);
GainVector2 = VectorAdd(GainVector2, GainDeltasVector2);
}
}
void Mix2ChannelsTo8ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
Mix2ChannelsTo8ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 8, Gains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frames per iteration:
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Vector 1 | | | | Vector 2 | | | |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 |
* | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 |
* | | * | * | * | * | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 |
* | | + | + | + | + | + | + | + | + |
* | Gain2 | g8 | g9 | g10 | g11 | g12 | g13 | g14 | g5 |
* | | * | * | * | * | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i1 |
* | | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
*/
void Mix2ChannelsTo8ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
const VectorRegister GainVector11 = VectorLoadAligned(Gains);
const VectorRegister GainVector21 = VectorLoadAligned(Gains + 4);
const VectorRegister GainVector12 = VectorLoadAligned(Gains + 8);
const VectorRegister GainVector22 = VectorLoadAligned(Gains + 12);
for (int32 i = 0; i < NumFrames; i++)
{
const VectorRegister Input1 = VectorLoadFloat1(&SourceBuffer[i*2]);
const VectorRegister Input2 = VectorLoadFloat1(&SourceBuffer[i * 2 + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector11);
Result = VectorMultiplyAdd(Input2, GainVector12, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 8]);
Result = VectorMultiply(Input1, GainVector21);
Result = VectorMultiplyAdd(Input2, GainVector22, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 8 + 4]);
}
}
void Mix2ChannelsTo8ChannelsFast(const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
Mix2ChannelsTo8ChannelsFast(SourceBuffer.GetData(), DestinationBuffer.GetData(), DestinationBuffer.Num() / 8, StartGains, EndGains);
}
/**
* See CHANNEL MIXING OPERATIONS above for more info.
* 1 frames per iteration:
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Vector 1 | | | | Vector 2 | | | |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
* | | Index 0 | Index 1 | Index 2 | Index 3 | Index 4 | Index 5 | Index 6 | Index 7 |
* | Gain1 | g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7 |
* | | * | * | * | * | * | * | * | * |
* | Input1 | i0 | i0 | i0 | i0 | i0 | i0 | i0 | i0 |
* | | + | + | + | + | + | + | + | + |
* | Gain2 | g8 | g9 | g10 | g11 | g12 | g13 | g14 | g15 |
* | | * | * | * | * | * | * | * | * |
* | Input2 | i1 | i1 | i1 | i1 | i1 | i1 | i1 | i1 |
* | | = | = | = | = | = | = | = | = |
* | Output | o0 | o1 | o2 | o3 | o4 | o5 | o6 | o7 |
* +--------+----------+---------+---------+---------+----------+---------+---------+---------+
*/
void Mix2ChannelsTo8ChannelsFast(const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
const VectorRegister NumFramesVector = VectorSetFloat1((float) NumFrames);
VectorRegister GainVector11 = VectorLoadAligned(StartGains);
const VectorRegister DestinationVector11 = VectorLoadAligned(EndGains);
const VectorRegister GainDeltasVector11 = VectorDivide(VectorSubtract(DestinationVector11, GainVector11), NumFramesVector);
VectorRegister GainVector21 = VectorLoadAligned(StartGains + 4);
const VectorRegister DestinationVector21 = VectorLoadAligned(EndGains + 4);
const VectorRegister GainDeltasVector21 = VectorDivide(VectorSubtract(DestinationVector21, GainVector21), NumFramesVector);
VectorRegister GainVector12 = VectorLoadAligned(StartGains + 8);
const VectorRegister DestinationVector12 = VectorLoadAligned(EndGains + 8);
const VectorRegister GainDeltasVector12 = VectorDivide(VectorSubtract(DestinationVector12, GainVector12), NumFramesVector);
VectorRegister GainVector22 = VectorLoadAligned(StartGains + 12);
const VectorRegister DestinationVector22 = VectorLoadAligned(EndGains + 12);
const VectorRegister GainDeltasVector22 = VectorDivide(VectorSubtract(DestinationVector22, GainVector22), NumFramesVector);
for (int32 i = 0; i < NumFrames; i++)
{
const VectorRegister Input1 = VectorLoadFloat1(&SourceBuffer[i*2]);
const VectorRegister Input2 = VectorLoadFloat1(&SourceBuffer[i * 2 + 1]);
VectorRegister Result = VectorMultiply(Input1, GainVector11);
Result = VectorMultiplyAdd(Input2, GainVector12, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 8]);
GainVector11 = VectorAdd(GainVector11, GainDeltasVector11);
GainVector12 = VectorAdd(GainVector12, GainDeltasVector12);
Result = VectorMultiply(Input1, GainVector21);
Result = VectorMultiplyAdd(Input2, GainVector22, Result);
VectorStoreAligned(Result, &DestinationBuffer[i * 8 + 4]);
GainVector21 = VectorAdd(GainVector21, GainDeltasVector21);
GainVector22 = VectorAdd(GainVector22, GainDeltasVector22);
}
}
/**
* These functions are non-vectorized versions of the Mix[N]ChannelsTo[N]Channels functions above:
*/
void DownmixBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, const float* RESTRICT Gains)
{
DownmixBuffer(NumSourceChannels, NumDestinationChannels, SourceBuffer.GetData(), DestinationBuffer.GetData(), SourceBuffer.Num() / NumSourceChannels, Gains);
}
void DownmixBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, const float* RESTRICT Gains)
{
for (int32 FrameIndex = 0; FrameIndex < NumFrames; FrameIndex++)
{
float* RESTRICT OutputFrame = &DestinationBuffer[FrameIndex * NumDestinationChannels];
const float* RESTRICT InputFrame = &SourceBuffer[FrameIndex * NumSourceChannels];
FMemory::Memzero(OutputFrame, NumDestinationChannels * sizeof(float));
for (int32 OutputChannelIndex = 0; OutputChannelIndex < NumDestinationChannels; OutputChannelIndex++)
{
for (int32 InputChannelIndex = 0; InputChannelIndex < NumSourceChannels; InputChannelIndex++)
{
OutputFrame[OutputChannelIndex] += InputFrame[InputChannelIndex] * Gains[InputChannelIndex * NumDestinationChannels + OutputChannelIndex];
}
}
}
}
void DownmixBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& DestinationBuffer, float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
DownmixBuffer(NumSourceChannels, NumDestinationChannels, SourceBuffer.GetData(), DestinationBuffer.GetData(), SourceBuffer.Num() / NumSourceChannels, StartGains, EndGains);
}
void DownmixBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const float* RESTRICT SourceBuffer, float* RESTRICT DestinationBuffer, int32 NumFrames, float* RESTRICT StartGains, const float* RESTRICT EndGains)
{
// First, build a map of the per-frame delta that we will use to increment StartGains every frame:
check(NumSourceChannels <= 8 && NumDestinationChannels <= 8);
alignas(16) float GainDeltas[8 * 8];
for (int32 OutputChannelIndex = 0; OutputChannelIndex < NumDestinationChannels; OutputChannelIndex++)
{
for (int32 InputChannelIndex = 0; InputChannelIndex < NumSourceChannels; InputChannelIndex++)
{
const int32 GainMatrixIndex = InputChannelIndex * NumDestinationChannels + OutputChannelIndex;
GainDeltas[GainMatrixIndex] = (EndGains[GainMatrixIndex] - StartGains[GainMatrixIndex]) / NumFrames;
}
}
for (int32 FrameIndex = 0; FrameIndex < NumFrames; FrameIndex++)
{
float* RESTRICT OutputFrame = &DestinationBuffer[FrameIndex * NumDestinationChannels];
const float* RESTRICT InputFrame = &SourceBuffer[FrameIndex * NumSourceChannels];
FMemory::Memzero(OutputFrame, NumDestinationChannels * sizeof(float));
for (int32 OutputChannelIndex = 0; OutputChannelIndex < NumDestinationChannels; OutputChannelIndex++)
{
for (int32 InputChannelIndex = 0; InputChannelIndex < NumSourceChannels; InputChannelIndex++)
{
const int32 GainMatrixIndex = InputChannelIndex * NumDestinationChannels + OutputChannelIndex;
OutputFrame[OutputChannelIndex] += InputFrame[InputChannelIndex] * StartGains[GainMatrixIndex];
StartGains[GainMatrixIndex] += GainDeltas[GainMatrixIndex];
}
}
}
}
SIGNALPROCESSING_API void DownmixAndSumIntoBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const FAlignedFloatBuffer& SourceBuffer, FAlignedFloatBuffer& BufferToSumTo, const float* RESTRICT Gains)
{
DownmixAndSumIntoBuffer(NumSourceChannels, NumDestinationChannels, SourceBuffer.GetData(), BufferToSumTo.GetData(), SourceBuffer.Num() / NumSourceChannels, Gains);
}
SIGNALPROCESSING_API void DownmixAndSumIntoBuffer(int32 NumSourceChannels, int32 NumDestinationChannels, const float* RESTRICT SourceBuffer, float* RESTRICT BufferToSumTo, int32 NumFrames, const float* RESTRICT Gains)
{
for (int32 FrameIndex = 0; FrameIndex < NumFrames; FrameIndex++)
{
float* RESTRICT OutputFrame = &BufferToSumTo[FrameIndex * NumDestinationChannels];
const float* RESTRICT InputFrame = &SourceBuffer[FrameIndex * NumSourceChannels];
for (int32 OutputChannelIndex = 0; OutputChannelIndex < NumDestinationChannels; OutputChannelIndex++)
{
for (int32 InputChannelIndex = 0; InputChannelIndex < NumSourceChannels; InputChannelIndex++)
{
OutputFrame[OutputChannelIndex] += InputFrame[InputChannelIndex] * Gains[InputChannelIndex * NumDestinationChannels + OutputChannelIndex];
}
}
}
}
/** Interleaves samples from two input buffers */
void BufferInterleave2ChannelFast(const FAlignedFloatBuffer& InBuffer1, const FAlignedFloatBuffer& InBuffer2, FAlignedFloatBuffer& OutBuffer)
{
checkf(InBuffer1.Num() == InBuffer2.Num(), TEXT("InBuffer1 Num not equal to InBuffer2 Num"));
const int32 InNum = InBuffer1.Num();
OutBuffer.Reset(2 * InNum);
OutBuffer.AddUninitialized(2 * InNum);
BufferInterleave2ChannelFast(InBuffer1.GetData(), InBuffer2.GetData(), OutBuffer.GetData(), InNum);
}
/** Interleaves samples from two input buffers */
void BufferInterleave2ChannelFast(const float* RESTRICT InBuffer1, const float* RESTRICT InBuffer2, float* RESTRICT OutBuffer, const int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InBuffer1, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InBuffer2, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
const int32 OutNum = 2 * InNum;
int32 OutPos = 0;
for (int32 i = 0; i < InNum; i += 4)
{
// Vector1[L0, L1, L2, L3]
VectorRegister Vector1 = VectorLoadAligned(&InBuffer1[i]);
// Vector2[R0, R1, R2, R3]
VectorRegister Vector2 = VectorLoadAligned(&InBuffer2[i]);
// HalfInterleaved[L0, L1, R0, R1]
VectorRegister HalfInterleaved = VectorShuffle(Vector1, Vector2, 0, 1, 0, 1);
// Interleaved[L0, R0, L1, R1]
VectorRegister Interleaved = VectorSwizzle(HalfInterleaved, 0, 2, 1, 3);
VectorStoreAligned(Interleaved, &OutBuffer[OutPos]);
OutPos += 4;
// HalfInterleaved[L2, L3, R2, R3]
HalfInterleaved = VectorShuffle(Vector1, Vector2, 2, 3, 2, 3);
// Interleaved[L2, R2, L3, R3]
Interleaved = VectorSwizzle(HalfInterleaved, 0, 2, 1, 3);
VectorStoreAligned(Interleaved, &OutBuffer[OutPos]);
OutPos += 4;
}
}
/** Deinterleaves samples from a 2 channel input buffer */
void BufferDeinterleave2ChannelFast(const FAlignedFloatBuffer& InBuffer, FAlignedFloatBuffer& OutBuffer1, FAlignedFloatBuffer& OutBuffer2)
{
const int32 InNum = InBuffer.Num();
const int32 InNumFrames = InNum / 2;
const int32 OutNum = InNumFrames;
OutBuffer1.Reset(OutNum);
OutBuffer2.Reset(OutNum);
OutBuffer1.AddUninitialized(OutNum);
OutBuffer2.AddUninitialized(OutNum);
BufferDeinterleave2ChannelFast(InBuffer.GetData(), OutBuffer1.GetData(), OutBuffer2.GetData(), InNumFrames);
}
/** Deinterleaves samples from a 2 channel input buffer */
void BufferDeinterleave2ChannelFast(const float* RESTRICT InBuffer, float* RESTRICT OutBuffer1, float* RESTRICT OutBuffer2, const int32 InNumFrames)
{
checkf(InNumFrames >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNumFrames % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InBuffer, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(OutBuffer1, 4), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutBuffer2, 4), TEXT("Memory must be aligned to use vector operations."));
int32 InNum = InNumFrames * 2;
int32 OutPos = 0;
for (int32 InPos = 0; InPos < InNum; InPos += 8)
{
// load 4 frames (2 frames per vector)
VectorRegister InVector1 = VectorLoadAligned(&InBuffer[InPos]);
VectorRegister InVector2 = VectorLoadAligned(&InBuffer[InPos + 4]);
// Write channel 0
VectorRegister OutVector = VectorShuffle(InVector1, InVector2, 0, 2, 0, 2);
VectorStoreAligned(OutVector, &OutBuffer1[OutPos]);
// Write channel 1
OutVector = VectorShuffle(InVector1, InVector2, 1, 3, 1, 3);
VectorStoreAligned(OutVector, &OutBuffer2[OutPos]);
OutPos += 4;
}
}
/** Sums 2 channel interleaved input samples. OutSamples[n] = InSamples[2n] + InSamples[2n + 1] */
void BufferSum2ChannelToMonoFast(const FAlignedFloatBuffer& InSamples, FAlignedFloatBuffer& OutSamples)
{
const int32 InNum = InSamples.Num();
const int32 Frames = InNum / 2;
OutSamples.Reset(Frames);
OutSamples.AddUninitialized(Frames);
BufferSum2ChannelToMonoFast(InSamples.GetData(), OutSamples.GetData(), Frames);
}
/** Sums 2 channel interleaved input samples. OutSamples[n] = InSamples[2n] + InSamples[2n + 1] */
void BufferSum2ChannelToMonoFast(const float* RESTRICT InSamples, float* RESTRICT OutSamples, const int32 InNumFrames)
{
checkf(InNumFrames >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNumFrames % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InSamples, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutSamples, 4), TEXT("Memory must be aligned to use vector operations."));
const int32 InNum = InNumFrames * 2;
int32 OutPos = 0;
for (int32 i = 0; i < InNum; i += 8)
{
// Load 4 frames (2 frames per vector)
// Buffer1[L0, R0, L1, R1]
VectorRegister Buffer1 = VectorLoadAligned(&InSamples[i]);
// Buffer2[L2, R2, L3, R3]
VectorRegister Buffer2 = VectorLoadAligned(&InSamples[i + 4]);
// Shuffle samples into order
// Channel0[L0, L1, L2, L3]
VectorRegister Channel0 = VectorShuffle(Buffer1, Buffer2, 0, 2, 0, 2);
// Channel1[R0, R1, R2, R3]
VectorRegister Channel1 = VectorShuffle(Buffer1, Buffer2, 1, 3, 1, 3);
// Sum left and right.
// Out[L0 + R0, L1 + R1, L2 + R2, L3 + R3]
VectorRegister Out = VectorAdd(Channel0, Channel1);
VectorStoreAligned(Out, &OutSamples[OutPos]);
OutPos += 4;
}
}
void BufferComplexToPowerFast(const FAlignedFloatBuffer& InRealSamples, const FAlignedFloatBuffer& InImaginarySamples, FAlignedFloatBuffer& OutPowerSamples)
{
checkf(InRealSamples.Num() == InImaginarySamples.Num(), TEXT("Input buffers must have equal number of elements"));
const int32 Num = InRealSamples.Num();
OutPowerSamples.Reset(Num);
OutPowerSamples.AddUninitialized(Num);
BufferComplexToPowerFast(InRealSamples.GetData(), InImaginarySamples.GetData(), OutPowerSamples.GetData(), Num);
}
void BufferComplexToPowerFast(const float* RESTRICT InRealSamples, const float* RESTRICT InImaginarySamples, float* RESTRICT OutPowerSamples, const int32 InNum)
{
checkf(InNum >= 4, TEXT("Buffer must have atleast 4 elements."));
checkf(0 == (InNum % 4), TEXT("Buffer length be a multiple of 4."));
checkf(IsAligned<const float*>(InRealSamples, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<const float*>(InImaginarySamples, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
checkf(IsAligned<float*>(OutPowerSamples, AUDIO_SIMD_FLOAT_ALIGNMENT), TEXT("Memory must be aligned to use vector operations."));
RestrictedPtrAliasCheck(InRealSamples, OutPowerSamples, InNum);
RestrictedPtrAliasCheck(InImaginarySamples, OutPowerSamples, InNum);
for (int32 i = 0; i < InNum; i += 4)
{
VectorRegister VInReal = VectorLoadAligned(&InRealSamples[i]);
VectorRegister VInRealSquared = VectorMultiply(VInReal, VInReal);
VectorRegister VInImag = VectorLoadAligned(&InImaginarySamples[i]);
VectorRegister VInImagSquared = VectorMultiply(VInImag, VInImag);
VectorRegister VOut = VectorAdd(VInRealSquared, VInImagSquared);
VectorStoreAligned(VOut, &OutPowerSamples[i]);
}
}
// class FBufferLinearEase implementation
FBufferLinearEase::FBufferLinearEase() {}
FBufferLinearEase::FBufferLinearEase(const FAlignedFloatBuffer & InSourceValues, const FAlignedFloatBuffer & InTargetValues, int32 InLerpLength)
{
Init(InSourceValues, InTargetValues, InLerpLength);
}
FBufferLinearEase::~FBufferLinearEase() {}
void FBufferLinearEase::Init(const FAlignedFloatBuffer & InSourceValues, const FAlignedFloatBuffer & InTargetValues, int32 InLerpLength)
{
check(InSourceValues.Num());
check(InTargetValues.Num());
check(InLerpLength > 0);
BufferLength = InSourceValues.Num();
check(InTargetValues.Num() == BufferLength);
LerpLength = InLerpLength;
CurrentLerpStep = 0;
// init deltas
DeltaBuffer.Reset();
DeltaBuffer.AddZeroed(BufferLength);
const float OneOverLerpLength = 1.0f / static_cast<float>(LerpLength);
BufferSubtractFast(InTargetValues.GetData(), InSourceValues.GetData(), DeltaBuffer.GetData(), BufferLength);
MultiplyBufferByConstantInPlace(DeltaBuffer, OneOverLerpLength);
}
bool FBufferLinearEase::Update(AlignedFloatBuffer & InSourceValues)
{
check(InSourceValues.Num() == BufferLength);
check(CurrentLerpStep != LerpLength);
MixInBufferFast(DeltaBuffer.GetData(), InSourceValues.GetData(), BufferLength);
if (++CurrentLerpStep == LerpLength)
{
return true;
}
return false;
}
bool FBufferLinearEase::Update(uint32 StepsToJumpForward, FAlignedFloatBuffer & InSourceValues)
{
check(InSourceValues.Num() == BufferLength);
check(CurrentLerpStep != LerpLength);
check(StepsToJumpForward);
bool bIsComplete = false;
if ((CurrentLerpStep += StepsToJumpForward) >= LerpLength)
{
StepsToJumpForward -= (CurrentLerpStep - LerpLength);
CurrentLerpStep = LerpLength;
bIsComplete = true;
}
MixInBufferFast(DeltaBuffer.GetData(), InSourceValues.GetData(), BufferLength, static_cast<float>(StepsToJumpForward));
return bIsComplete;
}
const FAlignedFloatBuffer & FBufferLinearEase::GetDeltaBuffer()
{
return DeltaBuffer;
}
}
Reference in New Issue View Git Blame Copy Permalink