139 lines
2.9 KiB
C++
139 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <vector>
|
|
|
|
using namespace std;
|
|
|
|
namespace trnr {
|
|
|
|
enum midi_event_type {
|
|
note_on = 0,
|
|
note_off,
|
|
pitch_wheel,
|
|
mod_wheel
|
|
};
|
|
|
|
struct midi_event {
|
|
midi_event_type type;
|
|
int offset;
|
|
int midi_note;
|
|
float velocity;
|
|
double data;
|
|
};
|
|
|
|
#ifndef MAX_VOICES
|
|
#define MAX_VOICES 16
|
|
#endif
|
|
|
|
#ifndef MAX_EVENTS_PER_VOICE
|
|
#define MAX_EVENTS_PER_VOICE 32
|
|
#endif
|
|
|
|
struct voice_state {
|
|
int midi_note;
|
|
bool is_busy;
|
|
bool gate;
|
|
bool trigger;
|
|
float velocity;
|
|
array<midi_event, MAX_EVENTS_PER_VOICE> events;
|
|
};
|
|
|
|
struct voice_allocator {
|
|
array<voice_state, MAX_VOICES> voices;
|
|
array<size_t, MAX_EVENTS_PER_VOICE> counts;
|
|
int active_voice_count = 1;
|
|
size_t index_to_steal = 0;
|
|
};
|
|
|
|
inline void voice_allocator_init(voice_allocator& va)
|
|
{
|
|
for (size_t i = 0; i < MAX_VOICES; ++i) { va.counts[i] = 0; }
|
|
}
|
|
|
|
inline void voice_allocator_process_block(voice_allocator& va, const vector<midi_event>& midi_events)
|
|
{
|
|
// reset voice events and counts
|
|
for (int i = 0; i < MAX_VOICES; i++) {
|
|
for (int j = 0; j < MAX_EVENTS_PER_VOICE; j++) { va.voices[i].events[j] = midi_event {}; }
|
|
}
|
|
|
|
for (const auto& ev : midi_events) {
|
|
switch (ev.type) {
|
|
case note_on: {
|
|
bool found = false;
|
|
// attempt to find a free voice
|
|
for (size_t i = 0; i < va.active_voice_count; ++i) {
|
|
if (!va.voices[i].is_busy) {
|
|
va.voices[i].events[va.counts[i]++] = ev;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) break;
|
|
|
|
// try to find a voice that is not gated
|
|
for (size_t i = 0; i < va.active_voice_count; ++i) {
|
|
if (!va.voices[i].gate) {
|
|
va.voices[i].events[va.counts[i]++] = ev;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found) break;
|
|
|
|
// if all voices are gated, steal one round-robin
|
|
va.voices[va.index_to_steal].events[va.counts[va.index_to_steal]++] = ev;
|
|
va.index_to_steal++;
|
|
if (va.index_to_steal >= va.active_voice_count) va.index_to_steal = 0;
|
|
break;
|
|
}
|
|
case note_off: {
|
|
for (size_t i = 0; i < va.active_voice_count; ++i) {
|
|
if (va.voices[i].midi_note == ev.midi_note) va.voices[i].events[va.counts[i]++] = ev;
|
|
}
|
|
break;
|
|
}
|
|
case pitch_wheel:
|
|
case mod_wheel: {
|
|
for (size_t i = 0; i < va.active_voice_count; ++i) { va.voices[i].events[va.counts[i]++] = ev; }
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void voice_process_event_for_frame(voice_state& v, size_t frame)
|
|
{
|
|
const midi_event* best_event = nullptr;
|
|
|
|
for (int i = 0; i < v.events.size(); i++) {
|
|
const midi_event& ev = v.events[i];
|
|
if (ev.offset == frame) {
|
|
best_event = &ev;
|
|
if (ev.type == note_on) break;
|
|
}
|
|
}
|
|
|
|
if (best_event) switch (best_event->type) {
|
|
case note_on:
|
|
v.midi_note = best_event->midi_note;
|
|
v.velocity = best_event->velocity;
|
|
v.is_busy = true;
|
|
v.gate = true;
|
|
v.trigger = true;
|
|
break;
|
|
case note_off:
|
|
v.gate = false;
|
|
break;
|
|
// TODO: handle pitch wheel and mod wheel events
|
|
case pitch_wheel:
|
|
case mod_wheel:
|
|
break;
|
|
}
|
|
}
|
|
} // namespace trnr
|