spessasynth_lib 0.0.1

package/package/synthetizer/worklet_system/worklet_methods/note_off.js

@@ -0,0 +1,109 @@
+import { generatorTypes } from '../../../soundfont/read/generators.js'
+import { consoleColors } from '../../../utils/other.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.js'
+
+/**
+ * Release a note
+ * @param channel {number}
+ * @param midiNote {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function noteOff(channel, midiNote)
+{
+    if(midiNote > 127 || midiNote < 0)
+    {
+        SpessaSynthWarn(`Received a noteOn for note`, midiNote, "Ignoring.");
+        return;
+    }
+    midiNote += this.workletProcessorChannels[channel].channelTransposeKeyShift;
+
+    // if high performance mode, kill notes instead of stopping them
+    if(this.highPerformanceMode)
+    {
+        // if the channel is percussion channel, do not kill the notes
+        if(!this.workletProcessorChannels[channel].drumChannel)
+        {
+            this.killNote(channel, midiNote);
+            return;
+        }
+    }
+
+    const channelVoices = this.workletProcessorChannels[channel].voices;
+    channelVoices.forEach(v => {
+        if(v.midiNote !== midiNote || v.isInRelease === true)
+        {
+            return;
+        }
+        // if hold pedal, move to sustain
+        if(this.workletProcessorChannels[channel].holdPedal) {
+            this.workletProcessorChannels[channel].sustainedVoices.push(v);
+        }
+        else
+        {
+            this.releaseVoice(v);
+        }
+    });
+    this.callEvent("noteoff", {
+        midiNote: midiNote - this.workletProcessorChannels[channel].channelTransposeKeyShift,
+        channel: channel
+    });
+}
+
+/**
+ * Stops a note nearly instantly
+ * @param channel {number}
+ * @param midiNote {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function killNote(channel, midiNote)
+{
+    this.workletProcessorChannels[channel].voices.forEach(v => {
+        if(v.midiNote !== midiNote)
+        {
+            return;
+        }
+        v.modulatedGenerators[generatorTypes.releaseVolEnv] = -12000; // set release to be very short
+        this.releaseVoice(v);
+    });
+}
+
+/**
+ * stops all notes
+ * @param channel {number}
+ * @param force {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function stopAll(channel, force = false)
+{
+    const channelVoices = this.workletProcessorChannels[channel].voices;
+    if(force)
+    {
+        // force stop all
+        channelVoices.length = 0;
+        this.workletProcessorChannels[channel].sustainedVoices.length = 0;
+        this.sendChannelProperties();
+    }
+    else
+    {
+        channelVoices.forEach(v => {
+            if(v.isInRelease) return;
+            this.releaseVoice(v);
+        });
+        this.workletProcessorChannels[channel].sustainedVoices.forEach(v => {
+            this.releaseVoice(v);
+        })
+    }
+}
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param force {boolean}
+ */
+export function stopAllChannels(force = false)
+{
+    SpessaSynthInfo("%cStop all received!", consoleColors.info);
+    for (let i = 0; i < this.workletProcessorChannels.length; i++) {
+        this.stopAll(i, force);
+    }
+    this.callEvent("stopall", undefined);
+}

package/package/synthetizer/worklet_system/worklet_methods/note_on.js

