@marmooo/midy 0.3.0 → 0.3.2

package/esm/midy-GMLite.js

@@ -1,59 +1,13 @@
 import { parseMidi } from "midi-file";
 import { parse, SoundFont } from "@marmooo/soundfont-parser";
-// 2-3 times faster than Map
-class SparseMap {
-    constructor(size) {
-        this.data = new Array(size);
-        this.activeIndices = [];
-    }
-    set(key, value) {
-        if (this.data[key] === undefined) {
-            this.activeIndices.push(key);
-        }
-        this.data[key] = value;
-    }
-    get(key) {
-        return this.data[key];
-    }
-    delete(key) {
-        if (this.data[key] !== undefined) {
-            this.data[key] = undefined;
-            const index = this.activeIndices.indexOf(key);
-            if (index !== -1) {
-                this.activeIndices.splice(index, 1);
-            }
-            return true;
-        }
-        return false;
-    }
-    has(key) {
-        return this.data[key] !== undefined;
-    }
-    get size() {
-        return this.activeIndices.length;
-    }
-    clear() {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            this.data[key] = undefined;
-        }
-        this.activeIndices = [];
-    }
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            yield [key, this.data[key]];
-        }
-    }
-    forEach(callback) {
-        for (let i = 0; i < this.activeIndices.length; i++) {
-            const key = this.activeIndices[i];
-            callback(this.data[key], key, this);
-        }
-    }
-}
 class Note {
     constructor(noteNumber, velocity, startTime, voice, voiceParams) {
+        Object.defineProperty(this, "index", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -127,7 +81,7 @@ const defaultControllerState = {
     modulationDepth: { type: 128 + 1, defaultValue: 0 },
     // dataMSB: { type: 128 + 6, defaultValue: 0, },
     volume: { type: 128 + 7, defaultValue: 100 / 127 },
-    pan: { type: 128 + 10, defaultValue: 0.5 },
+    pan: { type: 128 + 10, defaultValue: 64 / 127 },
     expression: { type: 128 + 11, defaultValue: 1 },
     // bankLSB: { type: 128 + 32, defaultValue: 0, },
     // dataLSB: { type: 128 + 38, defaultValue: 0, },
@@ -338,7 +292,7 @@ export class MidyGMLite {
     initSoundFontTable() {
         const table = new Array(128);
         for (let i = 0; i < 128; i++) {
-            table[i] = new SparseMap(128);
+            table[i] = new Map();
         }
         return table;
     }
@@ -390,10 +344,10 @@ export class MidyGMLite {
             return {
                 currentBufferSource: null,
                 isDrum: false,
-                ...this.constructor.channelSettings,
                 state: new ControllerState(),
+                ...this.constructor.channelSettings,
                 ...this.setChannelAudioNodes(audioContext),
-                scheduledNotes: new SparseMap(128),
+                scheduledNotes: [],
                 sustainNotes: [],
             };
         });
@@ -438,24 +392,20 @@ export class MidyGMLite {
         }
         return bufferSource;
     }
-    async scheduleTimelineEvents(t, offset, queueIndex) {
+    async scheduleTimelineEvents(t, resumeTime, queueIndex) {
         while (queueIndex < this.timeline.length) {
             const event = this.timeline[queueIndex];
             if (event.startTime > t + this.lookAhead)
                 break;
-            const startTime = event.startTime + this.startDelay - offset;
+            const delay = this.startDelay - resumeTime;
+            const startTime = event.startTime + delay;
             switch (event.type) {
-                case "noteOn":
-                    if (event.velocity !== 0) {
-                        await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime);
-                        break;
-                    }
-                /* falls through */
-                case "noteOff": {
-                    const notePromise = this.scheduleNoteOff(event.channel, event.noteNumber, event.velocity, startTime, false);
-                    if (notePromise) {
-                        this.notePromises.push(notePromise);
-                    }
+                case "noteOn": {
+                    const noteOffEvent = {
+                        ...event.noteOffEvent,
+                        startTime: event.noteOffEvent.startTime + delay,
+                    };
+                    await this.scheduleNoteOn(event.channel, event.noteNumber, event.velocity, startTime, noteOffEvent);
                     break;
                 }
                 case "controller":
@@ -488,44 +438,53 @@ export class MidyGMLite {
             this.isPaused = false;
             this.startTime = this.audioContext.currentTime;
             let queueIndex = this.getQueueIndex(this.resumeTime);
-            let offset = this.resumeTime - this.startTime;
+            let resumeTime = this.resumeTime - this.startTime;
             this.notePromises = [];
             const schedulePlayback = async () => {
                 if (queueIndex >= this.timeline.length) {
                     await Promise.all(this.notePromises);
                     this.notePromises = [];
-                    this.exclusiveClassNotes.flll(undefined);
+                    this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
+                    for (let i = 0; i < this.channels.length; i++) {
+                        this.resetAllStates(i);
+                    }
                     resolve();
                     return;
                 }
                 const now = this.audioContext.currentTime;
-                const t = now + offset;
-                queueIndex = await this.scheduleTimelineEvents(t, offset, queueIndex);
+                const t = now + resumeTime;
+                queueIndex = await this.scheduleTimelineEvents(t, resumeTime, queueIndex);
                 if (this.isPausing) {
                     await this.stopNotes(0, true, now);
                     this.notePromises = [];
-                    resolve();
                     this.isPausing = false;
                     this.isPaused = true;
+                    resolve();
                     return;
                 }
                 else if (this.isStopping) {
                     await this.stopNotes(0, true, now);
                     this.notePromises = [];
                     this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.audioBufferCache.clear();
-                    resolve();
+                    for (let i = 0; i < this.channels.length; i++) {
+                        this.resetAllStates(i);
+                    }
                     this.isStopping = false;
                     this.isPaused = false;
+                    resolve();
                     return;
                 }
                 else if (this.isSeeking) {
                     this.stopNotes(0, true, now);
                     this.exclusiveClassNotes.fill(undefined);
+                    this.drumExclusiveClassNotes.fill(undefined);
                     this.startTime = this.audioContext.currentTime;
                     queueIndex = this.getQueueIndex(this.resumeTime);
-                    offset = this.resumeTime - this.startTime;
+                    resumeTime = this.resumeTime - this.startTime;
                     this.isSeeking = false;
                     await schedulePlayback();
                 }
@@ -611,17 +570,52 @@ export class MidyGMLite {
                 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);
+            this.notePromises.push(promise);
+            promises.push(promise);
+        });
+        return Promise.all(promises);
+    }
     stopChannelNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
         this.processScheduledNotes(channel, (note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
+            const promise = this.scheduleNoteOff(channelNumber, note, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
-        channel.scheduledNotes.clear();
+        channel.scheduledNotes = [];
         return Promise.all(promises);
     }
     stopNotes(velocity, force, scheduleTime) {
@@ -642,9 +636,6 @@ export class MidyGMLite {
         if (!this.isPlaying)
             return;
         this.isStopping = true;
-        for (let i = 0; i < this.channels.length; i++) {
-            this.resetAllStates(i);
-        }
     }
     pause() {
         if (!this.isPlaying || this.isPaused)
@@ -679,35 +670,31 @@ export class MidyGMLite {
         return this.resumeTime + now - this.startTime - this.startDelay;
     }
     processScheduledNotes(channel, callback) {
-        channel.scheduledNotes.forEach((noteList) => {
-            for (let i = 0; i < noteList.length; i++) {
-                const note = noteList[i];
-                if (!note)
-                    continue;
-                callback(note);
-            }
-        });
-    }
-    getActiveNotes(channel, scheduleTime) {
-        const activeNotes = new SparseMap(128);
-        channel.scheduledNotes.forEach((noteList) => {
-            const activeNote = this.getActiveNote(noteList, scheduleTime);
-            if (activeNote) {
-                activeNotes.set(activeNote.noteNumber, activeNote);
-            }
-        });
-        return activeNotes;
+        const scheduledNotes = channel.scheduledNotes;
+        for (let i = 0; i < scheduledNotes.length; i++) {
+            const note = scheduledNotes[i];
+            if (!note)
+                continue;
+            if (note.ending)
+                continue;
+            callback(note);
+        }
     }
-    getActiveNote(noteList, scheduleTime) {
-        for (let i = noteList.length - 1; i >= 0; i--) {
-            const note = noteList[i];
+    processActiveNotes(channel, scheduleTime, callback) {
+        const scheduledNotes = channel.scheduledNotes;
+        for (let i = 0; i < scheduledNotes.length; i++) {
+            const note = scheduledNotes[i];
             if (!note)
-                return;
+                continue;
+            if (note.ending)
+                continue;
+            const noteOffEvent = note.noteOffEvent;
+            if (noteOffEvent && noteOffEvent.startTime < scheduleTime)
+                continue;
             if (scheduleTime < note.startTime)
                 continue;
-            return (note.ending) ? null : note;
+            callback(note);
         }
-        return noteList[0];
     }
     cbToRatio(cb) {
         return Math.pow(10, cb / 200);
@@ -854,6 +841,7 @@ export class MidyGMLite {
         this.setVolumeEnvelope(note, now);
         this.setFilterEnvelope(note, now);
         this.setPitchEnvelope(note, now);
+        this.updateDetune(channel, note, now);
         if (0 < state.modulationDepth) {
             this.startModulation(channel, note, now);
         }
@@ -870,7 +858,7 @@ export class MidyGMLite {
         if (prev) {
             const [prevNote, prevChannelNumber] = prev;
             if (prevNote && !prevNote.ending) {
-                this.scheduleNoteOff(prevChannelNumber, prevNote.noteNumber, 0, // velocity,
+                this.scheduleNoteOff(prevChannelNumber, prevNote, 0, // velocity,
                 startTime, true);
             }
         }
@@ -886,12 +874,12 @@ export class MidyGMLite {
         const index = drumExclusiveClass * this.channels.length + channelNumber;
         const prevNote = this.drumExclusiveClassNotes[index];
         if (prevNote && !prevNote.ending) {
-            this.scheduleNoteOff(channelNumber, prevNote.noteNumber, 0, // velocity,
+            this.scheduleNoteOff(channelNumber, prevNote, 0, // velocity,
             startTime, true);
         }
         this.drumExclusiveClassNotes[index] = note;
     }
-    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime) {
+    async scheduleNoteOn(channelNumber, noteNumber, velocity, startTime, noteOffEvent) {
         const channel = this.channels[channelNumber];
         const bankNumber = channel.bank;
         const soundFontIndex = this.soundFontTable[channel.programNumber].get(bankNumber);
@@ -903,6 +891,7 @@ export class MidyGMLite {
             return;
         const isSF3 = soundFont.parsed.info.version.major === 3;
         const note = await this.createNote(channel, voice, noteNumber, velocity, startTime, isSF3);
+        note.noteOffEvent = noteOffEvent;
         note.volumeEnvelopeNode.connect(channel.gainL);
         note.volumeEnvelopeNode.connect(channel.gainR);
         if (0.5 <= channel.state.sustainPedal) {
@@ -911,33 +900,32 @@ export class MidyGMLite {
         this.handleExclusiveClass(note, channelNumber, startTime);
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        let notes = scheduledNotes.get(noteNumber);
-        if (notes) {
-            notes.push(note);
-        }
-        else {
-            notes = [note];
-            scheduledNotes.set(noteNumber, notes);
-        }
-        if (this.isDrumNoteOffException(channel, noteNumber)) {
+        note.index = scheduledNotes.length;
+        scheduledNotes.push(note);
+        if (channel.isDrum) {
             const stopTime = startTime + note.bufferSource.buffer.duration;
-            const index = notes.length - 1;
             const promise = new Promise((resolve) => {
                 note.bufferSource.onended = () => {
-                    this.disconnectNote(note, scheduledNotes, index);
+                    scheduledNotes[note.index] = undefined;
+                    this.disconnectNote(note);
                     resolve();
                 };
                 note.bufferSource.stop(stopTime);
             });
             this.notePromises.push(promise);
         }
+        else if (noteOffEvent) {
+            const notePromise = this.scheduleNoteOff(channelNumber, note, noteOffEvent.velocity, noteOffEvent.startTime, false);
+            if (notePromise) {
+                this.notePromises.push(notePromise);
+            }
+        }
     }
     noteOn(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime);
+        return this.scheduleNoteOn(channelNumber, noteNumber, velocity, scheduleTime, undefined);
     }
-    disconnectNote(note, scheduledNotes, index) {
-        scheduledNotes[index] = null;
+    disconnectNote(note) {
         note.bufferSource.disconnect();
         note.filterNode.disconnect();
         note.volumeEnvelopeNode.disconnect();
@@ -947,8 +935,7 @@ export class MidyGMLite {
             note.modulationLFO.stop();
         }
     }
-    stopNote(endTime, stopTime, scheduledNotes, index) {
-        const note = scheduledNotes[index];
+    stopNote(channel, note, endTime, stopTime) {
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
             .linearRampToValueAtTime(0, stopTime);
@@ -958,46 +945,52 @@ export class MidyGMLite {
         }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
-                this.disconnectNote(note, scheduledNotes, index);
+                channel.scheduledNotes[note.index] = undefined;
+                this.disconnectNote(note);
                 resolve();
             };
             note.bufferSource.stop(stopTime);
         });
     }
-    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+    scheduleNoteOff(channelNumber, note, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         if (channel.isDrum)
             return;
         if (!force && 0.5 <= channel.state.sustainPedal)
             return;
-        if (!channel.scheduledNotes.has(noteNumber))
-            return;
-        const scheduledNotes = channel.scheduledNotes.get(noteNumber);
+        const volRelease = endTime + note.voiceParams.volRelease;
+        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);
+    }
+    findNoteOffTarget(channel, noteNumber) {
+        const scheduledNotes = channel.scheduledNotes;
         for (let i = 0; i < scheduledNotes.length; i++) {
             const note = scheduledNotes[i];
             if (!note)
                 continue;
             if (note.ending)
                 continue;
-            const volRelease = endTime + note.voiceParams.volRelease;
-            const modRelease = endTime + note.voiceParams.modRelease;
-            note.filterNode.frequency
-                .cancelScheduledValues(endTime)
-                .linearRampToValueAtTime(0, modRelease);
-            const stopTime = Math.min(volRelease, modRelease);
-            return this.stopNote(endTime, stopTime, scheduledNotes, i);
+            if (note.noteNumber !== noteNumber)
+                continue;
+            return note;
         }
     }
     noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false);
+        const channel = this.channels[channelNumber];
+        const note = this.findNoteOffTarget(channel, noteNumber);
+        return this.scheduleNoteOff(channelNumber, note, 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.noteOff(channelNumber, channel.sustainNotes[i].noteNumber, velocity, scheduleTime);
+            const promise = this.scheduleNoteOff(channelNumber, channel.sustainNotes[i], velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1153,20 +1146,20 @@ export class MidyGMLite {
         });
     }
     createControlChangeHandlers() {
-        return {
-            1: this.setModulationDepth,
-            6: this.dataEntryMSB,
-            7: this.setVolume,
-            10: this.setPan,
-            11: this.setExpression,
-            38: this.dataEntryLSB,
-            64: this.setSustainPedal,
-            100: this.setRPNLSB,
-            101: this.setRPNMSB,
-            120: this.allSoundOff,
-            121: this.resetAllControllers,
-            123: this.allNotesOff,
-        };
+        const handlers = new Array(128);
+        handlers[1] = this.setModulationDepth;
+        handlers[6] = this.dataEntryMSB;
+        handlers[7] = this.setVolume;
+        handlers[10] = this.setPan;
+        handlers[11] = this.setExpression;
+        handlers[38] = this.dataEntryLSB;
+        handlers[64] = this.setSustainPedal;
+        handlers[100] = this.setRPNLSB;
+        handlers[101] = this.setRPNMSB;
+        handlers[120] = this.allSoundOff;
+        handlers[121] = this.resetAllControllers;
+        handlers[123] = this.allNotesOff;
+        return handlers;
     }
     handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
@@ -1308,22 +1301,29 @@ export class MidyGMLite {
     }
     allSoundOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.stopChannelNotes(channelNumber, 0, true, scheduleTime);
+        return this.stopActiveNotes(channelNumber, 0, true, scheduleTime);
     }
     resetAllStates(channelNumber) {
+        const scheduleTime = this.audioContext.currentTime;
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        for (const type of Object.keys(defaultControllerState)) {
-            state[type] = defaultControllerState[type].defaultValue;
+        const entries = Object.entries(defaultControllerState);
+        for (const [key, { type, defaultValue }] of entries) {
+            if (128 <= type) {
+                this.handleControlChange(channelNumber, type - 128, Math.ceil(defaultValue * 127), scheduleTime);
+            }
+            else {
+                state[key] = defaultValue;
+            }
         }
-        for (const type of Object.keys(this.constructor.channelSettings)) {
-            channel[type] = this.constructor.channelSettings[type];
+        for (const key of Object.keys(this.constructor.channelSettings)) {
+            channel[key] = this.constructor.channelSettings[key];
         }
         this.mode = "GM1";
     }
     // https://amei.or.jp/midistandardcommittee/Recommended_Practice/e/rp15.pdf
-    resetAllControllers(channelNumber) {
-        const stateTypes = [
+    resetAllControllers(channelNumber, _value, scheduleTime) {
+        const keys = [
             "pitchWheel",
             "expression",
             "modulationDepth",
@@ -1331,10 +1331,17 @@ export class MidyGMLite {
         ];
         const channel = this.channels[channelNumber];
         const state = channel.state;
-        for (let i = 0; i < stateTypes.length; i++) {
-            const type = stateTypes[i];
-            state[type] = defaultControllerState[type].defaultValue;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const { type, defaultValue } = defaultControllerState[key];
+            if (128 <= type) {
+                this.handleControlChange(channelNumber, type - 128, Math.ceil(defaultValue * 127), scheduleTime);
+            }
+            else {
+                state[key] = defaultValue;
+            }
         }
+        this.setPitchBend(channelNumber, 8192, scheduleTime);
         const settingTypes = [
             "rpnMSB",
             "rpnLSB",
@@ -1346,7 +1353,7 @@ export class MidyGMLite {
     }
     allNotesOff(channelNumber, _value, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
-        return this.stopChannelNotes(channelNumber, 0, false, scheduleTime);
+        return this.stopActiveNotes(channelNumber, 0, false, scheduleTime);
     }
     handleUniversalNonRealTimeExclusiveMessage(data, scheduleTime) {
         switch (data[2]) {