spessasynth_core 1.1.2 → 1.1.4

package/src/synthetizer/audio_engine/engine_methods/controller_control/controller_change.js

@@ -0,0 +1,132 @@
+import { midiControllers } from "../../../../midi/midi_message.js";
+import { computeModulators } from "../../engine_components/compute_modulator.js";
+import { channelConfiguration, dataEntryStates } from "../../engine_components/controller_tables.js";
+
+/**
+ * @param controllerNumber {number}
+ * @param controllerValue {number}
+ * @param force {boolean}
+ * @this {MidiAudioChannel}
+ */
+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));
+    }
+    if (this.lockedControllers[controllerNumber])
+    {
+        return;
+    }
+    
+    // apply the cc to the table
+    this.midiControllers[controllerNumber] = controllerValue << 7;
+    
+    // interpret special CCs
+    {
+        switch (controllerNumber)
+        {
+            case midiControllers.allNotesOff:
+                this.stopAllNotes();
+                break;
+            
+            case midiControllers.allSoundOff:
+                this.stopAllNotes(true);
+                break;
+            
+            // special case: bank select
+            case midiControllers.bankSelect:
+                this.setBankSelect(controllerValue);
+                break;
+            
+            case midiControllers.lsbForControl0BankSelect:
+                this.setBankSelect(controllerValue, true);
+                break;
+            
+            // check for RPN and NPRN and data entry
+            case midiControllers.RPNLsb:
+                this.dataEntryState = dataEntryStates.RPFine;
+                break;
+            
+            case midiControllers.RPNMsb:
+                this.dataEntryState = dataEntryStates.RPCoarse;
+                break;
+            
+            case midiControllers.NRPNMsb:
+                this.dataEntryState = dataEntryStates.NRPCoarse;
+                break;
+            
+            case midiControllers.NRPNLsb:
+                this.dataEntryState = dataEntryStates.NRPFine;
+                break;
+            
+            case midiControllers.dataEntryMsb:
+                this.dataEntryCoarse(controllerValue);
+                break;
+            
+            case midiControllers.lsbForControl6DataEntry:
+                this.dataEntryFine(controllerValue);
+                break;
+            
+            case midiControllers.resetAllControllers:
+                this.resetControllersRP15Compliant();
+                break;
+            
+            case midiControllers.sustainPedal:
+                if (controllerValue >= 64)
+                {
+                    this.holdPedal = true;
+                }
+                else
+                {
+                    this.holdPedal = false;
+                    this.sustainedVoices.forEach(v =>
+                    {
+                        v.release(this.synth.currentSynthTime);
+                    });
+                    this.sustainedVoices = [];
+                }
+                break;
+            
+            // default: just compute modulators
+            default:
+                this.voices.forEach(v => computeModulators(v, this.midiControllers, 1, controllerNumber));
+                break;
+        }
+    }
+    this.synth.callEvent("controllerchange", {
+        channel: this.channelNumber,
+        controllerNumber: controllerNumber,
+        controllerValue: controllerValue
+    });
+}

package/src/synthetizer/audio_engine/engine_methods/controller_control/master_parameters.js

