start on proper system for routing

Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.86"
+crossbeam = "0.8.4"
 eframe = "0.29.1"
 egui = "0.29.1"
 enigo = { version = "0.2.1", features = ["serde"] }

src/bin/main.rs

@@ -13,11 +13,14 @@ fn main() {
     //enigo.text("echo \"hello world\"").unwrap();
     //enigo.key(Key::Return, Direction::Press).unwrap();
 
+    midi_keys::midi::daemon::run_daemon();
     midi_keys::ui::run();
 
 }
 
 pub fn run() -> Result<()> {
+    midi_keys::midi::daemon::run_daemon();
+
     let midi_in = MidiInput::new("keyboard")?;
 
     let midi_device = match find_first_midi_device(&midi_in) {

src/midi.rs

@@ -1,3 +1,5 @@
+pub mod daemon;
+
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub enum Message {
     Voice(VoiceMessage),

src/midi/daemon.rs

@@ -0,0 +1,138 @@
+use std::{
+    collections::HashMap,
+    sync::mpsc::{self, Receiver, Sender},
+};
+
+use midir::{MidiInput, MidiInputConnection, MidiInputPort};
+
+use crate::parser::parse_message;
+
+use super::Message;
+
+enum Category {
+    Drums,
+    WindSynth,
+    Piano,
+    Ignore,
+}
+
+/// Architecture for the MIDI connectivity:
+///
+/// State is what's held by the daemon, and is used in an event loop.
+/// - queues are passed in which are what we use to route messages
+/// - this state can only be accessed directly by the event loop, as it owns the state
+/// - does a `select!` (crossbeam) on the timer tick and on other channels
+///     - each tick of the timer (on a timer rx channel), call `state.refresh_ports()` and assign
+///       ports if they're mapped automatically (drums / windsynth / ignore) for anything that
+///       isn't yet mapped (users can override in UI)
+///     - listens to a queue of routing updates ("set connectionid to drums / windsynth / ignore")
+///       from the UI
+///     - receive from the message_receive queue and route the messages
+///
+/// ideal would be to do the port refresh on a separate thread. but! it's relatively cheap (250
+/// microseconds per refresh) so it's not a big deal
+
+type ConnectionId = String;
+type Timestamp = u64;
+type TimestampedMessage = (Timestamp, Message);
+
+pub fn run_daemon() {
+    let mut state = State::new();
+
+    loop {
+        state.refresh_ports();
+        std::thread::sleep_ms(250);
+    }
+}
+
+pub struct State {
+    midi: MidiInput,
+    ports: Vec<MidiInputPort>,
+    connections: HashMap<
+        String,
+        MidiInputConnection<(ConnectionId, Sender<(ConnectionId, TimestampedMessage)>)>,
+    >,
+
+    message_receive: Receiver<(ConnectionId, TimestampedMessage)>,
+    message_send: Sender<(ConnectionId, TimestampedMessage)>,
+}
+
+impl State {
+    pub fn new() -> State {
+        let (tx, rx) = mpsc::channel();
+
+        State {
+            midi: MidiInput::new("midi-keys daemon").expect("could not connect to system MIDI"),
+            ports: vec![],
+            connections: HashMap::new(),
+            message_receive: rx,
+            message_send: tx,
+        }
+    }
+
+    pub fn refresh_ports(&mut self) {
+        let start = std::time::Instant::now();
+
+        let ports = self.midi.ports();
+        for port in ports.iter() {
+            self.refresh_port(port);
+        }
+        self.ports = ports;
+
+        let duration = std::time::Instant::now().duration_since(start).as_micros();
+        println!("refreshing ports took {} microseconds", duration);
+    }
+
+    pub fn refresh_port(&mut self, port: &MidiInputPort) {
+        let start = std::time::Instant::now();
+        let connected = self.connections.contains_key(&port.id());
+
+        println!("checking conn took {} microseconds", std::time::Instant::now().duration_since(start).as_micros());
+        let name = match self.midi.port_name(port) {
+            Ok(s) => s,
+            Err(_) => {
+                // this case happens if we're using a MidiInputPort which has been disconnected,
+                // so we will remove the device from our connections list. we can try this even
+                // if it's not already in the map, as this is idempotent.
+                self.connections.remove(&port.id());
+                return;
+            }
+        };
+
+        println!("getting name took {} microseconds", std::time::Instant::now().duration_since(start).as_micros());
+
+        if connected {
+            return;
+        }
+
+        let midi = MidiInput::new("midi-keys").expect("could not connect to system MIDI");
+        println!("midi input init took {} microseconds", std::time::Instant::now().duration_since(start).as_micros());
+        let send_queue = self.message_send.clone();
+        println!("cloning queue took {} microseconds", std::time::Instant::now().duration_since(start).as_micros());
+
+        if let Ok(conn) = midi.connect(
+            &port,
+            &name,
+            |timestamp, bytes, (conn_id, send_queue)| {
+                handle_message(timestamp, bytes, &conn_id, &send_queue);
+            },
+            (port.id(), send_queue),
+        ) {
+            self.connections.insert(port.id(), conn);
+        }
+        println!("midi conn took {} microseconds", std::time::Instant::now().duration_since(start).as_micros());
+    }
+}
+
+fn handle_message(
+    ts: Timestamp,
+    bytes: &[u8],
+    conn_id: &ConnectionId,
+    tx: &Sender<(ConnectionId, TimestampedMessage)>,
+) {
+    if let Ok((_rem, msg)) = parse_message(bytes) {
+        let _ = tx.send((conn_id.clone(), (ts, msg)));
+    }
+}
+// TODO: chain of handlers? -> handle event as keypress, send to UI
+

src/ui.rs

@@ -3,6 +3,8 @@ use std::{sync::Arc, thread::JoinHandle};
 use egui::{mutex::Mutex, Color32, Frame, Rounding, SelectableLabel};
 use midir::{MidiInput, MidiInputPort};
 
+use crate::midi::Message;
+
 /// Launches the UI and runs it until it's done executing.
 pub fn run() {
     let native_options = eframe::NativeOptions::default();
@@ -15,8 +17,65 @@ pub fn run() {
     );
 }
 
+const MAX_MESSAGES: usize = 1_000;
+type Timestamp = u64;
+
+struct MidiMessageBuffer {
+    messages: Vec<(Timestamp, Message)>,
+    start: usize,
+    max: usize,
+}
+
+impl MidiMessageBuffer {
+    pub fn new(max: usize) -> MidiMessageBuffer {
+        Self {
+            messages: vec![],
+            start: 0,
+            max,
+        }
+    }
+
+    pub fn insert(&mut self, m: (Timestamp, Message)) {
+        if self.messages.len() < self.max {
+            self.messages.push(m);
+        } else {
+            self.messages[self.start] = m;
+            self.start = (self.start + 1) % self.messages.len();
+        }
+    }
+
+    pub fn iter(&self) -> BufferIter {
+        BufferIter {
+            elems: self.messages.as_slice(),
+            start: self.start,
+            index: 0,
+        }
+    }
+}
+
+struct BufferIter<'a> {
+    elems: &'a [(Timestamp, Message)],
+    start: usize,
+    index: usize,
+}
+
+impl<'a> Iterator for BufferIter<'a> {
+    type Item = (Timestamp, Message);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index >= self.elems.len() {
+            None
+        } else {
+            let elem = self.elems[(self.start + self.index) % self.elems.len()].clone();
+            self.index += 1;
+            Some(elem)
+        }
+    }
+}
+
 struct MidiKeysApp {
     midi_input_ports: Arc<Mutex<Vec<MidiInputPort>>>,
+    midi_messages: Arc<Mutex<MidiMessageBuffer>>,
     midi_in: MidiInput,
 }
 
@@ -28,11 +87,14 @@ impl MidiKeysApp {
             MidiInput::new("midi-keys").expect("could not connect to system MIDI");
         let midi_input_ports = Arc::new(Mutex::new(Vec::new()));
 
+        let midi_messages = Arc::new(Mutex::new(MidiMessageBuffer::new(MAX_MESSAGES)));
+
         // TODO: have a way to shut down the midi daemon?
         let _ = launch_midi_daemon(midi_input_ports.clone());
 
         MidiKeysApp {
             midi_input_ports,
+            midi_messages,
             midi_in,
         }
     }
@@ -88,10 +150,16 @@ impl eframe::App for MidiKeysApp {
 
                 frame.end(ui);
             }
+
+            ctx.request_repaint();
         });
     }
 }
 
+struct MidiDaemon {
+
+}
+
 pub fn launch_midi_daemon(target_field: Arc<Mutex<Vec<MidiInputPort>>>) -> JoinHandle<()> {
     let daemon_handle = std::thread::spawn(move || midi_daemon(target_field));
 
@@ -102,13 +170,8 @@ pub fn midi_daemon(target_field: Arc<Mutex<Vec<MidiInputPort>>>) {
     let midi_in: MidiInput = MidiInput::new("midi-keys").expect("could not connect to system MIDI");
 
     loop {
-        let midi_input_ports = get_connnected_midi_devices(&midi_in);
+        *target_field.lock() = midi_in.ports();
-        *target_field.lock() = midi_input_ports;
 
         std::thread::sleep(std::time::Duration::from_millis(100));
     }
 }
-
-pub fn get_connnected_midi_devices(midi_in: &MidiInput) -> Vec<MidiInputPort> {
-    midi_in.ports()
-}