@marmooo/midy 0.3.2 → 0.3.4

package/esm/midy.js

@@ -8,11 +8,11 @@ class Note {
             writable: true,
             value: -1
         });
-        Object.defineProperty(this, "noteOffEvent", {
+        Object.defineProperty(this, "ending", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
@@ -44,24 +44,6 @@ class Note {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "volumeNode", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "gainL", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "gainR", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "modulationLFO", {
             enumerable: true,
             configurable: true,
@@ -214,6 +196,16 @@ class ControllerState {
         }
     }
 }
+const volumeEnvelopeKeys = [
+    "volDelay",
+    "volAttack",
+    "volHold",
+    "volDecay",
+    "volSustain",
+    "volRelease",
+    "initialAttenuation",
+];
+const volumeEnvelopeKeySet = new Set(volumeEnvelopeKeys);
 const filterEnvelopeKeys = [
     "modEnvToPitch",
     "initialFilterFc",
@@ -223,22 +215,20 @@ const filterEnvelopeKeys = [
     "modHold",
     "modDecay",
     "modSustain",
-    "modRelease",
-    "playbackRate",
 ];
 const filterEnvelopeKeySet = new Set(filterEnvelopeKeys);
-const volumeEnvelopeKeys = [
-    "volDelay",
-    "volAttack",
-    "volHold",
-    "volDecay",
-    "volSustain",
-    "volRelease",
-    "initialAttenuation",
+const pitchEnvelopeKeys = [
+    "modEnvToPitch",
+    "modDelay",
+    "modAttack",
+    "modHold",
+    "modDecay",
+    "modSustain",
+    "playbackRate",
 ];
-const volumeEnvelopeKeySet = new Set(volumeEnvelopeKeys);
+const pitchEnvelopeKeySet = new Set(pitchEnvelopeKeys);
 export class Midy {
-    constructor(audioContext, options = this.defaultOptions) {
+    constructor(audioContext) {
         Object.defineProperty(this, "mode", {
             enumerable: true,
             configurable: true,
@@ -262,6 +252,7 @@ export class Midy {
             configurable: true,
             writable: true,
             value: {
+                algorithm: "SchroederReverb",
                 time: this.getReverbTime(64),
                 feedback: 0.8,
             }
@@ -410,30 +401,7 @@ export class Midy {
             writable: true,
             value: new Array(this.numChannels * drumExclusiveClassCount)
         });
-        Object.defineProperty(this, "defaultOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                reverbAlgorithm: (audioContext) => {
-                    const { time: rt60, feedback } = this.reverb;
-                    // const delay = this.calcDelay(rt60, feedback);
-                    // const impulse = this.createConvolutionReverbImpulse(
-                    //   audioContext,
-                    //   rt60,
-                    //   delay,
-                    // );
-                    // return this.createConvolutionReverb(audioContext, impulse);
-                    const combFeedbacks = this.generateDistributedArray(feedback, 4);
-                    const combDelays = combFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
-                    const allpassFeedbacks = this.generateDistributedArray(feedback, 4);
-                    const allpassDelays = allpassFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
-                    return this.createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays);
-                },
-            }
-        });
         this.audioContext = audioContext;
-        this.options = { ...this.defaultOptions, ...options };
         this.masterVolume = new GainNode(audioContext);
         this.scheduler = new GainNode(audioContext, { gain: 0 });
         this.schedulerBuffer = new AudioBuffer({
@@ -443,7 +411,7 @@ export class Midy {
         this.voiceParamsHandlers = this.createVoiceParamsHandlers();
         this.controlChangeHandlers = this.createControlChangeHandlers();
         this.channels = this.createChannels(audioContext);
-        this.reverbEffect = this.options.reverbAlgorithm(audioContext);
+        this.reverbEffect = this.createReverbEffect(audioContext);
         this.chorusEffect = this.createChorusEffect(audioContext);
         this.chorusEffect.output.connect(this.masterVolume);
         this.reverbEffect.output.connect(this.masterVolume);
@@ -470,24 +438,44 @@ export class Midy {
             }
         }
     }
-    async loadSoundFont(soundFontUrl) {
-        const response = await fetch(soundFontUrl);
-        const arrayBuffer = await response.arrayBuffer();
-        const parsed = parse(new Uint8Array(arrayBuffer));
+    async loadSoundFont(input) {
+        let uint8Array;
+        if (typeof input === "string") {
+            const response = await fetch(input);
+            const arrayBuffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(arrayBuffer);
+        }
+        else if (input instanceof Uint8Array) {
+            uint8Array = input;
+        }
+        else {
+            throw new TypeError("input must be a URL string or Uint8Array");
+        }
+        const parsed = parse(uint8Array);
         const soundFont = new SoundFont(parsed);
         this.addSoundFont(soundFont);
     }
-    async loadMIDI(midiUrl) {
-        const response = await fetch(midiUrl);
-        const arrayBuffer = await response.arrayBuffer();
-        const midi = parseMidi(new Uint8Array(arrayBuffer));
+    async loadMIDI(input) {
+        let uint8Array;
+        if (typeof input === "string") {
+            const response = await fetch(input);
+            const arrayBuffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(arrayBuffer);
+        }
+        else if (input instanceof Uint8Array) {
+            uint8Array = input;
+        }
+        else {
+            throw new TypeError("input must be a URL string or Uint8Array");
+        }
+        const midi = parseMidi(uint8Array);
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
         this.timeline = midiData.timeline;
         this.totalTime = this.calcTotalTime();
     }
-    setChannelAudioNodes(audioContext) {
+    createChannelAudioNodes(audioContext) {
         const { gainLeft, gainRight } = this.panToGain(defaultControllerState.pan.defaultValue);
         const gainL = new GainNode(audioContext, { gain: gainLeft });
         const gainR = new GainNode(audioContext, { gain: gainRight });
@@ -502,11 +490,11 @@ export class Midy {
         };
     }
     resetChannelTable(channel) {
-        this.resetControlTable(channel.controlTable);
+        channel.controlTable.fill(-1);
         channel.scaleOctaveTuningTable.fill(0); // [-100, 100] cent
-        channel.channelPressureTable.set([64, 64, 64, 0, 0, 0]);
-        channel.polyphonicKeyPressureTable.set([64, 64, 64, 0, 0, 0]);
-        channel.keyBasedInstrumentControlTable.fill(0); // [-64, 63]
+        channel.channelPressureTable.fill(-1);
+        channel.polyphonicKeyPressureTable.fill(-1);
+        channel.keyBasedInstrumentControlTable.fill(-1);
     }
     createChannels(audioContext) {
         const channels = Array.from({ length: this.numChannels }, () => {
@@ -515,15 +503,17 @@ export class Midy {
                 isDrum: false,
                 state: new ControllerState(),
                 ...this.constructor.channelSettings,
-                ...this.setChannelAudioNodes(audioContext),
+                ...this.createChannelAudioNodes(audioContext),
                 scheduledNotes: [],
                 sustainNotes: [],
                 sostenutoNotes: [],
                 controlTable: this.initControlTable(),
                 scaleOctaveTuningTable: new Float32Array(12), // [-100, 100] cent
-                channelPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
-                polyphonicKeyPressureTable: new Uint8Array([64, 64, 64, 0, 0, 0]),
-                keyBasedInstrumentControlTable: new Int8Array(128 * 128), // [-64, 63]
+                channelPressureTable: new Int8Array(6).fill(-1),
+                polyphonicKeyPressureTable: new Int8Array(6).fill(-1),
+                keyBasedInstrumentControlTable: new Int8Array(128 * 128).fill(-1),
+                keyBasedGainLs: new Array(128),
+                keyBasedGainRs: new Array(128),
             };
         });
         return channels;
@@ -557,10 +547,17 @@ export class Midy {
             return audioBuffer;
         }
     }
-    createBufferSource(voiceParams, audioBuffer) {
+    isLoopDrum(channel, noteNumber) {
+        const programNumber = channel.programNumber;
+        return ((programNumber === 48 && noteNumber === 88) ||
+            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84));
+    }
+    createBufferSource(channel, noteNumber, voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
-        bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
+        bufferSource.loop = channel.isDrum
+            ? this.isLoopDrum(channel, noteNumber)
+            : (voiceParams.sampleModes % 2 !== 0);
         if (bufferSource.loop) {
             bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
             bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
@@ -575,12 +572,13 @@ export class Midy {
             const delay = this.startDelay - resumeTime;
             const startTime = event.startTime + delay;
             switch (event.type) {
-                case "noteOn": {
-                    const noteOffEvent = {
-                        ...event.noteOffEvent,
-                        startTime: event.noteOffEvent.startTime + delay,
-                    };
-                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, noteOffEvent);
+                case "noteOn":
+                    await this.scheduleNoteOn(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);
                     break;
                 }
                 case "noteAftertouch":
@@ -688,6 +686,7 @@ export class Midy {
         return `${programNumber}:${noteNumber}:${velocity}`;
     }
     extractMidiData(midi) {
+        this.audioBufferCounter.clear();
         const instruments = new Set();
         const timeline = [];
         const tmpChannels = new Array(this.channels.length);
@@ -787,38 +786,13 @@ export class Midy {
                 prevTempoTicks = event.ticks;
             }
         }
-        const activeNotes = new Array(this.channels.length * 128);
-        for (let i = 0; i < activeNotes.length; i++) {
-            activeNotes[i] = [];
-        }
-        for (let i = 0; i < timeline.length; i++) {
-            const event = timeline[i];
-            switch (event.type) {
-                case "noteOn": {
-                    const index = event.channel * 128 + event.noteNumber;
-                    activeNotes[index].push(event);
-                    break;
-                }
-                case "noteOff": {
-                    const index = event.channel * 128 + event.noteNumber;
-                    const noteOn = activeNotes[index].pop();
-                    if (noteOn) {
-                        noteOn.noteOffEvent = event;
-                    }
-                    else {
-                        const eventString = JSON.stringify(event, null, 2);
-                        console.warn(`noteOff without matching noteOn: ${eventString}`);
-                    }
-                }
-            }
-        }
         return { instruments, timeline };
     }
     stopActiveNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
         this.processActiveNotes(channel, scheduleTime, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -827,8 +801,8 @@ export class Midy {
     stopChannelNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
-        this.processScheduledNotes(channel, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime, force);
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -886,7 +860,7 @@ export class Midy {
         const now = this.audioContext.currentTime;
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
-    processScheduledNotes(channel, callback) {
+    processScheduledNotes(channel, scheduleTime, callback) {
         const scheduledNotes = channel.scheduledNotes;
         for (let i = 0; i < scheduledNotes.length; i++) {
             const note = scheduledNotes[i];
@@ -894,6 +868,8 @@ export class Midy {
                 continue;
             if (note.ending)
                 continue;
+            if (note.startTime < scheduleTime)
+                continue;
             callback(note);
         }
     }
@@ -905,11 +881,8 @@ export class Midy {
                 continue;
             if (note.ending)
                 continue;
-            const noteOffEvent = note.noteOffEvent;
-            if (noteOffEvent && noteOffEvent.startTime < scheduleTime)
-                continue;
             if (scheduleTime < note.startTime)
-                continue;
+                break;
             callback(note);
         }
     }
@@ -998,6 +971,22 @@ export class Midy {
         const output = allpasses.at(-1);
         return { input, output };
     }
+    createReverbEffect(audioContext) {
+        const { algorithm, time: rt60, feedback } = this.reverb;
+        switch (algorithm) {
+            case "ConvolutionReverb": {
+                const impulse = this.createConvolutionReverbImpulse(audioContext, rt60, this.calcDelay(rt60, feedback));
+                return this.createConvolutionReverb(audioContext, impulse);
+            }
+            case "SchroederReverb": {
+                const combFeedbacks = this.generateDistributedArray(feedback, 4);
+                const combDelays = combFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
+                const allpassFeedbacks = this.generateDistributedArray(feedback, 4);
+                const allpassDelays = allpassFeedbacks.map((feedback) => this.calcDelay(rt60, feedback));
+                return this.createSchroederReverb(audioContext, combFeedbacks, combDelays, allpassFeedbacks, allpassDelays);
+            }
+        }
+    }
     createChorusEffect(audioContext) {
         const input = new GainNode(audioContext);
         const output = new GainNode(audioContext);
@@ -1062,15 +1051,22 @@ export class Midy {
         const pitchWheel = channel.state.pitchWheel * 2 - 1;
         const pitchWheelSensitivity = channel.state.pitchWheelSensitivity * 12800;
         const pitch = pitchWheel * pitchWheelSensitivity;
-        const pressureDepth = (channel.channelPressureTable[0] - 64) / 37.5; // 2400 / 64;
-        const pressure = pressureDepth * channel.state.channelPressure;
-        return tuning + pitch + pressure;
+        const channelPressureRaw = channel.channelPressureTable[0];
+        if (0 <= channelPressureRaw) {
+            const channelPressureDepth = (channelPressureRaw - 64) / 37.5; // 2400 / 64;
+            const channelPressure = channelPressureDepth *
+                channel.state.channelPressure;
+            return tuning + pitch + channelPressure;
+        }
+        else {
+            return tuning + pitch;
+        }
     }
     calcNoteDetune(channel, note) {
         return channel.scaleOctaveTuningTable[note.noteNumber % 12];
     }
     updateChannelDetune(channel, scheduleTime) {
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             this.updateDetune(channel, note, scheduleTime);
         });
     }
@@ -1220,9 +1216,8 @@ export class Midy {
     }
     setPortamentoFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
-        const { voiceParams, noteNumber, startTime } = note;
-        const softPedalFactor = 1 -
-            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const { voiceParams, startTime } = note;
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor *
@@ -1242,9 +1237,8 @@ export class Midy {
     }
     setFilterEnvelope(channel, note, scheduleTime) {
         const state = channel.state;
-        const { voiceParams, noteNumber, startTime } = note;
-        const softPedalFactor = 1 -
-            (0.1 + (noteNumber / 127) * 0.2) * state.softPedal;
+        const { voiceParams, startTime } = note;
+        const softPedalFactor = this.getSoftPedalFactor(channel, note);
         const baseCent = voiceParams.initialFilterFc +
             this.getFilterCutoffControl(channel, note);
         const baseFreq = this.centToHz(baseCent) * softPedalFactor *
@@ -1321,14 +1315,11 @@ export class Midy {
     async createNote(channel, voice, noteNumber, velocity, startTime, isSF3) {
         const now = this.audioContext.currentTime;
         const state = channel.state;
-        const controllerState = this.getControllerState(channel, noteNumber, velocity);
+        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.programNumber, noteNumber, velocity, voiceParams, isSF3);
-        note.bufferSource = this.createBufferSource(voiceParams, audioBuffer);
-        note.volumeNode = new GainNode(this.audioContext);
-        note.gainL = new GainNode(this.audioContext);
-        note.gainR = new GainNode(this.audioContext);
+        note.bufferSource = this.createBufferSource(channel, noteNumber, voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(this.audioContext);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
@@ -1361,13 +1352,10 @@ export class Midy {
         }
         note.bufferSource.connect(note.filterNode);
         note.filterNode.connect(note.volumeEnvelopeNode);
-        note.volumeEnvelopeNode.connect(note.volumeNode);
-        note.volumeNode.connect(note.gainL);
-        note.volumeNode.connect(note.gainR);
-        if (0 < channel.chorusSendLevel) {
+        if (0 < state.chorusSendLevel) {
             this.setChorusEffectsSend(channel, note, 0, now);
         }
-        if (0 < channel.reverbSendLevel) {
+        if (0 < state.reverbSendLevel) {
             this.setReverbEffectsSend(channel, note, 0, now);
         }
         note.bufferSource.start(startTime);
@@ -1397,7 +1385,7 @@ export class Midy {
         if (prev) {
             const [prevNote, prevChannelNumber] = prev;
             if (prevNote && !prevNote.ending) {
-                this.scheduleNoteOff(prevChannelNumber, prevNote, 0, // velocity,
+                this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
                 startTime, true);
             }
         }
@@ -1417,19 +1405,12 @@ export class Midy {
             channelNumber;
         const prevNote = this.drumExclusiveClassNotes[index];
         if (prevNote && !prevNote.ending) {
-            this.scheduleNoteOff(channelNumber, prevNote, 0, // velocity,
+            this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
             startTime, true);
         }
         this.drumExclusiveClassNotes[index] = note;
     }
-    isDrumNoteOffException(channel, noteNumber) {
-        if (!channel.isDrum)
-            return false;
-        const programNumber = channel.programNumber;
-        return !((programNumber === 48 && noteNumber === 88) ||
-            (programNumber === 56 && 47 <= noteNumber && noteNumber <= 84));
-    }
-    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, noteOffEvent) {
+    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
         const channel = this.channels[channelNumber];
         const bankNumber = this.calcBank(channel, channelNumber);
         const soundFontIndex = this.soundFontTable[channel.programNumber].get(bankNumber);
@@ -1441,9 +1422,18 @@ export class Midy {
             return;
         const isSF3 = soundFont.parsed.info.version.major === 3;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, isSF3);
-        note.noteOffEvent = noteOffEvent;
-        note.gainL.connect(channel.gainL);
-        note.gainR.connect(channel.gainR);
+        if (channel.isDrum) {
+            const audioContext = this.audioContext;
+            const { gainL, gainR } = this.createChannelAudioNodes(audioContext);
+            channel.keyBasedGainLs[noteNumber] = gainL;
+            channel.keyBasedGainRs[noteNumber] = gainR;
+            note.volumeEnvelopeNode.connect(gainL);
+            note.volumeEnvelopeNode.connect(gainR);
+        }
+        else {
+            note.volumeEnvelopeNode.connect(channel.gainL);
+            note.volumeEnvelopeNode.connect(channel.gainR);
+        }
         if (0.5 <= channel.state.sustainPedal) {
             channel.sustainNotes.push(note);
         }
@@ -1452,31 +1442,6 @@ export class Midy {
         const scheduledNotes = channel.scheduledNotes;
         note.index = scheduledNotes.length;
         scheduledNotes.push(note);
-        if (this.isDrumNoteOffException(channel, noteNumber)) {
-            const stopTime = startTime + note.bufferSource.buffer.duration;
-            const promise = new Promise((resolve) => {
-                note.bufferSource.onended = () => {
-                    scheduledNotes[note.index] = undefined;
-                    this.disconnectNote(note);
-                    resolve();
-                };
-                note.bufferSource.stop(stopTime);
-            });
-            this.notePromises.push(promise);
-        }
-        else if (noteOffEvent) {
-            if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
-                const portamentoTime = this.getPortamentoTime(channel, note);
-                const portamentoEndTime = startTime + portamentoTime;
-                const notePromise = this.scheduleNoteOff(channelNumber, note, 0, // velocity
-                Math.max(noteOffEvent.startTime, portamentoEndTime), false);
-                this.notePromises.push(notePromise);
-            }
-            else {
-                const notePromise = this.scheduleNoteOff(channelNumber, note, noteOffEvent.velocity, noteOffEvent.startTime, false);
-                this.notePromises.push(notePromise);
-            }
-        }
     }
     noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
@@ -1486,9 +1451,6 @@ export class Midy {
         note.bufferSource.disconnect();
         note.filterNode.disconnect();
         note.volumeEnvelopeNode.disconnect();
-        note.volumeNode.disconnect();
-        note.gainL.disconnect();
-        note.gainR.disconnect();
         if (note.modulationDepth) {
             note.volumeDepth.disconnect();
             note.modulationDepth.disconnect();
@@ -1505,42 +1467,48 @@ export class Midy {
             note.chorusEffectsSend.disconnect();
         }
     }
-    stopNote(channel, note, endTime, stopTime) {
+    releaseNote(channel, note, endTime) {
+        const volRelease = endTime +
+            note.voiceParams.volRelease * channel.state.releaseTime * 2;
+        const modRelease = endTime + note.voiceParams.modRelease;
+        const stopTime = Math.min(volRelease, modRelease);
+        note.filterNode.frequency
+            .cancelScheduledValues(endTime)
+            .linearRampToValueAtTime(0, modRelease);
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, stopTime);
-        note.ending = true;
-        this.scheduleTask(() => {
-            note.bufferSource.loop = false;
-        }, stopTime);
+            .linearRampToValueAtTime(0, volRelease);
         return new Promise((resolve) => {
-            note.bufferSource.onended = () => {
-                channel.scheduledNotes[note.index] = undefined;
+            this.scheduleTask(() => {
+                const bufferSource = note.bufferSource;
+                bufferSource.loop = false;
+                bufferSource.stop(stopTime);
                 this.disconnectNote(note);
+                channel.scheduledNotes[note.index] = undefined;
                 resolve();
-            };
-            note.bufferSource.stop(stopTime);
+            }, stopTime);
         });
     }
-    scheduleNoteOff(channelNumber, note, _velocity, endTime, force) {
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
-        if (this.isDrumNoteOffException(channel, note.noteNumber))
-            return;
         const state = channel.state;
         if (!force) {
-            if (0.5 <= state.sustainPedal)
-                return;
-            if (0.5 <= channel.state.sostenutoPedal)
-                return;
+            if (channel.isDrum) {
+                if (!this.isLoopDrum(channel, noteNumber))
+                    return;
+            }
+            else {
+                if (0.5 <= state.sustainPedal)
+                    return;
+                if (0.5 <= state.sostenutoPedal)
+                    return;
+            }
         }
-        const volRelease = endTime +
-            note.voiceParams.volRelease * channel.state.releaseTime * 2;
-        const modRelease = endTime + note.voiceParams.modRelease;
-        note.filterNode.frequency
-            .cancelScheduledValues(endTime)
-            .linearRampToValueAtTime(0, modRelease);
-        const stopTime = Math.min(volRelease, modRelease);
-        return this.stopNote(channel, note, endTime, stopTime);
+        const note = this.findNoteOffTarget(channel, noteNumber);
+        if (!note)
+            return;
+        note.ending = true;
+        this.releaseNote(channel, note, endTime);
     }
     findNoteOffTarget(channel, noteNumber) {
         const scheduledNotes = channel.scheduledNotes;
@@ -1557,16 +1525,14 @@ export class Midy {
     }
     noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        const channel = this.channels[channelNumber];
-        const note = this.findNoteOffTarget(channel, noteNumber);
-        return this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime, false);
+        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], velocity, scheduleTime);
+            const promise = this.scheduleNoteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1580,7 +1546,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, velocity, scheduleTime);
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sostenutoNotes = [];
@@ -1610,10 +1576,10 @@ export class Midy {
     }
     handlePolyphonicKeyPressure(channelNumber, noteNumber, pressure, scheduleTime) {
         const channel = this.channels[channelNumber];
-        channel.state.polyphonicKeyPressure = pressure / 127;
         const table = channel.polyphonicKeyPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
             if (note.noteNumber === noteNumber) {
+                note.pressure = pressure;
                 this.setControllerParameters(channel, note, table);
             }
         });
@@ -1641,9 +1607,10 @@ export class Midy {
         const prev = channel.state.channelPressure;
         const next = value / 127;
         channel.state.channelPressure = next;
-        if (channel.channelPressureTable[0] !== 64) {
-            const pressureDepth = (channel.channelPressureTable[0] - 64) / 37.5; // 2400 / 64;
-            channel.detune += pressureDepth * (next - prev);
+        const channelPressureRaw = channel.channelPressureTable[0];
+        if (0 <= channelPressureRaw) {
+            const channelPressureDepth = (channelPressureRaw - 64) / 37.5; // 2400 / 64;
+            channel.detune += channelPressureDepth * (next - prev);
         }
         const table = channel.channelPressureTable;
         this.processActiveNotes(channel, scheduleTime, (note) => {
@@ -1703,10 +1670,15 @@ export class Midy {
             .setValueAtTime(volumeDepth, scheduleTime);
     }
     setReverbEffectsSend(channel, note, prevValue, scheduleTime) {
+        let value = note.voiceParams.reverbEffectsSend;
+        if (channel.isDrum) {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
+            if (0 <= keyBasedValue) {
+                value *= keyBasedValue / 127 / channel.state.reverbSendLevel;
+            }
+        }
         if (0 < prevValue) {
-            if (0 < note.voiceParams.reverbEffectsSend) {
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 91);
-                const value = note.voiceParams.reverbEffectsSend + keyBasedValue;
+            if (0 < value) {
                 note.reverbEffectsSend.gain
                     .cancelScheduledValues(scheduleTime)
                     .setValueAtTime(value, scheduleTime);
@@ -1716,22 +1688,27 @@ export class Midy {
             }
         }
         else {
-            if (0 < note.voiceParams.reverbEffectsSend) {
+            if (0 < value) {
                 if (!note.reverbEffectsSend) {
                     note.reverbEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.reverbEffectsSend,
+                        gain: value,
                     });
-                    note.volumeNode.connect(note.reverbEffectsSend);
+                    note.volumeEnvelopeNode.connect(note.reverbEffectsSend);
                 }
                 note.reverbEffectsSend.connect(this.reverbEffect.input);
             }
         }
     }
     setChorusEffectsSend(channel, note, prevValue, scheduleTime) {
+        let value = note.voiceParams.chorusEffectsSend;
+        if (channel.isDrum) {
+            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
+            if (0 <= keyBasedValue) {
+                value *= keyBasedValue / 127 / channel.state.chorusSendLevel;
+            }
+        }
         if (0 < prevValue) {
-            if (0 < note.voiceParams.chorusEffectsSend) {
-                const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 93);
-                const value = note.voiceParams.chorusEffectsSend + keyBasedValue;
+            if (0 < vaule) {
                 note.chorusEffectsSend.gain
                     .cancelScheduledValues(scheduleTime)
                     .setValueAtTime(value, scheduleTime);
@@ -1741,12 +1718,12 @@ export class Midy {
             }
         }
         else {
-            if (0 < note.voiceParams.chorusEffectsSend) {
+            if (0 < value) {
                 if (!note.chorusEffectsSend) {
                     note.chorusEffectsSend = new GainNode(this.audioContext, {
-                        gain: note.voiceParams.chorusEffectsSend,
+                        gain: value,
                     });
-                    note.volumeNode.connect(note.chorusEffectsSend);
+                    note.volumeEnvelopeNode.connect(note.chorusEffectsSend);
                 }
                 note.chorusEffectsSend.connect(this.chorusEffect.input);
             }
@@ -1821,21 +1798,22 @@ export class Midy {
             },
         };
     }
-    getControllerState(channel, noteNumber, velocity) {
+    getControllerState(channel, noteNumber, velocity, polyphonicKeyPressure) {
         const state = new Float32Array(channel.state.array.length);
         state.set(channel.state.array);
         state[2] = velocity / 127;
         state[3] = noteNumber / 127;
-        state[10] = state.polyphonicKeyPressure / 127;
+        state[10] = polyphonicKeyPressure / 127;
         state[13] = state.channelPressure / 127;
         return state;
     }
     applyVoiceParams(channel, controllerType, scheduleTime) {
-        this.processScheduledNotes(channel, (note) => {
-            const controllerState = this.getControllerState(channel, note.noteNumber, note.velocity);
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
+            const controllerState = this.getControllerState(channel, note.noteNumber, note.velocity, note.pressure);
             const voiceParams = note.voice.getParams(controllerType, controllerState);
-            let appliedFilterEnvelope = false;
-            let appliedVolumeEnvelope = false;
+            let applyVolumeEnvelope = false;
+            let applyFilterEnvelope = false;
+            let applyPitchEnvelope = false;
             for (const [key, value] of Object.entries(voiceParams)) {
                 const prevValue = note.voiceParams[key];
                 if (value === prevValue)
@@ -1844,37 +1822,23 @@ export class Midy {
                 if (key in this.voiceParamsHandlers) {
                     this.voiceParamsHandlers[key](channel, note, prevValue, scheduleTime);
                 }
-                else if (filterEnvelopeKeySet.has(key)) {
-                    if (appliedFilterEnvelope)
-                        continue;
-                    appliedFilterEnvelope = true;
-                    const noteVoiceParams = note.voiceParams;
-                    for (let i = 0; i < filterEnvelopeKeys.length; i++) {
-                        const key = filterEnvelopeKeys[i];
-                        if (key in voiceParams)
-                            noteVoiceParams[key] = voiceParams[key];
-                    }
-                    if (0.5 <= channel.state.portamento && 0 <= note.portamentoNoteNumber) {
-                        this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
-                    }
-                    else {
-                        this.setFilterEnvelope(channel, note, scheduleTime);
-                    }
-                    this.setPitchEnvelope(note, scheduleTime);
-                }
-                else if (volumeEnvelopeKeySet.has(key)) {
-                    if (appliedVolumeEnvelope)
-                        continue;
-                    appliedVolumeEnvelope = true;
-                    const noteVoiceParams = note.voiceParams;
-                    for (let i = 0; i < volumeEnvelopeKeys.length; i++) {
-                        const key = volumeEnvelopeKeys[i];
-                        if (key in voiceParams)
-                            noteVoiceParams[key] = voiceParams[key];
-                    }
-                    this.setVolumeEnvelope(channel, note, scheduleTime);
+                else {
+                    if (volumeEnvelopeKeySet.has(key))
+                        applyVolumeEnvelope = true;
+                    if (filterEnvelopeKeySet.has(key))
+                        applyFilterEnvelope = true;
+                    if (pitchEnvelopeKeySet.has(key))
+                        applyPitchEnvelope = true;
                 }
             }
+            if (applyVolumeEnvelope) {
+                this.setVolumeEnvelope(channel, note, scheduleTime);
+            }
+            if (applyFilterEnvelope) {
+                this.setFilterEnvelope(channel, note, scheduleTime);
+            }
+            if (applyPitchEnvelope)
+                this.setPitchEnvelope(note, scheduleTime);
         });
     }
     createControlChangeHandlers() {
@@ -1921,7 +1885,7 @@ export class Midy {
             handler.call(this, channelNumber, value, scheduleTime);
             const channel = this.channels[channelNumber];
             this.applyVoiceParams(channel, controllerType + 128, scheduleTime);
-            this.applyControlTable(channel, controllerType);
+            this.applyControlTable(channel, controllerType, scheduleTime);
         }
         else {
             console.warn(`Unsupported Control change: controllerType=${controllerType} value=${value}`);
@@ -1932,7 +1896,7 @@ export class Midy {
     }
     updateModulation(channel, scheduleTime) {
         const depth = channel.state.modulationDepth * channel.modulationDepthRange;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             if (note.modulationDepth) {
                 note.modulationDepth.gain.setValueAtTime(depth, scheduleTime);
             }
@@ -1951,7 +1915,7 @@ export class Midy {
         this.updateModulation(channel, scheduleTime);
     }
     updatePortamento(channel, scheduleTime) {
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             if (0.5 <= channel.state.portamento) {
                 if (0 <= note.portamentoNoteNumber) {
                     this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
@@ -1978,22 +1942,12 @@ export class Midy {
             return;
         this.updatePortamento(channel, scheduleTime);
     }
-    setKeyBasedVolume(channel, scheduleTime) {
-        this.processScheduledNotes(channel, (note) => {
-            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 7);
-            if (keyBasedValue !== 0) {
-                note.volumeNode.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(1 + keyBasedValue, scheduleTime);
-            }
-        });
-    }
     setVolume(channelNumber, volume, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.volume = volume / 127;
         this.updateChannelVolume(channel, scheduleTime);
-        this.setKeyBasedVolume(channel, scheduleTime);
+        this.updateKeyBasedVolume(channel, scheduleTime);
     }
     panToGain(pan) {
         const theta = Math.PI / 2 * Math.max(0, pan * 127 - 1) / 126;
@@ -2002,26 +1956,12 @@ export class Midy {
             gainRight: Math.sin(theta),
         };
     }
-    setKeyBasedPan(channel, scheduleTime) {
-        this.processScheduledNotes(channel, (note) => {
-            const keyBasedValue = this.getKeyBasedInstrumentControlValue(channel, note.noteNumber, 10);
-            if (keyBasedValue !== 0) {
-                const { gainLeft, gainRight } = this.panToGain((keyBasedValue + 1) / 2);
-                note.gainL.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(gainLeft, scheduleTime);
-                note.gainR.gain
-                    .cancelScheduledValues(scheduleTime)
-                    .setValueAtTime(gainRight, scheduleTime);
-            }
-        });
-    }
     setPan(channelNumber, pan, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         channel.state.pan = pan / 127;
         this.updateChannelVolume(channel, scheduleTime);
-        this.setKeyBasedPan(channel, scheduleTime);
+        this.updateKeyBasedVolume(channel, scheduleTime);
     }
     setExpression(channelNumber, expression, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
@@ -2047,6 +1987,34 @@ export class Midy {
             .cancelScheduledValues(scheduleTime)
             .setValueAtTime(volume * gainRight, scheduleTime);
     }
+    updateKeyBasedVolume(channel, scheduleTime) {
+        if (!channel.isDrum)
+            return;
+        const state = channel.state;
+        const defaultVolume = state.volume * state.expression;
+        const defaultPan = state.pan;
+        for (let i = 0; i < 128; i++) {
+            const gainL = channel.keyBasedGainLs[i];
+            const gainR = channel.keyBasedGainLs[i];
+            if (!gainL)
+                continue;
+            if (!gainR)
+                continue;
+            const keyBasedVolume = this.getKeyBasedInstrumentControlValue(channel, i, 7);
+            const volume = (0 <= keyBasedVolume)
+                ? defaultVolume * keyBasedVolume / 64
+                : defaultVolume;
+            const keyBasedPan = this.getKeyBasedInstrumentControlValue(channel, i, 10);
+            const pan = (0 <= keyBasedPan) ? keyBasedPan / 127 : defaultPan;
+            const { gainLeft, gainRight } = this.panToGain(pan);
+            gainL.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(volume * gainLeft, scheduleTime);
+            gainR.gain
+                .cancelScheduledValues(scheduleTime)
+                .setValueAtTime(volume * gainRight, scheduleTime);
+        }
+    }
     setSustainPedal(channelNumber, value, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2054,7 +2022,7 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.sustainPedal = value / 127;
         if (64 <= value) {
-            this.processScheduledNotes(channel, (note) => {
+            this.processScheduledNotes(channel, scheduleTime, (note) => {
                 channel.sustainNotes.push(note);
             });
         }
@@ -2087,6 +2055,9 @@ export class Midy {
             this.releaseSostenutoPedal(channelNumber, value, scheduleTime);
         }
     }
+    getSoftPedalFactor(channel, note) {
+        return 1 - (0.1 + (note.noteNumber / 127) * 0.2) * channel.state.softPedal;
+    }
     setSoftPedal(channelNumber, softPedal, scheduleTime) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
@@ -2094,7 +2065,7 @@ export class Midy {
         const state = channel.state;
         scheduleTime ??= this.audioContext.currentTime;
         state.softPedal = softPedal / 127;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             if (0.5 <= state.portamento && 0 <= note.portamentoNoteNumber) {
                 this.setPortamentoVolumeEnvelope(channel, note, scheduleTime);
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
@@ -2112,7 +2083,7 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         const state = channel.state;
         state.filterResonance = filterResonance / 127;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             const Q = note.voiceParams.initialFilterQ / 5 * state.filterResonance;
             note.filterNode.Q.setValueAtTime(Q, scheduleTime);
         });
@@ -2130,7 +2101,7 @@ export class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.attackTime = attackTime / 127;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             if (note.startTime < scheduleTime)
                 return false;
             this.setVolumeEnvelope(channel, note);
@@ -2143,7 +2114,7 @@ export class Midy {
         const state = channel.state;
         scheduleTime ??= this.audioContext.currentTime;
         state.brightness = brightness / 127;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             if (0.5 <= state.portamento && 0 <= note.portamentoNoteNumber) {
                 this.setPortamentoFilterEnvelope(channel, note, scheduleTime);
             }
@@ -2158,7 +2129,7 @@ export class Midy {
             return;
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.decayTime = dacayTime / 127;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             this.setVolumeEnvelope(channel, note, scheduleTime);
         });
     }
@@ -2170,7 +2141,7 @@ export class Midy {
         channel.state.vibratoRate = vibratoRate / 127;
         if (channel.vibratoDepth <= 0)
             return;
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             this.setVibLfoToPitch(channel, note, scheduleTime);
         });
     }
@@ -2182,12 +2153,12 @@ export class Midy {
         const prev = channel.state.vibratoDepth;
         channel.state.vibratoDepth = vibratoDepth / 127;
         if (0 < prev) {
-            this.processScheduledNotes(channel, (note) => {
+            this.processScheduledNotes(channel, scheduleTime, (note) => {
                 this.setFreqVibLFO(channel, note, scheduleTime);
             });
         }
         else {
-            this.processScheduledNotes(channel, (note) => {
+            this.processScheduledNotes(channel, scheduleTime, (note) => {
                 this.startVibrato(channel, note, scheduleTime);
             });
         }
@@ -2199,7 +2170,7 @@ export class Midy {
         scheduleTime ??= this.audioContext.currentTime;
         channel.state.vibratoDelay = vibratoDelay / 127;
         if (0 < channel.state.vibratoDepth) {
-            this.processScheduledNotes(channel, (note) => {
+            this.processScheduledNotes(channel, scheduleTime, (note) => {
                 this.startVibrato(channel, note, scheduleTime);
             });
         }
@@ -2217,16 +2188,17 @@ export class Midy {
                     .setValueAtTime(state.reverbSendLevel, scheduleTime);
             }
             else {
-                this.processScheduledNotes(channel, (note) => {
+                this.processScheduledNotes(channel, scheduleTime, (note) => {
                     if (note.voiceParams.reverbEffectsSend <= 0)
                         return false;
-                    note.reverbEffectsSend.disconnect();
+                    if (note.reverbEffectsSend)
+                        note.reverbEffectsSend.disconnect();
                 });
             }
         }
         else {
             if (0 < reverbSendLevel) {
-                this.processScheduledNotes(channel, (note) => {
+                this.processScheduledNotes(channel, scheduleTime, (note) => {
                     this.setReverbEffectsSend(channel, note, 0, scheduleTime);
                 });
                 state.reverbSendLevel = reverbSendLevel / 127;
@@ -2249,16 +2221,17 @@ export class Midy {
                     .setValueAtTime(state.chorusSendLevel, scheduleTime);
             }
             else {
-                this.processScheduledNotes(channel, (note) => {
+                this.processScheduledNotes(channel, scheduleTime, (note) => {
                     if (note.voiceParams.chorusEffectsSend <= 0)
                         return false;
-                    note.chorusEffectsSend.disconnect();
+                    if (note.chorusEffectsSend)
+                        note.chorusEffectsSend.disconnect();
                 });
             }
         }
         else {
             if (0 < chorusSendLevel) {
-                this.processScheduledNotes(channel, (note) => {
+                this.processScheduledNotes(channel, scheduleTime, (note) => {
                     this.setChorusEffectsSend(channel, note, 0, scheduleTime);
                 });
                 state.chorusSendLevel = chorusSendLevel / 127;
@@ -2673,8 +2646,7 @@ export class Midy {
     setReverbType(type) {
         this.reverb.time = this.getReverbTimeFromType(type);
         this.reverb.feedback = (type === 8) ? 0.9 : 0.8;
-        const { audioContext, options } = this;
-        this.reverbEffect = options.reverbAlgorithm(audioContext);
+        this.reverbEffect = this.createReverbEffect(this.audioContext);
     }
     getReverbTimeFromType(type) {
         switch (type) {
@@ -2696,8 +2668,7 @@ export class Midy {
     }
     setReverbTime(value) {
         this.reverb.time = this.getReverbTime(value);
-        const { audioContext, options } = this;
-        this.reverbEffect = options.reverbAlgorithm(audioContext);
+        this.reverbEffect = this.createReverbEffect(this.audioContext);
     }
     getReverbTime(value) {
         return Math.exp((value - 40) * 0.025);
@@ -2892,65 +2863,88 @@ export class Midy {
         }
     }
     getPitchControl(channel, note) {
-        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[0] - 64) *
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[0];
+        if (polyphonicKeyPressureRaw < 0)
+            return 0;
+        const polyphonicKeyPressure = (polyphonicKeyPressureRaw - 64) *
             note.pressure;
         return polyphonicKeyPressure * note.pressure / 37.5; // 2400 / 64;
     }
     getFilterCutoffControl(channel, note) {
-        const channelPressure = (channel.channelPressureTable[1] - 64) *
-            channel.state.channelPressure;
-        const polyphonicKeyPressure = (channel.polyphonicKeyPressureTable[1] - 64) *
-            note.pressure;
+        const channelPressureRaw = channel.channelPressureTable[1];
+        const channelPressure = (0 <= channelPressureRaw)
+            ? (channelPressureRaw - 64) * channel.state.channelPressure
+            : 0;
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[1];
+        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
+            ? (polyphonicKeyPressureRaw - 64) * note.pressure
+            : 0;
         return (channelPressure + polyphonicKeyPressure) * 15;
     }
     getAmplitudeControl(channel, note) {
-        const channelPressure = channel.channelPressureTable[2] *
-            channel.state.channelPressure;
-        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[2] *
-            note.pressure;
+        const channelPressureRaw = channel.channelPressureTable[2];
+        const channelPressure = (0 <= channelPressureRaw)
+            ? channelPressureRaw * channel.state.channelPressure
+            : 0;
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[2];
+        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
+            ? polyphonicKeyPressureRaw * note.pressure
+            : 0;
         return (channelPressure + polyphonicKeyPressure) / 128;
     }
     getLFOPitchDepth(channel, note) {
-        const channelPressure = channel.channelPressureTable[3] *
-            channel.state.channelPressure;
-        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[3] *
-            note.pressure;
+        const channelPressureRaw = channel.channelPressureTable[3];
+        const channelPressure = (0 <= channelPressureRaw)
+            ? channelPressureRaw * channel.state.channelPressure
+            : 0;
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[3];
+        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
+            ? polyphonicKeyPressureRaw * note.pressure
+            : 0;
         return (channelPressure + polyphonicKeyPressure) / 254 * 600;
     }
     getLFOFilterDepth(channel, note) {
-        const channelPressure = channel.channelPressureTable[4] *
-            channel.state.channelPressure;
-        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[4] *
-            note.pressure;
+        const channelPressureRaw = channel.channelPressureTable[4];
+        const channelPressure = (0 <= channelPressureRaw)
+            ? channelPressureRaw * channel.state.channelPressure
+            : 0;
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[4];
+        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
+            ? polyphonicKeyPressureRaw * note.pressure
+            : 0;
         return (channelPressure + polyphonicKeyPressure) / 254 * 2400;
     }
     getLFOAmplitudeDepth(channel, note) {
-        const channelPressure = channel.channelPressureTable[5] *
-            channel.state.channelPressure;
-        const polyphonicKeyPressure = channel.polyphonicKeyPressureTable[5] *
-            note.pressure;
+        const channelPressureRaw = channel.channelPressureTable[5];
+        const channelPressure = (0 <= channelPressureRaw)
+            ? channelPressureRaw * channel.state.channelPressure
+            : 0;
+        const polyphonicKeyPressureRaw = channel.polyphonicKeyPressureTable[5];
+        const polyphonicKeyPressure = (0 <= polyphonicKeyPressureRaw)
+            ? polyphonicKeyPressureRaw * note.pressure
+            : 0;
         return (channelPressure + polyphonicKeyPressure) / 254;
     }
     setControllerParameters(channel, note, table) {
-        if (table[0] !== 64)
+        if (0 <= table[0])
             this.updateDetune(channel, note);
         if (0.5 <= channel.state.portamemento && 0 <= note.portamentoNoteNumber) {
-            if (table[1] !== 64)
+            if (0 <= table[1])
                 this.setPortamentoFilterEnvelope(channel, note);
-            if (table[2] !== 64)
+            if (0 <= table[2])
                 this.setPortamentoVolumeEnvelope(channel, note);
         }
         else {
-            if (table[1] !== 64)
+            if (0 <= table[1])
                 this.setFilterEnvelope(channel, note);
-            if (table[2] !== 64)
+            if (0 <= table[2])
                 this.setVolumeEnvelope(channel, note);
         }
-        if (table[3] !== 0)
+        if (0 <= table[3])
             this.setModLfoToPitch(channel, note);
-        if (table[4] !== 0)
+        if (0 <= table[4])
             this.setModLfoToFilterFc(channel, note);
-        if (table[5] !== 0)
+        if (0 <= table[5])
             this.setModLfoToVolume(channel, note);
     }
     handlePressureSysEx(data, tableName) {
@@ -2966,26 +2960,15 @@ export class Midy {
         }
     }
     initControlTable() {
-        const channelCount = 128;
+        const ccCount = 128;
         const slotSize = 6;
-        const table = new Uint8Array(channelCount * slotSize);
-        return this.resetControlTable(table);
+        return new Int8Array(ccCount * slotSize).fill(-1);
     }
-    resetControlTable(table) {
-        const channelCount = 128;
-        const slotSize = 6;
-        const defaultValues = [64, 64, 64, 0, 0, 0];
-        for (let ch = 0; ch < channelCount; ch++) {
-            const offset = ch * slotSize;
-            table.set(defaultValues, offset);
-        }
-        return table;
-    }
-    applyControlTable(channel, controllerType) {
+    applyControlTable(channel, controllerType, scheduleTime) {
         const slotSize = 6;
         const offset = controllerType * slotSize;
         const table = channel.controlTable.subarray(offset, offset + slotSize);
-        this.processScheduledNotes(channel, (note) => {
+        this.processScheduledNotes(channel, scheduleTime, (note) => {
             this.setControllerParameters(channel, note, table);
         });
     }
@@ -3005,12 +2988,12 @@ export class Midy {
     getKeyBasedInstrumentControlValue(channel, keyNumber, controllerType) {
         const index = keyNumber * 128 + controllerType;
         const controlValue = channel.keyBasedInstrumentControlTable[index];
-        return (controlValue + 64) / 64;
+        return controlValue;
     }
     handleKeyBasedInstrumentControlSysEx(data, scheduleTime) {
         const channelNumber = data[4];
         const channel = this.channels[channelNumber];
-        if (channel.isDrum)
+        if (!channel.isDrum)
             return;
         const keyNumber = data[5];
         const table = channel.keyBasedInstrumentControlTable;
@@ -3018,7 +3001,7 @@ export class Midy {
             const controllerType = data[i];
             const value = data[i + 1];
             const index = keyNumber * 128 + controllerType;
-            table[index] = value - 64;
+            table[index] = value;
         }
         this.handleChannelPressure(channelNumber, channel.state.channelPressure * 127, scheduleTime);
     }