spessasynth_lib 0.0.1

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

@@ -0,0 +1,272 @@
+import { arrayToHexString, consoleColors } from '../../../utils/other.js'
+import { SpessaSynthInfo, SpessaSynthWarn } from '../../../utils/loggin.js'
+/**
+ * Executes a system exclusive
+ * @param messageData {number[]|IndexedByteArray} - the message data without f0
+ * @param channelOffset {number}
+ * @this {SpessaSynthProcessor}
+ */
+
+export function systemExclusive(messageData, channelOffset = 0)
+{
+    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.setMIDIVolume(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.
+                        let channel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][messageData[5] & 0x0F] + channelOffset;
+                        // 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)
+                                const isDrums = messageValue > 0 && messageData[5] >> 4; // if set to other than 0, is a drum channel
+                                this.setDrums(channel, isDrums);
+                                SpessaSynthInfo(
+                                    `%cChannel %c${channel}%c ${isDrums ?
+                                        "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.setMIDIVolume(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.setMIDIVolume(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
+            {
+                if(this.system === "xg")
+                {
+                    SpessaSynthWarn(`%cUnrecognized Yamaha SysEx: %c${arrayToHexString(messageData)}`,
+                        consoleColors.warn,
+                        consoleColors.unrecognized);
+                }
+            }
+            break;
+
+
+    }
+}

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

@@ -0,0 +1,195 @@
+import { customControllers, NON_CC_INDEX_OFFSET } from '../worklet_utilities/worklet_processor_channel.js'
+import { consoleColors } from '../../../utils/other.js'
+import { modulatorSources } from '../../../soundfont/read/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 {SpessaSynthProcessor}
+ * @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 {SpessaSynthProcessor}
+ * @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)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    if(!channelObject.drumChannel)
+    {
+        semitones += this.transposition;
+    }
+    const keyShift = Math.trunc(semitones);
+    const currentTranspose = channelObject.channelTransposeKeyShift + channelObject.customControllers[customControllers.channelTransposeFine] / 100;
+    if(
+        (channelObject.drumChannel && !force)
+        || semitones === currentTranspose
+    )
+    {
+        return;
+    }
+    if(keyShift !== channelObject.channelTransposeKeyShift)
+    {
+        this.stopAll(channel, false);
+    }
+    // apply transpose
+    channelObject.channelTransposeKeyShift = keyShift;
+    channelObject.customControllers[customControllers.channelTransposeFine] = (semitones - keyShift) * 100;
+}
+
+/**
+ * Sets the channel's tuning
+ * @this {SpessaSynthProcessor}
+ * @param channel {number}
+ * @param cents {number}
+ * @param log {boolean}
+ */
+export function setChannelTuning(channel, cents, log = true)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    cents = Math.round(cents);
+    channelObject.customControllers[customControllers.channelTuning] = cents;
+    if(!log)
+    {
+        return;
+    }
+    SpessaSynthInfo(`%cChannel ${channel} fine tuning. Cents: %c${cents}`,
+        consoleColors.info,
+        consoleColors.value);
+}
+
+/**
+ * Sets the channel's tuning in semitones
+ * @param channel {number}
+ * @param semitones {number}
+ * @this {SpessaSynthProcessor}
+ */
+export function setChannelTuningSemitones(channel, semitones)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    semitones = Math.round(semitones);
+    channelObject.customControllers[customControllers.channelTuningSemitones] = semitones;
+    SpessaSynthInfo(`%cChannel ${channel} coarse tuning. Semitones: %c${semitones}`,
+        consoleColors.info,
+        consoleColors.value);
+}
+
+/**
+ * Sets the worklet's master tuning
+ * @this {SpessaSynthProcessor}
+ * @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 {SpessaSynthProcessor}
+ * @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 {SpessaSynthProcessor}
+ * @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)
+{
+    if(this.workletProcessorChannels[channel].lockedControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel])
+    {
+        return;
+    }
+    const bend = (LSB | (MSB << 7));
+    this.callEvent("pitchwheel", {
+        channel: channel,
+        MSB: MSB,
+        LSB: LSB
+    });
+    this.workletProcessorChannels[channel].midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = bend;
+    this.workletProcessorChannels[channel].voices.forEach(v =>
+        // compute pitch modulators
+        computeModulators(v, this.workletProcessorChannels[channel].midiControllers, 0, modulatorSources.pitchWheel));
+    this.sendChannelProperties();
+}
+
+/**
+ * Sets the pressure of the given channel
+ * @this {SpessaSynthProcessor}
+ * @param channel {number} usually 0-15: the channel to change pitch
+ * @param pressure {number} the pressure of the channel
+ */
+export function channelPressure(channel, pressure)
+{
+    const channelObject = this.workletProcessorChannels[channel];
+    channelObject.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] = pressure << 7;
+    this.workletProcessorChannels[channel].voices.forEach(v =>
+        computeModulators(v, channelObject.midiControllers, 0, modulatorSources.channelPressure));
+    this.callEvent("channelpressure",{
+        channel: channel,
+        pressure: pressure
+    });
+}
+
+/**
+ * Sets the pressure of the given note on a specific channel
+ * @this {SpessaSynthProcessor}
+ * @param channel {number} usually 0-15: the channel to change pitch
+ * @param midiNote {number} 0-127
+ * @param pressure {number} the pressure of the note
+ */
+export function polyPressure(channel, midiNote, pressure)
+{
+    this.workletProcessorChannels[channel].voices.forEach(v => {
+        if(v.midiNote !== midiNote)
+        {
+            return;
+        }
+        v.pressure = pressure;
+        computeModulators(v, this.workletProcessorChannels[channel].midiControllers, 0, modulatorSources.polyPressure);
+    });
+    this.callEvent("polypressure", {
+        channel: channel,
+        midiNote: midiNote,
+        pressure: pressure
+    });
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @param channel {number}
+ * @this {SpessaSynthProcessor}
+ */
+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 {SpessaSynthProcessor}
+ */
+export function setVibrato(channel, depth, rate, delay)
+{
+    if(this.workletProcessorChannels[channel].lockVibrato)
+    {
+        return;
+    }
+    this.workletProcessorChannels[channel].channelVibrato.rate = rate;
+    this.workletProcessorChannels[channel].channelVibrato.delay = delay;
+    this.workletProcessorChannels[channel].channelVibrato.depth = depth;
+}