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

crates/tek_core/src/time_base.rs

@@ -0,0 +1,103 @@
+use crate::*;
+
+#[derive(Debug)]
+/// Keeps track of global time units.
+pub struct Timebase {
+    /// Frames per second
+    pub rate: AtomicF64,
+    /// Beats per minute
+    pub bpm:  AtomicF64,
+    /// Ticks per beat
+    pub ppq:  AtomicF64,
+}
+impl Default for Timebase {
+    fn default () -> Self {
+        Self {
+            rate: 48000f64.into(),
+            bpm:  150f64.into(),
+            ppq:  96f64.into(),
+        }
+    }
+}
+impl Timebase {
+    pub fn new (rate: f64, bpm: f64, ppq: f64) -> Self {
+        Self { rate: rate.into(), bpm: bpm.into(), ppq: ppq.into() }
+    }
+
+    /// Frames per second
+    #[inline] fn rate (&self) -> f64 {
+        self.rate.load(Ordering::Relaxed)
+    }
+    #[inline] fn usec_per_frame (&self) -> f64 {
+        1_000_000 as f64 / self.rate() as f64
+    }
+    #[inline] pub fn frame_to_usec (&self, frame: f64) -> f64 {
+        frame * self.usec_per_frame()
+    }
+
+    /// Beats per minute
+    #[inline] pub fn bpm (&self) -> f64 {
+        self.bpm.load(Ordering::Relaxed)
+    }
+    #[inline] pub fn set_bpm (&self, bpm: f64) {
+        self.bpm.store(bpm, Ordering::Relaxed)
+    }
+    #[inline] fn usec_per_beat (&self) -> f64 {
+        60_000_000f64 / self.bpm() as f64
+    }
+    #[inline] fn beat_per_second (&self) -> f64 {
+        self.bpm() as f64 / 60000000.0
+    }
+
+    /// Pulses per beat
+    #[inline] pub fn ppq (&self) -> f64 {
+        self.ppq.load(Ordering::Relaxed)
+    }
+    #[inline] pub fn pulse_per_frame (&self) -> f64 {
+        self.usec_per_pulse() / self.usec_per_frame() as f64
+    }
+    #[inline] pub fn usec_per_pulse (&self) -> f64 {
+        self.usec_per_beat() / self.ppq() as f64
+    }
+    #[inline] pub fn pulse_to_frame (&self, pulses: f64) -> f64 {
+        self.pulse_per_frame() * pulses
+    }
+    #[inline] pub fn frame_to_pulse (&self, frames: f64) -> f64 {
+        frames / self.pulse_per_frame()
+    }
+    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
+        4.0 * self.usec_per_beat() * num / den
+    }
+    #[inline] pub fn frames_per_pulse (&self) -> f64 {
+        self.rate() as f64 / self.pulses_per_second()
+    }
+    #[inline] fn pulses_per_second (&self) -> f64 {
+        self.beat_per_second() * self.ppq() as f64
+    }
+
+    #[inline] pub fn note_to_frame (&self, note: (f64, f64)) -> f64 {
+        self.usec_to_frame(self.note_to_usec(note))
+    }
+    #[inline] fn usec_to_frame (&self, usec: f64) -> f64 {
+        usec * self.rate() / 1000.0
+    }
+
+    #[inline] pub fn quantize (
+        &self, step: (f64, f64), time: f64
+    ) -> (f64, f64) {
+        let step = self.note_to_usec(step);
+        (time / step, time % step)
+    }
+
+    #[inline] pub fn quantize_into <E, T> (
+        &self, step: (f64, f64), events: E
+    ) -> Vec<(f64, T)>
+        where E: std::iter::Iterator<Item=(f64, T)> + Sized
+    {
+        let step = (step.0.into(), step.1.into());
+        events
+            .map(|(time, event)|(self.quantize(step, time).0, event))
+            .collect()
+    }
+
+}