spessasynth_lib 3.24.25 → 3.24.26

package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -87,13 +87,14 @@ export function handleMessage(message)
             {
                 for (let i = 0; i < this.workletProcessorChannels.length; i++)
                 {
+                    const chan = this.workletProcessorChannels[i];
                     if (data.rate === -1)
                     {
-                        channelObject.disableAndLockGSNRPN();
+                        chan.disableAndLockGSNRPN();
                     }
                     else
                     {
-                        channelObject.setVibrato(data.depth, data.rate, data.delay);
+                        chan.setVibrato(data.depth, data.rate, data.delay);
                     }
                 }
             }

package/synthetizer/worklet_system/snapshot/channel_snapshot.js

@@ -72,12 +72,6 @@ export class ChannelSnapshot
      */
     channelOctaveTuning;
     
-    /**
-     * Tuning of individual keys in cents.
-     * @type {Int16Array}
-     */
-    keyCentTuning;
-    
     /**
      * Indicates whether the channel is muted.
      * @type {boolean}
@@ -124,7 +118,6 @@ export class ChannelSnapshot
         // tuning and transpose data
         channelSnapshot.channelTransposeKeyShift = channelObject.channelTransposeKeyShift;
         channelSnapshot.channelOctaveTuning = channelObject.channelOctaveTuning;
-        channelSnapshot.keyCentTuning = channelObject.keyCentTuning;
         
         // other data
         channelSnapshot.isMuted = channelObject.isMuted;

package/synthetizer/worklet_system/worklet_methods/controller_control/controller_change.js

@@ -51,6 +51,11 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
     {
         return;
     }
+    
+    // apply the cc to the table
+    this.midiControllers[controllerNumber] = controllerValue << 7;
+    
+    // interpret special CCs
     switch (controllerNumber)
     {
         case midiControllers.allNotesOff:
@@ -97,6 +102,13 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
                         {
                             this.setDrums(true);
                         }
+                        else
+                        {
+                            if (this.channelNumber % 16 !== DEFAULT_PERCUSSION)
+                            {
+                                this.setDrums(false);
+                            }
+                        }
                 }
                 
                 if (this.drumChannel)
@@ -135,22 +147,18 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
         
         // check for RPN and NPRN and data entry
         case midiControllers.RPNLsb:
-            this.RPValue = this.RPValue << 7 | controllerValue;
             this.dataEntryState = dataEntryStates.RPFine;
             break;
         
         case midiControllers.RPNMsb:
-            this.RPValue = controllerValue;
             this.dataEntryState = dataEntryStates.RPCoarse;
             break;
         
         case midiControllers.NRPNMsb:
-            this.NRPCoarse = controllerValue;
             this.dataEntryState = dataEntryStates.NRPCoarse;
             break;
         
         case midiControllers.NRPNLsb:
-            this.NRPFine = controllerValue;
             this.dataEntryState = dataEntryStates.NRPFine;
             break;
         
@@ -163,7 +171,7 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
             break;
         
         case midiControllers.resetAllControllers:
-            this.resetControllers();
+            this.resetControllersRP15Compliant();
             break;
         
         case midiControllers.sustainPedal:
@@ -182,9 +190,8 @@ export function controllerChange(controllerNumber, controllerValue, force = fals
             }
             break;
         
-        // default: apply the controller to the table
+        // default: just compute modulators
         default:
-            this.midiControllers[controllerNumber] = controllerValue << 7;
             this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, controllerNumber));
             break;
     }

package/synthetizer/worklet_system/worklet_methods/controller_control/reset_controllers.js

@@ -9,6 +9,8 @@ import {
     NON_CC_INDEX_OFFSET,
     resetArray
 } from "../../worklet_utilities/controller_tables.js";
+import { midiControllers } from "../../../../midi_parser/midi_message.js";
+
 
 /**
  * Full system reset
@@ -117,7 +119,6 @@ export function resetAllControllers(log = true)
 export function resetControllers()
 {
     this.channelOctaveTuning.fill(0);
-    this.keyCentTuning.fill(0);
     
     // reset the array
     for (let i = 0; i < resetArray.length; i++)
@@ -129,14 +130,14 @@ export function resetControllers()
         const resetValue = resetArray[i];
         if (this.midiControllers[i] !== resetValue && i < 127)
         {
-            // call cc change if reset
-            this.synth.callEvent("controllerchange", {
-                channel: this.channelNumber,
-                controllerNumber: i,
-                controllerValue: resetValue >> 7
-            });
+            // reset if reset
+            this.controllerChange(i, resetValue >> 7);
+        }
+        else
+        {
+            // out of range, do a regular reset
+            this.midiControllers[i] = resetValue;
         }
-        this.midiControllers[i] = resetValue;
     }
     this.channelVibrato = { rate: 0, depth: 0, delay: 0 };
     this.holdPedal = false;
@@ -152,26 +153,71 @@ export function resetControllers()
     
 }
 
+
+/**
+ * @type {Set<midiControllers|number>}
+ */
+export const nonResetableCCs = new Set([
+    midiControllers.bankSelect,
+    midiControllers.lsbForControl0BankSelect,
+    midiControllers.mainVolume,
+    midiControllers.lsbForControl7MainVolume,
+    midiControllers.pan,
+    midiControllers.lsbForControl10Pan,
+    midiControllers.reverbDepth,
+    midiControllers.tremoloDepth,
+    midiControllers.chorusDepth,
+    midiControllers.detuneDepth,
+    midiControllers.phaserDepth,
+    midiControllers.soundVariation,
+    midiControllers.filterResonance,
+    midiControllers.releaseTime,
+    midiControllers.attackTime,
+    midiControllers.brightness,
+    midiControllers.decayTime,
+    midiControllers.vibratoRate,
+    midiControllers.vibratoDepth,
+    midiControllers.vibratoDelay,
+    midiControllers.soundController10
+]);
+
+/**
+ * Reset all controllers for channel, but RP-15 compliant
+ *  https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
+ *  @this {WorkletProcessorChannel}
+ */
+export function resetControllersRP15Compliant()
+{
+    // reset tunings
+    this.channelOctaveTuning.fill(0);
+    
+    // reset pitch bend
+    this.pitchWheel(64, 0);
+    
+    this.channelVibrato = { rate: 0, depth: 0, delay: 0 };
+    
+    for (let i = 0; i < 128; i++)
+    {
+        const resetValue = resetArray[i];
+        if (!nonResetableCCs.has(i) && resetValue !== this.midiControllers[i])
+        {
+            this.controllerChange(i, resetValue);
+        }
+    }
+}
+
 /**
  * @this {WorkletProcessorChannel}
  */
 export function resetParameters()
 {
-    // reset parameters
-    /**
-     * @type {number}
-     */
-    this.NRPCoarse = 0;
-    /**
-     * @type {number}
-     */
-    this.NRPFine = 0;
-    /**
-     * @type {number}
-     */
-    this.RPValue = 0;
     /**
+     * reset the state machine to idle
      * @type {string}
      */
     this.dataEntryState = dataEntryStates.Idle;
+    SpessaSynthInfo(
+        "%cResetting Registered and Non-Registered Parameters!",
+        consoleColors.info
+    );
 }

