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

wip: init shared jack clients

Browse source
This commit is contained in:
🪞👃🪞 2024-10-27 02:58:51 +03:00
parent 5a325666fd
commit ec2c96d00e
8 changed files with 74 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

5
crates/tek_sequencer/src/arranger.rs
View file

@ -2,6 +2,8 @@ use crate::*;
/// Root level object for standalone `tek_arranger`
pub struct Arranger<E: Engine> {
/// JACK client handle (needs to not be dropped for standalone mode to work).
pub jack: Option<Arc<JackClient>>,
/// Which view is focused
pub focus_cursor: (usize, usize),
/// Controls the JACK transport.
@ -121,7 +123,8 @@ impl<E: Engine> Arranger<E> {
phrases: Arc<RwLock<PhrasePool<E>>>,
) -> Self {
let mut app = Self {
focus_cursor: (0, 1),
jack: None,
focus_cursor: (0, 1),
phrases_split: 20,
arrangement_split: 21,
editor: PhraseEditor::new(),

27
crates/tek_sequencer/src/arranger_cli.rs
View file

@ -44,19 +44,26 @@ impl ArrangerCli {
Some(okhsl_to_rgb(scene_color_1.mix(scene_color_2, i as f32 / self.scenes as f32)))
)?;
}
transport.write().unwrap().jack = Some(
jack.activate(
&transport.clone(),
|state: &Arc<RwLock<TransportToolbar<Tui>>>, client, scope| {
state.write().unwrap().process(client, scope)
}
)?.into()
);
Tui::run(Arc::new(RwLock::new(Arranger::new(
let arranger = Arc::new(RwLock::new(Arranger::new(
self.transport.then_some(transport),
arrangement,
phrases,
))))?;
)));
let jack = jack.activate(&arranger.clone(), arranger_jack_callback)?;
let jack = Some(jack.into());
if let Some(ref transport) = arranger.read().unwrap().transport {
transport.write().unwrap().jack = jack.clone();
}
arranger.write().unwrap().jack = jack.clone();
Tui::run(arranger)?;
Ok(())
}
}
fn arranger_jack_callback (
state: &Arc<RwLock<Arranger<Tui>>>,
client: &Client,
scope: &ProcessScope,
) -> Control {
state.write().unwrap().process(client, scope)
}

9
crates/tek_sequencer/src/arranger_snd.rs Normal file
View file

@ -0,0 +1,9 @@
use crate::*;
impl<E: Engine> Audio for Arranger<E> {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
if let Some(ref transport) = self.transport {
transport.write().unwrap().process(client, scope);
}
todo!("arranger process")
}
}

2
crates/tek_sequencer/src/lib.rs
View file

@ -10,7 +10,7 @@ pub(crate) use palette::{*, convert::*, okhsl::*};
use rand::distributions::uniform::UniformSampler;
submod! {
arranger arranger_cmd arranger_tui
arranger arranger_cmd arranger_tui arranger_snd
sequencer sequencer_cmd sequencer_tui sequencer_snd
transport transport_cmd transport_tui transport_snd
}

2
crates/tek_sequencer/src/sequencer.rs
View file

@ -7,6 +7,8 @@ pub type PhraseMessage = Vec<u8>;
pub type PhraseChunk = [Vec<PhraseMessage>];
/// Root level object for standalone `tek_sequencer`
pub struct Sequencer<E: Engine> {
/// JACK client handle (needs to not be dropped for standalone mode to work).
pub jack: Option<Arc<JackClient>>,
/// Which view is focused
pub focus_cursor: (usize, usize),
/// Controls the JACK transport.

37
crates/tek_sequencer/src/sequencer_cli.rs
View file

@ -18,34 +18,41 @@ pub struct SequencerCli {
impl SequencerCli {
fn run (&self) -> Usually<()> {
let jack = Client::new("tek_arranger", ClientOptions::NO_START_SERVER)?.0;
let jack = JackClient::Inactive(jack);
let jack = Client::new("tek_arranger", ClientOptions::NO_START_SERVER)?.0;
let jack = JackClient::Inactive(jack);
let transport = Arc::new(RwLock::new(TransportToolbar::new(None, Some(jack.transport()))));
transport.write().unwrap().jack = Some(
jack.activate(
&transport.clone(),
|state: &Arc<RwLock<TransportToolbar<Tui>>>, client, scope| {
state.write().unwrap().process(client, scope)
}
)?.into()
);
let focus_cursor = (1, 1);
let clock = transport.read().unwrap().clock.clone();
let transport = self.transport.then_some(transport);
let editor = PhraseEditor::new();
let phrases = Arc::new(RwLock::new(PhrasePool::new()));
let seq = Sequencer { focus_cursor, clock, transport, editor, phrases };
let sequencer = Sequencer { jack: None, focus_cursor, clock, transport, editor, phrases };
if let Some(_) = self.name.as_ref() {
// TODO: seq.name = Arc::new(RwLock::new(name.clone()));
// TODO: sequencer.name = Arc::new(RwLock::new(name.clone()));
}
if let Some(_) = self.ppq {
// TODO: seq.ppq = ppq;
// TODO: sequencer.ppq = ppq;
}
if let Some(_) = self.length {
// TODO: if let Some(phrase) = seq.phrase.as_mut() {
// TODO: if let Some(phrase) = sequencer.phrase.as_mut() {
//phrase.write().unwrap().length = length;
//}
}
Tui::run(Arc::new(RwLock::new(seq))).map(|_|())
let sequencer = Arc::new(RwLock::new(sequencer));
let jack = jack.activate(&sequencer.clone(), sequencer_jack_callback)?;
let jack = Some(jack.into());
if let Some(ref transport) = sequencer.read().unwrap().transport {
transport.write().unwrap().jack = jack.clone();
}
sequencer.write().unwrap().jack = jack.clone();
Tui::run(sequencer).map(|_|())
}
}
fn sequencer_jack_callback (
state: &Arc<RwLock<Sequencer<Tui>>>,
client: &Client,
scope: &ProcessScope,
) -> Control {
state.write().unwrap().process(client, scope)
}

9
crates/tek_sequencer/src/sequencer_snd.rs
View file

@ -1,4 +1,13 @@
use crate::*;
impl<E: Engine> Audio for Sequencer<E> {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
if let Some(ref transport) = self.transport {
transport.write().unwrap().process(client, scope);
}
todo!("sequencer process")
}
}
impl Phrase {
/// Write a chunk of MIDI events to an output port.
pub fn process_out (

18
crates/tek_sequencer/src/transport_cli.rs
View file

@ -7,14 +7,16 @@ pub fn main () -> Usually<()> {
let mut transport = TransportToolbar::new(None, Some(jack.transport()));
transport.focused = true;
let transport = Arc::new(RwLock::new(transport));
transport.write().unwrap().jack = Some(
jack.activate(
&transport.clone(),
|state: &Arc<RwLock<TransportToolbar<Tui>>>, client, scope| {
state.write().unwrap().process(client, scope)
}
)?.into()
);
let jack = jack.activate(&transport.clone(), transport_jack_callback)?;
transport.write().unwrap().jack = Some(jack.into());
Tui::run(transport)?;
Ok(())
}
fn transport_jack_callback (
state: &Arc<RwLock<TransportToolbar<Tui>>>,
client: &Client,
scope: &ProcessScope,
) -> Control {
state.write().unwrap().process(client, scope)
}