@@ -0,0 +1,48 @@
+import { SYNTHESIZER_GAIN } from "../../main_processor.js";
+
+/**
+ * @enum {number}
+ */
+export const masterParameterType = {
+    mainVolume: 0,
+    masterPan: 1,
+    voicesCap: 2,
+    interpolationType: 3,
+    midiSystem: 4
+};
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param type {masterParameterType}
+ * @param value {number|string|interpolationTypes}
+ */
+export function setMasterParameter(type, value)
+{
+    switch (type)
+    {
+        case masterParameterType.masterPan:
+            let pan = value;
+            this.pan = pan;
+            // clamp to 0-1 (0 is left)
+            pan = (pan / 2) + 0.5;
+            this.panLeft = (1 - pan);
+            this.panRight = (pan);
+            break;
+        
+        case masterParameterType.mainVolume:
+            this.masterGain = value * SYNTHESIZER_GAIN;
+            this.setMasterParameter(masterParameterType.masterPan, this.pan);
+            break;
+        
+        case masterParameterType.voicesCap:
+            this.voiceCap = value;
+            break;
+        
+        case masterParameterType.interpolationType:
+            this.interpolationType = value;
+            break;
+        
+        case masterParameterType.midiSystem:
+            this.setSystem(value);
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/controller_control/reset_controllers.js

@@ -0,0 +1,241 @@
+import { consoleColors } from "../../../../utils/other.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
+import {
+    customControllers,
+    customResetArray,
+    dataEntryStates,
+    NON_CC_INDEX_OFFSET,
+    PORTAMENTO_CONTROL_UNSET,
+    resetArray
+} from "../../engine_components/controller_tables.js";
+import { midiControllers } from "../../../../midi/midi_message.js";
+import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE } from "../../../synth_constants.js";
+import { getDefaultBank } from "../../../../utils/xg_hacks.js";
+
+
+/**
+ * Full system reset
+ * @this {SpessaSynthProcessor}
+ * @param log {boolean}
+ */
+export function resetAllControllers(log = true)
+{
+    if (log)
+    {
+        SpessaSynthInfo("%cResetting all controllers!", consoleColors.info);
+    }
+    this.callEvent("allcontrollerreset", undefined);
+    this.setSystem(DEFAULT_SYNTH_MODE);
+    for (let channelNumber = 0; channelNumber < this.midiAudioChannels.length; channelNumber++)
+    {
+        this.midiAudioChannels[channelNumber].resetControllers();
+        
+        /**
+         * @type {MidiAudioChannel}
+         **/
+        const ch = this.midiAudioChannels[channelNumber];
+        
+        // if preset is unlocked, switch to non-drums and call event
+        if (!ch.lockPreset)
+        {
+            ch.setBankSelect(getDefaultBank(this.system));
+            if (channelNumber % 16 === DEFAULT_PERCUSSION)
+            {
+                ch.setPreset(this.drumPreset);
+                ch.presetUsesOverride = this.defaultDrumsUsesOverride;
+                ch.drumChannel = true;
+                this.callEvent("drumchange", {
+                    channel: channelNumber,
+                    isDrumChannel: true
+                });
+            }
+            else
+            {
+                ch.drumChannel = false;
+                ch.presetUsesOverride = this.defaultDrumsUsesOverride;
+                ch.setPreset(this.defaultPreset);
+                this.callEvent("drumchange", {
+                    channel: channelNumber,
+                    isDrumChannel: false
+                });
+            }
+        }
+        else
+        {
+            this.callEvent("drumchange", {
+                channel: channelNumber,
+                isDrumChannel: ch.drumChannel
+            });
+        }
+        
+        const presetBank = ch.preset.bank;
+        const sentBank = presetBank === 128 ? 128 : (ch.presetUsesOverride ? presetBank + this.soundfontBankOffset : presetBank);
+        
+        // call program change
+        this.callEvent("programchange", {
+            channel: channelNumber,
+            program: ch.preset.program,
+            bank: sentBank
+        });
+        
+        for (let ccNum = 0; ccNum < 128; ccNum++)
+        {
+            if (this.midiAudioChannels[channelNumber].lockedControllers[ccNum])
+            {
+                // was not reset so restore the value
+                this.callEvent("controllerchange", {
+                    channel: channelNumber,
+                    controllerNumber: ccNum,
+                    controllerValue: this.midiAudioChannels[channelNumber].midiControllers[ccNum] >> 7
+                });
+            }
+            
+        }
+        
+        
+        // restore pitch wheel
+        if (this.midiAudioChannels[channelNumber].lockedControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] === false)
+        {
+            const val = this.midiAudioChannels[channelNumber].midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel];
+            const msb = val >> 7;
+            const lsb = val & 0x7F;
+            this.callEvent("pitchwheel", {
+                channel: channelNumber,
+                MSB: msb,
+                LSB: lsb
+            });
+        }
+    }
+    this.tunings = [];
+    this.tunings = [];
+    for (let i = 0; i < 128; i++)
+    {
+        this.tunings.push([]);
+    }
+    
+    this.setMIDIVolume(1);
+}
+
+/**
+ * Resets all controllers for channel
+ * @this {MidiAudioChannel}
+ */
+export function resetControllers()
+{
+    this.channelOctaveTuning.fill(0);
+    
+    // reset the array
+    for (let i = 0; i < resetArray.length; i++)
+    {
+        if (this.lockedControllers[i])
+        {
+            continue;
+        }
+        const resetValue = resetArray[i];
+        if (this.midiControllers[i] !== resetValue && i < 127)
+        {
+            if (i === midiControllers.portamentoControl)
+            {
+                this.midiControllers[i] = PORTAMENTO_CONTROL_UNSET;
+            }
+            else
+            {
+                this.controllerChange(i, resetValue >> 7);
+            }
+        }
+        else
+        {
+            // out of range, do a regular reset
+            this.midiControllers[i] = resetValue;
+        }
+    }
+    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 = this.customControllers[customControllers.channelTransposeFine];
+    this.customControllers.set(customResetArray);
+    this.setCustomController(customControllers.channelTransposeFine, transpose);
+    
+    this.resetParameters();
+    
+}
+
+
+/**
+ * @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 {MidiAudioChannel}
+ */
+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])
+        {
+            if (i === midiControllers.portamentoControl)
+            {
+                this.midiControllers[i] = PORTAMENTO_CONTROL_UNSET;
+            }
+            else
+            {
+                this.controllerChange(i, resetValue >> 7);
+            }
+        }
+    }
+}
+
+/**
+ * @this {MidiAudioChannel}
+ */
+export function resetParameters()
+{
+    /**
+     * reset the state machine to idle
+     * @type {string}
+     */
+    this.dataEntryState = dataEntryStates.Idle;
+    SpessaSynthInfo(
+        "%cResetting Registered and Non-Registered Parameters!",
+        consoleColors.info
+    );
+}

