Add library for launching widgets as processes

gridbugs · gridbugs · commit 8922f7cacf19 · 2025-04-23T01:25:33.000+10:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,7 @@ members = [
     "midi-udp",
     "midi-udp-client",
     "midi-udp-widgets-app",
+    "midi-udp-widgets-app-lib",
     "modules",
     "patches",
     "player",
diff --git a/core/src/sig.rs b/core/src/sig.rs
@@ -1100,6 +1100,14 @@ where
             buf: Vec::new(),
         }
     }
+
+    pub fn with_inner<T, F>(&self, mut f: F) -> T
+    where
+        F: FnMut(&S) -> T,
+    {
+        let inner_cached = self.shared_cached_sig.read().unwrap();
+        f(&inner_cached.sig)
+    }
 }
 
 impl<S> Clone for SigShared<S>
diff --git a/midi-udp-widgets-app-lib/Cargo.toml b/midi-udp-widgets-app-lib/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "caw_midi_udp_widgets_app_lib"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+caw_midi_udp = { version = "0.1", path = "../midi-udp" }
+caw_core = { version = "0.5", path = "../core" }
+caw_midi = { version = "0.4", path = "../midi" }
+caw_builder_proc_macros = { version = "0.1", path = "../builder-proc-macros" }
+lazy_static = "1.5"
+anyhow = "1.0"
+
+[dev-dependencies]
+env_logger = "0.11"
+caw_interactive = { path = "../interactive" }
+caw_modules = { version = "0.4", path = "../modules" }
+
+[[example]]
+name = "midi_udp_widgets_app_lib_knob"
diff --git a/midi-udp-widgets-app-lib/examples/midi_udp_widgets_app_lib_knob.rs b/midi-udp-widgets-app-lib/examples/midi_udp_widgets_app_lib_knob.rs
@@ -0,0 +1,17 @@
+use caw_core::*;
+use caw_interactive::window::Window;
+use caw_midi_udp_widgets_app_lib::knob;
+use caw_modules::*;
+
+fn sig() -> Sig<impl SigT<Item = f32>> {
+    oscillator(waveform::Saw, 40.0 + 40.0 * knob().title("freq").build())
+        .build()
+        .zip(oscillator(waveform::Saw, 40.1).build())
+        .map(|(a, b)| (a + b) / 10.0)
+}
+
+fn main() -> anyhow::Result<()> {
+    env_logger::init();
+    let window = Window::builder().build();
+    window.play_mono(sig(), Default::default())
+}
diff --git a/midi-udp-widgets-app-lib/src/lib.rs b/midi-udp-widgets-app-lib/src/lib.rs
@@ -0,0 +1,124 @@
+use caw_core::{Buf, Sig, SigShared, SigT, sig_shared};
+use caw_midi::{MidiController01, MidiMessagesT};
+use caw_midi_udp::{MidiLiveUdp, MidiLiveUdpChannel};
+use lazy_static::lazy_static;
+use std::{
+    net::SocketAddr,
+    process::{Child, Command},
+};
+
+// For now this library only supports midi channel 0
+const CHANNEL: u8 = 0;
+
+lazy_static! {
+    static ref SIG: Sig<SigShared<MidiLiveUdpChannel>> =
+        sig_shared(MidiLiveUdp::new_unspecified().unwrap().channel(CHANNEL).0);
+}
+
+fn sig_server_local_socket_address() -> SocketAddr {
+    SIG.0.with_inner(|midi_live_udp_channel| {
+        midi_live_udp_channel.server.local_socket_address().unwrap()
+    })
+}
+
+const PROGRAM_NAME: &str = "caw_midi_udp_widgets_app";
+
+pub struct Knob {
+    controller: u8,
+    title: Option<String>,
+    initial_value_01: f32,
+    sensitivity: f32,
+    process: Option<Child>,
+    sig: Sig<MidiController01<SigShared<MidiLiveUdpChannel>>>,
+}
+
+impl Knob {
+    pub fn new(
+        controller: u8,
+        title: Option<String>,
+        initial_value_01: f32,
+        sensitivity: f32,
+    ) -> Sig<Self> {
+        let sig = SIG
+            .clone()
+            .controllers()
+            .get_with_initial_value_01(controller, initial_value_01);
+        let mut s = Self {
+            controller,
+            title,
+            initial_value_01,
+            sensitivity,
+            process: None,
+            sig,
+        };
+        let child = s
+            .command()
+            .unwrap()
+            .spawn()
+            .expect("Failed to launch process");
+        s.process = Some(child);
+        Sig(s)
+    }
+
+    fn command(&self) -> anyhow::Result<Command> {
+        let mut command = Command::new(PROGRAM_NAME);
+        let mut args = vec![
+            "knob".to_string(),
+            "--server".to_string(),
+            sig_server_local_socket_address().to_string(),
+            "--channel".to_string(),
+            format!("{}", CHANNEL),
+            "--controller".to_string(),
+            format!("{}", self.controller),
+            "--initial-value".to_string(),
+            format!("{}", self.initial_value_01),
+            "--sensitivity".to_string(),
+            format!("{}", self.sensitivity),
+        ];
+        if let Some(title) = self.title.as_ref() {
+            args.extend(["--title".to_string(), title.clone()]);
+        }
+        command.args(args);
+        Ok(command)
+    }
+}
+
+impl SigT for Knob {
+    type Item = f32;
+
+    fn sample(&mut self, ctx: &caw_core::SigCtx) -> impl Buf<Self::Item> {
+        self.sig.sample(ctx)
+    }
+}
+
+mod builder {
+    use super::Knob;
+    use caw_builder_proc_macros::builder;
+    use caw_core::Sig;
+
+    builder! {
+        #[constructor = "knob"]
+        #[constructor_doc = "A visual knob in a new window"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "Knob::new"]
+        #[build_ty = "Sig<Knob>"]
+        pub struct Props {
+            #[default = 0]
+            controller: u8,
+            #[default = None]
+            title_opt: Option<String>,
+            #[default = 0.5]
+            initial_value_01: f32,
+            #[default = 0.2]
+            sensitivity: f32,
+        }
+    }
+
+    impl Props {
+        pub fn title(self, title: impl Into<String>) -> Self {
+            self.title_opt(Some(title.into()))
+        }
+    }
+}
+
+pub use builder::knob;
diff --git a/midi-udp-widgets-app/src/main.rs b/midi-udp-widgets-app/src/main.rs
@@ -41,9 +41,9 @@ fn main() {
             sensitivity,
         } => {
             let client = MidiUdpClient::new(server).unwrap();
-            let title = title.unwrap_or_else(|| "".to_string());
             let mut knob =
-                Knob::new(title.as_str(), initial_value, sensitivity).unwrap();
+                Knob::new(title.as_deref(), initial_value, sensitivity)
+                    .unwrap();
             loop {
                 knob.tick().unwrap();
                 client
diff --git a/midi-udp/src/lib.rs b/midi-udp/src/lib.rs
@@ -1,9 +1,9 @@
-use caw_core::{Sig, SigT};
+use caw_core::{Buf, Sig, SigCtx, SigT};
 use caw_midi::MidiMessages;
 use midly::{MidiMessage, live::LiveEvent, num::u4};
 use std::{
     io,
-    net::{ToSocketAddrs, UdpSocket},
+    net::{Ipv4Addr, SocketAddr, ToSocketAddrs, UdpSocket},
 };
 
 const BUF_SIZE: usize = 256;
@@ -26,6 +26,14 @@ impl MidiLiveUdp {
         Ok(Self { socket, buf })
     }
 
+    pub fn new_unspecified() -> anyhow::Result<Self> {
+        Self::new((Ipv4Addr::UNSPECIFIED, 0))
+    }
+
+    pub fn local_socket_address(&self) -> anyhow::Result<SocketAddr> {
+        Ok(self.socket.local_addr()?)
+    }
+
     fn recv_into_buf(&mut self) -> Result<bool, io::Error> {
         match self.socket.recv(&mut self.buf) {
             Ok(size) => {
@@ -63,34 +71,48 @@ impl MidiLiveUdp {
         }
     }
 
-    pub fn channel(
-        mut self,
-        channel: u8,
-    ) -> Sig<impl SigT<Item = MidiMessages>> {
-        Sig::from_buf_fn(move |ctx, buf: &mut Vec<MidiMessages>| {
-            // This is called once per frame (not once per sample). This will add an imperceptible
-            // amount of latency (unless the output buffer is too large!), but reduce cpu usage.
-            buf.resize_with(ctx.num_samples, Default::default);
-            let mut midi_messages = MidiMessages::empty();
-            loop {
-                match self.recv_midi_event() {
-                    Err(e) => {
-                        log::warn!("IO error reading from UDP socket: {e}");
-                        break;
-                    }
-                    Ok(None) => break,
-                    Ok(Some(MidiEvent {
-                        channel: message_channel,
-                        message,
-                    })) => {
-                        if message_channel == channel {
-                            midi_messages.push(message);
-                        }
+    pub fn channel(self, channel: u8) -> Sig<MidiLiveUdpChannel> {
+        Sig(MidiLiveUdpChannel {
+            channel: channel.into(),
+            server: self,
+            buf: Vec::new(),
+        })
+    }
+}
+
+pub struct MidiLiveUdpChannel {
+    pub channel: u4,
+    pub server: MidiLiveUdp,
+    buf: Vec<MidiMessages>,
+}
+
+impl SigT for MidiLiveUdpChannel {
+    type Item = MidiMessages;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        // This is called once per frame (not once per sample). This will add an imperceptible
+        // amount of latency (unless the output buffer is too large!), but reduce cpu usage.
+        self.buf.resize_with(ctx.num_samples, Default::default);
+        let mut midi_messages = MidiMessages::empty();
+        loop {
+            match self.server.recv_midi_event() {
+                Err(e) => {
+                    log::warn!("IO error reading from UDP socket: {e}");
+                    break;
+                }
+                Ok(None) => break,
+                Ok(Some(MidiEvent {
+                    channel: message_channel,
+                    message,
+                })) => {
+                    if message_channel == self.channel {
+                        midi_messages.push(message);
                     }
                 }
             }
-            // Only the first sample of each frame is populated with midi messages.
-            buf[0] = midi_messages;
-        })
+        }
+        // Only the first sample of each frame is populated with midi messages.
+        self.buf[0] = midi_messages;
+        &self.buf
     }
 }
diff --git a/midi/src/lib.rs b/midi/src/lib.rs
@@ -1,4 +1,4 @@
-use caw_core::{sig_shared, Sig, SigShared, SigT};
+use caw_core::{sig_shared, Buf, Sig, SigCtx, SigShared, SigT};
 use caw_keyboard::{KeyEvent, KeyEvents, Note, TONE_RATIO};
 use midly::{num::u7, MidiMessage};
 use smallvec::{smallvec, SmallVec};
@@ -73,6 +73,39 @@ where
     messages: Sig<SigShared<M>>,
 }
 
+pub struct MidiController01<M>
+where
+    M: SigT<Item = MidiMessages>,
+{
+    index: u7,
+    state: f32,
+    messages: SigShared<M>,
+    buf: Vec<f32>,
+}
+
+impl<M> SigT for MidiController01<M>
+where
+    M: SigT<Item = MidiMessages>,
+{
+    type Item = f32;
+
+    fn sample(&mut self, ctx: &SigCtx) -> impl Buf<Self::Item> {
+        self.buf.resize(ctx.num_samples, 0.0);
+        let messages = self.messages.sample(ctx);
+        for (out, messages) in self.buf.iter_mut().zip(messages.iter()) {
+            for message in messages {
+                if let MidiMessage::Controller { controller, value } = message {
+                    if controller == self.index {
+                        self.state = value.as_int() as f32 / 127.0;
+                    }
+                }
+            }
+            *out = self.state;
+        }
+        &self.buf
+    }
+}
+
 impl<M> MidiControllers<M>
 where
     M: SigT<Item = MidiMessages>,
@@ -81,32 +114,24 @@ where
         &self,
         index: u8,
         initial_value: f32,
-    ) -> Sig<impl SigT<Item = f32>> {
-        let index: u7 = index.into();
-        let mut state = initial_value.clamp(0., 1.);
-        self.messages.clone().map_mut(move |midi_messages| {
-            for midi_message in midi_messages {
-                if let MidiMessage::Controller { controller, value } =
-                    midi_message
-                {
-                    if controller == index {
-                        state = value.as_int() as f32 / 127.0;
-                    }
-                }
-            }
-            state
+    ) -> Sig<MidiController01<M>> {
+        Sig(MidiController01 {
+            index: index.into(),
+            state: initial_value.clamp(0., 1.),
+            messages: self.messages.clone().0,
+            buf: Vec::new(),
         })
     }
 
-    pub fn get_01(&self, index: u8) -> Sig<impl SigT<Item = f32>> {
+    pub fn get_01(&self, index: u8) -> Sig<MidiController01<M>> {
         self.get_with_initial_value_01(index, 0.0)
     }
 
-    pub fn volume(&self) -> Sig<impl SigT<Item = f32>> {
+    pub fn volume(&self) -> Sig<MidiController01<M>> {
         self.get_01(7)
     }
 
-    pub fn modulation(&self) -> Sig<impl SigT<Item = f32>> {
+    pub fn modulation(&self) -> Sig<MidiController01<M>> {
         self.get_01(1)
     }
 }
diff --git a/widgets/src/knob.rs b/widgets/src/knob.rs

Original file line number	Diff line number	Diff line change
`@@ -1100,6 +1100,14 @@ where`
`1100`	`1100`	`buf: Vec::new(),`
`1101`	`1101`	`}`
`1102`	`1102`	`}`
	`1103`	`+`
	`1104`	`+ pub fn with_inner<T, F>(&self, mut f: F) -> T`
	`1105`	`+ where`
	`1106`	`+ F: FnMut(&S) -> T,`
	`1107`	`+ {`
	`1108`	`+ let inner_cached = self.shared_cached_sig.read().unwrap();`
	`1109`	`+ f(&inner_cached.sig)`
	`1110`	`+ }`
`1103`	`1111`	`}`
`1104`	`1112`
`1105`	`1113`	`impl<S> Clone for SigShared<S>`