@@ -0,0 +1,91 @@
+import { getWorkletVoices } from '../worklet_utilities/worklet_voice.js'
+import { generatorTypes } from '../../../soundfont/read/generators.js'
+import { computeModulators } from '../worklet_utilities/worklet_modulator.js'
+import { recalculateVolumeEnvelope } from '../worklet_utilities/volume_envelope.js'
+
+/**
+ * Append the voices
+ * @param channel {number}
+ * @param midiNote {number}
+ * @param velocity {number}
+ * @param enableDebugging {boolean}
+ * @param sendEvent {boolean}
+ * @param startTime {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function noteOn(channel, midiNote, velocity, enableDebugging = false, sendEvent = true, startTime = currentTime)
+{
+    if (velocity === 0)
+    {
+        this.noteOff(channel, midiNote);
+        return;
+    }
+
+    if (
+        (this.highPerformanceMode && this.totalVoicesAmount > 200 && velocity < 40) ||
+        (this.highPerformanceMode && velocity < 10) ||
+        (this.workletProcessorChannels[channel].isMuted)
+    )
+    {
+        return;
+    }
+
+    midiNote += this.workletProcessorChannels[channel].channelTransposeKeyShift;
+
+    if(midiNote > 127 || midiNote < 0)
+    {
+        return;
+    }
+
+    // get voices
+    const voices = getWorkletVoices(
+        channel,
+        midiNote,
+        velocity,
+        this.workletProcessorChannels[channel].preset,
+        startTime,
+        sampleRate,
+        data => this.sampleDump(data.channel, data.sampleID, data.sampleData),
+        this.workletProcessorChannels[channel].cachedVoices,
+        enableDebugging
+    );
+
+    // add voices and exclusive class apply
+    const channelVoices = this.workletProcessorChannels[channel].voices;
+    voices.forEach(voice => {
+        const exclusive = voice.generators[generatorTypes.exclusiveClass];
+        if(exclusive !== 0)
+        {
+            channelVoices.forEach(v => {
+                if(v.generators[generatorTypes.exclusiveClass] === exclusive)
+                {
+                    this.releaseVoice(v);
+                    v.modulatedGenerators[generatorTypes.releaseVolEnv] = -7000; // make the release nearly instant
+                    v.modulatedGenerators[generatorTypes.releaseModEnv] = -7000;
+                    recalculateVolumeEnvelope(v);
+                }
+            })
+        }
+        // compute all modulators
+        computeModulators(voice, this.workletProcessorChannels[channel].midiControllers);
+        // set initial pan to avoid split second changing from middle to the correct value
+        voice.currentPan = ((Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan] )) + 500) / 1000) // 0 to 1
+    });
+
+    this.totalVoicesAmount += voices.length;
+    // cap the voices
+    if(this.totalVoicesAmount > this.voiceCap)
+    {
+        this.voiceKilling(voices.length);
+    }
+    channelVoices.push(...voices);
+    if(sendEvent)
+    {
+        this.sendChannelProperties();
+        this.callEvent("noteon", {
+            midiNote: midiNote - this.workletProcessorChannels[channel].channelTransposeKeyShift,
+            channel: channel,
+            velocity: velocity,
+        });
+    }
+}

package/package/synthetizer/worklet_system/worklet_methods/program_control.js

@@ -0,0 +1,183 @@
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { SoundFont2 } from '../../../soundfont/soundfont.js'
+import { clearSamplesList } from '../worklet_utilities/worklet_voice.js'
+import { generatorTypes } from '../../../soundfont/read/generators.js'
+import { returnMessageType } from '../message_protocol/worklet_message.js'
+import { SpessaSynthInfo } from '../../../utils/loggin.js'
+import { consoleColors } from '../../../utils/other.js'
+
+/**
+ * executes a program change
+ * @param channel {number}
+ * @param programNumber {number}
+ * @param userChange {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function programChange(channel, programNumber, userChange=false)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channelObject = this.workletProcessorChannels[channel];
+    if(channelObject.lockPreset)
+    {
+        return;
+    }
+    // always 128 for percussion
+    const bank = channelObject.drumChannel ? 128 : channelObject.midiControllers[midiControllers.bankSelect];
+    const preset = this.soundfont.getPreset(bank, programNumber);
+    this.setPreset(channel, preset);
+    this.callEvent("programchange",{
+        channel: channel,
+        program: preset.program,
+        bank: preset.bank,
+        userCalled: userChange
+    });
+}
+
+/**
+ * @param channel {number}
+ * @param preset {Preset}
+ * @this {SpessaSynthProcessor}
+ */
+export function setPreset(channel, preset)
+{
+    if(this.workletProcessorChannels[channel].lockPreset)
+    {
+        return;
+    }
+    this.workletProcessorChannels[channel].preset = preset;
+
+    // reset cached voices
+    this.workletProcessorChannels[channel].cachedVoices = [];
+    for (let i = 0; i < 128; i++) {
+        this.workletProcessorChannels[channel].cachedVoices.push([]);
+    }
+}
+
+/**
+ * Toggles drums on a given channel
+ * @param channel {number}
+ * @param isDrum {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function setDrums(channel, isDrum)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    if(channelObject.lockPreset)
+    {
+        return;
+    }
+    if(isDrum)
+    {
+        // clear transpose
+        channelObject.channelTransposeKeyShift = 0;
+        channelObject.drumChannel = true;
+        this.setPreset(channel, this.soundfont.getPreset(128, channelObject.preset.program));
+    }
+    else
+    {
+        channelObject.drumChannel = false;
+        this.setPreset(channel, this.soundfont.getPreset(channelObject.midiControllers[midiControllers.bankSelect], channelObject.preset.program));
+    }
+    this.callEvent("drumchange",{
+        channel: channel,
+        isDrumChannel: channelObject.drumChannel
+    });
+    this.sendChannelProperties();
+}
+
+/**
+ * @this {SpessaSynthProcessor}
+ */
+export function sendPresetList()
+{
+    this.callEvent("presetlistchange", this.soundfont.presets.map(p => {
+        return {presetName: p.presetName, bank: p.bank, program: p.program};
+    }));
+}
+
+/**
+ * @param buffer {ArrayBuffer}
+ * @this {SpessaSynthProcessor}
+ */
+export function reloadSoundFont(buffer)
+{
+    this.stopAllChannels(true);
+    delete this.soundfont;
+
+
+    try {
+        this.soundfont = new SoundFont2(buffer);
+    }
+    catch (e)
+    {
+        this.post({
+            messageType: returnMessageType.soundfontError,
+            messageData: e
+        });
+        return;
+    }
+    clearSamplesList();
+    delete this.workletDumpedSamplesList;
+    this.workletDumpedSamplesList = [];
+    this.defaultPreset = this.soundfont.getPreset(0, 0);
+    this.drumPreset = this.soundfont.getPreset(128, 0);
+
+    for(let i = 0; i < this.workletProcessorChannels.length; i++)
+    {
+        const channelObject = this.workletProcessorChannels[i];
+        channelObject.cachedVoices = [];
+        for (let j = 0; j < 128; j++) {
+            channelObject.cachedVoices.push([]);
+        }
+        channelObject.lockPreset = false;
+        this.programChange(i, channelObject.preset.program);
+    }
+    this.post({messageType: returnMessageType.ready, messageData: undefined});
+    this.sendPresetList();
+    SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);
+}
+
+/**
+ * saves a sample
+ * @param channel {number}
+ * @param sampleID {number}
+ * @param sampleData {Float32Array}
+ * @this {SpessaSynthProcessor}
+ */
+export function sampleDump(channel, sampleID, sampleData)
+{
+    this.workletDumpedSamplesList[sampleID] = sampleData;
+    // the sample maybe was loaded after the voice was sent... adjust the end position!
+
+    // not for all channels because the system tells us for what channel this voice was dumped! yay!
+    this.workletProcessorChannels[channel].voices.forEach(v => {
+        if(v.sample.sampleID !== sampleID)
+        {
+            return;
+        }
+        v.sample.end = sampleData.length - 1 + v.generators[generatorTypes.endAddrOffset] + (v.generators[generatorTypes.endAddrsCoarseOffset] * 32768);
+        // calculate for how long the sample has been playing and move the cursor there
+        v.sample.cursor = (v.sample.playbackStep * sampleRate) * (currentTime - v.startTime);
+        if(v.sample.loopingMode === 0) // no loop
+        {
+            if (v.sample.cursor >= v.sample.end)
+            {
+                v.finished = true;
+                return;
+            }
+        }
+        else
+        {
+            // go through modulo (adjust cursor if the sample has looped
+            if(v.sample.cursor > v.sample.loopEnd)
+            {
+                v.sample.cursor = v.sample.cursor % (v.sample.loopEnd - v.sample.loopStart) + v.sample.loopStart - 1;
+            }
+        }
+        // set start time to current!
+        v.startTime = currentTime;
+    })
+
+}

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

