spessasynth_core 1.0.0

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

@@ -0,0 +1,265 @@
+import { arrayToHexString, consoleColors } from '../../../utils/other.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.js'
+/**
+ * Executes a system exclusive
+ * @param messageData {number[]} - the message data without f0
+ * @this {Synthesizer}
+ */
+
+export function systemExclusive(messageData)
+{
+    const type = messageData[0];
+    switch (type)
+    {
+        default:
+            SpessaSynthWarn(`%cUnrecognized SysEx: %c${arrayToHexString(messageData)}`,
+                consoleColors.warn,
+                consoleColors.unrecognized);
+            break;
+
+        // non realtime
+        case 0x7E:
+            // gm system
+            if(messageData[2] === 0x09)
+            {
+                if(messageData[3] === 0x01)
+                {
+                    SpessaSynthInfo("%cGM system on", consoleColors.info);
+                    this.system = "gm";
+                }
+                else if(messageData[3] === 0x03)
+                {
+                    SpessaSynthInfo("%cGM2 system on", consoleColors.info);
+                    this.system = "gm2";
+                }
+                else
+                {
+                    SpessaSynthInfo("%cGM system off, defaulting to GS", consoleColors.info);
+                    this.system = "gs";
+                }
+            }
+            break;
+
+        // realtime
+        case 0x7F:
+            if(messageData[2] === 0x04 && messageData[3] === 0x01)
+            {
+                // main volume
+                const vol = messageData[5] << 7 | messageData[4];
+                this.setMainVolume(vol / 16384);
+                SpessaSynthInfo(`%cMaster Volume. Volume: %c${vol}`,
+                    consoleColors.info,
+                    consoleColors.value);
+            }
+            else
+            if(messageData[2] === 0x04 && messageData[3] === 0x03)
+            {
+                // fine tuning
+                const tuningValue = ((messageData[5] << 7) | messageData[6]) - 8192;
+                const cents = Math.floor(tuningValue / 81.92); // [-100;+99] cents range
+                this.setMasterTuning(cents);
+                SpessaSynthInfo(`%cMaster Fine Tuning. Cents: %c${cents}`,
+                    consoleColors.info,
+                    consoleColors.value)
+            }
+            else
+            if(messageData[2] === 0x04 && messageData[3] === 0x04)
+            {
+                // coarse tuning
+                // lsb is ignored
+                const semitones = messageData[5] - 64;
+                const cents = semitones * 100;
+                this.setMasterTuning(cents);
+                SpessaSynthInfo(`%cMaster Coarse Tuning. Cents: %c${cents}`,
+                    consoleColors.info,
+                    consoleColors.value)
+            }
+            else
+            {
+                SpessaSynthWarn(
+                    `%cUnrecognized MIDI Real-time message: %c${arrayToHexString(messageData)}`,
+                    consoleColors.warn,
+                    consoleColors.unrecognized)
+            }
+            break;
+
+        // this is a roland sysex
+        // http://www.bandtrax.com.au/sysex.htm
+        // https://cdn.roland.com/assets/media/pdf/AT-20R_30R_MI.pdf
+        case 0x41:
+            // messagedata[1] is device id (ignore as we're everything >:) )
+            if(messageData[2] === 0x42 && messageData[3] === 0x12)
+            {
+                // this is a GS sysex
+                // messageData[5] and [6] is the system parameter, messageData[7] is the value
+                const messageValue = messageData[7];
+                if(messageData[6] === 0x7F)
+                {
+                    // GS mode set
+                    if(messageValue === 0x00) {
+                        // this is a GS reset
+                        SpessaSynthInfo("%cGS system on", consoleColors.info);
+                        this.system = "gs";
+                    }
+                    else if(messageValue === 0x7F)
+                    {
+                        // GS mode off
+                        SpessaSynthInfo("%cGS system off, switching to GM2", consoleColors.info);
+                        this.system = "gm2";
+                    }
+                    return;
+                }
+                else
+                if(messageData[4] === 0x40)
+                {
+                    // this is a system parameter
+                    if((messageData[5] & 0x10) > 0)
+                    {
+                        // this is an individual part (channel) parameter
+                        // determine the channel 0 means channel 10 (default), 1 means 1 etc.
+                        const channel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][messageData[5] & 0x0F]; // for example 1A means A = 11, which corresponds to channel 12 (counting from 1)
+                        switch (messageData[6])
+                        {
+                            default:
+                                break;
+
+                            case 0x15:
+                                // this is the Use for Drum Part sysex (multiple drums)
+                                this.setDrums(channel, messageValue > 0 && messageData[5] >> 4); // if set to other than 0, is a drum channel
+                                SpessaSynthInfo(
+                                    `%cChannel %c${channel}%c ${messageValue > 0 && messageData[5] >> 4 ?
+                                        "is now a drum channel"
+                                        :
+                                        "now isn't a drum channel"
+                                    }%c via: %c${arrayToHexString(messageData)}`,
+                                    consoleColors.info,
+                                    consoleColors.value,
+                                    consoleColors.recognized,
+                                    consoleColors.info,
+                                    consoleColors.value);
+                                return;
+
+                            case 0x16:
+                                // this is the pitch key shift sysex
+                                const keyShift = messageValue - 64;
+                                this.transposeChannel(channel, keyShift);
+                                SpessaSynthInfo(`%cChannel %c${channel}%c pitch shift. Semitones %c${keyShift}%c, with %c${arrayToHexString(messageData)}`,
+                                    consoleColors.info,
+                                    consoleColors.recognized,
+                                    consoleColors.info,
+                                    consoleColors.value,
+                                    consoleColors.info,
+                                    consoleColors.value);
+                                return;
+
+                            case 0x40:
+                            case 0x41:
+                            case 0x42:
+                            case 0x43:
+                            case 0x44:
+                            case 0x45:
+                            case 0x46:
+                            case 0x47:
+                            case 0x48:
+                            case 0x49:
+                            case 0x4A:
+                            case 0x4B:
+                                // scale tuning
+                                const cents = messageValue - 64;
+                                SpessaSynthInfo(`%cChannel %c${channel}%c tuning. Cents %c${cents}%c, with %c${arrayToHexString(messageData)}`,
+                                    consoleColors.info,
+                                    consoleColors.recognized,
+                                    consoleColors.info,
+                                    consoleColors.value,
+                                    consoleColors.info,
+                                    consoleColors.value);
+                                this.setChannelTuning(channel, cents);
+                        }
+                    }
+                    else
+                        // this is a global system parameter
+                    if(messageData[5] === 0x00 && messageData[6] === 0x06)
+                    {
+                        // roland master pan
+                        SpessaSynthInfo(`%cRoland GS Master Pan set to: %c${messageValue}%c with: %c${arrayToHexString(messageData)}`,
+                            consoleColors.info,
+                            consoleColors.value,
+                            consoleColors.info,
+                            consoleColors.value);
+                        this.setMasterPan((messageValue - 64) / 64);
+                        return;
+                    }
+                    else
+                    if(messageData[5] === 0x00 && messageData[6] === 0x05)
+                    {
+                        // roland master key shift (transpose)
+                        const transpose = messageValue - 64;
+                        SpessaSynthInfo(`%cRoland GS Master Key-Shift set to: %c${transpose}%c with: %c${arrayToHexString(messageData)}`,
+                            consoleColors.info,
+                            consoleColors.value,
+                            consoleColors.info,
+                            consoleColors.value);
+                        this.setMasterTuning(transpose * 100);
+                        return;
+                    }
+                    else
+                    if(messageData[5] === 0x00 && messageData[6] === 0x04)
+                    {
+                        // roland GS master volume
+                        SpessaSynthInfo(`%cRoland GS Master Volume set to: %c${messageValue}%c with: %c${arrayToHexString(messageData)}`,
+                            consoleColors.info,
+                            consoleColors.value,
+                            consoleColors.info,
+                            consoleColors.value);
+                        this.setMainVolume(messageValue / 127);
+                        return;
+                    }
+                }
+                // this is some other GS sysex...
+                SpessaSynthWarn(`%cUnrecognized Roland %cGS %cSysEx: %c${arrayToHexString(messageData)}`,
+                    consoleColors.warn,
+                    consoleColors.recognized,
+                    consoleColors.warn,
+                    consoleColors.unrecognized);
+                return;
+            }
+            else
+            if(messageData[2] === 0x16 && messageData[3] === 0x12 && messageData[4] === 0x10)
+            {
+                // this is a roland master volume message
+                this.setMainVolume(messageData[7] / 100);
+                SpessaSynthInfo(`%cRoland Master Volume control set to: %c${messageData[7]}%c via: %c${arrayToHexString(messageData)}`,
+                    consoleColors.info,
+                    consoleColors.value,
+                    consoleColors.info,
+                    consoleColors.value);
+                return;
+            }
+            else
+            {
+                // this is something else...
+                SpessaSynthWarn(`%cUnrecognized Roland SysEx: %c${arrayToHexString(messageData)}`,
+                    consoleColors.warn,
+                    consoleColors.unrecognized);
+                return;
+            }
+
+        // yamaha
+        case 0x43:
+            // XG on
+            if(messageData[2] === 0x4C && messageData[5] === 0x7E && messageData[6] === 0x00)
+            {
+                SpessaSynthInfo("%cXG system on", consoleColors.info);
+                this.system = "xg";
+            }
+            else
+            {
+                SpessaSynthWarn(`%cUnrecognized Yamaha SysEx: %c${arrayToHexString(messageData)}`,
+                    consoleColors.warn,
+                    consoleColors.unrecognized);
+            }
+            break;
+
+
+    }
+}

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

