wip: nromalize

app/connect.rs

@@ -0,0 +1,306 @@
+use crate::*;
+
+/// Audio input port.
+#[derive(Debug)] pub struct AudioInput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<AudioIn>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+/// Audio output port.
+#[derive(Debug)] pub struct AudioOutput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<AudioOut>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+/// MIDI input port.
+#[derive(Debug)] pub struct MidiInput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<MidiIn>,
+    /// List of currently held notes.
+    pub held: Arc<RwLock<[bool;128]>>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+}
+
+/// MIDI output port.
+#[derive(Debug)] pub struct MidiOutput {
+    /// Handle to JACK client, for receiving reconnect events.
+    pub jack: Jack<'static>,
+    /// Port name
+    pub name: Arc<str>,
+    /// Port handle.
+    pub port: Port<MidiOut>,
+    /// List of ports to connect to.
+    pub connections: Vec<Connect>,
+    /// List of currently held notes.
+    pub held: Arc<RwLock<[bool;128]>>,
+    /// Buffer
+    pub note_buffer: Vec<u8>,
+    /// Buffer
+    pub output_buffer: Vec<Vec<Vec<u8>>>,
+}
+
+#[derive(Clone, Debug, PartialEq)] pub enum ConnectName {
+    /** Exact match */
+    Exact(Arc<str>),
+    /** Match regular expression */
+    RegExp(Arc<str>),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectScope {
+    One,
+    All
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)] pub enum ConnectStatus {
+    Missing,
+    Disconnected,
+    Connected,
+    Mismatch,
+}
+
+/// Port connection manager.
+///
+/// ```
+/// let connect = tek::Connect::default();
+/// ```
+#[derive(Clone, Debug, Default)] pub struct Connect {
+    pub name:   Option<ConnectName>,
+    pub scope:  Option<ConnectScope>,
+    pub status: Arc<RwLock<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>>,
+    pub info:   Arc<str>,
+}
+
+impl Connect {
+    pub fn collect (exact: &[impl AsRef<str>], re: &[impl AsRef<str>], re_all: &[impl AsRef<str>])
+        -> Vec<Self>
+    {
+        let mut connections = vec![];
+        for port in exact.iter()  { connections.push(Self::exact(port)) }
+        for port in re.iter()     { connections.push(Self::regexp(port)) }
+        for port in re_all.iter() { connections.push(Self::regexp_all(port)) }
+        connections
+    }
+    /// Connect to this exact port
+    pub fn exact (name: impl AsRef<str>) -> Self {
+        let info = format!("=:{}", name.as_ref()).into();
+        let name = Some(Exact(name.as_ref().into()));
+        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn regexp (name: impl AsRef<str>) -> Self {
+        let info = format!("~:{}", name.as_ref()).into();
+        let name = Some(RegExp(name.as_ref().into()));
+        Self { name, scope: Some(One), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn regexp_all (name: impl AsRef<str>) -> Self {
+        let info = format!("+:{}", name.as_ref()).into();
+        let name = Some(RegExp(name.as_ref().into()));
+        Self { name, scope: Some(All), status: Arc::new(RwLock::new(vec![])), info }
+    }
+    pub fn info (&self) -> Arc<str> {
+        format!(" ({}) {} {}", {
+            let status = self.status.read().unwrap();
+            let mut ok = 0;
+            for (_, _, state) in status.iter() {
+                if *state == Connected {
+                    ok += 1
+                }
+            }
+            format!("{ok}/{}", status.len())
+        }, match self.scope {
+            None      => "x",
+            Some(One) => " ",
+            Some(All) => "*",
+        }, match &self.name {
+            None               => format!("x"),
+            Some(Exact(name))  => format!("= {name}"),
+            Some(RegExp(name)) => format!("~ {name}"),
+        }).into()
+    }
+}
+
+impl HasJack<'static> for MidiInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl HasJack<'static> for MidiOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl HasJack<'static> for AudioInput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl HasJack<'static> for AudioOutput { fn jack (&self) -> &Jack<'static> { &self.jack } }
+impl<J: HasJack<'static>> RegisterPorts for J {
+    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput> {
+        MidiInput::new(self.jack(), name, connect)
+    }
+    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput> {
+        MidiOutput::new(self.jack(), name, connect)
+    }
+    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput> {
+        AudioInput::new(self.jack(), name, connect)
+    }
+    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput> {
+        AudioOutput::new(self.jack(), name, connect)
+    }
+}
+
+/// May create new MIDI input ports.
+pub trait AddMidiIn {
+    fn midi_in_add (&mut self) -> Usually<()>;
+}
+
+/// May create new MIDI output ports.
+pub trait AddMidiOut {
+    fn midi_out_add (&mut self) -> Usually<()>;
+}
+
+pub trait RegisterPorts: HasJack<'static> {
+    /// Register a MIDI input port.
+    fn midi_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiInput>;
+    /// Register a MIDI output port.
+    fn midi_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<MidiOutput>;
+    /// Register an audio input port.
+    fn audio_in (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioInput>;
+    /// Register an audio output port.
+    fn audio_out (&self, name: &impl AsRef<str>, connect: &[Connect]) -> Usually<AudioOutput>;
+}
+
+pub trait JackPort: HasJack<'static> {
+
+    type Port: PortSpec + Default;
+
+    type Pair: PortSpec + Default;
+
+    fn new (jack: &Jack<'static>, name: &impl AsRef<str>, connect: &[Connect])
+        -> Usually<Self> where Self: Sized;
+
+    fn register (jack: &Jack<'static>, name: &impl AsRef<str>) -> Usually<Port<Self::Port>> {
+        jack.with_client(|c|c.register_port::<Self::Port>(name.as_ref(), Default::default()))
+            .map_err(|e|e.into())
+    }
+
+    fn port_name (&self) -> &Arc<str>;
+
+    fn connections (&self) -> &[Connect];
+
+    fn port (&self) -> &Port<Self::Port>;
+
+    fn port_mut (&mut self) -> &mut Port<Self::Port>;
+
+    fn into_port (self) -> Port<Self::Port> where Self: Sized;
+
+    fn close (self) -> Usually<()> where Self: Sized {
+        let jack = self.jack().clone();
+        Ok(jack.with_client(|c|c.unregister_port(self.into_port()))?)
+    }
+
+    fn ports (&self, re_name: Option<&str>, re_type: Option<&str>, flags: PortFlags) -> Vec<String> {
+        self.with_client(|c|c.ports(re_name, re_type, flags))
+    }
+
+    fn port_by_id (&self, id: u32) -> Option<Port<Unowned>> {
+        self.with_client(|c|c.port_by_id(id))
+    }
+
+    fn port_by_name (&self, name: impl AsRef<str>) -> Option<Port<Unowned>> {
+        self.with_client(|c|c.port_by_name(name.as_ref()))
+    }
+
+    fn connect_to_matching <'k> (&'k self) -> Usually<()> {
+        for connect in self.connections().iter() {
+            match &connect.name {
+                Some(Exact(name)) => {
+                    *connect.status.write().unwrap() = self.connect_exact(name)?;
+                },
+                Some(RegExp(re))  => {
+                    *connect.status.write().unwrap() = self.connect_regexp(re, connect.scope)?;
+                },
+                _ => {},
+            };
+        }
+        Ok(())
+    }
+
+    fn connect_exact <'k> (&'k self, name: &str) ->
+        Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>>
+    {
+        self.with_client(move|c|{
+            let mut status = vec![];
+            for port in c.ports(None, None, PortFlags::empty()).iter() {
+                if port.as_str() == &*name {
+                    if let Some(port) = c.port_by_name(port.as_str()) {
+                        let port_status = self.connect_to_unowned(&port)?;
+                        let name = port.name()?.into();
+                        status.push((port, name, port_status));
+                        if port_status == Connected {
+                            break
+                        }
+                    }
+                }
+            }
+            Ok(status)
+        })
+    }
+
+    fn connect_regexp <'k> (
+        &'k self, re: &str, scope: Option<ConnectScope>
+    ) -> Usually<Vec<(Port<Unowned>, Arc<str>, ConnectStatus)>> {
+        self.with_client(move|c|{
+            let mut status = vec![];
+            let ports = c.ports(Some(&re), None, PortFlags::empty());
+            for port in ports.iter() {
+                if let Some(port) = c.port_by_name(port.as_str()) {
+                    let port_status = self.connect_to_unowned(&port)?;
+                    let name = port.name()?.into();
+                    status.push((port, name, port_status));
+                    if port_status == Connected && scope == Some(One) {
+                        break
+                    }
+                }
+            }
+            Ok(status)
+        })
+    }
+
+    /** Connect to a matching port by name. */
+    fn connect_to_name (&self, name: impl AsRef<str>) -> Usually<ConnectStatus> {
+        self.with_client(|c|if let Some(ref port) = c.port_by_name(name.as_ref()) {
+            self.connect_to_unowned(port)
+        } else {
+            Ok(Missing)
+        })
+    }
+
+    /** Connect to a matching port by reference. */
+    fn connect_to_unowned (&self, port: &Port<Unowned>) -> Usually<ConnectStatus> {
+        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
+            Connected
+        } else if let Ok(_) = c.connect_ports(port, self.port()) {
+            Connected
+        } else {
+            Mismatch
+        }))
+    }
+
+    /** Connect to an owned matching port by reference. */
+    fn connect_to_owned (&self, port: &Port<Self::Pair>) -> Usually<ConnectStatus> {
+        self.with_client(|c|Ok(if let Ok(_) = c.connect_ports(self.port(), port) {
+            Connected
+        } else if let Ok(_) = c.connect_ports(port, self.port()) {
+            Connected
+        } else {
+            Mismatch
+        }))
+    }
+
+}