spessasynth_core 1.0.0

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

@@ -0,0 +1,280 @@
+import { consoleColors } from '../../../utils/other.js'
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import {
+    customControllers,
+    dataEntryStates,
+    NON_CC_INDEX_OFFSET,
+} from '../worklet_utilities/worklet_processor_channel.js'
+import { modulatorSources } from '../../../soundfont/chunk/modulators.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.js'
+
+/**
+ * Executes a data entry for an NRP for a sc88pro NRP (because touhou yes) and RPN tuning
+ * @param channel {number}
+ * @param dataValue {number} dataEntryCoarse MSB
+ * @this {Synthesizer}
+ * @private
+ */
+export function dataEntryCoarse(channel, dataValue)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    let addDefaultVibrato = () =>
+    {
+        if(channelObject.channelVibrato.delay === 0 && channelObject.channelVibrato.rate === 0 && channelObject.channelVibrato.depth === 0)
+        {
+            channelObject.channelVibrato.depth = 50;
+            channelObject.channelVibrato.rate = 8;
+            channelObject.channelVibrato.delay = 0.6;
+        }
+    }
+    switch(channelObject.dataEntryState)
+    {
+        default:
+        case dataEntryStates.Idle:
+            break;
+
+        // https://cdn.roland.com/assets/media/pdf/SC-88PRO_OM.pdf
+        // http://hummer.stanford.edu/sig/doc/classes/MidiOutput/rpn.html
+        case dataEntryStates.NRPFine:
+            switch(channelObject.NRPCoarse)
+            {
+                default:
+                    if(dataValue === 64)
+                    {
+                        // default value
+                        return;
+                    }
+                    SpessaSynthWarn(
+                        `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16).toUpperCase()} 0x${channelObject.NRPFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`,
+                        consoleColors.warn,
+                        consoleColors.recognized,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value);
+                    break;
+
+                case 0x01:
+                    switch(channelObject.NRPFine)
+                    {
+                        default:
+                            if(dataValue === 64)
+                            {
+                                // default value
+                                return;
+                            }
+                            SpessaSynthWarn(
+                                `%cUnrecognized NRPN for %c${channel}%c: %c(0x${channelObject.NRPCoarse.toString(16)} 0x${channelObject.NRPFine.toString(16)})%c data value: %c${dataValue}`,
+                                consoleColors.warn,
+                                consoleColors.recognized,
+                                consoleColors.warn,
+                                consoleColors.unrecognized,
+                                consoleColors.warn,
+                                consoleColors.value);
+                            break;
+
+                        // vibrato rate
+                        case 0x08:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.rate = (dataValue / 64) * 8;
+                            SpessaSynthInfo(`%cVibrato rate for channel %c${channel}%c is now set to %c${channelObject.channelVibrato.rate}%cHz.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // vibrato depth
+                        case 0x09:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.depth = dataValue / 2;
+                            SpessaSynthInfo(`%cVibrato depth for %c${channel}%c is now set to %c${channelObject.channelVibrato.depth}%c cents range of detune.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // vibrato delay
+                        case 0x0A:
+                            if(channelObject.lockVibrato)
+                            {
+                                return;
+                            }
+                            if(dataValue === 64)
+                            {
+                                return;
+                            }
+                            addDefaultVibrato();
+                            channelObject.channelVibrato.delay = (dataValue / 64) / 3;
+                            SpessaSynthInfo(`%cVibrato delay for %c${channel}%c is now set to %c${channelObject.channelVibrato.delay}%c seconds.`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value,
+                                consoleColors.info);
+                            break;
+
+                        // filter cutoff
+                        case 0x20:
+                            // affect the "brightness" controller as we have a default modulator that controls it
+                            const ccValue = dataValue;
+                            this.controllerChange(channel, midiControllers.brightness, dataValue)
+                            SpessaSynthInfo(`%cFilter cutoff for %c${channel}%c is now set to %c${ccValue}`,
+                                consoleColors.info,
+                                consoleColors.recognized,
+                                consoleColors.info,
+                                consoleColors.value);
+                    }
+                    break;
+
+                // drum reverb
+                case 0x1D:
+                    if(!channelObject.percussionChannel)
+                    {
+                        return;
+                    }
+                    const reverb = dataValue;
+                    this.controllerChange(channel, midiControllers.effects1Depth, reverb);
+                    SpessaSynthInfo(
+                        `%cGS Drum reverb for %c${channel}%c: %c${reverb}`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.value);
+                    break;
+
+                // drum chorus
+                case 0x1E:
+                    if(!channelObject.percussionChannel)
+                    {
+                        return;
+                    }
+                    const chorus = dataValue;
+                    this.controllerChange(channel, midiControllers.effects3Depth, chorus);
+                    SpessaSynthInfo(
+                        `%cGS Drum chorus for %c${channel}%c: %c${chorus}`,
+                        consoleColors.info,
+                        consoleColors.recognized,
+                        consoleColors.info,
+                        consoleColors.value);
+            }
+            break;
+
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            switch(channelObject.RPValue)
+            {
+                default:
+                    SpessaSynthWarn(
+                        `%cUnrecognized RPN for %c${channel}%c: %c(0x${channelObject.RPValue.toString(16)})%c data value: %c${dataValue}`,
+                        consoleColors.warn,
+                        consoleColors.recognized,
+                        consoleColors.warn,
+                        consoleColors.unrecognized,
+                        consoleColors.warn,
+                        consoleColors.value);
+                    break;
+
+                // pitch bend range
+                case 0x0000:
+                    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheelRange] = dataValue << 7;
+                    SpessaSynthInfo(`%cChannel ${channel} bend range. Semitones: %c${dataValue}`,
+                        consoleColors.info,
+                        consoleColors.value);
+                    break;
+
+                // coarse tuning
+                case 0x0002:
+                    // semitones
+                    this.setChannelTuning(channel, (dataValue - 64) * 100);
+                    break;
+
+                // fine tuning
+                case 0x0001:
+                    // note: this will not work properly unless the lsb is sent!
+                    // here we store the raw value to then adjust in fine
+                    this.setChannelTuning(channel, (dataValue - 64));
+                    break;
+
+                // modulation depth
+                case 0x0005:
+                    this.setModulationDepth(channel, dataValue * 100);
+                    break
+
+                case 0x3FFF:
+                    this.resetParameters(channel);
+                    break;
+
+            }
+
+    }
+}
+
+/**
+ * Executes a data entry for an RPN tuning
+ * @param channel {number}
+ * @param dataValue {number} dataEntry LSB
+ * @this {Synthesizer}
+ * @private
+ */
+export function dataEntryFine(channel, dataValue)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    switch (channelObject.dataEntryState)
+    {
+        default:
+            break;
+
+        case dataEntryStates.RPCoarse:
+        case dataEntryStates.RPFine:
+            switch(channelObject.RPValue)
+            {
+                default:
+                    break;
+
+                // pitch bend range fine tune is not supported in the SoundFont2 format. (pitchbend range is in semitones rather than cents)
+                case 0x0000:
+                    break;
+
+                // fine tuning
+                case 0x0001:
+                    // grab the data and shift
+                    const coarse = channelObject.customControllers[customControllers.channelTuning];
+                    const finalTuning = (coarse << 7) | dataValue;
+                    this.setChannelTuning(channel, finalTuning * 0.0122); // multiply by 8192 / 100 (cent increment)
+                    break;
+
+                // modulation depth
+                case 0x0005:
+                    const currentModulationDepthCents = channelObject.customControllers[customControllers.modulationMultiplier] * 50;
+                    let cents = currentModulationDepthCents + (dataValue / 128) * 100;
+                    this.setModulationDepth(channel, cents);
+                    break
+
+                case 0x3FFF:
+                    this.resetParameters(channel);
+                    break;
+
+            }
+
+    }
+}

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

