146 lines
3.3 KiB
C++
146 lines
3.3 KiB
C++
#pragma once
|
|
#include "ivoice.h"
|
|
#include "midi_event.h"
|
|
#include <vector>
|
|
|
|
namespace trnr {
|
|
|
|
template <typename t_voice, typename t_sample>
|
|
class voice_allocator {
|
|
public:
|
|
std::vector<t_voice> voices;
|
|
|
|
voice_allocator()
|
|
: voices(4, t_voice())
|
|
{
|
|
// checks whether template derives from ivoice
|
|
typedef t_voice assert_at_compile_time[is_convertible<t_voice, t_sample>::value ? 1 : -1];
|
|
}
|
|
|
|
void set_voice_count(const int& voice_count) { voices.resize(voice_count, voices.at(0)); }
|
|
|
|
void note_on(const midi_event& event)
|
|
{
|
|
t_voice* voice = get_free_voice(event.midi_note);
|
|
|
|
if (voice == nullptr) { voice = steal_voice(); }
|
|
|
|
if (voice != nullptr) { voice->note_on(event.midi_note, event.velocity); }
|
|
}
|
|
|
|
void note_off(const midi_event& event)
|
|
{
|
|
for (auto it = voices.begin(); it != voices.end(); it++) {
|
|
if ((*it).midi_note == event.midi_note) { (*it).note_off(); }
|
|
}
|
|
}
|
|
|
|
void access(std::function<void(t_voice&)> f) { std::for_each(voices.begin(), voices.end(), f); }
|
|
|
|
void process_samples(t_sample** _outputs, int _start_index, int _block_size)
|
|
{
|
|
for (int b = _start_index; b < _start_index + _block_size; b += internal_block_size) {
|
|
|
|
const int block_size = internal_block_size;
|
|
|
|
// process all events in the block (introduces potential inaccuracy of up to 16 samples)
|
|
process_events(b, block_size);
|
|
|
|
std::for_each(voices.begin(), voices.end(), [&_outputs, &b, &block_size](t_voice& voice) {
|
|
voice.process_samples(_outputs, b, block_size);
|
|
});
|
|
}
|
|
}
|
|
|
|
void add_event(midi_event event) { input_queue.push_back(event); }
|
|
|
|
bool voices_active()
|
|
{
|
|
bool voices_active = false;
|
|
|
|
for (auto it = voices.begin(); it != voices.end(); it++) {
|
|
bool busy = (*it).is_busy();
|
|
voices_active |= busy;
|
|
}
|
|
|
|
return voices_active;
|
|
}
|
|
|
|
void set_samplerate(double _samplerate)
|
|
{
|
|
for (int i = 0; i < voices.size(); i++) { voices.at(i).set_samplerate(_samplerate); }
|
|
}
|
|
|
|
private:
|
|
std::vector<midi_event> input_queue;
|
|
int index_to_steal = 0;
|
|
const int internal_block_size = 16;
|
|
|
|
t_voice* get_free_voice(float frequency)
|
|
{
|
|
t_voice* voice = nullptr;
|
|
|
|
for (auto it = voices.begin(); it != voices.end(); it++) {
|
|
if (!(*it).is_busy()) { voice = &*it; }
|
|
}
|
|
|
|
return voice;
|
|
}
|
|
|
|
t_voice* steal_voice()
|
|
{
|
|
t_voice* free_voice = nullptr;
|
|
|
|
for (auto it = voices.begin(); it != voices.end(); it++) {
|
|
if (!(*it).gate) {
|
|
free_voice = &*it;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (free_voice == nullptr) {
|
|
free_voice = &voices.at(index_to_steal);
|
|
|
|
if (index_to_steal < voices.size() - 1) {
|
|
index_to_steal++;
|
|
} else {
|
|
index_to_steal = 0;
|
|
}
|
|
}
|
|
|
|
return free_voice;
|
|
}
|
|
|
|
void process_events(int _start_index, int _block_size)
|
|
{
|
|
for (int s = _start_index; s < _start_index + _block_size; s++) {
|
|
auto iterator = input_queue.begin();
|
|
while (iterator != input_queue.end()) {
|
|
|
|
midi_event& event = *iterator;
|
|
if (event.offset == _start_index) {
|
|
|
|
switch (event.type) {
|
|
case midi_event_type::note_on:
|
|
note_on(event);
|
|
break;
|
|
case midi_event_type::note_off:
|
|
note_off(event);
|
|
break;
|
|
case midi_event_type::pitch_wheel:
|
|
access([&event](t_voice& voice) { voice.modulate_pitch(event.data); });
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
iterator = input_queue.erase(iterator);
|
|
} else {
|
|
iterator++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
} // namespace trnr
|