Working looper module

Author: gridbugs

caw/examples/live_example.rs

@@ -7,49 +7,42 @@ fn main() {
         ..Default::default()
     })
     .with_volume(volume.clone());
-    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 mut scope = blink::Server::new("env", Default::default()).unwrap();
-        adsr(clock.clone().trig_to_gate(tempo_s.clone() / 2.))
-            .a(tempo_s.clone() / 8.)
-            .r(tempo_s.clone() / 2.)
-            .build()
-            .exp_01(1.)
-            .with_buf(move |buf| {
-                let _ = scope.send_samples(buf);
-            })
-    });
+    volume.set(knob("volume").initial_value_01(0.5).build());
+    let tempo_s = sv(knob("tempo s").build() * 0.5);
+    let lpf = sv(knob("lpf").build() * 0.5);
+    let clock = sv(periodic_trig_s(tempo_s.clone())
+        .build()
+        .viz_blink("clock".to_string(), Default::default()));
     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();
-    out.set(|| {
+    out.set_channel(|channel| {
         let voice = key_events.clone().mono_voice();
-        let (note, gate) = sequence_looper(
+        let (note, gate) = key_looper(
             voice.gated_note(),
             clock.clone(),
             space_button.clone(),
             8,
         )
         .ungated();
         let env = adsr(gate)
+            .key_press_trig(clock.clone())
             .a(tempo_s.clone() / 24.)
             .r(tempo_s.clone() / 2.)
-            .s(0.75)
-            .d(tempo_s.clone() / 24.)
+            .s(0.25)
+            .d(tempo_s.clone() / 2.)
             .build()
-            .exp_01(1.);
-        super_saw(note.freq_hz())
-            .build()
-            .filter(
-                low_pass::default(10. + env_.clone() * 0. + (env * 15000.))
-                    .q(0.2),
-            )
+            .exp_01(1.)
+            .shared();
+        let voice = (super_saw(note.freq_hz()).build() * env.clone()).filter(
+            low_pass::default(10. + (env.clone() * lpf.clone() * 15000.))
+                .q(0.2),
+        );
+        voice
             .filter(
                 chorus()
                     .lfo_rate_hz(0.1)
@@ -59,9 +52,6 @@ fn main() {
                     .feedback_ratio(0.5),
             )
             .filter(reverb::default().room_size(0.9).damping(0.1))
-
-        //            .filter(reverb())
-        //            .filter(chorus())
     });
     thread::park();
 }

core/src/sig.rs

@@ -666,6 +666,16 @@ where
             x
         })
     }
+
+    /// Force the evaluation of some other signal when this signal is evaluated but ignore the
+    /// result. Use this when computing a signal has side effects (e.g. rendering a visualization)
+    /// but the effectful signal's value is unnecessary.
+    pub fn force<O>(self, other: O) -> Sig<impl SigT<Item = S::Item>>
+    where
+        O: SigT,
+    {
+        self.zip(other).map(|(x, _)| x)
+    }
 }
 
 impl<S, A, B> Sig<S>

core/src/stereo.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use crate::{Buf, Sig, SigCtx, SigSampleIntoBufT, SigT, sig_ops::sig_add};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -6,6 +8,15 @@ pub enum Channel {
     Right,
 }
 
