ame_Delay.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ame_AudioBuffer.hpp"
#include "ame_Math.hpp"
#include "ame_Util.hpp"
 
#include <array>
#include <cassert>
#include <cmath>
 
namespace ame::dsp
{
template <size_t MaximumChannels, size_t MaximumDelayInSamples>
class Delay
{
public:
    Delay()
    {
        readPos.changeLength (MaximumChannels * MaximumDelayInSamples);
        writePos.changeLength (MaximumChannels * MaximumDelayInSamples);
    }
    ~Delay() = default;
 
    void setDelay (const float delayInSamples)
    {
        assert (delayInSamples <= MaximumDelayInSamples);
        assert (0 <= delayInSamples);
 
        fractional = delayInSamples - static_cast<uint_fast32_t> (delayInSamples);
        readPos.set (writePos.get (-delayInSamples));
    }
 
    template <typename SampleType, size_t N>
    void process (AudioBlockView<SampleType, N>& block)
    {
        assert (block.getNumChannels() <= MaximumChannels);
 
        uint_fast32_t i = 0;
        for (uint_fast32_t samp = 0; samp < block.getNumSamplesPerChannel(); ++samp)
        {
            for (uint_fast32_t ch = 0; ch < block.getNumChannels(); ++ch)
            {
                const float input = block.view[i];
                delayLine[ch][writePos.get()] = input;
                block.view[i] = std::lerp (delayLine[ch][readPos.get()], delayLine[ch][readPos.get (-1)], fractional);
                ++i;
            }
            ++readPos;
            ++writePos;
        }
    }
 
private:
    std::array<std::array<float, MaximumDelayInSamples + 1>, MaximumChannels> delayLine {}; 
    Wrap<int32_t> readPos {};                                                               
    Wrap<int32_t> writePos {};                                                              
    float fractional = 0.0f;                                                                
};
} // namespace ame::dsp