audio-mixer-engine 0.3.4 → 0.4.0

package/src/lib/midi-player.js

@@ -182,6 +182,8 @@ export default class MidiPlayer {
     if (doRestart) {
       this.pause();
     }
+
+    const midiTime = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed;
     
     this.playbackSpeed = speed;
     
@@ -189,7 +191,7 @@ export default class MidiPlayer {
       this.play();
     } else {
       // if not restarting, then reset the reference time
-      this.playbackStartTime = this.audioEngine.audioContext.currentTime - (this._currentTime / this.playbackSpeed);
+      this.playbackStartTime = this.audioEngine.audioContext.currentTime - (midiTime / this.playbackSpeed);
     }
   }
 

package/src/lib/spessasynth-audio-engine.js

@@ -1,4 +1,4 @@
-import AudioEngine, { ChannelHandle, AudioEngineUtils } from './audio-engine.js';
+import AudioEngine from './audio-engine.js';
 import SpessaSynthChannelHandle from './spessasynth-channel-handle.js';
 
 /**
@@ -18,54 +18,48 @@ export default class SpessaSynthAudioEngine extends AudioEngine {
   }
 
   async initialize(soundfontData) {
-    try {
-      // Import SpessaSynth WorkletSynthesizer
-      const { WorkletSynthesizer } = await import('spessasynth_lib');
-      
-      // Handle different soundfont data types
-      let soundfontBuffer;
-      if (typeof soundfontData === 'string') {
-        soundfontBuffer = await this._loadSoundfontFromPath(soundfontData);
-      } else if (soundfontData instanceof ArrayBuffer) {
-        soundfontBuffer = soundfontData;
-      } else {
-        throw new Error('Invalid soundfont data type. Expected string path or ArrayBuffer.');
-      }
-
-      // Add the AudioWorklet module (required by SpessaSynth)
-      // Use aggressive Firefox-specific loading strategy
-      await this._loadAudioWorkletSafely();
-      
-      // Create individual output nodes for each MIDI channel (16 channels)
-      this._setupIndividualOutputs();
-      
-      // Create a dummy target node for the synthesizer (won't be used for output)
-      // SpessaSynth requires a valid AudioNode but we'll use individual outputs instead
-      this.dummyTarget = this.audioContext.createGain();
-      // Don't connect dummyTarget to anything - it's just to satisfy the constructor
-      
-      // Add delay before synthesizer creation to prevent Firefox timing issues
-      await new Promise(resolve => setTimeout(resolve, 50));
-      
-      // Create synthesizer with v4 API
-      this.synthesizer = new WorkletSynthesizer(this.audioContext);
-      
-      // Load soundfont using the v4 API
-      await this.synthesizer.soundBankManager.addSoundBank(soundfontBuffer, 'main');
-      await this.synthesizer.isReady;
-      
-      // Connect individual outputs for per-channel routing
-      this._connectIndividualOutputs();
-
-      // Initialize metronome channel with woodblock instrument
-      this._initializeMetronomeChannel();
-
-      this.isInitialized = true;
-      
-    } catch (error) {
-      console.error('Failed to initialize SpessaSynthAudioEngine:', error);
-      throw error;
+    // Import SpessaSynth WorkletSynthesizer
+    const { WorkletSynthesizer } = await import('spessasynth_lib');
+
+    // Handle different soundfont data types
+    let soundfontBuffer;
+    if (typeof soundfontData === 'string') {
+      soundfontBuffer = await this._loadSoundfontFromPath(soundfontData);
+    } else if (soundfontData instanceof ArrayBuffer) {
+      soundfontBuffer = soundfontData;
+    } else {
+      throw new Error('Invalid soundfont data type. Expected string path or ArrayBuffer.');
     }
+
+    // Add the AudioWorklet module (required by SpessaSynth)
+    // Use aggressive Firefox-specific loading strategy
+    await this._loadAudioWorkletSafely();
+
+    // Create individual output nodes for each MIDI channel (16 channels)
+    this._setupIndividualOutputs();
+
+    // Create a dummy target node for the synthesizer (won't be used for output)
+    // SpessaSynth requires a valid AudioNode but we'll use individual outputs instead
+    this.dummyTarget = this.audioContext.createGain();
+    // Don't connect dummyTarget to anything - it's just to satisfy the constructor
+
+    // Add delay before synthesizer creation to prevent Firefox timing issues
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // Create synthesizer with v4 API
+    this.synthesizer = new WorkletSynthesizer(this.audioContext);
+
+    // Load soundfont using the v4 API
+    await this.synthesizer.soundBankManager.addSoundBank(soundfontBuffer, 'main');
+    await this.synthesizer.isReady;
+
+    // Connect individual outputs for per-channel routing
+    this._connectIndividualOutputs();
+
+    // Initialize metronome channel with woodblock instrument
+    this._initializeMetronomeChannel();
+
+    this.isInitialized = true;
   }
 
   createChannel(partId, options = {}) {
@@ -261,21 +255,11 @@ export default class SpessaSynthAudioEngine extends AudioEngine {
    * @private
    */
   async _loadSoundfontFromPath(path) {
-    if (typeof window !== 'undefined') {
-      // Browser environment
-      const response = await fetch(path);
-      if (!response.ok) {
-        throw new Error(`Failed to load soundfont: ${response.status} ${response.statusText}`);
-      }
-      return await response.arrayBuffer();
-    } else {
-      // Node.js environment
-      const fs = await import('fs');
-      const pathModule = await import('path');
-      
-      const resolvedPath = pathModule.isAbsolute(path) ? path : pathModule.resolve(process.cwd(), path);
-      return fs.readFileSync(resolvedPath).buffer;
+    const response = await fetch(path);
+    if (!response.ok) {
+      throw new Error(`Failed to load soundfont: ${response.status} ${response.statusText}`);
     }
+    return await response.arrayBuffer();
   }
 
   /**
@@ -371,32 +355,60 @@ export default class SpessaSynthAudioEngine extends AudioEngine {
       const delay = startTime - currentTime;
 
       // Note: instrument (woodblock) is already set during channel creation
-      if (delay <= 0.010) { // 10ms tolerance for immediate playback (includes test scenarios)
-        // Play immediately if time is now or very close
-        if (synthesizer.noteOn) {
-          synthesizer.noteOn(midiChannel, note, velocity);
-        }
-
-        // Schedule note off after brief duration
-        setTimeout(() => {
-          if (synthesizer.noteOff) {
-            synthesizer.noteOff(midiChannel, note);
+      // Use SpessaSynth's precise scheduling with options.time (NO setTimeout!)
+      const tickDuration = 0.1; // 100ms tick duration
+
+      if (synthesizer.post) {
+        // Send note-on message with precise timing
+        synthesizer.post({
+          channelNumber: midiChannel,
+          type: "midiMessage",
+          data: {
+            messageData: [0x90 | midiChannel, note, velocity],
+            channelOffset: 0,
+            force: false,
+            options: {
+              time: startTime  // Sample-accurate metronome timing!
+            }
           }
-        }, 100); // 100ms tick duration
+        });
+
+        // Send note-off message with precise timing
+        synthesizer.post({
+          channelNumber: midiChannel,
+          type: "midiMessage",
+          data: {
+            messageData: [0x80 | midiChannel, note, 0],
+            channelOffset: 0,
+            force: false,
+            options: {
+              time: startTime + tickDuration  // Precise tick duration!
+            }
+          }
+        });
       } else {
-        // Schedule for future playback
-        setTimeout(() => {
+        // Fallback to direct method calls if post() not available
+        if (delay <= 0.010) {
           if (synthesizer.noteOn) {
             synthesizer.noteOn(midiChannel, note, velocity);
           }
-
-          // Schedule note off
           setTimeout(() => {
             if (synthesizer.noteOff) {
               synthesizer.noteOff(midiChannel, note);
             }
           }, 100);
-        }, delay * 1000); // Convert seconds to milliseconds
+        } else {
+          setTimeout(() => {
+            if (synthesizer.noteOn) {
+              synthesizer.noteOn(midiChannel, note, velocity);
+            }
+            setTimeout(() => {
+              if (synthesizer.noteOff) {
+                synthesizer.noteOff(midiChannel, note);
+              }
+            }, 100);
+          }, delay * 1000);
+        }
       }
 
     } catch (error) {

package/src/lib/spessasynth-channel-handle.js

@@ -111,6 +111,88 @@ export default class SpessaSynthChannelHandle extends ChannelHandle {
     return this.activeNotes.size;
   }
 
+  /**
+   * Override playNote to use SpessaSynth's precise sample-accurate scheduling
+   * @param {number} startTime - Absolute audio context time when note should start
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @param {number} velocity - Note velocity (0-127)
+   * @param {number} duration - Note duration in seconds
+   * @returns {string} Event ID for compatibility
+   */
+  playNote(startTime, pitch, velocity, duration) {
+    this._validateActive();
+
+    const eventId = `${this.partId}_${startTime}_${pitch}_${Date.now()}`;
+
+    // Get the synthesizer for message posting
+    const synthesizer = this.engine._getSynthesizer();
+    if (synthesizer && synthesizer.post) {
+      // Apply channel volume
+      const adjustedVelocity = Math.round(velocity * this.currentVolume);
+
+      // Send note-on message with precise timing (NO setTimeout!)
+      synthesizer.post({
+        channelNumber: this.midiChannel,
+        type: "midiMessage",
+        data: {
+          messageData: [0x90 | this.midiChannel, pitch, adjustedVelocity],
+          channelOffset: 0,
+          force: false,
+          options: {
+            time: startTime  // SpessaSynth will schedule this precisely!
+          }
+        }
+      });
+
+      // Send note-off message with precise timing (NO setTimeout!)
+      synthesizer.post({
+        channelNumber: this.midiChannel,
+        type: "midiMessage",
+        data: {
+          messageData: [0x80 | this.midiChannel, pitch, 0],
+          channelOffset: 0,
+          force: false,
+          options: {
+            time: startTime + duration  // Precise note-off timing!
+          }
+        }
+      });
+
+    } else {
+      // Fallback to parent implementation if synthesizer.post not available
+      return super.playNote(startTime, pitch, velocity, duration);
+    }
+
+    return eventId;
+  }
+
+  /**
+   * Override allNotesOff to use SpessaSynth messaging system
+   */
+  allNotesOff() {
+    this._validateActive();
+
+    const synthesizer = this.engine._getSynthesizer();
+    if (synthesizer && synthesizer.post) {
+      // Send MIDI All Notes Off controller message (CC 123) immediately
+      synthesizer.post({
+        channelNumber: this.midiChannel,
+        type: "midiMessage",
+        data: {
+          messageData: [0xB0 | this.midiChannel, 123, 0], // Control Change: All Notes Off
+          channelOffset: 0,
+          force: false,
+          options: {
+            time: this.engine.audioContext.currentTime // Execute immediately
+          }
+        }
+      });
+    } else {
+      // Fallback to parent implementation
+      super.allNotesOff();
+    }
+  }
+
   destroy() {
     if (!this.isDestroyed) {
       // Note: Don't disconnect outputGain if it's an individual output from the synthesizer
@@ -122,7 +204,7 @@ export default class SpessaSynthChannelHandle extends ChannelHandle {
       }
       this.outputGain = null;
     }
-    
+
     // Call parent destroy (handles allNotesOff and cleanup)
     super.destroy();
   }