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: refactor pt.22: api traits in snd

Browse source
This commit is contained in:
🪞👃🪞 2024-11-13 19:49:52 +01:00
parent 029614631e
commit e7e57cea1e
8 changed files with 100 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/tek_snd/src/lib.rs
View file

@ -1,5 +1,5 @@
pub use tek_core::{*, jack::{*, Transport as JackTransport}};
pub use tek_api::{*, Transport};
pub use tek_core::{*, jack::*};
pub use tek_api::*;
pub(crate) use tek_core::midly::{*, live::LiveEvent, num::u7};
submod! {

12
crates/tek_snd/src/snd_arrange.rs
View file

@ -1,8 +1,16 @@
use crate::*;
impl<T: ArrangerModelApi + Send + Sync> Audio for T {
impl Audio for ArrangerModel {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
ArrangerRefAudio(self).process(client, scope)
}
}
pub struct ArrangerRefAudio<'a, T: ArrangerModelApi + Send + Sync>(&'a mut T);
impl<'a, T: ArrangerModelApi + Send + Sync> Audio for ArrangerRefAudio<'a, T> {
#[inline] fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
for track in self.tracks_mut().iter_mut() {
for track in self.0.tracks_mut().iter_mut() {
if MIDIPlayerAudio::from(&mut track.player).process(client, scope) == Control::Quit {
return Control::Quit
}

20
crates/tek_snd/src/snd_sequencer.rs
View file

@ -1,27 +1,19 @@
use crate::*;
pub struct SequencerAudio(pub Arc<RwLock<Transport>>, pub Arc<RwLock<MIDIPlayer>>);
/// JACK process callback for sequencer app
impl<'a> Audio for SequencerAudio {
impl Audio for SequencerModel {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
SequencerRefAudio(
&mut*self.0.write().unwrap(),
&mut*self.1.write().unwrap()
).process(client, scope)
SequencerRefAudio(self).process(client, scope)
}
}
pub struct SequencerRefAudio<'a, T: SequencerModelApi + Send + Sync>(&'a mut T);
pub struct SequencerRefAudio<'a>(pub &'a mut Transport, pub &'a mut MIDIPlayer);
/// JACK process callback for sequencer embed
impl<'a> Audio for SequencerRefAudio<'a> {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
impl<'a, T: SequencerModelApi + Send + Sync> Audio for SequencerRefAudio<'a, T> {
#[inline] fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
if TransportRefAudio(&mut*self.0).process(client, scope) == Control::Quit {
return Control::Quit
}
if MIDIPlayerAudio::from(&mut*self.1).process(client, scope) == Control::Quit {
if MIDIPlayerAudio::from(&mut*self.0.player_mut()).process(client, scope) == Control::Quit {
return Control::Quit
}
Control::Continue

26
crates/tek_snd/src/snd_transport.rs
View file

@ -1,27 +1,23 @@
use crate::*;
pub struct TransportAudio(pub Arc<RwLock<Transport>>);
impl Audio for TransportAudio {
impl Audio for TransportModel {
fn process (&mut self, client: &Client, scope: &ProcessScope) -> Control {
TransportRefAudio(
&mut*self.0.write().unwrap()
).process(client, scope)
TransportRefAudio(self).process(client, scope)
}
}
pub struct TransportRefAudio<'a>(pub &'a mut Transport);
pub struct TransportRefAudio<'a, T: TransportModelApi + Send + Sync>(pub(crate) &'a mut T);
impl<'a> Audio for TransportRefAudio<'a> {
fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
let ref state = self.0;
impl<'a, T: TransportModelApi + Send + Sync> Audio for TransportRefAudio<'a, T> {
#[inline] fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
let state = &mut self.0;
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 = state.transport.query().unwrap();
state.clock.current.sample.set(transport.pos.frame() as f64);
let mut playing = state.clock.playing.write().unwrap();
let mut started = state.clock.started.write().unwrap();
let transport = state.transport().query().unwrap();
state.clock().current.sample.set(transport.pos.frame() as f64);
let mut playing = state.clock().playing.write().unwrap();
let mut started = state.clock().started.write().unwrap();
if *playing != Some(transport.state) {
match transport.state {
TransportState::Rolling => {
@ -37,7 +33,7 @@ impl<'a> Audio for TransportRefAudio<'a> {
if *playing == Some(TransportState::Stopped) {
*started = None;
}
state.clock.current.update_from_usec(match *started {
state.clock().current.update_from_usec(match *started {
Some((_, usecs)) => current_usecs as f64 - usecs as f64,
None => 0.
});