234 lines
7.4 KiB
Rust
234 lines
7.4 KiB
Rust
use crate::audio::midi::MidiEvent;
|
|
use crate::audio::node_graph::{AudioNode, NodeCategory, NodePort, Parameter, ParameterUnit, SignalType};
|
|
|
|
const PARAM_PITCH_BEND_RANGE: u32 = 0;
|
|
|
|
/// MIDI to CV converter
|
|
/// Converts MIDI note events to control voltage signals
|
|
pub struct MidiToCVNode {
|
|
name: String,
|
|
note: u8, // Current MIDI note number
|
|
gate: f32, // Gate CV (1.0 when note on, 0.0 when off)
|
|
velocity: f32, // Velocity CV (0.0-1.0)
|
|
pitch_cv: f32, // Pitch CV (V/Oct: 0V = A4, ±1V per octave), without bend
|
|
pitch_bend_range: f32, // Pitch bend range in semitones (default 2.0)
|
|
current_bend: f32, // Current pitch bend, normalised -1.0..=1.0 (0 = centre)
|
|
current_mod: f32, // Current modulation (CC1), 0.0..=1.0
|
|
inputs: Vec<NodePort>,
|
|
outputs: Vec<NodePort>,
|
|
parameters: Vec<Parameter>,
|
|
}
|
|
|
|
impl MidiToCVNode {
|
|
pub fn new(name: impl Into<String>) -> Self {
|
|
let name = name.into();
|
|
|
|
let inputs = vec![
|
|
NodePort::new("MIDI In", SignalType::Midi, 0),
|
|
NodePort::new("Bend CV", SignalType::CV, 0), // External pitch bend in semitones
|
|
NodePort::new("Mod CV", SignalType::CV, 1), // External modulation 0.0..=1.0
|
|
];
|
|
|
|
let outputs = vec![
|
|
NodePort::new("V/Oct", SignalType::CV, 0), // V/Oct: 0V = A4, ±1V per octave (with bend applied)
|
|
NodePort::new("Gate", SignalType::CV, 1), // 1.0 = on, 0.0 = off
|
|
NodePort::new("Velocity", SignalType::CV, 2), // 0.0-1.0
|
|
NodePort::new("Bend", SignalType::CV, 3), // Total pitch bend in semitones (MIDI + CV)
|
|
NodePort::new("Mod", SignalType::CV, 4), // Total modulation 0.0..=1.0 (MIDI CC1 + CV)
|
|
];
|
|
|
|
let parameters = vec![
|
|
Parameter::new(
|
|
PARAM_PITCH_BEND_RANGE,
|
|
"Pitch Bend Range",
|
|
0.0, 48.0, 2.0,
|
|
ParameterUnit::Generic,
|
|
),
|
|
];
|
|
|
|
Self {
|
|
name,
|
|
note: 60,
|
|
gate: 0.0,
|
|
velocity: 0.0,
|
|
pitch_cv: Self::midi_note_to_voct(60),
|
|
pitch_bend_range: 2.0,
|
|
current_bend: 0.0,
|
|
current_mod: 0.0,
|
|
inputs,
|
|
outputs,
|
|
parameters,
|
|
}
|
|
}
|
|
|
|
/// Convert MIDI note to V/oct CV (proper V/Oct standard)
|
|
/// 0V = A4 (MIDI 69), ±1V per octave
|
|
/// Middle C (MIDI 60) = -0.75V, A5 (MIDI 81) = +1.0V
|
|
fn midi_note_to_voct(note: u8) -> f32 {
|
|
// Standard V/Oct: 0V at A4, 1V per octave (12 semitones)
|
|
(note as f32 - 69.0) / 12.0
|
|
}
|
|
|
|
fn apply_midi_event(&mut self, event: &MidiEvent) {
|
|
let status = event.status & 0xF0;
|
|
match status {
|
|
0x90 if event.data2 > 0 => {
|
|
// Note on — reset per-note expression so previous note's bend doesn't bleed in
|
|
self.note = event.data1;
|
|
self.pitch_cv = Self::midi_note_to_voct(self.note);
|
|
self.velocity = event.data2 as f32 / 127.0;
|
|
self.gate = 1.0;
|
|
self.current_bend = 0.0;
|
|
self.current_mod = 0.0;
|
|
}
|
|
0x80 | 0x90 => {
|
|
// Note off (or note on with velocity 0)
|
|
if event.data1 == self.note {
|
|
self.gate = 0.0;
|
|
}
|
|
}
|
|
0xE0 => {
|
|
// Pitch bend: 14-bit value, center = 8192
|
|
let bend_raw = ((event.data2 as i16) << 7) | (event.data1 as i16);
|
|
self.current_bend = (bend_raw - 8192) as f32 / 8192.0;
|
|
}
|
|
0xB0 if event.data1 == 1 => {
|
|
// CC1 (modulation wheel)
|
|
self.current_mod = event.data2 as f32 / 127.0;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AudioNode for MidiToCVNode {
|
|
fn category(&self) -> NodeCategory {
|
|
NodeCategory::Input
|
|
}
|
|
|
|
fn inputs(&self) -> &[NodePort] {
|
|
&self.inputs
|
|
}
|
|
|
|
fn outputs(&self) -> &[NodePort] {
|
|
&self.outputs
|
|
}
|
|
|
|
fn parameters(&self) -> &[Parameter] {
|
|
&self.parameters
|
|
}
|
|
|
|
fn set_parameter(&mut self, id: u32, value: f32) {
|
|
if id == PARAM_PITCH_BEND_RANGE {
|
|
self.pitch_bend_range = value.clamp(0.0, 48.0);
|
|
}
|
|
}
|
|
|
|
fn get_parameter(&self, id: u32) -> f32 {
|
|
if id == PARAM_PITCH_BEND_RANGE {
|
|
self.pitch_bend_range
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
|
|
fn handle_midi(&mut self, event: &MidiEvent) {
|
|
self.apply_midi_event(event);
|
|
}
|
|
|
|
fn process(
|
|
&mut self,
|
|
inputs: &[&[f32]],
|
|
outputs: &mut [&mut [f32]],
|
|
midi_inputs: &[&[MidiEvent]],
|
|
_midi_outputs: &mut [&mut Vec<MidiEvent>],
|
|
_sample_rate: u32,
|
|
) {
|
|
// Process MIDI events from input buffer
|
|
if !midi_inputs.is_empty() {
|
|
for event in midi_inputs[0] {
|
|
self.apply_midi_event(event);
|
|
}
|
|
}
|
|
|
|
if outputs.len() < 5 {
|
|
return;
|
|
}
|
|
|
|
// Read CV inputs (use first sample of buffer). NaN = unconnected port → treat as 0.
|
|
let bend_cv = inputs.get(0).and_then(|b| b.first().copied())
|
|
.filter(|v| v.is_finite()).unwrap_or(0.0);
|
|
let mod_cv = inputs.get(1).and_then(|b| b.first().copied())
|
|
.filter(|v| v.is_finite()).unwrap_or(0.0);
|
|
|
|
// Total bend in semitones: MIDI bend + CV bend
|
|
let bend_semitones = self.current_bend * self.pitch_bend_range + bend_cv;
|
|
// Total mod: MIDI CC1 + CV mod, clamped to 0..1
|
|
let total_mod = (self.current_mod + mod_cv).clamp(0.0, 1.0);
|
|
// Pitch output includes bend
|
|
let pitch_out_val = self.pitch_cv + bend_semitones / 12.0;
|
|
|
|
// Use split_at_mut to get multiple mutable references
|
|
let (v0, rest) = outputs.split_at_mut(1);
|
|
let (v1, rest) = rest.split_at_mut(1);
|
|
let (v2, rest) = rest.split_at_mut(1);
|
|
let (v3, v4_slice) = rest.split_at_mut(1);
|
|
|
|
let pitch_out = &mut v0[0];
|
|
let gate_out = &mut v1[0];
|
|
let velocity_out = &mut v2[0];
|
|
let bend_out = &mut v3[0];
|
|
let mod_out = &mut v4_slice[0];
|
|
|
|
let frames = pitch_out.len();
|
|
|
|
// Output constant CV values for the entire buffer
|
|
for frame in 0..frames {
|
|
pitch_out[frame] = pitch_out_val;
|
|
gate_out[frame] = self.gate;
|
|
velocity_out[frame] = self.velocity;
|
|
bend_out[frame] = bend_semitones;
|
|
mod_out[frame] = total_mod;
|
|
}
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
self.gate = 0.0;
|
|
self.velocity = 0.0;
|
|
self.current_bend = 0.0;
|
|
self.current_mod = 0.0;
|
|
}
|
|
|
|
fn node_type(&self) -> &str {
|
|
"MidiToCV"
|
|
}
|
|
|
|
fn name(&self) -> &str {
|
|
&self.name
|
|
}
|
|
|
|
fn clone_node(&self) -> Box<dyn AudioNode> {
|
|
Box::new(Self {
|
|
name: self.name.clone(),
|
|
note: 60,
|
|
gate: 0.0,
|
|
velocity: 0.0,
|
|
pitch_cv: Self::midi_note_to_voct(60),
|
|
pitch_bend_range: self.pitch_bend_range,
|
|
current_bend: 0.0,
|
|
current_mod: 0.0,
|
|
inputs: self.inputs.clone(),
|
|
outputs: self.outputs.clone(),
|
|
parameters: self.parameters.clone(),
|
|
})
|
|
}
|
|
|
|
fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
|
|
self
|
|
}
|
|
|
|
fn as_any(&self) -> &dyn std::any::Any {
|
|
self
|
|
}
|
|
}
|