Add blink visualization

Author: gridbugs

caw/Cargo.toml

@@ -73,3 +73,7 @@ required-features = [ "interactive", "audio_file" ]
 [[example]]
 name = "udp_viz_demo"
 required-features = [ "viz", "player" ]
+
+[[example]]
+name = "live_example"
+required-features = [ "live", "widgets", "viz" ]

caw/examples/live_example.rs

@@ -0,0 +1,30 @@
+use caw::prelude::*;
+use std::thread;
+
+fn main() {
+    let volume = sv_default();
+    let out: LiveStereoOut = live_stereo_viz_udp(oscilloscope::Config {
+        ..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);
+            })
+    });
+    out.set(|| {
+        super_saw(60.)
+            .build()
+            .filter(low_pass::default(100. + env.clone() * 4000.).q(0.5))
+    });
+    thread::park();
+}

core/src/sig.rs

@@ -19,6 +19,7 @@ where
 {
     fn iter(&self) -> impl Iterator<Item = T>;
 
+    /// Clears `out` and populates it with the contents of `self`.
     fn clone_to_vec(&self, out: &mut Vec<T>) {
         out.clear();
         for x in self.iter() {
@@ -586,6 +587,19 @@ where
         })
     }
 
+    /// Calls `f` once per frame on all the samples computed during that frame, returning the
+    /// original signal unchanged.
+    pub fn with_buf<F>(self, f: F) -> Sig<WithBuf<S, F>>
+    where
+        F: FnMut(&[S::Item]),
+    {
+        Sig(WithBuf {
+            sig: self.0,
+            f,
+            buf: Vec::new(),
+        })
+    }
+
     pub fn zip<O>(self, other: O) -> Sig<Zip<S, O>>
     where
         O: SigT,
@@ -1002,6 +1016,31 @@ where
     }
 }
 
+pub struct WithBuf<S, F>
+where
+    S: SigT,
+    F: FnMut(&[S::Item]),
+{
+    sig: S,
+    f: F,
+    buf: Vec<S::Item>,
+}
+
+impl<S, F> SigT for WithBuf<S, F>
+where
+    S: SigT,
+    F: FnMut(&[S::Item]),
+{
+    type Item = S::Item;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        let ret = self.sig.sample(ctx);
+        ret.clone_to_vec(&mut self.buf);
+        (self.f)(&self.buf);
+        ret
+    }
+}
+
 pub struct MapMut<S, T, F>
 where
     S: SigT,

live/src/lib.rs

@@ -2,7 +2,7 @@ use caw_core::{Sig, SigBoxedVar, Stereo, StereoPair, svf32};
 use caw_player::{
     PlayerConfig, PlayerVisualizationData, VisualizationDataPolicy, play_stereo,
 };
-use caw_viz_udp_app_lib::oscilloscope;
+use caw_viz_udp_app_lib::{SendStatus, oscilloscope};
 use lazy_static::lazy_static;
 use std::{sync::Mutex, thread, time::Duration};
 
