Initial version

Author: eras

.gitignore

@@ -0,0 +1,2 @@
+*~
+target

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "midihid"
+version = "0.1.0"
+edition = "2021"
+authors = ["Erkki Seppälä <[email protected]>"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = { version = "1.0.65", features = [] }
+clap = { version = "4.0.10", features = ["derive", "wrap_help", "unicode"] }
+jack = "0.8.0"                               # Real time audio and midi with JACK.
+thiserror = "1.0.22"

src/error.rs

@@ -0,0 +1,8 @@
+use std::io;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub(crate) enum Error {
+    #[error(transparent)]
+    IOError(#[from] io::Error),
+}

src/main.rs

@@ -0,0 +1,94 @@
+mod error;
+
+use std::sync::{Arc, Mutex};
+use std::{thread, time};
+
+struct State {}
+
+fn init_midi() -> (
+    jack::Client,
+    Arc<Mutex<jack::Port<jack::MidiIn>>>,
+    Arc<Mutex<State>>,
+) {
+    let (client, _status) =
+        jack::Client::new("midihid", jack::ClientOptions::NO_START_SERVER).unwrap();
+
+    let midi_receiver = client
+        .register_port("keyboard", jack::MidiIn::default())
+        .unwrap();
+
+    let state = State {};
+    (
+        client,
+        Arc::new(Mutex::new(midi_receiver)),
+        Arc::new(Mutex::new(state)),
+    )
+}
+
+fn main() {
+    let (client, midi_receiver, _state) = init_midi();
+
+    let jack_callback = {
+        //let state = Arc::clone(&state);
+        let midi_receiver = Arc::clone(&midi_receiver);
+        move |_: &jack::Client, ps: &jack::ProcessScope| -> jack::Control {
+            let midi_receiver = Arc::clone(&midi_receiver);
+            let midi = midi_receiver.lock().expect("Cannot lock midi");
+            for event in midi.iter(ps) {
+                match event.bytes {
+                    [248] => (),
+                    _ => println!("{event:?}"),
+                }
+            }
+            jack::Control::Continue
+        }
+    };
+
+    let port_names = client.ports(None, None, jack::PortFlags::IS_OUTPUT);
+
+    let mut connected = false;
+    for port_name in port_names {
+        if let Some(port) = client.port_by_name(&port_name) {
+            let matches = matches!(
+                port.aliases()
+                    .expect("aiee")
+                    .iter()
+                    .filter(|&x| x.as_str() == "Novation SL MkIII:Novation SL MkIII MIDI 1")
+                    .next(),
+                Some(_)
+            );
+            if matches {
+                let midi_receiver = Arc::clone(&midi_receiver);
+                let midi_receiver = midi_receiver.lock().expect("cannot lock midi_receiver");
+                client
+                    .connect_ports(&port, &midi_receiver)
+                    .expect("cannot connect ports");
+                println!("port: {port:?}");
+                connected = true;
+                break;
+            }
+        }
+    }
+
+    if !connected {
+        println!("Did not find port to connect :(");
+    }
+
+    if true {
+        let _active_client = client
+            .activate_async((), jack::ClosureProcessHandler::new(jack_callback))
+            .expect("Failed to activate client");
+
+        // measurement_fin_rx
+        //     .recv()
+        //     .expect("Failed to received measurement finish response")?;
+
+        loop {
+            thread::sleep(time::Duration::from_secs(10));
+        }
+
+        // active_client
+        //     .deactivate()
+        //     .expect("Failed to deactivate Jack session");
+    }
+}