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

MidiPlayer -> Sequencer; connect sequencer to sampler in groovebox mode

Browse source
This commit is contained in:
🪞👃🪞 2025-05-10 19:08:22 +03:00
parent c5586c3a35
commit 5fab1af138
10 changed files with 120 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/app/src/api.rs
View file

@ -469,7 +469,7 @@ impl<'state> Context<'state, SamplerCommand> for App {
Ok(None)
}
fn stop (app: &mut App, index: usize) -> Perhaps<Self> {
app.tracks[index].player.enqueue_next(None);
app.tracks[index].sequencer.enqueue_next(None);
Ok(None)
}
fn add (app: &mut App) -> Perhaps<Self> {
@ -535,7 +535,7 @@ impl<'state> Context<'state, SamplerCommand> for App {
}
fn enqueue (app: &mut App, a: usize, b: usize) -> Perhaps<Self> {
//(Enqueue [t: usize, s: usize]
//cmd!(app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref())))
//cmd!(app.tracks[t].sequencer.enqueue_next(app.scenes[s].clips[t].as_ref())))
//("enqueue" [a: usize, b: usize] Some(Self::Enqueue(a.unwrap(), b.unwrap())))
todo!()
}

2
crates/app/src/audio.rs
View file

@ -57,7 +57,7 @@ audio!(
// Update track sequencers and devices
for track in self.tracks.iter_mut() {
if Control::Quit == PlayerAudio(
track.player_mut(), &mut self.note_buf, &mut self.midi_buf
track.sequencer_mut(), &mut self.note_buf, &mut self.midi_buf
).process(client, scope) {
return Control::Quit
}

16
crates/app/src/model.rs
View file

@ -102,7 +102,7 @@ impl App {
let mut track = Track {
width: (name.len() + 2).max(12),
color: color.unwrap_or_else(ItemTheme::random),
player: MidiPlayer::new(
sequencer: Sequencer::new(
&format!("{name}"),
self.jack(),
Some(self.clock()),
@ -141,7 +141,7 @@ impl App {
let exists = self.tracks().get(index).is_some();
if exists {
let track = self.tracks_mut().remove(index);
let Track { player: MidiPlayer { midi_ins, midi_outs, .. }, .. } = track;
let Track { sequencer: Sequencer { midi_ins, midi_outs, .. }, .. } = track;
for port in midi_ins.into_iter() {
port.close()?;
}
@ -196,7 +196,7 @@ impl App {
/// Enqueue clips from a scene across all tracks
pub fn scene_enqueue (&mut self, scene: usize) {
for track in 0..self.tracks.len() {
self.tracks[track].player.enqueue_next(self.scenes[scene].clips[track].as_ref());
self.tracks[track].sequencer.enqueue_next(self.scenes[scene].clips[track].as_ref());
}
}
@ -315,7 +315,7 @@ impl App {
/// Stop all playing clips
pub(crate) fn stop_all (&mut self) {
for track in 0..self.tracks.len() {
self.tracks[track].player.enqueue_next(None);
self.tracks[track].sequencer.enqueue_next(None);
}
}
@ -324,14 +324,14 @@ impl App {
use Selection::*;
match self.selected {
Track(t) => {
self.tracks[t].player.enqueue_next(None)
self.tracks[t].sequencer.enqueue_next(None)
},
TrackClip { track, scene } => {
self.tracks[track].player.enqueue_next(self.scenes[scene].clips[track].as_ref())
self.tracks[track].sequencer.enqueue_next(self.scenes[scene].clips[track].as_ref())
},
Scene(s) => {
for t in 0..self.tracks.len() {
self.tracks[t].player.enqueue_next(self.scenes[s].clips[t].as_ref())
self.tracks[t].sequencer.enqueue_next(self.scenes[s].clips[t].as_ref())
}
},
_ => {}
@ -417,7 +417,7 @@ impl App {
fn device_add_sampler (&mut self) -> Usually<()> {
let name = self.jack.with_client(|c|c.name().to_string());
let midi = self.track().expect("no active track").player.midi_outs[0].name();
let midi = self.track().expect("no active track").sequencer.midi_outs[0].name();
let sampler = if let Ok(sampler) = Sampler::new(
&self.jack,
&format!("{}/Sampler", &self.track().expect("no active track").name),

2
crates/app/src/model/scene.rs
View file

@ -24,7 +24,7 @@ impl Scene {
Some(c) => tracks
.get(track_index)
.map(|track|{
if let Some((_, Some(clip))) = track.player().play_clip() {
if let Some((_, Some(clip))) = track.sequencer().play_clip() {
*clip.read().unwrap() == *c.read().unwrap()
} else {
false

104
crates/app/src/model/track.rs
View file

@ -7,8 +7,8 @@ use crate::*;
pub width: usize,
/// Identifying color of track
pub color: ItemTheme,
/// MIDI player state
pub player: MidiPlayer,
/// MIDI sequencer state
pub sequencer: Sequencer,
/// Device chain
pub devices: Vec<Device>,
/// Inputs of 1st device
@ -17,52 +17,60 @@ use crate::*;
pub audio_outs: Vec<JackAudioOut>,
}
has_clock!(|self: Track|self.player.clock);
has_clock!(|self: Track|self.sequencer.clock);
has_player!(|self: Track|self.player);
has_sequencer!(|self: Track|self.sequencer);
impl Track {
pub const MIN_WIDTH: usize = 9;
/// Create a new track with only the default [MidiPlayer].
pub fn new () -> Self {
Self::default()
/// Create a new track with only the default [Sequencer].
pub fn new (
name: &impl AsRef<str>,
color: Option<ItemTheme>,
jack: &Jack,
clock: Option<&Clock>,
midi_from: &[PortConnect],
midi_to: &[PortConnect],
) -> Usually<Self> {
Ok(Self {
name: name.as_ref().into(),
color: color.unwrap_or_default(),
sequencer: Sequencer::new(
format!("{}/sequencer", name.as_ref()),
jack,
clock,
None,
midi_from,
midi_to
)?,
..Default::default()
})
}
/// Create a new track connecting the [MidiPlayer] to a [Sampler].
/// Create a new track connecting the [Sequencer] to a [Sampler].
pub fn new_with_sampler (
name: &impl AsRef<str>,
color: Option<ItemTheme>,
jack: &Jack,
clock: Option<&Clock>,
midi_from: &[PortConnect],
midi_to: &[PortConnect],
audio_from: &[&[PortConnect];2],
audio_to: &[&[PortConnect];2],
) -> Usually<Self> {
let mut track = Self::new_sequencer();
let name = jack.with_client(|c|c.name().to_string());
let midi = track.player.midi_outs[0].name();
let port = PortConnect::exact(format!("{name}:{midi}"));
let sampler = Sampler::new(jack, &"sampler", &[port], audio_from, audio_to)?;
track.devices.push(Device::Sampler(sampler));
let mut track = Self::new(
name, color, jack, clock, midi_from, midi_to
)?;
track.devices.push(Device::Sampler(Sampler::new(
jack,
&"sampler",
&[PortConnect::exact(format!("{}:{}",
jack.with_client(|c|c.name().to_string()),
track.sequencer.midi_outs[0].name()
))],
audio_from,
audio_to
)?));
Ok(track)
}
pub fn width_inc (&mut self) {
self.width += 1;
}
pub fn width_dec (&mut self) {
if self.width > Track::MIN_WIDTH {
self.width -= 1;
}
}
pub fn sequencer (&self, mut nth: usize) -> Option<&MidiPlayer> {
for device in self.devices.iter() {
match device {
Device::Sequencer(s) => if nth == 0 {
return Some(s);
} else {
nth -= 1;
},
_ => {}
}
}
None
}
pub fn sampler (&self, mut nth: usize) -> Option<&Sampler> {
for device in self.devices.iter() {
match device {
@ -91,6 +99,26 @@ impl Track {
}
}
pub trait HasWidth {
const MIN_WIDTH: usize;
/// Increment track width.
fn width_inc (&mut self);
/// Decrement track width, down to a hardcoded minimum of [Self::MIN_WIDTH].
fn width_dec (&mut self);
}
impl HasWidth for Track {
const MIN_WIDTH: usize = 9;
fn width_inc (&mut self) {
self.width += 1;
}
fn width_dec (&mut self) {
if self.width > Track::MIN_WIDTH {
self.width -= 1;
}
}
}
pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync {
fn midi_ins (&self) -> &Vec<JackMidiIn>;
fn midi_outs (&self) -> &Vec<JackMidiOut>;
@ -117,14 +145,14 @@ pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync
fn track_toggle_record (&mut self) {
if let Some(t) = self.selected().track() {
let tracks = self.tracks_mut();
tracks[t-1].player.recording = !tracks[t-1].player.recording;
tracks[t-1].sequencer.recording = !tracks[t-1].sequencer.recording;
}
}
/// Toggle track monitoring
fn track_toggle_monitor (&mut self) {
if let Some(t) = self.selected().track() {
let tracks = self.tracks_mut();
tracks[t-1].player.monitoring = !tracks[t-1].player.monitoring;
tracks[t-1].sequencer.monitoring = !tracks[t-1].sequencer.monitoring;
}
}
}

10
crates/app/src/view.rs
View file

@ -336,8 +336,8 @@ impl<'a> ArrangerView<'a> {
self.width_mid,
||self.tracks_with_sizes_scrolled(),
move|t, track|{
let rec = track.player.recording;
let mon = track.player.monitoring;
let rec = track.sequencer.recording;
let mon = track.sequencer.monitoring;
let rec = if rec { White } else { track.color.darkest.rgb };
let mon = if mon { White } else { track.color.darkest.rgb };
let bg = if self.track_selected == Some(t) {
@ -377,10 +377,10 @@ impl<'a> ArrangerView<'a> {
let label = Align::ne("Next clip:");
Tryptich::top(2).left(self.width_side, label).middle(self.width_mid, per_track_top(
self.width_mid, ||self.tracks_with_sizes_scrolled(), |t, track|{
let queued = track.player.next_clip.is_some();
let queued = track.sequencer.next_clip.is_some();
let queued_blank = Thunk::new(||Tui::bg(Reset, " ------ "));
let queued_clip = Thunk::new(||{
Tui::bg(Reset, if let Some((_, clip)) = track.player.next_clip.as_ref() {
Tui::bg(Reset, if let Some((_, clip)) = track.sequencer.next_clip.as_ref() {
if let Some(clip) = clip {
clip.read().unwrap().name.clone()
} else {
@ -1224,7 +1224,7 @@ impl std::fmt::Debug for PianoHorizontal {
}
// Update sequencer playhead indicator
//self.now().set(0.);
//if let Some((ref started_at, Some(ref playing))) = self.player.play_clip {
//if let Some((ref started_at, Some(ref playing))) = self.sequencer.play_clip {
//let clip = clip.read().unwrap();
//if *playing.read().unwrap() == *clip {
//let pulse = self.current().pulse.get();