gabry/CodenameEngine
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Polish AudioAnalyzer & fix 8-bit detection

Browse Source
This commit is contained in:
Ralty
2025-07-15 01:23:52 +07:00
parent 7f3d976ac6
commit bffb147cc2
2 changed files with 88 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/funkin/backend/utils/AudioAnalyzer.hx
+70 -23
View File
@@ -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;
source/openfl/media/SoundChannel.hx
+18 -14
View File
@@ -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;
}