@marmooo/midy 0.4.3 → 0.4.4

package/script/midy.js

@@ -265,6 +265,16 @@ const releaseCurve = 1 / (-Math.log(cbToRatio(-600)));
 class Midy extends EventTarget {
     constructor(audioContext) {
         super();
+        // https://pmc.ncbi.nlm.nih.gov/articles/PMC4191557/
+        // https://pubmed.ncbi.nlm.nih.gov/12488797/
+        // Gap detection studies indicate humans detect temporal discontinuities
+        // around 2–3 ms. Smoothing over ~4 ms is perceived as continuous.
+        Object.defineProperty(this, "perceptualSmoothingTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.004
+        });
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -487,6 +497,33 @@ class Midy extends EventTarget {
             writable: true,
             value: new Array(this.numChannels * drumExclusiveClassCount)
         });
+        Object.defineProperty(this, "mpeEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "lowerMPEMembers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "upperMPEMembers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "mpeState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                channelToNote: new Map(),
+                noteToChannel: new Map(),
+            }
+        });
         this.audioContext = audioContext;
         this.masterVolume = new GainNode(audioContext);
         this.scheduler = new GainNode(audioContext, { gain: 0 });
@@ -1013,6 +1050,13 @@ class Midy extends EventTarget {
             this.isSeeking = true;
         }
     }
+    tempoChange(tempo) {
+        const timeScale = this.tempo / tempo;
+        this.resumeTime = this.resumeTime * timeScale;
+        this.tempo = tempo;
+        this.totalTime = this.calcTotalTime();
+        this.seekTo(this.currentTime() * timeScale);
+    }
     calcTotalTime() {
         const totalTimeEventTypes = this.totalTimeEventTypes;
         const timeline = this.timeline;
@@ -1235,39 +1279,24 @@ class Midy extends EventTarget {
             return tuning + pitch;
         }
     }
-    calcNoteDetune(channel, note) {
-        return channel.scaleOctaveTuningTable[note.noteNumber % 12];
-    }
     updateChannelDetune(channel, scheduleTime) {
         this.processScheduledNotes(channel, (note) => {
-            this.updateDetune(channel, note, scheduleTime);
+            if (this.isPortamento(channel, note)) {
+                this.setPortamentoDetune(channel, note, scheduleTime);
+            }
+            else {
+                this.setDetune(channel, note, scheduleTime);
+            }
         });
     }
