spessasynth_core 3.26.28 → 3.26.30

package/src/soundfont/dls/read_samples.js

@@ -10,101 +10,6 @@ import { consoleColors } from "../../utils/other.js";
 import { readLittleEndian, signedInt16 } from "../../utils/byte_functions/little_endian.js";
 import { DLSSample } from "./dls_sample.js";
 
-const W_FORMAT_TAG = {
-    PCM: 0x01,
-    ALAW: 0x6
-};
-
-/**
- * @param dataChunk {RiffChunk}
- * @param bytesPerSample {number}
- * @returns {Float32Array}
- */
-function readPCM(dataChunk, bytesPerSample)
-{
-    const maxSampleValue = Math.pow(2, bytesPerSample * 8 - 1); // Max value for the sample
-    const maxUnsigned = Math.pow(2, bytesPerSample * 8);
-    
-    let normalizationFactor;
-    let isUnsigned = false;
-    
-    if (bytesPerSample === 1)
-    {
-        normalizationFactor = 255; // For 8-bit normalize from 0-255
-        isUnsigned = true;
-    }
-    else
-    {
-        normalizationFactor = maxSampleValue; // For 16-bit normalize from -32,768 to 32,767
-    }
-    const sampleLength = dataChunk.size / bytesPerSample;
-    const sampleData = new Float32Array(sampleLength);
-    for (let i = 0; i < sampleData.length; i++)
-    {
-        // read
-        let sample = readLittleEndian(dataChunk.chunkData, bytesPerSample);
-        // turn into signed
-        if (isUnsigned)
-        {
-            // normalize unsigned 8-bit sample
-            sampleData[i] = (sample / normalizationFactor) - 0.5;
-        }
-        else
-        {
-            // normalize signed 16-bit sample
-            if (sample >= maxSampleValue)
-            {
-                sample -= maxUnsigned;
-            }
-            sampleData[i] = sample / normalizationFactor;
-        }
-    }
-    return sampleData;
-}
-
-/**
- * @param dataChunk {RiffChunk}
- * @param bytesPerSample {number}
- * @returns {Float32Array}
- */
-function readALAW(dataChunk, bytesPerSample)
-{
-    const sampleLength = dataChunk.size / bytesPerSample;
-    const sampleData = new Float32Array(sampleLength);
-    for (let i = 0; i < sampleData.length; i++)
-    {
-        // read
-        const input = readLittleEndian(dataChunk.chunkData, bytesPerSample);
-        
-        // https://en.wikipedia.org/wiki/G.711#A-law
-        // re-toggle toggled bits
-        let sample = input ^ 0x55;
-        
-        // remove sign bit
-        sample &= 0x7F;
-        
-        // extract exponent
-        let exponent = sample >> 4;
-        // extract mantissa
-        let mantissa = sample & 0xF;
-        if (exponent > 0)
-        {
-            mantissa += 16; // add leading '1', if exponent > 0
-        }
-        
-        mantissa = (mantissa << 4) + 0x8;
-        if (exponent > 1)
-        {
-            mantissa = mantissa << (exponent - 1);
-        }
-        
-        const s16sample = input > 127 ? mantissa : -mantissa;
-        
-        // convert to float
-        sampleData[i] = s16sample / 32678;
-    }
-    return sampleData;
-}
 
 /**
  * @this {DLSSoundFont}
@@ -138,7 +43,7 @@ export function readDLSSamples(waveListChunk)
             throw new Error("No fmt chunk in the wave file!");
         }
         // https://github.com/tpn/winsdk-10/blob/9b69fd26ac0c7d0b83d378dba01080e93349c2ed/Include/10.0.14393.0/shared/mmreg.h#L2108
-        const waveFormat = readLittleEndian(fmtChunk.chunkData, 2);
+        const wFormatTag = readLittleEndian(fmtChunk.chunkData, 2);
         const channelsAmount = readLittleEndian(fmtChunk.chunkData, 2);
         if (channelsAmount !== 1)
         {
@@ -153,30 +58,11 @@ export function readDLSSamples(waveListChunk)
         const wBitsPerSample = readLittleEndian(fmtChunk.chunkData, 2);
         const bytesPerSample = wBitsPerSample / 8;
         
-        // read the data
-        let failed = false;
         const dataChunk = waveChunks.find(c => c.header === "data");
         if (!dataChunk)
         {
             this.parsingError("No data chunk in the WAVE chunk!");
         }
-        let sampleData;
-        switch (waveFormat)
-        {
-            default:
-                failed = true;
-                sampleData = new Float32Array(dataChunk.size / bytesPerSample);
-                break;
-            
-            case W_FORMAT_TAG.PCM:
-                sampleData = readPCM(dataChunk, bytesPerSample);
-                break;
-            
-            case W_FORMAT_TAG.ALAW:
-                sampleData = readALAW(dataChunk, bytesPerSample);
-                break;
-            
-        }
         
         // read sample name
         const waveInfo = findRIFFListType(waveChunks, "INFO");
@@ -198,7 +84,8 @@ export function readDLSSamples(waveListChunk)
         let sampleKey = 60;
         let samplePitch = 0;
         let sampleLoopStart = 0;
-        let sampleLoopEnd = sampleData.length - 1;
+        const sampleLength = dataChunk.size / bytesPerSample;
+        let sampleLoopEnd = sampleLength - 1;
         let sampleDbAttenuation = 0;
         
         // read wsmp
@@ -242,11 +129,6 @@ export function readDLSSamples(waveListChunk)
             SpessaSynthWarn("No wsmp chunk in wave... using sane defaults.");
         }
         
-        if (failed)
-        {
-            console.error(`Failed to load '${sampleName}': Unsupported format: (${waveFormat})`);
-        }
-        
         this.samples.push(new DLSSample(
             sampleName,
             sampleRate,
@@ -254,8 +136,10 @@ export function readDLSSamples(waveListChunk)
             samplePitch,
             sampleLoopStart,
             sampleLoopEnd,
-            sampleData,
-            sampleDbAttenuation
+            sampleDbAttenuation,
+            dataChunk,
+            wFormatTag,
+            bytesPerSample
         ));
         
         

package/src/soundfont/read_sf2/instrument_zones.js

@@ -4,7 +4,6 @@
  */
 import { BasicInstrumentZone } from "../basic_soundfont/basic_instrument_zone.js";
 import { generatorTypes } from "../basic_soundfont/generator_types.js";