@@ -0,0 +1,102 @@
+import { generatorTypes } from '../../../soundfont/chunk/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 {Synthesizer}
+ */
+export function noteOff(channel, midiNote)
+{
+    if(midiNote > 127 || midiNote < 0)
+    {
+        SpessaSynthWarn(`Received a noteOn for note`, midiNote, "Ignoring.");
+        return;
+    }
+
+    // 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);
+        }
+    });
+}
+
+/**
+ * Stops a note nearly instantly
+ * @param channel {number}
+ * @param midiNote {number}
+ * @this {Synthesizer}
+ */
+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 {Synthesizer}
+ */
+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;
+    }
+    else
+    {
+        channelVoices.forEach(v => {
+            if(v.isInRelease) return;
+            this.releaseVoice(v);
+        });
+        this.workletProcessorChannels[channel].sustainedVoices.forEach(v => {
+            this.releaseVoice(v);
+        })
+    }
+}
+
+/**
+ * @this {Synthesizer}
+ * @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);
+    }
+}

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

@@ -0,0 +1,75 @@
+import { getWorkletVoices } from '../worklet_utilities/worklet_voice.js'
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+import { computeModulators } from '../worklet_utilities/worklet_modulator.js'
+import { VOICE_CAP } from "../../synthesizer.js";
+import { SpessaSynthWarn } from '../../../utils/loggin.js'
+
+/**
+ * Append the voices
+ * @param channel {number}
+ * @param midiNote {number}
+ * @param velocity {number}
+ * @param enableDebugging {boolean}
+ * @this {Synthesizer}
+ */
+export function noteOn(channel, midiNote, velocity, enableDebugging = false)
+{
+    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;
+    }
+
+    if(midiNote > 127 || midiNote < 0)
+    {
+        SpessaSynthWarn(`Received a noteOn for note`, midiNote, "Ignoring.");
+        return;
+    }
+
+
+    // get voices
+    const voices = getWorkletVoices(
+        channel,
+        midiNote,
+        velocity,
+        this.workletProcessorChannels[channel].preset,
+        this.currentTime,
+        this.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.generators[generatorTypes.releaseVolEnv] = -7200; // make the release nearly instant
+                    computeModulators(v, this.workletProcessorChannels[channel].midiControllers);
+                }
+            })
+        }
+        computeModulators(voice, this.workletProcessorChannels[channel].midiControllers);
+        voice.currentAttenuationDb = 100;
+    })
+    channelVoices.push(...voices);
+
+    this.totalVoicesAmount += voices.length;
+    // cap the voices
+    if(this.totalVoicesAmount > VOICE_CAP)
+    {
+        this.voiceKilling(this.totalVoicesAmount - VOICE_CAP);
+    }
+}

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

