unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 19:56:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update JACK to 0.13

Browse source 
Biggest changes are to logging and safety.
  - Panics are caught at C/Rust boundary instead of crashing program
    with no messages.
    - Stack trace is usually printed.
  - `log` crate logging is enabled by default. Use something like
    https://docs.rs/env_logger/latest/env_logger/ with writing to file
    to see debug logs.
This commit is contained in:
Will Medrano 2024-09-22 14:16:37 -07:00
parent 0bf9002e6b
commit 6851240c8c
4 changed files with 253 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Cargo.lock generated
View file

@ -1094,11 +1094,11 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
[[package]]
name = "jack"
version = "0.10.0"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce722655a29b13bb98ec7e8ba9dc65d670b9b37c7b1c09775c7f7516811c5a36"
checksum = "78a4ae24f4ee29676aef8330fed1104e72f314cab16643dbeb61bfd99b4a8273"
dependencies = [
"bitflags 1.3.2",
"bitflags 2.6.0",
"jack-sys",
"lazy_static",
"libc",
@ -1107,14 +1107,15 @@ dependencies = [
[[package]]
name = "jack-sys"
version = "0.4.0"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e9d70559ff166d148ccb750ddd77702af760718f3a752c731add168c22c16a9f"
checksum = "6013b7619b95a22b576dfb43296faa4ecbe40abbdb97dfd22ead520775fc86ab"
dependencies = [
"bitflags 1.3.2",
"lazy_static",
"libc",
"libloading 0.7.4",
"log",
"pkg-config",
]

80
crates/tek/src/app.rs
View file

@ -1,7 +1,7 @@
use crate::*;
use tek_core::Direction;
use tek_sequencer::{TransportToolbar, Arranger};
use tek_mixer::Mixer;
use tek_sequencer::{Arranger, TransportToolbar};
/// Root of application state.
pub struct App {
@ -16,7 +16,7 @@ pub struct App {
/// Mixer (contains tracks)
pub mixer: Mixer,
/// Main JACK client.
pub jack: Option<JackClient>,
pub jack: Option<JackClientt>,
/// Map of external MIDI outs in the jack graph
/// to internal MIDI ins of this app.
pub midi_in: Option<Arc<Port<MidiIn>>>,
@ -33,15 +33,12 @@ pub struct App {
}
impl App {
pub fn new () -> Usually<Self> {
pub fn new() -> Usually<Self> {
let xdg = Arc::new(XdgApp::new("tek")?);
let first_run = AppPaths::new(&xdg)?.should_create();
let jack = JackClient::Inactive(
Client::new("tek", ClientOptions::NO_START_SERVER)?.0
);
*MODAL.lock().unwrap() = first_run.then(||{
ExitableComponent::boxed(SetupModal(Some(xdg.clone()), false))
});
let jack = JackClient::Inactive(Client::new("tek", ClientOptions::NO_START_SERVER)?.0);
*MODAL.lock().unwrap() =
first_run.then(|| ExitableComponent::boxed(SetupModal(Some(xdg.clone()), false)));
Ok(Self {
entered: true,
section: AppFocus::default(),
@ -57,36 +54,39 @@ impl App {
_xdg: Some(xdg),
})
}
pub fn client (&self) -> &Client {
pub fn client(&self) -> &Client {
self.jack.as_ref().unwrap().client()
}
pub fn audio_out (&self, index: usize) -> Option<Arc<Port<Unowned>>> {
self.audio_outs.get(index).map(|x|x.clone())
pub fn audio_out(&self, index: usize) -> Option<Arc<Port<Unowned>>> {
self.audio_outs.get(index).map(|x| x.clone())
}
pub fn with_midi_ins (mut self, names: &[&str]) -> Usually<Self> {
self.midi_ins = names.iter().map(|x|x.to_string()).collect();
pub fn with_midi_ins(mut self, names: &[&str]) -> Usually<Self> {
self.midi_ins = names.iter().map(|x| x.to_string()).collect();
Ok(self)
}
pub fn with_audio_outs (mut self, names: &[&str]) -> Usually<Self> {
pub fn with_audio_outs(mut self, names: &[&str]) -> Usually<Self> {
let client = self.client();
self.audio_outs = names
.iter()
.map(|name|client
.map(|name| {
client
.ports(Some(name), None, PortFlags::empty())
.get(0)
.map(|name|client.port_by_name(name)))
.map(|name| client.port_by_name(name))
})
.flatten()
.filter_map(|x|x)
.filter_map(|x| x)
.map(Arc::new)
.collect();
Ok(self)
}
pub fn activate (
mut self, init: Option<impl FnOnce(&Arc<RwLock<Self>>)->Usually<()>>
pub fn activate(
mut self,
init: Option<impl FnOnce(&Arc<RwLock<Self>>) -> Usually<()>>,
) -> Usually<Arc<RwLock<Self>>> {
let jack = self.jack.take().expect("no jack client");
let app = Arc::new(RwLock::new(self));
app.write().unwrap().jack = Some(jack.activate(&app.clone(), |state, client, scope|{
app.write().unwrap().jack = Some(jack.activate(&app.clone(), |state, client, scope| {
state.write().unwrap().process(client, scope)
})?);
if let Some(init) = init {
@ -96,34 +96,42 @@ impl App {
}
}
render!(App |self, buf, area| {
render!(
App | self,
buf,
area | {
Split::down()
.add_ref(&self.transport)
.add_ref(&self.arranger)
.add(If(self.arranger.selected.is_clip(), &Split::right()
.add(If(
self.arranger.selected.is_clip(),
&Split::right()
.add(tek_mixer::TrackView {
direction: Direction::Down,
entered: self.entered,
focused: self.section == AppFocus::Chain,
chain: self.mixer.track()
chain: self.mixer.track(),
})
.add_ref(&self.arranger.sequencer())
.add_ref(&self.arranger.sequencer()),
))
.render(buf, area)?;
if let Some(ref modal) = *MODAL.lock().unwrap() {
modal.render(buf, area)?;
}
Ok(area)
});
}
);
process!(App |self, _client, scope| {
let (
reset, current_frames, chunk_size, current_usecs, next_usecs, period_usecs
) = self.transport.update(&scope);
process!(
App | self,
_client,
scope | {
let (reset, current_frames, chunk_size, current_usecs, next_usecs, period_usecs) =
self.transport.update(&scope);
self.chunk_size = chunk_size;
for track in self.arranger.tracks.iter_mut() {
track.process(
self.midi_in.as_ref().map(|p|p.iter(&scope)),
self.midi_in.as_ref().map(|p| p.iter(&scope)),
&self.transport.timebase,
self.transport.playing,
self.transport.started,
@ -131,9 +139,13 @@ process!(App |self, _client, scope| {
reset,
&scope,
(current_frames as usize, self.chunk_size),
(current_usecs as usize, next_usecs.saturating_sub(current_usecs) as usize),
period_usecs as f64
(
current_usecs as usize,
next_usecs.saturating_sub(current_usecs) as usize,
),
period_usecs as f64,
);
}
Control::Continue
});
}
);

2
crates/tek_core/Cargo.toml
View file

@ -10,7 +10,7 @@ better-panic = "0.3.0"
clap = { version = "4.5.4", features = [ "derive" ] }
clojure-reader = "0.1.0"
crossterm = "0.27"
jack = "0.10"
jack = "0.13"
midly = "0.5"
once_cell = "1.19.0"
ratatui = { version = "0.26.3", features = [ "unstable-widget-ref", "underline-color" ] }

237
crates/tek_core/src/audio.rs
View file

@ -1,25 +1,25 @@
use jack::*;
use crate::*;
use jack::*;
/// Trait for things that have a JACK process callback.
pub trait Audio {
fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
fn process(&mut self, _: &Client, _: &ProcessScope) -> Control {
Control::Continue
}
}
/// Trait for things that may expose JACK ports.
pub trait Ports {
fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
fn audio_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(vec![])
}
fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
fn audio_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(vec![])
}
fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
fn midi_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(vec![])
}
fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
fn midi_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(vec![])
}
}
@ -27,7 +27,10 @@ pub trait Ports {
/// A UI component that may be associated with a JACK client by the `Jack` factory.
pub trait AudioComponent<E: Engine>: Component<E> + Audio {
/// Perform type erasure for collecting heterogeneous devices.
fn boxed (self) -> Box<dyn AudioComponent<E>> where Self: Sized + 'static {
fn boxed(self) -> Box<dyn AudioComponent<E>>
where
Self: Sized + 'static,
{
Box::new(self)
}
}
@ -42,72 +45,69 @@ pub enum JackClient {
}
impl JackClient {
pub fn client (&self) -> &Client {
pub fn client(&self) -> &Client {
match self {
Self::Inactive(ref client) =>
client,
Self::Active(ref client) =>
client.as_client(),
Self::Inactive(ref client) => client,
Self::Active(ref client) => client.as_client(),
}
}
pub fn transport (&self) -> Transport {
pub fn transport(&self) -> Transport {
self.client().transport()
}
pub fn port_by_name (&self, name: &str) -> Option<Port<Unowned>> {
pub fn port_by_name(&self, name: &str) -> Option<Port<Unowned>> {
self.client().port_by_name(name)
}
pub fn register_port <PS: PortSpec> (&self, name: &str, spec: PS) -> Usually<Port<PS>> {
pub fn register_port<PS: PortSpec>(&self, name: &str, spec: PS) -> Usually<Port<PS>> {
Ok(self.client().register_port(name, spec)?)
}
pub fn activate <T: Send + Sync + 'static> (
pub fn activate<T: Send + Sync + 'static>(
self,
state: &Arc<RwLock<T>>,
mut process: impl FnMut(&Arc<RwLock<T>>, &Client, &ProcessScope)->Control + Send + 'static
mut process: impl FnMut(&Arc<RwLock<T>>, &Client, &ProcessScope) -> Control + Send + 'static,
) -> Usually<Self> {
Ok(match self {
Self::Active(_) => self,
Self::Inactive(client) => Self::Active(client.activate_async(
Notifications(Box::new(move|_|{/*TODO*/})
as Box<dyn Fn(JackEvent) + Send + Sync>),
ClosureProcessHandler::new(Box::new({
Notifications(
Box::new(move |_| { /*TODO*/ }) as Box<dyn Fn(JackEvent) + Send + Sync>
),
contrib::ClosureProcessHandler::new(Box::new({
let state = state.clone();
move|c: &Client, s: &ProcessScope|process(&state, c, s)
}) as BoxedAudioHandler)
)?)
move |c: &Client, s: &ProcessScope| process(&state, c, s)
}) as BoxedAudioHandler),
)?),
})
}
}
pub type DynamicAsyncClient =
AsyncClient<DynamicNotifications, DynamicAudioHandler>;
pub type DynamicAsyncClient = AsyncClient<DynamicNotifications, DynamicAudioHandler>;
type DynamicAudioHandler =
ClosureProcessHandler<BoxedAudioHandler>;
type DynamicAudioHandler = contrib::ClosureProcessHandler<(), BoxedAudioHandler>;
pub type BoxedAudioHandler =
Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
pub type BoxedAudioHandler = Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send>;
/// Just run thing with JACK. Returns the activated client.
pub fn jack_run <T, E: Engine> (name: &str, app: &Arc<RwLock<T>>) -> Usually<DynamicAsyncClient>
where T: Handle<E> + Audio + Send + Sync + 'static
pub fn jack_run<T, E: Engine>(name: &str, app: &Arc<RwLock<T>>) -> Usually<DynamicAsyncClient>
where
T: Handle<E> + Audio + Send + Sync + 'static,
{
let options = ClientOptions::NO_START_SERVER;
let (client, _status) = Client::new(name, options)?;
Ok(client.activate_async(
Notifications(Box::new({
let _app = app.clone();
move|_event|{
move |_event| {
// FIXME: this deadlocks
//app.lock().unwrap().handle(&event).unwrap();
}
}) as Box<dyn Fn(JackEvent) + Send + Sync>),
ClosureProcessHandler::new(Box::new({
contrib::ClosureProcessHandler::new(Box::new({
let app = app.clone();
move|c: &Client, s: &ProcessScope|{
move |c: &Client, s: &ProcessScope| {
app.write().unwrap().process(c, s)
//Control::Continue
}
}) as BoxedAudioHandler)
}) as BoxedAudioHandler),
)?)
}
@ -122,53 +122,62 @@ pub struct Jack {
}
impl Jack {
pub fn new (name: &str) -> Usually<Self> {
pub fn new(name: &str) -> Usually<Self> {
Ok(Self {
midi_ins: vec![],
audio_ins: vec![],
midi_outs: vec![],
audio_outs: vec![],
client: Client::new(
name,
ClientOptions::NO_START_SERVER
)?.0,
client: Client::new(name, ClientOptions::NO_START_SERVER)?.0,
})
}
pub fn run <'a: 'static, D, E> (
self, state: impl FnOnce(JackPorts)->Box<D>
pub fn run<'a: 'static, D, E>(
self,
state: impl FnOnce(JackPorts) -> Box<D>,
) -> Usually<JackDevice<E>>
where D: AudioComponent<E> + Sized + 'static,
where
D: AudioComponent<E> + Sized + 'static,
E: Engine + 'static,
{
let owned_ports = JackPorts {
audio_ins: register_ports(&self.client, self.audio_ins, AudioIn)?,
audio_outs: register_ports(&self.client, self.audio_outs, AudioOut)?,
midi_ins: register_ports(&self.client, self.midi_ins, MidiIn)?,
midi_outs: register_ports(&self.client, self.midi_outs, MidiOut)?,
audio_ins: register_ports(&self.client, self.audio_ins, AudioIn::default())?,
audio_outs: register_ports(&self.client, self.audio_outs, AudioOut::default())?,
midi_ins: register_ports(&self.client, self.midi_ins, MidiIn::default())?,
midi_outs: register_ports(&self.client, self.midi_outs, MidiOut::default())?,
};
let midi_outs = owned_ports.midi_outs.values()
.map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
let midi_ins = owned_ports.midi_ins.values()
.map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
let audio_outs = owned_ports.audio_outs.values()
.map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
let audio_ins = owned_ports.audio_ins.values()
.map(|p|Ok(p.name()?)).collect::<Usually<Vec<_>>>()?;
let midi_outs = owned_ports
.midi_outs
.values()
.map(|p| Ok(p.name()?))
.collect::<Usually<Vec<_>>>()?;
let midi_ins = owned_ports
.midi_ins
.values()
.map(|p| Ok(p.name()?))
.collect::<Usually<Vec<_>>>()?;
let audio_outs = owned_ports
.audio_outs
.values()
.map(|p| Ok(p.name()?))
.collect::<Usually<Vec<_>>>()?;
let audio_ins = owned_ports
.audio_ins
.values()
.map(|p| Ok(p.name()?))
.collect::<Usually<Vec<_>>>()?;
let state = Arc::new(RwLock::new(state(owned_ports) as Box<dyn AudioComponent<E>>));
let client = self.client.activate_async(
Notifications(Box::new({
let _state = state.clone();
move|_event|{
move |_event| {
// FIXME: this deadlocks
//state.lock().unwrap().handle(&event).unwrap();
}
}) as Box<dyn Fn(JackEvent) + Send + Sync>),
ClosureProcessHandler::new(Box::new({
contrib::ClosureProcessHandler::new(Box::new({
let state = state.clone();
move|c: &Client, s: &ProcessScope|{
state.write().unwrap().process(c, s)
}
}) as BoxedAudioHandler)
move |c: &Client, s: &ProcessScope| state.write().unwrap().process(c, s)
}) as BoxedAudioHandler),
)?;
Ok(JackDevice {
ports: UnownedJackPorts {
@ -181,38 +190,40 @@ impl Jack {
state,
})
}
pub fn audio_in (mut self, name: &str) -> Self {
pub fn audio_in(mut self, name: &str) -> Self {
self.audio_ins.push(name.to_string());
self
}
pub fn audio_out (mut self, name: &str) -> Self {
pub fn audio_out(mut self, name: &str) -> Self {
self.audio_outs.push(name.to_string());
self
}
pub fn midi_in (mut self, name: &str) -> Self {
pub fn midi_in(mut self, name: &str) -> Self {
self.midi_ins.push(name.to_string());
self
}
pub fn midi_out (mut self, name: &str) -> Self {
pub fn midi_out(mut self, name: &str) -> Self {
self.midi_outs.push(name.to_string());
self
}
}
fn register_ports <T: PortSpec + Copy> (
client: &Client, names: Vec<String>, spec: T
fn register_ports<T: PortSpec + Copy>(
client: &Client,
names: Vec<String>,
spec: T,
) -> Usually<BTreeMap<String, Port<T>>> {
names.into_iter().try_fold(BTreeMap::new(), |mut ports, name|{
names
.into_iter()
.try_fold(BTreeMap::new(), |mut ports, name| {
let port = client.register_port(&name, spec)?;
ports.insert(name, port);
Ok(ports)
})
}
fn query_ports (
client: &Client, names: Vec<String>
) -> BTreeMap<String, Port<Unowned>> {
names.into_iter().fold(BTreeMap::new(), |mut ports, name|{
fn query_ports(client: &Client, names: Vec<String>) -> BTreeMap<String, Port<Unowned>> {
names.into_iter().fold(BTreeMap::new(), |mut ports, name| {
let port = client.port_by_name(&name).unwrap();
ports.insert(name, port);
ports
@ -221,8 +232,7 @@ fn query_ports (
/// Notification handler used by the [Jack] factory
/// when constructing [JackDevice]s.
pub type DynamicNotifications =
Notifications<Box<dyn Fn(JackEvent) + Send + Sync>>;
pub type DynamicNotifications = Notifications<Box<dyn Fn(JackEvent) + Send + Sync>>;
#[derive(Debug)]
/// Event enum for JACK events.
@ -243,46 +253,46 @@ pub enum JackEvent {
pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
fn thread_init (&self, _: &Client) {
fn thread_init(&self, _: &Client) {
self.0(JackEvent::ThreadInit);
}
fn shutdown (&mut self, status: ClientStatus, reason: &str) {
unsafe fn shutdown(&mut self, status: ClientStatus, reason: &str) {
self.0(JackEvent::Shutdown(status, reason.into()));
}
fn freewheel (&mut self, _: &Client, enabled: bool) {
fn freewheel(&mut self, _: &Client, enabled: bool) {
self.0(JackEvent::Freewheel(enabled));
}
fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
fn sample_rate(&mut self, _: &Client, frames: Frames) -> Control {
self.0(JackEvent::SampleRate(frames));
Control::Quit
}
fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
fn client_registration(&mut self, _: &Client, name: &str, reg: bool) {
self.0(JackEvent::ClientRegistration(name.into(), reg));
}
fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
fn port_registration(&mut self, _: &Client, id: PortId, reg: bool) {
self.0(JackEvent::PortRegistration(id, reg));
}
fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
fn port_rename(&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
self.0(JackEvent::PortRename(id, old.into(), new.into()));
Control::Continue
}
fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
fn ports_connected(&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
self.0(JackEvent::PortsConnected(a, b, are));
}
fn graph_reorder (&mut self, _: &Client) -> Control {
fn graph_reorder(&mut self, _: &Client) -> Control {
self.0(JackEvent::GraphReorder);
Control::Continue
}
fn xrun (&mut self, _: &Client) -> Control {
fn xrun(&mut self, _: &Client) -> Control {
self.0(JackEvent::XRun);
Control::Continue
}
@ -301,61 +311,75 @@ pub struct JackDevice<E: Engine> {
impl<E: Engine> std::fmt::Debug for JackDevice<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("JackDevice").field("ports", &self.ports).finish()
f.debug_struct("JackDevice")
.field("ports", &self.ports)
.finish()
}
}
impl<E: Engine> Widget for JackDevice<E> {
type Engine = E;
fn layout (&self, to: E::Size) -> Perhaps<E::Size> {
fn layout(&self, to: E::Size) -> Perhaps<E::Size> {
self.state.read().unwrap().layout(to)
}
fn render (&self, to: &mut E::Output) -> Usually<()> {
fn render(&self, to: &mut E::Output) -> Usually<()> {
self.state.read().unwrap().render(to)
}
}
impl<E: Engine> Handle<E> for JackDevice<E> {
fn handle (&mut self, from: &E::Input) -> Perhaps<E::Handled> {
fn handle(&mut self, from: &E::Input) -> Perhaps<E::Handled> {
self.state.write().unwrap().handle(from)
}
}
impl<E: Engine> Ports for JackDevice<E> {
fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
fn audio_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(self.ports.audio_ins.values().collect())
}
fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
fn audio_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(self.ports.audio_outs.values().collect())
}
fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
fn midi_ins(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(self.ports.midi_ins.values().collect())
}
fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
fn midi_outs(&self) -> Usually<Vec<&Port<Unowned>>> {
Ok(self.ports.midi_outs.values().collect())
}
}
impl<E: Engine> JackDevice<E> {
/// Returns a locked mutex of the state's contents.
pub fn state (&self) -> LockResult<RwLockReadGuard<Box<dyn AudioComponent<E>>>> {
pub fn state(&self) -> LockResult<RwLockReadGuard<Box<dyn AudioComponent<E>>>> {
self.state.read()
}
/// Returns a locked mutex of the state's contents.
pub fn state_mut (&self) -> LockResult<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
pub fn state_mut(&self) -> LockResult<RwLockWriteGuard<Box<dyn AudioComponent<E>>>> {
self.state.write()
}
pub fn connect_midi_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self.client.as_client().connect_ports(port, self.midi_ins()?[index])?)
pub fn connect_midi_in(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self
.client
.as_client()
.connect_ports(port, self.midi_ins()?[index])?)
}
pub fn connect_midi_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self.client.as_client().connect_ports(self.midi_outs()?[index], port)?)
pub fn connect_midi_out(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self
.client
.as_client()
.connect_ports(self.midi_outs()?[index], port)?)
}
pub fn connect_audio_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self.client.as_client().connect_ports(port, self.audio_ins()?[index])?)
pub fn connect_audio_in(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self
.client
.as_client()
.connect_ports(port, self.audio_ins()?[index])?)
}
pub fn connect_audio_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self.client.as_client().connect_ports(self.audio_outs()?[index], port)?)
pub fn connect_audio_out(&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
Ok(self
.client
.as_client()
.connect_ports(self.audio_outs()?[index], port)?)
}
}
@ -378,7 +402,7 @@ pub struct UnownedJackPorts {
}
impl JackPorts {
pub fn clone_unowned (&self) -> UnownedJackPorts {
pub fn clone_unowned(&self) -> UnownedJackPorts {
let mut unowned = UnownedJackPorts::default();
for (name, port) in self.midi_ins.iter() {
unowned.midi_ins.insert(name.clone(), port.clone_unowned());
@ -390,14 +414,17 @@ impl JackPorts {
unowned.audio_ins.insert(name.clone(), port.clone_unowned());
}
for (name, port) in self.audio_outs.iter() {
unowned.audio_outs.insert(name.clone(), port.clone_unowned());
unowned
.audio_outs
.insert(name.clone(), port.clone_unowned());
}
unowned
}
}
/// Implement the `Ports` trait.
#[macro_export] macro_rules! ports {
#[macro_export]
macro_rules! ports {
($T:ty $({ $(audio: {
$(ins: |$ai_arg:ident|$ai_impl:expr,)?
$(outs: |$ao_arg:ident|$ao_impl:expr,)?