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

Cleanup AudioAnalyzer

Browse Source
This commit is contained in:
Ralty
2025-07-30 20:48:42 +07:00
parent 0615b7a9ec
commit 2724c8b236
2 changed files with 185 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/funkin/backend/utils/AudioAnalyzer.hx
+172 -126
View File
@@ -2,11 +2,12 @@ package funkin.backend.utils;
import flixel.sound.FlxSound;
import lime.media.AudioBuffer;
import lime.utils.ArrayBufferView.ArrayBufferIO;
import lime.utils.ArrayBuffer;
#if lime_vorbis
#if (lime_cffi && lime_vorbis)
import lime.media.vorbis.Vorbis;
import lime.media.vorbis.VorbisFile;
import lime.utils.ArrayBuffer;
#end
/**
@@ -17,193 +18,238 @@ import lime.utils.ArrayBuffer;
* time, use that instead.
**/
class AudioAnalyzer {
public static function getByte(buf:ArrayBuffer, pos:Int, wordSize:Int):Int {
if (wordSize == 2) return ArrayBufferIO.getInt16(buf, pos);
else if (wordSize == 3) {
var b = ArrayBufferIO.getUint16(buf, pos) | (buf.get(pos + 2) << 16);
if (b > 8388608) return b - 16777216;
else return b;
}
else if (wordSize == 4) return ArrayBufferIO.getInt32(buf, pos);
else return ArrayBufferIO.getUint8(buf, pos) - 128;
}
public var sound:FlxSound;
public var buffer:AudioBuffer;
public var fftSize:Int;
public var byteSize:Int;
var __toBits:Float;
var __wordSize:Int;
var __bitUnsignedSize:Int;
var __bitSize:Int;
var __sampleSize:Int;
#if (lime_cffi && lime_vorbis)
var __vorbis:VorbisFile;
var __buffer:ArrayBuffer;
var __bufferSize:Int;
#end
// analyze
var __min:Array<Int> = [];
var __max:Array<Int> = [];
//var __ln10:Float = 2.3025850929940456;
//var __ln2:Float = 0.6931471805599453;
#if lime_vorbis
var __vorbis:VorbisFile;
#end
var __minByte:Int;
var __maxByte:Int;
/**
* Creates an analyzer for specified FlxSound
* @param sound An FlxSound to analyze.
**/
public function new(sound:FlxSound) {
public function new(sound:FlxSound, fftSize = 1024) {
this.sound = sound;
this.fftSize = fftSize;
__check();
}
function __check() if (sound.buffer != buffer) {
byteSize = 1 << ((buffer = sound.buffer).bitsPerSample - 1);
__toBits = buffer.sampleRate / 1000 * (__sampleSize = buffer.channels * (__wordSize = buffer.bitsPerSample >> 3));
__min.resize(buffer.channels);
__max.resize(buffer.channels);
#if (lime_cffi && lime_vorbis) __vorbis = null; #end
}
/**
* TODO: IMPLEMENT FFT
**/
public function getLevels(levels:Array<Float>, barCount:Int, duration:Float):Float {
__check();
return 0;
}
inline function __check() if (sound.buffer != buffer) {
__bitSize = 1 << ((buffer = sound.buffer).bitsPerSample - 1);
__bitUnsignedSize = 1 << buffer.bitsPerSample;
__toBits = buffer.sampleRate / 1000 * buffer.channels * (__wordSize = buffer.bitsPerSample >> 3);
__vorbis = null;
__min.resize(buffer.channels);
__max.resize(buffer.channels);
}
/**
* Returns a peak of an attached FlxSound from startPos to endPos in milliseconds.
* @param startPos Start Position of the FlxSound in milliseconds.
* @param endPos End Position of the FlxSound in milliseconds.
* @param outMin The output minimum value from the analyzer, indices is in channels (0 to -0.5 -> 0 to 0.5) (Optional)
* @param outOrOutMin The output minimum value from the analyzer, indices is in channels (0 to -0.5 -> 0 to 0.5) (Optional, if outMax doesn't get passed in, it will be [min, max] with all channels combined instead)
* @param outMax The output maximum value from the analyzer, indices is in channels (Optional)
* @return Output Amplitude value
**/
public function analyze(startPos:Float, endPos:Float, ?outMin:Array<Float>, ?outMax:Array<Float>):Float {
__check();
if (buffer.data != null) return __analyze(startPos, endPos, outMin, outMax);
#if lime_vorbis
else if (__prepareVorbis()) return __analyzeVorbis(startPos, endPos, outMin, outMax);
#end
return 0;
public function analyze(startPos:Float, endPos:Float, ?outOrOutMin:Array<Float>, ?outMax:Array<Float>):Float {
__minByte = __maxByte = 0;
if (outOrOutMin != null) {
var f:Float;
if (outMax != null) {
for (i in 0...buffer.channels) __min[i] = __max[i] = 0;
read(startPos, endPos, __analyzeCallback);
for (i in 0...buffer.channels) {
if (outOrOutMin[i] < (f = __min[i] / byteSize)) outOrOutMin[i] = f;
if (outMax[i] < (f = __max[i] / byteSize)) outMax[i] = f;
}
}
else {
read(startPos, endPos, __analyzeCallbackSimple);
outOrOutMin.resize(2);
if (outOrOutMin[0] < (f = __minByte / byteSize)) outOrOutMin[0] = f;
if (outOrOutMin[1] < (f = __maxByte / byteSize)) outOrOutMin[1] = f;
}
}
else
read(startPos, endPos, __analyzeCallbackSimple);
return (__maxByte + __minByte) / byteSize;
}
function __analyze(startPos:Float, endPos:Float, ?outMin:Array<Float>, ?outMax:Array<Float>):Float {
__prepareAmplitude();
function __analyzeCallback(b:Int, c:Int):Void
((b > __max[c]) ? (if ((__max[c] = b) > __maxByte) (__maxByte = b)) : (if (-b > __min[c]) (if ((__min[c] = -b) > __minByte) (__minByte = __min[c]))));
var pos = Math.floor(startPos * __toBits), end = Math.floor(endPos * __toBits), buf = buffer.data #if !js .buffer #end;
var c = Math.floor((pos % (__wordSize * buffer.channels)) / __wordSize), b = 0, w = 0;
pos -= pos % __wordSize;
end -= end % __wordSize;
function __analyzeCallbackSimple(b:Int, c:Int):Void
((b > __maxByte) ? (__maxByte = b) : (if (-b > __minByte) (__minByte = -b)));
public function read(startPos:Float, endPos:Float, callback:AudioAnalyzerCallback) {
__check();
if (buffer.data != null) __read(startPos, endPos, callback);
#if lime_cffi
else if (__canReadStream() && (startPos += __readStream(startPos, endPos, callback)) >= endPos) return;
#if lime_vorbis
else if (__prepareDecoder()) __readDecoder(startPos, endPos, callback);
#end
#end
}
inline function __read(startPos:Float, endPos:Float, callback:AudioAnalyzerCallback) {
var pos = Math.floor(startPos * __toBits), end = Math.floor(endPos * __toBits), c = 0;
pos -= pos % __sampleSize;
end -= end % __sampleSize;
while (pos < end) {
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;
w += 8;
pos++;
}
if (b > __bitSize) b -= __bitUnsignedSize;
}
if (__max[c] < b) __max[c] = b; else if (__min[c] < (b = -b)) __min[c] = b;
callback(getByte(buffer.data.buffer, pos, __wordSize), c);
if (++c > buffer.channels) c = 0;
w = b = 0;
pos += __wordSize;
}
return __getAmplitude(outMin, outMax);
}
inline function __prepareAmplitude() for (i in 0...buffer.channels) __min[i] = __max[i] = 0;
inline function __getAmplitude(?outMin:Array<Float>, ?outMax:Array<Float>):Float {
var min = 0, max = 0, useOutput = outMin != null && outMax != null, v:Float;
for (i in 0...buffer.channels) {
if (__min[i] > min) min = __min[i];
if (__max[i] > max) max = __max[i];
if (useOutput) {
if (outMin[i] < (v = __min[i] / __bitSize)) outMin[i] = v;
if (outMax[i] < (v = __max[i] / __bitSize)) outMax[i] = v;
#if lime_cffi
inline function __canReadStream():Bool
@:privateAccess return sound._source != null && sound._source.__backend != null && sound._source.__backend.streamTimer != null;
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;
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;
pos -= pos % __sampleSize;
while (n > 0) {
callback(getByte(buf, pos, __wordSize), c);
if (++c > buffer.channels) c = 0;
if ((pos += __wordSize) >= size) {
if (++i >= backend.bufferDatas.length) break;
buf = backend.bufferDatas[i].buffer;
size = backend.bufferSizes[i];
pos = 0;
}
n -= __wordSize;
}
}
return (max + min) / __bitSize;
return endPos - (n / __toBits);
}
#if lime_vorbis // As far i know, only native supports vorbis
var __buffer:ArrayBuffer;
var __bufferSize:Int;
function __prepareVorbis():Bool @:privateAccess {
#if lime_vorbis
inline function __prepareDecoder():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(__bufferSize = 0x400 * buffer.channels * (buffer.bitsPerSample >> 3));
__buffer = new ArrayBuffer(__bufferSize = 0x400 * __sampleSize);
return true;
}
return false;
}
function __analyzeVorbis(startPos:Float, endPos:Float, ?outMin:Array<Float>, ?outMax:Array<Float>):Float @:privateAccess {
var n = Math.floor((endPos - startPos) * __toBits);
if ((n -= n % __wordSize) < __wordSize) return 0;
var pos = 0, c = 0, b = 0, w = 0;
__prepareAmplitude();
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];
c = Math.floor(((pos = Math.floor((startPos - time) * __toBits)) % (__wordSize * buffer.channels)) / __wordSize);
pos -= pos % __wordSize;
while (n > 0) {
if (__wordSize == 1) b = buf.get(pos++) - __bitSize;
else {
while (w < buffer.bitsPerSample) {
b |= buf.get(pos) << w;
w += 8;
pos++;
}
if (b > __bitSize) b -= __bitUnsignedSize;
}
if (__max[c] < b) __max[c] = b; else if (__min[c] < (b = -b)) __min[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;
n -= __wordSize;
}
if (n == 0) return __getAmplitude(outMin, outMax);
startPos = pos / __toBits + time;
pos = c = 0;
}
}
if (Math.abs(startPos - __vorbis.timeTell() * 1000) > 4) {
inline function __readDecoder(startPos:Float, endPos:Float, callback:AudioAnalyzerCallback) {
var time = startPos / 1000;
if (Math.abs(time - __vorbis.timeTell()) > 0.004) {
if (startPos < 1) __vorbis.rawSeek(0);
else __vorbis.timeSeek(startPos / 1000);
else __vorbis.timeSeek(time);
}
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));
var n = Math.floor((endPos - startPos) * __toBits), pos = 0, c = 0;
n -= n % __sampleSize;
while (n > 0) {
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;
else {
while (w < buffer.bitsPerSample) {
b |= __buffer.get(pos) << w;
w += 8;
pos++;
}
if (b > __bitSize) b -= __bitUnsignedSize;
}
if (__max[c] < b) __max[c] = b; else if (__min[c] < (b = -b)) __min[c] = b;
callback(getByte(__buffer, pos, __wordSize), c);
if (++c > buffer.channels) c = 0;
w = b = 0;
if ((pos += __wordSize) >= n) break;
}
pos = 0;
n -= result;
}
return __getAmplitude(outMin, outMax);
}
#end
}
#end
}
private typedef AudioAnalyzerCallback = Int->Int->Void;
/*
abstract Complex(Array<Float>) {
public var real(get, never):Float;
inline function get_real() return this[0];
public var imag(get, never):Float;
inline function get_imag() return this[1];
public inline function new(real:Float, imag:Float) this = [real, imag];
public static inline function fromReal(real:Float):Complex return new Complex(real, 0);
public static inline function exp(w:Float):Complex return new Complex(Math.cos(w), Math.sin(w));
public var angle(get, never):Float;
inline function get_angle() return Math.atan2(imag, real);
public var magnitude(get, never):Float;
inline function get_magnitude():Float return Math.sqrt(real*real + imag*imag);
@:op(A + B)
public inline function add(rhs:Complex):Complex return new Complex(real + rhs.real, imag + rhs.imag);
@:op(A - B)
public inline function sub(rhs:Complex):Complex return new Complex(real - rhs.real, imag - rhs.imag);
@:op(A * B)
public inline function mult(rhs:Complex):Complex
return new Complex(real*rhs.real - imag*rhs.imag, real*rhs.imag + imag*rhs.real);
@:op(A / B)
public inline function div(rhs:Complex):Complex {
var m = rhs.magnitude;
return new Complex((real*rhs.real + imag*rhs.imag) / m, (imag*rhs.real - real*rhs.imag) / m);
}
public inline function conj():Complex return new Complex(real, -imag);
}
*/
source/openfl/media/SoundChannel.hx
+13 -25
View File
@@ -27,7 +27,7 @@ import lime.media.openal.AL;
@:fileXml('tags="haxe,release"')
@:noDebug
#end
#if (lime && lime_cffi)
#if lime_cffi
@:access(lime._internal.backend.native.NativeAudioSource)
@:access(lime.media.AudioSource)
#end
@@ -158,9 +158,9 @@ import lime.media.openal.AL;
if (!__isValid) return false;
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, buf;
var leftMin = 0, leftMax = 0, rightMin = 0, rightMax = 0;
var wordSize = buffer.bitsPerSample >> 3, byteSize = 1 << (buffer.bitsPerSample - 1);
var pos = Math.floor(time * buffer.sampleRate / 1000 * buffer.channels * wordSize);
var leftMin = 0, leftMax = 0, rightMin = 0, rightMax = 0, size = 0, buf;
#if lime_cffi
var backend = __source.__backend, i = 0;
@@ -175,25 +175,14 @@ import lime.media.openal.AL;
size = #if js buf.byteLength #else buf.length #end;
}
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;
var s = Math.floor(Math.min(buffer.sampleRate / 80, 512)), c = 0, b;
pos -= pos % (buffer.channels * wordSize);
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;
w += 8;
pos++;
}
if (b > bitSize) b -= bitUnsignedSize;
}
if (c % 2 == 0) {
if (leftMax < b) leftMax = b; else if (leftMin < (b = -b)) leftMin = b;
}
else if (rightMax < b) rightMax = b; else if (rightMin < (b = -b)) rightMin = b;
if (pos >= size) #if lime_cffi {
b = funkin.backend.utils.AudioAnalyzer.getByte(buf, pos, wordSize);
if (c % 2 == 0) ((b > leftMax) ? (leftMax = b) : (if ((b = -b) > leftMin) (leftMin = b)));
else ((b > rightMax) ? (rightMax = b) : (if ((b = -b) > rightMin) (rightMin = b)));
if ((pos += wordSize) >= size) #if lime_cffi {
if (!backend.streamed || ++i >= backend.bufferDatas.length) break;
size = backend.bufferSizes[i];
buf = backend.bufferDatas[i].buffer;
@@ -205,13 +194,12 @@ import lime.media.openal.AL;
c = 0;
s--;
}
w = b = 0;
}
if (buffer.channels == 1) __rightPeak = (__leftPeak = (leftMax + leftMin) / bitSize);
if (buffer.channels == 1) __rightPeak = (__leftPeak = (leftMax + leftMin) / byteSize);
else {
__leftPeak = (leftMax + leftMin) / bitSize;
__rightPeak = (rightMax + rightMin) / bitSize;
__leftPeak = (leftMax + leftMin) / byteSize;
__rightPeak = (rightMax + rightMin) / byteSize;
}
#end