@@ -0,0 +1,177 @@
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE } from '../../synthetizer.js'
+import {
+    customControllers,
+    customResetArray, dataEntryStates,
+    NON_CC_INDEX_OFFSET,
+    resetArray,
+} from '../worklet_utilities/worklet_processor_channel.js'
+import { modulatorSources } from '../../../soundfont/read/modulators.js'
+import { SpessaSynthInfo } from '../../../utils/loggin.js'
+
+/**
+ * @this {SpessaSynthProcessor}
+ */
+export function resetAllControllers()
+{
+    SpessaSynthInfo("%cResetting all controllers!", consoleColors.info);
+    this.callEvent("allcontrollerreset", undefined);
+    for (let channelNumber = 0; channelNumber < this.workletProcessorChannels.length; channelNumber++)
+    {
+        this.resetControllers(channelNumber);
+
+        /**
+         * @type {WorkletProcessorChannel}
+         **/
+        const ch = this.workletProcessorChannels[channelNumber];
+
+        // if preset is unlocked, switch to non drums and call event
+        if(!ch.lockPreset)
+        {
+            ch.midiControllers[midiControllers.bankSelect] = 0;
+            if (channelNumber % 16 === DEFAULT_PERCUSSION)
+            {
+                this.setPreset(channelNumber, this.drumPreset);
+                ch.drumChannel = true;
+                this.callEvent("drumchange", {
+                    channel: channelNumber,
+                    isDrumChannel: true
+                });
+            }
+            else
+            {
+                ch.drumChannel = false;
+                this.setPreset(channelNumber, this.defaultPreset);
+                this.callEvent("drumchange", {
+                    channel: channelNumber,
+                    isDrumChannel: false
+                });
+            }
+        }
+        else
+        {
+            this.callEvent("drumchange", {
+                channel: channelNumber,
+                isDrumChannel: ch.drumChannel
+            })
+        }
+
+        // call program change
+        this.callEvent("programchange", {
+            channel: channelNumber,
+            program: ch.preset.program,
+            bank: ch.preset.bank,
+            userCalled: false
+        });
+
+        let restoreControllerValueEvent = ccNum =>
+        {
+            if(this.workletProcessorChannels[channelNumber].lockedControllers[ccNum])
+            {
+                // was not reset so restore the value
+                this.callEvent("controllerchange", {
+                    channel: channelNumber,
+                    controllerNumber: ccNum,
+                    controllerValue: this.workletProcessorChannels[channelNumber].midiControllers[ccNum] >> 7
+                });
+            }
+
+        }
+
+        restoreControllerValueEvent(midiControllers.mainVolume);
+        restoreControllerValueEvent(midiControllers.pan);
+        restoreControllerValueEvent(midiControllers.expressionController);
+        restoreControllerValueEvent(midiControllers.modulationWheel);
+        restoreControllerValueEvent(midiControllers.effects3Depth);
+        restoreControllerValueEvent(midiControllers.effects1Depth);
+
+        // restore pitch wheel
+        if(this.workletProcessorChannels[channelNumber].lockedControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel])
+        {
+            const val = this.workletProcessorChannels[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.setMIDIVolume(1);
+    this.system = DEFAULT_SYNTH_MODE;
+}
+
+/**
+ * Resets all controllers for channel
+ * @param channel {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function resetControllers(channel)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    /**
+     * get excluded (locked) cc numbers as locked ccs are unaffected by reset
+     * @type {number[]}
+     */
+    const excludedCCs = channelObject.lockedControllers.reduce((lockedCCs, cc, ccNum) => {
+        if(cc)
+        {
+            lockedCCs.push(ccNum);
+        }
+        return lockedCCs;
+    }, []);
+    // save excluded controllers as reset doesn't affect them
+    let excludedCCvalues = excludedCCs.map(ccNum => {
+        return {
+            ccNum: ccNum,
+            ccVal: channelObject.midiControllers[ccNum]
+        }
+    });
+
+    // reset the array
+    channelObject.midiControllers.set(resetArray);
+    channelObject.channelVibrato = {rate: 0, depth: 0, delay: 0};
+    channelObject.holdPedal = false;
+
+    excludedCCvalues.forEach((cc) => {
+        channelObject.midiControllers[cc.ccNum] = cc.ccVal;
+    });
+
+    // 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;
+
+    this.resetParameters(channel);
+
+}
+
+/**
+ * @param channel {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function resetParameters(channel)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+
+    // reset parameters
+    /**
+     * @type {number}
+     */
+    channelObject.NRPCoarse = 0;
+    /**
+     * @type {number}
+     */
+    channelObject.NRPFine = 0;
+    /**
+     * @type {number}
+     */
+    channelObject.RPValue = 0;
+    /**
+     * @type {string}
+     */
+    channelObject.dataEntryState = dataEntryStates.Idle;
+}

