voice.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/drum/output_stage.hpp>
#include <pulp/signal/drum/velocity.hpp>
 
#include <algorithm>
#include <cstddef>
 
namespace pulp::signal::drum {

enum class VoiceState {
    idle,
    ringing,
    choking,
};

class Voice {
public:
    virtual ~Voice() = default;
 
    Voice() = default;
    Voice(const Voice&) = delete;
    Voice& operator=(const Voice&) = delete;

    void prepare(double sample_rate) {
        sample_rate_ = sample_rate > 0.0 ? sample_rate : sample_rate_;
        on_prepare(sample_rate_);
        reset();
    }

    void reset() {
        choking_ = false;
        choke_gain_ = 1.0f;
        on_reset();
    }

    void note_on(float velocity) {
        choking_ = false;
        choke_gain_ = 1.0f;
        velocity_ = std::clamp(velocity, 0.0f, 1.0f);
        on_note_on(velocity_);
    }

    void choke(float fade_ms = 4.0f) {
        if (!is_active()) return;
        const double samples = std::max(0.001 * static_cast<double>(fade_ms) * sample_rate_, 1.0);
        choke_step_ = static_cast<float>(1.0 / samples);
        choking_ = true;
    }

    bool is_active() const { return on_is_active(); }
 
    VoiceState state() const {
        if (!on_is_active()) return VoiceState::idle;
        return choking_ ? VoiceState::choking : VoiceState::ringing;
    }
 
    float velocity() const { return velocity_; }
    double sample_rate() const { return sample_rate_; }

    virtual int latency_samples() const noexcept { return 0; }

    virtual OutputOversampling output_oversampling() const noexcept {
        return OutputOversampling::bypass;
    }
    virtual void set_output_oversampling(OutputOversampling) {}

    virtual OutputStage* output_stage() noexcept { return nullptr; }
    const OutputStage* output_stage() const noexcept {
        return const_cast<Voice*>(this)->output_stage();
    }
 
    void set_velocity_response(const VelocityResponse& r) { velocity_response_ = r; }
    const VelocityResponse& velocity_response() const { return velocity_response_; }

    void process(float* out, int num_samples) {
        if (out == nullptr || num_samples <= 0 || !is_active()) return;
 
        if (!choking_) {
            render_add(out, num_samples);
            return;
        }
 
        // A fade cannot be applied to an additive render in place, because the
        // buffer may already hold another voice. Render into a fixed-size
        // scratch in chunks, scale, and accumulate -- which keeps the fade
        // exact without allocating.
        int done = 0;
        while (done < num_samples) {
            const int n = std::min(kScratchSamples, num_samples - done);
            std::fill(scratch_, scratch_ + n, 0.0f);
            render_add(scratch_, n);
            for (int i = 0; i < n; ++i) {
                out[done + i] += scratch_[i] * choke_gain_;
                choke_gain_ = std::max(choke_gain_ - choke_step_, 0.0f);
            }
            done += n;
            if (choke_gain_ <= 0.0f) break;
        }
 
        if (choke_gain_ <= 0.0f) reset();
    }

    void process_stereo(float* left, float* right, int num_samples) {
        if (left == nullptr || right == nullptr || num_samples <= 0 ||
            !is_active())
            return;
 
        if (!choking_) {
            render_add_stereo(left, right, num_samples);
            return;
        }
 
        int done = 0;
        while (done < num_samples) {
            const int n = std::min(kScratchSamples, num_samples - done);
            std::fill(stereo_left_scratch_, stereo_left_scratch_ + n, 0.0f);
            std::fill(stereo_right_scratch_, stereo_right_scratch_ + n, 0.0f);
            render_add_stereo(stereo_left_scratch_, stereo_right_scratch_, n);
            for (int i = 0; i < n; ++i) {
                left[done + i] += stereo_left_scratch_[i] * choke_gain_;
                right[done + i] += stereo_right_scratch_[i] * choke_gain_;
                choke_gain_ = std::max(choke_gain_ - choke_step_, 0.0f);
            }
            done += n;
            if (choke_gain_ <= 0.0f) break;
        }
 
        if (choke_gain_ <= 0.0f) reset();
    }
 
protected:
    virtual void on_prepare(double sample_rate) = 0;

    virtual void on_reset() = 0;

    virtual void on_note_on(float velocity) = 0;
 
    virtual bool on_is_active() const = 0;

    virtual void render_add(float* out, int num_samples) = 0;

    virtual void render_add_stereo(float* left, float* right,
                                   int num_samples) {
        int done = 0;
        while (done < num_samples) {
            const int n = std::min(kScratchSamples, num_samples - done);
            std::fill(mono_stereo_scratch_, mono_stereo_scratch_ + n, 0.0f);
            render_add(mono_stereo_scratch_, n);
            for (int i = 0; i < n; ++i) {
                const float centred = 0.5f * mono_stereo_scratch_[i];
                left[done + i] += centred;
                right[done + i] += centred;
            }
            done += n;
        }
    }
 
private:
    // 256 samples is longer than any block a plugin host is likely to ask for
    // in the low-latency configurations where choking matters, and small
    // enough that a whole kit's scratch stays inside a cache level.
    static constexpr int kScratchSamples = 256;
 
    double sample_rate_ = 44100.0;
    float velocity_ = 1.0f;
    VelocityResponse velocity_response_{};
 
    bool choking_ = false;
    float choke_gain_ = 1.0f;
    float choke_step_ = 1.0f;
    float scratch_[kScratchSamples]{};
    float mono_stereo_scratch_[kScratchSamples]{};
    float stereo_left_scratch_[kScratchSamples]{};
    float stereo_right_scratch_[kScratchSamples]{};
};
 
}  // namespace pulp::signal::drum