kit.hpp

Go to the documentation of this file.

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

class Kit {
public:
    std::size_t add_voice(Voice* voice, int note, int choke_group = 0) {
        slots_.push_back({voice, note, choke_group});
        // Prepare on registration as well as in `prepare()`. Registering after
        // the kit was prepared is a reasonable thing to do -- a caller may add
        // a voice in response to a preset load -- and without this the new
        // voice would run at whatever rate it was constructed with, which is
        // audible as a wrongly-pitched drum rather than as an error.
        if (voice != nullptr) {
            set_output_oversampling(oversampling_);
            voice->prepare(sample_rate_);
        }
        return slots_.size() - 1;
    }
 
    std::size_t voice_count() const { return slots_.size(); }

    int latency_samples() const noexcept {
        return OutputStage::latency_samples_for(oversampling_);
    }
 
    OutputOversampling output_oversampling() const noexcept {
        return oversampling_;
    }
 
    void set_output_oversampling(OutputOversampling factor) {
        oversampling_ = factor;
        for (auto& slot : slots_) {
            if (slot.voice != nullptr)
                slot.voice->set_output_oversampling(oversampling_);
        }
        for (const auto& slot : slots_) {
            if (slot.voice != nullptr &&
                slot.voice->output_oversampling() != oversampling_) {
                // A source-compatible legacy Voice has no quality stage. Keep
                // the entire sum honest and aligned by falling back to the
                // zero-latency contract it reports.
                oversampling_ = OutputOversampling::bypass;
                for (auto& fallback_slot : slots_) {
                    if (fallback_slot.voice != nullptr)
                        fallback_slot.voice->set_output_oversampling(
                            oversampling_);
                }
                break;
            }
        }
    }
 
    void prepare(double sample_rate) {
        sample_rate_ = sample_rate > 0.0 ? sample_rate : sample_rate_;
        for (auto& slot : slots_) {
            if (slot.voice != nullptr) {
                slot.voice->set_output_oversampling(oversampling_);
                slot.voice->prepare(sample_rate_);
            }
        }
    }

    void set_choke_fade_ms(float ms) { choke_fade_ms_ = std::max(ms, 0.1f); }

    void reset() {
        for (auto& slot : slots_) {
            if (slot.voice != nullptr) slot.voice->reset();
        }
    }

    void trigger(int note, float velocity) {
        for (std::size_t i = 0; i < slots_.size(); ++i) {
            if (slots_[i].note == note) {
                trigger_slot(i, velocity);
                return;
            }
        }
    }

    void trigger_slot(std::size_t index, float velocity) {
        if (index >= slots_.size() || slots_[index].voice == nullptr) return;
 
        slots_[index].voice->set_output_oversampling(oversampling_);
        const int group = slots_[index].choke_group;
        if (group != 0) {
            for (std::size_t other = 0; other < slots_.size(); ++other) {
                if (other == index || slots_[other].choke_group != group) continue;
                if (slots_[other].voice != nullptr) {
                    slots_[other].voice->choke(choke_fade_ms_);
                }
            }
        }
        slots_[index].voice->note_on(velocity);
    }

    void choke_group(int group) {
        if (group == 0) return;
        for (auto& slot : slots_) {
            if (slot.choke_group == group && slot.voice != nullptr) {
                slot.voice->choke(choke_fade_ms_);
            }
        }
    }

    bool is_active() const {
        for (const auto& slot : slots_) {
            if (slot.voice != nullptr && slot.voice->is_active()) return true;
        }
        return false;
    }

    void process(float* out, int num_samples) {
        if (out == nullptr || num_samples <= 0) return;
        for (auto& slot : slots_) {
            if (slot.voice != nullptr && slot.voice->is_active()) {
                slot.voice->set_output_oversampling(oversampling_);
                slot.voice->process(out, num_samples);
            }
        }
    }
 
private:
    struct Slot {
        Voice* voice = nullptr;
        int note = 0;
        int choke_group = 0;
    };
 
    std::vector<Slot> slots_;
    double sample_rate_ = 44100.0;
    float choke_fade_ms_ = 4.0f;
    OutputOversampling oversampling_ = OutputOversampling::x2;
};
 
}  // namespace pulp::signal::drum