1 files changed, 37 insertions, 14 deletions

diff --git a/src/audio/tracker.cc b/src/audio/tracker.cc
index 7ad5a67..1cccc57 100644
--- a/src/audio/tracker.cc
+++ b/src/audio/tracker.cc
@@ -172,7 +172,8 @@ static int get_free_pattern_slot() {
 }
 
 // Helper to trigger a single note event (OPTIMIZED with caching)
-static void trigger_note_event(const TrackerEvent& event) {
+// start_offset_samples: How many samples into the future to trigger (for sample-accurate timing)
+static void trigger_note_event(const TrackerEvent& event, int start_offset_samples) {
 #if defined(DEBUG_LOG_TRACKER)
   // VALIDATION: Check sample_id bounds
   if (event.sample_id >= g_tracker_samples_count) {
@@ -207,24 +208,29 @@ static void trigger_note_event(const TrackerEvent& event) {
     return;
   }
 
-  // Trigger voice directly with cached spectrogram
-  synth_trigger_voice(cached_synth_id, event.volume, event.pan);
+  // Trigger voice with sample-accurate offset
+  synth_trigger_voice(cached_synth_id, event.volume, event.pan, start_offset_samples);
 }
 
 void tracker_update(float music_time_sec) {
+  // Unit-less timing: 1 unit = 4 beats (by convention)
+  const float BEATS_PER_UNIT = 4.0f;
+  const float unit_duration_sec = (BEATS_PER_UNIT / g_tracker_score.bpm) * 60.0f;
+
   // Step 1: Process new pattern triggers
   while (g_last_trigger_idx < g_tracker_score.num_triggers) {
     const TrackerPatternTrigger& trigger =
         g_tracker_score.triggers[g_last_trigger_idx];
 
-    if (trigger.time_sec > music_time_sec)
+    const float trigger_time_sec = trigger.unit_time * unit_duration_sec;
+    if (trigger_time_sec > music_time_sec)
       break;
 
     // Add this pattern to active patterns list
     const int slot = get_free_pattern_slot();
     if (slot != -1) {
       g_active_patterns[slot].pattern_id = trigger.pattern_id;
-      g_active_patterns[slot].start_music_time = trigger.time_sec;
+      g_active_patterns[slot].start_music_time = trigger_time_sec;
       g_active_patterns[slot].next_event_idx = 0;
       g_active_patterns[slot].active = true;
     }
@@ -233,7 +239,10 @@ void tracker_update(float music_time_sec) {
   }
 
   // Step 2: Update all active patterns and trigger individual events
-  const float beat_duration = 60.0f / g_tracker_score.bpm;
+  // Get current audio RENDER position (write position) for sample-accurate timing
+  // This is where we're currently writing to the ring buffer (~400ms ahead of playback)
+  const float current_render_time = audio_get_render_time();
+  const float SAMPLE_RATE = 32000.0f; // Audio sample rate
 
   for (int i = 0; i < MAX_SPECTROGRAMS; ++i) {
     if (!g_active_patterns[i].active)
@@ -242,25 +251,39 @@ void tracker_update(float music_time_sec) {
     ActivePattern& active = g_active_patterns[i];
     const TrackerPattern& pattern = g_tracker_patterns[active.pattern_id];
 
-    // Calculate elapsed beats since pattern started
+    // Calculate elapsed unit-less time since pattern started
     const float elapsed_music_time = music_time_sec - active.start_music_time;
-    const float elapsed_beats = elapsed_music_time / beat_duration;
+    const float elapsed_units = elapsed_music_time / unit_duration_sec;
 
-    // Trigger all events that have passed their beat time
+    // Trigger all events that have passed their unit time
     while (active.next_event_idx < pattern.num_events) {
       const TrackerEvent& event = pattern.events[active.next_event_idx];
 
-      if (event.beat > elapsed_beats)
+      if (event.unit_time > elapsed_units)
         break; // This event hasn't reached its time yet
 
-      // Trigger this event as an individual voice
-      trigger_note_event(event);
+      // Calculate exact trigger time for this event
+      const float event_trigger_time = active.start_music_time +
+                                       (event.unit_time * unit_duration_sec);
+
+      // Calculate sample-accurate offset from current RENDER position (write pos)
+      // This is where we're currently writing to the buffer, not where playback is
+      const float time_delta = event_trigger_time - current_render_time;
+      int sample_offset = (int)(time_delta * SAMPLE_RATE);
+
+      // Clamp to 0 if negative (event is late, play immediately)
+      if (sample_offset < 0) {
+        sample_offset = 0;
+      }
+
+      // Trigger this event as an individual voice with sample-accurate timing
+      trigger_note_event(event, sample_offset);
 
       active.next_event_idx++;
     }
 
-    // If all events have been triggered, mark pattern as complete
-    if (active.next_event_idx >= pattern.num_events) {
+    // Pattern remains active until full duration elapses
+    if (elapsed_units >= pattern.unit_length) {
       active.active = false;
     }
   }