-import { readLittleEndian } from "../../utils/byte_functions/little_endian.js";
 
 export class InstrumentZone extends BasicInstrumentZone
 {
@@ -33,28 +32,16 @@ export class InstrumentZone extends BasicInstrumentZone
 
 /**
  * Reads the given instrument zone
- * @param zonesChunk {RiffChunk}
+ * @param indexes {{mod: number[], gen: number[]}}
  * @param instrumentGenerators {Generator[]}
  * @param instrumentModulators {Modulator[]}
  * @param samples {BasicSample[]}
  * @param instruments {Instrument[]}
  */
-export function readInstrumentZones(zonesChunk, instrumentGenerators, instrumentModulators, samples, instruments)
+export function applyInstrumentZones(indexes, instrumentGenerators, instrumentModulators, samples, instruments)
 {
-    /**
-     * @type {number[]}
-     */
-    const modStartIndexes = [];
-    /**
-     * @type {number[]}
-     */
-    const genStartIndexes = [];
-    
-    while (zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
-    {
-        genStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
-        modStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
-    }
+    const genStartIndexes = indexes.gen;
+    const modStartIndexes = indexes.mod;
     
     let modIndex = 0;
     let genIndex = 0;

package/src/soundfont/read_sf2/instruments.js

@@ -28,7 +28,7 @@ export class Instrument extends BasicInstrument
     constructor(instrumentChunk)
     {
         super();
-        this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20).trim();
+        this.instrumentName = readBytesAsString(instrumentChunk.chunkData, 20);
         this.zoneStartIndex = readLittleEndian(instrumentChunk.chunkData, 2);
     }
     

package/src/soundfont/read_sf2/preset_zones.js

@@ -1,5 +1,3 @@
-import { readLittleEndian } from "../../utils/byte_functions/little_endian.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";
@@ -35,30 +33,19 @@ export class PresetZone extends BasicPresetZone
     }
 }
 
