spessasynth_lib 3.20.23 → 3.20.25

package/@types/soundfont/basic_soundfont/basic_preset.d.ts

@@ -1,4 +1,8 @@
 export class BasicPreset {
+    /**
+     * @param modulators {Modulator[]}
+     */
+    constructor(modulators: Modulator[]);
     /**
      * The preset's name
      * @type {string}
@@ -44,6 +48,11 @@ export class BasicPreset {
      * @type {number}
      */
     morphology: number;
+    /**
+     * Default modulators
+     * @type {Modulator[]}
+     */
+    defaultModulators: Modulator[];
     deletePreset(): void;
     /**
      * @param index {number}
@@ -74,3 +83,4 @@ export type SampleAndGenerators = {
     sample: BasicSample;
     sampleID: number;
 };
+import { Modulator } from '../read_sf2/modulators.js';

package/@types/soundfont/basic_soundfont/basic_soundfont.d.ts

@@ -17,10 +17,10 @@ export class BasicSoundFont {
     });
     /**
      * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g. 2.1)
-     * @type {Object<string, string>}
+     * @type {Object<string, string|IndexedByteArray>}
      */
     soundFontInfo: {
-        [x: string]: string;
+        [x: string]: string | IndexedByteArray;
     };
     /**
      * The soundfont's presets
@@ -37,6 +37,11 @@ export class BasicSoundFont {
      * @type {BasicInstrument[]}
      */
     instruments: BasicInstrument[];
+    /**
+     * Soundfont's default modulatorss
+     * @type {Modulator[]}
+     */
+    defaultModulators: Modulator[];
     removeUnusedElements(): void;
     /**
      * @param instrument {BasicInstrument}
@@ -78,4 +83,5 @@ export class BasicSoundFont {
     getPresetByName(presetName: string): BasicPreset;
     write: typeof write;
 }
+import { Modulator } from '../read_sf2/modulators.js';
 import { write } from './write_sf2/write.js';

package/@types/soundfont/dls/dls_zone.d.ts

@@ -13,10 +13,11 @@ export class DLSZone extends BasicInstrumentZone {
      * @param sampleKey {number}
      * @param sample {BasicSample}
      * @param sampleID {number}
+     * @param samplePitchCorrection {number} cents
      */
     setWavesample(attenuationCb: number, loopingMode: number, loop: {
         start: number;
         end: number;
-    }, sampleKey: number, sample: BasicSample, sampleID: number): void;
+    }, sampleKey: number, sample: BasicSample, sampleID: number, samplePitchCorrection: number): void;
 }
 import { BasicInstrumentZone } from '../basic_soundfont/basic_zones.js';

package/@types/soundfont/read_sf2/modulators.d.ts

