spessasynth_lib 0.0.1

package/package/synthetizer/worklet_system/message_protocol/worklet_message.js

@@ -0,0 +1,121 @@
+/**
+ * @enum {number}
+ * // NOTE: Every message needs a channel number (if not relevant or all, set to -1)
+ * @property {number} noteOff                    - 0  -> midiNote<number>
+ * @property {number} noteOn                     - 1  -> [midiNote<number>, velocity<number>, enableDebugging<boolean>]
+ * @property {number} ccChange                   - 2  -> [ccNumber<number>, ccValue<number>, force<boolean>]
+ * @property {number} programChange              - 3  -> [programNumber<number>, userChange<boolean>]
+ * @property {number} channelPressure            - 4  -> pressure<number>
+ * @property {number} polyPressure               - 5  -> [midiNote<number>, pressure<number>]
+ * @property {number} killNote                   - 6  -> midiNote<number>
+ * @property {number} ccReset                    - 7  -> (no data) note: if channel is -1 then reset all channels
+ * @property {number} setChannelVibrato          - 8  -> {frequencyHz: number, depthCents: number, delaySeconds: number} note: if channel is -1 then stop all channels note 2: if rate is -1, it means locking
+ * @property {number} reloadSoundFont            - 9  -> (no data)
+ * @property {number} stopAll                    - 10  -> force<number> (0 false, 1 true) note: if channel is -1 then stop all channels
+ * @property {number} killNotes                  - 11  -> amount<number>
+ * @property {number} muteChannel                - 12 -> isMuted<boolean>
+ * @property {number} addNewChannel              - 13 -> (no data)
+ * @property {number} customCcChange             - 14 -> [ccNumber<number>, ccValue<number>]
+ * @property {number} debugMessage               - 15 -> (no data)
+ * @property {number} systemExclusive            - 16 -> message data <number[]> (without the F0 byte)
+ * @property {number} setMasterParameter         - 17 -> [parameter<masterParameterType>, value<number>]
+ * @property {number} setDrums                   - 18 -> isDrums<boolean>
+ * @property {number} pitchWheel                 - 19 -> [MSB<number>, LSB<number>]
+ * @property {number} transpose                  - 20 -> [semitones<number>, force<boolean>] note: if channel is -1 then transpose all channels
+ * @property {number} highPerformanceMode        - 21 -> isOn<boolean>
+ * @property {number} lockController             - 22 -> [controllerNumber<number>, isLocked<boolean>]
+ * @property {number} sequencerSpecific          - 23 -> [messageType<WorkletSequencerMessageType> messageData<any>] note: refer to sequencer_message.js
+ * @property {number} requestSynthesizerSnapshot - 24 -> (no data)
+ * @property {number} setLogLevel                - 25 -> [enableInfo<boolean>, enableWarning<boolean>, enableGroup<boolean>, enableTable<boolean>]
+ */
+export const workletMessageType = {
+    noteOff:                    0,
+    noteOn:                     1,
+    ccChange:                   2,
+    programChange:              3,
+    channelPressure:            4,
+    polyPressure:               5,
+    killNote:                   6,
+    ccReset:                    7,
+    setChannelVibrato:          8,
+    reloadSoundFont:            9,
+    stopAll:                    10,
+    killNotes:                  11,
+    muteChannel:                12,
+    addNewChannel:              13,
+    customcCcChange:            14,
+    debugMessage:               15,
+    systemExclusive:            16,
+    setMasterParameter:         17,
+    setDrums:                   18,
+    pitchWheel:                 19,
+    transpose:                  20,
+    highPerformanceMode:        21,
+    lockController:             22,
+    sequencerSpecific:          23,
+    requestSynthesizerSnapshot: 24,
+    setLogLevel:                25
+};
+
+/**
+ * @enum {number}
+ */
+export const masterParameterType = {
+    mainVolume: 0,
+    masterPan: 1,
+    voicesCap: 2,
+}
+
+
+export const ALL_CHANNELS_OR_DIFFERENT_ACTION = -1;
+/**
+ * @typedef {{
+ *     channelNumber: number
+ *     messageType: workletMessageType,
+ *     messageData: (
+ *     number[]
+ *     |boolean[]
+ *     |WorkletVoice[]
+ *     |number
+ *     |{sampleData: Float32Array, sampleID: number}
+ *     |{rate: number, depth: number, delay: number}
+ *     |boolean
+ *     |ArrayBuffer
+ *     |{messageType: WorkletSequencerMessageType, messageData: any}
+ *     )
+ * }} WorkletMessage
+ */
+
+/**
+ * @typedef {Object} WorkletReturnMessage
+ * @property {returnMessageType} messageType - the message's type
+ * @property {{
+ *     eventName: string,
+ *     eventData: any
+ * }|ChannelProperty[]
+ * |PresetListElement[]
+ * |string
+ * |{messageType: WorkletSequencerReturnMessageType, messageData: any}
+ * |SynthesizerSnapshot} messageData - the message's data
+ *
+ * 0 - channel properties           -> [...<ChannelProperty>] see message_sending.js line 29
+ * 1 - event call                   -> {eventName<string>, eventData:<the event's data>}
+ * 2 - reported current time        -> currentTime<number>
+ * 3 - sequencer specific           -> [messageType<WorkletSequencerReturnMessageType> messageData<any>] note: refer to sequencer_message.js
+ * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to snapshot.js
+ * 5 - ready                        -> (no data)
+ * 6 - soundfontError               -> errorMessage<string>
+ */
+
+/**
+ * @enum {number}
+ */
+export const returnMessageType = {
+    channelProperties: 0,
+    eventCall: 1,
+    reportedCurrentTime: 2,
+    sequencerSpecific: 3,
+    synthesizerSnapshot: 4,
+    ready: 5,
+    soundfontError: 6,
+}

