midi-audio-player 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midi-audio-player",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Javascript Midi Audio Player for WebAudioFont",
   "keywords": [
     "audio",

package/src/downloader.js

@@ -1,54 +1,33 @@
 import fs from 'fs/promises';
 import path from 'path';
 
-/**
- * Télécharge une police audio WebAudioFont et la convertit en JSON
- * @param {string} id - L'ID de la police (ex: "0810_GeneralUserGS_sf2_file")
- * @param {string} filename - Le nom du fichier de sortie (ex: "ma_police.json")
- */
+
 export async function downloadWebAudioFont(id, filename) {
-    // Nettoyage du nom de fichier : s'assurer qu'il finit par .json
     const cleanFilename = filename.endsWith('.json') ? filename : `${filename}.json`;
-    
-    // On définit la destination par rapport au dossier de travail actuel
     const destPath = path.join(process.cwd(), cleanFilename);
     const url = `https://surikov.github.io/webaudiofontdata/sound/${id}.js`;
 
     try {
         console.log(`📡 Téléchargement de : ${id}...`);
-        
         const response = await fetch(url);
-        
-        if (!response.ok) {
-            throw new Error(`Erreur HTTP: ${response.status} (Vérifiez l'ID)`);
-        }
+        if (!response.ok) throw new Error(`Erreur HTTP: ${response.status} (Vérifiez l'ID)`);
 
         const rawContent = await response.text();
-
-        // Extraction de l'objet JS entre les premières '{' et les dernières '}'
         const firstBrace = rawContent.indexOf('{');
         const lastBrace = rawContent.lastIndexOf('}');
 
-        if (firstBrace === -1 || lastBrace === -1) {
-            throw new Error("Format de fichier invalide : structure d'objet introuvable.");
-        }
+        if (firstBrace === -1 || lastBrace === -1) throw new Error("Format de fichier invalide : structure d'objet introuvable.");
 
         const objectString = rawContent.substring(firstBrace, lastBrace + 1);
-
-        // Transformation de la chaîne en objet JavaScript
         const data = new Function(`return ${objectString}`)();
-
-        // Création du dossier parent s'il n'existe pas
         await fs.mkdir(path.dirname(destPath), { recursive: true });
-
-        // Sauvegarde en format JSON
         await fs.writeFile(destPath, JSON.stringify(data, null, 2));
 
         console.log(`✅ Terminé ! Fichier créé : ${destPath}`);
-        return data; // Retourne l'objet au cas où on veut l'utiliser immédiatement
+        return data;
         
     } catch (error) {
         console.error(`❌ Échec : ${error.message}`);
-        throw error; // On relance l'erreur pour que l'appelant puisse la gérer
+        throw error;
     }
 }

package/src/midiaudioplayer.js

@@ -31,6 +31,27 @@ export default class MidiAudioPlayer {
 	}
 
 
+	async play(content = null) {
+		if(content) await this.#load(content);
+        await this.#audioCtx.resume();
+		await this.#midiPlayer.play();
+	}
+
+
+	async pause() {
+        await this.#midiPlayer.pause();
+        await this.#audioCtx.suspend();
+        await this.#clearActiveNotes();
+	}
+
+	
+    async stop() {
+        await this.#midiPlayer.stop();
+        await this.#audioCtx.suspend();
+        await this.#clearActiveNotes();
+	}
+
+
 	async #endOfFile() {
 		if(typeof this.#opts.onEndFile == 'function') await this.#opts.onEndFile();
 	}
@@ -73,11 +94,7 @@ export default class MidiAudioPlayer {
 
     #clearActiveNotes() {
         if (this.#activeNotes) {
-            this.#activeNotes.forEach((envelope, note) => {
-                if (envelope && envelope.cancel) {
-                    envelope.cancel();
-                }
-            });
+            this.#activeNotes.forEach((envelope, note) => { if (envelope && envelope.cancel) envelope.cancel(); });
             this.#activeNotes.clear();
         }
     }
@@ -89,25 +106,4 @@ export default class MidiAudioPlayer {
 		await this.#midiPlayer.loadArrayBuffer(content);
 	}
 
