@marmooo/midy 0.0.4 → 0.0.6

package/esm/midy-GMLite.js

@@ -1,5 +1,43 @@
 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
+        });
+        this.noteNumber = noteNumber;
+        this.velocity = velocity;
+        this.startTime = startTime;
+        this.instrumentKey = instrumentKey;
+    }
+}
 export class MidyGMLite {
     constructor(audioContext) {
         Object.defineProperty(this, "ticksPerBeat", {
@@ -145,20 +183,16 @@ export class MidyGMLite {
         this.totalTime = this.calcTotalTime();
     }
     setChannelAudioNodes(audioContext) {
-        const gainNode = new GainNode(audioContext, {
-            gain: MidyGMLite.channelSettings.volume,
-        });
-        const pannerNode = new StereoPannerNode(audioContext, {
-            pan: MidyGMLite.channelSettings.pan,
-        });
-        const modulationEffect = this.createModulationEffect(audioContext);
-        modulationEffect.lfo.start();
-        pannerNode.connect(gainNode);
-        gainNode.connect(this.masterGain);
+        const { gainLeft, gainRight } = this.panToGain(MidyGMLite.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);
         return {
-            gainNode,
-            pannerNode,
-            modulationEffect,
+            gainL,
+            gainR,
         };
     }
     createChannels(audioContext) {
@@ -168,16 +202,15 @@ export class MidyGMLite {
                 ...MidyGMLite.effectSettings,
                 ...this.setChannelAudioNodes(audioContext),
                 scheduledNotes: new Map(),
-                sostenutoNotes: new Map(),
             };
         });
         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);
@@ -186,26 +219,27 @@ export class MidyGMLite {
             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;
     }
@@ -243,7 +277,7 @@ export class MidyGMLite {
                     this.handleProgramChange(event.channel, event.programNumber);
                     break;
                 case "pitchBend":
-                    this.handlePitchBend(event.channel, event.value);
+                    this.setPitchBend(event.channel, event.value);
                     break;
                 case "sysEx":
                     this.handleSysEx(event.data);
@@ -323,7 +357,6 @@ export class MidyGMLite {
         const tmpChannels = new Array(16);
         for (let i = 0; i < tmpChannels.length; i++) {
             tmpChannels[i] = {
-                durationTicks: new Map(),
                 programNumber: -1,
                 bank: this.channels[i].bank,
             };
@@ -340,16 +373,6 @@ export class MidyGMLite {
                             instruments.add(`${channel.bank}:0`);
                             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 "programChange": {
@@ -363,8 +386,8 @@ export class MidyGMLite {
             });
         });
         const priority = {
-            setTempo: 0,
-            controller: 1,
+            controller: 0,
+            sysEx: 1,
         };
         timeline.sort((a, b) => {
             if (a.ticks !== b.ticks)
@@ -447,30 +470,26 @@ export class MidyGMLite {
         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];
     }
     connectNoteEffects(channel, gainNode) {
         gainNode.connect(channel.pannerNode);
@@ -482,73 +501,89 @@ export class MidyGMLite {
         return 8.176 * Math.pow(2, cent / 1200);
     }
     calcSemitoneOffset(channel) {
-        return channel.pitchBend * channel.pitchBendRange + tuning;
+        return channel.pitchBend * channel.pitchBendRange;
     }
-    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);
-        const peekFreq = this.centToHz(noteInfo.initialFilterFc + noteInfo.modEnvToFilterFc);
-        const sustainFreq = baseFreq +
-            (peekFreq - baseFreq) * (1 - noteInfo.modSustain);
+        const baseFreq = this.centToHz(instrumentKey.initialFilterFc) *
+            softPedalFactor;
+        const peekFreq = this.centToHz(instrumentKey.initialFilterFc + instrumentKey.modEnvToFilterFc) * softPedalFactor;
+        const sustainFreq = (baseFreq +
+            (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);
+    }
+    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);
         }
-        bufferSource.connect(filterNode);
-        filterNode.connect(gainNode);
-        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;
     }
     async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
@@ -558,27 +593,17 @@ export class MidyGMLite {
             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);
         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) {
@@ -598,15 +623,15 @@ export class MidyGMLite {
                 continue;
             if (targetNote.ending)
                 continue;
-            const { bufferSource, filterNode, gainNode, lfoGain, noteInfo } = targetNote;
+            const { bufferSource, filterNode, gainNode, modLFO, modLFOGain, 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);
@@ -620,8 +645,10 @@ export class MidyGMLite {
                     bufferSource.disconnect(0);
                     filterNode.disconnect(0);
                     gainNode.disconnect(0);
-                    if (lfoGain)
-                        lfoGain.disconnect(0);
+                    if (modLFOGain)
+                        modLFOGain.disconnect(0);
+                    if (modLFO)
+                        modLFO.stop();
                     resolve();
                 };
                 bufferSource.stop(volEndTime);
@@ -672,20 +699,22 @@ export class MidyGMLite {
     }
     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) {
@@ -719,21 +748,37 @@ export class MidyGMLite {
         }
     }
     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);
+            }
+        });
     }
     setVolume(channelNumber, volume) {
         const channel = this.channels[channelNumber];
         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];
@@ -743,8 +788,13 @@ export class MidyGMLite {
     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;
@@ -766,20 +816,39 @@ export class MidyGMLite {
         const { dataMSB, dataLSB } = channel;
         switch (rpn) {
             case 0:
-                channel.pitchBendRange = dataMSB + dataLSB / 100;
-                break;
+                return this.handlePitchBendRangeMessage(channelNumber, dataMSB, dataLSB);
             default:
                 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);
@@ -796,8 +865,8 @@ export class MidyGMLite {
         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);
@@ -847,9 +916,9 @@ export class MidyGMLite {
     }
     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");
         }
@@ -890,10 +959,7 @@ Object.defineProperty(MidyGMLite, "channelSettings", {
     writable: true,
     value: {
         volume: 100 / 127,
-        pan: 0,
-        vibratoRate: 5,
-        vibratoDepth: 0.5,
-        vibratoDelay: 2.5,
+        pan: 64,
         bank: 0,
         dataMSB: 0,
         dataLSB: 0,