transport_edge.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/detail/modular_sequencing_common.hpp>
#include <pulp/signal/trigger_kit.hpp>
#include <pulp/signal/units.hpp>
 
#include <cmath>
#include <cstdint>
 
namespace pulp::signal {
 
// ── Transport front end ───────────────────────────────────────────────────

template <typename SampleType = float>
class TransportEdgeT {
public:
    static constexpr double kRefractoryMs = 0.5;

    struct Frame {
        bool run_high = false;
        bool reset_edge = false;
        bool clock_edge = false;
    };
 
    void prepare(double sample_rate) {
        if (std::isfinite(sample_rate) && sample_rate > 0.0) sample_rate_ = sample_rate;
        update();
    }

    static constexpr double kMaxRefractoryMs = 1000.0;
 
    void set_refractory_ms(double ms) {
        refractory_ms_ = seq_detail::clamp_finite(ms, 0.0, kMaxRefractoryMs);
        update();
    }

    void set_thresholds(double high, double low) {
        run_.set_thresholds(high, low);
        reset_.set_thresholds(high, low);
        clock_.set_thresholds(high, low);
    }
 
    void reset() {
        run_.reset();
        reset_.reset();
        clock_.reset();
        refractory_ = 0;
    }
 
    static constexpr int latency_samples() { return 0; }

    Frame process(SampleType run, SampleType reset_in, SampleType clock) {
        Frame f{};
        run_.process(run);
        f.run_high = run_.high();
 
        const bool raw_reset = reset_.process(reset_in);
        if (refractory_ > 0) --refractory_;
        if (raw_reset && refractory_ == 0) {
            f.reset_edge = true;
            refractory_ = refractory_samples_;
        }
 
        f.clock_edge = clock_.process(clock);
        return f;
    }

    Frame process(SampleType run, SampleType reset_in) {
        return process(run, reset_in, SampleType{0});
    }
 
private:
    void update() {
        refractory_samples_ = static_cast<std::int64_t>(
            std::llround(units::ms_to_samples(refractory_ms_, sample_rate_)));
        if (refractory_samples_ < 0) refractory_samples_ = 0;
    }
 
    double sample_rate_ = 44100.0;
    double refractory_ms_ = kRefractoryMs;
    std::int64_t refractory_samples_ = 0;
    std::int64_t refractory_ = 0;
    HystereticTriggerDetectT<SampleType> run_{};
    HystereticTriggerDetectT<SampleType> reset_{};
    HystereticTriggerDetectT<SampleType> clock_{};
};
 
using TransportEdge = TransportEdgeT<float>;
using TransportEdge64 = TransportEdgeT<double>;
 
}  // namespace pulp::signal