spessasynth_core 1.0.0

package/spessasynth_core/synthetizer/synthesizer.js

@@ -0,0 +1,303 @@
+import {
+    addNewChannel,
+} from './worklet_system/worklet_utilities/worklet_processor_channel.js'
+
+import { SoundFont2 } from '../soundfont/soundfont_parser.js'
+import { systemExclusive } from './worklet_system/worklet_methods/system_exclusive.js'
+import { noteOn } from './worklet_system/worklet_methods/note_on.js'
+import { dataEntryCoarse, dataEntryFine } from './worklet_system/worklet_methods/data_entry.js'
+import { killNote, noteOff, stopAll, stopAllChannels } from './worklet_system/worklet_methods/note_off.js'
+import {
+    controllerChange, muteChannel,
+    resetAllControllers,
+    resetControllers,
+    resetParameters, setMainVolume, setMasterPan,
+} from './worklet_system/worklet_methods/controller_control.js'
+import {
+    pitchWheel,
+    setChannelTuning,
+    setMasterTuning, setModulationDepth,
+    transposeAllChannels,
+    transposeChannel,
+} from './worklet_system/worklet_methods/tuning_control.js'
+import {
+    programChange,
+    reloadSoundFont,
+    sampleDump,
+    setDrums,
+    setPreset,
+} from './worklet_system/worklet_methods/program_control.js'
+import { disableAndLockVibrato, setVibrato } from './worklet_system/worklet_methods/vibrato_control.js'
+import { SpessaSynthInfo } from '../utils/loggin.js'
+import { consoleColors } from '../utils/other.js'
+import { releaseVoice, renderVoice, voiceKilling } from './worklet_system/worklet_methods/voice_control.js'
+import {stbvorbis} from "../utils/stbvorbis_sync.js";
+
+
+export const VOICE_CAP = 450;
+
+export const DEFAULT_PERCUSSION = 9;
+export const DEFAULT_CHANNEL_COUNT = 16;
+export const DEFAULT_SYNTH_MODE = "gs";
+
+export const MIN_NOTE_LENGTH = 0.07; // if the note is released faster than that, it forced to last that long
+
+export const SYNTHESIZER_GAIN = 1.0;
+
+const BLOCK_SIZE = 128;
+
+class Synthesizer {
+    /**
+     * Creates a new synthesizer
+     * @param soundFontBuffer {Buffer|ArrayBufferLike} the soundfont file buffer.
+     * @param sampleRate {number} the sample rate, in hertz.
+     * @param blockSize {number} the block size in samples, represets the interval of updating the sequencer, modulation envelope, etc. Defaults to 128.
+     */
+    constructor(soundFontBuffer, sampleRate, blockSize = BLOCK_SIZE) {
+
+        this.currentTime = 0;
+        this.sampleRate = sampleRate;
+        this.blockSize = blockSize;
+
+        this._outputsAmount = DEFAULT_CHANNEL_COUNT;
+
+        /**
+         * @type {function}
+         */
+        this.processTickCallback = undefined;
+
+        this.transposition = 0;
+
+        /**
+         * The volume gain
+         * @type {number}
+         */
+        this.mainVolume = SYNTHESIZER_GAIN;
+
+        /**
+         * -1 to 1
+         * @type {number}
+         */
+        this.pan = 0.0;
+        /**
+         * the pan of the left channel
+         * @type {number}
+         */
+        this.panLeft = 0.5 * this.mainVolume;
+
+        this.highPerformanceMode = false;
+
+        /**
+         * If using sf3 soundfonts, wait for this promise
+         * @type {Promise<unknown>}
+         */
+        this.sf3supportReady = stbvorbis.isReady;
+
+        /**
+         * the pan of the right channel
+         * @type {number}
+         */
+        this.panRight = 0.5 * this.mainVolume;
+        /**
+         * @type {SoundFont2}
+         */
+        this.soundfont = new SoundFont2(soundFontBuffer);
+
+        this.defaultPreset = this.soundfont.getPreset(0, 0);
+        this.drumPreset = this.soundfont.getPreset(128, 0);
+
+        /**
+         * @type {Float32Array[]}
+         */
+        this.workletDumpedSamplesList = [];
+        /**
+         * contains all the channels with their voices on the processor size
+         * @type {WorkletProcessorChannel[]}
+         */
+        this.workletProcessorChannels = [];
+        for (let i = 0; i < this._outputsAmount; i++) {
+            this.addNewChannel(false);
+        }
+
+        this.workletProcessorChannels[DEFAULT_PERCUSSION].preset = this.drumPreset;
+        this.workletProcessorChannels[DEFAULT_PERCUSSION].drumChannel = true;
+
+        // in seconds, time between two samples (very, very short)
+        this.sampleTime = 1 / this.sampleRate;
+
+        /**
+         * Controls the system
+         * @typedef {"gm"|"gm2"|"gs"|"xg"} SynthSystem
+         * @type {SynthSystem}
+         */
+        this.system = DEFAULT_SYNTH_MODE;
+
+        this.totalVoicesAmount = 0;
+        SpessaSynthInfo(`%cSpessaSynth is ready!`,
+            consoleColors.info)
+    }
+
+    debugMessage()
+    {
+        SpessaSynthInfo({
+            channels: this.workletProcessorChannels,
+            voicesAmount: this.totalVoicesAmount,
+            outputAmount: this._outputsAmount,
+            dumpedSamples: this.workletDumpedSamplesList
+        });
+    }
+
+    /**
+     * @param channel {number}
+     * @param controllerNumber {number}
+     * @param isLocked {boolean}
+     */
+    lockController(channel, controllerNumber, isLocked)
+    {
+        this.workletProcessorChannels[channel].lockedControllers[controllerNumber] = isLocked;
+    }
+
+    /**
+     * Syntesizes the voice to output buffers.
+     * @param outputChannels {Float32Array[]} - the dry audio output data of 2 arrays. The first array is left the second is right.
+     * @param reverbOutputChannels {Float32Array[]} - the dry audio output data for the reverb of 2 arrays. The first array is left the second is right.
+     * @param chorusOutputChannels {Float32Array[]} - the dry audio output data for the chorus of 2 arrays. The first array is left the second is right.
+     */
+    render(outputChannels, reverbOutputChannels = undefined, chorusOutputChannels = undefined) {
+        // render in blocks until we reach the output
+        let samplesToRender = outputChannels[0].length;
+        let renderedSamples = 0;
+        while(samplesToRender > 0)
+        {
+            /**
+             * @type {Float32Array[]}
+             */
+            let block;
+            let reverbBlock;
+            let chorusBlock;
+            if(samplesToRender < this.blockSize)
+            {
+                block = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
+                reverbBlock = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
+                chorusBlock = [new Float32Array(samplesToRender), new Float32Array(samplesToRender)];
+            }
+            else
+            {
+                block = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
+                chorusBlock = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
+                reverbBlock = [new Float32Array(this.blockSize), new Float32Array(this.blockSize)];
+            }
+            samplesToRender -= this.blockSize;
+            // for every channel
+            let totalCurrentVoices = 0;
+            this.workletProcessorChannels.forEach(channel => {
+                if(channel.voices.length < 1 || channel.isMuted)
+                {
+                    // skip the channels
+                    return;
+                }
+                const tempV = channel.voices;
+
+                // reset voices
+                channel.voices = [];
+
+                // for every voice
+                tempV.forEach(v => {
+                    // render voice
+                    this.renderVoice(channel, v, block, reverbBlock, chorusBlock);
+                    if(!v.finished)
+                    {
+                        // if not finished, add it back
+                        channel.voices.push(v);
+                    }
+                });
+
+                totalCurrentVoices += tempV.length;
+            });
+
+            // if voice count changed, update voice amount
+            if(totalCurrentVoices !== this.totalVoicesAmount)
+            {
+                this.totalVoicesAmount = totalCurrentVoices;
+            }
+
+            // if sequencer connected, process
+            if(this.processTickCallback)
+            {
+                this.processTickCallback();
+            }
+            // append to blocks
+            outputChannels[0].set(block[0], renderedSamples);
+            outputChannels[1].set(block[1], renderedSamples);
+
+            if(reverbOutputChannels)
+            {
+                reverbOutputChannels[0].set(reverbBlock[0], renderedSamples);
+                reverbOutputChannels[1].set(reverbBlock[1], renderedSamples);
+            }
+
+            if(chorusOutputChannels)
+            {
+                chorusOutputChannels[1].set(chorusBlock[1], renderedSamples);
+                chorusOutputChannels[1].set(chorusBlock[1], renderedSamples);
+            }
+
+            renderedSamples += block[0].length;
+            this.currentTime += this.sampleTime * block[0].length;
+        }
+    }
+}
+
+// include other methods
+// voice related
+Synthesizer.prototype.renderVoice = renderVoice;
+Synthesizer.prototype.releaseVoice = releaseVoice;
+Synthesizer.prototype.voiceKilling = voiceKilling;
+
+// system exlcusive related
+Synthesizer.prototype.systemExclusive = systemExclusive;
+
+// note messages related
+Synthesizer.prototype.noteOn = noteOn;
+Synthesizer.prototype.noteOff = noteOff;
+Synthesizer.prototype.killNote = killNote;
+Synthesizer.prototype.stopAll = stopAll;
+Synthesizer.prototype.stopAllChannels = stopAllChannels;
+Synthesizer.prototype.muteChannel = muteChannel;
+
+// vustom vibrato related
+Synthesizer.prototype.setVibrato = setVibrato;
+Synthesizer.prototype.disableAndLockVibrato = disableAndLockVibrato;
+
+// data entry related
+Synthesizer.prototype.dataEntryCoarse = dataEntryCoarse;
+Synthesizer.prototype.dataEntryFine = dataEntryFine;
+
+// channel related
+Synthesizer.prototype.addNewChannel = addNewChannel;
+Synthesizer.prototype.controllerChange = controllerChange;
+Synthesizer.prototype.resetAllControllers = resetAllControllers;
+Synthesizer.prototype.resetControllers = resetControllers;
+Synthesizer.prototype.resetParameters = resetParameters;
+
+// master parameter related
+Synthesizer.prototype.setMainVolume = setMainVolume;
+Synthesizer.prototype.setMasterPan = setMasterPan;
+
+// tuning related
+Synthesizer.prototype.transposeAllChannels = transposeAllChannels;
+Synthesizer.prototype.transposeChannel = transposeChannel;
+Synthesizer.prototype.setChannelTuning = setChannelTuning;
+Synthesizer.prototype.setMasterTuning = setMasterTuning;
+Synthesizer.prototype.setModulationDepth = setModulationDepth;
+Synthesizer.prototype.pitchWheel = pitchWheel;
+
+// program related
+Synthesizer.prototype.programChange = programChange;
+Synthesizer.prototype.setPreset = setPreset;
+Synthesizer.prototype.setDrums = setDrums;
+Synthesizer.prototype.reloadSoundFont = reloadSoundFont;
+Synthesizer.prototype.sampleDump = sampleDump;
+
+
+export { Synthesizer }

