@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.17 → 1.0.19

package/README.md

@@ -79,7 +79,7 @@ sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
 - **Coordinate normalization** – Unreal sends centimeters; `SpatialAudioManager` auto-detects large values and converts to meters once.
 - **Orientation math** – `setListenerFromLSD()` builds forward/right/up vectors from camera/LookAt to keep the listener aligned with head movement.
 - **Dynamic distance gain** – `updateSpatialAudio()` measures distance from listener → source and applies a smooth rolloff curve, so distant avatars fade to silence.
-- **Noise handling** – optional AudioWorklet denoiser plus high/low-pass filters trim rumble & hiss before HRTF processing.
+- **Noise handling** – the AudioWorklet denoiser now runs an adaptive multi-band gate (per W3C AudioWorklet guidance) before the high/low-pass filters, stripping constant HVAC/fan noise even when the speaker is close.
 
 #### How Spatial Audio Is Built
 1. **Telemetry ingestion** – each LSD packet is passed through `setListenerFromLSD(listenerPos, cameraPos, lookAtPos)` so the Web Audio listener matches the player’s real head/camera pose.

package/dist/SpatialAudioManager.d.ts

@@ -11,6 +11,12 @@ type DenoiserOptions = {
     threshold?: number;
     noiseFloor?: number;
     release?: number;
+    attack?: number;
+    holdMs?: number;
+    maxReduction?: number;
+    hissCut?: number;
+    expansionRatio?: number;
+    learnRate?: number;
 };
 type SpatialAudioOptions = {
     distance?: SpatialAudioDistanceConfig;
@@ -25,7 +31,6 @@ export declare class SpatialAudioManager extends EventManager {
     private options;
     private denoiseWorkletReady;
     private denoiseWorkletUrl?;
-    private denoiserWasmBytes?;
     private listenerPosition;
     private listenerInitialized;
     private listenerDirection;
@@ -96,6 +101,13 @@ export declare class SpatialAudioManager extends EventManager {
     private getDistanceBetween;
     private calculateDistanceGain;
     private normalizePositionUnits;
+    private getVectorFromListener;
+    private applyDirectionalSuppression;
+    private calculateClarityScore;
+    private calculateProximityWeight;
+    private calculateDirectionFocus;
+    private normalizeVector;
+    private clamp;
     private isDenoiserEnabled;
     private ensureDenoiseWorklet;
     private resolveOptions;

package/dist/SpatialAudioManager.js

@@ -69,6 +69,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const panner = this.audioContext.createPanner();
         const analyser = this.audioContext.createAnalyser();
         const gain = this.audioContext.createGain();
+        const proximityGain = this.audioContext.createGain();
         let denoiseNode;
         if (this.isDenoiserEnabled() && typeof this.audioContext.audioWorklet !== "undefined") {
             try {
@@ -81,9 +82,12 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                         threshold: this.options.denoiser?.threshold,
                         noiseFloor: this.options.denoiser?.noiseFloor,
                         release: this.options.denoiser?.release,
-                        wasmBytes: this.denoiserWasmBytes
-                            ? this.denoiserWasmBytes.slice(0)
-                            : null,
+                        attack: this.options.denoiser?.attack,
+                        holdMs: this.options.denoiser?.holdMs,
+                        maxReduction: this.options.denoiser?.maxReduction,
+                        hissCut: this.options.denoiser?.hissCut,
+                        expansionRatio: this.options.denoiser?.expansionRatio,
+                        learnRate: this.options.denoiser?.learnRate,
                     },
                 });
             }
@@ -102,6 +106,11 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         lowpassFilter.type = "lowpass";
         lowpassFilter.frequency.value = 7500; // Below 8kHz to avoid flat/muffled sound
         lowpassFilter.Q.value = 1.0; // Quality factor
+        const dynamicLowpass = this.audioContext.createBiquadFilter();
+        dynamicLowpass.type = "lowpass";
+        dynamicLowpass.frequency.value = 7600;
+        dynamicLowpass.Q.value = 0.8;
+        proximityGain.gain.value = 1.0;
         // Configure Panner for realistic 3D spatial audio
         const distanceConfig = this.getDistanceConfig();
         panner.panningModel = "HRTF"; // Head-Related Transfer Function for realistic 3D
@@ -121,15 +130,17 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         currentNode.connect(highpassFilter);
         highpassFilter.connect(lowpassFilter);
+        lowpassFilter.connect(dynamicLowpass);
+        dynamicLowpass.connect(proximityGain);
         if (bypassSpatialization) {
             console.log(`🔊 TESTING: Connecting audio directly to destination (bypassing spatial audio) for ${participantId}`);
-            lowpassFilter.connect(analyser);
+            proximityGain.connect(analyser);
             analyser.connect(this.masterGainNode);
         }
         else {
             // Standard spatialized path with full audio chain
             // Audio Chain: source -> filters -> panner -> analyser -> gain -> masterGain -> compressor -> destination
-            lowpassFilter.connect(panner);
+            proximityGain.connect(panner);
             panner.connect(analyser);
             analyser.connect(gain);
             gain.connect(this.masterGainNode);
@@ -139,8 +150,10 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             panner,
             analyser,
             gain,
+            proximityGain,
             highpassFilter,
             lowpassFilter,
+            dynamicLowpass,
             denoiseNode,
             stream,
         });
