Process -> Audio; Layers2 -> Layers

crates/tek_core/src/audio.rs

@@ -1,10 +1,31 @@
 use jack::*;
 use crate::*;
 
-submod! { device event ports }
+/// Trait for things that have a JACK process callback.
+pub trait Audio {
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+}
+
+/// Trait for things that may expose JACK ports.
+pub trait Ports {
+    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+}
 
 /// A UI component that may be associated with a JACK client by the `Jack` factory.
-pub trait Device<E: Engine>: Component<E> + Process {
+pub trait Device<E: Engine>: Component<E> + Audio {
     /// Perform type erasure for collecting heterogeneous devices.
     fn boxed (self) -> Box<dyn Device<E>> where Self: Sized + 'static {
         Box::new(self)
@@ -12,13 +33,7 @@ pub trait Device<E: Engine>: Component<E> + Process {
 }
 
 /// All things that implement the required traits can be treated as `Device`.
-impl<E: Engine, W: Component<E> + Process> Device<E> for W {}
-
-//impl<'a, E: Engine> Render<E> for Box<dyn Device<E> + 'a> {
-    //fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
-        //(**self).render(to)
-    //}
-//}
+impl<E: Engine, W: Component<E> + Audio> Device<E> for W {}
 
 /// Wraps [Client] or [DynamicAsyncClient] in place.
 pub enum JackClient {
@@ -57,52 +72,24 @@ impl JackClient {
                 ClosureProcessHandler::new(Box::new({
                     let state = state.clone();
                     move|c: &Client, s: &ProcessScope|process(&state, c, s)
-                }) as BoxedProcessHandler)
+                }) as BoxedAudioHandler)
             )?)
         })
     }
 }
 
 pub type DynamicAsyncClient =
-    AsyncClient<DynamicNotifications, DynamicProcessHandler>;
+    AsyncClient<DynamicNotifications, DynamicAudioHandler>;
 
-type DynamicProcessHandler =
-    ClosureProcessHandler<BoxedProcessHandler>;
+type DynamicAudioHandler =
+    ClosureProcessHandler<BoxedAudioHandler>;
 
-pub type BoxedProcessHandler =
+pub type BoxedAudioHandler =
     Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
 
-/// Trait for things that have a JACK process callback.
-pub trait Process {
-    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
-        Control::Continue
-    }
-}
-
-/// Define the JACK process callback associated with a struct.
-#[macro_export] macro_rules! process {
-    ($T:ty) => {
-        impl Process for $T {}
-    };
-    ($T:ty |$self:ident, $c:ident, $s:ident|$block:tt) => {
-        impl Process for $T {
-            fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control {
-                $block
-            }
-        }
-    };
-    ($T:ty = $process:path) => {
-        impl Process for $T {
-            fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
-                $process(self, c, s)
-            }
-        }
-    }
-}
-
 /// Just run thing with JACK. Returns the activated client.
 pub fn jack_run <T, E: Engine> (name: &str, app: &Arc<RwLock<T>>) -> Usually<DynamicAsyncClient>
-    where T: Handle<E> + Process + Send + Sync + 'static
+    where T: Handle<E> + Audio + Send + Sync + 'static
 {
     let options = ClientOptions::NO_START_SERVER;
     let (client, _status) = Client::new(name, options)?;
@@ -120,7 +107,7 @@ pub fn jack_run <T, E: Engine> (name: &str, app: &Arc<RwLock<T>>) -> Usually<Dyn
                 app.write().unwrap().process(c, s)
                 //Control::Continue
             }
-        }) as BoxedProcessHandler)
+        }) as BoxedAudioHandler)
     )?)
 }
 
@@ -133,6 +120,7 @@ pub struct Jack {
     pub midi_outs:  Vec<String>,
     pub audio_outs: Vec<String>,
 }
