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

wip: AudioEngine pt.2 (rewrite activation sanely)

Browse source
This commit is contained in:
🪞👃🪞 2024-11-03 04:43:50 +02:00
parent 2303b258f6
commit 746e29aeb3
8 changed files with 104 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -3,7 +3,7 @@ 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>>,
pub jack: Arc<RwLock<JackClient>>,
/// Which view is focused
pub focus_cursor: (usize, usize),
/// Controls the JACK transport.
@ -51,7 +51,7 @@ pub enum ArrangerStatusBar {
/// Represents the tracks and scenes of the composition.
pub struct Arrangement<E: Engine> {
/// Global JACK client
pub jack: Arc<JackClient>,
pub jack: Arc<RwLock<JackClient>>,
/// Global timebase
pub clock: Arc<TransportTime>,
/// Name of arranger
@ -120,26 +120,27 @@ pub struct HorizontalArranger<'a, E: Engine>(pub &'a Arrangement<E>);
/// General methods for arranger
impl<E: Engine> Arranger<E> {
pub fn new (
jack: &Arc<RwLock<JackClient>>,
transport: Option<Arc<RwLock<TransportToolbar<E>>>>,
arrangement: Arrangement<E>,
phrases: Arc<RwLock<PhrasePool<E>>>,
) -> Self {
let mut app = Self {
jack: None,
focus_cursor: (0, 1),
phrases_split: 20,
jack: jack.clone(),
focus_cursor: (0, 1),
phrases_split: 20,
arrangement_split: 21,
editor: PhraseEditor::new(),
status: ArrangerStatusBar::ArrangementClip,
editor: PhraseEditor::new(),
status: ArrangerStatusBar::ArrangementClip,
transport: transport.clone(),
arrangement,
phrases,
size: Measure::new(),
clock: if let Some(ref transport) = transport {
transport.read().unwrap().clock.clone()
} else {
Arc::new(TransportTime::default())
},
transport,
arrangement,
phrases,
size: Measure::new(),
};
app.update_focus();
app
@ -226,7 +227,7 @@ impl<E: Engine> FocusGrid<ArrangerFocus> for Arranger<E> {
/// General methods for arrangement
impl<E: Engine> Arrangement<E> {
pub fn new (
jack: &Arc<JackClient>,
jack: &Arc<RwLock<JackClient>>,
clock: &Arc<TransportTime>,
name: &str,
phrases: &Arc<RwLock<PhrasePool<E>>>
@ -537,16 +538,16 @@ impl<E: Engine> Arrangement<E> {
}
impl ArrangementTrack {
pub fn new (
jack: &Arc<JackClient>,
jack: &Arc<RwLock<JackClient>>,
clock: &Arc<TransportTime>,
name: &str,
color: Option<ItemColor>
) -> Self {
Self {
name: Arc::new(RwLock::new(name.into())),
width: name.len() + 2,
color: color.unwrap_or_else(ItemColor::random),
player: PhrasePlayer::new(jack, clock),
name: Arc::new(RwLock::new(name.into())),
width: name.len() + 2,
color: color.unwrap_or_else(ItemColor::random),
player: PhrasePlayer::new(&jack, clock),
}
}
pub fn longest_name (tracks: &[Self]) -> usize {

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

@ -9,7 +9,7 @@ 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>>,
pub jack: Arc<RwLock<JackClient>>,
/// Which view is focused
pub focus_cursor: (usize, usize),
/// Controls the JACK transport.
@ -392,7 +392,7 @@ impl PartialEq for Phrase { fn eq (&self, other: &Self) -> bool { self.uuid == o
impl Eq for Phrase {}
impl PhrasePlayer {
pub fn new (
jack: &Arc<JackClient>,
jack: &Arc<RwLock<JackClient>>,
clock: &Arc<TransportTime>
) -> Self {
Self {

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

@ -18,39 +18,31 @@ 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 transport = Arc::new(RwLock::new(TransportToolbar::new(None, Some(jack.transport()))));
let clock = transport.read().unwrap().clock.clone();
let sequencer = Sequencer {
jack: None,
player: None,
focus_cursor: (1, 1),
phrases: Arc::new(RwLock::new(PhrasePool::new())),
editor: PhraseEditor::new(),
transport: self.transport.then_some(transport),
clock,
};
if let Some(_) = self.name.as_ref() {
// TODO: sequencer.name = Arc::new(RwLock::new(name.clone()));
}
if let Some(_) = self.ppq {
// TODO: sequencer.ppq = ppq;
}
if let Some(_) = self.length {
// TODO: if let Some(phrase) = sequencer.phrase.as_mut() {
//phrase.write().unwrap().length = length;
//}
}
let sequencer = Arc::new(RwLock::new(sequencer));
let jack = jack.activate(&sequencer.clone(), Sequencer::callback)?;
let jack = Arc::new(jack);
let player = PhrasePlayer::new(&jack, &clock);
if let Some(ref transport) = sequencer.read().unwrap().transport {
transport.write().unwrap().jack = Some(jack.clone());
}
sequencer.write().unwrap().jack = Some(jack.clone());
sequencer.write().unwrap().player = player;
Tui::run(sequencer).map(|_|())
let name = self.name.map(|name|name.as_str()).unwrap_or("tek_arranger");
Tui::run(JackClient::new(name)?.activate_with(|jack|{
let mut transport = TransportToolbar::new(jack, None);
let sequencer = Sequencer {
jack: jack.clone(),
focus_cursor: (1, 1),
phrases: Arc::new(RwLock::new(PhrasePool::new())),
editor: PhraseEditor::new(),
clock: transport.clock.clone(),
player: Some(PhrasePlayer::new(jack, &transport.clock)),
transport: self.transport.then_some(Arc::new(RwLock::new(transport))),
};
if let Some(_) = self.name.as_ref() {
// TODO: sequencer.name = Arc::new(RwLock::new(name.clone()));
}
if let Some(_) = self.ppq {
// TODO: sequencer.ppq = ppq;
}
if let Some(_) = self.length {
// TODO: if let Some(phrase) = sequencer.phrase.as_mut() {
//phrase.write().unwrap().length = length;
//}
}
sequencer
}))?;
Ok(())
}
}

24
crates/tek_sequencer/src/transport.rs
View file

@ -26,14 +26,14 @@ impl TransportTime {
/// Stores and displays time-related state.
pub struct TransportToolbar<E: Engine> {
_engine: PhantomData<E>,
/// JACK client handle (needs to not be dropped for standalone mode to work).
pub jack: Arc<RwLock<JackClient>>,
/// JACK transport handle.
pub transport: Transport,
/// Current sample rate, tempo, and PPQ.
pub clock: Arc<TransportTime>,
/// Enable metronome?
pub metronome: bool,
/// JACK client handle (needs to not be dropped for standalone mode to work).
pub jack: Option<Arc<JackClient>>,
/// JACK transport handle.
pub transport: Option<Transport>,
/// Whether the toolbar is focused
pub focused: bool,
/// Which part of the toolbar is focused
@ -43,17 +43,14 @@ pub struct TransportToolbar<E: Engine> {
#[derive(Clone, Copy, PartialEq)]
pub enum TransportToolbarFocus { Bpm, Sync, PlayPause, Clock, Quant, }
impl<E: Engine> TransportToolbar<E> {
pub fn new (
clock: Option<&Arc<TransportTime>>,
transport: Option<Transport>,
) -> Self {
pub fn new (jack: &Arc<RwLock<JackClient>>, clock: Option<&Arc<TransportTime>>) -> Self {
Self {
_engine: Default::default(),
focused: false,
focus: TransportToolbarFocus::PlayPause,
metronome: false,
jack: None,
transport,
transport: jack.read().unwrap().transport(),
jack: jack.clone(),
clock: match clock {
Some(clock) => clock.clone(),
None => {
@ -70,16 +67,15 @@ impl<E: Engine> TransportToolbar<E> {
}
}
pub fn toggle_play (&mut self) -> Usually<()> {
let transport = self.transport.as_ref().unwrap();
let playing = self.clock.playing.read().unwrap().expect("1st sample has not been processed yet");
let playing = match playing {
TransportState::Stopped => {
transport.start()?;
self.transport.start()?;
Some(TransportState::Starting)
},
_ => {
transport.stop()?;
transport.locate(0)?;
self.transport.stop()?;
self.transport.locate(0)?;
Some(TransportState::Stopped)
},
};

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

@ -1,14 +1,10 @@
include!("lib.rs");
/// Application entrypoint.
pub fn main () -> Usually<()> {
let jack = JackClient::Inactive(
Client::new("tek_transport", ClientOptions::NO_START_SERVER)?.0
);
let mut transport = TransportToolbar::new(None, Some(jack.transport()));
transport.focused = true;
let transport = Arc::new(RwLock::new(transport));
let jack = jack.activate(&transport.clone(), TransportToolbar::callback)?;
transport.write().unwrap().jack = Some(jack.into());
Tui::run(transport)?;
Tui::run(JackClient::new("tek_transport")?.activate_with(|jack|{
let mut transport = TransportToolbar::new(jack, None);
transport.focused = true;
transport
}))?;
Ok(())
}

4
crates/tek_sequencer/src/transport_snd.rs
View file

@ -1,10 +1,10 @@
use crate::*;
impl<E: Engine> Audio for TransportToolbar<E> {
fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
let times = scope.cycle_times().unwrap();
let times = scope.cycle_times().unwrap();
let CycleTimes { current_frames, current_usecs, next_usecs: _, period_usecs: _ } = times;
let _chunk_size = scope.n_frames() as usize;
let transport = self.transport.as_ref().unwrap().query().unwrap();
let transport = self.transport.query().unwrap();
self.clock.current.sample.set(transport.pos.frame() as f64);
let mut playing = self.clock.playing.write().unwrap();
let mut started = self.clock.started.write().unwrap();