granular.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/denormal.hpp>
#include <pulp/signal/interpolator.hpp>
#include <pulp/signal/panner.hpp>
#include <pulp/signal/rng.hpp>
#include <pulp/signal/smoothed_value.hpp>
#include <pulp/signal/units.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <vector>
 
namespace pulp::signal {

enum class GrainSource : std::uint8_t {
    buffer,     
    live_ring,  
};

enum class Coherence : std::uint8_t {
    incoherent,  
    coherent,    
};

enum class StealPolicy : std::uint8_t {
    oldest,    
    quietest,  
    drop_new,  
};

enum class GrainInterp : std::uint8_t {
    linear,         
    cubic_hermite,  
};

struct GrainView {
    bool active = false;
    double phase = 0.0;
    double read_position = 0.0;
    double ratio = 1.0;
    double gain = 0.0;
    double pan_left = 0.0;
    double pan_right = 0.0;
};
 
template <typename SampleType = float>
class GranularEngineT {
public:
    // ── Fixed capacities ──────────────────────────────────────────────────

    static constexpr int kMaxGrainBudget = 64;

    static constexpr int kMinGrainBudget = 32;

    static constexpr int kDefaultMaxGrains = 48;

    static constexpr int kWindowTableSize = 2048;

    static constexpr double kRingSeconds = 4.0;
 
    // ── Parameter ranges ──────────────────────────────────────────────────

    static constexpr double kDefaultDensityHz = 40.0;
    static constexpr double kMinDensityHz = 0.1;
    static constexpr double kMaxDensityHz = 2000.0;

    static constexpr double kDefaultGrainMs = 50.0;
    static constexpr double kMinGrainMs = 1.0;
    static constexpr double kMaxGrainMs = 500.0;

    static constexpr double kDefaultJitter = 0.0;

    static constexpr double kMaxPositionSprayMs = 500.0;

    static constexpr double kDefaultStretch = 1.0;
    static constexpr double kMaxStretch = 4.0;

    static constexpr double kMaxPitchSemitones = 24.0;

    static constexpr double kMaxPitchSpraySemitones = 12.0;

    static constexpr double kMinLevelDb = -24.0;
    static constexpr double kMaxLevelDb = 12.0;

    static constexpr std::uint32_t kDefaultSeed = 0x9E3779B9u;

    static constexpr double kControlSmoothingMs = 10.0;

    static constexpr double kMinDrawForLog = 1e-12;

    static constexpr double kMinOnsetIntervalSamples = 1.0;
 
    // ── Keyed-draw field ids ──────────────────────────────────────────────
    // Distinct ids keep draws that share a grain index from being perfectly
    // correlated. Values are arbitrary but must never be reused or reordered:
    // changing one changes every render made with a given seed.
    static constexpr std::uint64_t kFieldOnsetJitter = 1;
    static constexpr std::uint64_t kFieldPositionSpray = 2;
    static constexpr std::uint64_t kFieldPitchSpray = 3;
    static constexpr std::uint64_t kFieldPanSpray = 4;
 
    GranularEngineT() {
        panner_.set_law(PanLaw::EqualPower);
        rebuild_window();
    }
 
    // ── Lifecycle ─────────────────────────────────────────────────────────

    void prepare(double sample_rate) {
        sample_rate_ = std::isfinite(sample_rate) && sample_rate > 0.0 ? sample_rate
                                                                       : sample_rate_;
        ring_length_ = static_cast<int>(std::ceil(kRingSeconds * sample_rate_));
        ring_.assign(static_cast<std::size_t>(ring_length_), SampleType{0});
        guard_samples_ = derived_guard_samples(sample_rate_);
        level_.set_ramp_time(kControlSmoothingMs * 0.001, sample_rate_);
        mix_.set_ramp_time(kControlSmoothingMs * 0.001, sample_rate_);
        rebuild_window();
        reset();
    }

    void reset() {
        std::fill(ring_.begin(), ring_.end(), SampleType{0});
        reset_runtime_state();
    }
 
private:
    void audio_fault_reset() {
        reset_runtime_state();
    }
 
