UniformPartitionConvolution.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "DSP/BufferVectorOperations.h"
#include "DSP/ConvolutionAlgorithm.h"
#include "DSP/FFTAlgorithm.h"
 
namespace Audio
{
    struct FUniformPartitionConvolutionSettings
    {
        int32 NumInputChannels = 0;
 
        int32 NumOutputChannels = 0; 
 
        int32 NumImpulseResponses = 0; 
 
        int32 MaxNumImpulseResponseSamples = 0;
    };
 
    class FUniformPartitionConvolution : public IConvolutionAlgorithm
    {
        public:
            using FSharedFFTRef = TSharedRef<IFFTAlgorithm>;
 
            FUniformPartitionConvolution(const FUniformPartitionConvolutionSettings& InSettings, FSharedFFTRef InFFTAlgorithm);
 
            virtual ~FUniformPartitionConvolution();
 
            virtual int32 GetNumSamplesInBlock() const override;
 
            virtual int32 GetNumAudioInputs() const override;
 
            virtual int32 GetNumAudioOutputs() const override;
 
            virtual void ProcessAudioBlock(const float* const InSamples[], float* const OutSamples[]) override;
 
            virtual void ResetAudioHistory() override;
 
            virtual int32 GetMaxNumImpulseResponseSamples() const override;
 
            virtual int32 GetNumImpulseResponses() const override;
 
            virtual int32 GetNumImpulseResponseSamples(int32 InImpulseResponseIndex) const override;
 
            virtual void SetImpulseResponse(int32 InImpulseResponseIndex, const float* InSamples, int32 InNumSamples) override;
 
            virtual void SetMatrixGain(int32 InAudioInputIndex, int32 InImpulseResponseIndex, int32 InAudioOutputIndex, float InGain) override;
 
            virtual float GetMatrixGain(int32 InAudioInputIndex, int32 InImpulseResponseIndex, int32 InAudioOutputIndex) const override;
 
        private:
 
            // Bit mask to determine how many values to apply SIMD optimization. 
            static const int32 NumSimdMask;
 
            // Triple index into 3D mixing matrix.
            struct FInputTransformOutputGroup : public TTuple<int32, int32, int32>
            {
                FInputTransformOutputGroup(int32 InInputIndex, int32 InTransformIndex, int32 InOutputIndex)
                :   TTuple<int32, int32, int32>(InInputIndex, InTransformIndex, InOutputIndex)
                {}
 
                int32 GetInputIndex() const
                {
                    return Get<0>();
                }
 
                int32 GetTransformIndex() const
                {
                    return Get<1>();
                }
 
                int32 GetOutputIndex() const
                {
                    return Get<2>();
                }
            };
 
            // Vector optimized complex multiply add
            void VectorComplexMultiplyAdd(const FAlignedFloatBuffer& InA, const FAlignedFloatBuffer& InB, FAlignedFloatBuffer& Out) const;
 
            // Vector optimized multiply
            void VectorMultiplyByConstant(const FAlignedFloatBuffer& InBuffer, float InConstant, FAlignedFloatBuffer& OutBuffer) const;
 
            // Contains a single input channel.
            //
            // The input channel holds the FFT of the latest input block.
            struct FInput
            {
                    // 
                    FInput(FSharedFFTRef InFFTAlgorithm);
 
                    // Add one block of audio samples.
                    void PushBlock(const float* InSamples);
 
                    // Reference to latest transformed block.
                    const FAlignedFloatBuffer& GetTransformedBlock() const;
 
                    // Clears the transformed block
                    void Reset();
 
                    // Number of samples in a block
                    const int32 BlockSize;
 
                private: 
 
                    FSharedFFTRef FFTAlgorithm;
                    FAlignedFloatBuffer InputBuffer;
                    FAlignedFloatBuffer OutputBuffer;
            };
 
