tek/engine/engine_impls.rs

use crate::*;

impl Gettable<bool> for AtomicBool {
    fn get (&self) -> bool {
        self.load(Relaxed)
    }
}

impl InteriorMutable<bool> for AtomicBool {
    fn set (&self, value: bool) -> bool {
        self.swap(value, Relaxed)
    }
}

impl Gettable<usize> for AtomicUsize {
    fn get (&self) -> usize {
        self.load(Relaxed)
    }
}

impl InteriorMutable<usize> for AtomicUsize {
    fn set (&self, value: usize) -> usize {
        self.swap(value, Relaxed)
    }
}

//impl<T, U: Has<Option<T>>> MaybeHas<T> for U {
    //fn get (&self) -> Option<&T> {
        //Has::<Option<T>>::get(self).as_ref()
    //}
//}

impl Default for MidiCursor {
    fn default () -> Self {
        Self {
            time_pos: Arc::new(0.into()),
            note_pos: Arc::new(36.into()),
            note_len: Arc::new(24.into()),
        }
    }
}

impl NotePoint for MidiCursor {
    fn note_len (&self) -> &AtomicUsize {
        &self.note_len
    }
    fn note_pos (&self) -> &AtomicUsize {
        &self.note_pos
    }
}

impl TimePoint for MidiCursor {
    fn time_pos (&self) -> &AtomicUsize {
        self.time_pos.as_ref()
    }
}

impl<T: NotePoint + TimePoint> MidiPoint for T {}

from!(MidiSelection: |data:(usize, bool)| Self {
    time_len:   Arc::new(0.into()),
    note_axis:  Arc::new(0.into()),
    note_lo:    Arc::new(0.into()),
    time_axis:  Arc::new(0.into()),
    time_start: Arc::new(0.into()),
    time_zoom:  Arc::new(data.0.into()),
    time_lock:  Arc::new(data.1.into()),
});

impl<T: TimeRange + NoteRange> MidiRange for T {}

impl TimeRange for MidiSelection {
    fn time_len   (&self) -> &AtomicUsize { &self.time_len   }
    fn time_zoom  (&self) -> &AtomicUsize { &self.time_zoom  }
    fn time_lock  (&self) -> &AtomicBool  { &self.time_lock  }
    fn time_start (&self) -> &AtomicUsize { &self.time_start }
    fn time_axis  (&self) -> &AtomicUsize { &self.time_axis  }
}

impl NoteRange for MidiSelection {
    fn note_lo    (&self) -> &AtomicUsize { &self.note_lo    }
    fn note_axis  (&self) -> &AtomicUsize { &self.note_axis  }
}

impl Moment {
    pub fn zero (timebase: &Arc<Timebase>) -> Self {
        Self { usec: 0.into(), sample: 0.into(), pulse: 0.into(), timebase: timebase.clone() }
    }
    pub fn from_usec (timebase: &Arc<Timebase>, usec: f64) -> Self {
        Self {
            usec:     usec.into(),
            sample:   timebase.sr.usecs_to_sample(usec).into(),
            pulse:    timebase.usecs_to_pulse(usec).into(),
            timebase: timebase.clone(),
        }
    }
    pub fn from_sample (timebase: &Arc<Timebase>, sample: f64) -> Self {
        Self {
            sample:   sample.into(),
            usec:     timebase.sr.samples_to_usec(sample).into(),
            pulse:    timebase.samples_to_pulse(sample).into(),
            timebase: timebase.clone(),
        }
    }
    pub fn from_pulse (timebase: &Arc<Timebase>, pulse: f64) -> Self {
        Self {
            pulse:    pulse.into(),
            sample:   timebase.pulses_to_sample(pulse).into(),
            usec:     timebase.pulses_to_usec(pulse).into(),
            timebase: timebase.clone(),
        }
    }
    #[inline] pub fn update_from_usec (&self, usec: f64) {
        self.usec.set(usec);
        self.pulse.set(self.timebase.usecs_to_pulse(usec));
        self.sample.set(self.timebase.sr.usecs_to_sample(usec));
    }
    #[inline] pub fn update_from_sample (&self, sample: f64) {
        self.usec.set(self.timebase.sr.samples_to_usec(sample));
        self.pulse.set(self.timebase.samples_to_pulse(sample));
        self.sample.set(sample);
    }
    #[inline] pub fn update_from_pulse (&self, pulse: f64) {
        self.usec.set(self.timebase.pulses_to_usec(pulse));
        self.pulse.set(pulse);
        self.sample.set(self.timebase.pulses_to_sample(pulse));
    }
    #[inline] pub fn format_beat (&self) -> Arc<str> {
        self.timebase.format_beats_1(self.pulse.get()).into()
    }
}

