Actually fix seeking in audio pipeline

Thanks to claude.ai that knew what the fuck it was doing.

Edit: Nevermind. It was my flawed code. I didn't even need to waste server power consumption using claude. I had already figured it out myself, which was directly in the `Mixer.setTime` function.

I will now be reverting the claude.ai generated "fixes" that I've tried.

Author: SomeGuyWhoLovesCoding

src/debug/DeveloperStuff.hx

@@ -20,9 +20,11 @@ class DeveloperStuff {
 		if (playField == null) return;
 		switch (code) {
 			case KeyCode.PERIOD:
-				playField.setTime(playField.songPosition + 2000);
+				playField.setTime(playField.songPosition + 200);
 			case KeyCode.COMMA:
-				playField.setTime(playField.songPosition - 2000);
+				playField.setTime(playField.songPosition - 200);
+			case KeyCode.S:
+				playField.setTime(2200);
 			case KeyCode.NUMBER_9:
 				if (playField.songStarted)
 					Mixer.speed -= 0.25;

src/miniaudio/extras/stb_vorbis.c

@@ -4879,39 +4879,82 @@ static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int
 
 int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)
 {
+   //printf("move to %i test\n", sample_number);
    uint32 max_frame_samples;
+   uint32 remaining;
 
    if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
 
-   // fast page-level search
    if (!seek_to_sample_coarse(f, sample_number))
       return 0;
 
    assert(f->current_loc_valid);
    assert(f->current_loc <= sample_number);
 
-   // linear search for the relevant packet
+   // OPTIMIZATION 1: Early exit if already at target
+   if (f->current_loc == sample_number)
+      return 1;
+
    max_frame_samples = (f->blocksize_1*3 - f->blocksize_0) >> 2;
+   remaining = sample_number - f->current_loc;
+
+   // OPTIMIZATION 2: Skip full frames quickly
+   while (remaining > max_frame_samples * 2) {
+      int mode;
+      int left_start, left_end, right_start, right_end;
+      
+      // Save bit reader state
+      int saved_valid_bits = f->valid_bits;
+      uint32 saved_acc = f->acc;
+      int saved_packet_bytes = f->packet_bytes;
+      
+      if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode)) {
+         // Restore and continue with normal path
+         f->valid_bits = saved_valid_bits;
+         f->acc = saved_acc;
+         f->packet_bytes = saved_packet_bytes;
+         break;
+      }
+      
+      int frame_samples = right_start - left_start;
+      
+      // Check if it's a full frame we can skip
+      if (frame_samples == max_frame_samples) {
+         // Skip this full frame
+         f->current_loc += frame_samples;
+         f->previous_length = 0;
+         maybe_start_packet(f);
+         flush_packet(f);
+         remaining = sample_number - f->current_loc;
+      } else {
+         // Not a full frame, restore and use normal path
+         f->valid_bits = saved_valid_bits;
+         f->acc = saved_acc;
+         f->packet_bytes = saved_packet_bytes;
+         break;
+      }
+   }
+
+   // Original algorithm for remaining frames
    while (f->current_loc < sample_number) {
       int left_start, left_end, right_start, right_end, mode, frame_samples;
       if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode))
          return error(f, VORBIS_seek_failed);
-      // calculate the number of samples returned by the next frame
+      
       frame_samples = right_start - left_start;
+      
       if (f->current_loc + frame_samples > sample_number) {
-         return 1; // the next frame will contain the sample
+         return 1;
       } else if (f->current_loc + frame_samples + max_frame_samples > sample_number) {
-         // there's a chance the frame after this could contain the sample
          vorbis_pump_first_frame(f);
       } else {
-         // this frame is too early to be relevant
          f->current_loc += frame_samples;
          f->previous_length = 0;
          maybe_start_packet(f);
          flush_packet(f);
       }
    }
-   // the next frame should start with the sample
+   
    if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed);
    return 1;
 }

src/miniaudio/ma_thing.cpp

