Boilerplate for sequence looper

Author: gridbugs

caw/examples/live_example.rs

@@ -10,7 +10,7 @@ fn main() {
     volume.set(knob("volume").initial_value_01(0.2).build());
     let tempo_s = sv(knob("tempo s").build() * 2.);
     let clock = sv(periodic_trig_s(tempo_s.clone()).build());
-    let env = sv({
+    let env_ = sv({
         let mut scope = blink::Server::new("env", Default::default()).unwrap();
         adsr(clock.clone().trig_to_gate(tempo_s.clone() / 2.))
             .a(tempo_s.clone() / 8.)
@@ -21,21 +21,47 @@ fn main() {
                 let _ = scope.send_samples(buf);
             })
     });
-    let keys = computer_keyboard("keys").build().shared();
-    let space_button = keys.clone().controllers().get_01(0).is_positive();
+    let keys = computer_keyboard("keys")
+        .start_note(note::B_1)
+        .build()
+        .shared();
+    let space_button =
+        keys.clone().controllers().get_01(0).is_positive().shared();
     let key_events = keys.clone().key_events().shared();
-    let env2 = adsr(space_button).build().shared();
     out.set(|| {
         let voice = key_events.clone().mono_voice();
-        super_saw(voice.note.freq_hz())
+        let (note, gate) = sequence_looper(
+            voice.gated_note(),
+            clock.clone(),
+            space_button.clone(),
+            8,
+        )
+        .ungated();
+        let env = adsr(gate)
+            .a(tempo_s.clone() / 24.)
+            .r(tempo_s.clone() / 2.)
+            .s(0.75)
+            .d(tempo_s.clone() / 24.)
+            .build()
+            .exp_01(1.);
+        super_saw(note.freq_hz())
             .build()
             .filter(
-                low_pass::default(
-                    100. + env.clone() * 4000. + (env2.clone() * 5000.),
-                )
-                .q(0.5),
+                low_pass::default(10. + env_.clone() * 0. + (env * 15000.))
+                    .q(0.2),
             )
-            .filter(reverb())
+            .filter(
+                chorus()
+                    .lfo_rate_hz(0.1)
+                    .delay_s(0.001)
+                    .depth_s(0.002)
+                    .mix_01(0.5)
+                    .feedback_ratio(0.5),
+            )
+            .filter(reverb::default().room_size(0.9).damping(0.1))
+
+        //            .filter(reverb())
+        //            .filter(chorus())
     });
     thread::park();
 }

core/src/sig.rs

@@ -641,6 +641,18 @@ where
         })
     }
 
+    /// A signal whose items are None if the gate is down and the input signal if the gate is up.
+    pub fn gated<G>(self, gate: G) -> Sig<impl SigT<Item = Option<S::Item>>>
+    where
+        G: SigT<Item = bool>,
+    {
+        self.zip(gate).map(
+            |(self_, gate)| {
+                if gate { Some(self_) } else { None }
+            },
+        )
+    }
+
     pub fn shared(self) -> Sig<SigShared<S>> {
         sig_shared(self.0)
     }
@@ -1024,6 +1036,30 @@ where
     }
 }
 
+impl<T, S> Sig<S>
+where
+    T: Clone + Default,
+    S: SigT<Item = Option<T>>,
+{
+    /// Reverses the `gated` function. Given a sequence of optional values, produces a sequence of
+    /// values and a gate sequence. When the input signal is `None`, the output value sequence uses
+    /// the previous `Some` value of the input, or `Default::default()` if no `Some` value has been
+    /// produced yet.
+    pub fn ungated(
+        self,
+    ) -> (Sig<impl SigT<Item = T>>, Sig<impl SigT<Item = bool>>) {
+        let mut prev_value = T::default();
+        self.map_mut(move |value_opt| match value_opt {
+            Some(value) => {
+                prev_value = value.clone();
+                (value, true)
+            }
+            None => (prev_value.clone(), false),
+        })
+        .unzip()
+    }
+}
+
 pub struct WithBuf<S, F>
 where
     S: SigT,

keyboard/src/mono_voice.rs

@@ -34,6 +34,20 @@ where
     }
 }
 
+impl<K> MonoVoice<K>
+where
+    K: SigT<Item = KeyEvents>,
+{
+    pub fn gated_note(self) -> Sig<impl SigT<Item = Option<crate::Note>>> {
+        let Self {
+            note,
+            key_down_gate,
+            ..
+        } = self;
+        note.gated(key_down_gate)
+    }
+}
+
 /// Extracts a sequence of notes from a sequence of key events.
 pub struct Note<K>
 where

midi/src/lib.rs