impl LaunchSync {
    pub fn next (&self) -> f64 {
        note_duration_next(self.get() as usize) as f64
    }
    pub fn prev (&self) -> f64 {
        note_duration_prev(self.get() as usize) as f64
    }
}

impl Quantize {
    pub fn next (&self) -> f64 {
        note_duration_next(self.get() as usize) as f64
    }
    pub fn prev (&self) -> f64 {
        note_duration_prev(self.get() as usize) as f64
    }
}

impl Iterator for TicksIterator {
    type Item = (usize, usize);
    fn next (&mut self) -> Option<Self::Item> {
        loop {
            if self.sample > self.end { return None }
            let spp    = self.spp;
            let sample = self.sample as f64;
            let start  = self.start;
            let end    = self.end;
            self.sample += 1;
            //println!("{spp} {sample} {start} {end}");
            let jitter = sample.rem_euclid(spp); // ramps
            let next_jitter = (sample + 1.0).rem_euclid(spp);
            if jitter > next_jitter { // at crossing:
                let time = (sample as usize) % (end as usize-start as usize);
                let tick = (sample / spp) as usize;
                return Some((time, tick))
            }
        }
    }
}

impl Timebase {
    /// Specify sample rate, BPM and PPQ
    pub fn new (
        s: impl Into<SampleRate>,
        b: impl Into<BeatsPerMinute>,
        p: impl Into<PulsesPerQuaver>
    ) -> Self {
        Self { sr: s.into(), bpm: b.into(), ppq: p.into() }
    }
    /// Iterate over ticks between start and end.
    #[inline] pub fn pulses_between_samples (&self, start: usize, end: usize) -> TicksIterator {
        TicksIterator { spp: self.samples_per_pulse(), sample: start, start, end }
    }
    /// Return the duration fo a beat in microseconds
    #[inline] pub fn usec_per_beat (&self) -> f64 { 60_000_000f64 / self.bpm.get() }
    /// Return the number of beats in a second
    #[inline] pub fn beat_per_second (&self) -> f64 { self.bpm.get() / 60f64 }
    /// Return the number of microseconds corresponding to a note of the given duration
    #[inline] pub fn note_to_usec (&self, (num, den): (f64, f64)) -> f64 {
        4.0 * self.usec_per_beat() * num / den
    }
    /// Return duration of a pulse in microseconds (BPM-dependent)
    #[inline] pub fn pulse_per_usec (&self) -> f64 { self.ppq.get() / self.usec_per_beat() }
    /// Return duration of a pulse in microseconds (BPM-dependent)
    #[inline] pub fn usec_per_pulse (&self) -> f64 { self.usec_per_beat() / self.ppq.get() }
    /// Return number of pulses to which a number of microseconds corresponds (BPM-dependent)
    #[inline] pub fn usecs_to_pulse (&self, usec: f64) -> f64 { usec * self.pulse_per_usec() }
    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
    #[inline] pub fn pulses_to_usec (&self, pulse: f64) -> f64 { pulse / self.usec_per_pulse() }
    /// Return number of pulses in a second (BPM-dependent)
    #[inline] pub fn pulses_per_second (&self) -> f64 { self.beat_per_second() * self.ppq.get() }
    /// Return fraction of a pulse to which a sample corresponds (SR- and BPM-dependent)
    #[inline] pub fn pulses_per_sample (&self) -> f64 {
        self.usec_per_pulse() / self.sr.usec_per_sample()
    }
    /// Return number of samples in a pulse (SR- and BPM-dependent)
    #[inline] pub fn samples_per_pulse (&self) -> f64 {
        self.sr.get() / self.pulses_per_second()
    }
    /// Convert a number of pulses to a sample number (SR- and BPM-dependent)
    #[inline] pub fn pulses_to_sample (&self, p: f64) -> f64 {
        self.pulses_per_sample() * p
    }
    /// Convert a number of samples to a pulse number (SR- and BPM-dependent)
    #[inline] pub fn samples_to_pulse (&self, s: f64) -> f64 {
        s / self.pulses_per_sample()
    }
    /// Return the number of samples corresponding to a note of the given duration
    #[inline] pub fn note_to_samples (&self, note: (f64, f64)) -> f64 {
        self.usec_to_sample(self.note_to_usec(note))
    }
    /// Return the number of samples corresponding to the given number of microseconds
    #[inline] pub fn usec_to_sample (&self, usec: f64) -> f64 {
        usec * self.sr.get() / 1000f64
    }
    /// Return the quantized position of a moment in time given a step
    #[inline] pub fn quantize (&self, step: (f64, f64), time: f64) -> (f64, f64) {
        let step = self.note_to_usec(step);
        (time / step, time % step)
    }
    /// Quantize a collection of events
    #[inline] pub fn quantize_into <E: Iterator<Item=(f64, f64)> + Sized, T> (
        &self, step: (f64, f64), events: E
    ) -> Vec<(f64, f64)> {
        events.map(|(time, event)|(self.quantize(step, time).0, event)).collect()
    }
    /// Format a number of pulses into Beat.Bar.Pulse starting from 0
    #[inline] pub fn format_beats_0 (&self, pulse: f64) -> Arc<str> {
        let pulse = pulse as usize;
        let ppq   = self.ppq.get() as usize;
        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
        format!("{}.{}.{pulses:02}", beats / 4, beats % 4).into()
    }
    /// Format a number of pulses into Beat.Bar starting from 0
    #[inline] pub fn format_beats_0_short (&self, pulse: f64) -> Arc<str> {
        let pulse = pulse as usize;
        let ppq   = self.ppq.get() as usize;
        let beats = if ppq > 0 { pulse / ppq } else { 0 };
        format!("{}.{}", beats / 4, beats % 4).into()
    }
    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
    #[inline] pub fn format_beats_1 (&self, pulse: f64) -> Arc<str> {
        let mut string = String::with_capacity(16);
        self.format_beats_1_to(&mut string, pulse).expect("failed to format {pulse} into beat");
        string.into()
    }
    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
    #[inline] pub fn format_beats_1_to (&self, w: &mut impl std::fmt::Write, pulse: f64) -> Result<(), std::fmt::Error> {
        let pulse = pulse as usize;
        let ppq   = self.ppq.get() as usize;
        let (beats, pulses) = if ppq > 0 { (pulse / ppq, pulse % ppq) } else { (0, 0) };
        write!(w, "{}.{}.{pulses:02}", beats / 4 + 1, beats % 4 + 1)
    }
    /// Format a number of pulses into Beat.Bar.Pulse starting from 1
    #[inline] pub fn format_beats_1_short (&self, pulse: f64) -> Arc<str> {
        let pulse = pulse as usize;
        let ppq   = self.ppq.get() as usize;
        let beats = if ppq > 0 { pulse / ppq } else { 0 };
        format!("{}.{}", beats / 4 + 1, beats % 4 + 1).into()
    }
}

