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

wip: fixing port autoconnect

Browse source
This commit is contained in:
🪞👃🪞 2024-07-11 14:15:29 +03:00
parent 6979fd67ec
commit 32dc708096
5 changed files with 98 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

102
src/model.rs
View file

@ -20,8 +20,11 @@ pub struct App {
pub xdg: Option<Arc<XdgApp>>,
/// Main JACK client.
pub jack: Option<JackClient>,
/// Main MIDI controller.
/// Map of external MIDI outs in the jack graph
/// to internal MIDI ins of this app.
pub midi_in: Option<Port<MidiIn>>,
/// Names of ports to connect to main MIDI IN.
pub midi_ins: Vec<String>,
/// Main audio outputs.
pub audio_outs: Vec<Arc<Port<Unowned>>>,
/// JACK transport handle.
@ -70,23 +73,27 @@ pub struct App {
pub chunk_size: usize,
/// Quantization factor
pub quant: usize,
/// Init callbacks called once after root JACK client has activated.
pub callbacks: Vec<Box<dyn (FnOnce(Arc<RwLock<Self>>)->Usually<()>) + Send + Sync>>
}
impl App {
pub fn new (project: &str) -> Usually<Self> {
pub fn new () -> Usually<Self> {
let xdg = Arc::new(microxdg::XdgApp::new("tek")?);
let first_run = crate::config::AppPaths::new(&xdg)?.should_create();
let jack = JackClient::Inactive(Client::new("tek", ClientOptions::NO_START_SERVER)?.0);
let transport = jack.transport();
let mut app = Self {
Ok(Self {
arranger_mode: false,
audio_outs: vec![],
callbacks: vec![],
chain_mode: false,
chunk_size: 0,
entered: true,
jack: Some(jack),
metronome: false,
midi_in: None,
midi_ins: vec![],
modal: first_run.then(||crate::config::SetupModal(Some(xdg.clone())).boxed()),
note_cursor: 0,
note_start: 2,
@ -106,9 +113,7 @@ impl App {
tracks: vec![],
transport: Some(transport),
xdg: Some(xdg),
};
app.load_edn(project)?;
Ok(app)
})
}
}
@ -118,7 +123,7 @@ process!(App |self, _client, scope| {
) = self.process_update_time(&scope);
for track in self.tracks.iter_mut() {
track.process(
self.midi_in.as_ref().unwrap().iter(scope),
self.midi_in.as_ref().map(|p|p.iter(&scope)),
&self.timebase,
self.playing,
self.play_started,
@ -133,11 +138,49 @@ process!(App |self, _client, scope| {
Control::Continue
});
impl App {
pub fn activate (mut self) -> Usually<Arc<RwLock<Self>>> {
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> {
let client = self.client();
self.audio_outs = names
.iter()
.map(|name|client
.ports(Some(name), None, PortFlags::empty())
.get(0)
.map(|name|client.port_by_name(name)))
.flatten()
.filter_map(|x|x)
.map(Arc::new)
.collect();
Ok(self)
}
pub fn connect_to_midi_ins (&mut self, ports: &[&str]) -> Usually<&mut Self> {
let client = self.client();
let midi_in = client.register_port("midi-in", MidiIn)?;
ports
.iter()
.map(|name|client
.ports(Some(name), None, PortFlags::empty())
.iter()
.map(|name|{
if let Some(port) = client.port_by_name(name) {
client.connect_ports(&port, &midi_in)?;
}
Ok(())
})
.collect::<Usually<()>>())
.collect::<Usually<()>>()?;
self.midi_in = Some(midi_in);
Ok(self)
}
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 state = Arc::new(RwLock::new(self));
state.write().unwrap().jack = Some(jack.activate(&state, Self::process)?);
Ok(state)
let app = Arc::new(RwLock::new(self));
app.write().unwrap().jack = Some(jack.activate(&app.clone(), Self::process)?);
if let Some(init) = init { init(&app)?; }
Ok(app)
}
pub fn process (state: &Arc<RwLock<Self>>, client: &Client, scope: &ProcessScope) -> Control {
state.write().unwrap().process(client, scope)
@ -201,7 +244,7 @@ impl App {
name: Option<&str>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
self.tracks.push(Track::new(&name, self.client(), None, None)?);
self.tracks.push(Track::new(&name, None, None)?);
self.track_cursor = self.tracks.len();
Ok(&mut self.tracks[self.track_cursor - 1])
}
@ -211,7 +254,7 @@ impl App {
init: impl FnOnce(&Client, &mut Track)->Usually<()>,
) -> Usually<&mut Track> {
let name = name.ok_or_else(||self.new_track_name())?;
let mut track = Track::new(&name, self.client(), None, None)?;
let mut track = Track::new(&name, None, None)?;
init(self.client(), &mut track)?;
self.tracks.push(track);
self.track_cursor = self.tracks.len();
@ -334,39 +377,6 @@ impl App {
//phrase
//}
//}
pub fn connect_to_midi_ins (&mut self, ports: &[&str]) -> Usually<&mut Self> {
let client = self.client();
let midi_in = client.register_port("midi-in", MidiIn)?;
ports
.iter()
.map(|name|client
.ports(Some(name), None, PortFlags::empty())
.iter()
.map(|name|{
if let Some(port) = client.port_by_name(name) {
client.connect_ports(&port, &midi_in)?;
}
Ok(())
})
.collect::<Usually<()>>())
.collect::<Usually<()>>()?;
self.midi_in = Some(midi_in);
Ok(self)
}
pub fn connect_to_audio_outs (&mut self, ports: &[&str]) -> Usually<&mut Self> {
let client = self.client();
self.audio_outs = ports
.iter()
.map(|name|client
.ports(Some(name), None, PortFlags::empty())
.get(0)
.map(|name|client.port_by_name(name)))
.flatten()
.filter_map(|x|x)
.map(Arc::new)
.collect();
Ok(self)
}
}
struct Selection<'a> {