Reverb.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "DSP/Delay.h"
#include "DSP/AllPassFilter.h"
#include "DSP/OnePole.h"
 
namespace Audio
{
    // forward
    class FWaveTableOsc;
 
    struct FEarlyReflectionsSettings
    {
        // Early reflections gain
        float Gain;
 
        // Delay between input signal and early reflections
        float PreDelayMsec;
 
        // Input sample bandwidth before entering early reflections
        float Bandwidth;
 
        // Early reflections decay (lower value is longer)
        float Decay;
 
        // Early reflection high frequency absorption factor
        float Absorption;
 
        FEarlyReflectionsSettings()
            : Gain(1.0f)
            , PreDelayMsec(0.0f)
            , Bandwidth(0.8)
            , Decay(0.5)
            , Absorption(0.7)
        {}
    };
 
    // Basic implementation of a 4x4 Feedback Delay Network
    class FEarlyReflections
    {
    public:
        SIGNALPROCESSING_API FEarlyReflections();
        SIGNALPROCESSING_API virtual ~FEarlyReflections();
 
        SIGNALPROCESSING_API void Init(const int32 InSampleRate);
 
        // Sets the reverb settings, applies, and updates
        SIGNALPROCESSING_API void SetSettings(const FEarlyReflectionsSettings& InSettings);
 
        // Process the single audio frame
        SIGNALPROCESSING_API void ProcessAudioFrame(const float* InBuffer, const int32 InChannels, float* OutBuffer, const int32 OutChannels);
 
    protected:
        SIGNALPROCESSING_API void ApplySettings();
        SIGNALPROCESSING_API float ProcessDelayLine(const float InSample, FDelayAPF& InAPF, FOnePoleLPF& InLPF);
 
        FEarlyReflectionsSettings Settings;
 
        struct FFDNDelayData
        {
            // Pre-Delay for the input audio to the FDN reverberator
            FDelay PreDelay;
 
            // Input LPF for early reflections
            FOnePoleLPF InputLPF;
 
            // 4 feedback delay lines per input channel (stereo) which feed into each other using a normalized feedback matrix
            FDelayAPF APF[4];
            FOnePoleLPF LPF[4];
 
            float DelayLineInputs[4];
            float DelayLineOuputs[4];
        };
 
        float MatrixScaleFactor;
 
        // Stereo input/output for early reflections
        FFDNDelayData Data[2];
    };
 
    struct FPlateReverbSettings
    {
        // The settings for the early reflections part of the reverb
        FEarlyReflectionsSettings EarlyReflections;
 
        // Milliseconds for the predelay
        float LateDelayMsec;
 
        // Initial attenuation of audio after it leaves the predelay
        float LateGain;
 
        // Frequency bandwidth of audio going into input diffusers. 0.999 is full bandwidth
        float Bandwidth;
 
        // Amount of input diffusion (larger value results in more diffusion)
        float Diffusion;
 
        // The amount of high-frequency dampening in plate feedback paths
        float Dampening;
 
        // The amount of decay in the feedback path. Lower value is larger reverb time.
        float Decay;
 
        // The amount of diffusion in decay path. Larger values is a more dense reverb.
        float Density;
 
        // The amount of output wetness of the reverb as a whole
        float Wetness;
 
        FPlateReverbSettings()
            : LateDelayMsec(0.0f)
            , LateGain(0.0f)
            , Bandwidth(0.5f)
            , Diffusion(0.5f)
            , Dampening(0.5f)
            , Decay(0.5f)
            , Density(0.5f)
            , Wetness(0.5f)
        {}
    };
 
    class FPlateReverb
    {
    public:
        SIGNALPROCESSING_API FPlateReverb();
        SIGNALPROCESSING_API ~FPlateReverb();
 
        // Initialize the reverb with the given sample rate
        SIGNALPROCESSING_API void Init(const int32 InSampleRate);
 
        // Whether or not to enable late reflections
        SIGNALPROCESSING_API void EnableLateReflections(const bool bInEnableLateReflections);
 
        // Whether or not to enable late reflections
        SIGNALPROCESSING_API void EnableEarlyReflections(const bool bInEnableEarlyReflections);
 
        // Sets the reverb settings, applies, and updates
        SIGNALPROCESSING_API void SetSettings(const FPlateReverbSettings& InSettings);
 
        // Process the single audio frame
        SIGNALPROCESSING_API void ProcessAudioFrame(const float* InBuffer, const int32 InChannels, float* OutBuffer, const int32 OutChannels);
 
    protected:
 
        SIGNALPROCESSING_API void ApplySettings();
 
        // Current parameter settings of reverb
        FPlateReverbSettings Settings;
 
        // Early reflections effect
        FEarlyReflections EarlyReflections;
 
        // Sample rate used for hard-coded delay line values
        static const int32 PresetSampleRate = 29761;
 
        // A simple pre-delay line to emulate large delays for late-reflections
        FDelay PreDelay;
 
        // Input diffusion
        FOnePoleLPF InputLPF;
        FDelayAPF APF1;
        FDelayAPF APF2;
        FDelayAPF APF3;
        FDelayAPF APF4;
 
        // Wave table oscillator, modulates input APF in plates
        TSharedPtr<FWaveTableOsc> LFO;
 
        // Plate data struction to organize each plate's delay lines and filters
        struct FPlate
        {
            FDelayAPF ModulatedAPF;
            FDelay Delay1;
            FOnePoleLPF LPF;
            FDelayAPF APF;
            FDelay Delay2;
 
            // Sample output of tank
            float PreviousSample;
            float ModulatedBaseDelayMsec;
            float ModulatedDeltaDelayMsec;
 
            FPlate()
                : PreviousSample(0.0f)
                , ModulatedBaseDelayMsec(0.0f)
                , ModulatedDeltaDelayMsec(0.0f)
            {}
        };
 
        // The plate data
        FPlate LeftPlate;
        FPlate RightPlate;
 
        // Tap points to read audio from various delay lines in plates
        static const int32 NumTaps = 7;
 
        float LeftTaps[NumTaps];
        float RightTaps[NumTaps];
 
        // Whether or not late reflections are enabled
        bool bEnableLateReflections;
 
        // Whether or not to enable early reflections
        bool bEnableEarlyReflections;
    };
}