+
 /**
- * Reads the given preset zone read
- * @param zonesChunk {RiffChunk}
+ * Reads the given preset zone
+ * @param indexes {{mod: number[], gen: number[]}}
  * @param presetGens {Generator[]}
  * @param instruments {BasicInstrument[]}
  * @param presetMods {Modulator[]}
  * @param presets {Preset[]}
  */
-export function readPresetZones(zonesChunk, presetGens, presetMods, instruments, presets)
+export function applyPresetZones(indexes, presetGens, presetMods, instruments, presets)
 {
-    /**
-     * @type {number[]}
-     */
-    const modStartIndexes = [];
-    /**
-     * @type {number[]}
-     */
-    const genStartIndexes = [];
-    
-    while (zonesChunk.chunkData.length > zonesChunk.chunkData.currentIndex)
-    {
-        genStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
-        modStartIndexes.push(readLittleEndian(zonesChunk.chunkData, 2));
-    }
+    const genStartIndexes = indexes.gen;
+    const modStartIndexes = indexes.mod;
     
     let modIndex = 0;
     let genIndex = 0;

package/src/soundfont/read_sf2/presets.js

@@ -29,7 +29,6 @@ export class Preset extends BasicPreset
     {
         super(sf2);
         this.presetName = readBytesAsString(presetChunk.chunkData, 20)
-            .trim()
             .replace(/\d{3}:\d{3}/, ""); // remove those pesky "000:001"
         
         this.program = readLittleEndian(presetChunk.chunkData, 2);

package/src/soundfont/read_sf2/samples.js

@@ -4,7 +4,7 @@ import { readLittleEndian, signedInt8 } from "../../utils/byte_functions/little_
 import { stbvorbis } from "../../externals/stbvorbis_sync/stbvorbis_sync.min.js";
 import { SpessaSynthWarn } from "../../utils/loggin.js";
 import { readBytesAsString } from "../../utils/byte_functions/string.js";
-import { BasicSample } from "../basic_soundfont/basic_sample.js";
+import { BasicSample, sampleTypes } from "../basic_soundfont/basic_sample.js";
 
 export const SF3_BIT_FLIT = 0x10;
 
@@ -16,6 +16,23 @@ export class SoundFontSample extends BasicSample
      */
     linkedSampleIndex;
     
+    /**
+     * The handle to the core sf2 file for dynamic sample reading
+     * @type {Uint8Array}
+     */
+    sf2FileArrayHandle;
+    
+    /**
+     * Start index of the sample in the file byte array
+     * @type {number}
+     */
+    s16leStart = 0;
+    /**
+     * End index of the sample in the file byte array
+     * @type {number}
+     */
+    s16leEnd = 0;
+    
     /**
      * Creates a sample
      * @param sampleName {string}
@@ -28,9 +45,8 @@ export class SoundFontSample extends BasicSample
      * @param samplePitchCorrection {number}
      * @param linkedSampleIndex {number}
      * @param sampleType {number}
-     * @param smplArr {IndexedByteArray|Float32Array}
+     * @param sampleDataArray {IndexedByteArray|Float32Array}
      * @param sampleIndex {number} initial sample index when loading the sfont
-     * @param isDataRaw {boolean} if false, the data is decoded as float32.
      * Used for SF2Pack support
      */
     constructor(
@@ -44,9 +60,8 @@ export class SoundFontSample extends BasicSample
         samplePitchCorrection,
         linkedSampleIndex,
         sampleType,
-        smplArr,
-        sampleIndex,
-        isDataRaw
+        sampleDataArray,
+        sampleIndex
     )
     {
         // read sf3
@@ -68,20 +83,47 @@ export class SoundFontSample extends BasicSample
         // in bytes
         this.sampleStartIndex = sampleStartIndex;
         this.sampleEndIndex = sampleEndIndex;
-        this.isSampleLoaded = false;
         this.sampleID = sampleIndex;
         // in bytes
         this.sampleLength = this.sampleEndIndex - this.sampleStartIndex;
-        this.sampleDataArray = smplArr;
-        this.sampleData = new Float32Array(0);
+        const smplStart = sampleDataArray.currentIndex;
+        
+        // three data types in:
+        // SF2 (s16le)
+        // SF3 (vorbis)
+        // SF2Pack (
         if (this.isCompressed)
         {
             // correct loop points
             this.sampleLoopStartIndex += this.sampleStartIndex / 2;
             this.sampleLoopEndIndex += this.sampleStartIndex / 2;
             this.sampleLength = 99999999; // set to 999,999 before we decode it
+            
+            // copy the compressed data, it can be preserved during writing
+            this.compressedData = sampleDataArray.slice(
+                this.sampleStartIndex / 2 + smplStart,
+                this.sampleEndIndex / 2 + smplStart
+            );
+        }
+        else
+        {
+            if (sampleDataArray instanceof Float32Array)
+            {
+                // float32 array from SF2pack, copy directly
+                this.sampleData = sampleDataArray.slice(
+                    this.sampleStartIndex / 2,
+                    this.sampleEndIndex / 2
+                );
+            }
+            else
+            {
+                // regular sf2 s16le
+                this.s16leStart = smplStart + this.sampleStartIndex;
+                this.s16leEnd = smplStart + this.sampleEndIndex;
+                this.sf2FileArrayHandle = sampleDataArray;
+            }
+            
         }
-        this.isDataRaw = isDataRaw;
         this.linkedSampleIndex = linkedSampleIndex;
     }
     
@@ -94,70 +136,62 @@ export class SoundFontSample extends BasicSample
         {
             return;
         }
-        this.setLinkedSample(samplesArray[this.linkedSampleIndex], this.sampleType);
-    }
-    
-    /**
-     * Get raw data, whether it's compressed or not as we simply write it to the file
-     * @return {Uint8Array} either s16 or vorbis data
-     */
-    getRawData()
-    {
-        const smplArr = this.sampleDataArray;
-        if (this.isCompressed)
+        const linkedSample = samplesArray[this.linkedSampleIndex];
+        if (!linkedSample)
         {
-            if (this.compressedData)
-            {
-                return this.compressedData;
-            }
-            const smplStart = smplArr.currentIndex;
-            return smplArr.slice(this.sampleStartIndex / 2 + smplStart, this.sampleEndIndex / 2 + smplStart);
+            SpessaSynthWarn(`Invalid linked sample for ${this.sampleName}. Setting to mono.`);
+            this.setSampleType(sampleTypes.monoSample);
         }
         else
         {
-            if (!this.isDataRaw)
-            {
-                // encode the f32 into s16 manually
-                super.getRawData();
-            }
-            const dataStartIndex = smplArr.currentIndex;
-            return smplArr.slice(dataStartIndex + this.sampleStartIndex, dataStartIndex + this.sampleEndIndex);
+            this.setLinkedSample(samplesArray[this.linkedSampleIndex], this.sampleType);
         }
     }
     
     /**
+     * @private
      * Decode binary vorbis into a float32 pcm
+     * @returns {Float32Array}
      */
     decodeVorbis()
     {
+        if (this.sampleData)
+        {
+            return this.sampleData;
+        }
         if (this.sampleLength < 1)
         {
             // eos, do not do anything
-            return;
+            return new Float32Array(0);
         }
         // get the compressed byte stream
-        const smplArr = this.sampleDataArray;
-        const smplStart = smplArr.currentIndex;
-        const buff = smplArr.slice(this.sampleStartIndex / 2 + smplStart, this.sampleEndIndex / 2 + smplStart);
         // reset array and being decoding
-        this.sampleData = new Float32Array(0);
         try
         {
             /**
              * @type {{data: Float32Array[], error: (string|null), sampleRate: number, eof: boolean}}
              */
-            const vorbis = stbvorbis.decode(buff.buffer);
-            this.sampleData = vorbis.data[0];
-            if (this.sampleData === undefined)
+            const vorbis = stbvorbis.decode(this.compressedData);
+            const decoded = vorbis.data[0];
+            if (decoded === undefined)
             {
                 SpessaSynthWarn(`Error decoding sample ${this.sampleName}: Vorbis decode returned undefined.`);
+                return new Float32Array(0);
             }
+            // clip
+            // because vorbis can go above 1 sometimes
+            for (let i = 0; i < decoded.length; i++)
+            {
+                // magic number is 32,767 / 32,768
+                decoded[i] = Math.max(-1, Math.min(decoded[i], 0.999969482421875));
+            }
+            return decoded;
         }
         catch (e)
         {
             // do not error out, fill with silence
             SpessaSynthWarn(`Error decoding sample ${this.sampleName}: ${e}`);
-            this.sampleData = new Float32Array(this.sampleLoopEndIndex + 1);
+            return new Float32Array(this.sampleLoopEndIndex + 1);
         }
     }
     
@@ -167,8 +201,6 @@ export class SoundFontSample extends BasicSample
     setAudioData(audioData)
     {
         super.setAudioData(audioData);
-        this.isSampleLoaded = true;
-        this.isDataRaw = false;
     }
     
     /**
@@ -177,48 +209,31 @@ export class SoundFontSample extends BasicSample
      */
     getAudioData()
     {
-        if (!this.isSampleLoaded)
+        if (this.sampleData)
         {
-            // start loading data if it is not loaded
-            if (this.sampleLength < 1)
-            {
-                SpessaSynthWarn(`Invalid sample ${this.sampleName}! Invalid length: ${this.sampleLength}`);
-                return new Float32Array(1);
-            }
-            
-            if (this.isCompressed)
-            {
-                // if compressed, decode
-                this.decodeVorbis();
-                this.isSampleLoaded = true;
-                return this.sampleData;
-            }
-            else if (!this.isDataRaw)
-            {
-                return this.getUncompressedReadyData();
-            }
-            return this.loadUncompressedData();
+            return this.sampleData;
         }
-        return this.sampleData;
-    }
-    
-    /**
-     * @returns {Float32Array}
-     */
-    loadUncompressedData()
-    {
-        if (this.isCompressed)
+        // SF2Pack is decoded during load time
+        
+        // start loading data if it is not loaded
+        if (this.sampleLength < 1)
         {
-            SpessaSynthWarn("Trying to load a compressed sample via loadUncompressedData()... aborting!");
-            return new Float32Array(0);
+            SpessaSynthWarn(`Invalid sample ${this.sampleName}! Invalid length: ${this.sampleLength}`);
+            return new Float32Array(1);
         }
         
+        if (this.isCompressed)
+        {
+            // SF3
+            // if compressed, decode
+            this.sampleData = this.decodeVorbis();
+            return this.sampleData;
+        }
+        // SF2
         // read the sample data
         let audioData = new Float32Array(this.sampleLength / 2);
-        const dataStartIndex = this.sampleDataArray.currentIndex;
         let convertedSigned16 = new Int16Array(
-            this.sampleDataArray.slice(dataStartIndex + this.sampleStartIndex, dataStartIndex + this.sampleEndIndex)
-                .buffer
+            this.sf2FileArrayHandle.buffer.slice(this.s16leStart, this.s16leEnd)
         );
         
         // convert to float
@@ -228,26 +243,28 @@ export class SoundFontSample extends BasicSample
         }
         
         this.sampleData = audioData;
-        this.isSampleLoaded = true;
         return audioData;
+        
     }
     
     /**
-     * @returns {Float32Array}
+     * @param allowVorbis
+     * @returns {Uint8Array}
      */