impl Default for Timebase {
    fn default () -> Self { Self::new(48000f64, 150f64, DEFAULT_PPQ) }
}
impl SampleRate {
    /// Return the duration of a sample in microseconds (floating)
    #[inline] pub fn usec_per_sample (&self) -> f64 {
        1_000_000f64 / self.get()
    }
    /// Return the duration of a sample in microseconds (floating)
    #[inline] pub fn sample_per_usec (&self) -> f64 {
        self.get() / 1_000_000f64
    }
    /// Convert a number of samples to microseconds (floating)
    #[inline] pub fn samples_to_usec (&self, samples: f64) -> f64 {
        self.usec_per_sample() * samples
    }
    /// Convert a number of microseconds to samples (floating)
    #[inline] pub fn usecs_to_sample (&self, usecs:   f64) -> f64 {
        self.sample_per_usec() * usecs
    }
}

impl Microsecond {
    #[inline] pub fn format_msu (&self) -> Arc<str> {
        let usecs              = self.get() as usize;
        let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
        let (minutes, seconds) = (seconds / 60, seconds % 60);
        format!("{minutes}:{seconds:02}:{msecs:03}").into()
    }
}

/// Implement an arithmetic operation for a unit of time
#[macro_export] macro_rules! impl_op {
    ($T:ident, $Op:ident, $method:ident, |$a:ident,$b:ident|{$impl:expr}) => {
        impl $Op<Self> for $T {
            type Output = Self; #[inline] fn $method (self, other: Self) -> Self::Output {
                let $a = self.get(); let $b = other.get(); Self($impl.into())
            }
        }
        impl $Op<usize> for $T {
            type Output = Self; #[inline] fn $method (self, other: usize) -> Self::Output {
                let $a = self.get(); let $b = other as f64; Self($impl.into())
            }
        }
        impl $Op<f64> for $T {
            type Output = Self; #[inline] fn $method (self, other: f64) -> Self::Output {
                let $a = self.get(); let $b = other; Self($impl.into())
            }
        }
    }
}

