sub_oscillator.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <cstdint>
#include <numbers>
#include <type_traits>
 
namespace pulp::signal {

enum class SubOscillatorWaveform {
    square,
    sine,
};

template <typename SampleType = float> class SubOscillatorT {
  public:
    static_assert(std::is_same_v<SampleType, float> || std::is_same_v<SampleType, double>);

    [[nodiscard]] bool set_octave(int octave) noexcept {
        if (octave != 1 && octave != 2)
            return false;
        octave_ = octave;
        return true;
    }
 
    int octave() const noexcept {
        return octave_;
    }
 
    void set_waveform(SubOscillatorWaveform waveform) noexcept {
        waveform_ = waveform;
    }
    SubOscillatorWaveform waveform() const noexcept {
        return waveform_;
    }

    void reset(std::uint32_t completed_parent_cycles = 0) noexcept {
        cycle_index_ = completed_parent_cycles % max_divisor;
        phase_ = SampleType{0};
    }

    void on_parent_cycle() noexcept {
        cycle_index_ = (cycle_index_ + 1u) % max_divisor;
    }

    SampleType next(SampleType parent_phase) noexcept {
        if (!std::isfinite(parent_phase) || parent_phase < SampleType{0} ||
            parent_phase >= SampleType{1}) {
            reset();
            return SampleType{0};
        }
 
        phase_ = (static_cast<SampleType>(cycle_index_ % divisor()) + parent_phase) /
                 static_cast<SampleType>(divisor());
        if (waveform_ == SubOscillatorWaveform::square)
            return phase_ < SampleType{0.5} ? SampleType{1} : SampleType{-1};
        return std::sin(SampleType{2} * std::numbers::pi_v<SampleType> * phase_);
    }

    SampleType next(SampleType parent_phase, bool parent_cycle_edge) noexcept {
        if (parent_cycle_edge)
            on_parent_cycle();
        return next(parent_phase);
    }

    SampleType phase() const noexcept {
        return phase_;
    }
 
  private:
    static constexpr std::uint32_t max_divisor = 4;
 
    std::uint32_t divisor() const noexcept {
        return std::uint32_t{1} << octave_;
    }
 
    std::uint32_t cycle_index_ = 0;
    int octave_ = 1;
    SampleType phase_ = SampleType{0};
    SubOscillatorWaveform waveform_ = SubOscillatorWaveform::square;
};
 
using SubOscillator = SubOscillatorT<float>;
using SubOscillator64 = SubOscillatorT<double>;
 
} // namespace pulp::signal