WIP: better precision?

src/engine/audio.rs

@@ -4,7 +4,7 @@ use crossbeam_channel::Receiver;
 use doux::{Engine, EngineMetrics};
 use ringbuf::{traits::*, HeapRb};
 use rustfft::{num_complex::Complex, FftPlanner};
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
 use std::sync::Arc;
 use std::thread::{self, JoinHandle};
 
@@ -225,6 +225,7 @@ pub fn build_stream(
     spectrum_buffer: Arc<SpectrumBuffer>,
     metrics: Arc<EngineMetrics>,
     initial_samples: Vec<doux::sample::SampleEntry>,
+    audio_sample_pos: Arc<AtomicU64>,
 ) -> Result<(Stream, f32, AnalysisHandle), String> {
     let host = cpal::default_host();
 
@@ -270,8 +271,12 @@ pub fn build_stream(
 
                 while let Ok(cmd) = audio_rx.try_recv() {
                     match cmd {
-                        AudioCommand::Evaluate(s) => {
-                            engine.evaluate(&s);
+                        AudioCommand::Evaluate { cmd, time } => {
+                            let cmd_with_time = match time {
+                                Some(t) => format!("{cmd}/time/{t:.6}"),
+                                None => cmd,
+                            };
+                            engine.evaluate(&cmd_with_time);
                         }
                         AudioCommand::Hush => {
                             engine.hush();
@@ -287,6 +292,7 @@ pub fn build_stream(
                             engine =
                                 Engine::new_with_metrics(sr, channels, max_voices, Arc::clone(&metrics_clone));
                             engine.sample_index = old_samples;
+                            audio_sample_pos.store(0, Ordering::Relaxed);
                         }
                     }
                 }
@@ -295,6 +301,8 @@ pub fn build_stream(
                 engine.process_block(data, &[], &[]);
                 scope_buffer.write(&engine.output);
 
+                audio_sample_pos.fetch_add(buffer_samples as u64, Ordering::Relaxed);
+
                 // Feed mono mix to analysis thread via ring buffer (non-blocking)
                 for chunk in engine.output.chunks(channels) {
                     let mono = chunk.iter().sum::<f32>() / channels as f32;