具有 MIDI 输入和输出端口的应用程序在 qjackctl 中显示为多个应用程序

似乎不可能做到这一点，midir因为它会为每个端口创建一个新的 JACK 连接，这只是糟糕的 api 设计。midir在它的私有Client结构上确实有仅具有此功能的方法，所以我不知道他们是怎么做的。

箱子jack里有一个midi 示例，可以按照您的需要工作。还有箱子pipewire。

使用一些粗略的变换和复制，您可以证明问题在于多个 JACK 连接midir（请勿实际使用此代码）。

//! I wouldn't recommend running this either. It could maybe break your audio server.

use std::error::Error;
use std::io::{stdin, stdout, Write};
use std::mem::ManuallyDrop;

use midir::{Ignore, MidiIO, MidiInput, MidiOutput};

fn main() {
    match run() {
        Ok(_) => (),
        Err(err) => println!("Error: {}", err),
    }
}

fn get_port<M: MidiIO>(midi_io: &M) -> Result<M::Port, Box<dyn Error>> {
    // Get an input port (read from console if multiple are available)
    let in_ports = midi_io.ports();
    let in_port = match in_ports.len() {
        0 => return Err("no input port found".into()),
        1 => {
            println!(
                "Choosing the only available input port: {}",
                midi_io.port_name(&in_ports[0]).unwrap()
            );
            &in_ports[0]
        }
        _ => {
            println!("\nAvailable input ports:");
            for (i, p) in in_ports.iter().enumerate() {
                println!("{}: {}", i, midi_io.port_name(p).unwrap());
            }
            print!("Please select input port: ");
            stdout().flush()?;
            let mut input = String::new();
            stdin().read_line(&mut input)?;
            in_ports
                .get(input.trim().parse::<usize>()?)
                .ok_or("invalid input port selected")?
        }
    };
    Ok(in_port.clone())
}

/// # Safety
/// Probablly not safe at all.
unsafe fn duplicate_as_midi_in(conn: &MidiInput) -> MidiInput {
    // Safety: maybe safe, uh breaks Midir library public interface.
    // you dont wanna drop this though.
    unsafe { std::ptr::read(conn) }
}

/// # Safety
/// The output [`MidiOutput`] should be a valid instance. A lot of segfaults and errors
/// when dropping though.
unsafe fn duplicate_as_midi_out(conn: &MidiInput, verify: Ignore) -> MidiOutput {
    struct MidiInputShadow {
        flags: Ignore,
        jack_connection: Option<*const ()>,
    }
    const _: () = assert!(size_of::<MidiInputShadow>() == size_of::<MidiInput>());
    const _: () = assert!(size_of::<MidiInputShadow>() == 24);

    // Safety: VERY UNSAFE relies on `MidiInputShadow` having the same layout as `MidiInput`.
    // Rust **does NOT** guarantee any layout for repr(Rust) types.
    // The existence of Rust dylibs sort of necessitates these being the same though.
    let MidiInputShadow {
        flags,
        jack_connection,
    } = unsafe { std::ptr::read(conn as *const MidiInput as *const MidiInputShadow) };

    // runtime layout checks idea from cve-rs
    assert_eq!(flags, verify, "BAD: type layout was different");
    assert!(jack_connection.is_some(), "can't verify layout");
    assert!(
        jack_connection != Some(std::ptr::null()),
        "can't verify layout"
    );

    // Safety: layout should be good now
    unsafe { std::mem::transmute(jack_connection) }
}

// NOTE: this particular setup doesn't segfault but prob can still break your audio server.
// Also input port 2 doesn't work, and output ports dont seem to do anything but
// it doesn't seem like they're used.
/// Creates 2 input ports and 2 output ports in one audio node.
fn run() -> Result<(), Box<dyn Error>> {
    let mut input = String::new();

    let mut jack_connection: MidiInput = MidiInput::new("my midir app")?;
    jack_connection.ignore(Ignore::None);

    let midi_in = unsafe { duplicate_as_midi_in(&jack_connection) };
    let midi_in2 = unsafe { duplicate_as_midi_in(&jack_connection) };
    let midi_out = unsafe { duplicate_as_midi_out(&jack_connection, Ignore::None) };
    let midi_out2 = unsafe { duplicate_as_midi_out(&jack_connection, Ignore::None) };

    // segfaults if this is uncommented
    // let midi_out3 = unsafe { duplicate_as_midi_out(&jack_connection, Ignore::None) };
    // drop(midi_out3);

    let in_port = get_port(&midi_in).unwrap();
    let in_port2 = get_port(&midi_in2).unwrap();
    let out_port = get_port(&midi_out).unwrap();
    let out_port2 = get_port(&midi_out2).unwrap();
    println!();
    
    let in_port_name = midi_in.port_name(&in_port)?;
    
    println!("Opening input connection 1");
    // ManuallyDrop or else double frees. Prob still double frees in `connect` but doesn't segfault
    let _conn_in = ManuallyDrop::new(midi_in.connect(
        &in_port,
        "midir-read-input1",
        move |stamp, message, _| {
            println!("input 1: {}: {:?} (len = {})", stamp, message, message.len());
        },
        (),
    )?);
    
    // NOTE: input port 2 doesn't seem to work on my pc.
    println!("Opening input connection 2");
    let _conn_in2 = ManuallyDrop::new(midi_in2.connect(
        &in_port2,
        "midir-read-input2",
        move |stamp, message, _| {
            println!("input 2: {}: {:?} (len = {})", stamp, message, message.len());
        },
        (),
    )?);
    
    println!("Opening output connection 1");
    let _conn_out = ManuallyDrop::new(midi_out.connect(&out_port, "midir-write-output1"));
    println!("Opening output connection 2");
    let _conn_out2 = ManuallyDrop::new(midi_out2.connect(&out_port2, "midir-write-output2"));
    
    println!(
        "Connection open, reading input from '{}' (press enter to exit) ...",
        in_port_name
    );

    input.clear();
    stdin().read_line(&mut input)?; // wait for next enter key press

    println!("Closing connection");
    drop(jack_connection);
    Ok(())
}