WIP: better precision?

src/main.rs

@@ -12,7 +12,7 @@ mod widgets;
 
 use std::io;
 use std::path::PathBuf;
-use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU32, AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -28,7 +28,8 @@ use ratatui::Terminal;
 
 use app::App;
 use engine::{
-    build_stream, spawn_sequencer, AudioStreamConfig, LinkState, ScopeBuffer, SpectrumBuffer,
+    build_stream, spawn_sequencer, AudioStreamConfig, LinkState, ScopeBuffer, SequencerConfig,
+    SpectrumBuffer,
 };
 use input::{handle_key, InputContext, InputResult};
 use settings::Settings;
@@ -88,6 +89,7 @@ fn main() -> io::Result<()> {
     app.audio.config.channels = args.channels.unwrap_or(settings.audio.channels);
     app.audio.config.buffer_size = args.buffer.unwrap_or(settings.audio.buffer_size);
     app.audio.config.max_voices = settings.audio.max_voices;
+    app.audio.config.lookahead_ms = settings.audio.lookahead_ms;
     app.audio.config.sample_paths = args.samples;
     app.audio.config.refresh_rate = RefreshRate::from_fps(settings.display.fps);
     app.ui.runtime_highlight = settings.display.runtime_highlight;
@@ -100,6 +102,10 @@ fn main() -> io::Result<()> {
     let scope_buffer = Arc::new(ScopeBuffer::new());
     let spectrum_buffer = Arc::new(SpectrumBuffer::new());
 
+    let audio_sample_pos = Arc::new(AtomicU64::new(0));
+    let sample_rate_shared = Arc::new(AtomicU32::new(44100));
+    let lookahead_ms = Arc::new(AtomicU32::new(settings.audio.lookahead_ms));
+
     let mut initial_samples = Vec::new();
     for path in &app.audio.config.sample_paths {
         let index = doux::loader::scan_samples_dir(path);
@@ -107,6 +113,12 @@ fn main() -> io::Result<()> {
         initial_samples.extend(index);
     }
 
+    let seq_config = SequencerConfig {
+        audio_sample_pos: Arc::clone(&audio_sample_pos),
+        sample_rate: Arc::clone(&sample_rate_shared),
+        lookahead_ms: Arc::clone(&lookahead_ms),
+    };
+
     let (sequencer, initial_audio_rx) = spawn_sequencer(
         Arc::clone(&link),
         Arc::clone(&playing),
@@ -116,6 +128,7 @@ fn main() -> io::Result<()> {
         settings.link.quantum,
         Arc::clone(&app.live_keys),
         Arc::clone(&nudge_us),
+        seq_config,
     );
 
     let stream_config = AudioStreamConfig {
@@ -132,9 +145,11 @@ fn main() -> io::Result<()> {
         Arc::clone(&spectrum_buffer),
         Arc::clone(&metrics),
         initial_samples,
+        Arc::clone(&audio_sample_pos),
     ) {
         Ok((s, sample_rate, analysis)) => {
             app.audio.config.sample_rate = sample_rate;
+            sample_rate_shared.store(sample_rate as u32, Ordering::Relaxed);
             (Some(s), Some(analysis))
         }
         Err(e) => {
@@ -174,6 +189,8 @@ fn main() -> io::Result<()> {
             }
             app.audio.config.sample_count = restart_samples.len();
 
+            audio_sample_pos.store(0, Ordering::Relaxed);
+
             match build_stream(
                 &new_config,
                 new_audio_rx,
@@ -181,11 +198,13 @@ fn main() -> io::Result<()> {
                 Arc::clone(&spectrum_buffer),
                 Arc::clone(&metrics),
                 restart_samples,
+                Arc::clone(&audio_sample_pos),
             ) {
                 Ok((new_stream, sr, new_analysis)) => {
                     _stream = Some(new_stream);
                     _analysis_handle = Some(new_analysis);
                     app.audio.config.sample_rate = sr;
+                    sample_rate_shared.store(sr as u32, Ordering::Relaxed);
                     app.audio.error = None;
                     app.ui.set_status("Audio restarted".to_string());
                 }
@@ -241,6 +260,7 @@ fn main() -> io::Result<()> {
                         audio_tx: &sequencer.audio_tx,
                         seq_cmd_tx: &sequencer.cmd_tx,
                         nudge_us: &nudge_us,
+                        lookahead_ms: &lookahead_ms,
                     };
 
                     if let InputResult::Quit = handle_key(&mut ctx, key) {