package/synthetizer/worklet_system/worklet_methods/data_entry/data_entry_coarse.js

@@ -1,9 +1,41 @@
-import { dataEntryStates, NON_CC_INDEX_OFFSET } from "../../worklet_utilities/controller_tables.js";
+import { customControllers, dataEntryStates, NON_CC_INDEX_OFFSET } from "../../worklet_utilities/controller_tables.js";
 import { SpessaSynthInfo, SpessaSynthWarn } from "../../../../utils/loggin.js";
 import { consoleColors } from "../../../../utils/other.js";
 import { midiControllers } from "../../../../midi_parser/midi_message.js";
 import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
 
+
+/**
+ * @enum {number}
+ */
+const registeredParameterTypes = {
+    pitchBendRange: 0x0000,
+    fineTuning: 0x0001,
+    coarseTuning: 0x0002,
+    modulationDepth: 0x0005,
+    resetParameters: 0x3FFF
+};
+
+/**
+ * https://cdn.roland.com/assets/media/pdf/SC-88PRO_OM.pdf
+ * http://hummer.stanford.edu/sig/doc/classes/MidiOutput/rpn.html
+ * @enum {number}
+ */
+const nonRegisteredParameterNumbers = {
+    partParameter: 0x01,
+    
+    vibratoRate: 0x08,
+    vibratoDepth: 0x09,
+    vibratoDelay: 0x0A,
+    
+    EGAttackTime: 0x64,
+    EGReleaseTime: 0x66,
+    
+    TVFFilterCutoff: 0x20,
+    drumReverb: 0x1D
+};
+
+
 /**
  * Executes a data entry for an NRP for a sc88pro NRP (because touhou yes) and RPN tuning
  * @param dataValue {number} dataEntryCoarse MSB
@@ -12,7 +44,7 @@ import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulato
  */
 export function dataEntryCoarse(dataValue)
 {
-    let addDefaultVibrato = () =>
+    const addDefaultVibrato = () =>
     {
         if (this.channelVibrato.delay === 0 && this.channelVibrato.rate === 0 && this.channelVibrato.depth === 0)
         {
@@ -21,24 +53,43 @@ export function dataEntryCoarse(dataValue)
             this.channelVibrato.delay = 0.6;
         }
     };
+    
+    const coolInfo = (what, value, type) =>
+    {
+        if (type.length > 0)
+        {
+            type = " " + type;
+        }
+        SpessaSynthInfo(
+            `%c${what} for %c${this.channelNumber}%c is now set to %c${value}%c${type}.`,
+            consoleColors.info,
+            consoleColors.recognized,
+            consoleColors.info,
+            consoleColors.value,
+            consoleColors.info
+        );
+    };
     switch (this.dataEntryState)
     {
         default:
         case dataEntryStates.Idle:
             break;
         
-        // https://cdn.roland.com/assets/media/pdf/SC-88PRO_OM.pdf
-        // http://hummer.stanford.edu/sig/doc/classes/MidiOutput/rpn.html
+        // process GS NRPNs
         case dataEntryStates.NRPFine:
-            if (this.synth.system !== "gs")
-            {
-                return;
-            }
             if (this.lockGSNRPNParams)
             {
                 return;
             }
-            switch (this.NRPCoarse)
+            /**
+             * @type {number}
+             */
+            const NRPNCoarse = this.midiControllers[midiControllers.NRPNMsb] >> 7;
+            /**
+             * @type {number}
+             */
+            const NRPNFine = this.midiControllers[midiControllers.NRPNLsb] >> 7;
+            switch (NRPNCoarse)
             {
                 default:
                     if (dataValue === 64)
@@ -47,8 +98,8 @@ export function dataEntryCoarse(dataValue)
                         return;
                     }
                     SpessaSynthWarn(
-                        `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${this.NRPCoarse.toString(16)
-                            .toUpperCase()} 0x${this.NRPFine.toString(
+                        `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${NRPNFine.toString(16)
+                            .toUpperCase()} 0x${NRPNFine.toString(
                             16).toUpperCase()})%c data value: %c${dataValue}`,
                         consoleColors.warn,
                         consoleColors.recognized,
@@ -60,8 +111,8 @@ export function dataEntryCoarse(dataValue)
                     break;
                 
                 // part parameters: vibrato, cutoff
-                case 0x01:
-                    switch (this.NRPFine)
+                case nonRegisteredParameterNumbers.partParameter:
+                    switch (NRPNFine)
                     {
                         default:
                             if (dataValue === 64)
@@ -70,7 +121,7 @@ export function dataEntryCoarse(dataValue)
                                 return;
                             }
                             SpessaSynthWarn(
-                                `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${this.NRPCoarse.toString(16)} 0x${this.NRPFine.toString(
+                                `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${NRPNCoarse.toString(16)} 0x${NRPNFine.toString(
                                     16)})%c data value: %c${dataValue}`,
                                 consoleColors.warn,
                                 consoleColors.recognized,
@@ -82,96 +133,81 @@ export function dataEntryCoarse(dataValue)
                             break;
                         
                         // vibrato rate
-                        case 0x08:
+                        case nonRegisteredParameterNumbers.vibratoRate:
                             if (dataValue === 64)
                             {
                                 return;
                             }
                             addDefaultVibrato();
                             this.channelVibrato.rate = (dataValue / 64) * 8;
-                            SpessaSynthInfo(
-                                `%cVibrato rate for %c${this.channelNumber}%c is now set to %c${dataValue} = ${this.channelVibrato.rate}%cHz.`,
-                                consoleColors.info,
-                                consoleColors.recognized,
-                                consoleColors.info,
-                                consoleColors.value,
-                                consoleColors.info
-                            );
+                            coolInfo("Vibrato rate", `${dataValue} = ${this.channelVibrato.rate}`, "Hz");
                             break;
                         
                         // vibrato depth
-                        case 0x09:
+                        case nonRegisteredParameterNumbers.vibratoDepth:
                             if (dataValue === 64)
                             {
                                 return;
                             }
                             addDefaultVibrato();
                             this.channelVibrato.depth = dataValue / 2;
-                            SpessaSynthInfo(
-                                `%cVibrato depth for %c${this.channelNumber}%c is now set to %c${dataValue} = ${this.channelVibrato.depth}%c cents range of detune.`,
-                                consoleColors.info,
-                                consoleColors.recognized,
-                                consoleColors.info,
-                                consoleColors.value,
-                                consoleColors.info
-                            );
+                            coolInfo("Vibrato depth", `${dataValue} = ${this.channelVibrato.depth}`, "cents of detune");
                             break;
                         
                         // vibrato delay
-                        case 0x0A:
+                        case nonRegisteredParameterNumbers.vibratoDelay:
                             if (dataValue === 64)
                             {
                                 return;
                             }
                             addDefaultVibrato();
                             this.channelVibrato.delay = (dataValue / 64) / 3;
-                            SpessaSynthInfo(
-                                `%cVibrato delay for %c${this.channelNumber}%c is now set to %c${dataValue} = ${this.channelVibrato.delay}%c seconds.`,
-                                consoleColors.info,
-                                consoleColors.recognized,
-                                consoleColors.info,
-                                consoleColors.value,
-                                consoleColors.info
-                            );
+                            coolInfo("Vibrato delay", `${dataValue} = ${this.channelVibrato.delay}`, "seconds");
                             break;
                         
                         // filter cutoff
-                        case 0x20:
+                        case nonRegisteredParameterNumbers.TVFFilterCutoff:
                             // affect the "brightness" controller as we have a default modulator that controls it
-                            const ccValue = dataValue;
                             this.controllerChange(midiControllers.brightness, dataValue);
-                            SpessaSynthInfo(
-                                `%cFilter cutoff for %c${this.channelNumber}%c is now set to %c${ccValue}`,
-                                consoleColors.info,
-                                consoleColors.recognized,
-                                consoleColors.info,
-                                consoleColors.value
-                            );
+                            coolInfo("Filter cutoff", dataValue.toString(), "");
+                            break;
+                        
+                        // attack time
+                        case nonRegisteredParameterNumbers.EGAttackTime:
+                            // affect the "attack time" controller as we have a default modulator that controls it
+                            this.controllerChange(midiControllers.attackTime, dataValue);
+                            coolInfo("EG attack time", dataValue.toString(), "");
+                            break;
+                        
+                        // release time
+                        case nonRegisteredParameterNumbers.EGReleaseTime:
+                            // affect the "release time" controller as we have a default modulator that controls it
+                            this.controllerChange(midiControllers.releaseTime, dataValue);
+                            coolInfo("EG release time", dataValue.toString(), "");
+                            break;
                     }
                     break;
                 
                 // drum reverb
-                case 0x1D:
+                case nonRegisteredParameterNumbers.drumReverb:
                     const reverb = dataValue;
                     this.controllerChange(midiControllers.reverbDepth, reverb);
-                    SpessaSynthInfo(
-                        `%cGS Drum reverb for %c${this.channelNumber}%c: %c${reverb}`,
-                        consoleColors.info,
-                        consoleColors.recognized,
-                        consoleColors.info,
-                        consoleColors.value
-                    );
+                    coolInfo("GS Drum reverb", reverb.toString(), "percent");
                     break;
             }
             break;
         
         case dataEntryStates.RPCoarse:
         case dataEntryStates.RPFine:
-            switch (this.RPValue)
+            /**
+             * @type {number}
+             */
+            const rpnValue = this.midiControllers[midiControllers.RPNMsb] | (this.midiControllers[midiControllers.RPNLsb] >> 7);
+            switch (rpnValue)
             {
                 default:
                     SpessaSynthWarn(
-                        `%cUnrecognized RPN for %c${this.channelNumber}%c: %c(0x${this.RPValue.toString(16)})%c data value: %c${dataValue}`,
+                        `%cUnrecognized RPN for %c${this.channelNumber}%c: %c(0x${rpnValue.toString(16)})%c data value: %c${dataValue}`,
                         consoleColors.warn,
                         consoleColors.recognized,
                         consoleColors.warn,
@@ -182,34 +218,32 @@ export function dataEntryCoarse(dataValue)
                     break;
                 
                 // pitch bend range
-                case 0x0000:
+                case registeredParameterTypes.pitchBendRange:
                     this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
-                    SpessaSynthInfo(
-                        `%cChannel ${this.channelNumber} bend range. Semitones: %c${dataValue}`,
-                        consoleColors.info,
-                        consoleColors.value
-                    );
+                    coolInfo("Pitch bend range", dataValue.toString(), "semitones");
                     break;
                 
                 // coarse tuning
-                case 0x0002:
+                case registeredParameterTypes.coarseTuning:
                     // semitones
-                    this.setTuningSemitones(dataValue - 64);
+                    const semitones = dataValue - 64;
+                    this.setCustomController(customControllers.channelTuningSemitones, semitones);
+                    coolInfo("Coarse tuning", semitones.toString(), "semitones");
                     break;
                 
                 // fine-tuning
-                case 0x0001:
+                case registeredParameterTypes.fineTuning:
                     // note: this will not work properly unless the lsb is sent!
                     // here we store the raw value to then adjust in fine
                     this.setTuning(dataValue - 64, false);
                     break;
                 
                 // modulation depth
-                case 0x0005:
+                case registeredParameterTypes.modulationDepth:
                     this.setModulationDepth(dataValue * 100);
                     break;
                 
-                case 0x3FFF:
+                case registeredParameterTypes.resetParameters:
                     this.resetParameters();
                     break;
                 

package/synthetizer/worklet_system/worklet_methods/data_entry/data_entry_fine.js

@@ -2,6 +2,7 @@ import { consoleColors } from "../../../../utils/other.js";
 import { SpessaSynthInfo } from "../../../../utils/loggin.js";
 import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
 import { customControllers, dataEntryStates, NON_CC_INDEX_OFFSET } from "../../worklet_utilities/controller_tables.js";
+import { midiControllers } from "../../../../midi_parser/midi_message.js";
 
 /**
  * Executes a data entry for an RPN tuning
@@ -18,7 +19,8 @@ export function dataEntryFine(dataValue)
         
         case dataEntryStates.RPCoarse:
         case dataEntryStates.RPFine:
-            switch (this.RPValue)
+            const rpnValue = this.midiControllers[midiControllers.RPNMsb] | (this.midiControllers[midiControllers.RPNLsb] >> 7);
+            switch (rpnValue)
             {
                 default:
                     break;
@@ -31,7 +33,7 @@ export function dataEntryFine(dataValue)
                     }
                     // 14-bit value, so upper 7 are coarse and lower 7 are fine!
                     this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] |= dataValue;
-                    const actualTune = (this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] >> 7) + dataValue / 127;
+                    const actualTune = (this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] >> 7) + dataValue / 128;
                     SpessaSynthInfo(
                         `%cChannel ${this.channelNumber} bend range. Semitones: %c${actualTune}`,
                         consoleColors.info,

package/synthetizer/worklet_system/worklet_methods/render_voice.js

@@ -62,7 +62,6 @@ export function renderVoice(
     // calculate tuning
     let cents = voice.modulatedGenerators[generatorTypes.fineTune]         // soundfont fine tune
         + this.channelOctaveTuning[voice.midiNote]                         // MTS octave tuning
-        + this.keyCentTuning[voice.midiNote]                               // SysEx key tuning
         + this.channelTuningCents;                                         // channel tuning
     let semitones = voice.modulatedGenerators[generatorTypes.coarseTune];  // soundfont coarse tuning
     

package/synthetizer/worklet_system/worklet_methods/tuning_control/set_tuning.js

@@ -17,8 +17,11 @@ export function setTuning(cents, log = true)
         return;
     }
     SpessaSynthInfo(
-        `%cChannel ${this.channelNumber} fine tuning. Cents: %c${cents}`,
+        `%cFine tuning for %c${this.channelNumber}%c is now set to %c${cents}%c cents.`,
         consoleColors.info,
-        consoleColors.value
+        consoleColors.recognized,
+        consoleColors.info,
+        consoleColors.value,
+        consoleColors.info
     );
 }

package/synthetizer/worklet_system/worklet_utilities/controller_tables.js

@@ -29,13 +29,18 @@ setResetValue(midiControllers.releaseTime, 64);
 setResetValue(midiControllers.attackTime, 64);
 setResetValue(midiControllers.brightness, 64);
 
-setResetValue(midiControllers.soundController6, 64);
-setResetValue(midiControllers.soundController7, 64);
-setResetValue(midiControllers.soundController8, 64);
-setResetValue(midiControllers.soundController9, 64);
+setResetValue(midiControllers.decayTime, 64);
+setResetValue(midiControllers.vibratoRate, 64);
+setResetValue(midiControllers.vibratoDepth, 64);
+setResetValue(midiControllers.vibratoDelay, 64);
 setResetValue(midiControllers.generalPurposeController6, 64);
 setResetValue(midiControllers.generalPurposeController8, 64);
 
+setResetValue(midiControllers.RPNLsb, 127);
+setResetValue(midiControllers.RPNMsb, 127);
+setResetValue(midiControllers.NRPNLsb, 127);
+setResetValue(midiControllers.NRPNMsb, 127);
+
 
 // special case: portamento control
 // since it is only 7-bit, only the values at multiple of 128 are allowed.