spessasynth_lib 3.17.0 → 3.20.0

package/soundfont/dls/read_samples.js

@@ -0,0 +1,174 @@
+import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
+import { readBytesAsString } from '../../utils/byte_functions/string.js'
+import {
+    SpessaSynthGroupCollapsed,
+    SpessaSynthGroupEnd,
+    SpessaSynthInfo, SpessaSynthWarn,
+} from '../../utils/loggin.js'
+import { consoleColors } from '../../utils/other.js'
+import { readLittleEndian, signedInt16 } from '../../utils/byte_functions/little_endian.js'
+import { DLSSample } from './dls_sample.js'
+
+/**
+ * @this {DLSSoundFont}
+ * @param waveListChunk {RiffChunk}
+ */
+export function readDLSSamples(waveListChunk)
+{
+    SpessaSynthGroupCollapsed("%cLoading Wave samples...",
+        consoleColors.recognized);
+    let sampleID = 0;
+    while(waveListChunk.chunkData.currentIndex < waveListChunk.chunkData.length)
+    {
+        const waveChunk = readRIFFChunk(waveListChunk.chunkData);
+        this.verifyHeader(waveChunk, "LIST");
+        this.verifyText(readBytesAsString(waveChunk.chunkData, 4), "wave");
+
+        /**
+         * @type {RiffChunk[]}
+         */
+        const waveChunks = [];
+        while(waveChunk.chunkData.currentIndex < waveChunk.chunkData.length)
+        {
+            waveChunks.push(readRIFFChunk(waveChunk.chunkData));
+        }
+
+        const fmtChunk = waveChunks.find(c => c.header === "fmt ");
+        if(!fmtChunk)
+        {
+            throw new Error("No fmt chunk in the wave file!");
+        }
+        const waveFormat = readLittleEndian(fmtChunk.chunkData, 2);
+        if(waveFormat !== 1)
+        {
+            throw new Error("Only PCM format in WAVE is supported.");
+        }
+        const channelsAmount = readLittleEndian(fmtChunk.chunkData, 2);
+        if(channelsAmount !== 1)
+        {
+            throw new Error("Only mono samples are supported.");
+        }
+        const sampleRate = readLittleEndian(fmtChunk.chunkData, 4);
+        // skip avg bytes
+        readLittleEndian(fmtChunk.chunkData, 4);
+        // blockAlign
+        readLittleEndian(fmtChunk.chunkData, 2);
+        // it's bits per sample because one channel
+        const wBitsPerSample = readLittleEndian(fmtChunk.chunkData, 2);
+        const bytesPerSample = wBitsPerSample / 8;
+
+        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 (wBitsPerSample === 8)
+        {
+            normalizationFactor = 255; // For 8-bit normalize from 0-255
+            isUnsigned = true;
+        }
+        else
+        {
+            normalizationFactor = maxSampleValue; // For 16-bit normalize from -32768 to 32767
+        }
+        // read the data
+        const dataChunk = waveChunks.find(c => c.header === "data");
+        if(!dataChunk)
+        {
+            throw new Error("No data chunk in the wave chunk!");
+        }
+        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;
+            }
+        }
+
+        // sane defaults
+        let sampleKey = 60;
+        let samplePitch = 0;
+        let sampleLoopStart = 0;
+        let sampleLoopEnd = sampleData.length - 1;
+
+        // read wsmp
+        const wsmpChunk = waveChunks.find(c => c.header === "wsmp")
+        if(wsmpChunk)
+        {
+            // skip cbsize
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            sampleKey = readLittleEndian(wsmpChunk.chunkData, 2);
+            // section 1.14.2: Each relative pitch unit represents 1/65536 cents.
+            // but that doesn't seem to be true for this one: it's just cents.
+            samplePitch = signedInt16(
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++],
+                wsmpChunk.chunkData[wsmpChunk.chunkData.currentIndex++]
+            );
+            // gain is handled in regions as initialAttenuation
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            // no idea about ful options
+            readLittleEndian(wsmpChunk.chunkData, 4);
+            const loopsAmount = readLittleEndian(wsmpChunk.chunkData, 4);
+            if(loopsAmount === 1)
+            {
+                // skip size and type
+                readLittleEndian(wsmpChunk.chunkData, 8);
+                sampleLoopStart = readLittleEndian(wsmpChunk.chunkData, 4);
+                const loopSize = readLittleEndian(wsmpChunk.chunkData, 4);
+                sampleLoopEnd = sampleLoopStart + loopSize;
+            }
+        }
+        else
+        {
+            SpessaSynthWarn("No wsmp chunk in wave... using sane defaults.")
+        }
+
+        // read sample name
+        const waveInfo = findRIFFListType(waveChunks, "INFO");
+        let sampleName = `Unnamed ${sampleID}`;
+        if(waveInfo)
+        {
+            let infoChunk = readRIFFChunk(waveInfo.chunkData);
+            while(infoChunk.header !== "INAM" && waveInfo.chunkData.currentIndex < waveInfo.chunkData.length)
+            {
+                infoChunk = readRIFFChunk(waveInfo.chunkData);
+            }
+            if(infoChunk.header === "INAM")
+            {
+                sampleName = readBytesAsString(infoChunk.chunkData, infoChunk.size).trim();
+            }
+        }
+
+        this.samples.push(new DLSSample(
+            sampleName,
+            sampleRate,
+            sampleKey,
+            samplePitch,
+            sampleLoopStart,
+            sampleLength,
+            sampleData
+        ));
+
+        sampleID++;
+        SpessaSynthInfo(`%cLoaded sample %c${sampleName}`,
+            consoleColors.info,
+            consoleColors.recognized);
+    }
+    SpessaSynthGroupEnd();
+}