            // Contains a single output channel
            //
            // The output channel holds a running history of fourier transformed output blocks. 
            // When a block is popped, it converts it from the fourier domain to the time domain.
            struct FOutput
            {
                    // Construct an output
                    //
                    // @param InNumBlocks - Number of running history blocks
                    // @param InFFTAlgorithm - FFT algorithm for performing inverse FFT.
                    FOutput(int32 InNumBlocks, FSharedFFTRef InFFTAlgorithm);
 
                    ~FOutput();
 
                    // Returns the history block at the given index. 
                    FAlignedFloatBuffer& GetTransformedBlock(int32 InBlockIndex);   
 
                    // Pop the latest block without performing inverse FFT
                    void PopBlock();
 
                    // Pop the latest block and perform inverse fft.
                    // Out samples should hold InFFTAlgorithm->Size() / 2 floats. 
                    void PopBlock(float* OutSamples);
 
                    // Reset history of output blocks.
                    void Reset();
 
                    const int32 NumBlocks;
                    const int32 BlockSize;
                    const int32 NumFFTOutputFloats;
                private:
 
                    FSharedFFTRef FFTAlgorithm;
                    FAlignedFloatBuffer OutputBuffer;
 
                    int32 HeadBlockIndex;
                    TArray<FAlignedFloatBuffer> Blocks;
 
            };
 
            // Contains a single impulse response 
            //
            // The impulse response is broken into blocks and transformed to the fourier domain.
            struct FImpulseResponse
            {
                    // Constructor
                    //
                    // @params InNumBlocks - Maximum number of FFT blocks
                    // @param InFFTAlgorithm - FFT algorithm to convert samples to fourier.
                    FImpulseResponse(int32 InNumBlocks, FSharedFFTRef InFFTAlgorithm);
 
                    ~FImpulseResponse();
 
                    // Sets the impulse response.
                    void SetImpulseResponse(const float* InSamples, int32 InNum);
 
                    // Returns a block of the transformed impulse response.
                    const FAlignedFloatBuffer& GetTransformedBlock(int32 InBlockIndex) const;
 
                    // Returns the number of active blocks. This may be less than the maximum
                    // number of blocks if the impulse response is shorter than the maximum
                    // number of impulse response samples. 
                    int32 GetNumActiveBlocks() const;
 
                    // Returns the number of samples in the impulse response.
                    int32 GetNumImpulseResponseSamples() const;
 
                    const int32 NumBlocks;
                    const int32 BlockSize;
                private:
 
                    FSharedFFTRef FFTAlgorithm;
                    int32 NumFFTOutputFloats;       
                    int32 NumActiveBlocks;
                    int32 NumImpulseResponseSamples;
                    FAlignedFloatBuffer FFTInput;
                    TArray<FAlignedFloatBuffer> Blocks;
            };
 
            FUniformPartitionConvolutionSettings Settings;
 
            int32 BlockSize;
            int32 NumFFTOutputFloats;
            int32 NumBlocks;
            FAlignedFloatBuffer TransformedAndScaledInput;
            TSharedRef<IFFTAlgorithm> FFTAlgorithm;
 
            TArray<FInput> Inputs;
            TArray<FOutput> Outputs;
            TArray<FImpulseResponse> ImpulseResponses;
 
            TMap<FInputTransformOutputGroup, float> NonZeroGains;
            TArray<bool> IsOutputZero;
    };
 
    class FUniformPartitionConvolutionFactory : public IConvolutionAlgorithmFactory
    {
        public:
            virtual ~FUniformPartitionConvolutionFactory();
 
            virtual const FName GetFactoryName() const override;
 
            virtual bool IsHardwareAccelerated() const override;
 
            virtual bool AreConvolutionSettingsSupported(const FConvolutionSettings& InSettings) const override;
 
            virtual TUniquePtr<IConvolutionAlgorithm> NewConvolutionAlgorithm(const FConvolutionSettings& InSettings) override;
 
        private:
 
            // Convert the convolution settings into FFTAlgorithm settings.
            static FFFTSettings FFTSettingsFromConvolutionSettings(const FConvolutionSettings& InConvolutionSettings);
    };
}