+impl Display for Channel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Left => write!(f, "left"),
+            Self::Right => write!(f, "right"),
+        }
+    }
+}
+
 impl Channel {
     // Apply a 90 degree offset to the right channel so a stereo sine wave would draw a circle with
     // stereo oscillographics.

keyboard/src/a440_12tet.rs

@@ -120,39 +120,39 @@ impl NoteName {
     pub const B: Self = Self::from_index(11);
 
     /// Returns a str representation of the note name where all accidentals are sharp, formatted
-    /// like "C" or "C_sharp"
+    /// like "C" or "C#"
     pub const fn to_str_sharp(self) -> &'static str {
         match self.relative_midi_index {
             0 => "C",
-            1 => "C_sharp",
+            1 => "C#",
             2 => "D",
-            3 => "D_sharp",
+            3 => "D#",
             4 => "E",
             5 => "F",
-            6 => "F_sharp",
+            6 => "F#",
             7 => "G",
-            8 => "G_sharp",
+            8 => "G#",
             9 => "A",
-            10 => "A_sharp",
+            10 => "A#",
             11 => "B",
             _ => unreachable!(),
         }
     }
 
-    /// Parses a str like "C" or "C_sharp"
+    /// Parses a str like "C" or "C#"
     pub fn from_str_sharp(s: &str) -> Option<Self> {
         let relative_midi_index = match s {
             "C" => 0,
-            "C_sharp" => 1,
+            "C#" => 1,
             "D" => 2,
-            "D_sharp" => 3,
+            "D#" => 3,
             "E" => 4,
             "F" => 5,
-            "F_sharp" => 6,
+            "F#" => 6,
             "G" => 7,
-            "G_sharp" => 8,
+            "G#" => 8,
             "A" => 9,
-            "A_sharp" => 10,
+            "A#" => 10,
             "B" => 11,
             _ => return None,
         };
@@ -287,7 +287,7 @@ impl Note {
     }
 }
 
-/// Example formats: "C_sharp:4", "C:4". Notes in octave "-1" are written like "C_sharp:-1" or
+/// Example formats: "C#:4", "C:4". Notes in octave "-1" are written like "C#:-1" or
 /// "C:-1".
 impl Display for Note {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -300,7 +300,7 @@ impl Display for Note {
     }
 }
 
-/// Expected format: "C_sharp-4", "C-4"
+/// Expected format: "C#-4", "C-4"
 impl FromStr for Note {
     type Err = String;
 

utils/src/lib.rs

@@ -4,4 +4,4 @@ pub mod noise;
 pub mod sequencer;
 pub use sequencer::value_sequencer;
 pub mod looper;
-pub use looper::sequence_looper;
+pub use looper::{key_looper, value_looper};

utils/src/looper.rs

@@ -1,63 +1,188 @@
 use caw_core::{Buf, Sig, SigCtx, SigT};
 use itertools::izip;
 
-struct SequenceLooper<X, S, T, R, N>
+#[derive(Default)]
+struct Sequence<T> {
+    sequence: Vec<T>,
+    index: usize,
+}
+
+impl<T> Sequence<T> {
+    fn tick(&mut self) {
+        assert!(self.sequence.len() > 0);
+        self.index = (self.index + 1) % self.sequence.len();
+    }
+
+    fn current(&self) -> &T {
+        &self.sequence[self.index]
+    }
+
+    fn current_mut(&mut self) -> &mut T {
+        &mut self.sequence[self.index]
+    }
+
+    fn resize_with<F: FnMut() -> T>(&mut self, length: usize, f: F) {
+        if length != self.sequence.len() {
+            let length = length.max(1);
+            self.sequence.resize_with(length, f);
+            if self.index >= length {
+                self.index = 0;
+            }
+        }
+    }
+
+    fn new_with<F: FnMut() -> T>(length: usize, f: F) -> Self {
+        let length = length.max(1);
+        let mut sequence = Vec::new();
+        sequence.resize_with(length, f);
+        Self { sequence, index: 0 }
+    }
+}
+
+struct KeyLooper<X, S, T, C, N>
 where
     X: Clone,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
-    R: SigT<Item = bool>,
+    C: SigT<Item = bool>,
     N: SigT<Item = u32>,
 {
     sig: S,
+    last_value: S::Item,
     tick: T,
-    recording: R,
+    clearing: C,
     length: N,
-    sequence: Vec<S::Item>,
+    sequence: Sequence<S::Item>,
     buf: Vec<S::Item>,
 }
 
-impl<X, S, T, R, N> SigT for SequenceLooper<X, S, T, R, N>
+impl<X, S, T, C, N> SigT for KeyLooper<X, S, T, C, N>
 where
     X: Clone,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
-    R: SigT<Item = bool>,
+    C: SigT<Item = bool>,
     N: SigT<Item = u32>,
 {
     type Item = S::Item;
 
     fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        self.buf.clear();
         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 clearing = self.clearing.sample(ctx);
         let length = self.length.sample(ctx);
-        for (out, sample, tick, recording, length) in izip! {
+        for (out, sample, tick, clearing, length) in izip! {
             self.buf.iter_mut(),
             sig.iter(),
             tick.iter(),
-            recording.iter(),
+            clearing.iter(),
             length.iter(),
         } {
-            *out = sample;
+            self.sequence.resize_with(length as usize, || None);
+            if tick {
+                self.sequence.tick();
+                self.last_value = None;
+            } else if sample.is_some() {
+                self.last_value = sample.clone();
+            }
+            if clearing {
+                *self.sequence.current_mut() = None;
+            } else if self.last_value.is_some() {
+                *self.sequence.current_mut() = self.last_value.clone();
+            }
+            *out = self.sequence.current().clone();
         }
         &self.buf
     }
 }
 
-pub fn sequence_looper<X: Clone>(
+pub fn key_looper<X: Clone>(
     sig: impl SigT<Item = Option<X>>,
     tick: impl SigT<Item = bool>,
-    recording: impl SigT<Item = bool>,
+    clearing: impl SigT<Item = bool>,
     length: impl SigT<Item = u32>,
 ) -> Sig<impl SigT<Item = Option<X>>> {
-    Sig(SequenceLooper {
+    Sig(KeyLooper {
+        sig,
+        last_value: None,
+        tick,
+        clearing,
+        length,
+        sequence: Sequence::new_with(1, || None),
+        buf: Vec::new(),
+    })
+}
+
+struct ValueLooper<S, T, R, N>
+where
+    S: SigT,
+    S::Item: Clone,
+    T: SigT<Item = bool>,
+    R: SigT<Item = bool>,
+    N: SigT<Item = u32>,
+{
+    sig: S,
+    tick: T,
+    recording: R,
+    length: N,
+    sequence: Sequence<Option<S::Item>>,
+    buf: Vec<S::Item>,
+}
+
+impl<S, T, R, N> SigT for ValueLooper<S, T, R, N>
+where
+    S: SigT,
+    S::Item: Clone,
+    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.clear();
+        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 (sample, tick, recording, length) in izip! {
+            sig.iter(),
+            tick.iter(),
+            recording.iter(),
+            length.iter(),
+        } {
+            self.sequence.resize_with(length as usize, || None);
+            if tick {
+                self.sequence.tick();
+            }
+            let stored = self.sequence.current_mut();
+            let out = match (recording, stored.clone()) {
+                (true, _) | (_, None) => {
+                    *stored = Some(sample.clone());
+                    sample
+                }
+                (_, Some(stored)) => stored,
+            };
+            self.buf.push(out);
+        }
+        &self.buf
+    }
+}
+
+pub fn value_looper<T: Clone>(
+    sig: impl SigT<Item = T>,
+    tick: impl SigT<Item = bool>,
+    recording: impl SigT<Item = bool>,
+    length: impl SigT<Item = u32>,
+) -> Sig<impl SigT<Item = T>> {
+    Sig(ValueLooper {
         sig,
         tick,
         recording,
         length,
-        sequence: Vec::new(),
+        sequence: Sequence::new_with(1, || None),
         buf: Vec::new(),
     })
 }