@@ -204,10 +204,12 @@ struct DecoderStream {
     float* loadingBuffer = nullptr;
 
     // Audio thread state (only touched by audio thread)
-    ma_uint64 filePosition = 0;
+    std::atomic<ma_uint64> filePosition{0};
     ma_uint64 bufferStartPos = 0;
     ma_uint64 localReadPos = 0;
     ma_uint64 validFrames = 0;
+
+    bool justSeeked = false;
 
     // Async loading state (atomic for lock-free access)
     struct AsyncState {
@@ -330,7 +332,7 @@ struct DecoderStream {
     }
 
     // Reset state
-    void resetState() {
+    void resetState(bool seeking = false) {
         // Reset atomic flags
         asyncState.nextBufferReady.store(false, std::memory_order_release);
         asyncState.loadingBufferReady.store(false, std::memory_order_release);
@@ -339,15 +341,17 @@ struct DecoderStream {
         asyncState.requestNextBuffer.store(false, std::memory_order_release);
         asyncState.requestLoadingBuffer.store(false, std::memory_order_release);
 
-        asyncState.nextBufferValidFrames = 0;
-        asyncState.loadingBufferValidFrames = 0;
-        asyncState.nextBufferStartPos = 0;
-        asyncState.loadingBufferStartPos = 0;
-        
-        filePosition = 0;
-        bufferStartPos = 0;
-        localReadPos = 0;
-        validFrames = 0;
+        if (!seeking) {
+            asyncState.nextBufferValidFrames = 0;
+            asyncState.loadingBufferValidFrames = 0;
+            asyncState.nextBufferStartPos = 0;
+            asyncState.loadingBufferStartPos = 0;
+            
+            filePosition.store(0, std::memory_order_relaxed);
+            bufferStartPos = 0;
+            localReadPos = 0;
+            validFrames = 0;
+        }
 
         if (pcmBufferA) memset(pcmBufferA, 0, TOTAL_BUFFER_FRAMES * CHANNEL_COUNT * sizeof(float));
         if (pcmBufferB) memset(pcmBufferB, 0, TOTAL_BUFFER_FRAMES * CHANNEL_COUNT * sizeof(float));
@@ -462,7 +466,7 @@ struct DecoderStream {
         memcpy(&decoder, &other.decoder, sizeof(ma_decoder));
 
         // Move regular members
-        filePosition = other.filePosition;
+        filePosition.store(other.filePosition, std::memory_order_relaxed);
         bufferStartPos = other.bufferStartPos;
         localReadPos = other.localReadPos;
         validFrames = other.validFrames;
@@ -965,7 +969,6 @@ class AudioSystem {
     void seekToPCMFrame(int64_t pos) {
         if(!exists) return;
 
-        // Pause async loading during seek
         if (asyncLoader) {
             asyncLoader->pauseLoading();
         }
@@ -978,20 +981,24 @@ class AudioSystem {
         for (size_t i = 0; i < streams.size(); i++) {
             DecoderStream& s = streams[i];
 
-            // Seek to the exact position requested
-            ma_uint64 target = std::min<ma_uint64>(
-                (ma_uint64)std::max<int64_t>(pos, (int64_t)0), 
-                s.decoderLength
-            );
+            ma_uint64 target = pos;
+
+            printf("SEEKING TO TARGET: %lld\n", (long long)target);
+            printf("  Before seek - filePos: %lld, bufferStart: %lld, localRead: %lld\n", 
+                (long long)s.filePosition, (long long)s.bufferStartPos, (long long)s.localReadPos);
 
-            s.resetState();
+            s.resetState(true);
+            s.justSeeked = true;
             fillInitialBuffer(i, target);
 
-            if (s.active && target < s.decoderLength) {
-                s.filePosition = target;
-            }
+            printf("  After seek - filePos: %lld, bufferStart: %lld, localRead: %lld\n",
+                (long long)s.filePosition, (long long)s.bufferStartPos, (long long)s.localReadPos);
+            
+            // Verify the math
+            ma_uint64 calculatedFilePos = s.bufferStartPos + s.localReadPos;
+            printf("  Calculated filePos should be: %lld (matches: %s)\n",
+                (long long)calculatedFilePos, (calculatedFilePos == s.filePosition) ? "YES" : "NO");
 
-            // Aggressively preload both buffers synchronously
             if (s.active) {
                 loadNextBufferSync(i);
                 if (s.asyncState.nextBufferReady.load(std::memory_order_relaxed)) {
@@ -1003,7 +1010,6 @@ class AudioSystem {
         mixerState = (pos < (int64_t)streams[longestDecoderIndex].decoderLength) ? 2 : 3;
 
         if (wasPlaying && mixerState == 2) {
-            // Resume async loading before starting playback
             if (asyncLoader) {
                 asyncLoader->resumeLoading();
             }
@@ -1059,6 +1065,7 @@ class AudioSystem {
     void fillInitialBuffer(size_t index, ma_uint64 startFrame) {
         DecoderStream& s = streams[index];
 
+        // Calculate where to start decoding (with padding before the target)
         ma_uint64 decodeStart = 0;
         if(startFrame > PADDING_FRAMES) {
             decodeStart = startFrame - PADDING_FRAMES;
@@ -1070,18 +1077,28 @@ class AudioSystem {
         s.bufferStartPos = decodeStart;
         s.validFrames = framesRead;
 
-        if(startFrame >= decodeStart) {
+        // Calculate the local read position within this buffer
+        if(startFrame >= decodeStart && startFrame < decodeStart + framesRead) {
             s.localReadPos = startFrame - decodeStart;
-        } else {
+        } else if(startFrame < decodeStart) {
             s.localReadPos = 0;
+        } else {
+            // startFrame is beyond what we loaded
+            s.localReadPos = framesRead;
         }
 
+        // Ensure localReadPos is within bounds
         if(s.localReadPos >= TOTAL_BUFFER_FRAMES) {
             s.localReadPos = TOTAL_BUFFER_FRAMES - 1;
         }
 
-        s.filePosition = startFrame;
-        s.active = (startFrame < s.decoderLength && framesRead > 0);
+        // Set filePosition to the ACTUAL position we'll start reading from
+        // This is critical - it should be bufferStart + localReadPos
+        //printf("before? %lld\n", s.filePosition);
+        s.filePosition.store(s.bufferStartPos + s.localReadPos, std::memory_order_relaxed);
+        //printf("after? %lld\n", s.filePosition);
+        
+        s.active = (s.filePosition < s.decoderLength && framesRead > 0);
         s.asyncState.needsLoad.store(false, std::memory_order_release);
     }
 
@@ -1093,6 +1110,7 @@ class AudioSystem {
             return;
         }
 
+        // Calculate next buffer start from CURRENT buffer position, not file position
         ma_uint64 nextBufferStart = s.bufferStartPos + HALF_BUFFER_FRAMES;
         if (nextBufferStart > PADDING_FRAMES) {
             nextBufferStart -= PADDING_FRAMES;
@@ -1177,8 +1195,11 @@ class AudioSystem {
             return 0;
         }
 
-        if (s.shouldSwapBuffers() || s.isBufferLow()) {
-            s.trySwapBuffers();
+        // Don't swap buffers immediately after seeking
+        if (!s.justSeeked) {
+            if (s.shouldSwapBuffers() || s.isBufferLow()) {
+                s.trySwapBuffers();
+            }
         }
 
         ma_uint32 framesRead = 0;
@@ -1192,6 +1213,7 @@ class AudioSystem {
             if (available == 0) {
                 if (s.filePosition < s.decoderLength) {
                     if (s.asyncState.nextBufferReady.load(std::memory_order_acquire)) {
+                        s.justSeeked = false;  // Clear flag before swapping
                         s.trySwapBuffers();
                         continue;
                     } else {
@@ -1220,9 +1242,14 @@ class AudioSystem {
             }
 
             s.localReadPos += toRead;
-            s.filePosition += toRead;
+            s.filePosition.store(s.filePosition.load(std::memory_order_relaxed) + toRead, std::memory_order_relaxed);
             framesRead += toRead;
 
+            // Clear the justSeeked flag after first successful read
+            if (framesRead > 0) {
+                s.justSeeked = false;
+            }
+            
             if (s.filePosition >= s.decoderLength) {
                 s.active = false;
                 break;

src/structures/gameplay/PlayField.hx

@@ -261,6 +261,7 @@ class PlayField implements State {
 
 		if (!died) {
 			Mixer.update(this, deltaTime);
+			Sys.println(songPosition);
 
 			#if !FV_LIME_FORK
 			// If the song hasn't started yet, update the countdown conductor only.