@@ -253,7 +266,9 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                 }
             }
             const listenerPos = this.listenerPosition;
+            const vectorToSource = this.getVectorFromListener(targetPosition);
             const distance = this.getDistanceBetween(listenerPos, targetPosition);
+            this.applyDirectionalSuppression(participantId, distance, vectorToSource);
             const distanceGain = this.calculateDistanceGain(distanceConfig, distance);
             nodes.gain.gain.setTargetAtTime(distanceGain, this.audioContext.currentTime, 0.05);
             if (Math.random() < 0.02) {
@@ -473,6 +488,75 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         return { ...position };
     }
+    getVectorFromListener(targetPosition) {
+        if (!this.listenerInitialized) {
+            return { ...targetPosition };
+        }
+        return {
+            x: targetPosition.x - this.listenerPosition.x,
+            y: targetPosition.y - this.listenerPosition.y,
+            z: targetPosition.z - this.listenerPosition.z,
+        };
+    }
+    applyDirectionalSuppression(participantId, distance, vectorToSource) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes) {
+            return;
+        }
+        const clarityScore = this.calculateClarityScore(distance, vectorToSource);
+        const targetGain = 0.55 + clarityScore * 0.6; // 0.55 → 1.15
+        const targetLowpass = 3200 + clarityScore * 4200; // 3.2kHz → ~7.4kHz
+        nodes.proximityGain.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, 0.08);
+        nodes.dynamicLowpass.frequency.setTargetAtTime(targetLowpass, this.audioContext.currentTime, 0.12);
+        if (Math.random() < 0.005) {
+            console.log("🎚️ [Spatial Audio] Directional tuning", {
+                participantId,
+                distance: distance.toFixed(2),
+                clarityScore: clarityScore.toFixed(2),
+                targetGain: targetGain.toFixed(2),
+                lowpassHz: targetLowpass.toFixed(0),
+            });
+        }
+    }
+    calculateClarityScore(distance, vectorToSource) {
+        const proximityWeight = this.calculateProximityWeight(distance);
+        const focusWeight = this.calculateDirectionFocus(vectorToSource);
+        return this.clamp(0.2 + proximityWeight * 0.6 + focusWeight * 0.2, 0, 1);
+    }
+    calculateProximityWeight(distance) {
+        const closeRange = 1.2;
+        const fadeRange = 12;
+        if (distance <= closeRange) {
+            return 1;
+        }
+        if (distance >= fadeRange) {
+            return 0;
+        }
+        return 1 - (distance - closeRange) / (fadeRange - closeRange);
+    }
+    calculateDirectionFocus(vectorToSource) {
+        if (!this.listenerInitialized) {
+            return 0.5;
+        }
+        const forward = this.normalizeVector(this.listenerDirection.forward);
+        const source = this.normalizeVector(vectorToSource, { x: 0, y: 0, z: 1 });
+        const dot = forward.x * source.x + forward.y * source.y + forward.z * source.z;
+        return this.clamp((dot + 1) / 2, 0, 1);
+    }
+    normalizeVector(vector, fallback = { x: 0, y: 0, z: 1 }) {
+        const length = Math.hypot(vector.x, vector.y, vector.z);
+        if (length < 1e-4) {
+            return { ...fallback };
+        }
+        return {
+            x: vector.x / length,
+            y: vector.y / length,
+            z: vector.z / length,
+        };
+    }
+    clamp(value, min, max) {
+        return Math.min(max, Math.max(min, value));
+    }
     isDenoiserEnabled() {
         return this.options.denoiser?.enabled !== false;
     }