package/package/synthetizer/worklet_system/minify_processor.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+esbuild worklet_processor.js --bundle --minify --format=esm --outfile=../worklet_processor.min.js --platform=browser
+echo "Processor minifed succesfully"

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

@@ -0,0 +1,230 @@
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { dataEntryStates } from '../worklet_utilities/worklet_processor_channel.js'
+import { computeModulators } from '../worklet_utilities/worklet_modulator.js'
+import { SpessaSynthInfo } from '../../../utils/loggin.js'
+import { SYNTHESIZER_GAIN } from '../main_processor.js'
+
+/**
+ * @param channel {number}
+ * @param controllerNumber {midiControllers}
+ * @param controllerValue {number}
+ * @param force {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function controllerChange(channel, controllerNumber, controllerValue, force = false)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channelObject = this.workletProcessorChannels[channel];
+    // 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(channelObject.lockedControllers[actualCCNum])
+        {
+            return;
+        }
+        // append the lower nibble to the main controller
+        channelObject.midiControllers[actualCCNum] = (channelObject.midiControllers[actualCCNum] & 0x3F80) | (controllerValue & 0x7F);
+        channelObject.voices.forEach(v => computeModulators(v, channelObject.midiControllers, 1, actualCCNum));
+    }
+    switch (controllerNumber) {
+        case midiControllers.allNotesOff:
+            this.stopAll(channel);
+            break;
+
+        case midiControllers.allSoundOff:
+            this.stopAll(channel, true);
+            break;
+
+        // special case: bank select
+        case midiControllers.bankSelect:
+            let bankNr = controllerValue;
+            if(!force)
+            {
+                switch (this.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(channel, true);
+                        }
+                        else
+                        {
+                            this.setDrums(channel, false);
+                        }
+                        break;
+
+                    case "gm2":
+                        if (bankNr === 120)
+                        {
+                            channelObject.drumChannel = true;
+                            this.callEvent("drumchange", {
+                                channel: channel,
+                                isDrumChannel: true
+                            });
+                        }
+                }
+
+                if (channelObject.drumChannel)
+                {
+                    // 128 for percussion channel
+                    bankNr = 128;
+                }
+                if (bankNr === 128 && !channelObject.drumChannel)
+                {
+                    // if channel is not for percussion, default to bank current
+                    bankNr = channelObject.midiControllers[midiControllers.bankSelect];
+                }
+            }
+
+            channelObject.midiControllers[midiControllers.bankSelect] = bankNr;
+            break;
+
+        case midiControllers.lsbForControl0BankSelect:
+            if(this.system === 'xg')
+            {
+                if(!channelObject.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)
+                    {
+                        channelObject.midiControllers[midiControllers.bankSelect] = controllerValue;
+                    }
+                }
+            }
+            else
+            if(this.system === "gm2")
+            {
+                channelObject.midiControllers[midiControllers.bankSelect] = controllerValue;
+            }
+            break;
+
+        // check for RPN and NPRN and data entry
+        case midiControllers.RPNLsb:
+            channelObject.RPValue = channelObject.RPValue << 7 | controllerValue;
+            channelObject.dataEntryState = dataEntryStates.RPFine;
+            break;
+
+        case midiControllers.RPNMsb:
+            channelObject.RPValue = controllerValue;
+            channelObject.dataEntryState = dataEntryStates.RPCoarse;
+            break;
+
+        case midiControllers.NRPNMsb:
+            channelObject.NRPCoarse = controllerValue;
+            channelObject.dataEntryState = dataEntryStates.NRPCoarse;
+            break;
+
+        case midiControllers.NRPNLsb:
+            channelObject.NRPFine = controllerValue;
+            channelObject.dataEntryState = dataEntryStates.NRPFine;
+            break;
+
+        case midiControllers.dataEntryMsb:
+            this.dataEntryCoarse(channel, controllerValue);
+            break;
+
+        case midiControllers.lsbForControl6DataEntry:
+            this.dataEntryFine(channel, controllerValue);
+            break;
+
+        case midiControllers.resetAllControllers:
+            this.resetControllers(channel);
+            break;
+
+        case midiControllers.sustainPedal:
+            if (controllerValue >= 64)
+            {
+                channelObject.holdPedal = true;
+            }
+            else
+            {
+                channelObject.holdPedal = false;
+                channelObject.sustainedVoices.forEach(v => {
+                    this.releaseVoice(v)
+                });
+                channelObject.sustainedVoices = [];
+            }
+            break;
+
+        // default: apply the controller to the table
+        default:
+            if(channelObject.lockedControllers[controllerNumber])
+            {
+                return;
+            }
+            channelObject.midiControllers[controllerNumber] = controllerValue << 7;
+            channelObject.voices.forEach(v => computeModulators(v, channelObject.midiControllers, 1, controllerNumber));
+            this.callEvent("controllerchange", {
+                channel: channel,
+                controllerNumber: controllerNumber,
+                controllerValue: controllerValue
+            });
+            break;
+    }
+}
+
+/**
+ * @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 1
+ * @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.currentGain;
+    this.panRight = (pan) * this.currentGain;
+}
+
+/**
+ * @param channel {number}
+ * @param isMuted {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function muteChannel(channel, isMuted)
+{
+    if(isMuted)
+    {
+        this.stopAll(channel, true);
+    }
+    this.workletProcessorChannels[channel].isMuted = isMuted;
+    this.sendChannelProperties();
+    this.callEvent("mutechannel", {
+        channel: channel,
+        isMuted: isMuted
+    });
+}

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

@@ -0,0 +1,277 @@
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import {
+    customControllers,
+    dataEntryStates,
+    NON_CC_INDEX_OFFSET,
+} from '../worklet_utilities/worklet_processor_channel.js'
+import { modulatorSources } from '../../../soundfont/read/modulators.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.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}
+ * @private
+ */
+export function dataEntryCoarse(channel, dataValue)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channelObject = this.workletProcessorChannels[channel];
+    let addDefaultVibrato = () =>
+    {
+        if(channelObject.channelVibrato.delay === 0 && channelObject.channelVibrato.rate === 0 && channelObject.channelVibrato.depth === 0)
+        {
+            channelObject.channelVibrato.depth = 50;
+            channelObject.channelVibrato.rate = 8;
+            channelObject.channelVibrato.delay = 0.6;
+        }
+    }
+    switch(channelObject.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
+        case dataEntryStates.NRPFine:
+            switch(channelObject.NRPCoarse)
+            {
+                default:
+                    if(dataValue === 64)
+                    {
+                        // default value
+                        return;
+                    }
+                    SpessaSynthWarn(
+                        `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16).toUpperCase()} 0x${channelObject.NRPFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`,
+                        consoleColors.warn,
+                        consoleColors.recognized,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value);
+                    break;
+
+                case 0x01:
+                    switch(channelObject.NRPFine)
+                    {
+                        default:
+                            if(dataValue === 64)
+                            {
+                                // default value
+                                return;
+                            }
+                            SpessaSynthWarn(
+                                `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16)} 0x${channelObject.NRPFine.toString(16)})%c data value: %c${dataValue}`,
+                                consoleColors.warn,
+                                consoleColors.recognized,
+                                consoleColors.warn,
+                                consoleColors.unrecognized,
+                                consoleColors.warn,
+                                consoleColors.value);
+                            break;
+
+                        // vibrato rate
+                        case 0x08:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.rate = (dataValue / 64) * 8;
+                            SpessaSynthInfo(`%cVibrato rate for channel %c${channel}%c is now set to %c${channelObject.channelVibrato.rate}%cHz.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // vibrato depth
+                        case 0x09:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.depth = dataValue / 2;
+                            SpessaSynthInfo(`%cVibrato depth for %c${channel}%c is now set to %c${channelObject.channelVibrato.depth}%c cents range of detune.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // vibrato delay
+                        case 0x0A:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.delay = (dataValue / 64) / 3;
+                            SpessaSynthInfo(`%cVibrato delay for %c${channel}%c is now set to %c${channelObject.channelVibrato.delay}%c seconds.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // filter cutoff
+                        case 0x20:
+                            // affect the "brightness" controller as we have a default modulator that controls it
+                            const ccValue = dataValue;
+                            this.controllerChange(channel, midiControllers.brightness, dataValue)
+                            SpessaSynthInfo(`%cFilter cutoff for %c${channel}%c is now set to %c${ccValue}`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value);
+                    }
+                    break;
+
+                // drum reverb
+                case 0x1D:
+                    if(!channelObject.drumChannel)
+                    {
+                        return;
+                    }
+                    const reverb = dataValue;
+                    this.controllerChange(channel, midiControllers.effects1Depth, reverb);
+                    SpessaSynthInfo(
+                        `%cGS Drum reverb for %c${channel}%c: %c${reverb}`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.value);
+                    break;
+            }
+            break;
+
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            switch(channelObject.RPValue)
+            {
+                default:
+                    SpessaSynthWarn(
+                        `%cUnrecognized RPN for %c${channel}%c: %c(0x${channelObject.RPValue.toString(16)})%c data value: %c${dataValue}`,
+                        consoleColors.warn,
+                        consoleColors.recognized,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value);
+                    break;
+
+                // pitch bend range
+                case 0x0000:
+                    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
+                    SpessaSynthInfo(`%cChannel ${channel} bend range. Semitones: %c${dataValue}`,
+                        consoleColors.info,
+                        consoleColors.value);
+                    break;
+
+                // coarse tuning
+                case 0x0002:
+                    // semitones
+                    this.setChannelTuningSemitones(channel, dataValue - 64);
+                    break;
+
+                // 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);
+                    break;
+
+                // modulation depth
+                case 0x0005:
+                    this.setModulationDepth(channel, 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;
+                    }
+                    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] |= dataValue; // 14 bit value so upper 7 are coarse and lower 7 are fine!
+                    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);
+                    break;
+
+            }
+
+    }
+}