legato 0.0.13

Legato is a WIP audiograph and DSL for quickly developing audio applications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::{
    context::AudioContext,
    msg::{NodeMessage, RtValue},
    node::{Inputs, Node},
    ports::{PortBuilder, Ports},
};

/// A single step in the sequencer.
#[derive(Clone, Debug)]
pub struct SequencerStep {
    pub freq: f32,
    pub vel: f32,
    /// 0.0 is muted, 1.0 fires
    pub gate: f32,
    /// Portion of the step duration the gate is held high. Range [0.0, 1.0].
    pub length: f32,
}

impl Default for SequencerStep {
    fn default() -> Self {
        Self {
            freq: 440.0,
            vel: 0.8,
            gate: 1.0,
            length: 0.1,
        }
    }
}

#[derive(Clone)]
pub struct StepSequencer {
    steps: Vec<SequencerStep>,
    ports: Ports,
}

impl StepSequencer {
    pub fn new(step_count: usize) -> Self {
        let ports = PortBuilder::default()
            .audio_in_named(&["phasor"])
            .audio_out_named(&["freq", "vel", "gate"])
            .build();

        Self {
            steps: vec![SequencerStep::default(); step_count],
            ports,
        }
    }

    #[inline(always)]
    fn step_index(&self, phase: f32) -> usize {
        let num_steps = self.steps.len();
        // map range of phasor (0,1) to (0,num_steps)
        let idx = (phase.min(0.999_999) * num_steps as f32).floor() as usize;
        // Clamp index to last elemenet
        idx.min(num_steps - 1)
    }

    #[inline(always)]
    fn phase_within_step(&self, phase: f32) -> f32 {
        (phase * self.steps.len() as f32).fract()
    }
}

impl Node for StepSequencer {
    fn process(&mut self, ctx: &mut AudioContext, inputs: &Inputs, outputs: &mut [&mut [f32]]) {
        let block_size = ctx.get_config().block_size;
        let phasor_in = inputs[0].expect("StepSequencer requires a phasor!");

        let (freq_out, rest) = outputs.split_at_mut(1);
        let (vel_out, rest) = rest.split_at_mut(1);
        let (gate_out, _) = rest.split_at_mut(1);

        let freq_out = &mut freq_out[0];
        let vel_out = &mut vel_out[0];
        let gate_out = &mut gate_out[0];

        for n in 0..block_size {
            let phase = phasor_in[n];
            let idx = self.step_index(phase);
            let step = &self.steps[idx];
            let local_phase = self.phase_within_step(phase);

            freq_out[n] = step.freq;
            vel_out[n] = step.vel;
            gate_out[n] = if step.gate > 0.0 && local_phase < step.length {
                1.0
            } else {
                0.0
            };
        }
    }

    fn handle_msg(&mut self, msg: NodeMessage) {
        match msg {
            NodeMessage::SetParam(inner) => {
                // delimitted with `_`, e.g "step_3_freq"
                let parts: Vec<&str> = inner.param_name.splitn(3, '_').collect();
                if parts.len() == 3 && parts[0] == "step" {
                    if let Ok(idx) = parts[1].parse::<usize>() {
                        if let Some(step) = self.steps.get_mut(idx) {
                            // parts[2] is the last string part
                            match (parts[2], inner.value) {
                                ("freq", RtValue::F32(x)) => step.freq = x,
                                ("vel", RtValue::F32(x)) => step.vel = x,
                                ("gate", RtValue::F32(x)) => step.gate = x,
                                ("length", RtValue::F32(x)) => step.length = x.clamp(0.0, 1.0),
                                _ => (),
                            }
                        }
                    }
                }
            }
            NodeMessage::SetStep(payload) => {
                if let Some(step) = self.steps.get_mut(payload.index) {
                    if let Some(v) = payload.freq {
                        step.freq = v;
                    }
                    if let Some(v) = payload.vel {
                        step.vel = v;
                    }
                    if let Some(v) = payload.gate {
                        step.gate = v;
                    }
                    if let Some(v) = payload.length {
                        step.length = v.clamp(0.0, 1.0);
                    }
                }
            }
            _ => (),
        }
    }

    fn ports(&self) -> &Ports {
        &self.ports
    }
}