spessasynth_lib 0.0.1

package/package/synthetizer/worklet_system/main_processor.js

@@ -0,0 +1,363 @@
+import { DEFAULT_PERCUSSION, DEFAULT_SYNTH_MODE, VOICE_CAP } from '../synthetizer.js'
+import {
+    createWorkletChannel,
+} from './worklet_utilities/worklet_processor_channel.js'
+
+import { SoundFont2 } from '../../soundfont/soundfont.js'
+import { handleMessage } from './message_protocol/handle_message.js'
+import { systemExclusive } from './worklet_methods/system_exclusive.js'
+import { noteOn } from './worklet_methods/note_on.js'
+import { dataEntryCoarse, dataEntryFine } from './worklet_methods/data_entry.js'
+import { killNote, noteOff, stopAll, stopAllChannels } from './worklet_methods/note_off.js'
+import {
+    controllerChange, muteChannel, setMasterGain, setMasterPan, setMIDIVolume,
+} from './worklet_methods/controller_control.js'
+import { callEvent, post, sendChannelProperties } from './message_protocol/message_sending.js'
+import {
+    channelPressure,
+    pitchWheel, polyPressure,
+    setChannelTuning, setChannelTuningSemitones,
+    setMasterTuning, setModulationDepth,
+    transposeAllChannels,
+    transposeChannel,
+} from './worklet_methods/tuning_control.js'
+import {
+    programChange,
+    reloadSoundFont,
+    sampleDump,
+    sendPresetList,
+    setDrums,
+    setPreset,
+} from './worklet_methods/program_control.js'
+import { disableAndLockVibrato, setVibrato } from './worklet_methods/vibrato_control.js'
+import { WorkletSequencer } from '../../sequencer/worklet_sequencer/worklet_sequencer.js'
+import { SpessaSynthInfo } from '../../utils/loggin.js'
+import { applySynthesizerSnapshot, sendSynthesizerSnapshot } from './worklet_methods/snapshot.js'
+import { consoleColors } from '../../utils/other.js'
+import { PAN_SMOOTHING_FACTOR, releaseVoice, renderVoice, voiceKilling } from './worklet_methods/voice_control.js'
+import { returnMessageType } from './message_protocol/worklet_message.js'
+import { stbvorbis } from '../../externals/stbvorbis_sync/stbvorbis_sync.min.js'
+import { VOLUME_ENVELOPE_SMOOTHING_FACTOR } from './worklet_utilities/volume_envelope.js'
+import { resetAllControllers, resetControllers, resetParameters } from './worklet_methods/reset_controllers.js'
+
+
+/**
+ * worklet_processor.js
+ * purpose: manages the synthesizer (and worklet sequencer) from the AudioWorkletGlobalScope and renders the audio data
+ */
+
+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;
+
+class SpessaSynthProcessor extends AudioWorkletProcessor {
+    /**
+     * Creates a new worklet synthesis system. contains all channels
+     * @param options {{
+     * processorOptions: {
+     *      midiChannels: number,
+     *      soundfont: ArrayBuffer,
+     *      enableEventSystem: boolean,
+     *      startRenderingData: {
+     *          parsedMIDI: MIDI,
+     *          snapshot: SynthesizerSnapshot,
+     *          oneOutput: boolean
+     *      }
+     * }}}
+     */
+    constructor(options) {
+        super();
+        this.oneOutputMode = options.processorOptions?.startRenderingData?.oneOutput === true;
+        this._outputsAmount = this.oneOutputMode ? 1 : options.processorOptions.midiChannels;
+
+        this.enableEventSystem = options.processorOptions.enableEventSystem;
+
+        /**
+         * @type {function}
+         */
+        this.processTickCallback = undefined;
+
+        this.sequencer = new WorkletSequencer(this);
+
+        this.transposition = 0;
+
+        /**
+         * The volume gain, set by user
+         * @type {number}
+         */
+        this.masterGain = SYNTHESIZER_GAIN;
+
+        this.midiVolume = 1;
+
+        /**
+         * Maximum number of voices allowed at once
+         * @type {number}
+         */
+        this.voiceCap = VOICE_CAP;
+
+        /**
+         * -1 to 1
+         * @type {number}
+         */
+        this.pan = 0.0;
+        /**
+         * the pan of the left channel
+         * @type {number}
+         */
+        this.panLeft = 0.5 * this.currentGain;
+
+        this.highPerformanceMode = false;
+
+        /**
+         * the pan of the right channel
+         * @type {number}
+         */
+        this.panRight = 0.5 * this.currentGain;
+        try
+        {
+            /**
+             * @type {SoundFont2}
+             */
+            this.soundfont = new SoundFont2(options.processorOptions.soundfont);
+        }
+        catch (e)
+        {
+            this.post({
+                messageType: returnMessageType.soundfontError,
+                messageData: e
+            });
+            throw e;
+        }
+        this.sendPresetList();
+
+        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 < options.processorOptions.midiChannels; i++)
+        {
+            this.createWorkletChannel(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 / sampleRate;
+
+        // these smoothing factors were tested on 44100Hz, adjust them here
+        this.volumeEnvelopeSmoothingFactor = VOLUME_ENVELOPE_SMOOTHING_FACTOR * (sampleRate / 44100);
+        this.panSmoothingFactor = PAN_SMOOTHING_FACTOR * (sampleRate / 44100);
+
+        /**
+         * Controls the system
+         * @typedef {"gm"|"gm2"|"gs"|"xg"} SynthSystem
+         */
+        /*
+         * @type {SynthSystem}
+         */
+        this.system = DEFAULT_SYNTH_MODE;
+
+        this.totalVoicesAmount = 0;
+
+        this.port.onmessage = e => this.handleMessage(e.data);
+
+        // if sent, start rendering
+        if(options.processorOptions.startRenderingData)
+        {
+            if (options.processorOptions.startRenderingData.snapshot)
+            {
+                this.applySynthesizerSnapshot(options.processorOptions.startRenderingData.snapshot);
+                this.resetAllControllers();
+            }
+
+            SpessaSynthInfo("%cRendering enabled! Starting render.", consoleColors.info)
+            if (options.processorOptions.startRenderingData.parsedMIDI)
+            {
+                this.sequencer.loadNewSongList([options.processorOptions.startRenderingData.parsedMIDI]);
+                this.sequencer.loop = false;
+            }
+        }
+
+        stbvorbis.isInitialized.then(() => {
+            this.post({
+                messageType: returnMessageType.ready,
+                messageData: undefined
+            });
+            SpessaSynthInfo("%cSpessaSynth is ready!", consoleColors.recognized);
+        });
+    }
+
+    /**
+     * @returns {number}
+     */
+    get currentGain()
+    {
+        return this.masterGain * this.midiVolume;
+    }
+
+    debugMessage()
+    {
+        SpessaSynthInfo({
+            channels: this.workletProcessorChannels,
+            voicesAmount: this.totalVoicesAmount,
+            outputAmount: this._outputsAmount,
+            dumpedSamples: this.workletDumpedSamplesList
+        });
+    }
+
+    /**
+     * Syntesizes the voice to buffers
+     * @param inputs {Float32Array[][]} required by WebAudioAPI
+     * @param outputs {Float32Array[][]} the outputs to write to, only the first 2 channels are populated
+     * @returns {boolean} true
+     */
+    process(inputs, outputs) {
+        if(this.processTickCallback)
+        {
+            this.processTickCallback();
+        }
+
+        // for every channel
+        let totalCurrentVoices = 0;
+        this.workletProcessorChannels.forEach((channel, index) => {
+            if(channel.voices.length < 1 || channel.isMuted)
+            {
+                // skip the channels
+                return;
+            }
+            let outputIndex;
+            let outputLeft;
+            let outputRight;
+            let reverbChannels;
+            let chorusChannels;
+            if(this.oneOutputMode)
+            {
+                // first output only
+                const output = outputs[0];
+                // reverb and chorus are disabled. 32 output channels: two for each midi channels
+                outputIndex = (index % 16) * 2;
+                outputLeft = output[outputIndex];
+                outputRight = output[outputIndex + 1];
+            }
+            else
+            {
+                // 2 first outputs are reverb and chorus, other are for channels
+                outputIndex = (index % this._outputsAmount) + 2;
+                outputLeft = outputs[outputIndex][0];
+                outputRight = outputs[outputIndex][1];
+                reverbChannels = outputs[0];
+                chorusChannels = outputs[1];
+            }
+
+            const tempV = channel.voices;
+
+            // reset voices
+            channel.voices = [];
+
+            // for every voice
+            tempV.forEach(v => {
+                // render voice
+                this.renderVoice(
+                    channel,
+                    v,
+                    outputLeft, outputRight,
+                    reverbChannels,
+                    chorusChannels
+                );
+                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;
+            this.sendChannelProperties();
+        }
+        return true;
+    }
+}
+
+// include other methods
+// voice related
+SpessaSynthProcessor.prototype.renderVoice = renderVoice;
+SpessaSynthProcessor.prototype.releaseVoice = releaseVoice;
+SpessaSynthProcessor.prototype.voiceKilling = voiceKilling;
+
+// message port related
+SpessaSynthProcessor.prototype.handleMessage = handleMessage;
+SpessaSynthProcessor.prototype.post = post;
+SpessaSynthProcessor.prototype.sendChannelProperties = sendChannelProperties;
+SpessaSynthProcessor.prototype.callEvent = callEvent;
+
+// system exlcusive related
+SpessaSynthProcessor.prototype.systemExclusive = systemExclusive;
+
+// note messages related
+SpessaSynthProcessor.prototype.noteOn = noteOn;
+SpessaSynthProcessor.prototype.noteOff = noteOff;
+SpessaSynthProcessor.prototype.polyPressure = polyPressure;
+SpessaSynthProcessor.prototype.killNote = killNote;
+SpessaSynthProcessor.prototype.stopAll = stopAll;
+SpessaSynthProcessor.prototype.stopAllChannels = stopAllChannels;
+SpessaSynthProcessor.prototype.muteChannel = muteChannel;
+
+// custom vibrato related
+SpessaSynthProcessor.prototype.setVibrato = setVibrato;
+SpessaSynthProcessor.prototype.disableAndLockVibrato = disableAndLockVibrato;
+
+// data entry related
+SpessaSynthProcessor.prototype.dataEntryCoarse = dataEntryCoarse;
+SpessaSynthProcessor.prototype.dataEntryFine = dataEntryFine;
+
+// channel related
+SpessaSynthProcessor.prototype.createWorkletChannel = createWorkletChannel;
+SpessaSynthProcessor.prototype.controllerChange = controllerChange;
+SpessaSynthProcessor.prototype.channelPressure = channelPressure;
+SpessaSynthProcessor.prototype.resetAllControllers = resetAllControllers;
+SpessaSynthProcessor.prototype.resetControllers = resetControllers;
+SpessaSynthProcessor.prototype.resetParameters = resetParameters;
+
+// master parameter related
+SpessaSynthProcessor.prototype.setMasterGain = setMasterGain;
+SpessaSynthProcessor.prototype.setMasterPan = setMasterPan;
+SpessaSynthProcessor.prototype.setMIDIVolume = setMIDIVolume;
+
+// tuning related
+SpessaSynthProcessor.prototype.transposeAllChannels = transposeAllChannels;
+SpessaSynthProcessor.prototype.transposeChannel = transposeChannel;
+SpessaSynthProcessor.prototype.setChannelTuning = setChannelTuning;
+SpessaSynthProcessor.prototype.setChannelTuningSemitones = setChannelTuningSemitones;
+SpessaSynthProcessor.prototype.setMasterTuning = setMasterTuning;
+SpessaSynthProcessor.prototype.setModulationDepth = setModulationDepth;
+SpessaSynthProcessor.prototype.pitchWheel = pitchWheel;
+
+// program related
+SpessaSynthProcessor.prototype.programChange = programChange;
+SpessaSynthProcessor.prototype.setPreset = setPreset;
+SpessaSynthProcessor.prototype.setDrums = setDrums;
+SpessaSynthProcessor.prototype.reloadSoundFont = reloadSoundFont;
+SpessaSynthProcessor.prototype.sampleDump = sampleDump;
+SpessaSynthProcessor.prototype.sendPresetList = sendPresetList;
+
+// snapshot related
+SpessaSynthProcessor.prototype.sendSynthesizerSnapshot = sendSynthesizerSnapshot;
+SpessaSynthProcessor.prototype.applySynthesizerSnapshot = applySynthesizerSnapshot;
+
+
+export { SpessaSynthProcessor }

package/package/synthetizer/worklet_system/message_protocol/handle_message.js

@@ -0,0 +1,197 @@
+import { ALL_CHANNELS_OR_DIFFERENT_ACTION, masterParameterType, workletMessageType } from './worklet_message.js'
+import { SpessaSynthLogging, SpessaSynthWarn } from '../../../utils/loggin.js'
+
+/**
+ * @this {SpessaSynthProcessor}
+ * @param message
+ */
+export function handleMessage(message)
+{
+    const data = message.messageData;
+    const channel = message.channelNumber;
+    /**
+     * @type {WorkletProcessorChannel}
+     */
+    let channelObject = {};
+    if(channel >= 0)
+    {
+        channelObject = this.workletProcessorChannels[channel];
+    }
+    switch (message.messageType) {
+        case workletMessageType.noteOn:
+            this.noteOn(channel, data[0], data[1], data[2]);
+            break;
+
+        case workletMessageType.noteOff:
+            this.noteOff(channel, data);
+            break;
+
+        case workletMessageType.pitchWheel:
+            this.pitchWheel(channel, data[0], data[1]);
+            break;
+
+        case workletMessageType.ccChange:
+            this.controllerChange(channel, data[0], data[1], data[2]);
+            break;
+
+        case workletMessageType.customcCcChange:
+            // custom controller change
+            channelObject.customControllers[data[0]] = data[1];
+            break;
+
+        case workletMessageType.killNote:
+            this.killNote(channel, data);
+            break;
+
+        case workletMessageType.programChange:
+            this.programChange(channel, data[0], data[1]);
+            break;
+
+        case workletMessageType.channelPressure:
+            this.channelPressure(channel, data);
+            break;
+
+        case workletMessageType.polyPressure:
+            this.polyPressure(channel, data[0], data[1]);
+            break;
+
+        case workletMessageType.ccReset:
+            if(channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                this.resetAllControllers();
+            }
+            else
+            {
+                this.resetControllers(channel);
+            }
+            break;
+
+        case workletMessageType.systemExclusive:
+            this.systemExclusive(data);
+            break;
+
+        case workletMessageType.setChannelVibrato:
+            if(channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                for (let i = 0; i < this.workletProcessorChannels.length; i++)
+                {
+                    if(data.rate === -1)
+                    {
+                        this.disableAndLockVibrato(i);
+                    }
+                    else
+                    {
+                        this.setVibrato(i, data.depth, data.rate, data.delay);
+                    }
+                }
+            }
+            if(data.rate === -1)
+            {
+                this.disableAndLockVibrato(channel);
+            }
+            else
+            {
+                this.setVibrato(channel, data.depth, data.rate, data.delay);
+            }
+            break;
+
+        case workletMessageType.reloadSoundFont:
+            this.reloadSoundFont(data);
+            break;
+
+        case workletMessageType.stopAll:
+            if(channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                this.stopAllChannels(data === 1);
+            }
+            else
+            {
+                this.stopAll(channel, data === 1);
+            }
+            break;
+
+        case workletMessageType.killNotes:
+            this.voiceKilling(data);
+            break;
+
+        case workletMessageType.muteChannel:
+            this.muteChannel(channel, data);
+            break;
+
+        case workletMessageType.addNewChannel:
+            this.createWorkletChannel(true);
+            break;
+
+        case workletMessageType.debugMessage:
+            this.debugMessage();
+            break;
+
+        case workletMessageType.setMasterParameter:
+            /**
+             * @type {masterParameterType}
+             */
+            const type = data[0];
+            const value = data[1];
+            switch (type)
+            {
+                case masterParameterType.masterPan:
+                    this.setMasterPan(value);
+                    break;
+
+                case masterParameterType.mainVolume:
+                    this.setMasterGain(value);
+                    break;
+
+                case masterParameterType.voicesCap:
+                    this.voiceCap = value;
+                    break;
+            }
+            break;
+
+        case workletMessageType.setDrums:
+            this.setDrums(channel, data);
+            break;
+
+        case workletMessageType.transpose:
+            if(channel === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                this.transposeAllChannels(data[0], data[1]);
+            }
+            else
+            {
+                this.transposeChannel(channel, data[0], data[1]);
+            }
+            break;
+
+        case workletMessageType.highPerformanceMode:
+            this.highPerformanceMode = data;
+            break;
+
+        case workletMessageType.lockController:
+            if(data[0] === ALL_CHANNELS_OR_DIFFERENT_ACTION)
+            {
+                channelObject.lockPreset = data[1];
+            }
+            else
+            {
+                channelObject.lockedControllers[data[0]] = data[1];
+            }
+            break;
+
+        case workletMessageType.sequencerSpecific:
+            this.sequencer.processMessage(data.messageType, data.messageData);
+            break;
+
+        case workletMessageType.requestSynthesizerSnapshot:
+            this.sendSynthesizerSnapshot();
+            break;
+
+        case workletMessageType.setLogLevel:
+            SpessaSynthLogging(data[0], data[1], data[2], data[3]);
+            break;
+
+        default:
+            SpessaSynthWarn("Unrecognized event:", data);
+            break;
+    }
+}

package/package/synthetizer/worklet_system/message_protocol/message_sending.js

@@ -0,0 +1,74 @@
+import { returnMessageType } from './worklet_message.js'
+import { NON_CC_INDEX_OFFSET } from '../worklet_utilities/worklet_processor_channel.js'
+import { modulatorSources } from '../../../soundfont/read/modulators.js'
+
+/**
+ * Calls synth event from the worklet side
+ * @param eventName {EventTypes} the event name
+ * @param eventData {any}
+ * @this {SpessaSynthProcessor}
+ */
+export function callEvent(eventName, eventData)
+{
+    if(!this.enableEventSystem)
+    {
+        return;
+    }
+    this.post({
+        messageType: returnMessageType.eventCall,
+        messageData: {
+            eventName: eventName,
+            eventData: eventData
+        }
+    })
+}
+
+/**
+ * @param data {WorkletReturnMessage}
+ * @this {SpessaSynthProcessor}
+ */
+export function post(data)
+{
+    if(!this.enableEventSystem)
+    {
+        return;
+    }
+    this.port.postMessage(data);
+}
+
+/**
+ * @typedef {Object} ChannelProperty
+ * @property {number} voicesAmount
+ * @property {number} pitchBend - from -8192 do 8192
+ * @property {number} pitchBendRangeSemitones - in semitones
+ * @property {boolean} isMuted
+ * @property {boolean} isDrum
+ */
+
+/**
+ * @this {SpessaSynthProcessor}
+ */
+export function sendChannelProperties()
+{
+    if(!this.enableEventSystem)
+    {
+        return;
+    }
+    /**
+     * @type {ChannelProperty[]}
+     */
+    const data = this.workletProcessorChannels.map(c => {
+        const range = (c.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] >> 7) + (c.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] & 0x7F) / 127;
+        return {
+            voicesAmount: c.voices.length,
+            pitchBend: c.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel],
+            pitchBendRangeSemitones: range,
+            isMuted: c.isMuted,
+            isDrum: c.drumChannel
+        }
+    });
+    this.post({
+        messageType: returnMessageType.channelProperties,
+        messageData: data
+    });
+}