refactor: merge plugin, sampler -> mixer; transport -> sequencer; time -> core

crates/tek_sequencer/src/arranger.rs

@@ -49,6 +49,16 @@ impl Arranger {
             _ => {}
         }
     }
+    pub fn sequencer (&self) -> Option<&Sequencer> {
+        self.selected.track()
+            .map(|track|self.tracks.get(track))
+            .flatten()
+    }
+    pub fn sequencer_mut (&mut self) -> Option<&mut Sequencer> {
+        self.selected.track()
+            .map(|track|self.tracks.get_mut(track))
+            .flatten()
+    }
     pub fn show_phrase (&mut self) -> Usually<()> {
         unimplemented!()
         //let phrase = self.phrase();

crates/tek_sequencer/src/arranger_cli.rs

@@ -1,5 +1,4 @@
 use tek_core::clap::{self, Parser};
-use tek_timer::TransportToolbar;
 use crate::*;
 
 #[derive(Debug, Parser)]

crates/tek_sequencer/src/lib.rs

@@ -4,24 +4,27 @@ pub(crate) use tek_core::*;
 pub(crate) use tek_core::ratatui::prelude::*;
 pub(crate) use tek_core::crossterm::event::{KeyCode, KeyModifiers};
 pub(crate) use tek_core::midly::{num::u7, live::LiveEvent, MidiMessage};
-pub(crate) use tek_jack::jack::*;
-pub(crate) use tek_timer::*;
+pub(crate) use tek_jack::{*, jack::*};
 pub(crate) use std::sync::{Arc, RwLock};
 
 submod! {
-    midi
-    phrase
-    sequencer
-    sequencer_cli
-    sequencer_handle
-    sequencer_render
     arranger
     arranger_cli
     arranger_focus
     arranger_handle
     arranger_track
     arranger_view
+    midi
+    phrase
     scene
+    sequencer
+    sequencer_cli
+    sequencer_handle
+    sequencer_render
+    transport
+    transport_focus
+    transport_handle
+    transport_render
 }
 
 pubmod! {

crates/tek_sequencer/src/sequencer_cli.rs

@@ -1,5 +1,4 @@
 use tek_core::clap::{self, Parser};
-use tek_timer::TransportToolbar;
 use crate::*;
 
 #[derive(Debug, Parser)]

crates/tek_sequencer/src/transport.rs

@@ -0,0 +1,142 @@
+use crate::*;
+
+/// Stores and displays time-related state.
+pub struct TransportToolbar {
+    /// Enable metronome?
+    pub metronome: bool,
+    pub focused:   bool,
+    pub entered:   bool,
+    pub selected:  TransportFocus,
+    /// Current sample rate, tempo, and PPQ.
+    pub timebase:  Arc<Timebase>,
+    /// JACK client handle (needs to not be dropped for standalone mode to work).
+    pub jack:      Option<JackClient>,
+    /// JACK transport handle.
+    pub transport: Option<Transport>,
+    /// Quantization factor
+    pub quant:     usize,
+    /// Global sync quant
+    pub sync:      usize,
+    /// Current transport state
+    pub playing:   Option<TransportState>,
+    /// Current position according to transport
+    pub playhead:  usize,
+    /// Global frame and usec at which playback started
+    pub started:   Option<(usize, usize)>,
+}
+
+process!(TransportToolbar |self, _client, scope| {
+    self.update(&scope);
+    Control::Continue
+});
+
+impl TransportToolbar {
+
+    pub fn standalone () -> Usually<Arc<RwLock<Self>>> {
+        let mut transport = Self::new(None);
+        transport.focused = true;
+        transport.entered = true;
+        let jack = JackClient::Inactive(
+            Client::new("tek_transport", ClientOptions::NO_START_SERVER)?.0
+        );
+        transport.transport = Some(jack.transport());
+        let transport = Arc::new(RwLock::new(transport));
+        transport.write().unwrap().jack = Some(
+            jack.activate(
+                &transport.clone(),
+                |state, client, scope| {
+                    state.write().unwrap().process(client, scope)
+                }
+            )?
+        );
+        Ok(transport)
+    }
+
+    pub fn new (transport: Option<Transport>) -> Self {
+        let timebase = Arc::new(Timebase::default());
+        Self {
+            selected:  TransportFocus::BPM,
+            metronome: false,
+            focused:   false,
+            entered:   false,
+            playhead:  0,
+            playing:   Some(TransportState::Stopped),
+            started:   None,
+            quant:     24,
+            sync:      timebase.ppq() as usize * 4,
+            jack:      None,
+            transport,
+            timebase,
+        }
+    }
+
+    pub fn toggle_play (&mut self) -> Usually<()> {
+        let transport = self.transport.as_ref().unwrap();
+        self.playing = match self.playing.expect("1st frame has not been processed yet") {
+            TransportState::Stopped => {
+                transport.start()?;
+                Some(TransportState::Starting)
+            },
+            _ => {
+                transport.stop()?;
+                transport.locate(0)?;
+                Some(TransportState::Stopped)
+            },
+        };
+        Ok(())
+    }
+
+    pub fn update (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, usize, f64) {
+        let CycleTimes {
+            current_frames,
+            current_usecs,
+            next_usecs,
+            period_usecs
+        } = scope.cycle_times().unwrap();
+        let chunk_size = scope.n_frames() as usize;
+        let transport = self.transport.as_ref().unwrap().query().unwrap();
+        self.playhead = transport.pos.frame() as usize;
+        let mut reset = false;
+        if self.playing != Some(transport.state) {
+            match transport.state {
+                TransportState::Rolling => {
+                    self.started = Some((
+                        current_frames as usize,
+                        current_usecs  as usize,
+                    ));
+                },
+                TransportState::Stopped => {
+                    self.started = None;
+                    reset = true;
+                },
+                _ => {}
+            }
+        }
+        self.playing = Some(transport.state);
+        (
+            reset,
+            current_frames as usize,
+            chunk_size as usize,
+            current_usecs as usize,
+            next_usecs as usize,
+            period_usecs as f64
+        )
+    }
+
+    pub fn bpm (&self) -> usize {
+        self.timebase.bpm() as usize
+    }
+
+    pub fn ppq (&self) -> usize {
+        self.timebase.ppq() as usize
+    }
+
+    pub fn pulse (&self) -> usize {
+        self.timebase.frame_to_pulse(self.playhead as f64) as usize
+    }
+
+    pub fn usecs (&self) -> usize {
+        self.timebase.frame_to_usec(self.playhead as f64) as usize
+    }
+
+}

crates/tek_sequencer/src/transport_focus.rs

@@ -0,0 +1,23 @@
+use crate::*;
+
+#[derive(PartialEq)]
+/// Which section of the transport is focused
+pub enum TransportFocus { BPM, Quant, Sync }
+
+impl TransportFocus {
+    pub fn prev (&mut self) {
+        *self = match self {
+            Self::BPM   => Self::Sync,
+            Self::Quant => Self::BPM,
+            Self::Sync  => Self::Quant,
+        }
+    }
+    pub fn next (&mut self) {
+        *self = match self {
+            Self::BPM   => Self::Quant,
+            Self::Quant => Self::Sync,
+            Self::Sync  => Self::BPM,
+        }
+    }
+}
+

crates/tek_sequencer/src/transport_handle.rs

@@ -0,0 +1,51 @@
+use crate::*;
+
+handle!{
+    TransportToolbar |self, e| {
+        handle_keymap(self, e, KEYMAP_TRANSPORT)
+    }
+}
+
+/// Key bindings for transport toolbar.
+pub const KEYMAP_TRANSPORT: &'static [KeyBinding<TransportToolbar>] = keymap!(TransportToolbar {
+    [Left,  NONE, "transport_prev", "select previous control",  |transport: &mut TransportToolbar| Ok({
+        transport.selected.prev();
+        true
+    })],
+    [Right, NONE, "transport_next", "select next control",      |transport: &mut TransportToolbar| Ok({
+        transport.selected.next();
+        true
+    })],
+    [Char('.'), NONE, "transport_increment", "increment value at cursor", |transport: &mut TransportToolbar| {
+        match transport.selected {
+            TransportFocus::BPM   => {
+                transport.timebase.bpm.fetch_add(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                transport.quant = next_note_length(transport.quant)
+            },
+            TransportFocus::Sync  => {
+                transport.sync = next_note_length(transport.sync)
+            },
+        };
+        Ok(true)
+    }],
+    [Char(','), NONE, "transport_decrement", "decrement value at cursor", |transport: &mut TransportToolbar| {
+        match transport.selected {
+            TransportFocus::BPM   => {
+                transport.timebase.bpm.fetch_sub(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                transport.quant = prev_note_length(transport.quant);
+            },
+            TransportFocus::Sync  => {
+                transport.sync = prev_note_length(transport.sync);
+            },
+        };
+        Ok(true)
+    }],
+    [Char(' '), NONE, "transport_play_toggle", "play or pause", |transport: &mut TransportToolbar| {
+        transport.toggle_play()?;
+        Ok(true)
+    }],
+});

crates/tek_sequencer/src/transport_main.rs

@@ -0,0 +1,6 @@
+include!("lib.rs");
+/// Application entrypoint.
+pub fn main () -> Usually<()> {
+    run(TransportToolbar::standalone()?)?;
+    Ok(())
+}

crates/tek_sequencer/src/transport_render.rs

@@ -0,0 +1,84 @@
+use crate::*;
+
+render!(TransportToolbar |self, buf, area| {
+    let mut area     = area;
+    area.height      = 2;
+    let gray         = Style::default().gray();
+    let not_dim      = Style::default().not_dim();
+    let not_dim_bold = not_dim.bold();
+    let corners      = Corners(Style::default().green().not_dim());
+    let ppq          = self.ppq();
+    let bpm          = self.bpm();
+    let pulse        = self.pulse();
+    let usecs        = self.usecs();
+    let Self { quant, sync, focused, entered, .. } = self;
+    fill_bg(buf, area, Nord::bg_lo(*focused, *entered));
+    Split::right([
+
+        // Play/Pause button
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            let style = Some(match self.playing {
+                Some(TransportState::Stopped)  => gray.dim().bold(),
+                Some(TransportState::Starting) => gray.not_dim().bold(),
+                Some(TransportState::Rolling)  => gray.not_dim().white().bold(),
+                _ => unreachable!(),
+            });
+            let label = match self.playing {
+                Some(TransportState::Rolling)  => "▶ PLAYING",
+                Some(TransportState::Starting) => "READY ...",
+                Some(TransportState::Stopped)  => "⏹ STOPPED",
+                _ => unreachable!(),
+            };
+            let mut result = label.blit(buf, x + 1, y, style)?;
+            result.width = result.width + 1;
+            Ok(result)
+        },
+
+        // Beats per minute
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "BPM".blit(buf, x, y, Some(not_dim))?;
+            let width = format!("{}.{:03}", bpm, bpm % 1).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::BPM {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Quantization
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "QUANT".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*quant as usize).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Quant {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clip launch sync
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "SYNC".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*sync as usize).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Sync {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clock
+        &|buf: &mut Buffer, Rect { x, y, width, .. }: Rect|{
+            let (beats, pulses)    = (pulse / ppq, pulse % ppq);
+            let (bars, beats)      = ((beats / 4) + 1, (beats % 4) + 1);
+            let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+            let (minutes, seconds) = (seconds / 60, seconds % 60);
+            let timer = format!("{bars}.{beats}.{pulses:02}");
+            timer.blit(buf, x + width - timer.len() as u16 - 1, y + 0, Some(not_dim))?;
+            let timer = format!("{minutes}:{seconds:02}:{msecs:03}");
+            timer.blit(buf, x + width - timer.len() as u16 - 1, y + 1, Some(not_dim))?;
+            Ok(area)
+        }
+
+    ]).render(buf, area)
+});