WaveformDataParser: 32bit float audio support

Author: NotHyper-474

source/funkin/audio/waveform/WaveformData.hx

@@ -72,12 +72,12 @@ class WaveformData
     return (channelData == null) ? buildChannelData()[index] : channelData[index];
   }
 
-  public function get(index:Int):Int
+  public inline function get(index:Int):Int
   {
     return data[index] ?? 0;
   }
 
-  public function set(index:Int, value:Int)
+  public inline function set(index:Int, value:Int)
   {
     data[index] = value;
   }
@@ -88,8 +88,9 @@ class WaveformData
    */
   public function maxSampleValue():Int
   {
+    // TODO: Should this still be cached?
     if (_maxSampleValue != 0) return _maxSampleValue;
-    return _maxSampleValue = Std.int(Math.pow(2, bits));
+    return _maxSampleValue = 1 << bits;
   }
 
   /**

source/funkin/audio/waveform/WaveformDataParser.hx

@@ -1,6 +1,8 @@
 package funkin.audio.waveform;
 
 import funkin.util.TimerUtil;
+import haxe.ds.Vector;
+import haxe.io.Bytes;
 
 class WaveformDataParser
 {
@@ -51,11 +53,31 @@ class WaveformDataParser
     var pointsPerSecond:Float = sampleRate / samplesPerPoint; // 172 samples per second for most songs is plenty precise while still being performant..
 
     // TODO: Make this work better on HTML5.
-    var soundData:lime.utils.Int16Array = cast soundBuffer.data;
+    var soundData:Bytes = soundBuffer.data.toBytes();
+    var fakeBitsPerSample:Int = bitsPerSample;
+    var minSampleValue:Int;
+    var maxSampleValue:Int;
+
+    switch (bitsPerSample)
+    {
+      case 8:
+        minSampleValue = INT8_MIN;
+        maxSampleValue = INT8_MAX;
+      case 16:
+        minSampleValue = INT16_MIN;
+        maxSampleValue = INT16_MAX;
+      case 32:
+        // We'll cheat by scaling the values to fit in a 16-bit range.
+        minSampleValue = INT16_MIN;
+        maxSampleValue = INT16_MAX;
+        fakeBitsPerSample = 16;
+      default:
+        throw 'Unsupported bits per sample: $bitsPerSample';
+    }
 
     var soundDataRawLength:Int = soundData.length;
-    var soundDataSampleCount:Int = Std.int(Math.ceil(soundDataRawLength / channels / (bitsPerSample == 16 ? 2 : 1)));
-    var outputPointCount:Int = Std.int(Math.ceil(soundDataSampleCount / samplesPerPoint));
+    var soundDataSampleCount:Int = Math.ceil(soundDataRawLength / channels / (bitsPerSample / 8));
+    var outputPointCount:Int = Math.ceil(soundDataSampleCount / samplesPerPoint);
 
     // trace('Interpreting audio buffer:');
     // trace('  sampleRate: ${sampleRate}');
@@ -68,22 +90,19 @@ class WaveformDataParser
     // trace('  soundDataRawLength/4: ${soundDataRawLength / 4}');
     // trace('  outputPointCount: ${outputPointCount}');
 
-    var minSampleValue:Int = bitsPerSample == 16 ? INT16_MIN : INT8_MIN;
-    var maxSampleValue:Int = bitsPerSample == 16 ? INT16_MAX : INT8_MAX;
-
-    var outputData:Array<Int> = [];
+    var outputData:Vector<Int> = new Vector<Int>(outputPointCount * 2 * channels);
 
     var perfStart:Float = TimerUtil.start();
 
+    // minChannel1, maxChannel1, minChannel2, maxChannel2, ...
+    var values:Vector<Int> = new Vector<Int>(2 * channels);
+
     for (pointIndex in 0...outputPointCount)
     {
-      // minChannel1, maxChannel1, minChannel2, maxChannel2, ...
-      var values:Array<Int> = [];
-
       for (i in 0...channels)
       {
-        values.push(bitsPerSample == 16 ? INT16_MAX : INT8_MAX);
-        values.push(bitsPerSample == 16 ? INT16_MIN : INT8_MIN);
+        values[i * 2] = maxSampleValue;
+        values[i * 2 + 1] = minSampleValue;
       }
 
       var rangeStart = pointIndex * samplesPerPoint;
@@ -95,20 +114,31 @@ class WaveformDataParser
         for (channelIndex in 0...channels)
         {
           var sampleIndex:Int = sampleIndex * channels + channelIndex;
-          var sampleValue = soundData[sampleIndex];
+          var sampleValue:Int = switch (bitsPerSample)
+          {
+            case 8:
+              final byte = soundData.get(sampleIndex);
+              (byte & 0x80) != 0 ? (byte | ~0xFF) : (byte & 0xFF);
+            case 16:
+              final word = soundData.getUInt16(sampleIndex * 2);
+              (word & 0x8000) != 0 ? (word | ~0xFFFF) : (word & 0xFFFF);
+            case 32:
+              Std.int(soundData.getFloat(sampleIndex * 4) * INT16_MAX);
+            default:
+              0;
+          }
 
           if (sampleValue < values[channelIndex * 2]) values[(channelIndex * 2)] = sampleValue;
           if (sampleValue > values[channelIndex * 2 + 1]) values[(channelIndex * 2) + 1] = sampleValue;
         }
       }
 
       // We now have the min and max values for the range.
-      for (value in values)
-        outputData.push(value);
+      Vector.blit(values, 0, outputData, pointIndex * values.length, values.length);
     }
 
     var outputDataLength:Int = Std.int(outputData.length / channels / 2);
-    var result = new WaveformData(null, channels, sampleRate, samplesPerPoint, bitsPerSample, outputPointCount, outputData);
+    var result = new WaveformData(null, channels, sampleRate, samplesPerPoint, fakeBitsPerSample, outputPointCount, outputData.toArray());
 
     trace('[WAVEFORM] Interpreted audio buffer in ${TimerUtil.seconds(perfStart)}.');