    void reset_runtime_state() {
        for (auto& grain : grains_) grain = Grain{};
        write_head_ = 0;
        sample_clock_ = 0;
        grain_index_ = 0;
        next_onset_ = 0.0;
        steal_count_ = 0;
        clamp_count_ = 0;
        playhead_ = position01_ * static_cast<double>(std::max(buffer_length_, 1));
        live_centre_ = 0.0;
        level_.set_immediate(units::db_to_linear(level_db_));
        mix_.set_immediate(mix_target_);
    }
 
public:
    // ── Source ────────────────────────────────────────────────────────────
 
    void set_source(GrainSource source) { source_ = source; }
    GrainSource source() const { return source_; }

    void set_buffer(const SampleType* data, int length, int channels) {
        buffer_ = data;
        buffer_length_ = std::max(length, 0);
        buffer_channels_ = std::max(channels, 1);
        playhead_ = position01_ * static_cast<double>(std::max(buffer_length_, 1));
    }

    void write_live(const SampleType* in, int n) {
        if (ring_length_ <= 0) return;
        // Live freeze holds the captured material, not merely its nominal
        // centre while the ring overwrites it underneath us.
        if (!accepts_live_input()) return;
        for (int i = 0; i < n; ++i) {
            if (!std::isfinite(static_cast<double>(in[i]))) {
                audio_fault_reset();
                continue;
            }
            write_one(in[i]);
        }
    }

    void set_stretch(double rate) {
        if (!std::isfinite(rate)) return;
        stretch_ = std::clamp(rate, 0.0, kMaxStretch);
    }
    double stretch() const { return stretch_; }

    void set_position(double pos01) {
        if (!std::isfinite(pos01)) return;
        position01_ = std::clamp(pos01, 0.0, 1.0);
        if (source_ == GrainSource::buffer) {
            playhead_ = position01_ * static_cast<double>(std::max(buffer_length_, 1));
        }
    }
    double position() const { return position01_; }
 
    void set_position_spray_ms(double ms) {
        if (!std::isfinite(ms)) return;
        position_spray_ms_ = std::clamp(ms, 0.0, kMaxPositionSprayMs);
    }
    double position_spray_ms() const { return position_spray_ms_; }
 
    // ── Schedule ──────────────────────────────────────────────────────────
 
    void set_density_hz(double hz) {
        if (!std::isfinite(hz)) return;
        density_hz_ = std::clamp(hz, kMinDensityHz, kMaxDensityHz);
    }
    double density_hz() const { return density_hz_; }
 
    void set_grain_ms(double ms) {
        if (!std::isfinite(ms)) return;
        grain_ms_ = std::clamp(ms, kMinGrainMs, kMaxGrainMs);
    }
    double grain_ms() const { return grain_ms_; }

    void set_async_jitter(double j01) {
        if (!std::isfinite(j01)) return;
        jitter_ = std::clamp(j01, 0.0, 1.0);
    }
    double async_jitter() const { return jitter_; }

    void set_max_grains(int count) {
        const int clamped = std::clamp(count, kMinGrainBudget, kMaxGrainBudget);
        for (int i = clamped; i < max_grains_; ++i) grains_[static_cast<std::size_t>(i)].active = false;
        max_grains_ = clamped;
    }
    int max_grains() const { return max_grains_; }
 
    void set_steal_policy(StealPolicy policy) { steal_policy_ = policy; }
    StealPolicy steal_policy() const { return steal_policy_; }
 
    // ── Per-grain shaping ─────────────────────────────────────────────────

    void set_window_taper(double t01) {
        if (!std::isfinite(t01)) return;
        taper_ = std::clamp(t01, 0.0, 1.0);
        rebuild_window();
    }
    double window_taper() const { return taper_; }
 
    void set_window_trapezoid(bool trapezoid) {
        trapezoid_ = trapezoid;
        rebuild_window();
    }
    bool window_trapezoid() const { return trapezoid_; }
 
    void set_pitch_semitones(double st) {
        if (!std::isfinite(st)) return;
        pitch_st_ = std::clamp(st, -kMaxPitchSemitones, kMaxPitchSemitones);
    }
    double pitch_semitones() const { return pitch_st_; }
 
    void set_pitch_spray_semitones(double st) {
        if (!std::isfinite(st)) return;
        pitch_spray_st_ = std::clamp(st, 0.0, kMaxPitchSpraySemitones);
    }
 
