213 lines
7.0 KiB
Rust
213 lines
7.0 KiB
Rust
/// Microsecond-precision timestamp for audio synchronization.
|
|
pub type SyncTime = u64;
|
|
|
|
/// Timing boundary types for step and pattern scheduling.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum StepTiming {
|
|
/// Fire when a beat boundary is crossed.
|
|
NextBeat,
|
|
/// Fire when a bar/quantum boundary is crossed.
|
|
NextBar,
|
|
}
|
|
|
|
impl StepTiming {
|
|
/// Returns true if the boundary was crossed between prev_beat and curr_beat.
|
|
pub fn crossed(&self, prev_beat: f64, curr_beat: f64, quantum: f64) -> bool {
|
|
if prev_beat < 0.0 {
|
|
return false;
|
|
}
|
|
match self {
|
|
Self::NextBeat => prev_beat.floor() as i64 != curr_beat.floor() as i64,
|
|
Self::NextBar => {
|
|
(prev_beat / quantum).floor() as i64 != (curr_beat / quantum).floor() as i64
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Return the beat positions of all substeps in the window [frontier, end).
|
|
/// Each entry is the exact beat at which that substep fires.
|
|
/// Clamped to 64 results max to prevent runaway.
|
|
pub fn substeps_in_window(frontier: f64, end: f64, speed: f64) -> Vec<f64> {
|
|
if frontier < 0.0 || end <= frontier || speed <= 0.0 {
|
|
return Vec::new();
|
|
}
|
|
let substeps_per_beat = 4.0 * speed;
|
|
let first = (frontier * substeps_per_beat).floor() as i64 + 1;
|
|
let last = (end * substeps_per_beat).floor() as i64;
|
|
let count = (last - first + 1).clamp(0, 64) as usize;
|
|
let mut result = Vec::with_capacity(count);
|
|
for i in 0..count as i64 {
|
|
result.push((first + i) as f64 / substeps_per_beat);
|
|
}
|
|
result
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn beats_to_micros(beats: f64, tempo: f64) -> SyncTime {
|
|
if tempo <= 0.0 {
|
|
return 0;
|
|
}
|
|
((beats / tempo) * 60_000_000.0).round() as SyncTime
|
|
}
|
|
|
|
fn substeps_crossed(prev_beat: f64, curr_beat: f64, speed: f64) -> usize {
|
|
if prev_beat < 0.0 {
|
|
return 0;
|
|
}
|
|
let prev_substep = (prev_beat * 4.0 * speed).floor() as i64;
|
|
let curr_substep = (curr_beat * 4.0 * speed).floor() as i64;
|
|
(curr_substep - prev_substep).clamp(0, 16) as usize
|
|
}
|
|
|
|
fn micros_until_next_substep(current_beat: f64, speed: f64, tempo: f64) -> SyncTime {
|
|
if tempo <= 0.0 || speed <= 0.0 {
|
|
return 0;
|
|
}
|
|
let substeps_per_beat = 4.0 * speed;
|
|
let current_substep = (current_beat * substeps_per_beat).floor();
|
|
let next_substep_beat = (current_substep + 1.0) / substeps_per_beat;
|
|
let beats_until = next_substep_beat - current_beat;
|
|
beats_to_micros(beats_until, tempo)
|
|
}
|
|
|
|
#[test]
|
|
fn test_beats_to_micros_at_120_bpm() {
|
|
// At 120 BPM, one beat = 0.5 seconds = 500,000 microseconds
|
|
assert_eq!(beats_to_micros(1.0, 120.0), 500_000);
|
|
assert_eq!(beats_to_micros(2.0, 120.0), 1_000_000);
|
|
assert_eq!(beats_to_micros(0.5, 120.0), 250_000);
|
|
}
|
|
|
|
#[test]
|
|
fn test_zero_tempo() {
|
|
assert_eq!(beats_to_micros(1.0, 0.0), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_step_timing_beat_crossed() {
|
|
// Crossing from beat 0 to beat 1
|
|
assert!(StepTiming::NextBeat.crossed(0.9, 1.1, 4.0));
|
|
// Not crossing (both in same beat)
|
|
assert!(!StepTiming::NextBeat.crossed(0.5, 0.9, 4.0));
|
|
// Negative prev_beat returns false
|
|
assert!(!StepTiming::NextBeat.crossed(-1.0, 1.0, 4.0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_step_timing_bar_crossed() {
|
|
// Crossing from bar 0 to bar 1 (quantum=4)
|
|
assert!(StepTiming::NextBar.crossed(3.9, 4.1, 4.0));
|
|
// Not crossing (both in same bar)
|
|
assert!(!StepTiming::NextBar.crossed(2.0, 3.0, 4.0));
|
|
// Crossing with different quantum
|
|
assert!(StepTiming::NextBar.crossed(7.9, 8.1, 8.0));
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_crossed_normal() {
|
|
// One substep crossed at 1x speed
|
|
assert_eq!(substeps_crossed(0.0, 0.26, 1.0), 1);
|
|
// Two substeps crossed
|
|
assert_eq!(substeps_crossed(0.0, 0.51, 1.0), 2);
|
|
// No substep crossed
|
|
assert_eq!(substeps_crossed(0.1, 0.2, 1.0), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_crossed_with_speed() {
|
|
// At 2x speed, 0.5 beats = 4 substeps
|
|
assert_eq!(substeps_crossed(0.0, 0.5, 2.0), 4);
|
|
// At 0.5x speed, 0.5 beats = 1 substep
|
|
assert_eq!(substeps_crossed(0.0, 0.5, 0.5), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_crossed_negative_prev() {
|
|
// Negative prev_beat returns 0
|
|
assert_eq!(substeps_crossed(-1.0, 0.5, 1.0), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_crossed_clamp() {
|
|
// Large jump clamped to 16
|
|
assert_eq!(substeps_crossed(0.0, 100.0, 1.0), 16);
|
|
}
|
|
|
|
#[test]
|
|
fn test_micros_until_next_substep_at_beat_zero() {
|
|
// At beat 0.0, speed 1.0, tempo 120 BPM
|
|
// Next substep is at beat 0.25 (1/4 beat)
|
|
// 1/4 beat at 120 BPM = 0.25 / 120 * 60_000_000 = 125_000 μs
|
|
let micros = micros_until_next_substep(0.0, 1.0, 120.0);
|
|
assert_eq!(micros, 125_000);
|
|
}
|
|
|
|
#[test]
|
|
fn test_micros_until_next_substep_near_boundary() {
|
|
// At beat 0.24, almost at the substep boundary (0.25)
|
|
// Next substep at 0.25, so 0.01 beats away
|
|
let micros = micros_until_next_substep(0.24, 1.0, 120.0);
|
|
// 0.01 beats at 120 BPM = 5000 μs
|
|
assert_eq!(micros, 5000);
|
|
}
|
|
|
|
#[test]
|
|
fn test_micros_until_next_substep_with_speed() {
|
|
// At 2x speed, substeps are at 0.125, 0.25, 0.375...
|
|
// At beat 0.0, next substep is at 0.125
|
|
let micros = micros_until_next_substep(0.0, 2.0, 120.0);
|
|
// 0.125 beats at 120 BPM = 62_500 μs
|
|
assert_eq!(micros, 62_500);
|
|
}
|
|
|
|
#[test]
|
|
fn test_micros_until_next_substep_zero_tempo() {
|
|
assert_eq!(micros_until_next_substep(0.0, 1.0, 0.0), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_micros_until_next_substep_zero_speed() {
|
|
assert_eq!(micros_until_next_substep(0.0, 0.0, 120.0), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_in_window_basic() {
|
|
// At 1x speed, substeps at 0.25, 0.5, 0.75, 1.0...
|
|
// Window [0.0, 0.5) should contain 0.25 and 0.5
|
|
let result = substeps_in_window(0.0, 0.5, 1.0);
|
|
assert_eq!(result, vec![0.25, 0.5]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_in_window_2x_speed() {
|
|
// At 2x speed, substeps at 0.125, 0.25, 0.375, 0.5...
|
|
// Window [0.0, 0.5) should contain 4 substeps
|
|
let result = substeps_in_window(0.0, 0.5, 2.0);
|
|
assert_eq!(result, vec![0.125, 0.25, 0.375, 0.5]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_in_window_mid_beat() {
|
|
// Window [0.3, 0.6): should contain 0.5
|
|
let result = substeps_in_window(0.3, 0.6, 1.0);
|
|
assert_eq!(result, vec![0.5]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_in_window_empty() {
|
|
// Window too small to contain any substep
|
|
let result = substeps_in_window(0.1, 0.2, 1.0);
|
|
assert!(result.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_substeps_in_window_negative_frontier() {
|
|
let result = substeps_in_window(-1.0, 0.5, 1.0);
|
|
assert!(result.is_empty());
|
|
}
|
|
}
|