spessasynth_lib 3.24.13 → 3.24.15

package/synthetizer/worklet_system/worklet_methods/system_exclusive.js

@@ -215,7 +215,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                             }
                             else
                             {
-                                // 2 byte tuning. Like fine tune: 0 is -100 cents, 8192 is 0 cents, 16383 is +100 cents
+                                // 2 byte tuning. Like fine tune: 0 is -100 cents, 8192 is 0 cents, 16,383 is +100 cents
                                 for (let i = 0; i < 24; i += 2)
                                 {
                                     const tuning = ((messageData[7 + i] << 7) | messageData[8 + i]) - 8192;
@@ -226,11 +226,11 @@ export function systemExclusive(messageData, channelOffset = 0)
                             // bit 1: 14 and 15
                             if ((messageData[4] & 1) === 1)
                             {
-                                this.setOctaveTuning(14 + channelOffset, newOctaveTuning);
+                                this.workletProcessorChannels[14 + channelOffset].setOctaveTuning(newOctaveTuning);
                             }
                             if (((messageData[4] >> 1) & 1) === 1)
                             {
-                                this.setOctaveTuning(15 + channelOffset, newOctaveTuning);
+                                this.workletProcessorChannels[15 + channelOffset].setOctaveTuning(newOctaveTuning);
                             }
                             
                             // bit 2: channels 7 to 13
@@ -239,7 +239,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                                 const bit = (messageData[5] >> i) & 1;
                                 if (bit === 1)
                                 {
-                                    this.setOctaveTuning(7 + i + channelOffset, newOctaveTuning);
+                                    this.workletProcessorChannels[7 + i + channelOffset].setOctaveTuning(newOctaveTuning);
                                 }
                             }
                             
@@ -249,7 +249,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                                 const bit = (messageData[6] >> i) & 1;
                                 if (bit === 1)
                                 {
-                                    this.setOctaveTuning(i + channelOffset, newOctaveTuning);
+                                    this.workletProcessorChannels[i + channelOffset].setOctaveTuning(newOctaveTuning);
                                 }
                             }
                             
@@ -330,8 +330,9 @@ export function systemExclusive(messageData, channelOffset = 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)
+                        const channel = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15][messageData[5] & 0x0F] + channelOffset;
+                        // for example, 0x1A means A = 11, which corresponds to channel 12 (counting from 1)
+                        const channelObject = this.workletProcessorChannels[channel];
                         switch (messageData[6])
                         {
                             default:
@@ -342,7 +343,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                             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);
+                                channelObject.setDrums(isDrums);
                                 SpessaSynthInfo(
                                     `%cChannel %c${channel}%c ${isDrums ?
                                         "is now a drum channel"
@@ -360,7 +361,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                             case 0x16:
                                 // this is the pitch key shift sysex
                                 const keyShift = messageValue - 64;
-                                this.transposeChannel(channel, keyShift);
+                                channelObject.transposeChannel(keyShift);
                                 SpessaSynthInfo(
                                     `%cChannel %c${channel}%c pitch shift. Semitones %c${keyShift}%c, with %c${arrayToHexString(
                                         messageData)}`,
@@ -379,7 +380,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                                 let panpot = messageValue;
                                 if (panpot === 0)
                                 {
-                                    this.workletProcessorChannels[channel].randomPan = true;
+                                    channelObject.randomPan = true;
                                     SpessaSynthInfo(
                                         `%cRandom pan is set to %cON%c for %c${channel}`,
                                         consoleColors.info,
@@ -390,19 +391,19 @@ export function systemExclusive(messageData, channelOffset = 0)
                                 }
                                 else
                                 {
-                                    this.workletProcessorChannels[channel].randomPan = false;
-                                    this.controllerChange(channel, midiControllers.pan, panpot);
+                                    channelObject.randomPan = false;
+                                    channelObject.controllerChange(midiControllers.pan, panpot);
                                 }
                                 break;
                             
                             // chorus send
                             case 0x21:
-                                this.controllerChange(channel, midiControllers.chorusDepth, messageValue);
+                                channelObject.controllerChange(midiControllers.chorusDepth, messageValue);
                                 break;
                             
                             // reverb send
                             case 0x22:
-                                this.controllerChange(channel, midiControllers.reverbDepth, messageValue);
+                                channelObject.controllerChange(midiControllers.reverbDepth, messageValue);
                                 break;
                             
                             case 0x40:
@@ -418,14 +419,14 @@ export function systemExclusive(messageData, channelOffset = 0)
                             case 0x4A:
                             case 0x4B:
                                 // scale tuning: up to 12 bytes
-                                const tuningBytes = messageData.length - 9; // data starts at 7 , minus checksum and f7
+                                const tuningBytes = messageData.length - 9; // data starts at 7, minus checksum and f7
                                 // read em bytes
                                 const newTuning = new Int8Array(12);
                                 for (let i = 0; i < tuningBytes; i++)
                                 {
                                     newTuning[i] = messageData[i + 7] - 64;
                                 }
-                                this.setOctaveTuning(channel, newTuning);
+                                channelObject.setOctaveTuning(newTuning);
                                 const cents = messageValue - 64;
                                 SpessaSynthInfo(
                                     `%cChannel %c${channel}%c octave scale tuning. Cents %c${newTuning.join(
@@ -437,7 +438,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                                     consoleColors.info,
                                     consoleColors.value
                                 );
-                                this.setChannelTuning(channel, cents);
+                                channelObject.setTuning(cents);
                                 break;
                         }
                         return;
@@ -623,38 +624,38 @@ export function systemExclusive(messageData, channelOffset = 0)
                         // invalid channel
                         return;
                     }