@@ -0,0 +1,105 @@
+import { customControllers, NON_CC_INDEX_OFFSET } from '../worklet_utilities/worklet_processor_channel.js'
+import { consoleColors } from '../../../utils/other.js'
+import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
+import { computeModulators } from '../worklet_utilities/worklet_modulator.js'
+import { SpessaSynthInfo } from '../../../utils/loggin.js'
+
+/**
+ * Transposes all channels by given amount of semitones
+ * @this {Synthesizer}
+ * @param semitones {number} Can be float
+ * @param force {boolean} defaults to false, if true transposes the channel even if it's a drum channel
+ */
+export function transposeAllChannels(semitones, force = false)
+{
+    this.transposition = 0;
+    for (let i = 0; i < this.workletProcessorChannels.length; i++) {
+        this.transposeChannel(i, semitones, force);
+    }
+    this.transposition = semitones;
+}
+
+/**
+ * Transposes the channel by given amount of semitones
+ * @this {Synthesizer}
+ * @param channel {number}
+ * @param semitones {number} Can be float
+ * @param force {boolean} defaults to false, if true transposes the channel even if it's a drum channel
+ */
+export function transposeChannel(channel, semitones, force=false)
+{
+    semitones += this.transposition;
+    const channelObject = this.workletProcessorChannels[channel];
+    if(channelObject.drumChannel && !force)
+    {
+        return;
+    }
+    channelObject.customControllers[customControllers.channelTranspose] = semitones * 100;
+}
+
+/**
+ * Sets the channel's tuning
+ * @this {Synthesizer}
+ * @param channel {number}
+ * @param cents {number}
+ */
+export function setChannelTuning(channel, cents)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    cents = Math.round(cents);
+    channelObject.customControllers[customControllers.channelTuning] = cents;
+    SpessaSynthInfo(`%cChannel ${channel} tuning. Cents: %c${cents}`,
+        consoleColors.info,
+        consoleColors.value);
+}
+
+/**
+ * Sets the worklet's master tuning
+ * @this {Synthesizer}
+ * @param cents {number}
+ */
+export function setMasterTuning(cents)
+{
+    cents = Math.round(cents);
+    for (let i = 0; i < this.workletProcessorChannels.length; i++) {
+        this.workletProcessorChannels[i].customControllers[customControllers.masterTuning] = cents;
+    }
+}
+
+/**
+ * @this {Synthesizer}
+ * @param channel {number}
+ * @param cents {number}
+ */
+export function setModulationDepth(channel, cents)
+{
+    let channelObject = this.workletProcessorChannels[channel];
+    cents = Math.round(cents);
+    SpessaSynthInfo(`%cChannel ${channel} modulation depth. Cents: %c${cents}`,
+        consoleColors.info,
+        consoleColors.value);
+    /* ==============
+        IMPORTANT
+        here we convert cents into a multiplier.
+        midi spec assumes the default is 50 cents,
+        but it might be different for the soundfont,
+        so we create a multiplier by divinging cents by 50.
+        for example, if we want 100 cents, then multiplier will be 2,
+        which for a preset with depth of 50 will create 100.
+     ================*/
+    channelObject.customControllers[customControllers.modulationMultiplier] = cents / 50;
+}
+
+/**
+ * Sets the pitch of the given channel
+ * @this {Synthesizer}
+ * @param channel {number} usually 0-15: the channel to change pitch
+ * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+ * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+ */
+export function pitchWheel(channel, MSB, LSB)
+{
+    const bend = (LSB | (MSB << 7));
+    this.workletProcessorChannels[channel].midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = bend;
+    this.workletProcessorChannels[channel].voices.forEach(v => computeModulators(v, this.workletProcessorChannels[channel].midiControllers));
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @param channel {number}
+ * @this {Synthesizer}
+ */
+export function disableAndLockVibrato(channel)
+{
+    this.workletProcessorChannels[channel].lockVibrato = true;
+    this.workletProcessorChannels[channel].channelVibrato.rate = 0;
+    this.workletProcessorChannels[channel].channelVibrato.delay = 0;
+    this.workletProcessorChannels[channel].channelVibrato.depth = 0;
+}
+
+/**
+ * @param channel {number}
+ * @param depth {number}
+ * @param rate {number}
+ * @param delay {number}
+ * @this {Synthesizer}
+ */
+export function setVibrato(channel, depth, rate, delay)
+{
+    if(this.workletProcessorChannels[channel].lockVibrato)
+    {
+        return;
+    }
+    this.workletProcessorChannels[channel].vibrato.rate = rate;
+    this.workletProcessorChannels[channel].vibrato.delay = delay;
+    this.workletProcessorChannels[channel].vibrato.depth = depth;
+}

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

@@ -0,0 +1,186 @@
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+import { absCentsToHz, timecentsToSeconds } from '../worklet_utilities/unit_converter.js'
+import { getLFOValue } from '../worklet_utilities/lfo.js'
+import { customControllers } from '../worklet_utilities/worklet_processor_channel.js'
+import { getModEnvValue } from '../worklet_utilities/modulation_envelope.js'
+import { getOscillatorData } from '../worklet_utilities/wavetable_oscillator.js'
+import { panVoice } from '../worklet_utilities/stereo_panner.js'
+import { applyVolumeEnvelope } from '../worklet_utilities/volume_envelope.js'
+import { applyLowpassFilter } from '../worklet_utilities/lowpass_filter.js'
+import { MIN_NOTE_LENGTH } from '../../synthesizer.js'
+
+/**
+ * Renders a voice to the stereo output buffer
+ * @param channel {WorkletProcessorChannel} the voice's channel
+ * @param voice {WorkletVoice} the voice to render
+ * @param output {Float32Array[]} the output buffer
+ * @param reverbOutput {Float32Array[]} output for reverb
+ * @param chorusOutput {Float32Array[]} output for chorus
+ * @this {Synthesizer}
+ */
+export function renderVoice(channel, voice, output, reverbOutput, chorusOutput)
+{
+    // if no matching sample, perhaps it's still being loaded...?
+    if(this.workletDumpedSamplesList[voice.sample.sampleID] === undefined)
+    {
+        return;
+    }
+
+    // check if release
+    if(!voice.isInRelease) {
+        // if not in release, check if the release time is
+        if (this.currentTime >= voice.releaseStartTime) {
+            voice.releaseStartModEnv = voice.currentModEnvValue;
+            voice.isInRelease = true;
+        }
+    }
+
+
+    // if the initial attenuation is more than 100dB, skip the voice (it's silent anyway)
+    if(voice.modulatedGenerators[generatorTypes.initialAttenuation] > 2500)
+    {
+        if(voice.isInRelease)
+        {
+            voice.finished = true;
+        }
+        return;
+    }
+
+    // TUNING
+
+    // calculate tuning
+    let cents = voice.modulatedGenerators[generatorTypes.fineTune]
+        + channel.customControllers[customControllers.channelTuning]
+        + channel.customControllers[customControllers.channelTranspose]
+        + channel.customControllers[customControllers.masterTuning];
+    let semitones = voice.modulatedGenerators[generatorTypes.coarseTune];
+
+    // calculate tuning by key
+    cents += (voice.targetKey - voice.sample.rootKey) * voice.modulatedGenerators[generatorTypes.scaleTuning];
+
+    // vibrato LFO
+    const vibratoDepth = voice.modulatedGenerators[generatorTypes.vibLfoToPitch];
+    if(vibratoDepth > 0)
+    {
+        const vibStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayVibLFO]);
+        const vibFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqVibLFO]);
+        const lfoVal = getLFOValue(vibStart, vibFreqHz, this.currentTime);
+        if(lfoVal)
+        {
+            cents += lfoVal * (vibratoDepth * channel.customControllers[customControllers.modulationMultiplier]);
+        }
+    }
+
+    // lowpass frequency
+    let lowpassCents = voice.modulatedGenerators[generatorTypes.initialFilterFc];
+
+    // mod LFO
+    const modPitchDepth = voice.modulatedGenerators[generatorTypes.modLfoToPitch];
+    const modVolDepth = voice.modulatedGenerators[generatorTypes.modLfoToVolume];
+    const modFilterDepth = voice.modulatedGenerators[generatorTypes.modLfoToFilterFc];
+    let modLfoCentibels = 0;
+    if(modPitchDepth + modFilterDepth + modVolDepth > 0)
+    {
+        const modStart = voice.startTime + timecentsToSeconds(voice.modulatedGenerators[generatorTypes.delayModLFO]);
+        const modFreqHz = absCentsToHz(voice.modulatedGenerators[generatorTypes.freqModLFO]);
+        const modLfoValue = getLFOValue(modStart, modFreqHz, this.currentTime);
+        cents += modLfoValue * (modPitchDepth * channel.customControllers[customControllers.modulationMultiplier]);
+        modLfoCentibels = modLfoValue * modVolDepth;
+        lowpassCents += modLfoValue * modFilterDepth;
+    }
+
+    // channel vibrato (GS NRPN)
+    if(channel.channelVibrato.depth > 0)
+    {
+        const channelVibrato = getLFOValue(voice.startTime + channel.channelVibrato.delay, channel.channelVibrato.rate, this.currentTime);
+        if(channelVibrato)
+        {
+            cents += channelVibrato * channel.channelVibrato.depth;
+        }
+    }
+
+    // mod env
+    const modEnvPitchDepth = voice.modulatedGenerators[generatorTypes.modEnvToPitch];
+    const modEnvFilterDepth = voice.modulatedGenerators[generatorTypes.modEnvToFilterFc];
+    const modEnv = getModEnvValue(voice, this.currentTime);
+    lowpassCents += modEnv * modEnvFilterDepth;
+    cents += modEnv * modEnvPitchDepth;
+
+    // finally calculate the playback rate
+    const centsTotal = ~~(cents + semitones * 100);
+    if(centsTotal !== voice.currentTuningCents)
+    {
+        voice.currentTuningCents = centsTotal;
+        voice.currentTuningCalculated = Math.pow(2, centsTotal / 1200);
+    }
+
+    // PANNING
+    const pan = ( (Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan] )) + 500) / 1000) ; // 0 to 1
+
+    // SYNTHESIS
+    const bufferOut = new Float32Array(output[0].length);
+
+    // wavetable oscillator
+    getOscillatorData(voice, this.workletDumpedSamplesList[voice.sample.sampleID], bufferOut);
+
+
+    // lowpass filter
+    applyLowpassFilter(voice, bufferOut, lowpassCents, this.sampleRate);
+
+    // volenv
+    applyVolumeEnvelope(voice, bufferOut, this.currentTime, modLfoCentibels, this.sampleTime);
+
+    // pan the voice and write out
+    voice.currentPan += (pan - voice.currentPan) * 0.1; // smooth out pan to prevent clicking
+    const panLeft = (1 - voice.currentPan) * this.panLeft;
+    const panRight = voice.currentPan *  this.panRight;
+    panVoice(
+        panLeft,
+        panRight,
+        bufferOut,
+        output,
+        reverbOutput, voice.modulatedGenerators[generatorTypes.reverbEffectsSend],
+        chorusOutput, voice.modulatedGenerators[generatorTypes.chorusEffectsSend]);
+}
+
+
+/**
+ * @this {Synthesizer}
+ * @param amount {number}
+ */
+export function voiceKilling(amount)
+{
+    // kill the smallest velocity voices
+    let voicesOrderedByVelocity = this.workletProcessorChannels.map(channel => channel.voices);
+
+    /**
+     * @type {WorkletVoice[]}
+     */
+    voicesOrderedByVelocity = voicesOrderedByVelocity.flat();
+    voicesOrderedByVelocity.sort((v1, v2) => v1.velocity - v2.velocity);
+    if(voicesOrderedByVelocity.length < amount)
+    {
+        amount = voicesOrderedByVelocity.length;
+    }
+    for (let i = 0; i < amount; i++) {
+        const voice = voicesOrderedByVelocity[i];
+        this.workletProcessorChannels[voice.channelNumber].voices
+            .splice(this.workletProcessorChannels[voice.channelNumber].voices.indexOf(voice), 1);
+        this.totalVoicesAmount--;
+    }
+}
+
+/**
+ * Stops the voice
+ * @param voice {WorkletVoice} the voice to stop
+ * @this {Synthesizer}
+ */
+export function releaseVoice(voice)
+{
+    voice.releaseStartTime = this.currentTime;
+    // check if the note is shorter than the min note time, if so, extend it
+    if(voice.releaseStartTime - voice.startTime < MIN_NOTE_LENGTH)
+    {
+        voice.releaseStartTime = voice.startTime + MIN_NOTE_LENGTH;
+    }
+}

package/spessasynth_core/synthetizer/worklet_system/worklet_utilities/lfo.js

@@ -0,0 +1,23 @@
+/**
+ * lfo.js
+ * purpose: low frequency triangel oscillator
+ */
+
+/**
+ * Calculates a triangular wave value for the given time
+ * @param startTime {number} seconds
+ * @param frequency {number} Hz
+ * @param currentTime {number} seconds
+ * @return {number} the value from -1 to 1
+ */
+export function getLFOValue(startTime, frequency, currentTime) {
+    if (currentTime < startTime) {
+        return 0;
+    }
+
+    const xVal = (currentTime - startTime) / (1 / frequency) - 0.25;
+    // offset by -0.25, otherwise we start at -1 and can have unexpected jump in pitch or lowpass (happened with Synth Strings 2)
+
+    // triangle, not sine
+    return Math.abs(xVal - (~~(xVal + 0.5))) * 4 - 1;
+}