    void set_pan_spray(double s01) {
        if (!std::isfinite(s01)) return;
        pan_spray_ = std::clamp(s01, 0.0, 1.0);
    }
 
    void set_coherence(Coherence coherence) { coherence_ = coherence; }
    Coherence coherence() const { return coherence_; }
 
    void set_interp(GrainInterp interp) { interp_ = interp; }
    GrainInterp interp() const { return interp_; }
 
    void set_level_db(double db) {
        if (!std::isfinite(db)) return;
        level_db_ = std::clamp(db, kMinLevelDb, kMaxLevelDb);
        level_.set_target(units::db_to_linear(level_db_));
    }

    void set_mix(double mix01) {
        if (!std::isfinite(mix01)) return;
        mix_target_ = std::clamp(mix01, 0.0, 1.0);
        mix_.set_target(mix_target_);
    }
    double mix() const { return mix_target_; }

    void set_seed(std::uint32_t seed) { seed_ = seed; }
    std::uint32_t seed() const { return seed_; }
 
    // ── Queries ───────────────────────────────────────────────────────────

    std::size_t latency_samples() const { return 0; }

    double mean_overlap() const { return density_hz_ * grain_ms_ * 0.001; }

    double grain_gain() const {
        const double overlap = std::max(mean_overlap(), 1e-9);
        const double raw = coherence_ == Coherence::incoherent
                               ? 1.0 / (window_rms_ * std::sqrt(overlap))
                               : 1.0 / (window_mean_ * overlap);
        return std::min(1.0, raw);
    }

    double window_mean() const { return window_mean_; }
    double window_rms() const { return window_rms_; }

    double window_at(double phase) const {
        const double x = std::clamp(phase, 0.0, 1.0) * static_cast<double>(kWindowTableSize);
        int index = static_cast<int>(x);
        if (index >= kWindowTableSize) index = kWindowTableSize - 1;
        const double frac = x - static_cast<double>(index);
        const double a = window_[static_cast<std::size_t>(index)];
        const double b = window_[static_cast<std::size_t>(index) + 1];
        return a + frac * (b - a);
    }
 
    int active_grain_count() const {
        int count = 0;
        for (int i = 0; i < max_grains_; ++i) {
            if (grains_[static_cast<std::size_t>(i)].active) ++count;
        }
        return count;
    }
 
    GrainView grain(int slot) const {
        GrainView view;
        if (slot < 0 || slot >= kMaxGrainBudget) return view;
        const Grain& g = grains_[static_cast<std::size_t>(slot)];
        view.active = g.active;
        view.phase = g.phase;
        view.read_position = g.read_position;
        view.ratio = g.ratio;
        view.gain = g.gain;
        view.pan_left = g.pan_left;
        view.pan_right = g.pan_right;
        return view;
    }

    std::uint64_t grain_index() const { return grain_index_; }

    std::uint64_t steal_count() const { return steal_count_; }

    std::uint64_t clamp_count() const { return clamp_count_; }
 
    int ring_length() const { return ring_length_; }

    SampleType ring_storage_sample(int index) const {
        if (index < 0 || index >= ring_length_) return SampleType{0};
        return ring_[static_cast<std::size_t>(index)];
    }

    int causality_guard_samples() const { return guard_samples_; }
 
    static int derived_guard_samples(double sample_rate) {
        const double r_max = std::exp2(kMaxPitchSemitones / 12.0);
        return static_cast<int>(
            std::ceil(sample_rate * (kMaxPositionSprayMs * 0.001 + kMaxGrainMs * 0.001 * r_max)));
    }
 
    // ── Render ────────────────────────────────────────────────────────────

    void process(SampleType* out_left, SampleType* out_right, int n) {
        render(nullptr, out_left, out_right, n);
    }

    void process(const SampleType* in, SampleType* out_left, SampleType* out_right, int n) {
        render(in, out_left, out_right, n);
    }
 
private:
    bool accepts_live_input() const {
        return source_ != GrainSource::live_ring || stretch_ != 0.0;
    }
 
    struct Grain {
        bool active = false;
        double phase = 0.0;
        double phase_increment = 0.0;
        double read_position = 0.0;
        double ratio = 1.0;
        double gain = 0.0;
        double pan_left = 0.0;
        double pan_right = 0.0;
    };
 
    static constexpr double kPi = 3.14159265358979323846;
 