package/src/synthetizer/audio_engine/engine_methods/create_midi_channel.js

@@ -0,0 +1,27 @@
+import { MidiAudioChannel } from "../engine_components/midi_audio_channel.js";
+
+import { DEFAULT_PERCUSSION } from "../../synth_constants.js";
+
+/**
+ * @param sendEvent {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function createMidiChannel(sendEvent = false)
+{
+    /**
+     * @type {MidiAudioChannel}
+     */
+    const channel = new MidiAudioChannel(this, this.defaultPreset, this.midiAudioChannels.length);
+    this.midiAudioChannels.push(channel);
+    channel.resetControllers();
+    channel.sendChannelProperty();
+    if (sendEvent)
+    {
+        this.callEvent("newchannel", undefined);
+    }
+    
+    if (channel.channelNumber % 16 === DEFAULT_PERCUSSION)
+    {
+        this.midiAudioChannels[this.midiAudioChannels.length - 1].setDrums(true);
+    }
+}

package/src/synthetizer/audio_engine/engine_methods/data_entry/data_entry_coarse.js

@@ -0,0 +1,253 @@
+import { customControllers, dataEntryStates, NON_CC_INDEX_OFFSET } from "../../engine_components/controller_tables.js";
+import { SpessaSynthInfo, SpessaSynthWarn } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+import { midiControllers } from "../../../../midi/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
+ * @this {MidiAudioChannel}
+ * @private
+ */
+export function dataEntryCoarse(dataValue)
+{
+    const addDefaultVibrato = () =>
+    {
+        if (this.channelVibrato.delay === 0 && this.channelVibrato.rate === 0 && this.channelVibrato.depth === 0)
+        {
+            this.channelVibrato.depth = 50;
+            this.channelVibrato.rate = 8;
+            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;
+        
+        // process GS NRPNs
+        case dataEntryStates.NRPFine:
+            if (this.lockGSNRPNParams)
+            {
+                return;
+            }
+            /**
+             * @type {number}
+             */
+            const NRPNCoarse = this.midiControllers[midiControllers.NRPNMsb] >> 7;
+            /**
+             * @type {number}
+             */
+            const NRPNFine = this.midiControllers[midiControllers.NRPNLsb] >> 7;
+            switch (NRPNCoarse)
+            {
+                default:
+                    if (dataValue === 64)
+                    {
+                        // default value
+                        return;
+                    }
+                    SpessaSynthWarn(
+                        `%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,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value
+                    );
+                    break;
+                
+                // part parameters: vibrato, cutoff
+                case nonRegisteredParameterNumbers.partParameter:
+                    switch (NRPNFine)
+                    {
+                        default:
+                            if (dataValue === 64)
+                            {
+                                // default value
+                                return;
+                            }
+                            SpessaSynthWarn(
+                                `%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,
+                                consoleColors.warn,
+                                consoleColors.unrecognized,
+                                consoleColors.warn,
+                                consoleColors.value
+                            );
+                            break;
+                        
+                        // vibrato rate
+                        case nonRegisteredParameterNumbers.vibratoRate:
+                            if (dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            this.channelVibrato.rate = (dataValue / 64) * 8;
+                            coolInfo("Vibrato rate", `${dataValue} = ${this.channelVibrato.rate}`, "Hz");
+                            break;
+                        
+                        // vibrato depth
+                        case nonRegisteredParameterNumbers.vibratoDepth:
+                            if (dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            this.channelVibrato.depth = dataValue / 2;
+                            coolInfo("Vibrato depth", `${dataValue} = ${this.channelVibrato.depth}`, "cents of detune");
+                            break;
+                        
+                        // vibrato delay
+                        case nonRegisteredParameterNumbers.vibratoDelay:
+                            if (dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            this.channelVibrato.delay = (dataValue / 64) / 3;
+                            coolInfo("Vibrato delay", `${dataValue} = ${this.channelVibrato.delay}`, "seconds");
+                            break;
+                        
+                        // filter cutoff
+                        case nonRegisteredParameterNumbers.TVFFilterCutoff:
+                            // affect the "brightness" controller as we have a default modulator that controls it
+                            this.controllerChange(midiControllers.brightness, dataValue);
+                            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 nonRegisteredParameterNumbers.drumReverb:
+                    const reverb = dataValue;
+                    this.controllerChange(midiControllers.reverbDepth, reverb);
+                    coolInfo("GS Drum reverb", reverb.toString(), "percent");
+                    break;
+            }
+            break;
+        
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            /**
+             * @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${rpnValue.toString(16)})%c data value: %c${dataValue}`,
+                        consoleColors.warn,
+                        consoleColors.recognized,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value
+                    );
+                    break;
+                
+                // pitch bend range
+                case registeredParameterTypes.pitchBendRange:
+                    this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
+                    coolInfo("Pitch bend range", dataValue.toString(), "semitones");
+                    break;
+                
+                // coarse tuning
+                case registeredParameterTypes.coarseTuning:
+                    // semitones
+                    const semitones = dataValue - 64;
+                    this.setCustomController(customControllers.channelTuningSemitones, semitones);
+                    coolInfo("Coarse tuning", semitones.toString(), "semitones");
+                    break;
+                
+                // fine-tuning
+                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 registeredParameterTypes.modulationDepth:
+                    this.setModulationDepth(dataValue * 100);
+                    break;
+                
+                case registeredParameterTypes.resetParameters:
+                    this.resetParameters();
+                    break;
+                
+            }
+        
+    }
+}