spessasynth_core 3.26.20 → 3.26.22

package/src/utils/buffer_to_wav.js

@@ -13,18 +13,17 @@ import { writeLittleEndian } from "./byte_functions/little_endian.js";
 
 /**
  *
- * @param audioData {{leftChannel: Float32Array, rightChannel: Float32Array, sampleRate: number}}
+ * @param audioData {Float32Array[]} channels
+ * @param sampleRate {number}
  * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
  * @param metadata {WaveMetadata}
  * @param loop {{start: number, end: number}} loop start and end points in seconds. Undefined if no loop
  * @returns {ArrayBuffer}
  */
-export function audioToWav(audioData, normalizeAudio = true, metadata = {}, loop = undefined)
+export function audioToWav(audioData, sampleRate, normalizeAudio = true, metadata = {}, loop = undefined)
 {
-    const channel1Data = audioData.leftChannel;
-    const channel2Data = audioData.rightChannel;
-    const length = channel1Data.length;
-    const sampleRate = audioData.sampleRate;
+    const length = audioData[0].length;
+    const numChannels = audioData.length;
     
     const bytesPerSample = 2; // 16-bit PCM
     
@@ -100,7 +99,7 @@ export function audioToWav(audioData, normalizeAudio = true, metadata = {}, loop
     
     // Prepare the header
     const headerSize = 44;
-    const dataSize = length * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    const dataSize = length * numChannels * bytesPerSample; // 16-bit per channel
     const fileSize = headerSize + dataSize + infoChunk.length + cueChunk.length - 8; // total file size minus the first 8 bytes
     const header = new Uint8Array(headerSize);
     
@@ -120,20 +119,20 @@ export function audioToWav(audioData, normalizeAudio = true, metadata = {}, loop
     // audio format (PCM)
     header.set([1, 0], 20);
     // number of channels (2)
-    header.set([2, 0], 22);
+    header.set([numChannels & 255, numChannels >> 8], 22);
     // sample rate
     header.set(
         new Uint8Array([sampleRate & 0xff, (sampleRate >> 8) & 0xff, (sampleRate >> 16) & 0xff, (sampleRate >> 24) & 0xff]),
         24
     );
     // byte rate (sample rate * block align)
-    const byteRate = sampleRate * 2 * bytesPerSample; // 2 channels, 16-bit per channel
+    const byteRate = sampleRate * numChannels * bytesPerSample; // 16-bit per channel
     header.set(
         new Uint8Array([byteRate & 0xff, (byteRate >> 8) & 0xff, (byteRate >> 16) & 0xff, (byteRate >> 24) & 0xff]),
         28
     );
     // block align (channels * bytes per sample)
-    header.set([4, 0], 32); // 2 channels * 16-bit per channel / 8
+    header.set([numChannels * bytesPerSample, 0], 32); // n channels * 16-bit per channel / 8
     // bits per sample
     header.set([16, 0], 34); // 16-bit
     
@@ -154,21 +153,37 @@ export function audioToWav(audioData, normalizeAudio = true, metadata = {}, loop
     if (normalizeAudio)
     {
         // find min and max values to prevent clipping when converting to 16 bits
-        const maxAbsValue = channel1Data.map((v, i) => Math.max(Math.abs(v), Math.abs(channel2Data[i])))
-            .reduce((a, b) => Math.max(a, b));
+        const numSamples = audioData[0].length;
+        
+        let maxAbsValue = 0;
+        
+        for (let ch = 0; ch < numChannels; ch++)
+        {
+            const data = audioData[ch];
+            for (let i = 0; i < numSamples; i++)
+            {
+                const sample = Math.abs(data[i]);
+                if (sample > maxAbsValue)
+                {
+                    maxAbsValue = sample;
+                }
+            }
+        }
+        
         multiplier = maxAbsValue > 0 ? (32767 / maxAbsValue) : 1;
     }
     for (let i = 0; i < length; i++)
     {
         // interleave both channels
-        const sample1 = Math.min(32767, Math.max(-32768, channel1Data[i] * multiplier));
-        const sample2 = Math.min(32767, Math.max(-32768, channel2Data[i] * multiplier));
+        audioData.forEach(d =>
+        {
+            const sample = Math.min(32767, Math.max(-32768, d[i] * multiplier));
+            // convert to 16-bit
+            wavData[offset++] = sample & 0xff;
+            wavData[offset++] = (sample >> 8) & 0xff;
+            
+        });
         
-        // convert to 16-bit
-        wavData[offset++] = sample1 & 0xff;
-        wavData[offset++] = (sample1 >> 8) & 0xff;
-        wavData[offset++] = sample2 & 0xff;
-        wavData[offset++] = (sample2 >> 8) & 0xff;
     }
     
     if (infoOn)

package/src/soundfont/read_sf2/zones.js

@@ -1,223 +0,0 @@
-import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
-import { IndexedByteArray } from "../../utils/indexed_array.js";
-import { RiffChunk } from "../basic_soundfont/riff_chunk.js";
-import { BasicPresetZone } from "../basic_soundfont/basic_preset_zone.js";
-import { Generator } from "../basic_soundfont/generator.js";
-import { Modulator } from "../basic_soundfont/modulator.js";
-import { generatorTypes } from "../basic_soundfont/generator_types.js";
-import { BasicInstrumentZone } from "../basic_soundfont/basic_instrument_zone.js";
-
-/**
- * zones.js
- * purpose: reads instrumend and preset zones from soundfont and gets their respective samples and generators and modulators
- */
-
-export class InstrumentZone extends BasicInstrumentZone
-{
-    /**
-     * Creates a zone (instrument)
-     * @param dataArray {IndexedByteArray}
-     */
-    constructor(dataArray)
-    {
-        super();
-        this.generatorZoneStartIndex = readLittleEndian(dataArray, 2);
-        this.modulatorZoneStartIndex = readLittleEndian(dataArray, 2);
-        this.modulatorZoneSize = 0;
-        this.generatorZoneSize = 0;
-    }
-    
-    setZoneSize(modulatorZoneSize, generatorZoneSize)
-    {
-        this.modulatorZoneSize = modulatorZoneSize;
-        this.generatorZoneSize = generatorZoneSize;
-    }
-    
-    /**
-     * grab the generators
-     * @param generators {Generator[]}
-     */
-    getGenerators(generators)
-    {
-        for (let i = this.generatorZoneStartIndex; i < this.generatorZoneStartIndex + this.generatorZoneSize; i++)
-        {
-            const g = generators[i];
-            if (!g)
-            {
-                throw new Error("Missing generator in instrument zone! The file may corrupted.");
-            }
-            this.addGenerators(g);
-        }
-    }
-    
-    /**
-     * grab the modulators
-     * @param modulators {Modulator[]}
-     */
-    getModulators(modulators)
-    {
-        for (let i = this.modulatorZoneStartIndex; i < this.modulatorZoneStartIndex + this.modulatorZoneSize; i++)
-        {
-            const m = modulators[i];
-            if (!m)
-            {
-                throw new Error("Missing modulator in instrument zone! The file may corrupted.");
-            }
-            this.addModulators(m);
-        }
-    }
-    
-    /**
-     * Loads the zone's sample
-     * @param samples {BasicSample[]}
-     */
-    getSample(samples)
-    {
-        let sampleID = this.generators.find(g => g.generatorType === generatorTypes.sampleID);
-        if (sampleID)
-        {
-            this.setSample(samples[sampleID.generatorValue]);
-        }
-    }
-}
-
-/**
- * Reads the given instrument zone read
- * @param zonesChunk {RiffChunk}
- * @param instrumentGenerators {Generator[]}
- * @param instrumentModulators {Modulator[]}
- * @param instrumentSamples {BasicSample[]}
- * @returns {InstrumentZone[]}
- */
-export function readInstrumentZones(zonesChunk, instrumentGenerators, instrumentModulators, instrumentSamples)
-{
-    /**
-     * @type {InstrumentZone[]}
-     */
-    let zones = [];
-    while (zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
-    {
-        let zone = new InstrumentZone(zonesChunk.chunkData);
-        if (zones.length > 0)
-        {
-            let modulatorZoneSize = zone.modulatorZoneStartIndex - zones[zones.length - 1].modulatorZoneStartIndex;
-            let generatorZoneSize = zone.generatorZoneStartIndex - zones[zones.length - 1].generatorZoneStartIndex;
-            zones[zones.length - 1].setZoneSize(modulatorZoneSize, generatorZoneSize);
-            zones[zones.length - 1].getGenerators(instrumentGenerators);
-            zones[zones.length - 1].getModulators(instrumentModulators);
-            zones[zones.length - 1].getSample(instrumentSamples);
-        }
-        zones.push(zone);
-    }
-    if (zones.length > 1)
-    {
-        // remove terminal
-        zones.pop();
-    }
-    return zones;
-}
-
-export class PresetZone extends BasicPresetZone
-{
-    /**
-     * Creates a zone (preset)
-     * @param dataArray {IndexedByteArray}
-     */
-    constructor(dataArray)
-    {
-        super();
-        this.generatorZoneStartIndex = readLittleEndian(dataArray, 2);
-        this.modulatorZoneStartIndex = readLittleEndian(dataArray, 2);
-        this.modulatorZoneSize = 0;
-        this.generatorZoneSize = 0;
-    }
-    
-    setZoneSize(modulatorZoneSize, generatorZoneSize)
-    {
-        this.modulatorZoneSize = modulatorZoneSize;
-        this.generatorZoneSize = generatorZoneSize;
-    }
-    
-    /**
-     * grab the generators
-     * @param generators {Generator[]}
-     */
-    getGenerators(generators)
-    {
-        for (let i = this.generatorZoneStartIndex; i < this.generatorZoneStartIndex + this.generatorZoneSize; i++)
-        {
-            const g = generators[i];
-            if (!g)
-            {
-                throw new Error("Missing generator in preset zone! The file may corrupted.");
-            }
-            this.addGenerators(g);
-        }
-    }
-    
-    /**
-     * grab the modulators
-     * @param modulators {Modulator[]}
-     */
-    getModulators(modulators)
-    {
-        for (let i = this.modulatorZoneStartIndex; i < this.modulatorZoneStartIndex + this.modulatorZoneSize; i++)
-        {
-            const m = modulators[i];
-            if (!m)
-            {
-                throw new Error("Missing modulator in preset zone! The file may corrupted.");
-            }
-            this.addModulators(m);
-        }
-    }
-    
-    /**
-     * grab the instrument
-     * @param instruments {BasicInstrument[]}
-     */
-    getInstrument(instruments)
-    {
-        let instrumentID = this.generators.find(g => g.generatorType === generatorTypes.instrument);
-        if (instrumentID)
-        {
-            this.setInstrument(instruments[instrumentID.generatorValue]);
-        }
-    }
-}
-
-/**
- * Reads the given preset zone read
- * @param zonesChunk {RiffChunk}
- * @param presetGenerators {Generator[]}
- * @param instruments {BasicInstrument[]}
- * @param presetModulators {Modulator[]}
- * @returns {PresetZone[]}
- */
-export function readPresetZones(zonesChunk, presetGenerators, presetModulators, instruments)
-{
-    /**
-     * @type {PresetZone[]}
-     */
-    let zones = [];
-    while (zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
-    {
-        let zone = new PresetZone(zonesChunk.chunkData);
-        if (zones.length > 0)
-        {
-            let modulatorZoneSize = zone.modulatorZoneStartIndex - zones[zones.length - 1].modulatorZoneStartIndex;
-            let generatorZoneSize = zone.generatorZoneStartIndex - zones[zones.length - 1].generatorZoneStartIndex;
-            zones[zones.length - 1].setZoneSize(modulatorZoneSize, generatorZoneSize);
-            zones[zones.length - 1].getGenerators(presetGenerators);
-            zones[zones.length - 1].getModulators(presetModulators);
-            zones[zones.length - 1].getInstrument(instruments);
-        }
-        zones.push(zone);
-    }
-    if (zones.length > 1)
-    {
-        // remove terminal
-        zones.pop();
-    }
-    return zones;
-}