@@ -40,11 +40,20 @@ pub fn live_stereo_viz(
 
 pub fn live_stereo_viz_udp(config: oscilloscope::Config) -> LiveStereoOut {
     let (out, viz_data) = live_stereo_viz(VisualizationDataPolicy::All);
-    let mut viz = oscilloscope::Server::new("CAW Synthesizer", config).unwrap();
+    let make_viz = move || {
+        oscilloscope::Server::new("CAW Synthesizer", config.clone()).unwrap()
+    };
+    let mut viz = make_viz();
     thread::spawn(move || {
         loop {
-            // TODO: Is it ok to ignore errors here?
-            let _ = viz_data.with_and_clear(|buf| viz.send_samples(buf));
+            match viz_data.with_and_clear(|buf| viz.send_samples(buf)) {
+                Ok(SendStatus::Success) => (),
+                Ok(SendStatus::Disconnected) => {
+                    // re-open the visualization if it was closed
+                    viz = make_viz();
+                }
+                Err(e) => eprintln!("{}", e),
+            }
             thread::sleep(Duration::from_millis(16));
         }
     });

viz-udp-app-lib/src/blink.rs

@@ -1,5 +1,6 @@
 use crate::common::{
-    MAX_F32_SAMPLES_TO_SEND, PROGRAM_NAME, VizUdpClient, VizUdpServer,
+    MAX_F32_SAMPLES_TO_SEND, PROGRAM_NAME, SendStatus, VizUdpClient,
+    VizUdpServer, samples_from_ne_bytes, samples_to_ne_bytes,
 };
 use std::{
     net::{SocketAddr, ToSocketAddrs},
@@ -19,8 +20,8 @@ impl Default for Config {
         Self {
             width: 100,
             height: 100,
-            red: 0,
-            green: 255,
+            red: 127,
+            green: 0,
             blue: 0,
         }
     }
@@ -36,7 +37,7 @@ fn start_client_app(
     command.args([
         format!("--server={}", server_addr.to_string()),
         format!("--title={}", title.to_string()),
-        "oscilloscope".to_string(),
+        "blink".to_string(),
         format!("--width={}", config.width),
         format!("--height={}", config.height),
         format!("--red={}", config.red),
@@ -45,3 +46,85 @@ fn start_client_app(
     ]);
     Ok(command.spawn()?)
 }
+
+pub struct Server {
+    raw: VizUdpServer,
+    buf: Vec<f32>,
+}
+
+fn send_samples(
+    server: &mut VizUdpServer,
+    samples: &[f32],
+) -> anyhow::Result<SendStatus> {
+    for samples_chunk in samples.chunks(MAX_F32_SAMPLES_TO_SEND) {
+        samples_to_ne_bytes(samples_chunk, &mut server.buf);
+        if !server.send_buf()? {
+            return Ok(SendStatus::Disconnected);
+        }
+    }
+    Ok(SendStatus::Success)
+}
+
+impl Server {
+    pub fn new(title: &str, config: Config) -> anyhow::Result<Self> {
+        Ok(Self {
+            raw: VizUdpServer::new(|server_addr| {
+                let _client_process = start_client_app(
+                    server_addr,
+                    PROGRAM_NAME,
+                    title,
+                    &config,
+                )?;
+                Ok(())
+            })?,
+            buf: Vec::new(),
+        })
+    }
+
+    pub fn send_samples(
+        &mut self,
+        samples: &[f32],
+    ) -> anyhow::Result<SendStatus> {
+        send_samples(&mut self.raw, samples)
+    }
+
+    pub fn send_samples_batched(
+        &mut self,
+        samples: &[f32],
+    ) -> anyhow::Result<()> {
+        self.buf.extend_from_slice(samples);
+        if self.buf.len() >= MAX_F32_SAMPLES_TO_SEND {
+            send_samples(&mut self.raw, &self.buf)?;
+            self.buf.clear();
+        }
+        Ok(())
+    }
+}
+
+pub struct Client {
+    raw: VizUdpClient,
+    buf: Vec<f32>,
+}
+
+impl Client {
+    pub fn new<A: ToSocketAddrs>(server_address: A) -> anyhow::Result<Self> {
+        Ok(Self {
+            raw: VizUdpClient::new(server_address)?,
+            buf: Vec::new(),
+        })
+    }
+
+    pub fn recv_sample(&mut self) -> anyhow::Result<bool> {
+        Ok(match self.raw.recv()? {
+            Some(buf_raw) => {
+                samples_from_ne_bytes(buf_raw, &mut self.buf);
+                true
+            }
+            None => false,
+        })
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = f32> {
+        self.buf.iter().cloned()
+    }
+}

viz-udp-app-lib/src/common.rs

@@ -123,3 +123,8 @@ impl VizUdpClient {
         }
     }
 }
+
+pub enum SendStatus {
+    Success,
+    Disconnected,
+}

viz-udp-app-lib/src/lib.rs

@@ -8,3 +8,4 @@
 pub mod blink;
 mod common;
 pub mod oscilloscope;
+pub use common::SendStatus;

viz-udp-app-lib/src/oscilloscope.rs

@@ -1,12 +1,31 @@
 use crate::common::{
-    MAX_F32_SAMPLES_TO_SEND, PROGRAM_NAME, VizUdpClient, VizUdpServer,
-    samples_from_ne_bytes, samples_to_ne_bytes,
+    MAX_F32_SAMPLES_TO_SEND, PROGRAM_NAME, SendStatus, VizUdpClient,
+    VizUdpServer, samples_from_ne_bytes, samples_to_ne_bytes,
 };
 use std::{
     net::{SocketAddr, ToSocketAddrs},
     process::{Child, Command},
 };
 
+#[derive(Clone, Copy, Debug)]
+pub enum OscilloscopeStyle {
+    Xy,
+    TimeDomain,
+    TimeDomainStereo,
+}
+impl ToString for OscilloscopeStyle {
+    fn to_string(&self) -> String {
+        match self {
+            OscilloscopeStyle::Xy => format!("xy"),
+            OscilloscopeStyle::TimeDomain => format!("time-domain"),
+            OscilloscopeStyle::TimeDomainStereo => {
+                format!("time-domain-stereo")
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
 pub struct Config {
     pub width: u32,
     pub height: u32,
@@ -17,6 +36,7 @@ pub struct Config {
     pub red: u8,
     pub green: u8,
     pub blue: u8,
+    pub style: OscilloscopeStyle,
 }
 
 impl Default for Config {
@@ -31,6 +51,7 @@ impl Default for Config {
             red: 0,
             green: 255,
             blue: 0,
+            style: OscilloscopeStyle::Xy,
         }
     }
 }
@@ -67,14 +88,14 @@ pub struct Server {
 fn send_samples(
     server: &mut VizUdpServer,
     samples: &[f32],
-) -> anyhow::Result<()> {
+) -> anyhow::Result<SendStatus> {
     for samples_chunk in samples.chunks(MAX_F32_SAMPLES_TO_SEND) {
         samples_to_ne_bytes(samples_chunk, &mut server.buf);
         if !server.send_buf()? {
-            break;
+            return Ok(SendStatus::Disconnected);
         }
     }
-    Ok(())
+    Ok(SendStatus::Success)
 }
 
 impl Server {
@@ -93,7 +114,10 @@ impl Server {
         })
     }
 
-    pub fn send_samples(&mut self, samples: &[f32]) -> anyhow::Result<()> {
+    pub fn send_samples(
+        &mut self,
+        samples: &[f32],
+    ) -> anyhow::Result<SendStatus> {
         send_samples(&mut self.raw, samples)
     }
 

viz-udp-app/Cargo.toml

@@ -11,7 +11,8 @@ documentation = "https://docs.rs/caw_viz_udp_app"
 
 [dependencies]
 anyhow = "1.0"
-sdl2 = { version = "0.38" }
+sdl2 = { version = "0.38", features = ["ttf"] }
 line_2d = "0.5"
 clap = { version = "4", features = ["derive"] }
 caw_viz_udp_app_lib = { version = "0.1", path = "../viz-udp-app-lib" }
+lazy_static = "1.5"