@@ -29,6 +29,17 @@ export namespace modulatorCurveTypes {
  */
 export const precomputedTransforms: Float32Array[][][];
 export class Modulator {
+    /**
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    static copy(modulator: Modulator): Modulator;
+    /**
+     * @param mod1 {Modulator}
+     * @param mod2 {Modulator}
+     * @returns {boolean}
+     */
+    static isIdentical(mod1: Modulator, mod2: Modulator): boolean;
     /**
      * Creates a modulator
      * @param dataArray {IndexedByteArray|{srcEnum: number, secSrcEnum: number, dest:number, amt: number, transform: number}}
@@ -40,12 +51,12 @@ export class Modulator {
         amt: number;
         transform: number;
     });
-    modulatorSource: any;
+    sourceEnum: any;
     /**
      * @type {generatorTypes}
      */
     modulatorDestination: generatorTypes;
-    modulationSecondarySrc: any;
+    secondarySourceEnum: any;
     transformAmount: any;
     transformType: any;
     sourcePolarity: number;

package/@types/soundfont/read_sf2/presets.d.ts

@@ -2,9 +2,10 @@
  * Reads the presets
  * @param presetChunk {RiffChunk}
  * @param presetZones {PresetZone[]}
+ * @param defaultModulators {Modulator[]}
  * @returns {Preset[]}
  */
-export function readPresets(presetChunk: RiffChunk, presetZones: PresetZone[]): Preset[];
+export function readPresets(presetChunk: RiffChunk, presetZones: PresetZone[], defaultModulators: Modulator[]): Preset[];
 /**
  * parses soundfont presets, also includes function for getting the generators and samples from midi note and velocity
  */
@@ -12,8 +13,9 @@ export class Preset extends BasicPreset {
     /**
      * Creates a preset
      * @param presetChunk {RiffChunk}
+     * @param defaultModulators {Modulator[]}
      */
-    constructor(presetChunk: RiffChunk);
+    constructor(presetChunk: RiffChunk, defaultModulators: Modulator[]);
     presetZoneStartIndex: number;
     presetZonesAmount: number;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spessasynth_lib",
-  "version": "3.20.23",
+  "version": "3.20.25",
   "description": "MIDI and SoundFont2 or DLS Synthesizer library with no compromises",
   "browser": "index.js",
   "types": "@types/index.d.ts",

package/soundfont/basic_soundfont/basic_preset.js

@@ -7,12 +7,15 @@
  *  sampleID: number,
  * }} SampleAndGenerators
  */
-import { defaultModulators } from '../read_sf2/modulators.js'
 import { generatorTypes } from '../read_sf2/generators.js'
+import { Modulator } from '../read_sf2/modulators.js'
 
 export class BasicPreset
 {
-    constructor()
+    /**
+     * @param modulators {Modulator[]}
+     */
+    constructor(modulators)
     {
         /**
          * The preset's name
@@ -67,6 +70,12 @@ export class BasicPreset
          * @type {number}
          */
         this.morphology = 0;
+
+        /**
+         * Default modulators
+         * @type {Modulator[]}
+         */
+        this.defaultModulators = modulators;
     }
 
     deletePreset()
@@ -137,21 +146,9 @@ export class BasicPreset
             return [];
         }
 
-        function isInRange(min, max, number) {
-            return number >= min && number <= max;
-        }
-
-        /**
-         * @param mod1 {Modulator}
-         * @param mod2 {Modulator}
-         * @returns {boolean}
-         */
-        function identicalMod(mod1, mod2)
+        function isInRange(min, max, number)
         {
-            return (mod1.modulatorSource === mod2.modulatorSource)
-                && (mod1.modulatorDestination === mod2.modulatorDestination)
-                && (mod1.modulationSecondarySrc === mod2.modulationSecondarySrc)
-                && (mod1.transformType === mod2.transformType);
+            return number >= min && number <= max;
         }
 
         /**
@@ -169,7 +166,7 @@ export class BasicPreset
          */
         function addUniqueMods(main, adder)
         {
-            main.push(...adder.filter(m => !main.find(mm => identicalMod(m, mm))));
+            main.push(...adder.filter(m => !main.find(mm => Modulator.isIdentical(m, mm))));
         }
 
         /**
@@ -237,7 +234,7 @@ export class BasicPreset
                 addUniqueMods(instrumentModulators, globalInstrumentModulators);
 
                 // default mods
-                addUniqueMods(instrumentModulators, defaultModulators);
+                addUniqueMods(instrumentModulators, this.defaultModulators);
 
                 /**
                  * sum preset modulators to instruments (amount) sf spec page 54
@@ -247,7 +244,7 @@ export class BasicPreset
                 for(let i = 0; i < presetModulators.length; i++)
                 {
                     let mod = presetModulators[i];
-                    const identicalInstrumentModulator = finalModulatorList.findIndex(m => identicalMod(mod, m));
+                    const identicalInstrumentModulator = finalModulatorList.findIndex(m => Modulator.isIdentical(mod, m));
                     if(identicalInstrumentModulator !== -1)
                     {
                         // sum the amounts (this makes a new modulator because otherwise it would overwrite the one in the soundfont!!!

package/soundfont/basic_soundfont/basic_soundfont.js

@@ -1,6 +1,7 @@
 import { SpessaSynthWarn } from '../../utils/loggin.js'
 import { consoleColors } from '../../utils/other.js'
 import { write } from './write_sf2/write.js'
+import { defaultModulators, Modulator } from '../read_sf2/modulators.js'
 
 class BasicSoundFont
 {
@@ -12,7 +13,7 @@ class BasicSoundFont
     {
         /**
          * Soundfont's info stored as name: value. ifil and iver are stored as string representation of float (e.g. 2.1)
-         * @type {Object<string, string>}
+         * @type {Object<string, string|IndexedByteArray>}
          */
         this.soundFontInfo = {};
 
@@ -34,6 +35,12 @@ class BasicSoundFont
          */
         this.instruments = [];
 
+        /**
+         * Soundfont's default modulatorss
+         * @type {Modulator[]}
+         */
+        this.defaultModulators = defaultModulators.map(m => Modulator.copy(m));
+
         if(data?.presets)
         {
             this.presets.push(...data.presets);

package/soundfont/basic_soundfont/write_sf2/imod.js

@@ -25,10 +25,10 @@ export function getIMOD()
             ibag.modulatorZoneStartIndex = imodIndex;
             for (const mod of ibag.modulators)
             {
-                writeWord(imoddata, mod.modulatorSource);
+                writeWord(imoddata, mod.sourceEnum);
                 writeWord(imoddata, mod.modulatorDestination);
                 writeWord(imoddata, mod.transformAmount);
-                writeWord(imoddata, mod.modulationSecondarySrc);
+                writeWord(imoddata, mod.secondarySourceEnum);
                 writeWord(imoddata, mod.transformType);
                 imodIndex++;
             }

package/soundfont/basic_soundfont/write_sf2/pmod.js

@@ -25,10 +25,10 @@ export function getPMOD()
             pbag.modulatorZoneStartIndex = pmodIndex;
             for (const mod of pbag.modulators)
             {
-                writeWord(pmoddata, mod.modulatorSource);
+                writeWord(pmoddata, mod.sourceEnum);
                 writeWord(pmoddata, mod.modulatorDestination);
                 writeWord(pmoddata, mod.transformAmount);
-                writeWord(pmoddata, mod.modulationSecondarySrc);
+                writeWord(pmoddata, mod.secondarySourceEnum);
                 writeWord(pmoddata, mod.transformType);
                 pmodIndex++;
             }

package/soundfont/basic_soundfont/write_sf2/write.js

@@ -68,6 +68,7 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
     {
         this.soundFontInfo["ifil"] = "3.0"; // set version to 3
     }
+
     for (const [type, data] of Object.entries(this.soundFontInfo))
     {
         if(type === "ifil" || type === "iver")
@@ -84,6 +85,15 @@ export function write(options = DEFAULT_WRITE_OPTIONS)
             )));
         }
         else
