diff --git a/source/funkin/backend/utils/AudioAnalyzer.hx b/source/funkin/backend/utils/AudioAnalyzer.hx
index 6364a0ee..0ad9af3d 100644
--- a/source/funkin/backend/utils/AudioAnalyzer.hx
+++ b/source/funkin/backend/utils/AudioAnalyzer.hx
@@ -12,6 +12,7 @@ import lime.utils.ArrayBuffer;
 // ORIGINAL CODES FROM YOSH & LUNAR https://github.com/CodenameCrew/YoshiCrafterEngine/blob/main/source/WaveformSprite.hx
 // REWRITTEN BY RALTYRO
 class AudioAnalyzer {
+	public var sound:FlxSound;
 	public var buffer:AudioBuffer;
 	var __toBits:Float;
 	var __wordSize:Int;
@@ -23,18 +24,19 @@ class AudioAnalyzer {
 	#end
 
 	public function new(sound:FlxSound) {
-		buffer = sound.buffer;
+		this.sound = sound;
+		__check();
+	}
 
+	inline function __check() if (sound.buffer != buffer) {
+		__bitSize = 1 << ((buffer = sound.buffer).bitsPerSample - 1);
 		__bitUnsignedSize = 1 << buffer.bitsPerSample;
-		__bitSize = 1 << (buffer.bitsPerSample - 1);
 		__toBits = buffer.sampleRate / 1000 * buffer.channels * (__wordSize = buffer.bitsPerSample >> 3);
-
-		#if lime_vorbis
-		__prepareVorbis();
-		#end
+		__vorbis = null;
 	}
 
 	public function analyze(startPos:Float, endPos:Float, ?outSeperate:Array<Float>):Float {
+		__check();
 		if (buffer.data != null) return __analyze(startPos, endPos, outSeperate);
 		#if lime_vorbis
 		else if (__prepareVorbis()) return __analyzeVorbis(startPos, endPos, outSeperate);
@@ -56,7 +58,7 @@ class AudioAnalyzer {
 
 		while (pos < end) {
 			// 8-bit audio data is unsigned (0 is 128, 128 is 256, -128 is 0)
-			if (__wordSize == 1) b = #if js buf[pos] #else buf.get(pos) #end - __bitSize;
+			if (__wordSize == 1) b = #if js buf[pos++] #else buf.get(pos++) #end - __bitSize;
 			else {
 				while (w < buffer.bitsPerSample) {
 					b |= #if js buf[pos] #else buf.get(pos) #end << w;
@@ -78,43 +80,88 @@ class AudioAnalyzer {
 
 	#if lime_vorbis // As far i know, only native supports vorbis
 	var __buffer:ArrayBuffer;
+	var __bufferSize:Int;
 	function __prepareVorbis():Bool @:privateAccess {
 		if (buffer.__srcVorbisFile == null) return __vorbis != null;
 		if (__vorbis != null) return true;
 		if ((__vorbis = buffer.__srcVorbisFile.clone()) != null) { // IM HOPING IT HAVE A GC CLOSURE.
-			__buffer = new ArrayBuffer(0x400 * buffer.channels * (buffer.bitsPerSample >> 3));
+			__buffer = new ArrayBuffer(__bufferSize = 0x400 * buffer.channels * (buffer.bitsPerSample >> 3));
 			return true;
 		}
 		return false;
 	}
 
-	var prevPos:Int = 0;
-	inline function __analyzeVorbis(startPos:Float, endPos:Float, ?outSeperate:Array<Float>):Float {
+	inline function __analyzeVorbis(startPos:Float, endPos:Float, ?outSeperate:Array<Float>):Float @:privateAccess {
 		var n = Math.floor((endPos - startPos) * __toBits);
-		if (n < __wordSize) return 0;
+		if ((n -= n % __wordSize) < __wordSize) return 0;
 
-		n -= n % __wordSize;
-
-		if (prevPos != Math.floor(startPos)) {
-			__vorbis.timeSeek(startPos / 1000);
-			prevPos = Math.floor(endPos);
-		}
-
-		var isBigEndian = lime.system.System.endianness == lime.system.Endian.BIG_ENDIAN, bufferSize = __buffer.length;
-		var max = 0, b = 0, c = 0, useSeperate = outSeperate != null, pos = 0, w = 0, result;
+		var pos = 0, max = 0, b = 0, w = 0, c = 0, useSeperate = outSeperate != null;
 		if (useSeperate) {
 			while (c < outSeperate.length) outSeperate[c++] *= __bitSize;
 			while (c++ < buffer.channels) outSeperate.push(0);
-			c = 0;
 		}
+
+		// IT SHOULD BE ALWAYS BACKEND.STREAMED IF THIS GETS CALLED.
+		var backend = sound._source != null ? sound._source.__backend : null;
+		if (backend != null && backend.streamTimer != null) {
+			var i = backend.bufferSizes.length - backend.queuedBuffers;
+			var time = backend.bufferTimes[i] * 1000;
+
+			if (startPos >= time && startPos < backend.bufferTimes[backend.bufferSizes.length - 1] * 1000) {
+				var buf = backend.bufferDatas[i].buffer, size = backend.bufferSizes[i];
+				pos = Math.floor((startPos - time) * __toBits);
+				c = Math.floor((pos % (__wordSize * buffer.channels)) / __wordSize);
+				pos -= pos % __wordSize;
+
+				while (n > 0) {
+					if (__wordSize == 1) {
+						b = buf.get(pos++) - __bitSize;
+						n--;
+					}
+					else {
+						while (w < buffer.bitsPerSample) {
+							b |= buf.get(pos) << w;
+							w += 8;
+							pos++;
+							n--;
+						}
+						if (b > __bitSize) b -= __bitUnsignedSize;
+					}
+					if (max < b) max = b;
+					if (useSeperate) {
+						if (outSeperate[c] < b) outSeperate[c] = b;
+						if (++c > buffer.channels) c = 0;
+					}
+					if (pos >= size) {
+						if (++i >= backend.bufferDatas.length) break;
+						size = backend.bufferSizes[i];
+						buf = backend.bufferDatas[i].buffer;
+						pos = 0;
+					}
+					w = b = 0;
+				}
+
+				startPos = pos / __toBits + time;
+				// Cannot inline a not final return
+			}
+		}
+		if (n == 0) return max / __bitSize;
+
+		if (Math.abs(startPos - __vorbis.timeTell() * 1000) > 4) {
+			if (startPos < 1) __vorbis.rawSeek(0);
+			else __vorbis.timeSeek(startPos / 1000);
+		}
+
+		pos = c = 0;
+		var isBigEndian = lime.system.System.endianness == lime.system.Endian.BIG_ENDIAN, result;
 		while (n > 0) {
-			n -= (result = __vorbis.read(__buffer, 0, n < bufferSize ? n : bufferSize, isBigEndian, __wordSize, true));
+			n -= (result = __vorbis.read(__buffer, 0, n < __bufferSize ? n : __bufferSize, isBigEndian, __wordSize, true));
 
 			if (result == Vorbis.HOLE) continue;
 			else if (result <= 0) break;
 
 			while (pos < result) {
-				if (__wordSize == 1) b = __buffer.get(pos) - __bitSize;
+				if (__wordSize == 1) b = __buffer.get(pos++) - __bitSize;
 				else {
 					while (w < buffer.bitsPerSample) {
 						b |= __buffer.get(pos) << w;
diff --git a/source/openfl/media/SoundChannel.hx b/source/openfl/media/SoundChannel.hx
index 9de0928e..6ccbf8ac 100644
--- a/source/openfl/media/SoundChannel.hx
+++ b/source/openfl/media/SoundChannel.hx
@@ -8,8 +8,6 @@ import openfl.events.EventDispatcher;
 #if lime
 import lime.media.AudioSource;
 import lime.media.openal.AL;
-
-#if lime_cffi import lime._internal.backend.native.NativeAudioSource; #end
 #end
 
 /**
@@ -157,28 +155,32 @@ import lime.media.openal.AL;
 
 		__lastPeakTime = time;
 		__leftPeak = __rightPeak = 0;
-		#if (lime_cffi && !macro)
+
+		#if !macro
 		if (!__isValid) return false;
 
-		var backend = __source.__backend, buffer = __source.buffer;
+		var buffer = __source.buffer;
 		var wordSize = buffer.bitsPerSample >> 3, bitUnsignedSize = 1 << buffer.bitsPerSample, bitSize = 1 << (buffer.bitsPerSample - 1);
-		var pos = Math.floor(time * buffer.sampleRate / 1000 * buffer.channels * wordSize), size = 0, i = 0, buf;
+		var pos = Math.floor(time * buffer.sampleRate / 1000 * buffer.channels * wordSize), size = 0, buf;
 
+		#if lime_cffi
+		var backend = __source.__backend, i = 0;
 		if (backend.streamed) {
-			buf = backend.bufferDatas[i = NativeAudioSource.STREAM_MAX_BUFFERS - backend.queuedBuffers] #if !js .buffer #end;
-			size = backend.bufferSize;
+			size = backend.bufferSizes[i = backend.bufferSizes.length - backend.queuedBuffers];
+			buf = backend.bufferDatas[i].buffer;
 			pos -= Math.floor(backend.bufferTimes[i] * buffer.sampleRate * buffer.channels * wordSize);
 		}
-		else {
+		else
+		#end {
 			buf = buffer.data #if !js .buffer #end;
 			size = #if js buf.byteLength #else buf.length #end;
 		}
 
-		var n = Math.floor(Math.min(buffer.sampleRate / 80, 512)), c = Math.floor((pos % (wordSize * buffer.channels)) / wordSize), b = 0, w = 0;
+		var s = Math.floor(Math.min(buffer.sampleRate / 80, 512)), c = Math.floor((pos % (wordSize * buffer.channels)) / wordSize), b = 0, w = 0;
 		pos -= pos % wordSize;
 
-		while (n > 0) {
-			if (wordSize == 1) b = #if js buf[pos] #else buf.get(pos) #end - bitSize;
+		while (s > 0) {
+			if (wordSize == 1) b = #if js buf[pos++] #else buf.get(pos++) #end - bitSize;
 			else {
 				while (w < buffer.bitsPerSample) {
 					b |= #if js buf[pos] #else buf.get(pos) #end << w;
@@ -189,15 +191,17 @@ import lime.media.openal.AL;
 			}
 			((c % 2 == 0) ? (if (__leftPeak < b) __leftPeak = b) : (if (__rightPeak < b) __rightPeak = b));
 
-			if (pos >= size) {
+			if (pos >= size) #if lime_cffi {
 				if (!backend.streamed || ++i >= backend.bufferDatas.length) break;
-				buf = backend.bufferDatas[i] #if !js .buffer #end;
+				size = backend.bufferSizes[i];
+				buf = backend.bufferDatas[i].buffer;
 				pos = 0;
 			}
+			#else break; #end
 
 			if (++c > buffer.channels) {
 				c = 0;
-				n--;
+				s--;
 			}
 			w = b = 0;
 		}