spessasynth_lib 3.24.13 → 3.24.15

package/synthetizer/worklet_system/snapshot/synthesizer_snapshot.js

@@ -0,0 +1,121 @@
+import { SpessaSynthInfo } from "../../../utils/loggin.js";
+import { consoleColors } from "../../../utils/other.js";
+import { ChannelSnapshot } from "./channel_snapshot.js";
+
+/**
+ * Represents a snapshot of the synthesizer's state.
+ */
+export class SynthesizerSnapshot
+{
+    /**
+     * The individual channel snapshots.
+     * @type {ChannelSnapshot[]}
+     */
+    channelSnapshots;
+    
+    /**
+     * Key modifiers.
+     * @type {KeyModifier[][]}
+     */
+    keyMappings;
+    
+    /**
+     * Main synth volume (set by MIDI), from 0 to 1.
+     * @type {number}
+     */
+    mainVolume;
+    
+    /**
+     * Master stereo panning, from -1 to 1.
+     * @type {number}
+     */
+    pan;
+    
+    /**
+     * The synth's interpolation type.
+     * @type {interpolationTypes}
+     */
+    interpolation;
+    
+    /**
+     * The synth's system. Values can be "gs", "gm", "gm2" or "xg".
+     * @type {SynthSystem}
+     */
+    system;
+    
+    /**
+     * The current synth transposition in semitones. Can be a float.
+     * @type {number}
+     */
+    transposition;
+    
+    /**
+     * The effect configuration object.
+     * @type {SynthConfig}
+     */
+    effectsConfig;
+    
+    
+    /**
+     * Creates a snapshot of the synthesizer's state.
+     * @param workletProcessor {SpessaSynthProcessor}
+     * @returns {SynthesizerSnapshot}
+     */
+    static createSynthesizerSnapshot(workletProcessor)
+    {
+        const snapshot = new SynthesizerSnapshot();
+        // channel snapshots
+        snapshot.channelSnapshots =
+            workletProcessor.workletProcessorChannels.map((_, i) =>
+                ChannelSnapshot.getChannelSnapshot(workletProcessor, i));
+        
+        // key mappings
+        snapshot.keyMappings = workletProcessor.keyModifierManager.getMappings();
+        // pan and volume
+        snapshot.mainVolume = workletProcessor.midiVolume;
+        snapshot.pan = workletProcessor.pan;
+        
+        // others
+        snapshot.system = workletProcessor.system;
+        snapshot.interpolation = workletProcessor.interpolationType;
+        snapshot.transposition = workletProcessor.transposition;
+        
+        // effect config is stored on the main thread, leave it empty
+        snapshot.effectsConfig = {};
+        return snapshot;
+        
+    }
+    
+    /**
+     * Applies the snapshot to the synthesizer.
+     * @param workletProcessor {SpessaSynthProcessor}
+     * @param snapshot {SynthesizerSnapshot}
+     */
+    static applySnapshot(workletProcessor, snapshot)
+    {
+        // restore system
+        workletProcessor.system = snapshot.system;
+        
+        // restore pan and volume
+        workletProcessor.setMasterGain(snapshot.mainVolume);
+        workletProcessor.setMasterPan(snapshot.pan);
+        workletProcessor.transposeAllChannels(snapshot.transposition);
+        workletProcessor.interpolationType = snapshot.interpolation;
+        workletProcessor.keyModifierManager.setMappings(snapshot.keyMappings);
+        
+        // add channels if more needed
+        while (workletProcessor.workletProcessorChannels.length < snapshot.channelSnapshots.length)
+        {
+            workletProcessor.createWorkletChannel();
+        }
+        
+        // restore channels
+        snapshot.channelSnapshots.forEach((channelSnapshot, index) =>
+        {
+            ChannelSnapshot.applyChannelSnapshot(workletProcessor, index, channelSnapshot);
+        });
+        
+        SpessaSynthInfo("%cFinished restoring controllers!", consoleColors.info);
+    }
+}
+

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

