tek/crates/tek_core/src/time_base.rs

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_000f64 / self.rate()
    }
    #[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()
    }
    #[inline] fn beat_per_second (&self) -> f64 {
        self.bpm() / 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()
    }
    #[inline] pub fn usec_per_pulse (&self) -> f64 {
        self.usec_per_beat() / self.ppq()
    }
    #[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() / self.pulses_per_second()
    }
    #[inline] fn pulses_per_second (&self) -> f64 {
        self.beat_per_second() * self.ppq()
    }

    #[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()
    }

}