galdr 0.1.0: terminal grid synthesizer (MIDI in, PipeWire out)

Signal flows downward through single-glyph unit generators; each MIDI note
voices the whole grid; the mix renders low-latency to PipeWire (reusing the
native path from spectrust). Grid edits recompile and hot-swap without
dropping audio. Pairs with orca (note/CC source) and spectrust (visualizer).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GLUwWE2KmFPzhKaf67tWbx

src/dsp.rs

@@ -0,0 +1,247 @@
+//! Grid -> compiled signal program, and the per-sample voice evaluator.
+//!
+//! The grid is the editor surface only. On every edit it compiles to a flat,
+//! row-ordered list of nodes (topological by construction: signal flows
+//! downward, so a cell's input - the cell above - is always evaluated first).
+//! The audio thread never sees the grid, only the compiled `Program`.
+
+use crate::grid::{Grid, H, SLOTS, W};
+
+pub const MAX_STATE: usize = 4 * SLOTS;
+pub const TAU: f32 = std::f32::consts::TAU;
+
+#[derive(Clone, Copy)]
+pub enum Op {
+    Sine,
+    Saw,
+    Pulse,
+    Tri,
+    Noise,
+    Lpf,
+    Env,
+    Shape,
+    Out,
+}
+
+/// A parameter read from a horizontal neighbour glyph.
+#[derive(Clone, Copy)]
+pub enum Param {
+    Const(f32),
+    Reg(usize),
+    None,
+}
+
+impl Param {
+    #[inline]
+    fn get(self, regs: &[f32]) -> Option<f32> {
+        match self {
+            Param::Const(c) => Some(c),
+            Param::Reg(i) => Some(regs[i]),
+            Param::None => None,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct Node {
+    pub op: Op,
+    pub out: usize,
+    pub input: Option<usize>,
+    pub left: Param,
+    pub right: Param,
+    pub st: usize,
+}
+
+pub struct Program {
+    pub nodes: Vec<Node>,
+    pub has_env: bool,
+}
+
+fn op_of(c: char) -> Option<(Op, usize)> {
+    // (operator, number of persistent state slots it needs per voice)
+    Some(match c {
+        '~' => (Op::Sine, 1),
+        '^' => (Op::Saw, 1),
+        '_' => (Op::Pulse, 1),
+        'v' => (Op::Tri, 1),
+        '*' => (Op::Noise, 0),
+        'f' => (Op::Lpf, 2),
+        'e' => (Op::Env, 2),
+        's' => (Op::Shape, 0),
+        '!' => (Op::Out, 0),
+        _ => return None,
+    })
+}
+
+fn param_of(c: char) -> Param {
+    match c {
+        '0'..='9' => Param::Const((c as u8 - b'0') as f32),
+        'a'..='z' => Param::Reg((c as u8 - b'a') as usize),
+        _ => Param::None,
+    }
+}
+
+fn occupied(c: char) -> bool {
+    !matches!(c, ' ' | '.' | '\0')
+}
+
+pub fn compile(grid: &Grid) -> Program {
+    let mut nodes = Vec::new();
+    let mut st = 0usize;
+    let mut has_env = false;
+    for row in 0..H {
+        for col in 0..W {
+            let Some((op, ssize)) = op_of(grid.get(col, row)) else { continue };
+            if matches!(op, Op::Env) {
+                has_env = true;
+            }
+            let input = if row > 0 && occupied(grid.get(col, row - 1)) {
+                Some((row - 1) * W + col)
+            } else {
+                None
+            };
+            let left = if col > 0 { param_of(grid.get(col - 1, row)) } else { Param::None };
+            let right = if col + 1 < W { param_of(grid.get(col + 1, row)) } else { Param::None };
+            let this_st = st;
+            st = (st + ssize).min(MAX_STATE - 4);
+            nodes.push(Node { op, out: row * W + col, input, left, right, st: this_st });
+        }
+    }
+    Program { nodes, has_env }
+}
+
+/// Per-voice mutable state consumed by the evaluator.
+pub struct Voice {
+    pub active: bool,
+    pub note: u8,
+    pub freq: f32,
+    pub gate: f32,
+    pub vel: f32,
+    pub env_level: f32,
+    pub age: u64,
+    pub rng: u32,
+    pub state: Vec<f32>,
+}
+
+impl Voice {
+    pub fn new() -> Self {
+        Voice {
+            active: false,
+            note: 0,
+            freq: 0.0,
+            gate: 0.0,
+            vel: 0.0,
+            env_level: 0.0,
+            age: 0,
+            rng: 0x1234_5678,
+            state: vec![0.0; MAX_STATE],
+        }
+    }
+}
+
+#[inline]
+fn cutoff_hz(v: f32) -> f32 {
+    // 0..=9 or a 0..1 CC value -> ~40 Hz .. ~16 kHz, exponential.
+    let n = if v > 1.0 { v / 9.0 } else { v };
+    40.0 * 400f32.powf(n.clamp(0.0, 1.0))
+}
+
+/// Evaluate one output sample for one voice. Returns the summed `!` outputs.
+#[inline]
+pub fn eval_voice(v: &mut Voice, p: &Program, regs: &[f32], sr: f32) -> f32 {
+    let mut s = [0f32; SLOTS];
+    let mut out = 0.0f32;
+    let mut env_max = 0.0f32;
+    for n in &p.nodes {
+        let inp = n.input.map(|i| s[i]).unwrap_or(0.0);
+        let l = n.left.get(regs);
+        let r = n.right.get(regs);
+        let y = match n.op {
+            Op::Sine => {
+                let ratio = l.filter(|&x| x > 0.0).unwrap_or(1.0);
+                let ph = &mut v.state[n.st];
+                let y = (*ph * TAU).sin();
+                *ph += v.freq * ratio / sr;
+                if *ph >= 1.0 {
+                    *ph -= 1.0;
+                }
+                y
+            }
+            Op::Saw => {
+                let ratio = l.filter(|&x| x > 0.0).unwrap_or(1.0);
+                let ph = &mut v.state[n.st];
+                let y = 2.0 * *ph - 1.0;
+                *ph += v.freq * ratio / sr;
+                if *ph >= 1.0 {
+                    *ph -= 1.0;
+                }
+                y
+            }
+            Op::Pulse => {
+                let width = l.map(|x| (x / 9.0).clamp(0.05, 0.95)).unwrap_or(0.5);
+                let ph = &mut v.state[n.st];
+                let y = if *ph < width { 1.0 } else { -1.0 };
+                *ph += v.freq / sr;
+                if *ph >= 1.0 {
+                    *ph -= 1.0;
+                }
+                y
+            }
+            Op::Tri => {
+                let ph = &mut v.state[n.st];
+                let y = 4.0 * (*ph - 0.5).abs() - 1.0;
+                *ph += v.freq / sr;
+                if *ph >= 1.0 {
+                    *ph -= 1.0;
+                }
+                y
+            }
+            Op::Noise => {
+                // xorshift32
+                v.rng ^= v.rng << 13;
+                v.rng ^= v.rng >> 17;
+                v.rng ^= v.rng << 5;
+                (v.rng as f32 / u32::MAX as f32) * 2.0 - 1.0
+            }
+            Op::Lpf => {
+                let fc = cutoff_hz(l.unwrap_or(9.0));
+                let a = (1.0 - (-TAU * fc / sr).exp()).clamp(0.0, 1.0);
+                let z = &mut v.state[n.st];
+                *z += a * (inp - *z);
+                let _res = r; // reserved for resonance later
+                *z
+            }
+            Op::Env => {
+                // Attack/Release, sustain = 1. l = attack, r = release (0..9).
+                let atk = l.map(|x| 0.002 + x * 0.05).unwrap_or(0.01);
+                let rel = r.map(|x| 0.01 + x * 0.15).unwrap_or(0.15);
+                let level = &mut v.state[n.st];
+                let target = if v.gate > 0.5 { 1.0 } else { 0.0 };
+                let rate = if v.gate > 0.5 { atk } else { rel };
+                let step = (1.0 / (rate * sr)).min(1.0);
+                *level += (target - *level) * step;
+                if *level > env_max {
+                    env_max = *level;
+                }
+                inp * *level * v.vel
+            }
+            Op::Shape => {
+                let drive = l.filter(|&x| x > 0.0).unwrap_or(1.0);
+                (inp * drive).tanh()
+            }
+            Op::Out => {
+                out += inp;
+                inp
+            }
+        };
+        s[n.out] = y;
+    }
+    // With no envelope, gate directly gates the voice so notes don't sustain
+    // forever.
+    if !p.has_env {
+        out *= v.gate * v.vel;
+        env_max = v.gate;
+    }
+    v.env_level = env_max;
+    out
+}