主页 / coding / 问题 / 79147714
Accepted
Green绿色
Asked: 2024-11-01 18:41:55 +0800 CST

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

  • 772

我正在使用 0.10.0 版的 cratemidir在我的 Linux 机器上接收和发送 MIDI 信号。根据其存储库中的示例代码，我创建了一个小示例，其中我只需打开一个输入和一个输出连接。它基本上可以正常工作。然而，在图形配线架应用程序（例如Patchance或qjackctl）中，每个端口都出现在自己的框中。

我尝试了一些其他音乐应用程序。有些由多个框表示，有些由一个带有输入和输出的框表示。SetBFree是后者的一个例子（见下文）。我的应用程序应该接收 MIDI 输入信号，修改它们并将它们发送到其他应用程序。因此，我希望将端口分组到同一个框中，将其输入和输出端口分组在一起。

图形配线架应用程序中的应用程序视图

有可能吗？我如何控制配线架应用程序如何识别我的应用程序？

我已经尝试在MidiInput::new和中使用相同的名称MidiOutput::new，但效果是一样的——只是系统在其名称后附加了一个随机整数。

我将非常感激任何提示，包括示例 C/C++ 代码或其他 MIDI 库，或文档。唯一的条件是它应该在 Linux 上运行。

我的代码（有点快速和肮脏，改编自midir）：

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

use midir::{Ignore, MidiInput, MidiIO, 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())
}

fn run() -> Result<(), Box<dyn Error>> {
    let mut input = String::new();

    let mut midi_in = MidiInput::new("midir reading input")?;
    let mut midi_out = MidiOutput::new("midir reading output")?;
    midi_in.ignore(Ignore::None);

    let in_port = get_port(&midi_in).unwrap();
    let out_port = get_port(&midi_out).unwrap();

    println!("\nOpening input connection");
    let in_port_name = midi_in.port_name(&in_port)?;

    // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
    let _conn_in = midi_in.connect(
        &in_port,
        "midir-read-input",
        move |stamp, message, _| {
            println!("{}: {:?} (len = {})", stamp, message, message.len());
        },
        (),
    )?;

    println!("\nOpening output connection");
    let _conn_out = midi_out.connect(
        &out_port,
        "midir-write-output",
    );

    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");
    Ok(())
}
linux

1 个回答

  1. Best Answer

    似乎不可能做到这一点，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(())
}
    • 1

相关问题