Update Audio Backend from Vs Camellia v2.75.1 (info at desc)

Before anyone asks why vs cam, the code is public, plus i helped most of the audio backend rewrite in the mod too. :P

- Static sounds can now also seamlessly loop with AL_SOFT_loop_points extension
- Panning stereo sounds is now possible with AL_EXT_STEREO_ANGLES extension (although this was already implemented before)
- Improved streaming sounds, should fix most of the lagspike issues
- Streaming sounds should no longer regenrate if it's in the nearest timestamp (not for reversing though)
! You still can't access FlxSound.latency because of the new procedures that's not available in lime

If there's any crashes with this pls report an issue asap.

Author: Raltyro

building/alsoft.txt

@@ -1,14 +1,17 @@
-[general]
+[General]
 sample-type=float32
 stereo-mode=speakers
-stereo-encoding=panpot
 hrtf=false
 cf_level=0
-resampler=fast_bsinc24
-front-stablizer=false
 output-limiter=false
+front-stabilizer=false
 volume-adjust=0
+period_size=441
+sources=512
+sends=64
+dither=false
+
 [decoder]
-hq-mode=false
-distance-comp=false
+hq-mode=true
+distance-comp=true
 nfc=false

source/flixel/sound/FlxSound.hx

@@ -718,7 +718,7 @@ class FlxSound extends FlxBasic {
 		_paused = false;
 		_time = startTime;
 		_lastTime = FlxG.game.getTicks();
-		if (_channel == null || !_channel.__isValid || _source == null #if lime_cffi || _source.__backend.disposed || _source.__backend.handle == null #end)
+		if (_channel == null || !_channel.__isValid || _source == null #if lime_cffi || _source.__backend.disposed #end)
 			makeChannel();
 
 		if (_channel != null) {
@@ -939,19 +939,19 @@ class FlxSound extends FlxBasic {
 		return _time = time;
 	}
 
-	inline function get_offset():Float return _offset;
-	inline function set_offset(offset:Float):Float {
+	function get_offset():Float return _offset;
+	function set_offset(offset:Float):Float {
 		if (_offset == (_offset = offset)) return offset;
 		//time = time + _offset;
 		return offset;
 	}
 
-	inline function get_length():Float return _length - _offset;
+	function get_length():Float return _length - _offset;
 
-	/*function get_latency():Float {
-		if (_channel != null) return _source.latency;
-		return 0;
-	}*/
+	//function get_latency():Float {
+	//	if (_channel != null) return _source.latency;
+	//	return 0;
+	//}
 
 	override function toString():String {
 		return FlxStringUtil.getDebugString([

source/funkin/backend/utils/AudioAnalyzer.hx

@@ -20,8 +20,7 @@ typedef AudioAnalyzerCallback = Int->Int->Void;
  * An utility that analyze FlxSounds,
  * can be used to make waveform or real-time audio visualizer.
  * 
- * FlxSound.amplitude does work in CNE so if any case if your only checking for peak of current
- * time, use that instead.
+ * FlxSound.amplitude works so if any case if your only checking for peak of current time, use that instead.
  */
 final class AudioAnalyzer {
 	/**
@@ -296,7 +295,7 @@ final class AudioAnalyzer {
 		__check();
 	}
 
-	function __check() if (sound.buffer != buffer) {
+	function __check() if (sound != null && sound.buffer != buffer) {
 		byteSize = 1 << ((buffer = sound.buffer).bitsPerSample - 1);
 
 		#if (lime_cffi && lime_vorbis)
@@ -324,7 +323,7 @@ final class AudioAnalyzer {
 	 * @param maxFreq The maximum frequency to cap (Optional, default 22000.0, Above 23000.0 is not recommended).
 	 * @return Output of levels/bars that ranges from 0 to 1.
 	 */
-	public function getLevels(startPos:Float, ?volume:Float, barCount:Int, ?levels:Array<Float>, ?ratio:Float, ?minDb:Float, ?maxDb:Float, ?minFreq:Float, ?maxFreq:Float):Array<Float>
+	public function getLevels(?startPos:Float, ?volume:Float, barCount:Int, ?levels:Array<Float>, ?ratio:Float, ?minDb:Float, ?maxDb:Float, ?minFreq:Float, ?maxFreq:Float):Array<Float>
 		return inline getLevelsFromFrequencies(__frequencies = getFrequencies(startPos, volume, __frequencies), buffer.sampleRate, barCount, levels, ratio, minDb, maxDb, minFreq, maxFreq);
 
 	/**
@@ -334,8 +333,8 @@ final class AudioAnalyzer {
 	 * @param frequencies The output for getting the frequencies, to avoid memory leaks (Optional).
 	 * @return Output of frequencies.
 	 */
-	public function getFrequencies(startPos:Float, ?volume:Float, ?frequencies:Array<Float>):Array<Float>
-		return inline getFrequenciesFromSamples(__freqSamples = getSamples(startPos, fftN, true, -1, volume, __freqSamples), fftN, useWindowingFFT, frequencies);
+	public function getFrequencies(?startPos:Float, ?volume:Float, ?frequencies:Array<Float>):Array<Float>
+		return inline getFrequenciesFromSamples(__freqSamples = getSamples(startPos != null ? startPos : sound.time, fftN, true, -1, volume, __freqSamples), fftN, useWindowingFFT, frequencies);
 
 	/**
 	 * Analyzes an attached FlxSound from startPos to endPos in milliseconds to get the amplitudes.
@@ -467,36 +466,37 @@ final class AudioAnalyzer {
 		@:privateAccess return sound._source != null && sound._source.__backend != null && sound._source.__backend.playing;
 
 	inline function __readStream(startPos:Float, endPos:Float, callback:AudioAnalyzerCallback):Float @:privateAccess {
-		var backend = sound._source.__backend;
-		var i = backend.bufferSizes.length - backend.queuedBuffers;
-		var time = backend.bufferTimes[i] * 1000;
+		final backend = sound._source.__backend;
 
+		// TODO: Wrap it with try until i figured it out an effective way to do this...
+		// So... sometimes it just uses the decoder even if it looks good?? please help
 		var n = Math.floor((endPos - startPos) * __toBits);
-		if (startPos >= time && startPos < backend.bufferTimes[backend.bufferSizes.length - 1] * 1000) {
-			var pos = Math.floor((startPos - time) * __toBits), buf = backend.bufferDatas[i].buffer, size = backend.bufferSizes[i], c = 0;
+		var i = backend.bufferLengths.length - backend.queuedBuffers - 1, time:Float;
+		while (++i < backend.bufferLengths.length) if (startPos >= (time = backend.bufferTimes[i] * 1000)) {
+			var pos = Math.floor((startPos - time) * __toBits), buf = backend.bufferDatas[i].buffer, size = backend.bufferLengths[i], c = 0;
 			while (pos >= size) {
-				if (++i >= backend.bufferSizes.length) {
-					n = 0;
-					break;
-				}
+				if (++i >= backend.bufferLengths.length) break;
 				pos -= size;
 				buf = backend.bufferDatas[i].buffer;
-				size = backend.bufferSizes[i];
+				size = backend.bufferLengths[i];
 			}
-			pos -= pos % __sampleSize;
+			if (i >= backend.bufferLengths.length) break;
+			if ((pos -= pos % __sampleSize) < 0) pos = 0;
 			n -= pos % __sampleSize;
 
 			while (n > 0) {
 				callback(getByte(buf, pos, __wordSize), c);
 				if (++c > buffer.channels) c = 0;
 				if ((pos += __wordSize) >= size) {
-					if (++i >= backend.bufferSizes.length) break;
+					if (++i >= backend.bufferLengths.length) break;
 					pos = 0;
 					buf = backend.bufferDatas[i].buffer;
-					size = backend.bufferSizes[i];
+					size = backend.bufferLengths[i];
 				}
 				n -= __wordSize;
 			}
+
+			break;
 		}
 
 		return endPos - (n / __toBits);

source/funkin/game/PlayState.hx

@@ -1587,13 +1587,11 @@ class PlayState extends MusicBeatState
 				var camera:FlxCamera = event.params[1] == "camHUD" ? camHUD : camGame;
 				camera.zoom += event.params[0];
 			case "Camera Bop":
-				if (Options.camZoomOnBeat) {
-					if (useCamZoomMult) {
-						camZoomingMult += event.params[0];
-					} else {
-						FlxG.camera.zoom += event.params[0] * camZoomingStrength;
-						camHUD.zoom += event.params[0] * camZoomingStrength;
-					}
+				if (useCamZoomMult) {
+					camZoomingMult += event.params[0];
+				} else {
+					FlxG.camera.zoom += event.params[0] * camZoomingStrength;
+					camHUD.zoom += event.params[0] * camZoomingStrength;
 				}
 			case "Camera Zoom":
 				var cam = event.params[2] == "camHUD" ? camHUD : camGame;