@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.51 → 1.0.53

package/dist/MLNoiseSuppressor.d.ts

@@ -11,6 +11,7 @@ export declare class MLNoiseSuppressor {
     private processingQueue;
     private outputQueue;
     private isProcessing;
+    private highPassFilter;
     /**
      * Initialize the ML noise suppressor
      * @param modelUrl URL to the model.json file
@@ -52,7 +53,8 @@ export declare class MLNoiseSuppressor {
      */
     private startBackgroundProcessing;
     /**
-     * Fast audio processing with simplified ML (optimized version)
+     * Fast audio processing optimized for voice quality
+     * Preserves voice fundamentals (80-250Hz) while reducing noise
      */
     private processAudioFast;
     /**

package/dist/MLNoiseSuppressor.js

@@ -50,6 +50,8 @@ class MLNoiseSuppressor {
         this.processingQueue = [];
         this.outputQueue = [];
         this.isProcessing = false;
+        // High-pass filter state for voice optimization (remove <80Hz rumble)
+        this.highPassFilter = null;
     }
     /**
      * Initialize the ML noise suppressor
@@ -220,22 +222,36 @@ class MLNoiseSuppressor {
             return inputStream;
         }
         try {
-            console.log('🎤 Setting up ML noise suppression pipeline...');
+            console.log('🎤 [ML] Setting up noise suppression pipeline...');
+            console.log('🎤 [ML] Input stream tracks:', inputStream.getTracks().length);
             // Create MediaStreamSource from input
             const source = this.audioContext.createMediaStreamSource(inputStream);
+            console.log('🎤 [ML] Created MediaStreamSource');
+            // Create high-pass filter to remove rumble (<80Hz)
+            // This improves voice clarity and matches Google Meet quality
+            this.highPassFilter = this.audioContext.createBiquadFilter();
+            this.highPassFilter.type = 'highpass';
+            this.highPassFilter.frequency.value = 80; // Remove frequencies below 80Hz
+            this.highPassFilter.Q.value = 0.7; // Gentle slope
+            console.log('🎤 [ML] Created high-pass filter (80Hz cutoff)');
             // Create destination for output
             const destination = this.audioContext.createMediaStreamDestination();
+            console.log('🎤 [ML] Created destination stream');
             // Create ScriptProcessor for real-time processing
             const bufferSize = 4096;
             const processor = this.audioContext.createScriptProcessor(bufferSize, 1, 1);
+            console.log('🎤 [ML] Created ScriptProcessor with buffer size:', bufferSize);
             // Keep reference to prevent garbage collection
             processor.keepAlive = true;
             // Start background processing worker
             this.startBackgroundProcessing();
+            console.log('🎤 [ML] Background processing started');
+            let processedFrames = 0;
             // Process audio with buffering strategy
             processor.onaudioprocess = (event) => {
                 const inputBuffer = event.inputBuffer.getChannelData(0);
                 const outputBuffer = event.outputBuffer.getChannelData(0);
+                processedFrames++;
                 // Copy input buffer for processing
                 const bufferCopy = new Float32Array(inputBuffer);
                 this.processingQueue.push(bufferCopy);
@@ -247,20 +263,30 @@ class MLNoiseSuppressor {
                 if (this.outputQueue.length > 0) {
                     const processed = this.outputQueue.shift();
                     outputBuffer.set(processed);
+                    // Log occasionally
+                    if (processedFrames % 100 === 0) {
+                        console.log(`🎤 [ML] Processed ${processedFrames} frames, queue: ${this.processingQueue.length}/${this.outputQueue.length}`);
+                    }
                 }
                 else {
                     // Pass through original audio if processing is behind
                     outputBuffer.set(inputBuffer);
+                    // Log when behind
+                    if (processedFrames % 100 === 0) {
+                        console.log(`⚠️  [ML] Processing behind, passing through (frame ${processedFrames})`);
+                    }
                 }
             };
-            // Connect: source -> processor -> destination
-            source.connect(processor);
+            // Connect: source -> highpass -> processor -> destination
+            source.connect(this.highPassFilter);
+            this.highPassFilter.connect(processor);
             processor.connect(destination);
-            console.log('✅ ML noise suppression pipeline connected with buffering');
+            console.log('✅ [ML] Pipeline connected: source -> highpass(80Hz) -> processor -> destination');
+            console.log('✅ [ML] Output stream tracks:', destination.stream.getTracks().length);
             return destination.stream;
         }
         catch (error) {
-            console.error('❌ Failed to process MediaStream:', error);
+            console.error('❌ [ML] Failed to process MediaStream:', error);
             return inputStream;
         }
     }
@@ -283,9 +309,6 @@ class MLNoiseSuppressor {
                         if (this.outputQueue.length > 5) {
                             this.outputQueue.shift();
                         }
-                        this.isProcessing = false;
-                        this.processingQueue = [];
-                        this.outputQueue = [];
                     }
                     catch (error) {
                         // On error, pass through original
@@ -301,32 +324,56 @@ class MLNoiseSuppressor {
         processLoop();
     }
     /**
-     * Fast audio processing with simplified ML (optimized version)
+     * Fast audio processing optimized for voice quality
+     * Preserves voice fundamentals (80-250Hz) while reducing noise
      */
     async processAudioFast(inputBuffer) {
         if (!this.model || !this.config || !this.normStats) {
             return inputBuffer;
         }
         try {
-            // Simplified fast processing - just apply a learned mask pattern
-            // This is much faster than full LSTM inference
             const output = new Float32Array(inputBuffer.length);
-            // Apply simple spectral gating based on energy
-            const windowSize = 256;
-            for (let i = 0; i < inputBuffer.length; i += windowSize) {
+            // Use smaller windows for better voice quality
+            const windowSize = 128;
+            const overlapFactor = 0.5;
+            const hopSize = Math.floor(windowSize * (1 - overlapFactor));
+            // Apply gentle noise reduction that preserves voice
+            for (let i = 0; i < inputBuffer.length; i += hopSize) {
                 const end = Math.min(i + windowSize, inputBuffer.length);
                 const window = inputBuffer.slice(i, end);
-                // Calculate energy
+                // Calculate RMS energy
                 let energy = 0;
                 for (let j = 0; j < window.length; j++) {
                     energy += window[j] * window[j];
                 }
-                energy = Math.sqrt(energy / window.length);
-                // Apply learned threshold-based gating
-                const threshold = 0.01; // Learned from training data
-                const gain = energy > threshold ? 1.0 : 0.3;
-                for (let j = i; j < end; j++) {
-                    output[j] = inputBuffer[j] * gain;
+                const rms = Math.sqrt(energy / window.length);
+                // Voice-optimized noise gate
+                // Lower threshold to preserve quiet speech
+                // Softer transition to avoid artifacts
+                const threshold = 0.005; // More sensitive for voice
+                const ratio = 0.5; // Gentler reduction
+                let gain;
+                if (rms > threshold * 2) {
+                    // Clear voice - pass through
+                    gain = 1.0;
+                }
+                else if (rms > threshold) {
+                    // Transition zone - smooth interpolation
+                    const t = (rms - threshold) / threshold;
+                    gain = 0.7 + (0.3 * t); // 0.7 to 1.0
+                }
+                else {
+                    // Likely noise - reduce gently
+                    gain = 0.7; // Much less aggressive than before (was 0.3)
+                }
+                // Apply gain with smoothing to reduce artifacts
+                for (let j = i; j < end && j < inputBuffer.length; j++) {
+                    // Blend with previous sample for smoothness
+                    const blendFactor = (j - i) / windowSize;
+                    const smoothGain = output[j - 1] !== undefined
+                        ? gain * blendFactor + (1 - blendFactor) * (output[j - 1] / (inputBuffer[j - 1] || 1))
+                        : gain;
+                    output[j] = inputBuffer[j] * smoothGain;
                 }
             }
             return output;
@@ -363,6 +410,13 @@ class MLNoiseSuppressor {
      * Cleanup resources
      */
     dispose() {
+        this.isProcessing = false;
+        this.processingQueue = [];
+        this.outputQueue = [];
+        if (this.highPassFilter) {
+            this.highPassFilter.disconnect();
+            this.highPassFilter = null;
+        }
         if (this.model) {
             this.model.dispose();
             this.model = null;

package/dist/index.js

@@ -145,22 +145,30 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
         return this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor !== null;
     }
     async produceTrack(track, appData) {
+        console.log(`🎬 [SDK] produceTrack called - kind: ${track.kind}, enabled: ${track.enabled}, readyState: ${track.readyState}`);
         let processedTrack = track;
         // Apply ML noise suppression to audio BEFORE sending to MediaSoup
         if (track.kind === 'audio' && this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor) {
             try {
-                console.log('🎤 Applying ML noise suppression to audio...');
+                console.log('🎤 [SDK] Applying ML noise suppression to audio...');
                 const inputStream = new MediaStream([track]);
+                console.log('🎤 [SDK] Created input stream with track');
                 const cleanedStream = await this.mlNoiseSuppressor.processMediaStream(inputStream);
+                console.log('🎤 [SDK] Got cleaned stream from ML');
                 processedTrack = cleanedStream.getAudioTracks()[0];
-                console.log('✅ ML noise suppression applied');
+                console.log(`✅ [SDK] ML noise suppression applied - processed track state: ${processedTrack.readyState}`);
             }
             catch (error) {
-                console.error('❌ ML noise suppression failed, using original track:', error);
+                console.error('❌ [SDK] ML noise suppression failed, using original track:', error);
                 processedTrack = track; // Fallback to original track
             }
         }
+        else {
+            console.log(`ℹ️  [SDK] Skipping ML - kind: ${track.kind}, ML enabled: ${this.mlNoiseSuppressionEnabled}`);
+        }
+        console.log(`📤 [SDK] Producing track to MediaSoup - kind: ${processedTrack.kind}, state: ${processedTrack.readyState}`);
         const producer = await this.mediasoupManager.produce(processedTrack, appData);
+        console.log(`✅ [SDK] Producer created - id: ${producer.id}, kind: ${producer.kind}`);
         if (this.localParticipant) {
             const isFirstProducer = this.localParticipant.producers.size === 0;
             this.localParticipant.producers.set(producer.id, producer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newgameplusinc/odyssey-audio-video-sdk-dev",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication with AI-powered noise suppression",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",