    // ── Window table ──────────────────────────────────────────────────────

    void rebuild_window() {
        window_.resize(static_cast<std::size_t>(kWindowTableSize) + 1);
        for (int i = 0; i <= kWindowTableSize; ++i) {
            window_[static_cast<std::size_t>(i)] =
                window_shape(static_cast<double>(i) / static_cast<double>(kWindowTableSize));
        }
        // Mean and RMS over the half-open phase domain [0, 1): the last table
        // entry is the wrap guard for interpolation and would double-count the
        // p = 0 point.
        double sum = 0.0;
        double sum_squares = 0.0;
        for (int i = 0; i < kWindowTableSize; ++i) {
            const double w = window_[static_cast<std::size_t>(i)];
            sum += w;
            sum_squares += w * w;
        }
        window_mean_ = sum / static_cast<double>(kWindowTableSize);
        window_rms_ = std::sqrt(sum_squares / static_cast<double>(kWindowTableSize));
    }
 
    double window_shape(double p) const {
        if (taper_ <= 0.0) return 1.0;
        const double half = 0.5 * taper_;
        const double edge = p < half ? p : (p > 1.0 - half ? 1.0 - p : half);
        if (edge >= half) return 1.0;
        const double t = edge / half;  // 0 at the grain edge, 1 where the flat top starts
        if (trapezoid_) return t;
        // Cosine taper. At taper = 1 the two halves meet at p = 0.5 and this is
        // exactly Hann: 0.5·(1 − cos(2πp)) = sin²(πp).
        return 0.5 * (1.0 - std::cos(kPi * t));
    }
 
    // ── Schedule ──────────────────────────────────────────────────────────

    double onset_interval_samples(std::uint64_t k) const {
        const double h = sample_rate_ / density_hz_;
        if (jitter_ <= 0.0) return h;
        double u = unit_from<double>(mix64(seed_, k, kFieldOnsetJitter));
        if (u < kMinDrawForLog) u = kMinDrawForLog;
        const double exponential = -std::log(u) * h;
        const double blended = (1.0 - jitter_) * h + jitter_ * exponential;
        return std::max(blended, kMinOnsetIntervalSamples);
    }
 
    int allocate_slot() {
        for (int i = 0; i < max_grains_; ++i) {
            if (!grains_[static_cast<std::size_t>(i)].active) return i;
        }
        if (steal_policy_ == StealPolicy::drop_new) return -1;
 
        int best = 0;
        if (steal_policy_ == StealPolicy::oldest) {
            // Furthest through its window. With equal durations that is also the
            // quietest, which is why stealing is click-free.
            double best_phase = -1.0;
            for (int i = 0; i < max_grains_; ++i) {
                const double phase = grains_[static_cast<std::size_t>(i)].phase;
                if (phase > best_phase) {
                    best_phase = phase;
                    best = i;
                }
            }
        } else {
            double best_level = 1e300;
            for (int i = 0; i < max_grains_; ++i) {
                const Grain& g = grains_[static_cast<std::size_t>(i)];
                const double level = window_at(g.phase) * g.gain;
                if (level < best_level) {
                    best_level = level;
                    best = i;
                }
            }
        }
        ++steal_count_;
        return best;
    }
 
    void spawn(std::uint64_t k) {
        const double u_position = unit_from<double>(mix64(seed_, k, kFieldPositionSpray));
        const double u_pitch = unit_from<double>(mix64(seed_, k, kFieldPitchSpray));
        const double u_pan = unit_from<double>(mix64(seed_, k, kFieldPanSpray));
 
        const double semitones = pitch_st_ + (u_pitch * 2.0 - 1.0) * pitch_spray_st_;
        Grain next{};
        next.ratio = units::semitones_to_ratio(semitones);
 
        const double grain_seconds = grain_ms_ * 0.001;
        next.phase = 0.0;
        next.phase_increment = 1.0 / std::max(grain_seconds * sample_rate_, 1.0);
        next.gain = grain_gain();
 
        const double spray =
            (u_position * 2.0 - 1.0) * units::ms_to_samples(position_spray_ms_, sample_rate_);
        const double requested_read = source_ == GrainSource::buffer ? playhead_ + spray
                                                                     : live_centre_ - spray;
        if (source_ == GrainSource::buffer) {
            next.read_position = requested_read;
        } else if (!place_live_read(requested_read, next.ratio, grain_seconds,
                                    next.read_position)) {
            // Nothing valid to read yet — the ring has not captured enough past.
            // The grain is skipped rather than placed on unwritten samples;
            // `grain_index_` still advances, so no draw shifts and determinism
            // is untouched.
            return;
        }
 
        // Placement is known-good before a sounding slot can be selected. A
        // failed live birth therefore cannot partially overwrite a victim or
        // count as a steal.
        const int slot = allocate_slot();
        if (slot < 0) return;
        if (next.read_position != requested_read) ++clamp_count_;
 
        panner_.set_pan(std::clamp((u_pan * 2.0 - 1.0) * pan_spray_, -1.0, 1.0));
        panner_.compute_gains(next.pan_left, next.pan_right);
 
        next.active = true;
        grains_[static_cast<std::size_t>(slot)] = next;
    }