-
-	async play(content = null) {
-		if(content) await this.#load(content);
-        await this.#audioCtx.resume();
-		await this.#midiPlayer.play();
-	}
-
-
-	async pause() {
-        await this.#midiPlayer.pause();
-        await this.#audioCtx.suspend();
-        await this.#clearActiveNotes();
-	}
-
-	
-    async stop() {
-        await this.#midiPlayer.stop();
-        await this.#audioCtx.suspend();
-        await this.#clearActiveNotes();
-	}
-
 }

package/src/webaudiofontplayer.js

@@ -1,134 +1,37 @@
-
-
-class WebAudioFontChannel {
-
-    constructor(audioContext) {
-        this.audioContext = audioContext;
-        this.input = audioContext.createGain();
-
-        let lastNode = this.input;
-        [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384].forEach(freq => {
-            lastNode = this.bandEqualizer(lastNode, freq);
-            this[`band${freq < 1000 ? freq : (freq / 1024) + 'k'}`] = lastNode;
-        });
-
-
-        this.limiter = audioContext.createDynamicsCompressor();
-        this.limiter.threshold.setValueAtTime(-3.0, audioContext.currentTime);
-        this.limiter.ratio.setValueAtTime(40, audioContext.currentTime);
-        this.limiter.attack.setValueAtTime(0.000, audioContext.currentTime);
-        this.limiter.release.setValueAtTime(0.25, audioContext.currentTime);
-        this.output = audioContext.createGain();
-
-        lastNode.connect(this.limiter);
-        this.limiter.connect(this.output);
-
-    }
-
-    bandEqualizer(from, frequency) {
-        const filter = this.audioContext.createBiquadFilter();
-        filter.frequency.setTargetAtTime(frequency, 0, 0.0001);
-        filter.type = "peaking";
-        filter.gain.setTargetAtTime(0, 0, 0.0001);
-        filter.Q.setTargetAtTime(1.0, 0, 0.0001);
-        from.connect(filter);
-        return filter;
-    }
-}
-
 class WebAudioFontPlayer {
 
-    envelopes = [];
-    afterTime = 0.05;
-    nearZero = 0.000001;
-
     #audioCtx = null;
     #preset = null;
-    
+
+    #envelopes = [];
+    #afterTime = 0.05;
+    #nearZero = 0.000001;
+
+
     constructor(audioCtx, preset) {
         this.#audioCtx = audioCtx;
         this.#preset = preset;
-        this.adjustPreset(this.#audioCtx, this.#preset);
+        this.#preset.zones.map(zone => this.#adjustZone(zone));
     }
 
 
-    adjustPreset(audioContext, preset) {
-        return preset.zones.map(zone => this.adjustZone(audioContext, zone));
-    };
-
-
-    adjustZone(audioContext, zone) {
-        if (zone.buffer) return Promise.resolve(zone);
-            zone.delay = 0;
-
-            if (zone.sample) {
-                const decoded = atob(zone.sample);
-                zone.buffer = audioContext.createBuffer(1, decoded.length / 2, zone.sampleRate);
-                const float32Array = zone.buffer.getChannelData(0);
-
-                for (let i = 0; i < decoded.length / 2; i++) {
-                    const b1 = decoded.charCodeAt(i * 2) & 0xFF;
-                    const b2 = decoded.charCodeAt(i * 2 + 1) & 0xFF;
-                    let n = (b2 << 8) | b1;
-                    if (n >= 32768) n -= 65536;
-                    float32Array[i] = n / 32768.0;
-                }
-                this.applyZoneParameters(zone);
-                return zone;
-
-            } else if (zone.file) {
-                const decoded = atob(zone.file);
-                const uint8Array = new Uint8Array(decoded.length);
-                for (let i = 0; i < decoded.length; i++) {
-                    uint8Array[i] = decoded.charCodeAt(i);
-                }
-
-                audioContext.decodeAudioData(
-                    uint8Array.buffer,
-                    audioBuffer => {
-                        zone.buffer = audioBuffer;
-                        this.applyZoneParameters(zone);
-                        return zone;
-                    },
-                    error => {
-                        console.error("Erreur de décodage audio:", error);
-                        return false;
-                    }
-                );
-            } else {
-                this.applyZoneParameters(zone);
-                return zone;
-            }
-    };
-
-    applyZoneParameters = (zone) => {
-        zone.loopStart = this.numValue(zone.loopStart, 0);
-        zone.loopEnd = this.numValue(zone.loopEnd, 0);
-        zone.coarseTune = this.numValue(zone.coarseTune, 0);
-        zone.fineTune = this.numValue(zone.fineTune, 0);
-        zone.originalPitch = this.numValue(zone.originalPitch, 6000);
-        zone.sampleRate = this.numValue(zone.sampleRate, 44100);
-    };
-
     queueWaveTable(when, pitch, duration, volume, slides) {
-        this.resumeContext(this.#audioCtx);
-        const vol = this.limitVolume(volume);
-        const zone = this.findZone(this.#audioCtx, this.#preset, pitch);
+        if(this.#audioCtx.state === 'suspended') this.#audioCtx.resume().catch(() => { });
 
+        const vol = this.#limitVolume(volume);
+        const zone = this.#findZone(pitch);
         if (!zone?.buffer) return null;
 
         const baseDetune = zone.originalPitch - 100.0 * zone.coarseTune - zone.fineTune;
         const playbackRate = Math.pow(2, (100.0 * pitch - baseDetune) / 1200.0);
         const startWhen = Math.max(when, this.#audioCtx.currentTime);
-        let waveDuration = duration + this.afterTime;
+        let waveDuration = duration + this.#afterTime;
 
         const loop = zone.loopStart >= 1 && zone.loopStart < zone.loopEnd;
-        if (!loop) {
-            waveDuration = Math.min(waveDuration, zone.buffer.duration / playbackRate);
-        }
+        if (!loop) waveDuration = Math.min(waveDuration, zone.buffer.duration / playbackRate);
 
-        const envelope = this.findEnvelope(this.#audioCtx, this.#audioCtx.destination);
-        this.setupEnvelope(this.#audioCtx, envelope, zone, vol, startWhen, waveDuration, duration);
+        const envelope = this.#findEnvelope();
+        this.#setupEnvelope(envelope, zone, vol, startWhen, waveDuration, duration);
 
         const source = this.#audioCtx.createBufferSource();
         source.buffer = zone.buffer;
@@ -160,10 +63,80 @@ class WebAudioFontPlayer {
         return envelope;
     }
 
-    setupEnvelope(audioContext, envelope, zone, volume, when, sampleDuration, noteDuration) {
-        envelope.gain.setValueAtTime(this.noZeroVolume(0), audioContext.currentTime);
 
-        const duration = Math.min(noteDuration, sampleDuration - this.afterTime);
+    queueChord(prst, w, pchs, d, v, s) {
+        const vol = this.#limitVolume(v);
+        return pchs.map((p, i) => this.queueWaveTable(this.#audioCtx, this.#audioCtx.destination, prst, w, p, d, vol - Math.random() * 0.01, s?.[i])).filter(Boolean);
+    }
+
+
+    cancelQueue(audioContext) {
+        this.#envelopes.forEach(e => {
+            e.gain.cancelScheduledValues(0);
+            e.gain.setValueAtTime(this.#nearZero, audioContext.currentTime);
+            e.when = -1;
+            try { e.audioBufferSourceNode?.disconnect(); } catch (e) { }
+        });
+    }
+
+
+    #adjustZone(zone) {
+        if (zone.buffer) return Promise.resolve(zone);
+        zone.delay = 0;
+
+        if (zone.sample) {
+            const decoded = atob(zone.sample);
+            zone.buffer = this.#audioCtx.createBuffer(1, decoded.length / 2, zone.sampleRate);
+            const float32Array = zone.buffer.getChannelData(0);
+
+            for (let i = 0; i < decoded.length / 2; i++) {
+                const b1 = decoded.charCodeAt(i * 2) & 0xFF;
+                const b2 = decoded.charCodeAt(i * 2 + 1) & 0xFF;
+                let n = (b2 << 8) | b1;
+                if (n >= 32768) n -= 65536;
+                float32Array[i] = n / 32768.0;
+            }
+            this.#applyZoneParameters(zone);
+            return zone;
+
+        } else if (zone.file) {
+            const decoded = atob(zone.file);
+            const uint8Array = new Uint8Array(decoded.length);
+            for (let i = 0; i < decoded.length; i++) uint8Array[i] = decoded.charCodeAt(i);
+
+            this.#audioCtx.decodeAudioData(
+                uint8Array.buffer,
+                audioBuffer => {
+                    zone.buffer = audioBuffer;
+                    this.#applyZoneParameters(zone);
+                    return zone;
+                },
+                error => {
+                    console.error("Erreur de décodage audio:", error);
+                    return false;
+                }
+            );
+        } else {
+            this.#applyZoneParameters(zone);
+            return zone;
+        }
+    };
+
+
+    #applyZoneParameters(zone) {
+        zone.loopStart = this.#numValue(zone.loopStart, 0);
+        zone.loopEnd = this.#numValue(zone.loopEnd, 0);
+        zone.coarseTune = this.#numValue(zone.coarseTune, 0);
+        zone.fineTune = this.#numValue(zone.fineTune, 0);
+        zone.originalPitch = this.#numValue(zone.originalPitch, 6000);
+        zone.sampleRate = this.#numValue(zone.sampleRate, 44100);
+    };
+
+
+    #setupEnvelope(envelope, zone, volume, when, sampleDuration, noteDuration) {
+        envelope.gain.setValueAtTime(this.#noZeroVolume(0), this.#audioCtx.currentTime);
+
+        const duration = Math.min(noteDuration, sampleDuration - this.#afterTime);
         const ahdsr = (zone.ahdsr && zone.ahdsr.length > 0) ? zone.ahdsr : [
             { duration: 0, volume: 1 },
             { duration: duration, volume: 1 }
@@ -171,7 +144,7 @@ class WebAudioFontPlayer {
 
         envelope.gain.cancelScheduledValues(when);
         const initialVol = (ahdsr[0]?.volume ?? 1) * volume;
-        envelope.gain.setValueAtTime(this.noZeroVolume(initialVol), when);
+        envelope.gain.setValueAtTime(this.#noZeroVolume(initialVol), when);
 
         let lastTime = 0;
         let lastVolume = ahdsr[0]?.volume ?? 1;
@@ -182,74 +155,111 @@ class WebAudioFontPlayer {
                 if (stage.duration + lastTime > duration) {
                     const r = 1 - (stage.duration + lastTime - duration) / stage.duration;
                     const n = lastVolume - r * (lastVolume - stage.volume);
-                    envelope.gain.linearRampToValueAtTime(this.noZeroVolume(volume * n), when + duration);
+                    envelope.gain.linearRampToValueAtTime(this.#noZeroVolume(volume * n), when + duration);
                     break;
                 }
                 lastTime += stage.duration;
                 lastVolume = stage.volume;
-                envelope.gain.linearRampToValueAtTime(this.noZeroVolume(volume * lastVolume), when + lastTime);
+                envelope.gain.linearRampToValueAtTime(this.#noZeroVolume(volume * lastVolume), when + lastTime);
             }
         }
-        envelope.gain.linearRampToValueAtTime(this.noZeroVolume(0), when + duration + this.afterTime);
+        envelope.gain.linearRampToValueAtTime(this.#noZeroVolume(0), when + duration + this.#afterTime);
     }
 
-    findEnvelope(audioContext, target) {
-        let envelope = this.envelopes.find(e =>
-            e.target === target && audioContext.currentTime > e.when + e.duration + 0.001
-        );
 
+    #findEnvelope() {
+        let envelope = this.#envelopes.find(e => e.target === this.#audioCtx.destination && this.#audioCtx.currentTime > e.when + e.duration + 0.001);
         if (envelope) {
             if (envelope.audioBufferSourceNode) {
-                try { envelope.audioBufferSourceNode.stop(0); envelope.audioBufferSourceNode.disconnect(); } catch (e) { }
+                try {
+                    envelope.audioBufferSourceNode.stop(0);
+                    envelope.audioBufferSourceNode.disconnect();
+                } catch (e) { }
                 envelope.audioBufferSourceNode = null;
             }
         } else {
-            envelope = audioContext.createGain();
-            envelope.target = target;
-            envelope.connect(target);
+            envelope = this.#audioCtx.createGain();
+            envelope.gain.value = 0;
+            envelope.target = this.#audioCtx.destination;
+            envelope.connect(this.#audioCtx.destination);
             envelope.cancel = () => {
-                if (envelope.when + envelope.duration > audioContext.currentTime) {
+                if (envelope.when + envelope.duration > this.#audioCtx.currentTime) {
                     envelope.gain.cancelScheduledValues(0);
-                    envelope.gain.setTargetAtTime(0.00001, audioContext.currentTime, 0.1);
-                    envelope.when = audioContext.currentTime + 0.00001;
+                    envelope.gain.setTargetAtTime(this.#nearZero, this.#audioCtx.currentTime, 0.1);
+                    envelope.when = this.#audioCtx.currentTime + 0.00001;
                     envelope.duration = 0;
                 }
             };
-            this.envelopes.push(envelope);
+            this.#envelopes.push(envelope);
         }
         return envelope;
     }
 
-    findZone = (audioContext, preset, pitch) => {
-        const zone = preset.zones.findLast(z => pitch >= z.keyRangeLow && pitch <= z.keyRangeHigh + 1);
-        if (zone) this.adjustZone(audioContext, zone);
+
+    #findZone(pitch) {
+        const zone = this.#preset.zones.findLast(z => pitch >= z.keyRangeLow && pitch <= z.keyRangeHigh + 1);
+        if (zone) this.#adjustZone(this.#audioCtx, zone);
         return zone;
     };
 
-    limitVolume = (v) => {
+    
+    #limitVolume(v) {
         const requestedVolume = v ? 1.0 * v : 0.5;
         return Math.min(requestedVolume, 0.8);
     };
-    noZeroVolume = (n) => n > this.nearZero ? n : this.nearZero;
-    numValue = (a, b) => typeof a === "number" ? a : b;
 
-    resumeContext(audioContext) {
-        if (audioContext.state === 'suspended') audioContext.resume().catch(() => { });
+
+    #noZeroVolume(n) {
+        return n > this.#nearZero ? n : this.#nearZero;
     }
 
-    queueChord(ctx, tgt, prst, w, pchs, d, v, s) {
-        const vol = this.limitVolume(v);
-        return pchs.map((p, i) => this.queueWaveTable(ctx, tgt, prst, w, p, d, vol - Math.random() * 0.01, s?.[i])).filter(Boolean);
+
+    #numValue(a, b) {
+        return typeof a === "number" ? a : b;
     }
 
-    cancelQueue(audioContext) {
-        this.envelopes.forEach(e => {
-            e.gain.cancelScheduledValues(0);
-            e.gain.setValueAtTime(this.nearZero, audioContext.currentTime);
-            e.when = -1;
-            try { e.audioBufferSourceNode?.disconnect(); } catch (e) { }
+}
+
+
+class WebAudioFontChannel {
+
+    #input = null;
+    #output = null;
+    #audioCtx = null;
+    #limiter = null;
+
+    constructor(audioCtx) {
+        this.#audioCtx = audioCtx;
+        this.#input = this.#audioCtx.createGain();
+
+        let lastNode = this.#input;
+        [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384].forEach(freq => {
+            lastNode = this.#bandEqualizer(lastNode, freq);
+            this[`band${freq < 1000 ? freq : (freq / 1024) + 'k'}`] = lastNode;
         });
+
+        this.#limiter = this.#audioCtx.createDynamicsCompressor();
+        this.#limiter.threshold.setValueAtTime(-3.0, this.#audioCtx.currentTime);
+        this.#limiter.ratio.setValueAtTime(40, this.#audioCtx.currentTime);
+        this.#limiter.attack.setValueAtTime(0.000, this.#audioCtx.currentTime);
+        this.#limiter.release.setValueAtTime(0.25, this.#audioCtx.currentTime);
+        this.#output = this.#audioCtx.createGain();
+        lastNode.connect(this.#limiter);
+        this.#limiter.connect(this.#output);
     }
+
+
+    #bandEqualizer(from, frequency) {
+        const filter = this.#audioCtx.createBiquadFilter();
+        filter.frequency.setTargetAtTime(frequency, 0, 0.0001);
+        filter.type = "peaking";
+        filter.gain.setTargetAtTime(0, 0, 0.0001);
+        filter.Q.setTargetAtTime(1.0, 0, 0.0001);
+        from.connect(filter);
+        return filter;
+    }
+
 }
 
+
 export default WebAudioFontPlayer;