Now here comes the real fix

Author: SomeGuyWhoLovesCoding

hdlls/windows/ma_thing.hdll

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

src/debug/DeveloperStuff.hx

@@ -204,12 +204,10 @@ struct DecoderStream {
     float* loadingBuffer = nullptr;
 
     // Audio thread state (only touched by audio thread)
-    std::atomic<ma_uint64> filePosition{0};
+    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 {
@@ -332,7 +330,7 @@ struct DecoderStream {
     }
 
     // Reset state
-    void resetState(bool seeking = false) {
+    void resetState() {
         // Reset atomic flags
         asyncState.nextBufferReady.store(false, std::memory_order_release);
         asyncState.loadingBufferReady.store(false, std::memory_order_release);
@@ -341,17 +339,15 @@ struct DecoderStream {
         asyncState.requestNextBuffer.store(false, std::memory_order_release);
         asyncState.requestLoadingBuffer.store(false, std::memory_order_release);
 
-        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;
-        }
+        asyncState.nextBufferValidFrames = 0;
+        asyncState.loadingBufferValidFrames = 0;
+        asyncState.nextBufferStartPos = 0;
+        asyncState.loadingBufferStartPos = 0;
+        
+        filePosition = 0;
+        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));
@@ -466,7 +462,7 @@ struct DecoderStream {
         memcpy(&decoder, &other.decoder, sizeof(ma_decoder));
 
         // Move regular members
-        filePosition.store(other.filePosition, std::memory_order_relaxed);
+        filePosition = other.filePosition;
         bufferStartPos = other.bufferStartPos;
         localReadPos = other.localReadPos;
         validFrames = other.validFrames;
@@ -783,9 +779,12 @@ class AudioSystem {
             s.asyncState.asyncLoadingBuffer = s.pcmBufferC;
 
             // Store per-decoder latency
-            s.detectedLatency = detectLatency(i);
-            if (s.detectedLatency > detectedLatency) {
-                detectedLatency = s.detectedLatency;
+            // the inst starts first so yeah
+            if (i == 0) {
+                s.detectedLatency = detectLatency(i);
+                if (s.detectedLatency > detectedLatency) {
+                    detectedLatency = s.detectedLatency;
+                }
             }
 
             // Fill initial buffer (starts at 0)
@@ -969,6 +968,7 @@ class AudioSystem {
     void seekToPCMFrame(int64_t pos) {
         if(!exists) return;
 
+        // Pause async loading during seek
         if (asyncLoader) {
             asyncLoader->pauseLoading();
         }
@@ -981,24 +981,20 @@ class AudioSystem {
         for (size_t i = 0; i < streams.size(); i++) {
             DecoderStream& s = streams[i];
 
-            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);
+            // 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
+            );
 
-            s.resetState(true);
-            s.justSeeked = true;
+            s.resetState();
             fillInitialBuffer(i, 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");
+            if (s.active && target < s.decoderLength) {
+                s.filePosition = target;
+            }
 
+            // Aggressively preload both buffers synchronously
             if (s.active) {
                 loadNextBufferSync(i);
                 if (s.asyncState.nextBufferReady.load(std::memory_order_relaxed)) {
@@ -1010,6 +1006,7 @@ 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();
             }
@@ -1065,7 +1062,6 @@ 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;
@@ -1077,28 +1073,18 @@ class AudioSystem {
         s.bufferStartPos = decodeStart;
         s.validFrames = framesRead;
 
-        // Calculate the local read position within this buffer
-        if(startFrame >= decodeStart && startFrame < decodeStart + framesRead) {
+        if(startFrame >= decodeStart) {
             s.localReadPos = startFrame - decodeStart;
-        } else if(startFrame < decodeStart) {
-            s.localReadPos = 0;
         } else {
-            // startFrame is beyond what we loaded
-            s.localReadPos = framesRead;
+            s.localReadPos = 0;
         }
 
-        // Ensure localReadPos is within bounds
         if(s.localReadPos >= TOTAL_BUFFER_FRAMES) {
             s.localReadPos = TOTAL_BUFFER_FRAMES - 1;
         }
 
-        // 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.filePosition = startFrame;
+        s.active = (startFrame < s.decoderLength && framesRead > 0);
         s.asyncState.needsLoad.store(false, std::memory_order_release);
     }
 
@@ -1110,7 +1096,6 @@ 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;
@@ -1195,11 +1180,8 @@ class AudioSystem {
             return 0;
         }
 
-        // Don't swap buffers immediately after seeking
-        if (!s.justSeeked) {
-            if (s.shouldSwapBuffers() || s.isBufferLow()) {
-                s.trySwapBuffers();
-            }
+        if (s.shouldSwapBuffers() || s.isBufferLow()) {
+            s.trySwapBuffers();
         }
 
         ma_uint32 framesRead = 0;
@@ -1213,7 +1195,6 @@ 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 {
@@ -1242,14 +1223,9 @@ class AudioSystem {
             }
 
             s.localReadPos += toRead;
-            s.filePosition.store(s.filePosition.load(std::memory_order_relaxed) + toRead, std::memory_order_relaxed);
+            s.filePosition += toRead;
             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;
@@ -2150,7 +2126,7 @@ bool wearingPlugNPlay() {
 
 int detectLatency() {
 	#if HX_WINDOWS
-	int osMs = 56;
+	int osMs = 61;
 	#else
 	int osMs = 1;
 	#endif
@@ -2215,4 +2191,4 @@ float getMixerMasterVolume() {
 
 void destroyMixer() {
 	g_mixer.destroy();
-}
+}

src/miniaudio/ma_thing.cpp

@@ -2135,7 +2135,7 @@ HL_PRIM bool HL_NAME(wearingPlugNPlay)(_NO_ARG) {
 
 HL_PRIM int HL_NAME(detectLatency)(_NO_ARG) {
 	#if HX_WINDOWS
-	int osMs = 56;
+	int osMs = 61;
 	#else
 	int osMs = 1;
 	#endif

src/miniaudio/ma_thing_hl.cpp

@@ -85,7 +85,9 @@ class Mixer {
 	}
 
 	static function setTime(value:Float, playfield:PlayField) {
-		MiniAudio.seekToPCMFrame(Tools.betterInt64FromFloat(value * 0.001) * sampleRate);
+		var pcmFrame = Tools.betterInt64FromFloat(value * (sampleRate / 1000.0));
+		// Ah HAH! I found it! It's that
+		MiniAudio.seekToPCMFrame(pcmFrame);
 		if (playfield != null) {
 			if (playfield.songEnded) playfield.songPosition = MiniAudio.getPlaybackPosition();
 		}

src/music/Mixer.hx

@@ -241,6 +241,7 @@ class PlayField implements State {
 	/**
 		Updates the playfield.
 	**/
+	var lastsongpos:Float = 0;
 	function update(deltaTime:Float) {
 		if (disposed || paused) return;
 
@@ -261,7 +262,7 @@ class PlayField implements State {
 
 		if (!died) {
 			Mixer.update(this, deltaTime);
-			Sys.println(songPosition);
+			Sys.println('$songPosition' + (((lastsongpos - songPosition) > 50) ? " (CHANGE ALERT! CHANGE ALERT! CHANGE!)" : ""));
 
 			#if !FV_LIME_FORK
 			// If the song hasn't started yet, update the countdown conductor only.
@@ -298,6 +299,8 @@ class PlayField implements State {
 			songPosition += latencyCompensation;
 			songPosition += Mixer.latency();
 
+			lastsongpos = songPosition;
+
 			return;
 		}