@@ -0,0 +1,196 @@
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { midiControllers } from "../../../../midi_parser/midi_message.js";
+import { computeModulators } from "../../worklet_utilities/worklet_modulator.js";
+import { consoleColors } from "../../../../utils/other.js";
+import { DEFAULT_PERCUSSION } from "../../../synthetizer.js";
+import { channelConfiguration, dataEntryStates } from "../../worklet_utilities/controller_tables.js";
+
+/**
+ * @param controllerNumber {number}
+ * @param controllerValue {number}
+ * @param force {boolean}
+ * @this {WorkletProcessorChannel}
+ */
+export function controllerChange(controllerNumber, controllerValue, force = false)
+{
+    if (controllerNumber > 127)
+    {
+        // channel configuration. force must be set to true
+        if (!force)
+        {
+            return;
+        }
+        switch (controllerNumber)
+        {
+            default:
+                return;
+            
+            case channelConfiguration.velocityOverride:
+                this.velocityOverride = controllerValue;
+        }
+    }
+    
+    // lsb controller values: append them as the lower nibble of the 14-bit value
+    // excluding bank select and data entry as it's handled separately
+    if (
+        controllerNumber >= midiControllers.lsbForControl1ModulationWheel
+        && controllerNumber <= midiControllers.lsbForControl13EffectControl2
+        && controllerNumber !== midiControllers.lsbForControl6DataEntry
+    )
+    {
+        const actualCCNum = controllerNumber - 32;
+        if (this.lockedControllers[actualCCNum])
+        {
+            return;
+        }
+        // append the lower nibble to the main controller
+        this.midiControllers[actualCCNum] = (this.midiControllers[actualCCNum] & 0x3F80) | (controllerValue & 0x7F);
+        this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, actualCCNum));
+    }
+    switch (controllerNumber)
+    {
+        case midiControllers.allNotesOff:
+            this.stopAllNotes();
+            break;
+        
+        case midiControllers.allSoundOff:
+            this.stopAllNotes(true);
+            break;
+        
+        // special case: bank select
+        case midiControllers.bankSelect:
+            let bankNr = controllerValue;
+            if (!force)
+            {
+                switch (this.synth.system)
+                {
+                    case "gm":
+                        // gm ignores bank select
+                        SpessaSynthInfo(
+                            `%cIgnoring the Bank Select (${controllerValue}), as the synth is in GM mode.`,
+                            consoleColors.info
+                        );
+                        return;
+                    
+                    case "xg":
+                        // for xg, if msb is 120, 126 or 127, then it's drums
+                        if (bankNr === 120 || bankNr === 126 || bankNr === 127)
+                        {
+                            this.setDrums(true);
+                        }
+                        else
+                        {
+                            // drums shall not be disabled on channel 9
+                            if (this.channelNumber % 16 !== DEFAULT_PERCUSSION)
+                            {
+                                this.setDrums(false);
+                            }
+                        }
+                        break;
+                    
+                    case "gm2":
+                        if (bankNr === 120)
+                        {
+                            this.setDrums(true);
+                        }
+                }
+                
+                if (this.drumChannel)
+                {
+                    // 128 for percussion channel
+                    bankNr = 128;
+                }
+                if (bankNr === 128 && !this.drumChannel)
+                {
+                    // if a channel is not for percussion, default to bank current
+                    bankNr = this.getBankSelect();
+                }
+            }
+            
+            this.setBankSelect(bankNr);
+            break;
+        
+        case midiControllers.lsbForControl0BankSelect:
+            if (this.synth.system === "xg")
+            {
+                if (!this.drumChannel)
+                {
+                    // some soundfonts use 127 as drums and
+                    // if it's not marked as drums by bank MSB (line 47), then we DO NOT want the drums!
+                    if (controllerValue !== 127)
+                    {
+                        this.setBankSelect(controllerValue);
+                    }
+                }
+            }
+            else if (this.synth.system === "gm2")
+            {
+                this.setBankSelect(controllerValue);
+            }
+            break;
+        
+        // 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;
+        
+        case midiControllers.dataEntryMsb:
+            this.dataEntryCoarse(controllerValue);
+            break;
+        
+        case midiControllers.lsbForControl6DataEntry:
+            this.dataEntryFine(controllerValue);
+            break;
+        
+        case midiControllers.resetAllControllers:
+            this.resetControllers();
+            break;
+        
+        case midiControllers.sustainPedal:
+            if (controllerValue >= 64)
+            {
+                this.holdPedal = true;
+            }
+            else
+            {
+                this.holdPedal = false;
+                this.sustainedVoices.forEach(v =>
+                {
+                    v.release();
+                });
+                this.sustainedVoices = [];
+            }
+            break;
+        
+        // default: apply the controller to the table
+        default:
+            if (this.lockedControllers[controllerNumber])
+            {
+                return;
+            }
+            this.midiControllers[controllerNumber] = controllerValue << 7;
+            this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, controllerNumber));
+            break;
+    }
+    this.synth.callEvent("controllerchange", {
+        channel: this.channelNumber,
+        controllerNumber: controllerNumber,
+        controllerValue: controllerValue
+    });
+}

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

