@marmooo/midy 0.3.1 → 0.3.2

package/esm/midy-GM1.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,
@@ -114,7 +68,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, },
@@ -319,7 +273,7 @@ export class MidyGM1 {
     initSoundFontTable() {
         const table = new Array(128);
         for (let i = 0; i < 128; i++) {
-            table[i] = new SparseMap(128);
+            table[i] = new Map();
         }
         return table;
     }
@@ -371,10 +325,10 @@ export class MidyGM1 {
             return {
                 currentBufferSource: null,
                 isDrum: false,
-                ...this.constructor.channelSettings,
                 state: new ControllerState(),
+                ...this.constructor.channelSettings,
                 ...this.setChannelAudioNodes(audioContext),
-                scheduledNotes: new SparseMap(128),
+                scheduledNotes: [],
                 sustainNotes: [],
             };
         });
@@ -409,7 +363,7 @@ export class MidyGM1 {
             return audioBuffer;
         }
     }
-    createBufferSource(audioBuffer, voiceParams) {
+    createBufferSource(voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
         bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
@@ -419,24 +373,20 @@ export class MidyGM1 {
         }
         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 (0 < event.velocity) {
-                        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":
@@ -469,7 +419,7 @@ export class MidyGM1 {
             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) {
@@ -477,18 +427,21 @@ export class MidyGM1 {
                     this.notePromises = [];
                     this.exclusiveClassNotes.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) {
@@ -496,9 +449,12 @@ export class MidyGM1 {
                     this.notePromises = [];
                     this.exclusiveClassNotes.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) {
@@ -506,7 +462,7 @@ export class MidyGM1 {
                     this.exclusiveClassNotes.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();
                 }
@@ -592,13 +548,37 @@ export class MidyGM1 {
                 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 = [];
-        const activeNotes = this.getActiveNotes(channel, scheduleTime);
-        activeNotes.forEach((note) => {
+        this.processActiveNotes(channel, scheduleTime, (note) => {
             const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
             this.notePromises.push(promise);
             promises.push(promise);
@@ -609,11 +589,11 @@ export class MidyGM1 {
         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) {
@@ -634,9 +614,6 @@ export class MidyGM1 {
         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)
@@ -671,37 +648,31 @@ export class MidyGM1 {
         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;
-                if (note.ending)
-                    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);
@@ -841,7 +812,7 @@ export class MidyGM1 {
         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(audioBuffer, voiceParams);
+        note.bufferSource = this.createBufferSource(voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(this.audioContext);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
@@ -850,6 +821,7 @@ export class MidyGM1 {
         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);
         }
@@ -866,13 +838,13 @@ export class MidyGM1 {
         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);
             }
         }
         this.exclusiveClassNotes[exclusiveClass] = [note, channelNumber];
     }
-    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);
@@ -884,6 +856,7 @@ export class MidyGM1 {
             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) {
@@ -891,18 +864,18 @@ export class MidyGM1 {
         }
         this.handleExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        let noteList = scheduledNotes.get(noteNumber);
-        if (noteList) {
-            noteList.push(note);
-        }
-        else {
-            noteList = [note];
-            scheduledNotes.set(noteNumber, noteList);
+        note.index = scheduledNotes.length;
+        scheduledNotes.push(note);
+        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) {
         note.bufferSource.disconnect();
@@ -914,8 +887,7 @@ export class MidyGM1 {
             note.modulationLFO.stop();
         }
     }
-    stopNote(endTime, stopTime, noteList, index) {
-        const note = noteList[index];
+    stopNote(channel, note, endTime, stopTime) {
         note.volumeEnvelopeNode.gain
             .cancelScheduledValues(endTime)
             .linearRampToValueAtTime(0, stopTime);
@@ -925,54 +897,50 @@ export class MidyGM1 {
         }, stopTime);
         return new Promise((resolve) => {
             note.bufferSource.onended = () => {
-                noteList[index] = undefined;
+                channel.scheduledNotes[note.index] = undefined;
                 this.disconnectNote(note);
                 resolve();
             };
             note.bufferSource.stop(stopTime);
         });
     }
-    findNoteOffTarget(noteList) {
-        for (let i = 0; i < noteList.length; i++) {
-            const note = noteList[i];
-            if (!note)
-                continue;
-            if (note.ending)
-                continue;
-            return [note, i];
-        }
-    }
-    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+    scheduleNoteOff(channelNumber, note, _velocity, endTime, force) {
         const channel = this.channels[channelNumber];
         if (!force && 0.5 <= channel.state.sustainPedal)
             return;
-        if (!channel.scheduledNotes.has(noteNumber))
-            return;
-        const noteList = channel.scheduledNotes.get(noteNumber);
-        if (!noteList)
-            return; // be careful with drum channel
-        const noteOffTarget = this.findNoteOffTarget(noteList, endTime);
-        if (!noteOffTarget)
-            return;
-        const [note, i] = noteOffTarget;
         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, noteList, i);
+        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;
+            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 = [];
@@ -1128,20 +1096,19 @@ export class MidyGM1 {
         });
     }
     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;
+        return handlers;
     }
     handleControlChange(channelNumber, controllerType, value, scheduleTime) {
         const handler = this.controlChangeHandlers[controllerType];
@@ -1330,19 +1297,26 @@ export class MidyGM1 {
         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",
@@ -1350,10 +1324,17 @@ export class MidyGM1 {
         ];
         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",