/// Define and implement a unit of time
#[macro_export] macro_rules! impl_time_unit {
    ($T:ident) => {
        impl Gettable<f64> for $T {
            fn get (&self) -> f64 { self.0.load(Relaxed) }
        }
        impl InteriorMutable<f64> for $T {
            fn set (&self, value: f64) -> f64 {
                let old = self.get();
                self.0.store(value, Relaxed);
                old
            }
        }
        impl TimeUnit for $T {}
        impl_op!($T, Add, add, |a, b|{a + b});
        impl_op!($T, Sub, sub, |a, b|{a - b});
        impl_op!($T, Mul, mul, |a, b|{a * b});
        impl_op!($T, Div, div, |a, b|{a / b});
        impl_op!($T, Rem, rem, |a, b|{a % b});
        impl From<f64>   for $T    { fn from (value: f64)   -> Self { Self(value.into()) } }
        impl From<usize> for $T    { fn from (value: usize) -> Self { Self((value as f64).into()) } }
        impl From<$T>    for f64   { fn from (value: $T)    -> Self { value.get() } }
        impl From<$T>    for usize { fn from (value: $T)    -> Self { value.get() as usize } }
        impl From<&$T>   for f64   { fn from (value: &$T)   -> Self { value.get() } }
        impl From<&$T>   for usize { fn from (value: &$T)   -> Self { value.get() as usize } }
        impl Clone for $T { fn clone (&self) -> Self { Self(self.get().into()) } }
    }
}

impl_time_unit!(SampleCount);
impl_time_unit!(SampleRate);
impl_time_unit!(Microsecond);
impl_time_unit!(Quantize);
impl_time_unit!(PulsesPerQuaver);
impl_time_unit!(Pulse);
impl_time_unit!(BeatsPerMinute);
impl_time_unit!(LaunchSync);