-    getUncompressedReadyData()
+    getRawData(allowVorbis = true)
     {
-        /**
-         * read the sample data
-         * @type {Float32Array}
-         */
-        let audioData = /**@type {Float32Array}*/ this.sampleDataArray.slice(
-            this.sampleStartIndex / 2,
-            this.sampleEndIndex / 2
-        );
-        this.sampleData = audioData;
-        this.isSampleLoaded = true;
-        return audioData;
+        if (this.dataOverriden)
+        {
+            return this.encodeS16LE();
+        }
+        else
+        {
+            if (this.compressedData && allowVorbis)
+            {
+                return this.compressedData;
+            }
+            return this.sf2FileArrayHandle.slice(this.s16leStart, this.s16leEnd);
+        }
     }
 }
 
@@ -255,10 +272,10 @@ export class SoundFontSample extends BasicSample
  * Reads the generatorTranslator from the shdr read
  * @param sampleHeadersChunk {RiffChunk}
  * @param smplChunkData {IndexedByteArray|Float32Array}
- * @param isSmplDataRaw {boolean}
+ * @param linkSamples {boolean}
  * @returns {SoundFontSample[]}
  */
-export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = true)
+export function readSamples(sampleHeadersChunk, smplChunkData, linkSamples = true)
 {
     /**
      * @type {SoundFontSample[]}
@@ -267,7 +284,7 @@ export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = t
     let index = 0;
     while (sampleHeadersChunk.chunkData.length > sampleHeadersChunk.chunkData.currentIndex)
     {
-        const sample = readSample(index, sampleHeadersChunk.chunkData, smplChunkData, isSmplDataRaw);
+        const sample = readSample(index, sampleHeadersChunk.chunkData, smplChunkData);
         samples.push(sample);
         index++;
     }
@@ -275,7 +292,10 @@ export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = t
     samples.pop();
     
     // link samples
-    samples.forEach(s => s.getLinkedSample(samples));
+    if (linkSamples)
+    {
+        samples.forEach(s => s.getLinkedSample(samples));
+    }
     
     return samples;
 }
@@ -285,10 +305,9 @@ export function readSamples(sampleHeadersChunk, smplChunkData, isSmplDataRaw = t
  * @param index {number}
  * @param sampleHeaderData {IndexedByteArray}
  * @param smplArrayData {IndexedByteArray|Float32Array}
- * @param isDataRaw {boolean} true means binary 16-bit data, false means float32
  * @returns {SoundFontSample}
  */
-function readSample(index, sampleHeaderData, smplArrayData, isDataRaw)
+function readSample(index, sampleHeaderData, smplArrayData)
 {
     
     // read the sample name
@@ -311,9 +330,9 @@ function readSample(index, sampleHeaderData, smplArrayData, isDataRaw)
     
     // read the original sample pitch
     let samplePitch = sampleHeaderData[sampleHeaderData.currentIndex++];
-    if (samplePitch === 255)
+    if (samplePitch > 127)
     {
-        // if it's 255, then default to 60
+        // if it's out of range, then default to 60
         samplePitch = 60;
     }
     
@@ -338,7 +357,6 @@ function readSample(index, sampleHeaderData, smplArrayData, isDataRaw)
         sampleLink,
         sampleType,
         smplArrayData,
-        index,
-        isDataRaw
+        index
     );
 }