@@ -0,0 +1,34 @@
+import { SYNTHESIZER_GAIN } from "../../main_processor.js";
+
+/**
+ * @param volume {number} 0 to 1
+ * @this {SpessaSynthProcessor}
+ */
+export function setMIDIVolume(volume)
+{
+    this.midiVolume = volume;
+    this.setMasterPan(this.pan);
+}
+
+/**
+ * @param volume {number} 0-1
+ * @this {SpessaSynthProcessor}
+ */
+export function setMasterGain(volume)
+{
+    this.masterGain = volume * SYNTHESIZER_GAIN;
+    this.setMasterPan(this.pan);
+}
+
+/**
+ * @param pan {number} -1 to one
+ * @this {SpessaSynthProcessor}
+ */
+export function setMasterPan(pan)
+{
+    this.pan = pan;
+    // clamp to 0-1 (0 is left)
+    pan = (pan / 2) + 0.5;
+    this.panLeft = (1 - pan);
+    this.panRight = (pan);
+}

package/synthetizer/worklet_system/worklet_methods/{reset_controllers.js → controller_control/reset_controllers.js}

@@ -1,17 +1,17 @@
-import { consoleColors } from "../../../utils/other.js";
-import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE } from "../../synthetizer.js";
-import { SpessaSynthInfo } from "../../../utils/loggin.js";
-import { modulatorSources } from "../../../soundfont/basic_soundfont/modulator.js";
+import { consoleColors } from "../../../../utils/other.js";
+import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE } from "../../../synthetizer.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
 import {
     customControllers,
     customResetArray,
     dataEntryStates,
     NON_CC_INDEX_OFFSET,
     resetArray
-} from "../worklet_utilities/controller_tables.js";
-import { getBankSelect, setBankSelect } from "../worklet_utilities/worklet_processor_channel.js";
+} from "../../worklet_utilities/controller_tables.js";
 
 /**
+ * Full system reset
  * @this {SpessaSynthProcessor}
  * @param log {boolean}
  */
