square_osc_bank.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/denormal.hpp>
#include <pulp/signal/oscillator.hpp>
 
#include <cmath>
#include <cstddef>
#include <vector>
 
namespace pulp::signal {

template <typename SampleType = float>
class SquareOscBankT {
public:
    struct Partial {
        SampleType frequency = SampleType{0};
        SampleType amplitude = SampleType{1};
    };

    void prepare(SampleType sample_rate) {
        sample_rate_ = sample_rate > SampleType{0} ? sample_rate : SampleType{44100};
        for (auto& osc : osc_) osc.set_sample_rate(sample_rate_);
        reset();
    }

    void set_partials(const Partial* partials, std::size_t count) {
        using Wave = typename OscillatorT<SampleType>::Waveform;
        osc_.resize(count);
        amplitude_.resize(count);
        for (std::size_t i = 0; i < count; ++i) {
            osc_[i].set_sample_rate(sample_rate_);
            osc_[i].set_waveform(Wave::square);
            osc_[i].set_frequency(partials[i].frequency);
            amplitude_[i] = partials[i].amplitude;
        }
        reset();
    }

    void set_partials(const std::vector<Partial>& partials) {
        set_partials(partials.data(), partials.size());
    }
 
    std::size_t size() const noexcept { return osc_.size(); }

    void set_frequency(std::size_t index, SampleType hz) noexcept {
        if (index < osc_.size()) osc_[index].set_frequency(hz);
    }

    void set_amplitude(std::size_t index, SampleType amp) noexcept {
        if (index < amplitude_.size()) amplitude_[index] = amp;
    }
 
    SampleType frequency(std::size_t index) const noexcept {
        return index < osc_.size() ? osc_[index].frequency() : SampleType{0};
    }
 
    SampleType amplitude(std::size_t index) const noexcept {
        return index < amplitude_.size() ? amplitude_[index] : SampleType{0};
    }

    void set_level(SampleType level) noexcept { level_ = level; }
    SampleType level() const noexcept { return level_; }

    void reset() noexcept {
        for (auto& osc : osc_) osc.reset();
    }

    SampleType process() noexcept {
        SampleType sum = SampleType{0};
        const std::size_t n = osc_.size();
        for (std::size_t i = 0; i < n; ++i) {
            sum += amplitude_[i] * osc_[i].next();
        }
        return snap_to_zero(level_ * sum);
    }

    SampleType peak_bound() const noexcept {
        SampleType s = SampleType{0};
        for (SampleType a : amplitude_) s += std::abs(a);
        return std::abs(level_) * s;
    }
 
private:
    SampleType sample_rate_ = SampleType{44100};
    SampleType level_ = SampleType{1};
    std::vector<OscillatorT<SampleType>> osc_;
    std::vector<SampleType> amplitude_;
};
 
using SquareOscBank = SquareOscBankT<float>;
using SquareOscBank64 = SquareOscBankT<double>;
 
} // namespace pulp::signal