LinkwitzRileyBandSplitter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "DSP/Filter.h"
#include "DSP/VariablePoleFilter.h"
#include "DSP/BufferVectorOperations.h"
 
#define  MAX_BUFFER_SIZE 8192 // 8 channels * 1024 samples
 
namespace Audio
{
    struct FLinkwitzRileyBandFilter
    {
        TArray<FVariablePoleFilter> Filters;
 
        FVariablePoleFilter& operator[](int32 InIndex) { return Filters[InIndex]; }
    };
 
    struct FMultibandBuffer
    {
        Audio::FAlignedFloatBuffer Buffer;
 
        int32 NumBands = 0;
        int32 NumSamples = 0;
 
        FMultibandBuffer() = default;
 
        FMultibandBuffer(int32 InBands, int32 InSamples)
            : NumBands(InBands)
            , NumSamples(InSamples)
        {
            Buffer.SetNumZeroed(InBands * InSamples);
        }
 
        void Init(int32 InBands, int32 InSamples)
        {
            NumBands = InBands;
            NumSamples = InSamples;
 
            Buffer.SetNumZeroed(InBands * InSamples);
        }
 
        void SetBands(int32 InBands)
        {
            NumBands = InBands;
            Reset();
        }
 
        void SetSamples(int32 InSamples)
        {
            NumSamples = InSamples;
            Reset();
        }
 
        // Zero buffers
        void Reset()
        {
            Buffer.Reset(NumSamples * NumBands);
            Buffer.AddZeroed(NumSamples * NumBands);
        }
 
        float* operator[](int32 BandIndex) { return &Buffer[BandIndex * NumSamples]; }
    };
 
    /*
     * Helper for Multi-Band processing to generate Linwitz-Riley filtered outputs from input
     * https://en.wikipedia.org/wiki/Linkwitz%E2%80%93Riley_filter
     */
    class FLinkwitzRileyBandSplitter
    {
    public:
        struct FCrossoverBandwidthPair
        {
            float Frequency = 0.f;
            float Bandwidth = 0.f;
        };
 
        FLinkwitzRileyBandSplitter() {};
 
        // initalize filters
        SIGNALPROCESSING_API void Init(const int32 InChannels,
                  const float InSampleRate,
                  const EFilterOrder FilterOrder, 
                  const bool bInPhaseCompensate,
                  const TArray<float>& InCrossovers); // Always InBands - 1 Crossovers
 
        SIGNALPROCESSING_API void ProcessAudioFrame(const float* InBuffer, FMultibandBuffer& OutBuffer);
        SIGNALPROCESSING_API void ProcessAudioBuffer(const float* InBuffer, FMultibandBuffer& OutBuffer, const int32 NumFrames);
 
        SIGNALPROCESSING_API void SetCrossovers(const TArray<float>& InCrossoverFrequencies);
 
    private:
        EFilterOrder FilterOrder = EFilterOrder::FourPole;
 
        int32 NumBands = 1;
        int32 NumChannels = 2;
        float SampleRate = 48000.f;
 
        TArray<float> SharedBuffer;
        TArray<float> BandWorkBuffer;
        FAlignedFloatBuffer SharedAlignedBuffer;
        FAlignedFloatBuffer BandAlignedBuffer;
 
        TArray<FLinkwitzRileyBandFilter> BandFilters;
        TArray<FCrossoverBandwidthPair> Crossovers;
 
        SIGNALPROCESSING_API void CopyToBuffer(float* Destination, const float* Origin, const int32 NumSamples);
        SIGNALPROCESSING_API void InvertBuffer(float* Buffer, const int32 NumSamples);
        SIGNALPROCESSING_API float GetQ(EFilterOrder InFilterOrder);
    };
}