+
 impl Jack {
     pub fn new (name: &str) -> Usually<Self> {
         Ok(Self {
@@ -180,7 +168,7 @@ impl Jack {
                 move|c: &Client, s: &ProcessScope|{
                     state.write().unwrap().process(c, s)
                 }
-            }) as BoxedProcessHandler)
+            }) as BoxedAudioHandler)
         )?;
         Ok(JackDevice {
             ports: UnownedJackPorts {
@@ -230,3 +218,219 @@ fn query_ports (
         ports
     })
 }
+
+/// Notification handler used by the [Jack] factory
+/// when constructing [JackDevice]s.
+pub type DynamicNotifications =
+    Notifications<Box<dyn Fn(JackEvent) + Send + Sync>>;
+
+#[derive(Debug)]
+/// Event enum for JACK events.
+pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, String),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(String, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, String, String),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [JackEvent]
+pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
+
+impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
+    fn thread_init (&self, _: &Client) {
+        self.0(JackEvent::ThreadInit);
+    }
+
+    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
+        self.0(JackEvent::Shutdown(status, reason.into()));
+    }
+
+    fn freewheel (&mut self, _: &Client, enabled: bool) {
+        self.0(JackEvent::Freewheel(enabled));
+    }
+
+    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(JackEvent::SampleRate(frames));
+        Control::Quit
+    }
+
+    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(JackEvent::ClientRegistration(name.into(), reg));
+    }
+
+    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(JackEvent::PortRegistration(id, reg));
+    }
+
+    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(JackEvent::PortRename(id, old.into(), new.into()));
+        Control::Continue
+    }
+
+    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(JackEvent::PortsConnected(a, b, are));
+    }
+
+    fn graph_reorder (&mut self, _: &Client) -> Control {
+        self.0(JackEvent::GraphReorder);
+        Control::Continue
+    }
+
+    fn xrun (&mut self, _: &Client) -> Control {
+        self.0(JackEvent::XRun);
+        Control::Continue
+    }
+}
+
+/// A [Device] bound to a JACK client and a set of ports.
+pub struct JackDevice<E: Engine> {
+    /// The active JACK client of this device.
+    pub client: DynamicAsyncClient,
+    /// The device state, encapsulated for sharing between threads.
+    pub state:  Arc<RwLock<Box<dyn Device<E>>>>,
+    /// Unowned copies of the device's JACK ports, for connecting to the device.
+    /// The "real" readable/writable `Port`s are owned by the `state`.
+    pub ports:  UnownedJackPorts,
+}
+
+impl<E: Engine> std::fmt::Debug for JackDevice<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("JackDevice").field("ports", &self.ports).finish()
+    }
+}
+
+impl<E: Engine> Widget for JackDevice<E> {
+    type Engine = E;
+    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+        self.state.read().unwrap().layout(to)
+    }
+    fn render (&self, to: &mut E) -> Perhaps<E::Area> {
+        self.state.read().unwrap().render(to)
+    }
+}
+
+impl<E: Engine> Handle<E> for JackDevice<E> {
+    fn handle (&mut self, from: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.state.write().unwrap().handle(from)
+    }
+}
+
+impl<E: Engine> Ports for JackDevice<E> {
+    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.audio_ins.values().collect())
+    }
+    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.audio_outs.values().collect())
+    }
+    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.midi_ins.values().collect())
+    }
+    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.midi_outs.values().collect())
+    }
+}
+
+impl<E: Engine> JackDevice<E> {
+    /// Returns a locked mutex of the state's contents.
+    pub fn state (&self) -> LockResult<RwLockReadGuard<Box<dyn Device<E>>>> {
+        self.state.read()
+    }
+    /// Returns a locked mutex of the state's contents.
+    pub fn state_mut (&self) -> LockResult<RwLockWriteGuard<Box<dyn Device<E>>>> {
+        self.state.write()
+    }
+    pub fn connect_midi_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.midi_ins()?[index])?)
+    }
+    pub fn connect_midi_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.midi_outs()?[index], port)?)
+    }
+    pub fn connect_audio_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.audio_ins()?[index])?)
+    }
+    pub fn connect_audio_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.audio_outs()?[index], port)?)
+    }
+}
+
+/// Collection of JACK ports as [AudioIn]/[AudioOut]/[MidiIn]/[MidiOut].
+#[derive(Default, Debug)]
+pub struct JackPorts {
+    pub audio_ins:  BTreeMap<String, Port<AudioIn>>,
+    pub midi_ins:   BTreeMap<String, Port<MidiIn>>,
+    pub audio_outs: BTreeMap<String, Port<AudioOut>>,
+    pub midi_outs:  BTreeMap<String, Port<MidiOut>>,
+}
+
+/// Collection of JACK ports as [Unowned].
+#[derive(Default, Debug)]
+pub struct UnownedJackPorts {
+    pub audio_ins:  BTreeMap<String, Port<Unowned>>,
+    pub midi_ins:   BTreeMap<String, Port<Unowned>>,
+    pub audio_outs: BTreeMap<String, Port<Unowned>>,
+    pub midi_outs:  BTreeMap<String, Port<Unowned>>,
+}
+
+impl JackPorts {
+    pub fn clone_unowned (&self) -> UnownedJackPorts {
+        let mut unowned = UnownedJackPorts::default();
+        for (name, port) in self.midi_ins.iter() {
+            unowned.midi_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.midi_outs.iter() {
+            unowned.midi_outs.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_ins.iter() {
+            unowned.audio_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_outs.iter() {
+            unowned.audio_outs.insert(name.clone(), port.clone_unowned());
+        }
+        unowned
+    }
+}
+
+/// Implement the `Ports` trait.
+#[macro_export] macro_rules! ports {
+    ($T:ty $({ $(audio: {
+        $(ins:  |$ai_arg:ident|$ai_impl:expr,)?
+        $(outs: |$ao_arg:ident|$ao_impl:expr,)?
+    })? $(midi: {
+        $(ins:  |$mi_arg:ident|$mi_impl:expr,)?
+        $(outs: |$mo_arg:ident|$mo_impl:expr,)?
+    })?})?) => {
+        impl Ports for $T {$(
+            $(
+                $(fn audio_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = |$ai_arg:&'a Self|$ai_impl;
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$ao_arg:&'a Self|$ao_impl);
+                    cb(self)
+                })?
+            )?
+        )? $(
+            $(
+                $(fn midi_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mi_arg:&'a Self|$mi_impl);
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mo_arg:&'a Self|$mo_impl);
+                    cb(self)
+                })?
+            )?
+        )?}
+    };
+}