@@ -24,7 +24,7 @@ export function resetAllControllers(log = true)
     this.callEvent("allcontrollerreset", undefined);
     for (let channelNumber = 0; channelNumber < this.workletProcessorChannels.length; channelNumber++)
     {
-        this.resetControllers(channelNumber);
+        this.workletProcessorChannels[channelNumber].resetControllers();
         
         /**
          * @type {WorkletProcessorChannel}
@@ -35,10 +35,10 @@ export function resetAllControllers(log = true)
         if (!ch.lockPreset)
         {
             ch.presetUsesOverride = true;
-            setBankSelect(ch, 0);
+            ch.setBankSelect(0);
             if (channelNumber % 16 === DEFAULT_PERCUSSION)
             {
-                this.setPreset(channelNumber, this.drumPreset);
+                this.workletProcessorChannels[channelNumber].setPreset(this.drumPreset);
                 ch.drumChannel = true;
                 this.callEvent("drumchange", {
                     channel: channelNumber,
@@ -48,7 +48,7 @@ export function resetAllControllers(log = true)
             else
             {
                 ch.drumChannel = false;
-                this.setPreset(channelNumber, this.defaultPreset);
+                ch.setPreset(this.defaultPreset);
                 this.callEvent("drumchange", {
                     channel: channelNumber,
                     isDrumChannel: false
@@ -67,7 +67,7 @@ export function resetAllControllers(log = true)
         this.callEvent("programchange", {
             channel: channelNumber,
             program: ch.preset.program,
-            bank: getBankSelect(ch),
+            bank: ch.getBankSelect(),
             userCalled: false
         });
         
@@ -112,72 +112,66 @@ export function resetAllControllers(log = true)
 
 /**
  * Resets all controllers for channel
- * @param channel {number}
- * @this {SpessaSynthProcessor}
+ * @this {WorkletProcessorChannel}
  */
-export function resetControllers(channel)
+export function resetControllers()
 {
-    const channelObject = this.workletProcessorChannels[channel];
-    
-    channelObject.channelOctaveTuning.fill(0);
-    channelObject.keyCentTuning.fill(0);
+    this.channelOctaveTuning.fill(0);
+    this.keyCentTuning.fill(0);
     
     // reset the array
     for (let i = 0; i < resetArray.length; i++)
     {
-        if (channelObject.lockedControllers[i])
+        if (this.lockedControllers[i])
         {
             return;
         }
         const resetValue = resetArray[i];
-        if (channelObject.midiControllers[i] !== resetValue && i < 127)
+        if (this.midiControllers[i] !== resetValue && i < 127)
         {
             // call cc change if reset
-            this.callEvent("controllerchange", {
-                channel: channel,
+            this.synth.callEvent("controllerchange", {
+                channel: this.channelNumber,
                 controllerNumber: i,
                 controllerValue: resetValue >> 7
             });
         }
-        channelObject.midiControllers[i] = resetValue;
+        this.midiControllers[i] = resetValue;
     }
-    channelObject.channelVibrato = { rate: 0, depth: 0, delay: 0 };
-    channelObject.holdPedal = false;
-    channelObject.randomPan = false;
+    this.channelVibrato = { rate: 0, depth: 0, delay: 0 };
+    this.holdPedal = false;
+    this.randomPan = false;
     
     // reset custom controllers
     // special case: transpose does not get affected
-    const transpose = channelObject.customControllers[customControllers.channelTransposeFine];
-    channelObject.customControllers.set(customResetArray);
-    channelObject.customControllers[customControllers.channelTransposeFine] = transpose;
+    const transpose = this.customControllers[customControllers.channelTransposeFine];
+    this.customControllers.set(customResetArray);
+    this.customControllers[customControllers.channelTransposeFine] = transpose;
     
-    this.resetParameters(channel);
+    this.resetParameters();
     
 }
 
 /**
- * @param channel {number}
- * @this {SpessaSynthProcessor}
+ * @this {WorkletProcessorChannel}
  */
-export function resetParameters(channel)
+export function resetParameters()
 {
-    const channelObject = this.workletProcessorChannels[channel];
-    
     // reset parameters
     /**
      * @type {number}
      */
-    channelObject.NRPCoarse = 0;
+    this.NRPCoarse = 0;
     /**
      * @type {number}
      */
-    channelObject.NRPFine = 0;
+    this.NRPFine = 0;
     /**
      * @type {number}
      */
-    channelObject.RPValue = 0;
+    this.RPValue = 0;
     /**
      * @type {string}
      */
-    channelObject.dataEntryState = dataEntryStates.Idle;
+    this.dataEntryState = dataEntryStates.Idle;
 }

package/synthetizer/worklet_system/worklet_methods/create_worklet_channel.js

@@ -0,0 +1,26 @@
+import { WorkletProcessorChannel } from "../worklet_utilities/worklet_processor_channel.js";
+import { DEFAULT_PERCUSSION } from "../../synthetizer.js";
+
+/**
+ * @param sendEvent {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function createWorkletChannel(sendEvent = false)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channel = new WorkletProcessorChannel(this, this.defaultPreset, this.workletProcessorChannels.length);
+    this.workletProcessorChannels.push(channel);
+    channel.resetControllers();
+    this.sendChannelProperties();
+    if (sendEvent)
+    {
+        this.callEvent("newchannel", undefined);
+    }
+    
+    if (channel.channelNumber % 16 === DEFAULT_PERCUSSION)
+    {
+        this.workletProcessorChannels[this.workletProcessorChannels.length - 1].setDrums(true);
+    }
+}