+        if(type === "DMOD")
+        {
+            infoArrays.push(writeRIFFChunk(new RiffChunk(
+                type,
+                data.length,
+                data
+            )));
+        }
+        else
         {
             const arr = new IndexedByteArray(data.length);
             writeStringAsBytes(arr, data);

package/soundfont/dls/dls_preset.js

@@ -1,6 +1,7 @@
 import { BasicPreset } from '../basic_soundfont/basic_preset.js'
 import { BasicPresetZone } from '../basic_soundfont/basic_zones.js'
 import { BasicInstrument } from '../basic_soundfont/basic_instrument.js'
+import { defaultModulators } from '../read_sf2/modulators.js'
 
 export class DLSPreset extends BasicPreset
 {
@@ -11,7 +12,8 @@ export class DLSPreset extends BasicPreset
      */
     constructor(ulBank, ulInstrument)
     {
-        super();
+        // use stock default modulators, dls won't ever have DMOD chunk
+        super(defaultModulators);
         this.program = ulInstrument & 127;
         this.bank = (ulBank >> 8) & 127;
         const isDrums = ulBank >> 31;

package/soundfont/dls/dls_zone.js

@@ -22,6 +22,7 @@ export class DLSZone extends BasicInstrumentZone
      * @param sampleKey {number}
      * @param sample {BasicSample}
      * @param sampleID {number}
+     * @param samplePitchCorrection {number} cents
      */
     setWavesample(
         attenuationCb,
@@ -30,6 +31,7 @@ export class DLSZone extends BasicInstrumentZone
         sampleKey,
         sample,
         sampleID,
+        samplePitchCorrection,
     )
     {
         if(loopingMode !== 0)
@@ -39,6 +41,18 @@ export class DLSZone extends BasicInstrumentZone
         this.generators.push(new Generator(generatorTypes.initialAttenuation, attenuationCb));
         this.isGlobal = false;
 
+        // correct tuning if needed
+        const coarseTune = Math.trunc(samplePitchCorrection / 100);
+        if(coarseTune !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.coarseTune, coarseTune));
+        }
+        const fineTune = samplePitchCorrection - (coarseTune * 100);
+        if(fineTune !== 0)
+        {
+            this.generators.push(new Generator(generatorTypes.fineTune, fineTune));
+        }
+
         // correct loop if needed
         const diffStart = loop.start - (sample.sampleLoopStartIndex / 2);
         const diffEnd = loop.end - (sample.sampleLoopEndIndex / 2);

package/soundfont/dls/read_region.js

@@ -1,4 +1,4 @@
-import { readLittleEndian } from '../../utils/byte_functions/little_endian.js'
+import { readLittleEndian, signedInt16 } from '../../utils/byte_functions/little_endian.js'
 import { findRIFFListType, readRIFFChunk } from '../basic_soundfont/riff_chunk.js'
 import { Generator, generatorTypes } from '../read_sf2/generators.js'
 import { DLSZone } from './dls_zone.js'
@@ -57,8 +57,12 @@ export function readRegion(chunk)
     // cbSize
     readLittleEndian(waveSampleChunk.chunkData, 4);
     const originalKey = readLittleEndian(waveSampleChunk.chunkData, 2);
-    // pitch correction is read from the wave wsmpl chunk
-    readLittleEndian(waveSampleChunk.chunkData, 2);
+
+    // sFineTune
+    const pitchCorrection = signedInt16(
+        waveSampleChunk.chunkData[waveSampleChunk.chunkData.currentIndex++],
+        waveSampleChunk.chunkData[waveSampleChunk.chunkData.currentIndex++]
+    );
 
     // gain correction:  Each unit of gain represents 1/655360 dB
     const gainCorrection = readLittleEndian(waveSampleChunk.chunkData, 4);
@@ -124,6 +128,7 @@ export function readRegion(chunk)
         loop,
         originalKey,
         sample,
-        sampleID);
+        sampleID,
+        pitchCorrection);
     return zone;
 }

