@marmooo/midy 0.0.4 → 0.0.6

package/esm/midy.js

@@ -1,5 +1,55 @@
 import { parseMidi } from "./deps/cdn.jsdelivr.net/npm/midi-file@1.2.4/+esm.js";
-import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.1/+esm.js";
+import { parse, SoundFont, } from "./deps/cdn.jsdelivr.net/npm/@marmooo/soundfont-parser@0.0.2/+esm.js";
+class Note {
+    constructor(noteNumber, velocity, startTime, instrumentKey) {
+        Object.defineProperty(this, "bufferSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gainNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filterNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modLFO", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modLFOGain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vibLFO", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "vibLFOGain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.noteNumber = noteNumber;
+        this.velocity = velocity;
+        this.startTime = startTime;
+        this.instrumentKey = instrumentKey;
+    }
+}
 export class Midy {
     constructor(audioContext) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -175,25 +225,23 @@ export class Midy {
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
-        const gainNode = new GainNode(audioContext, {
-            gain: Midy.channelSettings.volume,
-        });
-        const pannerNode = new StereoPannerNode(audioContext, {
-            pan: Midy.channelSettings.pan,
-        });
-        const modulationEffect = this.createModulationEffect(audioContext);
+        const { gainLeft, gainRight } = this.panToGain(Midy.channelSettings.pan);
+        const gainL = new GainNode(audioContext, { gain: gainLeft });
+        const gainR = new GainNode(audioContext, { gain: gainRight });
+        const merger = new ChannelMergerNode(audioContext, { numberOfInputs: 2 });
+        gainL.connect(merger, 0, 0);
+        gainR.connect(merger, 0, 1);
+        merger.connect(this.masterGain);
         const reverbEffect = this.createReverbEffect(audioContext);
         const chorusEffect = this.createChorusEffect(audioContext);
-        modulationEffect.lfo.start();
         chorusEffect.lfo.start();
-        reverbEffect.dryGain.connect(pannerNode);
-        reverbEffect.wetGain.connect(pannerNode);
-        pannerNode.connect(gainNode);
-        gainNode.connect(this.masterGain);
+        reverbEffect.dryGain.connect(gainL);
+        reverbEffect.dryGain.connect(gainR);
+        reverbEffect.wetGain.connect(gainL);
+        reverbEffect.wetGain.connect(gainR);
         return {
-            gainNode,
-            pannerNode,
-            modulationEffect,
+            gainL,
+            gainR,
             reverbEffect,
             chorusEffect,
         };
@@ -216,11 +264,11 @@ export class Midy {
         });
         return channels;
     }
-    async createNoteBuffer(noteInfo, isSF3) {
-        const sampleEnd = noteInfo.sample.length + noteInfo.end;
+    async createNoteBuffer(instrumentKey, isSF3) {
+        const sampleEnd = instrumentKey.sample.length + instrumentKey.end;
         if (isSF3) {
-            const sample = new Uint8Array(noteInfo.sample.length);
-            sample.set(noteInfo.sample);
+            const sample = new Uint8Array(instrumentKey.sample.length);
+            sample.set(instrumentKey.sample);
             const audioBuffer = await this.audioContext.decodeAudioData(sample.buffer);
             for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
                 const channelData = audioBuffer.getChannelData(channel);
@@ -229,26 +277,27 @@ export class Midy {
             return audioBuffer;
         }
         else {
-            const sample = noteInfo.sample.subarray(0, sampleEnd);
+            const sample = instrumentKey.sample.subarray(0, sampleEnd);
             const floatSample = this.convertToFloat32Array(sample);
             const audioBuffer = new AudioBuffer({
                 numberOfChannels: 1,
                 length: sample.length,
-                sampleRate: noteInfo.sampleRate,
+                sampleRate: instrumentKey.sampleRate,
             });
             const channelData = audioBuffer.getChannelData(0);
             channelData.set(floatSample);
             return audioBuffer;
         }
     }
-    async createNoteBufferNode(noteInfo, isSF3) {
+    async createNoteBufferNode(instrumentKey, isSF3) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
-        const audioBuffer = await this.createNoteBuffer(noteInfo, isSF3);
+        const audioBuffer = await this.createNoteBuffer(instrumentKey, isSF3);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = noteInfo.sampleModes % 2 !== 0;
+        bufferSource.loop = instrumentKey.sampleModes % 2 !== 0;
         if (bufferSource.loop) {
-            bufferSource.loopStart = noteInfo.loopStart / noteInfo.sampleRate;
-            bufferSource.loopEnd = noteInfo.loopEnd / noteInfo.sampleRate;
+            bufferSource.loopStart = instrumentKey.loopStart /
+                instrumentKey.sampleRate;
+            bufferSource.loopEnd = instrumentKey.loopEnd / instrumentKey.sampleRate;
         }
         return bufferSource;
     }
@@ -292,7 +341,7 @@ export class Midy {
                     this.handleChannelPressure(event.channel, event.amount);
                     break;
                 case "pitchBend":
-                    this.handlePitchBend(event.channel, event.value);
+                    this.setPitchBend(event.channel, event.value);
                     break;
                 case "sysEx":
                     this.handleSysEx(event.data);
@@ -372,7 +421,6 @@ export class Midy {
         const tmpChannels = new Array(16);
         for (let i = 0; i < tmpChannels.length; i++) {
             tmpChannels[i] = {
-                durationTicks: new Map(),
                 programNumber: -1,
                 bankMSB: this.channels[i].bankMSB,
                 bankLSB: this.channels[i].bankLSB,
@@ -402,16 +450,6 @@ export class Midy {
                             }
                             channel.programNumber = 0;
                         }
-                        channel.durationTicks.set(event.noteNumber, {
-                            ticks: event.ticks,
-                            noteOn: event,
-                        });
-                        break;
-                    }
-                    case "noteOff": {
-                        const { ticks, noteOn } = tmpChannels[event.channel].durationTicks
-                            .get(event.noteNumber);
-                        noteOn.durationTicks = event.ticks - ticks;
                         break;
                     }
                     case "controller":
@@ -446,8 +484,8 @@ export class Midy {
             });
         });
         const priority = {
-            setTempo: 0,
-            controller: 1,
+            controller: 0,
+            sysEx: 1,
         };
         timeline.sort((a, b) => {
             if (a.ticks !== b.ticks)
@@ -530,30 +568,26 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    getActiveNotes(channel) {
+    getActiveNotes(channel, time) {
         const activeNotes = new Map();
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, time);
             if (activeNote) {
                 activeNotes.set(activeNote.noteNumber, activeNote);
             }
         });
         return activeNotes;
     }
-    getActiveChannelNotes(scheduledNotes) {
-        for (let i = 0; i < scheduledNotes; i++) {
-            const scheduledNote = scheduledNotes[i];
-            if (scheduledNote)
-                return scheduledNote;
+    getActiveNote(noteList, time) {
+        for (let i = noteList.length - 1; i >= 0; i--) {
+            const note = noteList[i];
+            if (!note)
+                return;
+            if (time < note.startTime)
+                continue;
+            return (note.ending) ? null : note;
         }
-    }
-    createModulationEffect(audioContext) {
-        const lfo = new OscillatorNode(audioContext, {
-            frequency: 5,
-        });
-        return {
-            lfo,
-        };
+        return noteList[0];
     }
     createReverbEffect(audioContext, options = {}) {
         const { decay = 0.8, preDecay = 0, } = options;
@@ -589,12 +623,8 @@ export class Midy {
     }
     createChorusEffect(audioContext, options = {}) {
         const { chorusCount = 2, chorusRate = 0.6, chorusDepth = 0.15, delay = 0.01, variance = delay * 0.1, } = options;
-        const lfo = new OscillatorNode(audioContext, {
-            frequency: chorusRate,
-        });
-        const lfoGain = new GainNode(audioContext, {
-            gain: chorusDepth,
-        });
+        const lfo = new OscillatorNode(audioContext, { frequency: chorusRate });
+        const lfoGain = new GainNode(audioContext, { gain: chorusDepth });
         const chorusGains = [];
         const delayNodes = [];
         const baseGain = 1 / chorusCount;
@@ -605,9 +635,7 @@ export class Midy {
                 maxDelayTime: delayTime,
             });
             delayNodes.push(delayNode);
-            const chorusGain = new GainNode(audioContext, {
-                gain: baseGain,
-            });
+            const chorusGain = new GainNode(audioContext, { gain: baseGain });
             chorusGains.push(chorusGain);
             lfo.connect(lfoGain);
             lfoGain.connect(delayNode.delayTime);
@@ -663,77 +691,108 @@ export class Midy {
         const tuning = masterTuning + channelTuning;
         return channel.pitchBend * channel.pitchBendRange + tuning;
     }
-    calcPlaybackRate(noteInfo, noteNumber, semitoneOffset) {
-        return noteInfo.playbackRate(noteNumber) * Math.pow(2, semitoneOffset / 12);
+    calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset) {
+        return instrumentKey.playbackRate(noteNumber) *
+            Math.pow(2, semitoneOffset / 12);
     }
-    async createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3) {
-        const bufferSource = await this.createNoteBufferNode(noteInfo, isSF3);
-        const semitoneOffset = this.calcSemitoneOffset(channel);
-        bufferSource.playbackRate.value = this.calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
-        // volume envelope
-        const gainNode = new GainNode(this.audioContext, {
-            gain: 0,
-        });
+    setVolumeEnvelope(channel, note) {
+        const { instrumentKey, startTime, velocity } = note;
+        note.gainNode = new GainNode(this.audioContext, { gain: 0 });
         let volume = (velocity / 127) * channel.volume * channel.expression;
         if (volume === 0)
             volume = 1e-6; // exponentialRampToValueAtTime() requires a non-zero value
-        const attackVolume = this.cbToRatio(-noteInfo.initialAttenuation) * volume;
-        const sustainVolume = attackVolume * (1 - noteInfo.volSustain);
-        const volDelay = startTime + noteInfo.volDelay;
-        const volAttack = volDelay + noteInfo.volAttack;
-        const volHold = volAttack + noteInfo.volHold;
-        const volDecay = volHold + noteInfo.volDecay;
-        gainNode.gain
+        const attackVolume = this.cbToRatio(-instrumentKey.initialAttenuation) *
+            volume;
+        const sustainVolume = attackVolume * (1 - instrumentKey.volSustain);
+        const volDelay = startTime + instrumentKey.volDelay;
+        const volAttack = volDelay + instrumentKey.volAttack;
+        const volHold = volAttack + instrumentKey.volHold;
+        const volDecay = volHold + instrumentKey.volDecay;
+        note.gainNode.gain
             .setValueAtTime(1e-6, volDelay) // exponentialRampToValueAtTime() requires a non-zero value
             .exponentialRampToValueAtTime(attackVolume, volAttack)
             .setValueAtTime(attackVolume, volHold)
             .linearRampToValueAtTime(sustainVolume, volDecay);
-        // filter envelope
+    }
+    setFilterEnvelope(channel, note) {
+        const { instrumentKey, startTime, noteNumber } = note;
         const softPedalFactor = 1 -
             (0.1 + (noteNumber / 127) * 0.2) * channel.softPedal;
         const maxFreq = this.audioContext.sampleRate / 2;
-        const baseFreq = this.centToHz(noteInfo.initialFilterFc) * softPedalFactor;
-        const peekFreq = this.centToHz(noteInfo.initialFilterFc + noteInfo.modEnvToFilterFc) * softPedalFactor;
+        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            softPedalFactor;
+        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
         const sustainFreq = (baseFreq +
-            (peekFreq - baseFreq) * (1 - noteInfo.modSustain)) * softPedalFactor;
+            (peekFreq - baseFreq) * (1 - instrumentKey.modSustain)) * softPedalFactor;
+        const modDelay = startTime + instrumentKey.modDelay;
+        const modAttack = modDelay + instrumentKey.modAttack;
+        const modHold = modAttack + instrumentKey.modHold;
+        const modDecay = modHold + instrumentKey.modDecay;
         const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
         const adjustedPeekFreq = Math.min(maxFreq, peekFreq);
         const adjustedSustainFreq = Math.min(maxFreq, sustainFreq);
-        const filterNode = new BiquadFilterNode(this.audioContext, {
+        note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
-            Q: noteInfo.initialFilterQ / 10, // dB
+            Q: instrumentKey.initialFilterQ / 10, // dB
             frequency: adjustedBaseFreq,
         });
-        const modDelay = startTime + noteInfo.modDelay;
-        const modAttack = modDelay + noteInfo.modAttack;
-        const modHold = modAttack + noteInfo.modHold;
-        const modDecay = modHold + noteInfo.modDecay;
-        filterNode.frequency
+        note.filterNode.frequency
             .setValueAtTime(adjustedBaseFreq, modDelay)
             .exponentialRampToValueAtTime(adjustedPeekFreq, modAttack)
             .setValueAtTime(adjustedPeekFreq, modHold)
             .linearRampToValueAtTime(adjustedSustainFreq, modDecay);
-        let lfoGain;
+        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modEnvToPitch, modDelay);
+    }
+    startModulation(channel, note, time) {
+        const { instrumentKey } = note;
+        note.modLFOGain = new GainNode(this.audioContext, {
+            gain: this.cbToRatio(instrumentKey.modLfoToVolume) * channel.modulation,
+        });
+        note.modLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqModLFO),
+        });
+        note.modLFO.start(time);
+        note.filterNode.frequency.setValueAtTime(note.filterNode.frequency.value + instrumentKey.modLfoToFilterFc, time);
+        note.bufferSource.detune.setValueAtTime(note.bufferSource.detune.value + instrumentKey.modLfoToPitch, time);
+        note.modLFO.connect(note.modLFOGain);
+        note.modLFOGain.connect(note.bufferSource.detune);
+    }
+    startVibrato(channel, note, time) {
+        const { instrumentKey } = note;
+        note.vibLFOGain = new GainNode(this.audioContext, {
+            gain: channel.vibratoDepth,
+        });
+        note.vibLFO = new OscillatorNode(this.audioContext, {
+            frequency: this.centToHz(instrumentKey.freqModLFO) +
+                channel.vibratoRate,
+        });
+        note.vibLFO.start(time + channel.vibratoDelay);
+        note.vibLFO.connect(note.vibLFOGain);
+        note.vibLFOGain.connect(note.bufferSource.detune);
+    }
+    async createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3) {
+        const semitoneOffset = this.calcSemitoneOffset(channel);
+        const note = new Note(noteNumber, velocity, startTime, instrumentKey);
+        note.bufferSource = await this.createNoteBufferNode(instrumentKey, isSF3);
+        note.bufferSource.playbackRate.value = this.calcPlaybackRate(instrumentKey, noteNumber, semitoneOffset);
+        this.setVolumeEnvelope(channel, note);
+        this.setFilterEnvelope(channel, note);
         if (channel.modulation > 0) {
-            const vibratoDelay = startTime + channel.vibratoDelay;
-            const vibratoAttack = vibratoDelay + 0.1;
-            lfoGain = new GainNode(this.audioContext, {
-                gain: 0,
-            });
-            lfoGain.gain
-                .setValueAtTime(1e-6, vibratoDelay) // exponentialRampToValueAtTime() requires a non-zero value
-                .exponentialRampToValueAtTime(channel.modulation, vibratoAttack);
-            channel.modulationEffect.lfo.connect(lfoGain);
-            lfoGain.connect(bufferSource.detune);
+            const delayModLFO = startTime + instrumentKey.delayModLFO;
+            this.startModulation(channel, note, delayModLFO);
+        }
+        if (channel.vibratoDepth > 0) {
+            const delayVibLFO = startTime + instrumentKey.delayVibLFO;
+            this.startVibrato(channel, note, delayVibLFO);
         }
-        bufferSource.connect(filterNode);
-        filterNode.connect(gainNode);
         if (this.mono && channel.currentBufferSource) {
             channel.currentBufferSource.stop(startTime);
-            channel.currentBufferSource = bufferSource;
+            channel.currentBufferSource = note.bufferSource;
         }
-        bufferSource.start(startTime, noteInfo.start / noteInfo.sampleRate);
-        return { bufferSource, gainNode, filterNode, lfoGain };
+        note.bufferSource.connect(note.filterNode);
+        note.filterNode.connect(note.gainNode);
+        note.bufferSource.start(startTime, instrumentKey.start / instrumentKey.sampleRate);
+        return note;
     }
     calcBank(channel, channelNumber) {
         if (channel.bankMSB === 121) {
@@ -752,36 +811,20 @@ export class Midy {
             return;
         const soundFont = this.soundFonts[soundFontIndex];
         const isSF3 = soundFont.parsed.info.version.major === 3;
-        const noteInfo = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
-        if (!noteInfo)
+        const instrumentKey = soundFont.getInstrumentKey(bankNumber, channel.program, noteNumber);
+        if (!instrumentKey)
             return;
-        const { bufferSource, gainNode, filterNode, lfoGain } = await this
-            .createNoteAudioChain(channel, noteInfo, noteNumber, velocity, startTime, isSF3);
-        this.connectNoteEffects(channel, gainNode);
+        const note = await this.createNote(channel, instrumentKey, noteNumber, velocity, startTime, isSF3);
+        this.connectNoteEffects(channel, note.gainNode);
         if (channel.sostenutoPedal) {
-            channel.sostenutoNotes.set(noteNumber, {
-                gainNode,
-                filterNode,
-                bufferSource,
-                noteNumber,
-                noteInfo,
-            });
+            channel.sostenutoNotes.set(noteNumber, note);
         }
         const scheduledNotes = channel.scheduledNotes;
-        const scheduledNote = {
-            bufferSource,
-            filterNode,
-            gainNode,
-            lfoGain,
-            noteInfo,
-            noteNumber,
-            startTime,
-        };
         if (scheduledNotes.has(noteNumber)) {
-            scheduledNotes.get(noteNumber).push(scheduledNote);
+            scheduledNotes.get(noteNumber).push(note);
         }
         else {
-            scheduledNotes.set(noteNumber, [scheduledNote]);
+            scheduledNotes.set(noteNumber, [note]);
         }
     }
     noteOn(channelNumber, noteNumber, velocity) {
@@ -803,15 +846,15 @@ export class Midy {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, modLFO, modLFOGain, vibLFO, vibLFOGain, instrumentKey, } = targetNote;
             const velocityRate = (velocity + 127) / 127;
-            const volEndTime = stopTime + noteInfo.volRelease * velocityRate;
+            const volEndTime = stopTime + instrumentKey.volRelease * velocityRate;
             gainNode.gain.cancelScheduledValues(stopTime);
             gainNode.gain.linearRampToValueAtTime(0, volEndTime);
             const maxFreq = this.audioContext.sampleRate / 2;
-            const baseFreq = this.centToHz(noteInfo.initialFilterFc);
+            const baseFreq = this.centToHz(instrumentKey.initialFilterFc);
             const adjustedBaseFreq = Math.min(maxFreq, baseFreq);
-            const modEndTime = stopTime + noteInfo.modRelease * velocityRate;
+            const modEndTime = stopTime + instrumentKey.modRelease * velocityRate;
             filterNode.frequency
                 .cancelScheduledValues(stopTime)
                 .linearRampToValueAtTime(adjustedBaseFreq, modEndTime);
@@ -825,8 +868,14 @@ export class Midy {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
-                    if (lfoGain)
-                        lfoGain.disconnect(0);
+                    if (modLFOGain)
+                        modLFOGain.disconnect(0);
+                    if (vibLFOGain)
+                        vibLFOGain.disconnect(0);
+                    if (modLFO)
+                        modLFO.stop();
+                    if (vibLFO)
+                        vibLFO.stop();
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -892,7 +941,7 @@ export class Midy {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         pressure /= 64;
-        const activeNotes = this.getActiveNotes(channel);
+        const activeNotes = this.getActiveNotes(channel, now);
         if (channel.polyphonicKeyPressure.amplitudeControl !== 1) {
             if (activeNotes.has(noteNumber)) {
                 const activeNote = activeNotes.get(noteNumber);
@@ -913,7 +962,7 @@ export class Midy {
         const channel = this.channels[channelNumber];
         pressure /= 64;
         channel.channelPressure = pressure;
-        const activeNotes = this.getActiveNotes(channel);
+        const activeNotes = this.getActiveNotes(channel, now);
         if (channel.channelPressure.amplitudeControl !== 1) {
             activeNotes.forEach((activeNote) => {
                 const gain = activeNote.gainNode.gain.value;
@@ -925,20 +974,22 @@ export class Midy {
     }
     handlePitchBendMessage(channelNumber, lsb, msb) {
         const pitchBend = msb * 128 + lsb;
-        this.handlePitchBend(channelNumber, pitchBend);
+        this.setPitchBend(channelNumber, pitchBend);
     }
-    handlePitchBend(channelNumber, pitchBend) {
+    setPitchBend(channelNumber, pitchBend) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
+        const prevPitchBend = channel.pitchBend;
         channel.pitchBend = (pitchBend - 8192) / 8192;
-        const semitoneOffset = this.calcSemitoneOffset(channel);
-        const activeNotes = this.getActiveNotes(channel);
+        const detuneChange = (channel.pitchBend - prevPitchBend) *
+            channel.pitchBendRange * 100;
+        const activeNotes = this.getActiveNotes(channel, now);
         activeNotes.forEach((activeNote) => {
-            const { bufferSource, noteInfo, noteNumber } = activeNote;
-            const playbackRate = calcPlaybackRate(noteInfo, noteNumber, semitoneOffset);
-            bufferSource.playbackRate
+            const { bufferSource } = activeNote;
+            const detune = bufferSource.detune.value + detuneChange;
+            bufferSource.detune
                 .cancelScheduledValues(now)
-                .setValueAtTime(playbackRate * pressure, now);
+                .setValueAtTime(detune, now);
         });
     }
     handleControlChange(channelNumber, controller, value) {
@@ -1010,9 +1061,20 @@ export class Midy {
         this.channels[channelNumber].bankMSB = msb;
     }
     setModulation(channelNumber, modulation) {
+        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.modulation = (modulation / 127) *
             (channel.modulationDepthRange * 100);
+        const activeNotes = this.getActiveNotes(channel, now);
+        activeNotes.forEach((activeNote) => {
+            if (activeNote.modLFO) {
+                activeNote.gainNode.gain.setValueAtTime(this.cbToRatio(activeNote.instrumentKey.modLfoToVolume) *
+                    channel.modulation, now);
+            }
+            else {
+                this.startModulation(channel, activeNote, now);
+            }
+        });
     }
     setPortamentoTime(channelNumber, portamentoTime) {
         this.channels[channelNumber].portamentoTime = portamentoTime / 127;
@@ -1022,12 +1084,17 @@ export class Midy {
         channel.volume = volume / 127;
         this.updateChannelGain(channel);
     }
+    panToGain(pan) {
+        const theta = Math.PI / 2 * Math.max(0, pan - 1) / 126;
+        return {
+            gainLeft: Math.cos(theta),
+            gainRight: Math.sin(theta),
+        };
+    }
     setPan(channelNumber, pan) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
-        channel.pan = pan / 127 * 2 - 1; // -1 (left) - +1 (right)
-        channel.pannerNode.pan.cancelScheduledValues(now);
-        channel.pannerNode.pan.setValueAtTime(channel.pan, now);
+        channel.pan = pan;
+        this.updateChannelGain(channel);
     }
     setExpression(channelNumber, expression) {
         const channel = this.channels[channelNumber];
@@ -1040,8 +1107,13 @@ export class Midy {
     updateChannelGain(channel) {
         const now = this.audioContext.currentTime;
         const volume = channel.volume * channel.expression;
-        channel.gainNode.gain.cancelScheduledValues(now);
-        channel.gainNode.gain.setValueAtTime(volume, now);
+        const { gainLeft, gainRight } = this.panToGain(channel.pan);
+        channel.gainL.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(volume * gainLeft, now);
+        channel.gainR.gain
+            .cancelScheduledValues(now)
+            .setValueAtTime(volume * gainRight, now);
     }
     setSustainPedal(channelNumber, value) {
         const isOn = value >= 64;
@@ -1073,7 +1145,8 @@ export class Midy {
         const channel = this.channels[channelNumber];
         channel.sostenutoPedal = isOn;
         if (isOn) {
-            const activeNotes = this.getActiveNotes(channel);
+            const now = this.audioContext.currentTime;
+            const activeNotes = this.getActiveNotes(channel, now);
             channel.sostenutoNotes = new Map(activeNotes);
         }
         else {
@@ -1085,20 +1158,12 @@ export class Midy {
         channel.softPedal = softPedal / 127;
     }
     setVibratoRate(channelNumber, vibratoRate) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoRate = vibratoRate / 127 * 4 + 3; // 3-7Hz
-        channel.modulationEffect.lfo.frequency
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.vibratoRate, now);
     }
     setVibratoDepth(channelNumber, vibratoDepth) {
-        const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.vibratoDepth = vibratoDepth / 127;
-        channel.modulationEffect.lfoGain.gain
-            .cancelScheduledValues(now)
-            .setValueAtTime(channel.vibratoDepth, now);
     }
     setVibratoDelay(channelNumber, vibratoDelay) {
         // Access Virus: 0-10sec
@@ -1158,8 +1223,7 @@ export class Midy {
         const { dataMSB, dataLSB } = channel;
         switch (rpn) {
             case 0:
-                channel.pitchBendRange = dataMSB + dataLSB / 100;
-                break;
+                return this.handlePitchBendRangeMessage(channelNumber, dataMSB, dataLSB);
             case 1:
                 channel.fineTuning = (dataMSB * 128 + dataLSB - 8192) / 8192;
                 break;
@@ -1173,14 +1237,34 @@ export class Midy {
                 console.warn(`Channel ${channelNumber}: Unsupported RPN MSB=${channel.rpnMSB} LSB=${channel.rpnLSB}`);
         }
     }
+    handlePitchBendRangeMessage(channelNumber, dataMSB, dataLSB) {
+        const pitchBendRange = dataMSB + dataLSB / 100;
+        this.setPitchBendRange(channelNumber, pitchBendRange);
+    }
+    setPitchBendRange(channelNumber, pitchBendRange) {
+        const now = this.audioContext.currentTime;
+        const channel = this.channels[channelNumber];
+        const prevPitchBendRange = channel.pitchBendRange;
+        channel.pitchBendRange = pitchBendRange;
+        const detuneChange = (channel.pitchBendRange - prevPitchBendRange) *
+            channel.pitchBend * 100;
+        const activeNotes = this.getActiveNotes(channel, now);
+        activeNotes.forEach((activeNote) => {
+            const { bufferSource } = activeNote;
+            const detune = bufferSource.detune.value + detuneChange;
+            bufferSource.detune
+                .cancelScheduledValues(now)
+                .setValueAtTime(detune, now);
+        });
+    }
     allSoundOff(channelNumber) {
         const now = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const velocity = 0;
         const stopPedal = true;
         const promises = [];
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, now);
             if (activeNote) {
                 const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
                 promises.push(notePromise);
@@ -1197,8 +1281,8 @@ export class Midy {
         const velocity = 0;
         const stopPedal = false;
         const promises = [];
-        channel.scheduledNotes.forEach((scheduledNotes) => {
-            const activeNote = this.getActiveChannelNotes(scheduledNotes);
+        channel.scheduledNotes.forEach((noteList) => {
+            const activeNote = this.getActiveNote(noteList, now);
             if (activeNote) {
                 const notePromise = this.scheduleNoteRelease(channelNumber, noteNumber, velocity, now, stopPedal);
                 promises.push(notePromise);
@@ -1263,9 +1347,9 @@ export class Midy {
                     case 1:
                         return this.handleMasterVolumeSysEx(data);
                     case 3:
-                        return this.handleMasterFineTuning(data);
+                        return this.handleMasterFineTuningSysEx(data);
                     case 4:
-                        return this.handleMasterCoarseTuning(data);
+                        return this.handleMasterCoarseTuningSysEx(data);
                     // case 5: // TODO: Global Parameter Control
                     default:
                         console.warn(`Unsupported Exclusive Message ${data}`);
@@ -1307,9 +1391,9 @@ export class Midy {
     }
     handleMasterVolumeSysEx(data) {
         const volume = (data[5] * 128 + data[4]) / 16383;
-        this.handleMasterVolume(volume);
+        this.setMasterVolume(volume);
     }
-    handleMasterVolume(volume) {
+    setMasterVolume(volume) {
         if (volume < 0 && 1 < volume) {
             console.error("Master Volume is out of range");
         }
@@ -1321,9 +1405,9 @@ export class Midy {
     }
     handleMasterFineTuningSysEx(data) {
         const fineTuning = (data[5] * 128 + data[4] - 8192) / 8192;
-        this.handleMasterFineTuning(fineTuning);
+        this.setMasterFineTuning(fineTuning);
     }
-    handleMasterFineTuning(fineTuning) {
+    setMasterFineTuning(fineTuning) {
         if (fineTuning < -1 && 1 < fineTuning) {
             console.error("Master Fine Tuning value is out of range");
         }
@@ -1333,9 +1417,9 @@ export class Midy {
     }
     handleMasterCoarseTuningSysEx(data) {
         const coarseTuning = data[4];
-        this.handleMasterCoarseTuning(coarseTuning);
+        this.setMasterCoarseTuning(coarseTuning);
     }
-    handleMasterCoarseTuning(coarseTuning) {
+    setMasterCoarseTuning(coarseTuning) {
         if (coarseTuning < 0 && 127 < coarseTuning) {
             console.error("Master Coarse Tuning value is out of range");
         }
@@ -1375,7 +1459,7 @@ Object.defineProperty(Midy, "channelSettings", {
     value: {
         currentBufferSource: null,
         volume: 100 / 127,
-        pan: 0,
+        pan: 64,
         portamentoTime: 0,
         reverb: 0,
         chorus: 0,