    bool place_live_read(double start, double ratio, double grain_seconds, double& out) {
        const double duration = grain_seconds * sample_rate_;
        const double head = static_cast<double>(write_head_);
        const double newest = head - std::max(0.0, ratio - 1.0) * duration - 2.0;
        const double oldest =
            std::max(0.0, head - static_cast<double>(ring_length_) +
                              std::max(0.0, 1.0 - ratio) * duration) +
            2.0;
        if (newest < oldest) return false;
        out = std::clamp(start, oldest, newest);
        return true;
    }
 
    // ── Source reads ──────────────────────────────────────────────────────
 
    void write_one(SampleType x) {
        ring_[static_cast<std::size_t>(write_head_ % ring_length_)] = x;
        ++write_head_;
    }

    static int wrap_index(std::int64_t index, int length) {
        std::int64_t m = index % length;
        if (m < 0) m += length;
        return static_cast<int>(m);
    }
 
    double buffer_frame(std::int64_t frame) const {
        if (buffer_ == nullptr || buffer_length_ <= 0) return 0.0;
        const int index = wrap_index(frame, buffer_length_);
        // Multi-channel folds to mono as the channel MEAN, not the sum, so a
        // stereo source does not arrive 6 dB hotter than a mono one and the
        // normalization law stays valid for both.
        double sum = 0.0;
        for (int c = 0; c < buffer_channels_; ++c) {
            const double sample = static_cast<double>(
                buffer_[static_cast<std::size_t>(index) * static_cast<std::size_t>(buffer_channels_) +
                        static_cast<std::size_t>(c)]);
            if (!std::isfinite(sample)) return 0.0;
            sum += sample;
        }
        return sum / static_cast<double>(buffer_channels_);
    }
 
    double ring_sample(std::int64_t index) const {
        if (ring_length_ <= 0) return 0.0;
        return static_cast<double>(ring_[static_cast<std::size_t>(wrap_index(index, ring_length_))]);
    }
 
    double read_source(double position) const {
        const double floored = std::floor(position);
        const auto base = static_cast<std::int64_t>(floored);
        const double t = position - floored;
 
        double y0 = 0.0;
        double y1 = 0.0;
        if (source_ == GrainSource::buffer) {
            y0 = buffer_frame(base);
            y1 = buffer_frame(base + 1);
        } else {
            y0 = ring_sample(base);
            y1 = ring_sample(base + 1);
        }
        if (interp_ == GrainInterp::linear) return Interpolator::linear(t, y0, y1);
 
        const double ym1 =
            source_ == GrainSource::buffer ? buffer_frame(base - 1) : ring_sample(base - 1);
        const double y2 =
            source_ == GrainSource::buffer ? buffer_frame(base + 2) : ring_sample(base + 2);
        // Catmull-Rom, from the shared interpolator rather than a second copy of
        // the same four coefficients.
        return Interpolator::hermite(t, ym1, y0, y1, y2);
    }
 
    // ── Render core ───────────────────────────────────────────────────────
 