@@ -0,0 +1,140 @@
+import { midiControllers } from '../../../midi_parser/midi_message.js'
+import { SoundFont2 } from '../../../soundfont/soundfont_parser.js'
+import { clearSamplesList } from '../worklet_utilities/worklet_voice.js'
+import { generatorTypes } from '../../../soundfont/chunk/generators.js'
+
+/**
+ * executes a program change
+ * @param channel {number}
+ * @param programNumber {number}
+ * @param userChange {boolean}
+ * @this {Synthesizer}
+ */
+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);
+}
+
+/**
+ * @param channel {number}
+ * @param preset {Preset}
+ * @this {Synthesizer}
+ */
+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 {Synthesizer}
+ */
+export function setDrums(channel, isDrum)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    if(isDrum)
+    {
+        channelObject.drumChannel = true;
+        this.setPreset(channel, this.soundfont.getPreset(128, channelObject.preset.program));
+    }
+    else
+    {
+        channelObject.percussionChannel = false;
+        this.setPreset(channel, this.soundfont.getPreset(0, channelObject.preset.program));
+    }
+}
+
+/**
+ * @param buffer {ArrayBuffer}
+ * @this {Synthesizer}
+ */
+export function reloadSoundFont(buffer)
+{
+    this.stopAllChannels(true);
+    delete this.soundfont;
+    clearSamplesList();
+    delete this.workletDumpedSamplesList;
+    this.workletDumpedSamplesList = [];
+
+
+    this.soundfont = new SoundFont2(buffer);
+    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);
+    }
+}
+
+/**
+ * saves a sample
+ * @param channel {number}
+ * @param sampleID {number}
+ * @param sampleData {Float32Array}
+ * @this {Synthesizer}
+ */
+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 * this.sampleRate) * (this.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 = this.currentTime;
+    })
+
+}