spessasynth_core 3.26.16 → 3.26.18

package/src/soundfont/basic_soundfont/modulator.js

@@ -1,11 +1,16 @@
-import { generatorTypes, MAX_GENERATOR } from "./generator.js";
 import { midiControllers } from "../../midi/midi_message.js";
+import { generatorTypes, MAX_GENERATOR } from "./generator_types.js";
 
 /**
  * modulators.js
  * purpose: parses soundfont modulators and the source enums, also includes the default modulators list
  **/
 
+export const MOD_BYTE_SIZE = 10;
+
+/**
+ * @enum {number}
+ */
 export const modulatorSources = {
     noController: 0,
     noteOnVelocity: 2,
@@ -17,6 +22,11 @@ export const modulatorSources = {
     link: 127
     
 };
+
+/**
+ *
+ * @enum {number}
+ */
 export const modulatorCurveTypes = {
     linear: 0,
     concave: 1,
@@ -27,23 +37,11 @@ export const modulatorCurveTypes = {
 export class Modulator
 {
     /**
-     * The current computed value of this modulator
+     * The current computed value of this modulator. Only used in the synthesis engine for local voices
      * @type {number}
      */
     currentValue = 0;
     
-    /**
-     * The source enumeration for this modulator
-     * @type {number}
-     */
-    sourceEnum;
-    
-    /**
-     * The secondary source enumeration for this modulator
-     * @type {number}
-     */
-    secondarySourceEnum;
-    
     /**
      * The generator destination of this modulator
      * @type {generatorTypes}
@@ -63,18 +61,123 @@ export class Modulator
     transformType;
     
     /**
-     * creates a modulator
-     * @param srcEnum {number}
-     * @param secSrcEnum {number}
-     * @param destination {generatorTypes|number}
+     * Indicates if the given modulator is chorus or reverb effects modulator.
+     * This is done to simulate BASSMIDI effects behavior:
+     * - defaults to 1000 transform amount rather than 200
+     * - values can be changed, but anything above 200 is 1000
+     * (except for values above 1000, they are copied directly)
+     * - all values below are multiplied by 5 (200 * 5 = 1000)
+     * - still can be disabled if the soundfont has its own modulator curve
+     * - this fixes the very low amount of reverb by default and doesn't break soundfonts
+     * @type {boolean}
+     */
+    isEffectModulator = false;
+    
+    /**
+     * 1 if the source is bipolar (min is -1, max is 1)
+     * otherwise min is 0 and max is 1
+     * @type {0|1}
+     */
+    sourcePolarity;
+    
+    /**
+     * 1 if the source is negative (from 1 to 0)
+     * @type {0|1}
+     */
+    sourceDirection;
+    
+    /**
+     * 1 if the source uses a MIDI CC
+     * @type {0|1}
+     */
+    sourceUsesCC;
+    
+    /**
+     * source index/CC number
+     * @type {modulatorSources|midiControllers}
+     */
+    sourceIndex;
+    
+    /**
+     * source curve type
+     * @type {modulatorCurveTypes}
+     */
+    sourceCurveType;
+    
+    /**
+     * 1 if the source is bipolar (min is -1, max is 1)
+     * otherwise min is 0 and max is 1
+     * @type {0|1}
+     */
+    secSrcPolarity;
+    
+    /**
+     * 1 if the source is negative (from 1 to 0)
+     * @type {0|1}
+     */
+    secSrcDirection;
+    
+    /**
+     * 1 if the source uses a MIDI CC
+     * @type {0|1}
+     */
+    secSrcUsesCC;
+    
+    /**
+     * source index/CC number
+     * @type {modulatorSources|midiControllers}
+     */
+    secSrcIndex;
+    
+    /**
+     * source curve type
+     * @type {modulatorCurveTypes}
+     */
+    secSrcCurveType;
+    
+    /**
+     * Creates a new SF2 Modulator
+     * @param sourceIndex {modulatorSources|midiControllers}
+     * @param sourceCurveType {modulatorCurveTypes}
+     * @param sourceUsesCC {0|1}
+     * @param sourcePolarity {0|1}
+     * @param sourceDirection {0|1}
+     * @param secSrcIndex {modulatorSources|midiControllers}
+     * @param secSrcCurveType {modulatorCurveTypes}
+     * @param secSrcUsesCC {0|1}
+     * @param secSrcPolarity {0|1}
+     * @param secSrcDirection {0|1}
+     * @param destination {generatorTypes}
      * @param amount {number}
-     * @param transformType {number}
+     * @param transformType {0|2}
      */
-    constructor(srcEnum, secSrcEnum, destination, amount, transformType)
+    constructor(sourceIndex,
+                sourceCurveType,
+                sourceUsesCC,
+                sourcePolarity,
+                sourceDirection,
+                secSrcIndex,
+                secSrcCurveType,
+                secSrcUsesCC,
+                secSrcPolarity,
+                secSrcDirection,
+                destination,
+                amount,
+                transformType)
     {
-        this.sourceEnum = srcEnum;
+        this.sourcePolarity = sourcePolarity;
+        this.sourceDirection = sourceDirection;
+        this.sourceUsesCC = sourceUsesCC;
+        this.sourceIndex = sourceIndex;
+        this.sourceCurveType = sourceCurveType;
+        
+        this.secSrcPolarity = secSrcPolarity;
+        this.secSrcDirection = secSrcDirection;
+        this.secSrcUsesCC = secSrcUsesCC;
+        this.secSrcIndex = secSrcIndex;
+        this.secSrcCurveType = secSrcCurveType;
+        
         this.modulatorDestination = destination;
-        this.secondarySourceEnum = secSrcEnum;
         this.transformAmount = amount;
         this.transformType = transformType;
         
@@ -84,41 +187,6 @@ export class Modulator
             this.modulatorDestination = generatorTypes.INVALID; // flag as invalid (for linked ones)
         }
         
-        // decode the source
-        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.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;
-        
-        /**
-         * Indicates if the given modulator is chorus or reverb effects modulator.
-         * This is done to simulate BASSMIDI effects behavior:
-         * - defaults to 1000 transform amount rather than 200
-         * - values can be changed, but anything above 200 is 1000
-         * (except for values above 1000, they are copied directly)
-         * - all values below are multiplied by 5 (200 * 5 = 1000)
-         * - still can be disabled if the soundfont has its own modulator curve
-         * - this fixes the very low amount of reverb by default and doesn't break soundfonts
-         * @type {boolean}
-         */
-        this.isEffectModulator =
-            (
-                this.sourceEnum === 0x00DB
-                || this.sourceEnum === 0x00DD
-            )
-            && this.secondarySourceEnum === 0x0
-            && (
-                this.modulatorDestination === generatorTypes.reverbEffectsSend
-                || this.modulatorDestination === generatorTypes.chorusEffectsSend
-            );
     }
     
     /**
@@ -128,8 +196,16 @@ export class Modulator
     static copy(modulator)
     {
         return new Modulator(
-            modulator.sourceEnum,
-            modulator.secondarySourceEnum,
+            modulator.sourceIndex,
+            modulator.sourceCurveType,
+            modulator.sourceUsesCC,
+            modulator.sourcePolarity,
+            modulator.sourceDirection,
+            modulator.secSrcIndex,
+            modulator.secSrcCurveType,
+            modulator.secSrcUsesCC,
+            modulator.secSrcPolarity,
+            modulator.secSrcDirection,
             modulator.modulatorDestination,
             modulator.transformAmount,
             modulator.transformType
@@ -144,9 +220,19 @@ export class Modulator
      */
     static isIdentical(mod1, mod2, checkAmount = false)
     {
-        return (mod1.sourceEnum === mod2.sourceEnum)
+        return (mod1.sourceIndex === mod2.sourceIndex)
+            && (mod1.sourceUsesCC === mod2.sourceUsesCC)
+            && (mod1.sourcePolarity === mod2.sourcePolarity)
+            && (mod1.sourceDirection === mod2.sourceDirection)
+            && (mod1.sourceCurveType === mod2.sourceCurveType)
+            
+            && (mod1.secSrcIndex === mod2.secSrcIndex)
+            && (mod1.secSrcUsesCC === mod2.secSrcUsesCC)
+            && (mod1.secSrcPolarity === mod2.secSrcPolarity)
+            && (mod1.secSrcDirection === mod2.secSrcDirection)
+            && (mod1.secSrcCurveType === mod2.secSrcCurveType)
+            
             && (mod1.modulatorDestination === mod2.modulatorDestination)
-            && (mod1.secondarySourceEnum === mod2.secondarySourceEnum)
             && (mod1.transformType === mod2.transformType)
             && (!checkAmount || (mod1.transformAmount === mod2.transformAmount));
     }
@@ -176,7 +262,7 @@ export class Modulator
         
         let secSrcString = getKeyByValue(modulatorCurveTypes, mod.secSrcCurveType);
         secSrcString += mod.secSrcPolarity === 0 ? " unipolar " : " bipolar ";
-        secSrcString += mod.secSrcCurveType === 0 ? "forwards " : "backwards ";
+        secSrcString += mod.secSrcDirection === 0 ? "forwards " : "backwards ";
         if (mod.secSrcUsesCC)
         {
             secSrcString += getKeyByValue(midiControllers, mod.secSrcIndex);
@@ -194,6 +280,28 @@ export class Modulator
         \n\n`;
     }
     
+    getSourceEnum()
+    {
+        return getModSourceEnum(
+            this.sourceCurveType,
+            this.sourcePolarity,
+            this.sourceDirection,
+            this.sourceUsesCC,
+            this.sourceIndex
+        );
+    }
+    
+    getSecSrcEnum()
+    {
+        return getModSourceEnum(
+            this.secSrcCurveType,
+            this.secSrcPolarity,
+            this.secSrcDirection,
+            this.secSrcUsesCC,
+            this.secSrcIndex
+        );
+    }
+    
     /**
      * Sum transform and create a NEW modulator
      * @param modulator {Modulator}
@@ -202,8 +310,16 @@ export class Modulator
     sumTransform(modulator)
     {
         return new Modulator(
-            this.sourceEnum,
-            this.secondarySourceEnum,
+            this.sourceIndex,
+            this.sourceCurveType,
+            this.sourceUsesCC,
+            this.sourcePolarity,
+            this.sourceDirection,
+            this.secSrcIndex,
+            this.secSrcCurveType,
+            this.secSrcUsesCC,
+            this.secSrcPolarity,
+            this.secSrcDirection,
             this.modulatorDestination,
             this.transformAmount + modulator.transformAmount,
             this.transformType
@@ -211,6 +327,62 @@ export class Modulator
     }
 }
 
+export class DecodedModulator extends Modulator
+{
+    /**
+     * reads an SF2 modulator
+     * @param sourceEnum {number} SF2 source enum
+     * @param secondarySourceEnum {number} SF2 secondary source enum
+     * @param destination {generatorTypes|number} destination
+     * @param amount {number} amount
+     * @param transformType {number} transform type
+     */
+    constructor(sourceEnum, secondarySourceEnum, destination, amount, transformType)
+    {
+        // decode the source
+        const sourcePolarity = sourceEnum >> 9 & 1;
+        const sourceDirection = sourceEnum >> 8 & 1;
+        const sourceUsesCC = sourceEnum >> 7 & 1;
+        const sourceIndex = /** @type {modulatorSources} **/ sourceEnum & 127;
+        const sourceCurveType = /** @type {modulatorCurveTypes} **/ sourceEnum >> 10 & 3;
+        
+        // decode the secondary source
+        const secSrcPolarity = secondarySourceEnum >> 9 & 1;
+        const secSrcDirection = secondarySourceEnum >> 8 & 1;
+        const secSrcUsesCC = secondarySourceEnum >> 7 & 1;
+        const secSrcIndex = /** @type {modulatorSources} **/ secondarySourceEnum & 127;
+        const secSrcCurveType = /** @type {modulatorCurveTypes} **/ secondarySourceEnum >> 10 & 3;
+        
+        super(
+            sourceIndex,
+            sourceCurveType,
+            sourceUsesCC,
+            sourcePolarity,
+            sourceDirection,
+            secSrcIndex,
+            secSrcCurveType,
+            secSrcUsesCC,
+            secSrcPolarity,
+            secSrcDirection,
+            destination,
+            amount,
+            transformType
+        );
+        
+        
+        this.isEffectModulator =
+            (
+                sourceEnum === 0x00DB
+                || sourceEnum === 0x00DD
+            )
+            && secondarySourceEnum === 0x0
+            && (
+                this.modulatorDestination === generatorTypes.reverbEffectsSend
+                || this.modulatorDestination === generatorTypes.chorusEffectsSend
+            );
+    }
+}
+
 export const DEFAULT_ATTENUATION_MOD_AMOUNT = 960;
 export const DEFAULT_ATTENUATION_MOD_CURVE_TYPE = modulatorCurveTypes.concave;
 
@@ -221,7 +393,7 @@ export function getModSourceEnum(curveType, polarity, direction, isCC, index)
 
 const soundFontModulators = [
     // vel to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -236,10 +408,10 @@ const soundFontModulators = [
     ),
     
     // mod wheel to vibrato
-    new Modulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    new DecodedModulator(0x0081, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
     
     // vol to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -254,17 +426,17 @@ const soundFontModulators = [
     ),
     
     // channel pressure to vibrato
-    new Modulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
+    new DecodedModulator(0x000D, 0x0, generatorTypes.vibLfoToPitch, 50, 0),
     
     // pitch wheel to tuning
-    new Modulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
+    new DecodedModulator(0x020E, 0x0010, generatorTypes.fineTune, 12700, 0),
     
     // pan to uhh, pan
     // amount is 500 instead of 1000, see #59
-    new Modulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
+    new DecodedModulator(0x028A, 0x0, generatorTypes.pan, 500, 0),
     
     // expression to attenuation
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             DEFAULT_ATTENUATION_MOD_CURVE_TYPE,
             0,
@@ -279,16 +451,16 @@ const soundFontModulators = [
     ),
     
     // reverb effects to send
-    new Modulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
+    new DecodedModulator(0x00DB, 0x0, generatorTypes.reverbEffectsSend, 200, 0),
     
     // chorus effects to send
-    new Modulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
+    new DecodedModulator(0x00DD, 0x0, generatorTypes.chorusEffectsSend, 200, 0)
 ];
 
 const customModulators = [
     // custom modulators heck yeah
     // poly pressure to vibrato
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(modulatorCurveTypes.linear, 0, 0, 0, modulatorSources.polyPressure),
         0x0,
         generatorTypes.vibLfoToPitch,
@@ -297,7 +469,7 @@ const customModulators = [
     ),
     
     // cc 92 (tremolo) to modLFO volume
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             0,
@@ -312,7 +484,7 @@ const customModulators = [
     ),
     
     // cc 73 (attack time) to volEnv attack
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.convex,
             1,
@@ -327,7 +499,7 @@ const customModulators = [
     ),
     
     // cc 72 (release time) to volEnv release
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,
@@ -342,7 +514,7 @@ const customModulators = [
     ),
     
     // cc 74 (brightness) to filterFc
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,
@@ -357,7 +529,7 @@ const customModulators = [
     ),
     
     // cc 71 (filter Q) to filter Q
-    new Modulator(
+    new DecodedModulator(
         getModSourceEnum(
             modulatorCurveTypes.linear,
             1,

package/src/soundfont/basic_soundfont/write_dls/art2.js

@@ -1,7 +1,7 @@
 import { getDLSArticulatorFromSf2Generator, getDLSArticulatorFromSf2Modulator } from "./modulator_converter.js";
 import { writeRIFFOddSize } from "../riff_chunk.js";
 import { combineArrays, IndexedByteArray } from "../../../utils/indexed_array.js";
-import { Generator, generatorTypes } from "../generator.js";
+import { Generator } from "../generator.js";
 import { writeDword } from "../../../utils/byte_functions/little_endian.js";
 import { consoleColors } from "../../../utils/other.js";
 import { SpessaSynthInfo, SpessaSynthWarn } from "../../../utils/loggin.js";
@@ -12,6 +12,7 @@ import {
     DLS_1_NO_VIBRATO_MOD,
     DLS_1_NO_VIBRATO_PRESSURE
 } from "../../dls/dls_sources.js";
+import { generatorTypes } from "../generator_types.js";
 
 const invalidGeneratorTypes = new Set([
     generatorTypes.sampleModes,
@@ -34,7 +35,7 @@ const invalidGeneratorTypes = new Set([
 ]);
 
 /**
- * @param zone {BasicInstrumentZone}
+ * @param zone {BasicZone}
  * @returns {IndexedByteArray}
  */
 export function writeArticulator(zone)

package/src/soundfont/basic_soundfont/write_dls/combine_zones.js

@@ -1,6 +1,8 @@
 import { Modulator } from "../modulator.js";
-import { BasicInstrumentZone } from "../basic_zones.js";
-import { Generator, generatorLimits, generatorTypes } from "../generator.js";
+import { Generator } from "../generator.js";
+import { generatorLimits, generatorTypes } from "../generator_types.js";
+import { BasicInstrumentZone } from "../basic_instrument_zone.js";
+import { BasicGlobalZone } from "../basic_global_zone.js";
 
 const notGlobalizedTypes = new Set([
     generatorTypes.velRange,
@@ -30,7 +32,7 @@ const notGlobalizedTypes = new Set([
  * Combines preset zones
  * @param preset {BasicPreset}
  * @param globalize {boolean}
- * @returns {BasicInstrumentZone[]}
+ * @returns {{global: BasicGlobalZone, zones: BasicInstrumentZone[]}}
  */
 export function combineZones(preset, globalize = true)
 {
@@ -75,25 +77,16 @@ export function combineZones(preset, globalize = true)
      * @type {Modulator[]}
      */
     const globalPresetModulators = [];
-    let globalPresetKeyRange = { min: 0, max: 127 };
-    let globalPresetVelRange = { min: 0, max: 127 };
     
     // find the global zone and apply ranges, generators, and modulators
-    const globalPresetZone = preset.presetZones.find(z => z.isGlobal);
-    if (globalPresetZone)
-    {
-        globalPresetGenerators.push(...globalPresetZone.generators);
-        globalPresetModulators.push(...globalPresetZone.modulators);
-        globalPresetKeyRange = globalPresetZone.keyRange;
-        globalPresetVelRange = globalPresetZone.velRange;
-    }
+    const globalPresetZone = preset.globalZone;
+    globalPresetGenerators.push(...globalPresetZone.generators);
+    globalPresetModulators.push(...globalPresetZone.modulators);
+    let globalPresetKeyRange = globalPresetZone.keyRange;
+    let globalPresetVelRange = globalPresetZone.velRange;
     // for each non-global preset zone
     for (const presetZone of preset.presetZones)
     {
-        if (presetZone.isGlobal)
-        {
-            continue;
-        }
         // use global ranges if not provided
         let presetZoneKeyRange = presetZone.keyRange;
         if (!presetZone.hasKeyRange)
@@ -110,8 +103,8 @@ export function combineZones(preset, globalize = true)
         addUnique(presetGenerators, globalPresetGenerators);
         const presetModulators = [...presetZone.modulators];
         addUniqueMods(presetModulators, globalPresetModulators);
-        
-        const iZones = presetZone.instrument.instrumentZones;
+        const instrument = presetZone.instrument;
+        const iZones = instrument.instrumentZones;
         /**
          * @type {Generator[]}
          */
@@ -120,23 +113,14 @@ export function combineZones(preset, globalize = true)
          * @type {Modulator[]}
          */
         const globalInstModulators = [];
-        let globalInstKeyRange = { min: 0, max: 127 };
-        let globalInstVelRange = { min: 0, max: 127 };
-        const globalInstZone = iZones.find(z => z.isGlobal);
-        if (globalInstZone)
-        {
-            globalInstGenerators.push(...globalInstZone.generators);
-            globalInstModulators.push(...globalInstZone.modulators);
-            globalInstKeyRange = globalInstZone.keyRange;
-            globalInstVelRange = globalInstZone.velRange;
-        }
+        const globalInstZone = instrument.globalZone;
+        globalInstGenerators.push(...globalInstZone.generators);
+        globalInstModulators.push(...globalInstZone.modulators);
+        let globalInstKeyRange = globalInstZone.keyRange;
+        let globalInstVelRange = globalInstZone.velRange;
         // for each non-global instrument zone
         for (const instZone of iZones)
         {
-            if (instZone.isGlobal)
-            {
-                continue;
-            }
             // use global ranges if not provided
             let instZoneKeyRange = instZone.keyRange;
             if (!instZone.hasKeyRange)
@@ -236,20 +220,17 @@ export function combineZones(preset, globalize = true)
             {
                 zone.velRange.min = -1;
             }
-            zone.isGlobal = false;
-            zone.sample = instZone.sample;
+            zone.setSample(instZone.sample);
             zone.generators = finalGenList;
             zone.modulators = finalModList;
             finalZones.push(zone);
         }
     }
-    
+    const globalZone = new BasicGlobalZone();
     if (globalize)
     {
         // create a global zone and add repeating generators to it
         // also modulators
-        const globalZone = new BasicInstrumentZone();
-        globalZone.isGlobal = true;
         // iterate over every type of generator
         for (let checkedType = 0; checkedType < 58; checkedType++)
         {
@@ -356,14 +337,14 @@ export function combineZones(preset, globalize = true)
         }
         
         // globalize only modulators that exist in all zones
-        const firstZone = finalZones.find(z => !z.isGlobal);
+        const firstZone = finalZones[0];
         const modulators = firstZone.modulators.map(m => Modulator.copy(m));
         for (const checkedModulator of modulators)
         {
             let existsForAllZones = true;
             for (const zone of finalZones)
             {
-                if (zone.isGlobal || !existsForAllZones)
+                if (!existsForAllZones)
                 {
                     continue;
                 }
@@ -394,7 +375,9 @@ export function combineZones(preset, globalize = true)
                 }
             }
         }
-        finalZones.splice(0, 0, globalZone);
     }
-    return finalZones;
+    return {
+        zones: finalZones,
+        global: globalZone
+    };
 }