    void render(const SampleType* in, SampleType* out_left, SampleType* out_right, int n) {
        const double buffer_span = static_cast<double>(std::max(buffer_length_, 1));
        for (int i = 0; i < n; ++i) {
            const double input_sample = in != nullptr ? static_cast<double>(in[i]) : 0.0;
            if (in != nullptr && !std::isfinite(input_sample)) {
                // Live input is ring history and the interleaved overload also
                // exposes it as dry audio. Reject it before either path sees it,
                // then restart from the documented fresh state.
                audio_fault_reset();
                out_left[i] = SampleType{0};
                out_right[i] = SampleType{0};
                continue;
            }
            if (in != nullptr && accepts_live_input()) {
                write_one(in[i]);
            }
 
            if (source_ == GrainSource::live_ring && stretch_ > 0.0) {
                live_centre_ = static_cast<double>(write_head_) -
                               position01_ * static_cast<double>(ring_length_);
            }
 
            // Spawn every grain whose onset has arrived. Driven by the absolute
            // sample clock, so where the block boundaries fall changes nothing.
            while (next_onset_ <= static_cast<double>(sample_clock_)) {
                spawn(grain_index_);
                next_onset_ += onset_interval_samples(grain_index_);
                ++grain_index_;
            }
 
            double left = 0.0;
            double right = 0.0;
            for (int s = 0; s < max_grains_; ++s) {
                Grain& g = grains_[static_cast<std::size_t>(s)];
                if (!g.active) continue;
                const double y = read_source(g.read_position) * window_at(g.phase) * g.gain;
                left += y * g.pan_left;
                right += y * g.pan_right;
                g.read_position += g.ratio;
                g.phase += g.phase_increment;
                if (g.phase >= 1.0) g.active = false;
            }
 
            const double level = level_.next();
            const double blend = mix_.next();
            const double dry = input_sample;
            const double wet_weight = in != nullptr ? blend : 1.0;
            const double dry_weight = in != nullptr ? 1.0 - blend : 0.0;
 
            out_left[i] = static_cast<SampleType>(
                snap_to_zero(left * level * wet_weight + dry * dry_weight));
            out_right[i] = static_cast<SampleType>(
                snap_to_zero(right * level * wet_weight + dry * dry_weight));
 
            if (source_ == GrainSource::buffer) {
                playhead_ += stretch_;
                if (playhead_ >= buffer_span) playhead_ -= buffer_span;
                if (playhead_ < 0.0) playhead_ += buffer_span;
            }
            ++sample_clock_;
        }
    }
 
    // ── State ─────────────────────────────────────────────────────────────
 
    double sample_rate_ = 44100.0;
 
    GrainSource source_ = GrainSource::buffer;
    const SampleType* buffer_ = nullptr;
    int buffer_length_ = 0;
    int buffer_channels_ = 1;
 
    std::vector<SampleType> ring_{};
    int ring_length_ = 0;
    int guard_samples_ = 0;
    std::int64_t write_head_ = 0;
    double live_centre_ = 0.0;
 
    double density_hz_ = kDefaultDensityHz;
    double grain_ms_ = kDefaultGrainMs;
    double jitter_ = kDefaultJitter;
    double stretch_ = kDefaultStretch;
    double position01_ = 0.0;
    double position_spray_ms_ = 0.0;
    double pitch_st_ = 0.0;
    double pitch_spray_st_ = 0.0;
    double pan_spray_ = 0.0;
    double taper_ = 0.5;
    bool trapezoid_ = false;
    double level_db_ = 0.0;
    double mix_target_ = 1.0;
 
    Coherence coherence_ = Coherence::incoherent;
    StealPolicy steal_policy_ = StealPolicy::oldest;
    GrainInterp interp_ = GrainInterp::cubic_hermite;
    int max_grains_ = kDefaultMaxGrains;
    std::uint32_t seed_ = kDefaultSeed;
 
    std::vector<double> window_{};
    double window_mean_ = 1.0;
    double window_rms_ = 1.0;
 
    Grain grains_[kMaxGrainBudget]{};
    double playhead_ = 0.0;
    double next_onset_ = 0.0;
    std::int64_t sample_clock_ = 0;
    std::uint64_t grain_index_ = 0;
    std::uint64_t steal_count_ = 0;
    std::uint64_t clamp_count_ = 0;
 
    SmoothedValue<double> level_{1.0};
    SmoothedValue<double> mix_{1.0};
    PannerT<double> panner_{};
};
 
using GranularEngine = GranularEngineT<float>;
using GranularEngine64 = GranularEngineT<double>;
 
}  // namespace pulp::signal