+                    const channelObject = this.workletProcessorChannels[channel];
                     const value = messageData[6];
                     switch (messageData[5])
                     {
-                        // bank select
+                        // bank-select MSB
                         case 0x01:
-                            this.controllerChange(channel, midiControllers.bankSelect, value);
+                            channelObject.controllerChange(midiControllers.bankSelect, value);
                             break;
                         
-                        // bank select lsb
+                        // bank-select LSB
                         case 0x02:
-                            this.controllerChange(channel, midiControllers.lsbForControl0BankSelect, value);
+                            channelObject.controllerChange(midiControllers.lsbForControl0BankSelect, value);
                             break;
                         
                         // program change
                         case 0x03:
-                            this.programChange(channel, value);
+                            channelObject.programChange(value);
                             break;
                         
                         // note shift
                         case 0x08:
-                            const chan = this.workletProcessorChannels[channel];
-                            if (chan.drumChannel)
+                            if (channelObject.drumChannel)
                             {
                                 return;
                             }
                             const semitones = value - 64;
-                            chan.channelTransposeKeyShift = semitones;
+                            channelObject.channelTransposeKeyShift = semitones;
                             break;
                         
                         // volume
                         case 0x0B:
-                            this.controllerChange(channel, midiControllers.mainVolume, value);
+                            channelObject.controllerChange(midiControllers.mainVolume, value);
                             break;
                         
                         // pan position
@@ -663,7 +664,7 @@ export function systemExclusive(messageData, channelOffset = 0)
                             if (pan === 0)
                             {
                                 // 0 means random
-                                this.workletProcessorChannels[channel].randomPan = true;
+                                channelObject.randomPan = true;
                                 SpessaSynthInfo(
                                     `%cRandom pan is set to %cON%c for %c${channel}`,
                                     consoleColors.info,
@@ -674,18 +675,18 @@ export function systemExclusive(messageData, channelOffset = 0)
                             }
                             else
                             {
-                                this.controllerChange(channel, midiControllers.pan, pan);
+                                channelObject.controllerChange(midiControllers.pan, pan);
                             }
                             break;
                         
                         // reverb
                         case 0x13:
-                            this.controllerChange(channel, midiControllers.reverbDepth, value);
+                            channelObject.controllerChange(midiControllers.reverbDepth, value);
                             break;
                         
                         // chorus
                         case 0x12:
-                            this.controllerChange(channel, midiControllers.chorusDepth, value);
+                            channelObject.controllerChange(midiControllers.chorusDepth, value);
                             break;
                         
                         default:

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

@@ -0,0 +1,24 @@
+import { NON_CC_INDEX_OFFSET } from "../../worklet_utilities/controller_tables.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
+import { computeModulators } from "../../worklet_utilities/worklet_modulator.js";
+
+/**
+ * Sets the pressure of the given channel
+ * @this {WorkletProcessorChannel}
+ * @param pressure {number} the pressure of the channel
+ */
+export function channelPressure(pressure)
+{
+    this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.channelPressure] = pressure << 7;
+    this.voices.forEach(v =>
+        computeModulators(
+            v,
+            this.midiControllers,
+            0,
+            modulatorSources.channelPressure
+        ));
+    this.synth.callEvent("channelpressure", {
+        channel: this.channelNumber,
+        pressure: pressure
+    });
+}

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

@@ -0,0 +1,33 @@
+import { NON_CC_INDEX_OFFSET } from "../../worklet_utilities/controller_tables.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
+import { computeModulators } from "../../worklet_utilities/worklet_modulator.js";
+
+/**
+ * Sets the pitch of the given channel
+ * @this {WorkletProcessorChannel}
+ * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+ * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+ */
+export function pitchWheel(MSB, LSB)
+{
+    if (this.lockedControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel])
+    {
+        return;
+    }
+    const bend = (LSB | (MSB << 7));
+    this.synth.callEvent("pitchwheel", {
+        channel: this.channelNumber,
+        MSB: MSB,
+        LSB: LSB
+    });
+    this.midiControllers[NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel] = bend;
+    this.voices.forEach(v =>
+        // compute pitch modulators
+        computeModulators(
+            v,
+            this.midiControllers,
+            0,
+            modulatorSources.pitchWheel
+        ));
+    this.synth.sendChannelProperties();
+}

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

