voice_pool.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstdint>
#include <functional>
#include <vector>
 
namespace ts {

enum class VoiceState {
    free,
    held,
    releasing,
};
 
class VoicePool;

struct Voice {
    const VoicePool* pool = nullptr;
    int index = 0;
 
    [[nodiscard]] VoiceState state() const noexcept;
    [[nodiscard]] int channel() const noexcept;
    [[nodiscard]] int note() const noexcept;
    [[nodiscard]] int velocity() const noexcept;
    [[nodiscard]] int note_group() const noexcept;
 
    [[nodiscard]] bool is_active() const noexcept { return state() != VoiceState::free; }
};

class VoicePool {
public:
    static constexpr int default_polyphony = 64;

    static constexpr int max_voices = default_polyphony;

    static constexpr int growth_chunk = 64;

    static constexpr int group_size = 4;

    std::function<void(int)> stealing;

    VoicePool() : VoicePool(default_polyphony, false) {}

    VoicePool(int polyphony, bool growing);

    [[nodiscard]] int capacity() const noexcept { return capacity_; }

    [[nodiscard]] bool grows() const noexcept { return growing_; }

    [[nodiscard]] int high_water() const noexcept { return high_water_; }

    [[nodiscard]] int steal_count() const noexcept { return steal_count_; }

    [[nodiscard]] int growth_count() const noexcept { return growth_count_; }

    [[nodiscard]] bool limit_was_reached() const noexcept
    {
        return steal_count_ > 0 || growth_count_ > 0;
    }

    [[nodiscard]] int active_count() const noexcept;

    [[nodiscard]] int begin_note_group() noexcept { return ++next_note_group_; }

    [[nodiscard]] Voice allocate(int channel, int note, int velocity, int note_group);

    int release(int channel, int note) noexcept;

    void free_slot(int index) noexcept
    {
        state_[static_cast<std::size_t>(index)] = VoiceState::free;
    }

    void reset() noexcept;

    [[nodiscard]] std::vector<Voice> active() const;
 
    [[nodiscard]] VoiceState state_of(int index) const noexcept
    {
        return state_[static_cast<std::size_t>(index)];
    }
 
    [[nodiscard]] int channel_of(int index) const noexcept
    {
        return channel_[static_cast<std::size_t>(index)];
    }
 
    [[nodiscard]] int note_of(int index) const noexcept
    {
        return note_[static_cast<std::size_t>(index)];
    }
 
    [[nodiscard]] int velocity_of(int index) const noexcept
    {
        return velocity_[static_cast<std::size_t>(index)];
    }
 
    [[nodiscard]] int note_group_of(int index) const noexcept
    {
        return note_group_[static_cast<std::size_t>(index)];
    }
 
private:
    [[nodiscard]] int find_free() const noexcept;
    [[nodiscard]] int find_oldest(VoiceState state) const noexcept;
    void steal_group(int note_group, int except);

    [[nodiscard]] int grow();
 
    // Vectors rather than arrays: the capacity is a run-time choice now. The struct-of-arrays
    // shape is unchanged, which is what the render loop cares about.
    std::vector<VoiceState> state_;
    std::vector<int> channel_;
    std::vector<int> note_;
    std::vector<int> velocity_;
    std::vector<int> note_group_;
    std::vector<std::int64_t> sequence_;
 
    int steal_count_ = 0;
    int growth_count_ = 0;
    int capacity_ = default_polyphony;
    int high_water_ = default_polyphony;
    bool growing_ = false;
    std::int64_t counter_ = 0;
    int next_note_group_ = 0;
};
 
inline VoiceState Voice::state() const noexcept
{
    return pool->state_of(index);
}
 
inline int Voice::channel() const noexcept
{
    return pool->channel_of(index);
}
 
inline int Voice::note() const noexcept
{
    return pool->note_of(index);
}
 
inline int Voice::velocity() const noexcept
{
    return pool->velocity_of(index);
}
 
inline int Voice::note_group() const noexcept
{
    return pool->note_group_of(index);
}
 
} // namespace ts