VoiceDelayBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
/************************************************************************/
/* FVoiceDelayBuffer                                                    */
/* This class provides a simple template circular buffer.               */
/************************************************************************/
template<class SampleType>
class FVoiceDelayBuffer
{
private:
    TArray<SampleType> InternalBuffer;
 
    int32 WriteIndex;
    int32 ReadIndex;
 
public:
    void Init(int32 MaxLength)
    {
        check(MaxLength > 1);
        InternalBuffer.Init(0, MaxLength);
        WriteIndex = 0;
        ReadIndex = 0;
    }
 
    void SetDelay(int32 NumSamples)
    {
        const int32 Delta = WriteIndex - NumSamples;
        if (Delta < 0)
        {
            ReadIndex = InternalBuffer.Num() + Delta;
        }
        else
        {
            ReadIndex = Delta;
        }
    }
 
    /* Gets the amount of samples on the buffer. */
    int32 GetBufferCount()
    {
        if (ReadIndex > WriteIndex)
        {
            return WriteIndex + InternalBuffer.Num() - ReadIndex;
        }
        else
        {
            return WriteIndex - ReadIndex;
        }
    }
 
    void PushSample(const SampleType& InSample)
    {
        WriteIndex = WriteIndex % InternalBuffer.Num();
        InternalBuffer[WriteIndex++] = InSample;
    }
 
    void PushFrame(const SampleType* InFrame, int32 NumChannels)
    {
        for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ChannelIndex++)
        {
            PushSample(InFrame[ChannelIndex]);
        }
    }
 
    SampleType PopSample()
    {
        ReadIndex = ReadIndex % InternalBuffer.Num();
        return InternalBuffer[ReadIndex++];
    }
 
    void ProcessSample(const SampleType& InSample, SampleType& OutSample)
    {
        PushSample(InSample);
        OutSample = PopSample();
    }
 
    /* pop as much audio as possible onto OutBuffer. returns the number of samples copied. */
    int32 PopBufferedAudio(SampleType* OutBuffer, int32 MaxNumSamples)
    {
        ReadIndex = ReadIndex % InternalBuffer.Num();
        int32 SamplesToCopy = FMath::Min(MaxNumSamples, GetBufferCount());
 
        if (SamplesToCopy == 0)
        {
            return 0;
        }
 
        if (ReadIndex <= WriteIndex)
        {
            FMemory::Memcpy(OutBuffer, InternalBuffer.GetData() + ReadIndex, SamplesToCopy * sizeof(SampleType));
        }
        else
        {
            const int32 SamplesUntilEndOfBuffer = InternalBuffer.Num() - ReadIndex;
            //Copy the rest of the buffer to the end, then the remainder in the beginning.
            FMemory::Memcpy(OutBuffer, InternalBuffer.GetData() + ReadIndex, SamplesUntilEndOfBuffer * sizeof(SampleType));
            FMemory::Memcpy(OutBuffer + SamplesUntilEndOfBuffer, InternalBuffer.GetData(), (SamplesToCopy - SamplesUntilEndOfBuffer) * sizeof(SampleType));
        }
        ReadIndex = ReadIndex + SamplesToCopy;
        return SamplesToCopy;
    }
};