Delay.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "DSP/AlignedBuffer.h"
#include "DSP/Dsp.h"
 
namespace Audio
{
    // Circular Buffer Delay Line
    class FDelay
    {
    public:
        // Constructor
        SIGNALPROCESSING_API FDelay();
 
        // Virtual Destructor
        SIGNALPROCESSING_API virtual ~FDelay();
 
        // Initialization of the delay with given sample rate and max buffer size in samples.
        // (calls Reset())
        SIGNALPROCESSING_API void Init(const float InSampleRate, const float InBufferLengthSec = 2.0f);
 
        // Resets the delay line state, flushes buffer and resets read/write pointers.
        // (called by Init())
        SIGNALPROCESSING_API void Reset();
        SIGNALPROCESSING_API void ResetWithFade();
        
 
        // Sets the delay line length. Will clamp to within range of the max initialized delay line length (won't resize).
        SIGNALPROCESSING_API void SetDelayMsec(const float InDelayMsec);
 
        // Same as SetDelayMsec, except in samples.
        SIGNALPROCESSING_API void SetDelaySamples(const float InDelaySamples);
 
        // Sets the delay line length but using the internal easing function for smooth delay line interpolation.
        SIGNALPROCESSING_API void SetEasedDelayMsec(const float InDelayMsec, const bool bIsInit = false);
 
        // Sets the easing factor for the delay line's internal exponential interpolator.
        SIGNALPROCESSING_API void SetEaseFactor(const float InEaseFactor);
 
        // Sets the output attenuation in DB
        SIGNALPROCESSING_API void SetOutputAttenuationDB(const float InDelayAttenDB);
 
        // Returns the current delay line length (in samples).
        float GetDelayLengthSamples() const { return DelayInSamples; }
 
        // Reads the delay line at current read index without writing or incrementing read/write pointers.
        SIGNALPROCESSING_API float Read() const;
 
        // Reads the delay line at an arbitrary time in Msec without writing or incrementing read/write pointers.
        SIGNALPROCESSING_API float ReadDelayAt(const float InReadMsec) const;
 
        // Write the input and increment read/write pointers
        SIGNALPROCESSING_API void WriteDelayAndInc(const float InDelayInput);
 
        // Process audio in the delay line, return the delayed value
        SIGNALPROCESSING_API virtual float ProcessAudioSample(const float InAudio);
 
        SIGNALPROCESSING_API virtual void ProcessAudioBuffer(const float* InAudio, int32 InNumSamples, float* OutAudio);
 
    protected:
        // Updates delay line based on any recent changes to settings
        SIGNALPROCESSING_API void Update(bool bForce = false);
 
        // Updates delay line based on any recent changes to settings
        SIGNALPROCESSING_API void ResizeIfNeeded(const int32 InNewNumSamples);
 
        // Pointer to the circular buffer of audio.
        FAlignedFloatBuffer AudioBuffer;
 
        // Max length of buffer (in samples)
        int32 AudioBufferSize;
 
        // Read index for circular buffer.
        int32 ReadIndex;
 
        // Write index for circular buffer.
        int32 WriteIndex;
 
        // Sample rate
        float SampleRate;
 
        // Delay in samples; float supports fractional delay
        float DelayInSamples;
 
        // Upper limit of where we will resize the array
        int32 MaxBufferLengthSamples;
 
        // Eased delay in msec
        FExponentialEase EaseDelayMsec;
 
        // Output attenuation value.
        float OutputAttenuation;
 
 
        // Attenuation in decibel
        float OutputAttenuationDB;
 
    private:
 
        // Used to do a quick fade-in of input after a call to "ResetWithFade()"
        float InputAttenuation = 1.f;
        float InputFadeGainStep = 0.f;
    };
 
}