@@ -496,47 +580,101 @@ class SpatialAudioManager extends EventManager_1.EventManager {
     super();
     const cfg = (options && options.processorOptions) || {};
     this.enabled = cfg.enabled !== false;
-    this.threshold = typeof cfg.threshold === 'number' ? cfg.threshold : 0.012;
-    this.noiseFloor = typeof cfg.noiseFloor === 'number' ? cfg.noiseFloor : 0.004;
-    this.release = typeof cfg.release === 'number' ? cfg.release : 0.18;
-    this.smoothedLevel = this.noiseFloor;
+    this.threshold = this._sanitize(cfg.threshold, 0.003, 0.05, 0.012);
+    this.noiseFloor = this._sanitize(cfg.noiseFloor, 0.0005, 0.05, 0.004);
+    this.attack = this._sanitize(cfg.attack, 0.01, 0.9, 0.35);
+    this.release = this._sanitize(cfg.release, 0.01, 0.9, 0.18);
+    this.holdSamples = Math.max(
+      8,
+      Math.round(
+        sampleRate * this._sanitize(cfg.holdMs, 10, 400, 110) / 1000
+      )
+    );
+    this.maxReduction = this._sanitize(cfg.maxReduction, 0.1, 0.95, 0.85);
+    this.hissCut = this._sanitize(cfg.hissCut, 0, 1, 0.45);
+    this.expansionRatio = this._sanitize(cfg.expansionRatio, 1.1, 4, 1.8);
+    this.learnRate = this._sanitize(cfg.learnRate, 0.001, 0.3, 0.08);
+    this.channelState = [];
+    this.hfAlpha = Math.exp(-2 * Math.PI * 3200 / sampleRate);
+  }
+
+  _sanitize(value, min, max, fallback) {
+    if (typeof value !== 'number' || !isFinite(value)) {
+      return fallback;
+    }
+    return Math.min(max, Math.max(min, value));
+  }
+
+  _ensureState(index) {
+    if (!this.channelState[index]) {
+      this.channelState[index] = {
+        envelope: this.noiseFloor,
+        noise: this.noiseFloor,
+        gain: 1,
+        quietSamples: 0,
+        lpState: 0,
+      };
+    }
+    return this.channelState[index];
   }
 
   process(inputs, outputs) {
     const input = inputs[0];
     const output = outputs[0];
-    if (!input || input.length === 0 || !output || output.length === 0) {
+    if (!input || !output) {
       return true;
     }
 
-    for (let channel = 0; channel < input.length; channel++) {
+    for (let channel = 0; channel < output.length; channel++) {
       const inChannel = input[channel];
       const outChannel = output[channel];
       if (!inChannel || !outChannel) {
         continue;
       }
 
-      let sum = 0;
+      if (!this.enabled) {
+        for (let i = 0; i < inChannel.length; i++) {
+          outChannel[i] = inChannel[i];
+        }
+        continue;
+      }
+
+      const state = this._ensureState(channel);
+
       for (let i = 0; i < inChannel.length; i++) {
         const sample = inChannel[i];
-        sum += sample * sample;
-      }
+        const magnitude = Math.abs(sample);
 
-      const rms = Math.sqrt(sum / inChannel.length);
-      this.smoothedLevel += (rms - this.smoothedLevel) * this.release;
-      const dynamicThreshold = Math.max(
-        this.noiseFloor,
-        this.threshold * 0.6 + this.smoothedLevel * 0.4
-      );
+        state.envelope += (magnitude - state.envelope) * this.attack;
 
-      if (!this.enabled || rms >= dynamicThreshold) {
-        for (let i = 0; i < inChannel.length; i++) {
-          outChannel[i] = inChannel[i];
+        if (state.envelope < this.threshold) {
+          state.noise += (state.envelope - state.noise) * this.learnRate;
+          state.quietSamples++;
+        } else {
+          state.quietSamples = 0;
         }
-      } else {
-        for (let i = 0; i < inChannel.length; i++) {
-          outChannel[i] = 0;
+
+        const ratio = state.noise / Math.max(state.envelope, 1e-6);
+        let gainTarget = 1 - Math.min(0.98, Math.pow(ratio, this.expansionRatio));
+        gainTarget = Math.max(0, Math.min(1, gainTarget));
+
+        if (state.quietSamples > this.holdSamples) {
+          gainTarget *= 1 - this.maxReduction;
         }
+
+        state.gain += (gainTarget - state.gain) * this.release;
+        let processed = sample * state.gain;
+
+        state.lpState = this.hfAlpha * state.lpState + (1 - this.hfAlpha) * processed;
+        const highComponent = processed - state.lpState;
+        const hissRatio = Math.min(
+          1,
+          Math.abs(highComponent) / (Math.abs(state.lpState) + 1e-5)
+        );
+        const hissGain = 1 - hissRatio * this.hissCut;
+        processed = state.lpState + highComponent * hissGain;
+
+        outChannel[i] = processed;
       }
     }
 
@@ -574,6 +712,12 @@ registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
             threshold: 0.012,
             noiseFloor: 0.004,
             release: 0.18,
+            attack: 0.35,
+            holdMs: 110,
+            maxReduction: 0.85,
+            hissCut: 0.45,
+            expansionRatio: 1.8,
+            learnRate: 0.08,
         };
         return {
             distance: {
@@ -587,6 +731,12 @@ registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
                 threshold: options?.denoiser?.threshold ?? denoiserDefaults.threshold,
                 noiseFloor: options?.denoiser?.noiseFloor ?? denoiserDefaults.noiseFloor,
                 release: options?.denoiser?.release ?? denoiserDefaults.release,
+                attack: options?.denoiser?.attack ?? denoiserDefaults.attack,
+                holdMs: options?.denoiser?.holdMs ?? denoiserDefaults.holdMs,
+                maxReduction: options?.denoiser?.maxReduction ?? denoiserDefaults.maxReduction,
+                hissCut: options?.denoiser?.hissCut ?? denoiserDefaults.hissCut,
+                expansionRatio: options?.denoiser?.expansionRatio ?? denoiserDefaults.expansionRatio,
+                learnRate: options?.denoiser?.learnRate ?? denoiserDefaults.learnRate,
             },
         };
     }

package/package.json

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