spessasynth_lib 3.24.13 → 3.24.16

package/synthetizer/worklet_system/worklet_methods/{data_entry.js → data_entry/data_entry_coarse.js}

@@ -1,32 +1,27 @@
-import { consoleColors } from "../../../utils/other.js";
-import { midiControllers } from "../../../midi_parser/midi_message.js";
-import { SpessaSynthInfo, SpessaSynthWarn } 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 { 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";
 
 /**
  * Executes a data entry for an NRP for a sc88pro NRP (because touhou yes) and RPN tuning
- * @param channel {number}
  * @param dataValue {number} dataEntryCoarse MSB
- * @this {SpessaSynthProcessor}
+ * @this {WorkletProcessorChannel}
  * @private
  */
-export function dataEntryCoarse(channel, dataValue)
+export function dataEntryCoarse(dataValue)
 {
-    /**
-     * @type {WorkletProcessorChannel}
-     */
-    const channelObject = this.workletProcessorChannels[channel];
     let addDefaultVibrato = () =>
     {
-        if (channelObject.channelVibrato.delay === 0 && channelObject.channelVibrato.rate === 0 && channelObject.channelVibrato.depth === 0)
+        if (this.channelVibrato.delay === 0 && this.channelVibrato.rate === 0 && this.channelVibrato.depth === 0)
         {
-            channelObject.channelVibrato.depth = 50;
-            channelObject.channelVibrato.rate = 8;
-            channelObject.channelVibrato.delay = 0.6;
+            this.channelVibrato.depth = 50;
+            this.channelVibrato.rate = 8;
+            this.channelVibrato.delay = 0.6;
         }
     };
-    switch (channelObject.dataEntryState)
+    switch (this.dataEntryState)
     {
         default:
         case dataEntryStates.Idle:
@@ -35,15 +30,15 @@ export function dataEntryCoarse(channel, dataValue)
         // https://cdn.roland.com/assets/media/pdf/SC-88PRO_OM.pdf
         // http://hummer.stanford.edu/sig/doc/classes/MidiOutput/rpn.html
         case dataEntryStates.NRPFine:
-            if (this.system !== "gs")
+            if (this.synth.system !== "gs")
             {
                 return;
             }
-            if (channelObject.lockGSNRPNParams)
+            if (this.lockGSNRPNParams)
             {
                 return;
             }
-            switch (channelObject.NRPCoarse)
+            switch (this.NRPCoarse)
             {
                 default:
                     if (dataValue === 64)
@@ -52,8 +47,8 @@ export function dataEntryCoarse(channel, dataValue)
                         return;
                     }
                     SpessaSynthWarn(
-                        `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16)
-                            .toUpperCase()} 0x${channelObject.NRPFine.toString(
+                        `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${this.NRPCoarse.toString(16)
+                            .toUpperCase()} 0x${this.NRPFine.toString(
                             16).toUpperCase()})%c data value: %c${dataValue}`,
                         consoleColors.warn,
                         consoleColors.recognized,
@@ -66,7 +61,7 @@ export function dataEntryCoarse(channel, dataValue)
                 
                 // part parameters: vibrato, cutoff
                 case 0x01:
-                    switch (channelObject.NRPFine)
+                    switch (this.NRPFine)
                     {
                         default:
                             if (dataValue === 64)
@@ -75,7 +70,7 @@ export function dataEntryCoarse(channel, dataValue)
                                 return;
                             }
                             SpessaSynthWarn(
-                                `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16)} 0x${channelObject.NRPFine.toString(
+                                `%cUnrecognized NRPN for %c${this.channelNumber}%c: %c(0x${this.NRPCoarse.toString(16)} 0x${this.NRPFine.toString(
                                     16)})%c data value: %c${dataValue}`,
                                 consoleColors.warn,
                                 consoleColors.recognized,
@@ -93,9 +88,9 @@ export function dataEntryCoarse(channel, dataValue)
                                 return;
                             }
                             addDefaultVibrato();
-                            channelObject.channelVibrato.rate = (dataValue / 64) * 8;
+                            this.channelVibrato.rate = (dataValue / 64) * 8;
                             SpessaSynthInfo(
-                                `%cVibrato rate for %c${channel}%c is now set to %c${dataValue} = ${channelObject.channelVibrato.rate}%cHz.`,
+                                `%cVibrato rate for %c${this.channelNumber}%c is now set to %c${dataValue} = ${this.channelVibrato.rate}%cHz.`,
                                 consoleColors.info,
                                 consoleColors.recognized,
                                 consoleColors.info,
@@ -111,9 +106,9 @@ export function dataEntryCoarse(channel, dataValue)
                                 return;
                             }
                             addDefaultVibrato();
-                            channelObject.channelVibrato.depth = dataValue / 2;
+                            this.channelVibrato.depth = dataValue / 2;
                             SpessaSynthInfo(
-                                `%cVibrato depth for %c${channel}%c is now set to %c${dataValue} = ${channelObject.channelVibrato.depth}%c cents range of detune.`,
+                                `%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,
@@ -129,9 +124,9 @@ export function dataEntryCoarse(channel, dataValue)
                                 return;
                             }
                             addDefaultVibrato();
-                            channelObject.channelVibrato.delay = (dataValue / 64) / 3;
+                            this.channelVibrato.delay = (dataValue / 64) / 3;
                             SpessaSynthInfo(
-                                `%cVibrato delay for %c${channel}%c is now set to %c${dataValue} = ${channelObject.channelVibrato.delay}%c seconds.`,
+                                `%cVibrato delay for %c${this.channelNumber}%c is now set to %c${dataValue} = ${this.channelVibrato.delay}%c seconds.`,
                                 consoleColors.info,
                                 consoleColors.recognized,
                                 consoleColors.info,
@@ -144,9 +139,9 @@ export function dataEntryCoarse(channel, dataValue)
                         case 0x20:
                             // affect the "brightness" controller as we have a default modulator that controls it
                             const ccValue = dataValue;
-                            this.controllerChange(channel, midiControllers.brightness, dataValue);
+                            this.controllerChange(midiControllers.brightness, dataValue);
                             SpessaSynthInfo(
-                                `%cFilter cutoff for %c${channel}%c is now set to %c${ccValue}`,
+                                `%cFilter cutoff for %c${this.channelNumber}%c is now set to %c${ccValue}`,
                                 consoleColors.info,
                                 consoleColors.recognized,
                                 consoleColors.info,
@@ -158,9 +153,9 @@ export function dataEntryCoarse(channel, dataValue)
                 // drum reverb
                 case 0x1D:
                     const reverb = dataValue;
-                    this.controllerChange(channel, midiControllers.reverbDepth, reverb);
+                    this.controllerChange(midiControllers.reverbDepth, reverb);
                     SpessaSynthInfo(
-                        `%cGS Drum reverb for %c${channel}%c: %c${reverb}`,
+                        `%cGS Drum reverb for %c${this.channelNumber}%c: %c${reverb}`,
                         consoleColors.info,
                         consoleColors.recognized,
                         consoleColors.info,
@@ -172,11 +167,11 @@ export function dataEntryCoarse(channel, dataValue)
         
         case dataEntryStates.RPCoarse:
         case dataEntryStates.RPFine:
-            switch (channelObject.RPValue)
+            switch (this.RPValue)
             {
                 default:
                     SpessaSynthWarn(
-                        `%cUnrecognized RPN for %c${channel}%c: %c(0x${channelObject.RPValue.toString(16)})%c data value: %c${dataValue}`,
+                        `%cUnrecognized RPN for %c${this.channelNumber}%c: %c(0x${this.RPValue.toString(16)})%c data value: %c${dataValue}`,
                         consoleColors.warn,
                         consoleColors.recognized,
                         consoleColors.warn,
@@ -188,9 +183,9 @@ export function dataEntryCoarse(channel, dataValue)
                 
                 // pitch bend range
                 case 0x0000:
-                    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
+                    this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
                     SpessaSynthInfo(
-                        `%cChannel ${channel} bend range. Semitones: %c${dataValue}`,
+                        `%cChannel ${this.channelNumber} bend range. Semitones: %c${dataValue}`,
                         consoleColors.info,
                         consoleColors.value
                     );
@@ -199,85 +194,23 @@ export function dataEntryCoarse(channel, dataValue)
                 // coarse tuning
                 case 0x0002:
                     // semitones
-                    this.setChannelTuningSemitones(channel, dataValue - 64);
+                    this.setTuningSemitones(dataValue - 64);
                     break;
                 
-                // fine tuning
+                // fine-tuning
                 case 0x0001:
                     // note: this will not work properly unless the lsb is sent!
                     // here we store the raw value to then adjust in fine
-                    this.setChannelTuning(channel, (dataValue - 64), false);
+                    this.setTuning(dataValue - 64, false);
                     break;
                 
                 // modulation depth
                 case 0x0005:
-                    this.setModulationDepth(channel, dataValue * 100);
+                    this.setModulationDepth(dataValue * 100);
                     break;
                 
                 case 0x3FFF:
-                    this.resetParameters(channel);
-                    break;
-                
-            }
-        
-    }
-}
-
-/**
- * Executes a data entry for an RPN tuning
- * @param channel {number}
- * @param dataValue {number} dataEntry LSB
- * @this {SpessaSynthProcessor}
- * @private
- */
-export function dataEntryFine(channel, dataValue)
-{
-    const channelObject = this.workletProcessorChannels[channel];
-    switch (channelObject.dataEntryState)
-    {
-        default:
-            break;
-        
-        case dataEntryStates.RPCoarse:
-        case dataEntryStates.RPFine:
-            switch (channelObject.RPValue)
-            {
-                default:
-                    break;
-                
-                // pitch bend range fine tune
-                case 0x0000:
-                    if (dataValue === 0)
-                    {
-                        break;
-                    }
-                    // 14-bit value, so upper 7 are coarse and lower 7 are fine!
-                    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] |= dataValue;
-                    const actualTune = (channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] >> 7) + dataValue / 127;
-                    SpessaSynthInfo(
-                        `%cChannel ${channel} bend range. Semitones: %c${actualTune}`,
-                        consoleColors.info,
-                        consoleColors.value
-                    );
-                    break;
-                
-                // fine tuning
-                case 0x0001:
-                    // grab the data and shift
-                    const coarse = channelObject.customControllers[customControllers.channelTuning];
-                    const finalTuning = (coarse << 7) | dataValue;
-                    this.setChannelTuning(channel, finalTuning * 0.01220703125); // multiply by 8192 / 100 (cent increment)
-                    break;
-                
-                // modulation depth
-                case 0x0005:
-                    const currentModulationDepthCents = channelObject.customControllers[customControllers.modulationMultiplier] * 50;
-                    let cents = currentModulationDepthCents + (dataValue / 128) * 100;
-                    this.setModulationDepth(channel, cents);
-                    break;
-                
-                case 0x3FFF:
-                    this.resetParameters(channel);
+                    this.resetParameters();
                     break;
                 
             }

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

@@ -0,0 +1,64 @@
+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";
+
+/**
+ * Executes a data entry for an RPN tuning
+ * @param dataValue {number} dataEntry LSB
+ * @this {WorkletProcessorChannel}
+ * @private
+ */
+export function dataEntryFine(dataValue)
+{
+    switch (this.dataEntryState)
+    {
+        default:
+            break;
+        
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            switch (this.RPValue)
+            {
+                default:
+                    break;
+                
+                // pitch bend range fine tune
+                case 0x0000:
+                    if (dataValue === 0)
+                    {
+                        break;
+                    }
+                    // 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;
+                    SpessaSynthInfo(
+                        `%cChannel ${this.channelNumber} bend range. Semitones: %c${actualTune}`,
+                        consoleColors.info,
+                        consoleColors.value
+                    );
+                    break;
+                
+                // fine-tuning
+                case 0x0001:
+                    // grab the data and shift
+                    const coarse = this.customControllers[customControllers.channelTuning];
+                    const finalTuning = (coarse << 7) | dataValue;
+                    this.setTuning(finalTuning * 0.01220703125); // multiply by 8192 / 100 (cent increments)
+                    break;
+                
+                // modulation depth
+                case 0x0005:
+                    const currentModulationDepthCents = this.customControllers[customControllers.modulationMultiplier] * 50;
+                    let cents = currentModulationDepthCents + (dataValue / 128) * 100;
+                    this.setModulationDepth(cents);
+                    break;
+                
+                case 0x3FFF:
+                    this.resetParameters();
+                    break;
+                
+            }
+        
+    }
+}

package/synthetizer/worklet_system/worklet_methods/mute_channel.js

@@ -0,0 +1,17 @@
+/**
+ * @param isMuted {boolean}
+ * @this {WorkletProcessorChannel}
+ */
+export function muteChannel(isMuted)
+{
+    if (isMuted)
+    {
+        this.stopAllNotes(true);
+    }
+    this.isMuted = isMuted;
+    this.synth.sendChannelProperties();
+    this.synth.callEvent("mutechannel", {
+        channel: this.channelNumber,
+        isMuted: isMuted
+    });
+}

package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -10,55 +10,53 @@ const EXCLUSIVE_CUTOFF_TIME = -2320;
 const EXCLUSIVE_MOD_CUTOFF_TIME = -1130; // less because filter shenanigans
 
 /**
- * Append the voices
- * @param channel {number}
+ * sends a "MIDI Note on message"
  * @param midiNote {number}
  * @param velocity {number}
  * @param enableDebugging {boolean}
  * @param sendEvent {boolean}
  * @param startTime {number}
- * @this {SpessaSynthProcessor}
+ * @this {WorkletProcessorChannel}
  */
-export function noteOn(channel, midiNote, velocity, enableDebugging = false, sendEvent = true, startTime = currentTime)
+export function noteOn(midiNote, velocity, enableDebugging = false, sendEvent = true, startTime = currentTime)
 {
     if (velocity < 1)
     {
-        this.noteOff(channel, midiNote);
+        this.noteOff(midiNote);
         return;
     }
     velocity = Math.min(127, velocity);
     
-    const channelObject = this.workletProcessorChannels[channel];
     if (
-        (this.highPerformanceMode && this.totalVoicesAmount > 200 && velocity < 40) ||
-        (this.highPerformanceMode && velocity < 10) ||
-        (channelObject.isMuted)
+        (this.synth.highPerformanceMode && this.totalVoicesAmount > 200 && velocity < 40) ||
+        (this.synth.highPerformanceMode && velocity < 10) ||
+        (this.isMuted)
     )
     {
         return;
     }
     
-    const realKey = midiNote + channelObject.channelTransposeKeyShift;
+    const realKey = midiNote + this.channelTransposeKeyShift;
     let sentMidiNote = realKey;
     
     if (realKey > 127 || realKey < 0)
     {
         return;
     }
-    const program = channelObject.preset.program;
-    if (this.tunings[program]?.[realKey]?.midiNote >= 0)
+    const program = this.preset.program;
+    if (this.synth.tunings[program]?.[realKey]?.midiNote >= 0)
     {
-        sentMidiNote = this.tunings[program]?.[realKey].midiNote;
+        sentMidiNote = this.synth.tunings[program]?.[realKey].midiNote;
     }
     
     // velocity override
-    if (channelObject.velocityOverride > 0)
+    if (this.velocityOverride > 0)
     {
-        velocity = channelObject.velocityOverride;
+        velocity = this.velocityOverride;
     }
     
     // key velocity override
-    const keyVel = this.keyModifierManager.getVelocity(channel, realKey);
+    const keyVel = this.synth.keyModifierManager.getVelocity(this.channelNumber, realKey);
     if (keyVel > -1)
     {
         velocity = keyVel;
@@ -67,24 +65,28 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
     // portamento
     let portamentoFromKey = -1;
     let portamentoDuration = 0;
-    const currentFromKey = channelObject.midiControllers[midiControllers.portamentoControl] >> 7;
-    if (!channelObject.drumChannel && currentFromKey !== sentMidiNote && channelObject.midiControllers[midiControllers.portamentoOnOff] >= 8192) // (64 << 7)
+    // note: the 14-bit value needs to go down to 7-bit
+    const portamentoTime = this.midiControllers[midiControllers.portamentoTime] >> 7;
+    const currentFromKey = this.midiControllers[midiControllers.portamentoControl] >> 7;
+    if (
+        !this.drumChannel && // no portamento on drum channel
+        currentFromKey !== sentMidiNote && // if the same note, there's no portamento
+        this.midiControllers[midiControllers.portamentoOnOff] >= 8192 && // (64 << 7)
+        portamentoTime > 0 // 0 duration is no portamento
+    )
     {
-        // note: the 14-bit value needs to go down to 7-bit
-        const portamentoTime = channelObject.midiControllers[midiControllers.portamentoTime] >> 7;
         const diff = Math.abs(sentMidiNote - currentFromKey);
         portamentoDuration = portamentoTimeToSeconds(portamentoTime, diff);
         portamentoFromKey = currentFromKey;
         // set portamento control to previous value
-        this.controllerChange(channel, midiControllers.portamentoControl, sentMidiNote);
+        this.controllerChange(midiControllers.portamentoControl, sentMidiNote);
     }
     
     // get voices
-    const voices = this.getWorkletVoices(
-        channel,
+    const voices = this.synth.getWorkletVoices(
+        this.channelNumber,
         sentMidiNote,
         velocity,
-        channelObject,
         startTime,
         realKey,
         enableDebugging
@@ -92,14 +94,14 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
     
     // zero means disabled
     let panOverride = 0;
-    if (channelObject.randomPan)
+    if (this.randomPan)
     {
         // the range is -500 to 500
         panOverride = Math.round(Math.random() * 1000 - 500);
     }
     
     // add voices
-    const channelVoices = channelObject.voices;
+    const channelVoices = this.voices;
     voices.forEach(voice =>
     {
         // apply portamento
@@ -118,7 +120,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
             {
                 if (v.generators[generatorTypes.exclusiveClass] === exclusive)
                 {
-                    this.releaseVoice(v, MIN_EXCLUSIVE_LENGTH);
+                    v.release(MIN_EXCLUSIVE_LENGTH);
                     v.modulatedGenerators[generatorTypes.releaseVolEnv] = EXCLUSIVE_CUTOFF_TIME; // make the release nearly instant
                     v.modulatedGenerators[generatorTypes.releaseModEnv] = EXCLUSIVE_MOD_CUTOFF_TIME;
                     WorkletVolumeEnvelope.recalculate(v);
@@ -127,7 +129,7 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
             });
         }
         // compute all modulators
-        computeModulators(voice, channelObject.midiControllers);
+        computeModulators(voice, this.midiControllers);
         // modulate sample offsets (these are not real time)
         const cursorStartOffset = voice.modulatedGenerators[generatorTypes.startAddrsOffset] + voice.modulatedGenerators[generatorTypes.startAddrsCoarseOffset] * 32768;
         const endOffset = voice.modulatedGenerators[generatorTypes.endAddrOffset] + voice.modulatedGenerators[generatorTypes.endAddrsCoarseOffset] * 32768;
@@ -159,19 +161,19 @@ export function noteOn(channel, midiNote, velocity, enableDebugging = false, sen
         voice.currentPan = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan])); //  -500 to 500
     });
     
-    this.totalVoicesAmount += voices.length;
+    this.synth.totalVoicesAmount += voices.length;
     // cap the voices
-    if (this.totalVoicesAmount > this.voiceCap)
+    if (this.synth.totalVoicesAmount > this.synth.voiceCap)
     {
-        this.voiceKilling(voices.length);
+        this.synth.voiceKilling(voices.length);
     }
     channelVoices.push(...voices);
     if (sendEvent)
     {
-        this.sendChannelProperties();
-        this.callEvent("noteon", {
+        this.synth.sendChannelProperties();
+        this.synth.callEvent("noteon", {
             midiNote: midiNote,
-            channel: channel,
+            channel: this.channelNumber,
             velocity: velocity
         });
     }

package/synthetizer/worklet_system/worklet_methods/program_change.js

@@ -0,0 +1,49 @@
+/**
+ * executes a program change
+ * @param programNumber {number}
+ * @param userChange {boolean}
+ * @this {WorkletProcessorChannel}
+ */
+export function programChange(programNumber, userChange = false)
+{
+    if (this.lockPreset)
+    {
+        return;
+    }
+    // always 128 for percussion
+    const bank = this.getBankSelect();
+    let sentBank;
+    let preset;
+    
+    // check if override
+    if (this.synth.overrideSoundfont)
+    {
+        const bankWithOffset = bank === 128 ? 128 : bank - this.synth.soundfontBankOffset;
+        const p = this.synth.overrideSoundfont.getPresetNoFallback(bankWithOffset, programNumber);
+        if (p)
+        {
+            sentBank = bank;
+            preset = p;
+            this.presetUsesOverride = true;
+        }
+        else
+        {
+            preset = this.synth.soundfontManager.getPreset(bank, programNumber);
+            sentBank = preset.bank;
+            this.presetUsesOverride = false;
+        }
+    }
+    else
+    {
+        preset = this.synth.soundfontManager.getPreset(bank, programNumber);
+        sentBank = preset.bank;
+        this.presetUsesOverride = false;
+    }
+    this.setPreset(preset);
+    this.synth.callEvent("programchange", {
+        channel: this.channelNumber,
+        program: preset.program,
+        bank: sentBank,
+        userCalled: userChange
+    });
+}