@marmooo/midy 0.3.1 → 0.3.3

package/script/midy-GMLite.js

@@ -3,60 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidyGMLite = void 0;
 const midi_file_1 = require("midi-file");
 const soundfont_parser_1 = require("@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, "ending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "bufferSource", {
             enumerable: true,
             configurable: true,
@@ -130,7 +90,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, },
@@ -341,7 +301,7 @@ 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;
     }
@@ -357,17 +317,37 @@ class MidyGMLite {
             }
         }
     }
-    async loadSoundFont(soundFontUrl) {
-        const response = await fetch(soundFontUrl);
-        const arrayBuffer = await response.arrayBuffer();
-        const parsed = (0, soundfont_parser_1.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 = (0, soundfont_parser_1.parse)(uint8Array);
         const soundFont = new soundfont_parser_1.SoundFont(parsed);
         this.addSoundFont(soundFont);
     }
-    async loadMIDI(midiUrl) {
-        const response = await fetch(midiUrl);
-        const arrayBuffer = await response.arrayBuffer();
-        const midi = (0, midi_file_1.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 = (0, midi_file_1.parseMidi)(uint8Array);
         this.ticksPerBeat = midi.header.ticksPerBeat;
         const midiData = this.extractMidiData(midi);
         this.instruments = midiData.instruments;
@@ -393,10 +373,10 @@ 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: [],
             };
         });
@@ -431,34 +411,33 @@ class MidyGMLite {
             return audioBuffer;
         }
     }
-    createBufferSource(voiceParams, audioBuffer) {
+    createBufferSource(channel, voiceParams, audioBuffer) {
         const bufferSource = new AudioBufferSourceNode(this.audioContext);
         bufferSource.buffer = audioBuffer;
         bufferSource.loop = voiceParams.sampleModes % 2 !== 0;
+        if (channel.isDrum)
+            bufferSource.loop = false;
         if (bufferSource.loop) {
             bufferSource.loopStart = voiceParams.loopStart / voiceParams.sampleRate;
             bufferSource.loopEnd = voiceParams.loopEnd / voiceParams.sampleRate;
         }
         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 */
+                    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) {
+                    if (notePromise)
                         this.notePromises.push(notePromise);
-                    }
                     break;
                 }
                 case "controller":
@@ -491,44 +470,53 @@ 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.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();
                 }
@@ -551,6 +539,7 @@ class MidyGMLite {
         return `${programNumber}:${noteNumber}:${velocity}`;
     }
     extractMidiData(midi) {
+        this.audioBufferCounter.clear();
         const instruments = new Set();
         const timeline = [];
         const tmpChannels = new Array(this.channels.length);
@@ -619,9 +608,8 @@ class MidyGMLite {
     stopActiveNotes(channelNumber, velocity, force, scheduleTime) {
         const channel = this.channels[channelNumber];
         const promises = [];
-        const activeNotes = this.getActiveNotes(channel, scheduleTime);
-        activeNotes.forEach((note) => {
-            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force, undefined);
+        this.processActiveNotes(channel, scheduleTime, (note) => {
+            const promise = this.scheduleNoteOff(channelNumber, note.noteNumber, velocity, scheduleTime, force);
             this.notePromises.push(promise);
             promises.push(promise);
         });
@@ -635,7 +623,7 @@ class MidyGMLite {
             this.notePromises.push(promise);
             promises.push(promise);
         });
-        channel.scheduledNotes.clear();
+        channel.scheduledNotes = [];
         return Promise.all(promises);
     }
     stopNotes(velocity, force, scheduleTime) {
@@ -656,9 +644,6 @@ 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)
@@ -693,37 +678,28 @@ 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;
-                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;
             if (scheduleTime < note.startTime)
                 continue;
-            return (note.ending) ? null : note;
+            callback(note);
         }
-        return noteList[0];
     }
     cbToRatio(cb) {
         return Math.pow(10, cb / 200);
@@ -861,7 +837,7 @@ class MidyGMLite {
         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.bufferSource = this.createBufferSource(channel, voiceParams, audioBuffer);
         note.volumeEnvelopeNode = new GainNode(this.audioContext);
         note.filterNode = new BiquadFilterNode(this.audioContext, {
             type: "lowpass",
@@ -870,6 +846,7 @@ 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);
         }
@@ -907,7 +884,7 @@ class MidyGMLite {
         }
         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);
@@ -919,6 +896,7 @@ 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) {
@@ -927,31 +905,12 @@ class MidyGMLite {
         this.handleExclusiveClass(note, channelNumber, startTime);
         this.handleDrumExclusiveClass(note, channelNumber, startTime);
         const scheduledNotes = channel.scheduledNotes;
-        let noteList = scheduledNotes.get(noteNumber);
-        if (noteList) {
-            noteList.push(note);
-        }
-        else {
-            noteList = [note];
-            scheduledNotes.set(noteNumber, noteList);
-        }
-        if (channel.isDrum) {
-            const stopTime = startTime + note.bufferSource.buffer.duration;
-            const index = noteList.length - 1;
-            const promise = new Promise((resolve) => {
-                note.bufferSource.onended = () => {
-                    noteList[index] = undefined;
-                    this.disconnectNote(note);
-                    resolve();
-                };
-                note.bufferSource.stop(stopTime);
-            });
-            this.notePromises.push(promise);
-        }
+        note.index = scheduledNotes.length;
+        scheduledNotes.push(note);
     }
     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();
@@ -963,57 +922,54 @@ class MidyGMLite {
             note.modulationLFO.stop();
         }
     }
-    stopNote(endTime, stopTime, noteList, index) {
-        const note = noteList[index];
+    releaseNote(channel, note, endTime) {
+        const volRelease = endTime + note.voiceParams.volRelease;
+        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 = () => {
-                noteList[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);
         });
     }
-    findNoteOffTarget(noteList) {
-        for (let i = 0; i < noteList.length; i++) {
-            const note = noteList[i];
+    scheduleNoteOff(channelNumber, noteNumber, _velocity, endTime, force) {
+        const channel = this.channels[channelNumber];
+        if (!force) {
+            if (channel.isDrum)
+                return;
+            if (0.5 <= channel.state.sustainPedal)
+                return;
+        }
+        const note = this.findNoteOffTarget(channel, noteNumber);
+        if (!note)
+            return;
+        note.ending = true;
+        this.releaseNote(channel, note, endTime);
+    }
+    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;
-            return [note, i];
+            if (note.noteNumber !== noteNumber)
+                continue;
+            return note;
         }
     }
-    scheduleNoteOff(channelNumber, noteNumber, _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 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);
-    }
     noteOff(channelNumber, noteNumber, velocity, scheduleTime) {
         scheduleTime ??= this.audioContext.currentTime;
         return this.scheduleNoteOff(channelNumber, noteNumber, velocity, scheduleTime, false);
@@ -1023,7 +979,7 @@ class MidyGMLite {
         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].noteNumber, velocity, scheduleTime);
             promises.push(promise);
         }
         channel.sustainNotes = [];
@@ -1179,20 +1135,20 @@ 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];
@@ -1337,19 +1293,26 @@ class MidyGMLite {
         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",
@@ -1357,10 +1320,17 @@ 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",