-    updateDetune(channel, note, scheduleTime) {
-        const noteDetune = this.calcNoteDetune(channel, note);
+    calcScaleOctaveTuning(channel, note) {
+        return channel.scaleOctaveTuningTable[note.noteNumber % 12];
+    }
+    calcNoteDetune(channel, note) {
+        const noteDetune = note.voiceParams.detune +
+            this.calcScaleOctaveTuning(channel, note);
         const pitchControl = this.getPitchControl(channel, note);
-        const detune = channel.detune + noteDetune + pitchControl;
-        if (channel.portamentoControl) {
-            const state = channel.state;
-            const portamentoNoteNumber = Math.ceil(state.portamentoNoteNumber * 127);
-            note.portamentoNoteNumber = portamentoNoteNumber;
-            channel.portamentoControl = false;
-            state.portamentoNoteNumber = 0;
-        }
-        if (this.isPortamento(channel, note)) {
-            const startTime = note.startTime;
-            const deltaCent = (note.noteNumber - note.portamentoNoteNumber) * 100;
-            const portamentoTime = startTime + this.getPortamentoTime(channel, note);
-            note.bufferSource.detune
-                .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(detune - deltaCent, scheduleTime)
-                .linearRampToValueAtTime(detune, portamentoTime);
-        }
-        else {
-            note.bufferSource.detune
-                .cancelScheduledValues(scheduleTime)
-                .setValueAtTime(detune, scheduleTime);
-        }
+        return channel.detune + noteDetune + pitchControl;
     }
     getPortamentoTime(channel, note) {
         const { portamentoTimeMSB, portamentoTimeLSB } = channel.state;
@@ -1340,7 +1369,7 @@ class Midy extends EventTarget {
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
-            .linearRampToValueAtTime(sustainVolume, portamentoTime);
+            .exponentialRampToValueAtTime(sustainVolume, portamentoTime);
     }
     setVolumeEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
@@ -1356,38 +1385,63 @@ class Midy extends EventTarget {
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(0, startTime)
-            .setValueAtTime(0, volDelay)
-            .linearRampToValueAtTime(attackVolume, volAttack)
+            .setValueAtTime(1e-6, volDelay)
+            .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .setTargetAtTime(sustainVolume, volHold, decayDuration * decayCurve);
     }
-    setPortamentoPitchEnvelope(note, scheduleTime) {
+    setPortamentoDetune(channel, note, scheduleTime) {
+        if (channel.portamentoControl) {
+            const state = channel.state;
+            const portamentoNoteNumber = Math.ceil(state.portamentoNoteNumber * 127);
+            note.portamentoNoteNumber = portamentoNoteNumber;
+            channel.portamentoControl = false;
+            state.portamentoNoteNumber = 0;
+        }
+        const detune = this.calcNoteDetune(channel, note);
+        const startTime = note.startTime;
+        const deltaCent = (note.noteNumber - note.portamentoNoteNumber) * 100;
+        const portamentoTime = startTime + this.getPortamentoTime(channel, note);
+        note.bufferSource.detune
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(detune - deltaCent, scheduleTime)
+            .linearRampToValueAtTime(detune, portamentoTime);
+    }
+    setDetune(channel, note, scheduleTime) {
+        const detune = this.calcNoteDetune(channel, note);
+        note.bufferSource.detune
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(detune, scheduleTime);
+        const timeConstant = this.perceptualSmoothingTime / 5; // 99.3% (5 * tau)
+        note.bufferSource.detune
+            .cancelAndHoldAtTime(scheduleTime)
+            .setTargetAtTime(detune, scheduleTime, timeConstant);
+    }
+    setPortamentoPitchEnvelope(channel, note, scheduleTime) {
         const baseRate = note.voiceParams.playbackRate;
         const portamentoTime = note.startTime +
             this.getPortamentoTime(channel, note);
         note.bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
-            .linearRampToValueAtTime(baseRate, portamentoTime);
+            .exponentialRampToValueAtTime(baseRate, portamentoTime);
     }
     setPitchEnvelope(note, scheduleTime) {
-        const { voiceParams } = note;
+        const { bufferSource, voiceParams } = note;
         const baseRate = voiceParams.playbackRate;
-        note.bufferSource.playbackRate
+        bufferSource.playbackRate
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(baseRate, note.startTime);
+            .setValueAtTime(baseRate, scheduleTime);
         const modEnvToPitch = voiceParams.modEnvToPitch;
         if (modEnvToPitch === 0)
             return;
-        const basePitch = this.rateToCent(baseRate);
-        const peekPitch = basePitch + modEnvToPitch;
-        const peekRate = this.centToRate(peekPitch);
+        const peekRate = baseRate * this.centToRate(modEnvToPitch);
         const modDelay = note.startTime + voiceParams.modDelay;
         const modAttack = modDelay + voiceParams.modAttack;
         const modHold = modAttack + voiceParams.modHold;
         const decayDuration = voiceParams.modDecay;
-        note.bufferSource.playbackRate
+        bufferSource.playbackRate
             .setValueAtTime(baseRate, modDelay)
-            .linearRampToValueAtTime(peekRate, modAttack)
+            .exponentialRampToValueAtTime(peekRate, modAttack)
             .setValueAtTime(peekRate, modHold)
             .setTargetAtTime(baseRate, modHold, decayDuration * decayCurve);
     }
@@ -1405,10 +1459,10 @@ class Midy extends EventTarget {
             this.getFilterCutoffControl(channel, note);
         const sustainCent = baseCent +
             voiceParams.modEnvToFilterFc * (1 - voiceParams.modSustain);
-        const baseFreq = this.centToHz(baseCent);
-        const sustainFreq = this.centToHz(sustainCent);
-        const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq * scale);
-        const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq * scale);
+        const baseFreq = this.centToHz(baseCent) * scale;
+        const sustainFreq = this.centToHz(sustainCent) * scale;
+        const adjustedBaseFreq = this.clampCutoffFrequency(baseFreq);
+        const adjustedSustainFreq = this.clampCutoffFrequency(sustainFreq);
         const portamentoTime = startTime + this.getPortamentoTime(channel, note);
         const modDelay = startTime + voiceParams.modDelay;
         note.adjustedBaseFreq = adjustedSustainFreq;
@@ -1416,7 +1470,7 @@ class Midy extends EventTarget {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
-            .linearRampToValueAtTime(adjustedSustainFreq, portamentoTime);
+            .exponentialRampToValueAtTime(adjustedSustainFreq, portamentoTime);
     }
     setFilterEnvelope(channel, note, scheduleTime) {
         const { voiceParams, startTime } = note;
@@ -1444,7 +1498,7 @@ class Midy extends EventTarget {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(adjustedBaseFreq, startTime)
             .setValueAtTime(adjustedBaseFreq, modDelay)
-            .linearRampToValueAtTime(adjustedPeekFreq, modAttack)
+            .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .setTargetAtTime(adjustedSustainFreq, modHold, decayDuration * decayCurve);
     }
@@ -1533,14 +1587,15 @@ class Midy extends EventTarget {
         if (!channel.isDrum && this.isPortamento(channel, note)) {
             this.setPortamentoVolumeEnvelope(channel, note, now);
             this.setPortamentoFilterEnvelope(channel, note, now);
-            this.setPortamentoPitchEnvelope(note, now);
+            this.setPortamentoPitchEnvelope(channel, note, now);
+            this.setPortamentoDetune(channel, note, now);
         }
         else {
             this.setVolumeEnvelope(channel, note, now);
             this.setFilterEnvelope(channel, note, now);
             this.setPitchEnvelope(note, now);
+            this.setDetune(channel, note, now);
         }
-        this.updateDetune(channel, note, now);
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, now);
         }
@@ -1623,6 +1678,16 @@ class Midy extends EventTarget {
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
     }
     async noteOn(channelNumber, noteNumber, velocity, startTime) {
+        if (this.mpeEnabled) {
+            const note = await this.startNote(channelNumber, noteNumber, velocity, startTime);
+            this.mpeState.channelToNote.set(channelNumber, note.index);
+            this.mpeState.noteToChannel.set(note.index, channelNumber);
+        }
+        else {
+            await this.startNote(channelNumber, noteNumber, velocity, startTime);
+        }
+    }
+    async startNote(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
         const realtime = startTime === undefined;
         if (realtime)
@@ -1649,6 +1714,7 @@ class Midy extends EventTarget {
         await this.setNoteAudioNode(channel, note, realtime);
         this.setNoteRouting(channelNumber, note, startTime);
         note.resolveReady();
+        return note;
     }
     disconnectNote(note) {
         note.bufferSource.disconnect();
@@ -1673,15 +1739,14 @@ class Midy extends EventTarget {
     releaseNote(channel, note, endTime) {
         endTime ??= this.audioContext.currentTime;
         const releaseTime = this.getRelativeKeyBasedValue(channel, note, 72) * 2;
-        const duration = note.voiceParams.volRelease * releaseTime;
-        const volRelease = endTime + duration;
-        const modRelease = endTime + note.voiceParams.modRelease;
+        const volDuration = note.voiceParams.volRelease * releaseTime;
+        const volRelease = endTime + volDuration;
         note.filterNode.frequency
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(note.adjustedBaseFreq, modRelease);
+            .setTargetAtTime(note.adjustedBaseFreq, endTime, note.voiceParams.modRelease * releaseCurve);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
-            .setTargetAtTime(0, endTime, duration * releaseCurve);
+            .setTargetAtTime(0, endTime, volDuration * releaseCurve);
         return new Promise((resolve) => {
             this.scheduleTask(() => {
                 const bufferSource = note.bufferSource;
@@ -1693,7 +1758,26 @@ class Midy extends EventTarget {
             }, volRelease);
         });
     }
-    noteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+    noteOff(channelNumber, noteNumber, velocity, endTime, force) {
+        if (this.mpeEnabled) {
+            const noteIndex = this.mpeState.channelToNote.get(channelNumber);
+            if (noteIndex === undefined)
+                return;
+            const channel = this.channels[channelNumber];
+            const note = channel.scheduledNotes[noteIndex];
+            note.ending = true;
+            const promise = note.ready.then(() => {
+                return this.releaseNote(channel, note, endTime);
+            });
+            this.mpeState.channelToNote.delete(channelNumber);
+            this.mpeState.noteToChannel.delete(noteIndex);
+            return promise;
+        }
+        else {
+            return this.stopNote(channelNumber, noteNumber, velocity, endTime, force);
+        }
+    }
+    stopNote(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1809,9 +1893,11 @@ class Midy extends EventTarget {
         this.lastActiveSensing = performance.now();
     }
     setPolyphonicKeyPressure(channelNumber, noteNumber, pressure, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        if (channel.isMPEMember)
+            return;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
         const table = channel.polyphonicKeyPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
             if (note.noteNumber === noteNumber) {
@@ -1994,13 +2080,6 @@ class Midy extends EventTarget {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(freqModLFO, scheduleTime);
     }
-    setFreqVibLFO(channel, note, scheduleTime) {
-        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
-        const freqVibLFO = note.voiceParams.freqVibLFO;
-        note.vibratoLFO.frequency
-            .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
-    }
     setDelayVibLFO(channel, note) {
         const vibratoDelay = this.getRelativeKeyBasedValue(channel, note, 78) * 2;
         const value = note.voiceParams.delayVibLFO;
@@ -2010,6 +2089,13 @@ class Midy extends EventTarget {
         }
         catch { /* empty */ }
     }
+    setFreqVibLFO(channel, note, scheduleTime) {
+        const vibratoRate = this.getRelativeKeyBasedValue(channel, note, 76) * 2;
+        const freqVibLFO = note.voiceParams.freqVibLFO;
+        note.vibratoLFO.frequency
+            .cancelScheduledValues(scheduleTime)
+            .setValueAtTime(freqVibLFO * vibratoRate, scheduleTime);
+    }
     createVoiceParamsHandlers() {
         return {
             modLfoToPitch: (channel, note, scheduleTime) => {
@@ -2063,6 +2149,14 @@ class Midy extends EventTarget {
                     this.setFreqVibLFO(channel, note, scheduleTime);
                 }
             },
+            detune: (channel, note, scheduleTime) => {
+                if (this.isPortamento(channel, note)) {
+                    this.setPortamentoDetune(channel, note, scheduleTime);
+                }
+                else {
+                    this.setDetune(channel, note, scheduleTime);
+                }
+            },
         };
     }
     getControllerState(channel, noteNumber, velocity, polyphonicKeyPressure) {
@@ -2154,6 +2248,21 @@ class Midy extends EventTarget {
         return handlers;
     }
     setControlChange(channelNumber, controllerType, value, scheduleTime) {
+        const channel = this.channels[channelNumber];
+        if (channel.isMPEMember) {
+            this.applyControlChange(channelNumber, controllerType, value, scheduleTime);
+        }
+        else if (channel.isMPEManager) {
+            channel.state[controllerType] = value / 127;
+            for (const memberChannel of this.mpeState.channelToNote.keys()) {
+                this.applyControlChange(memberChannel, controllerType, value, scheduleTime);
+            }
+        }
+        else {
+            this.applyControlChange(channelNumber, controllerType, value, scheduleTime);
+        }
+    }
+    applyControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
         if (handler) {
             handler.call(this, channelNumber, value, scheduleTime);
@@ -2200,14 +2309,14 @@ class Midy extends EventTarget {
             if (this.isPortamento(channel, note)) {
                 this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
-                this.setPortamentoPitchEnvelope(note, scheduleTime);
-                this.updateDetune(channel, note, scheduleTime);
+                this.setPortamentoPitchEnvelope(channel, note, scheduleTime);
+                this.setPortamentoDetune(channel, note, scheduleTime);
             }
             else {
                 this.setVolumeEnvelope(channel, note, scheduleTime);
                 this.setFilterEnvelope(channel, note, scheduleTime);
                 this.setPitchEnvelope(note, scheduleTime);
-                this.updateDetune(channel, note, scheduleTime);
+                this.setDetune(channel, note, scheduleTime);
             }
         });
     }
@@ -2576,6 +2685,12 @@ class Midy extends EventTarget {
                 channel.dataLSB += value;
                 this.handleModulationDepthRangeRPN(channelNumber, scheduleTime);
                 break;
+            case 6: // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp053.pdf
+                channel.dataLSB += value;
+                this.handleMIDIPolyphonicExpressionRPN(channelNumber, scheduleTime);
+                break;
+            case 16383: // NULL
+                break;
             default:
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
         }
@@ -2674,11 +2789,43 @@ class Midy extends EventTarget {
         channel.modulationDepthRange = value;
         this.updateModulation(channel, scheduleTime);
     }
+    handleMIDIPolyphonicExpressionRPN(channelNumber, _scheduleTime) {
+        this.setMIDIPolyphonicExpression(channelNumber, channel.dataMSB);
+    }
+    setMIDIPolyphonicExpression(channelNumber, value) {
+        if (channelNumber !== 0 && channelNumber !== 15)
+            return;
+        const members = value & 15;
+        if (channelNumber === 0) {
+            this.lowerMPEMembers = members;
+        }
+        else {
+            this.upperMPEMembers = members;
+        }
+        this.mpeEnabled = this.lowerMPEMembers > 0 || this.upperMPEMembers > 0;
+        const lowerStart = 1;
+        const lowerEnd = this.lowerMPEMembers;
+        const upperStart = 16 - this.upperMPEMembers;
+        const upperEnd = 14;
+        for (let i = 0; i < 16; i++) {
+            const isLower = this.lowerMPEMembers && lowerStart <= i && i <= lowerEnd;
+            const isUpper = this.upperMPEMembers && upperStart <= i && i <= upperEnd;
+            this.channels[i].isMPEMember = this.mpeEnabled && (isLower || isUpper);
+            this.channels[i].isMPEManager = this.mpeEnabled && (i === 0 || i === 15);
+        }
+    }
     setRPGMakerLoop(_channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         this.loopStart = scheduleTime + this.resumeTime - this.startTime;
     }
-    allSoundOff(channelNumber, _value, scheduleTime) {
+    allSoundOff(channelNumber, value, scheduleTime) {
+        if (this.channels[channelNumber].isMPEManager)
+            return;
+        this.applyAllSoundOff(channelNumber, value, scheduleTime);
+    }
+    applyAllSoundOff(channelNumber, _value, scheduleTime) {
+        if (this.channels[channelNumber].isMPEManager)
+            return;
         if (!(0 <= scheduleTime))
             scheduleTime = this.audioContext.currentTime;
         return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
@@ -2750,15 +2897,21 @@ class Midy extends EventTarget {
         this.allNotesOff(channelNumber, value, scheduleTime);
     }
     omniOn(channelNumber, value, scheduleTime) {
+        if (this.mpeEnabled)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
     }
     monoOn(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isMPEManager)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
         channel.mono = true;
     }
     polyOn(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
+        if (channel.isMPEManager)
+            return;
         this.allNotesOff(channelNumber, value, scheduleTime);
         channel.mono = false;
     }
@@ -2800,7 +2953,7 @@ class Midy extends EventTarget {
             scheduleTime = this.audioContext.currentTime;
         this.mode = "GM1";
         for (let i = 0; i < channels.length; i++) {
-            this.allSoundOff(i, 0, scheduleTime);
+            this.applyAllSoundOff(i, 0, scheduleTime);
             const channel = channels[i];
             channel.bankMSB = 0;
             channel.bankLSB = 0;
@@ -2815,7 +2968,7 @@ class Midy extends EventTarget {
             scheduleTime = this.audioContext.currentTime;
         this.mode = "GM2";
         for (let i = 0; i < channels.length; i++) {
-            this.allSoundOff(i, 0, scheduleTime);
+            this.applyAllSoundOff(i, 0, scheduleTime);
             const channel = channels[i];
             channel.bankMSB = 121;
             channel.bankLSB = 0;
@@ -3227,8 +3380,14 @@ class Midy extends EventTarget {
         return (channelPressure + polyphonicKeyPressure) / 254;
     }
     setEffects(channel, note, table, scheduleTime) {
-        if (0 < table[0])
-            this.updateDetune(channel, note, scheduleTime);
+        if (0 < table[0]) {
+            if (this.isPortamento(channel, note)) {
+                this.setPortamentoDetune(channel, note, scheduleTime);
+            }
+            else {
+                this.setDetune(channel, note, scheduleTime);
+            }
+        }
         if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
             if (0 < table[1]) {
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
@@ -3430,5 +3589,7 @@ Object.defineProperty(Midy, "channelSettings", {
         fineTuning: 0, // cent
         coarseTuning: 0, // cent
         portamentoControl: false,
+        isMPEMember: false,
+        isMPEManager: false,
     }
 });