ladder_bank.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/denormal.hpp>
#include <pulp/signal/ladder_filter.hpp>
 
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <type_traits>
 
namespace pulp::signal {

template <typename SampleType = float, std::size_t Voices = 16> class LadderBankT {
    static_assert(Voices > 0, "LadderBankT needs at least one voice");
 
  public:
    using Filter = LadderFilterT<SampleType>;
    static constexpr std::size_t voice_count = Voices;
 
    LadderBankT() {
        std::fill(std::begin(cutoff_), std::end(cutoff_), SampleType{1000.0f});
    }

    void set_sample_rate(SampleType sample_rate) {
        sample_rate_ = sample_rate;
        for (std::size_t v = 0; v < Voices; ++v)
            update(v);
    }
 
    SampleType sample_rate() const {
        return sample_rate_;
    }
 
    void set_frequency(std::size_t voice, SampleType hz) {
        if (voice >= Voices)
            return;
        cutoff_[voice] = hz;
        update(voice);
    }
 
    void set_resonance(std::size_t voice, SampleType resonance) {
        if (voice >= Voices)
            return;
        resonance_[voice] = std::clamp(resonance, SampleType{0.0f}, SampleType{1.0f});
        update(voice);
    }
 
    SampleType frequency(std::size_t voice) const {
        return voice < Voices ? cutoff_[voice] : SampleType{};
    }
    SampleType resonance(std::size_t voice) const {
        return voice < Voices ? resonance_[voice] : SampleType{};
    }

    SampleType stage_coefficient(std::size_t voice) const {
        return voice < Voices ? g_[voice] : SampleType{};
    }

    void process(const SampleType* in, SampleType* out) {
        SampleType prev[Voices];
        for (std::size_t v = 0; v < Voices; ++v) {
            const SampleType input = in[v];
            const SampleType feedback =
                resonance_[v] * SampleType{4.0f} * (stage_[3][v] - input * SampleType{0.5f});
            prev[v] = saturate(input - feedback);
        }
        for (int i = 0; i < 4; ++i) {
            SampleType* stage = stage_[i];
            SampleType* saturated = saturated_stage_[i];
            for (std::size_t v = 0; v < Voices; ++v) {
                stage[v] = detail::snap_to_zero_bits(stage[v] + g_[v] * (prev[v] - saturated[v]));
                saturated[v] = saturate(stage[v]);
                prev[v] = saturated[v];
            }
        }
        for (std::size_t v = 0; v < Voices; ++v)
            out[v] = stage_[3][v];
    }

    void process_voices(SampleType* const* buffers, std::size_t num_samples) {
        SampleType frame[Voices];
        for (std::size_t n = 0; n < num_samples; ++n) {
            for (std::size_t v = 0; v < Voices; ++v)
                frame[v] = buffers[v][n];
            process(frame, frame);
            for (std::size_t v = 0; v < Voices; ++v)
                buffers[v][n] = frame[v];
        }
    }

    void reset(std::size_t voice) {
        if (voice >= Voices)
            return;
        for (int i = 0; i < 4; ++i) {
            stage_[i][voice] = SampleType{0};
            saturated_stage_[i][voice] = SampleType{0};
        }
    }

    void reset() {
        for (std::size_t v = 0; v < Voices; ++v)
            reset(v);
    }
 
  private:
    // The scalar filter's saturator; for the accurate float saturator, its
    // bit-operation form, so the per-stage loop over voices vectorizes under
    // GCC as well as Clang (same values).
    static SampleType saturate(SampleType x) {
        if constexpr (std::is_same_v<SampleType, float> &&
                      kDefaultLadderSaturation == LadderSaturation::accurate)
            return detail::tanh_accurate_bits(x);
        else
            return Filter::template saturate<kDefaultLadderSaturation>(x);
    }
 
    void update(std::size_t voice) {
        g_[voice] = Filter::stage_coefficient(cutoff_[voice], sample_rate_);
    }
 
    SampleType sample_rate_ = SampleType{44100.0f};
    SampleType cutoff_[Voices];
    SampleType resonance_[Voices] = {};
    SampleType g_[Voices] = {};
    SampleType stage_[4][Voices] = {};
    SampleType saturated_stage_[4][Voices] = {};
};
 
template <std::size_t Voices = 16> using LadderBank = LadderBankT<float, Voices>;
 
} // namespace pulp::signal