package/soundfont/read_sf2/generators.js

@@ -149,6 +149,39 @@ generatorLimits[generatorTypes.exclusiveClass] = {min: 0, max: 99999, def: 0};
 generatorLimits[generatorTypes.overridingRootKey] = {min: 0-1, max: 127, def: -1};
 
 
+export class Generator
+{
+    /**
+     * Constructs a new generator
+     * @param type {generatorTypes|number}
+     * @param value {number}
+     */
+    constructor(type = generatorTypes.INVALID, value = 0)
+    {
+        this.generatorType = type;
+        if(value === undefined)
+        {
+            throw new Error("No value provided.");
+        }
+        const lim = generatorLimits[type];
+        this.generatorValue = Math.round(value);
+        if(lim !== undefined)
+        {
+            this.generatorValue = Math.max(lim.min, Math.min(lim.max, this.generatorValue));
+        }
+    }
+    /**
+     * The generator's enum number
+     * @type {generatorTypes|number}
+     */
+    generatorType = generatorTypes.INVALID;
+    /**
+     * The generator's 16-bit value
+     * @type {number}
+     */
+    generatorValue = 0;
+}
+
 /**
  * @param generatorType {number}
  * @param presetGens {Generator[]}
@@ -173,19 +206,21 @@ export function addAndClampGenerator(generatorType, presetGens, instrumentGens)
     return Math.max(limits.min, Math.min(limits.max, instruValue + presetValue));
 }
 
-
-export class Generator{
+export class ReadGenerator extends Generator
+{
     /**
      * Creates a generator
      * @param dataArray {IndexedByteArray}
      */
-    constructor(dataArray) {
+    constructor(dataArray)
+    {
+        super();
         // 4 bytes:
         // type, type, type, value
         const i = dataArray.currentIndex;
         /**
-         * @type {generatorTypes}
-         **/
+         * @type {generatorTypes|number}
+         */
         this.generatorType = (dataArray[i + 1] << 8) | dataArray[i];
         this.generatorValue = signedInt16(dataArray[i + 2], dataArray[i + 3]);
         dataArray.currentIndex += 4;
@@ -202,7 +237,7 @@ export function readGenerators(generatorChunk)
     let gens = [];
     while(generatorChunk.chunkData.length > generatorChunk.chunkData.currentIndex)
     {
-        gens.push(new Generator(generatorChunk.chunkData));
+        gens.push(new ReadGenerator(generatorChunk.chunkData));
     }
     if(gens.length > 1)
     {

package/soundfont/read_sf2/modulators.js

@@ -15,7 +15,8 @@ export const modulatorSources = {
     channelPressure: 13,
     pitchWheel: 14,
     pitchWheelRange: 16,
-    link: 127
+    link: 127,
+
 }
 
 export const modulatorCurveTypes = {
@@ -142,7 +143,7 @@ export class Modulator{
     }
 }
 
-function getModSourceEnum(curveType, polarity, direction, isCC, index)
+export function getModSourceEnum(curveType, polarity, direction, isCC, index)
 {
     return (curveType << 10) | (polarity << 9) | (direction << 8) | (isCC << 7) | index;
 }
@@ -189,7 +190,6 @@ export const defaultModulators = [
     }),
 
     // reverb effects to send
-    // 1000 to align with the reverbSend (overriding it works anyways)
     new Modulator({srcEnum: 0x00DB, dest: generatorTypes.reverbEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
 
     // chorus effects to send