@marmooo/midy 0.3.8 → 0.4.1

package/esm/midy.js

@@ -1,7 +1,19 @@
 import { parseMidi } from "midi-file";
 import { parse, SoundFont } from "@marmooo/soundfont-parser";
 class Note {
-    constructor(noteNumber, velocity, startTime, voice, voiceParams) {
+    constructor(noteNumber, velocity, startTime) {
+        Object.defineProperty(this, "voice", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "voiceParams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "index", {
             enumerable: true,
             configurable: true,
@@ -14,6 +26,12 @@ class Note {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -95,8 +113,6 @@ class Note {
         this.noteNumber = noteNumber;
         this.velocity = velocity;
         this.startTime = startTime;
-        this.voice = voice;
-        this.voiceParams = voiceParams;
     }
 }
 const drumExclusiveClassesByKit = new Array(57);
@@ -142,14 +158,19 @@ const defaultControllerState = {
     pitchWheelSensitivity: { type: 16, defaultValue: 2 / 128 },
     link: { type: 127, defaultValue: 0 },
     // bankMSB: { type: 128 + 0, defaultValue: 121, },
-    modulationDepth: { type: 128 + 1, defaultValue: 0 },
-    portamentoTime: { type: 128 + 5, defaultValue: 0 },
+    modulationDepthMSB: { type: 128 + 1, defaultValue: 0 },
+    portamentoTimeMSB: { type: 128 + 5, defaultValue: 0 },
     // dataMSB: { type: 128 + 6, defaultValue: 0, },
-    volume: { type: 128 + 7, defaultValue: 100 / 127 },
-    pan: { type: 128 + 10, defaultValue: 64 / 127 },
-    expression: { type: 128 + 11, defaultValue: 1 },
+    volumeMSB: { type: 128 + 7, defaultValue: 100 / 127 },
+    panMSB: { type: 128 + 10, defaultValue: 64 / 127 },
+    expressionMSB: { type: 128 + 11, defaultValue: 1 },
     // bankLSB: { type: 128 + 32, defaultValue: 0, },
+    modulationDepthLSB: { type: 128 + 33, defaultValue: 0 },
+    portamentoTimeLSB: { type: 128 + 37, defaultValue: 0 },
     // dataLSB: { type: 128 + 38, defaultValue: 0, },
+    volumeLSB: { type: 128 + 39, defaultValue: 0 },
+    panLSB: { type: 128 + 42, defaultValue: 0 },
+    expressionLSB: { type: 128 + 43, defaultValue: 0 },
     sustainPedal: { type: 128 + 64, defaultValue: 0 },
     portamento: { type: 128 + 65, defaultValue: 0 },
     sostenutoPedal: { type: 128 + 66, defaultValue: 0 },
@@ -162,6 +183,7 @@ const defaultControllerState = {
     vibratoRate: { type: 128 + 76, defaultValue: 64 / 127 },
     vibratoDepth: { type: 128 + 77, defaultValue: 64 / 127 },
     vibratoDelay: { type: 128 + 78, defaultValue: 64 / 127 },
+    portamentoNoteNumber: { type: 128 + 84, defaultValue: 0 },
     reverbSendLevel: { type: 128 + 91, defaultValue: 0 },
     chorusSendLevel: { type: 128 + 93, defaultValue: 0 },
     // dataIncrement: { type: 128 + 96, defaultValue: 0 },
@@ -353,6 +375,12 @@ export class Midy {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "realtimeVoiceCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         Object.defineProperty(this, "isPlaying", {
             enumerable: true,
             configurable: true,
@@ -539,7 +567,7 @@ export class Midy {
         return soundFontIndex * (2 ** 32) + (instrument << 16) + sampleID;
     }
     createChannelAudioNodes(audioContext) {
-        const { gainLeft, gainRight } = this.panToGain(defaultControllerState.pan.defaultValue);
+        const { gainLeft, gainRight } = this.panToGain(defaultControllerState.panMSB.defaultValue);
         const gainL = new GainNode(audioContext, { gain: gainLeft });
         const gainR = new GainNode(audioContext, { gain: gainRight });
         const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
@@ -582,10 +610,9 @@ export class Midy {
         return channels;
     }
     async createAudioBuffer(voiceParams) {
-        const sample = voiceParams.sample;
-        const sampleStart = voiceParams.start;
-        const sampleEnd = sample.data.length + voiceParams.end;
-        const audioBuffer = await sample.toAudioBuffer(this.audioContext, sampleStart, sampleEnd);
+        const { sample, start, end } = voiceParams;
+        const sampleEnd = sample.data.length + end;
+        const audioBuffer = await sample.toAudioBuffer(this.audioContext, start, sampleEnd);
         return audioBuffer;
     }
     isLoopDrum(channel, noteNumber) {
@@ -617,12 +644,10 @@ export class Midy {
             const startTime = event.startTime + schedulingOffset;
             switch (event.type) {
                 case "noteOn":
-                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime);
+                    await this.noteOn(event.channel, event.noteNumber, event.velocity, startTime);
                     break;
                 case "noteOff": {
-                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
-                    if (notePromise)
-                        this.notePromises.push(notePromise);
+                    this.noteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
                     break;
                 }
                 case "noteAftertouch":
@@ -659,6 +684,7 @@ export class Midy {
         this.exclusiveClassNotes.fill(undefined);
         this.drumExclusiveClassNotes.fill(undefined);
         this.voiceCache.clear();
+        this.realtimeVoiceCache.clear();
         for (let i = 0; i < this.channels.length; i++) {
             this.channels[i].scheduledNotes = [];
             this.resetChannelStates(i);
@@ -703,7 +729,6 @@ export class Midy {
                 finished = true;
                 break;
             }
-            queueIndex = await this.scheduleTimelineEvents(now, queueIndex);
             if (this.isPausing) {
                 await this.stopNotes(0, true, now);
                 await this.audioContext.suspend();
@@ -725,9 +750,16 @@ export class Midy {
                 this.isSeeking = false;
                 continue;
             }
+            queueIndex = await this.scheduleTimelineEvents(now, queueIndex);
             const waitTime = now + this.noteCheckInterval;
             await this.scheduleTask(() => { }, waitTime);
         }
+        if (this.timeline.length <= queueIndex) {
+            const now = this.audioContext.currentTime;
+            await this.stopNotes(0, true, now);
+            await this.audioContext.suspend();
+            finished = true;
+        }
         if (finished) {
             this.notePromises = [];
             this.resetAllStates();
@@ -833,7 +865,7 @@ export class Midy {
         const channel = this.channels[channelNumber];
         const promises = [];
         this.processActiveNotes(channel, scheduleTime, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
+            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -843,7 +875,7 @@ export class Midy {
         const channel = this.channels[channelNumber];
         const promises = [];
         this.processScheduledNotes(channel, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
+            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -876,7 +908,7 @@ export class Midy {
         if (!this.isPlaying || this.isPaused)
             return;
         const now = this.audioContext.currentTime;
-        this.resumeTime += now - this.startTime - this.startDelay;
+        this.resumeTime = now - this.startTime - this.startDelay;
         this.isPausing = true;
         await this.playPromise;
         this.isPausing = false;
@@ -902,11 +934,13 @@ export class Midy {
             if (totalTime < event.startTime)
                 totalTime = event.startTime;
         }
-        return totalTime;
+        return totalTime + this.startDelay;
     }
     currentTime() {
+        if (!this.isPlaying)
+            return this.resumeTime;
         const now = this.audioContext.currentTime;
-        return this.resumeTime + now - this.startTime - this.startDelay;
+        return now + this.resumeTime - this.startTime;
     }
     processScheduledNotes(channel, callback) {
         const scheduledNotes = channel.scheduledNotes;
@@ -1118,6 +1152,13 @@ export class Midy {
         const noteDetune = this.calcNoteDetune(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;
@@ -1134,8 +1175,10 @@ export class Midy {
         }
     }
     getPortamentoTime(channel, note) {
+        const { portamentoTimeMSB, portamentoTimeLSB } = channel.state;
+        const portamentoTime = portamentoTimeMSB + portamentoTimeLSB / 128;
         const deltaSemitone = Math.abs(note.noteNumber - note.portamentoNoteNumber);
-        const value = Math.ceil(channel.state.portamentoTime * 127);
+        const value = Math.ceil(portamentoTime * 128);
         return deltaSemitone / this.getPitchIncrementSpeed(value) / 10;
     }
     getPitchIncrementSpeed(value) {
@@ -1338,31 +1381,42 @@ export class Midy {
         note.vibratoLFO.connect(note.vibratoDepth);
         note.vibratoDepth.connect(note.bufferSource.detune);
     }
-    async getAudioBuffer(channel, noteNumber, velocity, voiceParams) {
+    async getAudioBuffer(channel, noteNumber, velocity, voiceParams, realtime) {
         const audioBufferId = this.getVoiceId(channel, noteNumber, velocity);
-        const cache = this.voiceCache.get(audioBufferId);
-        if (cache) {
-            cache.counter += 1;
-            if (cache.maxCount <= cache.counter) {
-                this.voiceCache.delete(audioBufferId);
-            }
-            return cache.audioBuffer;
-        }
-        else {
-            const maxCount = this.voiceCounter.get(audioBufferId) ?? 0;
+        if (realtime) {
+            const cachedAudioBuffer = this.realtimeVoiceCache.get(audioBufferId);
+            if (cachedAudioBuffer)
+                return cachedAudioBuffer;
             const audioBuffer = await this.createAudioBuffer(voiceParams);
-            const cache = { audioBuffer, maxCount, counter: 1 };
-            this.voiceCache.set(audioBufferId, cache);
+            this.realtimeVoiceCache.set(audioBufferId, audioBuffer);
             return audioBuffer;
         }
+        else {
+            const cache = this.voiceCache.get(audioBufferId);
+            if (cache) {
+                cache.counter += 1;
+                if (cache.maxCount <= cache.counter) {
+                    this.voiceCache.delete(audioBufferId);
+                }
+                return cache.audioBuffer;
+            }
+            else {
+                const maxCount = this.voiceCounter.get(audioBufferId) ?? 0;
+                const audioBuffer = await this.createAudioBuffer(voiceParams);
+                const cache = { audioBuffer, maxCount, counter: 1 };
+                this.voiceCache.set(audioBufferId, cache);
+                return audioBuffer;
+            }
+        }
     }
-    async createNote(channel, voice, noteNumber, velocity, startTime) {
+    async setNoteAudioNode(channel, note, realtime) {
         const now = this.audioContext.currentTime;
+        const { noteNumber, velocity, startTime } = note;
         const state = channel.state;
         const controllerState = this.getControllerState(channel, noteNumber, velocity, 0);
-        const voiceParams = voice.getAllParams(controllerState);
-        const note = new Note(noteNumber, velocity, startTime, voice, voiceParams);
-        const audioBuffer = await this.getAudioBuffer(channel, noteNumber, velocity, voiceParams);
+        const voiceParams = note.voice.getAllParams(controllerState);
+        note.voiceParams = voiceParams;
+        const audioBuffer = await this.getAudioBuffer(channel, noteNumber, velocity, voiceParams, realtime);
         note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(this.audioContext);
         const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
@@ -1388,7 +1442,7 @@ export class Midy {
         if (0 < state.vibratoDepth) {
             this.startVibrato(channel, note, now);
         }
-        if (0 < state.modulationDepth) {
+        if (0 < state.modulationDepthMSB + state.modulationDepthLSB) {
             this.startModulation(channel, note, now);
         }
         if (channel.mono && channel.currentBufferSource) {
@@ -1399,7 +1453,13 @@ export class Midy {
         note.filterNode.connect(note.volumeEnvelopeNode);
         this.setChorusSend(channel, note, now);
         this.setReverbSend(channel, note, now);
-        note.bufferSource.start(startTime);
+        if (voiceParams.sample.type === "compressed") {
+            const offset = voiceParams.start / audioBuffer.sampleRate;
+            note.bufferSource.start(startTime, offset);
+        }
+        else {
+            note.bufferSource.start(startTime);
+        }
         return note;
     }
     handleExclusiveClass(note, channelNumber, startTime) {
@@ -1410,7 +1470,7 @@ export class Midy {
         if (prev) {
             const [prevNote, prevChannelNumber] = prev;
             if (prevNote && !prevNote.ending) {
-                this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                this.noteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
                 startTime, true);
             }
         }
@@ -1430,27 +1490,14 @@ export class Midy {
             channelNumber;
         const prevNote = this.drumExclusiveClassNotes[index];
         if (prevNote && !prevNote.ending) {
-            this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
+            this.noteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
             startTime, true);
         }
         this.drumExclusiveClassNotes[index] = note;
     }
-    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
+    setNoteRouting(channelNumber, note, startTime) {
         const channel = this.channels[channelNumber];
-        const programNumber = channel.programNumber;
-        const bankTable = this.soundFontTable[programNumber];
-        if (!bankTable)
-            return;
-        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
-        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
-        const soundFontIndex = bankTable[bank];
-        if (soundFontIndex === undefined)
-            return;
-        const soundFont = this.soundFonts[soundFontIndex];
-        const voice = soundFont.getVoice(bank, programNumber, noteNumber, velocity);
-        if (!voice)
-            return;
-        const note = await this.createNote(channel, voice, noteNumber, velocity, startTime);
+        const { noteNumber, volumeEnvelopeNode } = note;
         if (channel.isDrum) {
             const { keyBasedGainLs, keyBasedGainRs } = channel;
             let gainL = keyBasedGainLs[noteNumber];
@@ -1460,25 +1507,48 @@ export class Midy {
                 gainL = keyBasedGainLs[noteNumber] = audioNodes.gainL;
                 gainR = keyBasedGainRs[noteNumber] = audioNodes.gainR;
             }
-            note.volumeEnvelopeNode.connect(gainL);
-            note.volumeEnvelopeNode.connect(gainR);
+            volumeEnvelopeNode.connect(gainL);
+            volumeEnvelopeNode.connect(gainR);
         }
         else {
-            note.volumeEnvelopeNode.connect(channel.gainL);
-            note.volumeEnvelopeNode.connect(channel.gainR);
+            volumeEnvelopeNode.connect(channel.gainL);
+            volumeEnvelopeNode.connect(channel.gainR);
         }
         if (0.5 <= channel.state.sustainPedal) {
             channel.sustainNotes.push(note);
         }
         this.handleExclusiveClass(note, channelNumber, startTime);
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
+    }
+    async noteOn(channelNumber, noteNumber, velocity, startTime) {
+        const channel = this.channels[channelNumber];
+        const realtime = startTime === undefined;
+        if (realtime)
+            startTime = this.audioContext.currentTime;
+        const note = new Note(noteNumber, velocity, startTime);
         const scheduledNotes = channel.scheduledNotes;
         note.index = scheduledNotes.length;
         scheduledNotes.push(note);
-    }
-    noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, undefined);
+        const programNumber = channel.programNumber;
+        const bankTable = this.soundFontTable[programNumber];
+        if (!bankTable)
+            return;
+        const bankLSB = channel.isDrum ? 128 : channel.bankLSB;
+        const bank = bankTable[bankLSB] !== undefined ? bankLSB : 0;
+        const soundFontIndex = bankTable[bank];
+        if (soundFontIndex === undefined)
+            return;
+        const soundFont = this.soundFonts[soundFontIndex];
+        note.voice = soundFont.getVoice(bank, programNumber, noteNumber, velocity);
+        if (!note.voice)
+            return;
+        await this.setNoteAudioNode(channel, note, realtime);
+        this.setNoteRouting(channelNumber, note, startTime);
+        note.pending = false;
+        const off = note.offEvent;
+        if (off) {
+            this.noteOff(channelNumber, noteNumber, off.velocity, off.startTime);
+        }
     }
     disconnectNote(note) {
         note.bufferSource.disconnect();
@@ -1501,6 +1571,7 @@ export class Midy {
         }
     }
     releaseNote(channel, note, endTime) {
+        endTime ??= this.audioContext.currentTime;
         const releaseTime = this.getRelativeKeyBasedValue(channel, note, 72) * 2;
         const volRelease = endTime + note.voiceParams.volRelease * releaseTime;
         const modRelease = endTime + note.voiceParams.modRelease;
@@ -1522,7 +1593,7 @@ export class Midy {
             }, stopTime);
         });
     }
-    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+    noteOff(channelNumber, noteNumber, velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         const state = channel.state;
         if (!force) {
@@ -1541,9 +1612,15 @@ export class Midy {
         if (index < 0)
             return;
         const note = channel.scheduledNotes[index];
+        if (note.pending) {
+            note.offEvent = { velocity, startTime: endTime };
+            return;
+        }
         note.ending = true;
         this.setNoteIndex(channel, index);
-        this.releaseNote(channel, note, endTime);
+        const promise = this.releaseNote(channel, note, endTime);
+        this.notePromises.push(promise);
+        return promise;
     }
     setNoteIndex(channel, index) {
         let allEnds = true;
@@ -1571,16 +1648,12 @@ export class Midy {
         }
         return -1;
     }
-    noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
-        scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false);
-    }
     releaseSustainPedal(channelNumber, halfVelocity, scheduleTime) {
         const velocity = halfVelocity * 2;
         const channel = this.channels[channelNumber];
         const promises = [];
         for (let i = 0; i < channel.sustainNotes.length; i++) {
-            const promise = this.scheduleNoteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
+            const promise = this.noteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1594,7 +1667,7 @@ export class Midy {
         channel.state.sostenutoPedal = 0;
         for (let i = 0; i < sostenutoNotes.length; i++) {
             const note = sostenutoNotes[i];
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
+            const promise = this.noteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sostenutoNotes = [];
@@ -1700,9 +1773,11 @@ export class Midy {
     }
     setModLfoToPitch(channel, note, scheduleTime) {
         if (note.modulationDepth) {
+            const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+            const modulationDepth = modulationDepthMSB + modulationDepthLSB / 128;
             const modLfoToPitch = note.voiceParams.modLfoToPitch +
                 this.getLFOPitchDepth(channel, note);
-            const baseDepth = Math.abs(modLfoToPitch) + channel.state.modulationDepth;
+            const baseDepth = Math.abs(modLfoToPitch) + modulationDepth;
             const depth = baseDepth * Math.sign(modLfoToPitch);
             note.modulationDepth.gain
                 .cancelScheduledValues(scheduleTime)
@@ -1835,7 +1910,8 @@ export class Midy {
     createVoiceParamsHandlers() {
         return {
             modLfoToPitch: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+                if (0 < modulationDepthMSB + modulationDepthLSB) {
                     this.setModLfoToPitch(channel, note, scheduleTime);
                 }
             },
@@ -1845,12 +1921,14 @@ export class Midy {
                 }
             },
             modLfoToFilterFc: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+                if (0 < modulationDepthMSB + modulationDepthLSB) {
                     this.setModLfoToFilterFc(channel, note, scheduleTime);
                 }
             },
             modLfoToVolume: (channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+                if (0 < modulationDepthMSB + modulationDepthLSB) {
                     this.setModLfoToVolume(channel, note, scheduleTime);
                 }
             },
@@ -1861,12 +1939,14 @@ export class Midy {
                 this.setReverbSend(channel, note, scheduleTime);
             },
             delayModLFO: (_channel, note, _scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+                if (0 < modulationDepthMSB + modulationDepthLSB) {
                     this.setDelayModLFO(note);
                 }
             },
             freqModLFO: (_channel, note, scheduleTime) => {
-                if (0 < channel.state.modulationDepth) {
+                const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+                if (0 < modulationDepthMSB + modulationDepthLSB) {
                     this.setFreqModLFO(note, scheduleTime);
                 }
             },
@@ -1935,7 +2015,12 @@ export class Midy {
         handlers[10] = this.setPan;
         handlers[11] = this.setExpression;
         handlers[32] = this.setBankLSB;
+        handlers[33] = this.setModulationDepth;
+        handlers[37] = this.setPortamentoTime;
         handlers[38] = this.dataEntryLSB;
+        handlers[39] = this.setVolume;
+        handlers[42] = this.setPan;
+        handlers[43] = this.setExpression;
         handlers[64] = this.setSustainPedal;
         handlers[65] = this.setPortamento;
         handlers[66] = this.setSostenutoPedal;
@@ -1948,6 +2033,7 @@ export class Midy {
         handlers[76] = this.setVibratoRate;
         handlers[77] = this.setVibratoDepth;
         handlers[78] = this.setVibratoDelay;
+        handlers[84] = this.setPortamentoNoteNumber;
         handlers[91] = this.setReverbSendLevel;
         handlers[93] = this.setChorusSendLevel;
         handlers[96] = this.dataIncrement;
@@ -1979,7 +2065,9 @@ export class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     updateModulation(channel, scheduleTime) {
-        const depth = channel.state.modulationDepth * channel.modulationDepthRange;
+        const { modulationDepthMSB, modulationDepthLSB } = channel.state;
+        const modulationDepth = modulationDepthMSB + modulationDepthLSB / 128;
+        const depth = modulationDepth * channel.modulationDepthRange;
         this.processScheduledNotes(channel, (note) => {
             if (note.modulationDepth) {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
@@ -1989,12 +2077,15 @@ export class Midy {
             }
         });
     }
-    setModulationDepth(channelNumber, modulation, scheduleTime) {
+    setModulationDepth(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.modulationDepth = modulation / 127;
+        const state = channel.state;
+        const intPart = Math.trunc(value);
+        state.modulationDepthMSB = intPart / 127;
+        state.modulationDepthLSB = value - intPart;
         this.updateModulation(channel, scheduleTime);
     }
     updatePortamento(channel, scheduleTime) {
@@ -2015,18 +2106,24 @@ export class Midy {
             }
         });
     }
-    setPortamentoTime(channelNumber, portamentoTime, scheduleTime) {
-        const channel = this.channels[channelNumber];
+    setPortamentoTime(channelNumber, value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        channel.state.portamentoTime = portamentoTime / 127;
+        const channel = this.channels[channelNumber];
+        const state = channel.state;
+        const intPart = Math.trunc(value);
+        state.portamentoTimeMSB = intPart / 127;
+        state.portamentoTimeLSB = value - 127;
         if (channel.isDrum)
             return;
         this.updatePortamento(channel, scheduleTime);
     }
-    setVolume(channelNumber, volume, scheduleTime) {
+    setVolume(channelNumber, value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.state.volume = volume / 127;
+        const state = channel.state;
+        const intPart = Math.trunc(value);
+        state.volumeMSB = intPart / 127;
+        state.volumeLSB = value - intPart;
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2037,16 +2134,19 @@ export class Midy {
         }
     }
     panToGain(pan) {
-        const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
+        const theta = Math.PI / 2 * Math.max(pan * 127 - 1) / 126;
         return {
             gainLeft: Math.cos(theta),
             gainRight: Math.sin(theta),
         };
     }
-    setPan(channelNumber, pan, scheduleTime) {
+    setPan(channelNumber, value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.state.pan = pan / 127;
+        const state = channel.state;
+        const intPart = Math.trunc(value);
+        state.panMSB = intPart / 127;
+        state.panLSB = value - intPart;
         if (channel.isDrum) {
             for (let i = 0; i < 128; i++) {
                 this.updateKeyBasedVolume(channel, i, scheduleTime);
@@ -2056,10 +2156,13 @@ export class Midy {
             this.updateChannelVolume(channel, scheduleTime);
         }
     }
-    setExpression(channelNumber, expression, scheduleTime) {
+    setExpression(channelNumber, value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.state.expression = expression / 127;
+        const state = channel.state;
+        const intPart = Math.trunc(value);
+        state.expressionMSB = intPart / 127;
+        state.expressionLSB = value - intPart;
         this.updateChannelVolume(channel, scheduleTime);
     }
     setBankLSB(channelNumber, lsb) {
@@ -2070,37 +2173,42 @@ export class Midy {
         this.handleRPN(channelNumber, 0, scheduleTime);
     }
     updateChannelVolume(channel, scheduleTime) {
-        const state = channel.state;
-        const volume = state.volume * state.expression;
-        const { gainLeft, gainRight } = this.panToGain(state.pan);
+        const { expressionMSB, expressionLSB, volumeMSB, volumeLSB, panMSB, panLSB, } = channel.state;
+        const volume = volumeMSB + volumeLSB / 128;
+        const expression = expressionMSB + expressionLSB / 128;
+        const pan = panMSB + panLSB / 128;
+        const gain = volume * expression;
+        const { gainLeft, gainRight } = this.panToGain(pan);
         channel.gainL.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volume * gainLeft, scheduleTime);
+            .setValueAtTime(gain * gainLeft, scheduleTime);
         channel.gainR.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volume * gainRight, scheduleTime);
+            .setValueAtTime(gain * gainRight, scheduleTime);
     }
     updateKeyBasedVolume(channel, keyNumber, scheduleTime) {
         const gainL = channel.keyBasedGainLs[keyNumber];
         if (!gainL)
             return;
         const gainR = channel.keyBasedGainRs[keyNumber];
-        const state = channel.state;
-        const defaultVolume = state.volume * state.expression;
-        const defaultPan = state.pan;
+        const { expressionMSB, expressionLSB, volumeMSB, volumeLSB, panMSB, panLSB, } = channel.state;
+        const volume = volumeMSB + volumeLSB / 128;
+        const expression = expressionMSB + expressionLSB / 128;
+        const defaultGain = volume * expression;
+        const defaultPan = panMSB + panLSB / 128;
         const keyBasedVolume = this.getKeyBasedValue(channel, keyNumber, 7);
-        const volume = (0 <= keyBasedVolume)
-            ? defaultVolume * keyBasedVolume / 64
-            : defaultVolume;
+        const gain = (0 <= keyBasedVolume)
+            ? defaultGain * keyBasedVolume / 64
+            : defaultGain;
         const keyBasedPan = this.getKeyBasedValue(channel, keyNumber, 10);
         const pan = (0 <= keyBasedPan) ? keyBasedPan / 127 : defaultPan;
         const { gainLeft, gainRight } = this.panToGain(pan);
         gainL.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volume * gainLeft, scheduleTime);
+            .setValueAtTime(gain * gainLeft, scheduleTime);
         gainR.gain
             .cancelScheduledValues(scheduleTime)
-            .setValueAtTime(volume * gainRight, scheduleTime);
+            .setValueAtTime(gain * gainRight, scheduleTime);
     }
     setSustainPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
@@ -2173,8 +2281,8 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         state.filterResonance = ccValue / 127;
-        const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
         this.processScheduledNotes(channel, (note) => {
+            const filterResonance = this.getRelativeKeyBasedValue(channel, note, 71);
             const Q = note.voiceParams.initialFilterQ / 5 * filterResonance;
             note.filterNode.Q.setValueAtTime(Q, scheduleTime);
         });
@@ -2274,6 +2382,12 @@ export class Midy {
             });
         }
     }
+    setPortamentoNoteNumber(channelNumber, value, scheduleTime) {
+        scheduleTime ??= this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        channel.portamentoControl = true;
+        channel.state.portamentoNoteNumber = value / 127;
+    }
     setReverbSendLevel(channelNumber, reverbSendLevel, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
@@ -2461,8 +2575,10 @@ export class Midy {
             "polyphonicKeyPressure",
             "channelPressure",
             "pitchWheel",
-            "expression",
-            "modulationDepth",
+            "expressionMSB",
+            "expressionLSB",
+            "modulationDepthMSB",
+            "modulationDepthLSB",
             "sustainPedal",
             "portamento",
             "sostenutoPedal",
@@ -3171,5 +3287,6 @@ Object.defineProperty(Midy, "channelSettings", {
         modulationDepthRange: 50, // cent
         fineTuning: 0, // cent
         coarseTuning: 0, // cent
+        portamentoControl: false,
     }
 });