@@ -0,0 +1,31 @@
+import { computeModulators } from "../../worklet_utilities/worklet_modulator.js";
+import { modulatorSources } from "../../../../soundfont/basic_soundfont/modulator.js";
+
+/**
+ * Sets the pressure of the given note on a specific channel
+ * @this {WorkletProcessorChannel}
+ * @param midiNote {number} 0-127
+ * @param pressure {number} the pressure of the note
+ */
+export function polyPressure(midiNote, pressure)
+{
+    this.voices.forEach(v =>
+    {
+        if (v.midiNote !== midiNote)
+        {
+            return;
+        }
+        v.pressure = pressure;
+        computeModulators(
+            v,
+            this.midiControllers,
+            0,
+            modulatorSources.polyPressure
+        );
+    });
+    this.synth.callEvent("polypressure", {
+        channel: this.channelNumber,
+        midiNote: midiNote,
+        pressure: pressure
+    });
+}

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

@@ -0,0 +1,15 @@
+import { customControllers } from "../../worklet_utilities/controller_tables.js";
+
+/**
+ * Sets the worklet's primary 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;
+    }
+}

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

@@ -0,0 +1,27 @@
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+import { customControllers } from "../../worklet_utilities/controller_tables.js";
+
+/**
+ * @this {WorkletProcessorChannel}
+ * @param cents {number}
+ */
+export function setModulationDepth(cents)
+{
+    cents = Math.round(cents);
+    SpessaSynthInfo(
+        `%cChannel ${this.channelNumber} 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 dividing 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.
+     ================ */
+    this.customControllers[customControllers.modulationMultiplier] = cents / 50;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Sets the octave tuning for a given channel
+ * @this {WorkletProcessorChannel}
+ * @param tuning {Int8Array} LENGTH of 12!
+ * relative cent tuning.
+ * min -128 max 127.
+ */
+export function setOctaveTuning(tuning)
+{
+    if (tuning.length !== 12)
+    {
+        throw new Error("Tuning is not the length of 12.");
+    }
+    this.channelOctaveTuning = tuning;
+}

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

@@ -0,0 +1,24 @@
+import { customControllers } from "../../worklet_utilities/controller_tables.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+
+/**
+ * Sets the channel's tuning
+ * @this {WorkletProcessorChannel}
+ * @param cents {number}
+ * @param log {boolean}
+ */
+export function setTuning(cents, log = true)
+{
+    cents = Math.round(cents);
+    this.customControllers[customControllers.channelTuning] = cents;
+    if (!log)
+    {
+        return;
+    }
+    SpessaSynthInfo(
+        `%cChannel ${this.channelNumber} fine tuning. Cents: %c${cents}`,
+        consoleColors.info,
+        consoleColors.value
+    );
+}

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

@@ -0,0 +1,19 @@
+import { customControllers } from "../../worklet_utilities/controller_tables.js";
+import { SpessaSynthInfo } from "../../../../utils/loggin.js";
+import { consoleColors } from "../../../../utils/other.js";
+
+/**
+ * Sets the channel's tuning in semitones
+ * @param semitones {number}
+ * @this {WorkletProcessorChannel}
+ */
+export function setTuningSemitones(semitones)
+{
+    semitones = Math.round(semitones);
+    this.customControllers[customControllers.channelTuningSemitones] = semitones;
+    SpessaSynthInfo(
+        `%cChannel ${this.channelNumber} coarse tuning. Semitones: %c${semitones}`,
+        consoleColors.info,
+        consoleColors.value
+    );
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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.workletProcessorChannels[i].transposeChannel(semitones, force);
+    }
+    this.transposition = semitones;
+}

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

@@ -0,0 +1,31 @@
+import { customControllers } from "../../worklet_utilities/controller_tables.js";
+
+/**
+ * Transposes the channel by given amount of semitones
+ * @this {WorkletProcessorChannel}
+ * @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(semitones, force = false)
+{
+    if (!this.drumChannel)
+    {
+        semitones += this.synth.transposition;
+    }
+    const keyShift = Math.trunc(semitones);
+    const currentTranspose = this.channelTransposeKeyShift + this.customControllers[customControllers.channelTransposeFine] / 100;
+    if (
+        (this.drumChannel && !force)
+        || semitones === currentTranspose
+    )
+    {
+        return;
+    }
+    if (keyShift !== this.channelTransposeKeyShift)
+    {
+        this.stopAllNotes(false);
+    }
+    // apply transpose
+    this.channelTransposeKeyShift = keyShift;
+    this.customControllers[customControllers.channelTransposeFine] = (semitones - keyShift) * 100;
+}

package/synthetizer/worklet_system/worklet_utilities/controller_tables.js

@@ -22,6 +22,8 @@ setResetValue(midiControllers.balance, 64);
 setResetValue(midiControllers.expressionController, 127);
 setResetValue(midiControllers.pan, 64);
 
+setResetValue(midiControllers.portamentoOnOff, 127);
+
 setResetValue(midiControllers.timbreHarmonicContent, 64);
 setResetValue(midiControllers.releaseTime, 64);
 setResetValue(midiControllers.attackTime, 64);
@@ -33,7 +35,7 @@ setResetValue(midiControllers.soundController8, 64);
 setResetValue(midiControllers.soundController9, 64);
 setResetValue(midiControllers.generalPurposeController6, 64);
 setResetValue(midiControllers.generalPurposeController8, 64);
-setResetValue(midiControllers.portamentoControl, 64);
+setResetValue(midiControllers.portamentoControl, 60);
 
 // pitch wheel
 setResetValue(NON_CC_INDEX_OFFSET + modulatorSources.pitchWheel, 64);
@@ -61,4 +63,11 @@ export const dataEntryStates = {
     NRPFine: 4,
     DataCoarse: 5,
     DataFine: 6
+};
+/**
+ * This is a channel configuration enum, it is internally sent from Synthetizer via controller change
+ * @enum {number}
+ */
+export const channelConfiguration = {
+    velocityOverride: 128 // overrides velocity for the given channel
 };

package/synthetizer/worklet_system/worklet_utilities/lfo.js

@@ -18,7 +18,8 @@ export function getLFOValue(startTime, frequency, currentTime)
     }
     
     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)
+    // offset by -0.25, otherwise we start at -1 and can have unexpected jump in pitch or low-pass
+    // (happened with Synth Strings 2)
     
     // triangle, not sine
     return Math.abs(xVal - (~~(xVal + 0.5))) * 4 - 1;

package/synthetizer/worklet_system/worklet_utilities/modulation_envelope.js

@@ -13,7 +13,7 @@ const MODENV_PEAK = 1;
 const CONVEX_ATTACK = new Float32Array(1000);
 for (let i = 0; i < CONVEX_ATTACK.length; i++)
 {
-    // this makes the db linear ( i think
+    // this makes the db linear (I think)
     CONVEX_ATTACK[i] = getModulatorCurveValue(0, modulatorCurveTypes.convex, i / 1000, 0);
 }
 
@@ -110,7 +110,7 @@ export class WorkletModulationEnvelope
         const decayKeyExcursionCents = ((60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvDecay]);
         const decayTime = timecentsToSeconds(voice.modulatedGenerators[generatorTypes.decayModEnv] + decayKeyExcursionCents);
         // according to the specification, the decay time is the time it takes to reach 0% from 100%.
-        // calculate the time to reach actual sustain level
+        // calculate the time to reach actual sustain level,
         // for example, sustain 0.6 will be 0.4 of the decay time
         env.decayDuration = decayTime * (1 - env.sustainLevel);
         
@@ -130,7 +130,7 @@ export class WorkletModulationEnvelope
     
     /**
      * Calculates the current modulation envelope value for the given time and voice
-     * @param voice {WorkletVoice} the voice we're working on
+     * @param voice {WorkletVoice} the voice we are working on
      * @param currentTime {number} in seconds
      * @param ignoreRelease {boolean} if true, it will compute the value as if the voice was not released
      * @returns {number} modenv value, from 0 to 1
@@ -141,7 +141,7 @@ export class WorkletModulationEnvelope
         if (voice.isInRelease && !ignoreRelease)
         {
             // if the voice is still in the delay phase,
-            // start level will be 0 which will result in divide by zero
+            // start level will be 0 that will result in divide by zero
             if (env.releaseStartLevel === 0)
             {
                 return 0;

package/synthetizer/worklet_system/worklet_utilities/modulator_curves.js

@@ -8,12 +8,11 @@ import { modulatorCurveTypes } from "../../../soundfont/basic_soundfont/modulato
 // the length of the precomputed curve tables
 export const MOD_PRECOMPUTED_LENGTH = 16384;
 
-// Precalculate lookup tables for concave and convers
+// Precalculate lookup tables for concave and convex curves
 const concave = new Float32Array(MOD_PRECOMPUTED_LENGTH + 1);
 const convex = new Float32Array(MOD_PRECOMPUTED_LENGTH + 1);
 // the equation is taken from FluidSynth as it's the standard for soundFonts
-// more precisely, this:
-// https://github.com/FluidSynth/fluidsynth/blob/cb8da1e1e2c0a5cff2bab6a419755b598b793384/src/gentables/gen_conv.c#L55
+// more precisely, the gen_conv.c file
 concave[0] = 0;
 concave[concave.length - 1] = 1;
 
@@ -32,7 +31,7 @@ for (let i = 1; i < MOD_PRECOMPUTED_LENGTH - 1; i++)
  * @param direction {number} 0 or 1
  * @param curveType {number} see modulatorCurveTypes in modulators.js
  * @param value {number} the linear value, 0 to 1
- * @returns {number} the transformed value, 0 to 1 or -1 to 1
+ * @returns {number} the transformed value, 0 to 1, or -1 to 1
  */
 export function getModulatorCurveValue(direction, curveType, value, polarity)
 {
@@ -46,7 +45,7 @@ export function getModulatorCurveValue(direction, curveType, value, polarity)
         case modulatorCurveTypes.linear:
             if (polarity)
             {
-                // bipolar
+                // bipolar curve
                 return value * 2 - 1;
             }
             return value;

package/synthetizer/worklet_system/worklet_utilities/stereo_panner.js

@@ -33,15 +33,17 @@ for (let pan = MIN_PAN; pan <= MAX_PAN; pan++)
  * @param inputBuffer {Float32Array} the input buffer in mono
  * @param outputLeft {Float32Array} left output buffer
  * @param outputRight {Float32Array} right output buffer
- * @param reverb {Float32Array[]} stereo reverb input
- * @param chorus {Float32Array[]} stereo chorus buffer
- * @this {SpessaSynthProcessor}
+ * @param reverbLeft {Float32Array} left reverb input
+ * @param reverbRight {Float32Array} right reverb input
+ * @param chorusLeft {Float32Array} left chorus buffer
+ * @param chorusRight {Float32Array} right chorus buffer
+ * @this {WorkletProcessorChannel}
  */
 export function panVoice(voice,
                          inputBuffer,
                          outputLeft, outputRight,
-                         reverb,
-                         chorus)
+                         reverbLeft, reverbRight,
+                         chorusLeft, chorusRight)
 {
     if (isNaN(inputBuffer[0]))
     {
@@ -58,40 +60,38 @@ export function panVoice(voice,
     }
     else
     {
-        pan = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan]));
+        const target = Math.max(-500, Math.min(500, voice.modulatedGenerators[generatorTypes.pan]));
         // smooth out pan to prevent clicking
-        voice.currentPan += (pan - voice.currentPan) * this.panSmoothingFactor;
+        voice.currentPan += (target - voice.currentPan) * this.synth.panSmoothingFactor;
+        pan = voice.currentPan;
     }
     
-    const gain = this.currentGain;
+    const gain = this.synth.currentGain;
     const index = ~~(pan + 500);
     // get voice's gain levels for each channel
-    const gainLeft = panTableLeft[index] * gain * this.panLeft;
-    const gainRight = panTableRight[index] * gain * this.panRight;
+    const gainLeft = panTableLeft[index] * gain * this.synth.panLeft;
+    const gainRight = panTableRight[index] * gain * this.synth.panRight;
     
     // disable reverb and chorus in one output mode
-    if (!this.oneOutputMode)
+    if (!this.synth.oneOutputMode)
     {
         // reverb is mono so we need to multiply by gain
-        const reverbLevel = this.reverbGain * voice.modulatedGenerators[generatorTypes.reverbEffectsSend] / WORKLET_SYSTEM_REVERB_DIVIDER * gain;
+        const reverbLevel = this.synth.reverbGain * voice.modulatedGenerators[generatorTypes.reverbEffectsSend] / WORKLET_SYSTEM_REVERB_DIVIDER * gain;
         // chorus is stereo so we do not need to
-        const chorusLevel = this.chorusGain * voice.modulatedGenerators[generatorTypes.chorusEffectsSend] / WORKLET_SYSTEM_CHORUS_DIVIDER;
+        const chorusLevel = this.synth.chorusGain * voice.modulatedGenerators[generatorTypes.chorusEffectsSend] / WORKLET_SYSTEM_CHORUS_DIVIDER;
         
         if (reverbLevel > 0)
         {
-            const reverbLeft = reverb[0];
-            const reverbRight = reverb[1];
             for (let i = 0; i < inputBuffer.length; i++)
             {
                 reverbLeft[i] += reverbLevel * inputBuffer[i];
-                reverbRight[i] += reverbLevel * inputBuffer[i];
             }
+            // copy as its mono
+            reverbRight.set(reverbLeft);
         }
         
         if (chorusLevel > 0)
         {
-            const chorusLeft = chorus[0];
-            const chorusRight = chorus[1];
             const chorusLeftGain = gainLeft * chorusLevel;
             const chorusRightGain = gainRight * chorusLevel;
             for (let i = 0; i < inputBuffer.length; i++)