package/spessasynth_core/synthetizer/worklet_system/README.md

@@ -0,0 +1,3 @@
+## This the worklet system synthesis folder.
+The code here is responsible for a single midi channel, synthesizing the sound to it.
+`worklet_utilities` contains the various digital signal processing functions such as the wavetable oscillator, low pass filter, etc.

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

@@ -0,0 +1,285 @@
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE } from '../../synthesizer.js'
+import {
+    customControllers,
+    customResetArray,
+    dataEntryStates,
+    resetArray,
+} 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 '../../synthesizer.js'
+
+/**
+ * @param channel {number}
+ * @param controllerNumber {number}
+ * @param controllerValue {number}
+ * @this {Synthesizer}
+ */
+export function controllerChange(channel, controllerNumber, controllerValue)
+{
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    const channelObject = this.workletProcessorChannels[channel];
+    switch (controllerNumber) {
+        case midiControllers.allNotesOff:
+            this.stopAll(channel);
+            break;
+
+        case midiControllers.allSoundOff:
+            this.stopAll(channel, true);
+            break;
+
+        case midiControllers.bankSelect:
+            let bankNr = controllerValue;
+            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 127, then it's drums
+                    if (bankNr === 127)
+                    {
+                        channelObject.drumChannel = true;
+                    }
+                    break;
+
+                case "gm2":
+                    if(bankNr === 120)
+                    {
+                        channelObject.drumChannel = 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.midiControllers[midiControllers.bankSelect] === 0)
+                {
+                    channelObject.midiControllers[midiControllers.bankSelect] = controllerValue;
+                }
+            }
+            else
+            if(this.system === "gm2")
+            {
+                channelObject.midiControllers[midiControllers.bankSelect] = controllerValue;
+            }
+            break;
+
+        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;
+
+        default:
+            if(channelObject.lockedControllers[controllerNumber])
+            {
+                return;
+            }
+            // special case: hold pedal
+            if(controllerNumber === midiControllers.sustainPedal) {
+                if (controllerValue >= 64)
+                {
+                    channelObject.holdPedal = true;
+                }
+                else
+                {
+                    channelObject.holdPedal = false;
+                    channelObject.sustainedVoices.forEach(v => {
+                        this.releaseVoice(v)
+                    });
+                    channelObject.sustainedVoices = [];
+                }
+            }
+            channelObject.midiControllers[controllerNumber] = controllerValue << 7;
+            channelObject.voices.forEach(v => computeModulators(v, channelObject.midiControllers));
+            break;
+    }
+}
+
+/**
+ * @this {Synthesizer}
+ */
+export function resetAllControllers()
+{
+    SpessaSynthInfo("%cResetting all controllers!", consoleColors.info);
+    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;
+            }
+            else
+            {
+                ch.drumChannel = false;
+                this.setPreset(channelNumber, this.defaultPreset);
+            }
+        }
+    }
+    this.system = DEFAULT_SYNTH_MODE;
+}
+
+/**
+ * Resets all controllers for channel
+ * @param channel {number}
+ * @this {Synthesizer}
+ */
+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.channelTranspose];
+    channelObject.customControllers.set(customResetArray);
+    channelObject.customControllers[customControllers.channelTranspose] = transpose;
+
+    this.resetParameters(channel);
+
+}
+
+/**
+ * @param channel {number}
+ * @this {Synthesizer}
+ */
+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;
+}
+
+/**
+ * @param volume {number} 0-1
+ * @this {Synthesizer}
+ */
+export function setMainVolume(volume)
+{
+    this.mainVolume = volume * SYNTHESIZER_GAIN;
+    this.setMasterPan(this.pan);
+}
+
+/**
+ * @param pan {number} -1 to 1
+ * @this {Synthesizer}
+ */
+
+export function setMasterPan(pan)
+{
+    this.pan = pan;
+    // clamp to 0-1 (0 is left)
+    pan = (pan / 2) + 0.5;
+    this.panLeft = (1 - pan) * this.mainVolume;
+    this.panRight = (pan) * this.mainVolume;
+}
+
+/**
+ * @param channel {number}
+ * @param isMuted {boolean}
+ * @this {Synthesizer}
+ */
+export function muteChannel(channel, isMuted)
+{
+    if(isMuted)
+    {
+        this.stopAll(channel, true);
+    }
+    this.workletProcessorChannels[channel].isMuted = isMuted;
+}