package/package/synthetizer/worklet_system/worklet_methods/snapshot.js

@@ -0,0 +1,129 @@
+
+/**
+ * @typedef {Object} ChannelSnapshot - a snapshot of the channel.
+ *
+ * @property {number} program - the channel's program
+ * @property {number} bank - the channel's bank
+ * @property {string} patchName - the channel's patch name
+ * @property {boolean} lockPreset - indicates whether the channel's program change is disabled
+ *
+ * @property {Int16Array} midiControllers - the array of all midi controllers (in 14-bit values) with the modulator sources at the end. See Synthesizer Class on wiki (lockController section)
+ * @property {boolean[]} lockedControllers - an array of booleans, indicating if the controller with a current index is locked
+ * @property {Float32Array} customControllers - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+ *
+ * // note: this is a custom vibrato object, set by NRPN messages
+ * @property {boolean} lockVibrato - indicates whether the channel vibrato is locked
+ * @property {Object} channelVibrato - the channel's vibrato
+ * @property {number} channelVibrato.depth - vibrato depth, in gain
+ * @property {number} channelVibrato.delay - vibrato delay from note on in seconds
+ * @property {number} channelVibrato.rate - vibrato rate in Hz
+ *
+ * @property {number} channelTransposeKeyShift - key shift for the channel
+ * @property {boolean} isMuted - indicates whether the channel is muted
+ * @property {boolean} drumChannel - indicates whether the channel is a drum channel
+ */
+/**
+ * @typedef {Object} SynthesizerSnapshot
+ * @property {ChannelSnapshot[]} channelSnapshots - the individual channel snapshots
+ * @property {number} mainVolume - main synth volume (set by MIDI), from 0 to 1
+ * @property {number} pan - master stereo panning, from -1 to 1
+ * @property {SynthSystem} system - the synths system. Values can be "gs", "gm", "gm2" or "xg"
+ * @property {number} transposition - the current synth transpositon in semitones. can be a float
+ */
+
+import { returnMessageType } from '../message_protocol/worklet_message.js'
+import { SpessaSynthInfo } from '../../../utils/loggin.js'
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+
+/**
+ * sends a snapshot of the current controller values of the synth (used to copy that data to OfflineAudioContext when rendering)
+ * @this {SpessaSynthProcessor}
+ */
+export function sendSynthesizerSnapshot()
+{
+    /**
+     * @type {ChannelSnapshot[]}
+     */
+    const channelSnapshots = this.workletProcessorChannels.map(channel => {
+        return {
+            program: channel.preset.program,
+            bank: channel.preset.bank,
+            lockPreset: channel.lockPreset,
+            patchName: channel.preset.presetName,
+
+            midiControllers: channel.midiControllers,
+            lockedControllers: channel.lockedControllers,
+            customControllers: channel.customControllers,
+
+            channelVibrato: channel.channelVibrato,
+            lockVibrato: channel.lockVibrato,
+
+            channelTransposeKeyShift: channel.channelTransposeKeyShift,
+            isMuted: channel.isMuted,
+            drumChannel: channel.drumChannel
+        }
+    });
+
+    /**
+     * @type {SynthesizerSnapshot}
+     */
+    const synthesizerSnapshot = {
+        channelSnapshots: channelSnapshots,
+        mainVolume: this.midiVolume,
+        pan: this.pan,
+        transposition: this.transposition,
+        system: this.system
+    };
+
+    this.post({
+        messageType: returnMessageType.synthesizerSnapshot,
+        messageData: synthesizerSnapshot
+    });
+}
+
+/**
+ * Applies the snapshot to the synth
+ * @param snapshot {SynthesizerSnapshot}
+ * @this {SpessaSynthProcessor}
+ */
+export function applySynthesizerSnapshot(snapshot)
+{
+    // restore system
+    this.system = snapshot.system;
+
+    // restore pan and volume
+    this.setMasterGain(snapshot.mainVolume);
+    this.setMasterPan(snapshot.pan);
+    this.transposeAllChannels(snapshot.transposition);
+
+    // add channels if more needed
+    while(this.workletProcessorChannels.length < snapshot.channelSnapshots.length)
+    {
+        this.createWorkletChannel();
+    }
+
+    // restore cahnnels
+    snapshot.channelSnapshots.forEach((channelSnapshot, index) => {
+        const channelObject = this.workletProcessorChannels[index];
+        this.muteChannel(index, channelSnapshot.isMuted);
+        this.setDrums(index, channelSnapshot.drumChannel);
+
+        // restore controllers
+        channelObject.midiControllers = channelSnapshot.midiControllers;
+        channelObject.lockedControllers = channelSnapshot.lockedControllers;
+        channelObject.customControllers = channelSnapshot.customControllers;
+
+        // restore vibrato and transpose
+        channelObject.channelVibrato = channelSnapshot.channelVibrato;
+        channelObject.lockVibrato = channelSnapshot.lockVibrato;
+        channelObject.channelTransposeKeyShift = channelSnapshot.channelTransposeKeyShift;
+
+        // restore preset and lock
+        channelObject.lockPreset = false;
+        channelObject.midiControllers[midiControllers.bankSelect] = channelSnapshot.bank;
+        this.programChange(index, channelSnapshot.program);
+        channelObject.lockPreset = channelSnapshot.lockPreset;
+    });
+    SpessaSynthInfo("%cFinished restoring controllers!", consoleColors.info);
+}