package/soundfont/read_sf2/modulators.js

@@ -44,21 +44,21 @@ export class Modulator{
     constructor(dataArray) {
         if(dataArray.srcEnum)
         {
-            this.modulatorSource = dataArray.srcEnum;
+            this.sourceEnum = dataArray.srcEnum;
             /**
              * @type {generatorTypes}
              */
             this.modulatorDestination = dataArray.dest;
-            this.modulationSecondarySrc = dataArray.secSrcEnum;
+            this.secondarySourceEnum = dataArray.secSrcEnum;
             this.transformAmount = dataArray.amt;
             this.transformType = dataArray.transform;
         }
         else
         {
-            this.modulatorSource = readLittleEndian(dataArray, 2);
+            this.sourceEnum = readLittleEndian(dataArray, 2);
             this.modulatorDestination = readLittleEndian(dataArray, 2);
             this.transformAmount = signedInt16(dataArray[dataArray.currentIndex++], dataArray[dataArray.currentIndex++]);
-            this.modulationSecondarySrc = readLittleEndian(dataArray, 2);
+            this.secondarySourceEnum = readLittleEndian(dataArray, 2);
             this.transformType = readLittleEndian(dataArray, 2);
         }
 
@@ -68,22 +68,50 @@ export class Modulator{
         }
 
         // decode the source
-        this.sourcePolarity = this.modulatorSource >> 9 & 1;
-        this.sourceDirection = this.modulatorSource >> 8 & 1;
-        this.sourceUsesCC = this.modulatorSource >> 7 & 1;
-        this.sourceIndex = this.modulatorSource & 127;
-        this.sourceCurveType = this.modulatorSource >> 10 & 3;
+        this.sourcePolarity = this.sourceEnum >> 9 & 1;
+        this.sourceDirection = this.sourceEnum >> 8 & 1;
+        this.sourceUsesCC = this.sourceEnum >> 7 & 1;
+        this.sourceIndex = this.sourceEnum & 127;
+        this.sourceCurveType = this.sourceEnum >> 10 & 3;
 
         // decode the secondary source
-        this.secSrcPolarity = this.modulationSecondarySrc >> 9 & 1;
-        this.secSrcDirection = this.modulationSecondarySrc >> 8 & 1;
-        this.secSrcUsesCC = this.modulationSecondarySrc >> 7 & 1;
-        this.secSrcIndex = this.modulationSecondarySrc & 127;
-        this.secSrcCurveType = this.modulationSecondarySrc >> 10 & 3;
+        this.secSrcPolarity = this.secondarySourceEnum >> 9 & 1;
+        this.secSrcDirection = this.secondarySourceEnum >> 8 & 1;
+        this.secSrcUsesCC = this.secondarySourceEnum >> 7 & 1;
+        this.secSrcIndex = this.secondarySourceEnum & 127;
+        this.secSrcCurveType = this.secondarySourceEnum >> 10 & 3;
 
         //this.precomputeModulatorTransform();
     }
 
+    /**
+     * @param modulator {Modulator}
+     * @returns {Modulator}
+     */
+    static copy(modulator)
+    {
+        return new Modulator({
+            srcEnum: modulator.sourceEnum,
+            secSrcEnum: modulator.secondarySourceEnum,
+            transform: modulator.transformType,
+            amt: modulator.transformAmount,
+            dest: modulator.modulatorDestination
+        });
+    }
+
+    /**
+     * @param mod1 {Modulator}
+     * @param mod2 {Modulator}
+     * @returns {boolean}
+     */
+    static isIdentical(mod1, mod2)
+    {
+        return (mod1.sourceEnum === mod2.sourceEnum)
+            && (mod1.modulatorDestination === mod2.modulatorDestination)
+            && (mod1.secondarySourceEnum === mod2.secondarySourceEnum)
+            && (mod1.transformType === mod2.transformType);
+    }
+
     /**
      * Sums transform and creates a NEW modulator
      * @param modulator {Modulator}
@@ -92,8 +120,8 @@ export class Modulator{
     sumTransform(modulator)
     {
         return new Modulator({
-            srcEnum: this.modulatorSource,
-            secSrcEnum: this.modulationSecondarySrc,
+            srcEnum: this.sourceEnum,
+            secSrcEnum: this.secondarySourceEnum,
             dest: this.modulatorDestination,
             transform: this.transformType,
             amt: this.transformAmount + modulator.transformAmount
@@ -190,10 +218,10 @@ export const defaultModulators = [
     }),
 
     // reverb effects to send
-    new Modulator({srcEnum: 0x00DB, dest: generatorTypes.reverbEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+    new Modulator({srcEnum: 0x00DB, dest: generatorTypes.reverbEffectsSend, amt: 750, secSrcEnum: 0x0, transform: 0}),
 
     // chorus effects to send
-    new Modulator({srcEnum: 0x00DD, dest: generatorTypes.chorusEffectsSend, amt: 200, secSrcEnum: 0x0, transform: 0}),
+    new Modulator({srcEnum: 0x00DD, dest: generatorTypes.chorusEffectsSend, amt: 750, secSrcEnum: 0x0, transform: 0}),
 
     // custom modulators heck yeah
     // poly pressure to vibrato

package/soundfont/read_sf2/presets.js

@@ -13,10 +13,11 @@ export class Preset extends BasicPreset
     /**
      * Creates a preset
      * @param presetChunk {RiffChunk}
+     * @param defaultModulators {Modulator[]}
      */
-    constructor(presetChunk)
+    constructor(presetChunk, defaultModulators)
     {
-        super();
+        super(defaultModulators);
         this.presetName = readBytesAsString(presetChunk.chunkData, 20)
             .trim()
             .replace(/\d{3}:\d{3}/, ""); // remove those pesky "000:001"
@@ -51,9 +52,10 @@ export class Preset extends BasicPreset
  * Reads the presets
  * @param presetChunk {RiffChunk}
  * @param presetZones {PresetZone[]}
+ * @param defaultModulators {Modulator[]}
  * @returns {Preset[]}
  */
-export function readPresets(presetChunk, presetZones)
+export function readPresets(presetChunk, presetZones, defaultModulators)
 {
     /**
      * @type {Preset[]}
@@ -61,7 +63,7 @@ export function readPresets(presetChunk, presetZones)
     let presets = [];
     while(presetChunk.chunkData.length > presetChunk.chunkData.currentIndex)
     {
-        let preset = new Preset(presetChunk);
+        let preset = new Preset(presetChunk, defaultModulators);
         if(presets.length > 0)
         {
             let presetZonesAmount = preset.presetZoneStartIndex - presets[presets.length - 1].presetZoneStartIndex;

package/soundfont/read_sf2/soundfont.js

@@ -66,26 +66,41 @@ export class SoundFont2 extends BasicSoundFont
         {
             let chunk = readRIFFChunk(infoChunk.chunkData);
             let text;
-            // special case: ifil
+            // special cases
             switch (chunk.header.toLowerCase())
             {
                 case  "ifil":
                 case "iver":
                     text = `${readLittleEndian(chunk.chunkData, 2)}.${readLittleEndian(chunk.chunkData, 2)}`;
+                    this.soundFontInfo[chunk.header] = text;
                     break;
 
                 case "icmt":
                     text = readBytesAsString(chunk.chunkData, chunk.chunkData.length, undefined, false);
+                    this.soundFontInfo[chunk.header] = text;
+                    break;
+
+                // dmod: default modulators
+                case "dmod":
+                    const newModulators = readModulators(chunk);
+                    newModulators.pop(); // remove the terminal record
+                    text = `Modulators: ${newModulators.length}`;
+                    // override default modulators
+                    const oldDefaults = this.defaultModulators;
+
+                    this.defaultModulators = newModulators;
+                    this.defaultModulators.push(...oldDefaults.filter(m => !this.defaultModulators.find(mm => Modulator.isIdentical(m, mm))));
+                    this.soundFontInfo[chunk.header] = chunk.chunkData;
                     break;
 
                 default:
                     text = readBytesAsString(chunk.chunkData, chunk.chunkData.length);
+                    this.soundFontInfo[chunk.header] = text;
             }
 
             SpessaSynthInfo(`%c"${chunk.header}": %c"${text}"`,
                 consoleColors.info,
                 consoleColors.recognized);
-            this.soundFontInfo[chunk.header] = text;
         }
 
         // SDTA
@@ -214,7 +229,7 @@ export class SoundFont2 extends BasicSoundFont
 
         let presetZones = readPresetZones(presetZonesChunk, presetGenerators, presetModulators, this.instruments);
 
-        this.presets.push(...readPresets(presetHeadersChunk, presetZones));
+        this.presets.push(...readPresets(presetHeadersChunk, presetZones, this.defaultModulators));
         this.presets.sort((a, b) => (a.program - b.program) + (a.bank - b.bank));
         // preload the first preset
         SpessaSynthInfo(`%cParsing finished! %c"${this.soundFontInfo["INAM"]}"%c has %c${this.presets.length} %cpresets,