@@ -49,6 +49,10 @@ impl MidiEvents {
         Self(smallvec![])
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     pub fn push(&mut self, midi_event: MidiEvent) {
         self.0.push(midi_event);
     }
@@ -80,6 +84,14 @@ impl MidiMessages {
         Self(smallvec![])
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn clear(&mut self) {
+        self.0.clear()
+    }
+
     pub fn push(&mut self, midi_event: MidiMessage) {
         self.0.push(midi_event);
     }
@@ -299,6 +311,7 @@ where
         {
             // Only copy messages from the first sample worth of events.
             let midi_messages = &mut self.buf[0];
+            midi_messages.clear();
             if let Some(midi_events) = midi_events.iter().next() {
                 for midi_event in midi_events {
                     if midi_event.channel == self.channel {

utils/src/lib.rs

@@ -3,3 +3,5 @@ pub use bitwise_pattern_trig::bitwise_pattern_trigs_8;
 pub mod noise;
 pub mod sequencer;
 pub use sequencer::value_sequencer;
+pub mod looper;
+pub use looper::sequence_looper;

utils/src/looper.rs

@@ -0,0 +1,63 @@
+use caw_core::{Buf, Sig, SigCtx, SigT};
+use itertools::izip;
+
+struct SequenceLooper<X, S, T, R, N>
+where
+    X: Clone,
+    S: SigT<Item = Option<X>>,
+    T: SigT<Item = bool>,
+    R: SigT<Item = bool>,
+    N: SigT<Item = u32>,
+{
+    sig: S,
+    tick: T,
+    recording: R,
+    length: N,
+    sequence: Vec<S::Item>,
+    buf: Vec<S::Item>,
+}
+
+impl<X, S, T, R, N> SigT for SequenceLooper<X, S, T, R, N>
+where
+    X: Clone,
+    S: SigT<Item = Option<X>>,
+    T: SigT<Item = bool>,
+    R: SigT<Item = bool>,
+    N: SigT<Item = u32>,
+{
+    type Item = S::Item;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        self.buf.resize_with(ctx.num_samples, || None);
+        let sig = self.sig.sample(ctx);
+        let tick = self.tick.sample(ctx);
+        let recording = self.recording.sample(ctx);
+        let length = self.length.sample(ctx);
+        for (out, sample, tick, recording, length) in izip! {
+            self.buf.iter_mut(),
+            sig.iter(),
+            tick.iter(),
+            recording.iter(),
+            length.iter(),
+        } {
+            *out = sample;
+        }
+        &self.buf
+    }
+}
+
+pub fn sequence_looper<X: Clone>(
+    sig: impl SigT<Item = Option<X>>,
+    tick: impl SigT<Item = bool>,
+    recording: impl SigT<Item = bool>,
+    length: impl SigT<Item = u32>,
+) -> Sig<impl SigT<Item = Option<X>>> {
+    Sig(SequenceLooper {
+        sig,
+        tick,
+        recording,
+        length,
+        sequence: Vec::new(),
+        buf: Vec::new(),
+    })
+}

widgets/src/computer_keyboard.rs

@@ -3,7 +3,10 @@ use caw_computer_keyboard::Key;
 use caw_keyboard::Note;
 use midly::{MidiMessage, num::u7};
 use sdl2::{keyboard::Scancode, pixels::Color};
-use std::{collections::HashMap, time::Instant};
+use std::{
+    collections::{HashMap, HashSet},
+    time::Instant,
+};
 
 const WIDTH_PX: u32 = 128;
 const HEIGHT_PX: u32 = 128;
@@ -20,6 +23,7 @@ impl KeyMappings {
 pub struct ComputerKeyboard {
     window: Window,
     key_mappings: KeyMappings,
+    pressed_keys: HashSet<Note>,
 }
 
 const SPACEBAR_CONTROLLER: u7 = u7::from_int_lossy(0);
@@ -35,6 +39,7 @@ impl ComputerKeyboard {
         Ok(Self {
             window,
             key_mappings,
+            pressed_keys: HashSet::new(),
         })
     }
 
@@ -57,18 +62,19 @@ impl ComputerKeyboard {
                     controller: SPACEBAR_CONTROLLER,
                     value: 0.into(),
                 }),
-
                 Event::KeyDown {
                     scancode: Some(scancode),
                     ..
                 } => {
                     if let Some(note) =
                         self.key_mappings.note_from_scancode(scancode)
                     {
-                        buf.push(MidiMessage::NoteOn {
-                            key: note.to_midi_index().into(),
-                            vel: u7::max_value(),
-                        });
+                        if self.pressed_keys.insert(note) {
+                            buf.push(MidiMessage::NoteOn {
+                                key: note.to_midi_index().into(),
+                                vel: u7::max_value(),
+                            });
+                        }
                     }
                 }
                 Event::KeyUp {
@@ -78,9 +84,10 @@ impl ComputerKeyboard {
                     if let Some(note) =
                         self.key_mappings.note_from_scancode(scancode)
                     {
+                        self.pressed_keys.remove(&note);
                         buf.push(MidiMessage::NoteOff {
                             key: note.to_midi_index().into(),
-                            vel: u7::max_value(),
+                            vel: 0.into(),
                         });
                     }
                 }