@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.259 → 1.0.261

package/dist/audio/MLNoiseSuppressor.js

@@ -63,18 +63,11 @@ class MLNoiseSuppressor {
             // Set TensorFlow.js backend
             await tf.setBackend('webgl');
             await tf.ready();
-            // Load model with input shape fix
-            const modelJson = await (await fetch(modelUrl)).json();
-            if (modelJson.modelTopology?.config?.layers?.[0]?.config
-                ?.batch_input_shape === undefined) {
-                modelJson.modelTopology.config.layers[0].config.batch_input_shape = [
-                    null,
-                    257,
-                    1,
-                    1,
-                ];
-            }
-            this.model = await tf.loadLayersModel(tf.io.fromMemory(modelJson.modelTopology, modelJson.weightsManifest[0].weights));
+            // Load model - use standard loadLayersModel instead of fromMemory
+            // This handles weight loading automatically
+            console.log(`[MLNoiseSuppressor] Loading model from: ${modelUrl}`);
+            this.model = await tf.loadLayersModel(modelUrl);
+            console.log(`[MLNoiseSuppressor] Model loaded successfully`);
             // Load config
             const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf('/'));
             const configResponse = await fetch(`${baseUrl}/model_config.json`);
@@ -88,8 +81,10 @@ class MLNoiseSuppressor {
                 this.normStats = { mean: 0, std: 1 };
             }
             this.isInitialized = true;
+            console.log(`[MLNoiseSuppressor] Initialization complete`);
         }
         catch (error) {
+            console.error(`[MLNoiseSuppressor] Initialization failed:`, error);
             throw error;
         }
     }

package/dist/channels/spatial/SpatialAudioChannel.js

@@ -62,11 +62,25 @@ class SpatialAudioChannel {
      * Setup spatial audio for a participant
      */
     async setupParticipant(participantId, track, bypassSpatialization = false) {
+        console.log(`🎧 [SpatialAudioChannel] Setting up participant ${participantId.substring(0, 8)}`, {
+            trackKind: track.kind,
+            trackEnabled: track.enabled,
+            trackMuted: track.muted,
+            trackReadyState: track.readyState,
+            bypassSpatialization,
+            audioContextState: this.audioContext.state,
+        });
         if (this.audioContext.state === 'suspended') {
+            console.log(`🎧 [SpatialAudioChannel] Resuming suspended AudioContext...`);
             await this.audioContext.resume();
+            console.log(`🎧 [SpatialAudioChannel] AudioContext resumed, state: ${this.audioContext.state}`);
         }
         const stream = new MediaStream([track]);
         const source = this.audioContext.createMediaStreamSource(stream);
+        console.log(`🎧 [SpatialAudioChannel] Created MediaStreamSource for ${participantId.substring(0, 8)}`, {
+            streamActive: stream.active,
+            streamTracks: stream.getTracks().length,
+        });
         // Create all audio nodes
         const panner = this.createPanner();
         const stereoPanner = this.audioContext.createStereoPanner();
@@ -124,6 +138,13 @@ class SpatialAudioChannel {
             dynamicLowpass,
             stream,
         });
+        console.log(`🎧 [SpatialAudioChannel] ✅ Audio pipeline setup complete for ${participantId.substring(0, 8)}`, {
+            bypassSpatialization,
+            masterGainValue: this.masterGainNode.gain.value,
+            participantGainValue: gain.gain.value,
+            audioContextState: this.audioContext.state,
+            connectedToDestination: true,
+        });
     }
     /**
      * Update spatial audio for a participant

package/dist/core/MediasoupManager.js

@@ -66,12 +66,31 @@ class MediasoupManager {
     }
     async createSendTransport(participantId) {
         const params = await this.createWebRtcTransport('send', participantId);
-        this.sendTransport = this.device.createSendTransport(params);
+        // Extract iceServers from params and pass them correctly
+        const { iceServers, ...transportParams } = params;
+        console.log(`🎧 [MediasoupManager] Creating send transport with ICE servers:`, {
+            hasIceServers: !!iceServers,
+            iceServerCount: iceServers?.length || 0,
+        });
+        this.sendTransport = this.device.createSendTransport({
+            ...transportParams,
+            iceServers: iceServers || [],
+        });
         this.connectSendTransport();
     }
     async createRecvTransport(participantId) {
         const params = await this.createWebRtcTransport('recv', participantId);
-        this.recvTransport = this.device.createRecvTransport(params);
+        // Extract iceServers from params and pass them correctly
+        const { iceServers, ...transportParams } = params;
+        console.log(`🎧 [MediasoupManager] Creating recv transport with ICE servers:`, {
+            hasIceServers: !!iceServers,
+            iceServerCount: iceServers?.length || 0,
+            iceServers: iceServers,
+        });
+        this.recvTransport = this.device.createRecvTransport({
+            ...transportParams,
+            iceServers: iceServers || [],
+        });
         this.connectRecvTransport();
     }
     connectSendTransport() {
@@ -108,18 +127,33 @@ class MediasoupManager {
     }
     connectRecvTransport() {
         this.recvTransport?.on('connect', async ({ dtlsParameters }, callback, errback) => {
+            console.log(`🎧 [MediasoupManager] Recv transport connecting, DTLS params:`, {
+                transportId: this.recvTransport.id.substring(0, 8),
+            });
             this.socket.emit('connect-transport', { transportId: this.recvTransport.id, dtlsParameters }, (response) => {
-                if (response.error)
+                if (response.error) {
+                    console.error(`🎧 [MediasoupManager] ❌ Recv transport connect failed:`, response.error);
                     errback(new Error(response.error));
-                else
+                }
+                else {
+                    console.log(`🎧 [MediasoupManager] ✅ Recv transport connected`);
                     callback();
+                }
             });
         });
         this.recvTransport?.on('connectionstatechange', (state) => {
+            console.log(`🎧 [MediasoupManager] Recv transport connection state changed: ${state}`);
             if (state === 'failed' || state === 'closed') {
-                // Consumers will be closed by server
+                console.error(`🎧 [MediasoupManager] ❌ Recv transport ${state}`);
+            }
+            if (state === 'connected') {
+                console.log(`🎧 [MediasoupManager] ✅ Recv transport fully connected!`);
             }
         });
+        // Also monitor ICE state separately
+        this.recvTransport?.on('icegatheringstatechange', (state) => {
+            console.log(`🎧 [MediasoupManager] Recv transport ICE gathering state: ${state}`);
+        });
     }
     async produce(track, appData) {
         if (!this.sendTransport)
@@ -149,12 +183,27 @@ class MediasoupManager {
     async consume(data) {
         if (!this.recvTransport)
             throw new Error('Receive transport not set up');
+        console.log(`🎧 [MediasoupManager] Creating consumer for ${data.participantId.substring(0, 8)}`, {
+            consumerId: data.consumerId.substring(0, 8),
+            producerId: data.producerId.substring(0, 8),
+            kind: data.kind,
+            recvTransportId: this.recvTransport.id.substring(0, 8),
+            recvTransportConnectionState: this.recvTransport.connectionState,
+        });
         const consumer = await this.recvTransport.consume({
             id: data.consumerId,
             producerId: data.producerId,
             kind: data.kind,
             rtpParameters: data.rtpParameters,
         });
+        console.log(`🎧 [MediasoupManager] Consumer created for ${data.participantId.substring(0, 8)}`, {
+            consumerId: consumer.id.substring(0, 8),
+            trackKind: consumer.track.kind,
+            trackEnabled: consumer.track.enabled,
+            trackMuted: consumer.track.muted,
+            trackReadyState: consumer.track.readyState,
+            consumerPaused: consumer.paused,
+        });
         consumer.on('transportclose', () => {
             this.consumers.delete(consumer.id);
         });

package/dist/index.js

@@ -399,11 +399,19 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                 participant.consumers.set(consumer.id, consumer);
                 if (track.kind === "audio") {
                     participant.audioTrack = track;
+                    console.log(`🎧 [SDK] Received audio consumer for ${participant.participantId.substring(0, 8)}`, {
+                        consumerId: consumer.id.substring(0, 8),
+                        trackEnabled: track.enabled,
+                        trackMuted: track.muted,
+                        trackReadyState: track.readyState,
+                        consumerPaused: consumer.paused,
+                    });
                     // CRITICAL: Do NOT setup spatial audio for local participant (yourself)
                     // This prevents hearing your own microphone (loopback)
                     const isLocalParticipant = participant.participantId ===
                         this.localParticipant?.participantId;
                     if (isLocalParticipant) {
+                        console.log(`🎧 [SDK] Skipping audio setup for local participant (prevent loopback)`);
                         // Do NOT connect this audio to Web Audio API
                         return; // Exit early to prevent any audio processing
                     }
@@ -411,18 +419,20 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
                         // Check if participant is in a huddle (non-spatial channel)
                         const participantChannel = participant.currentChannel || "spatial";
                         const isInHuddle = participantChannel !== "spatial";
+                        console.log(`🎧 [SDK] Setting up spatial audio for ${participant.participantId.substring(0, 8)}, huddle: ${isInHuddle}`);
                         // Setup spatial audio - bypass 3D positioning for huddle members
                         await this.spatialAudioManager.setupSpatialAudioForParticipant(participant.participantId, track, isInHuddle // Bypass spatialization if in huddle
                         );
                     }
                     // NOW resume the consumer after audio pipeline is ready
+                    console.log(`🎧 [SDK] Resuming consumer ${consumer.id.substring(0, 8)}...`);
                     this.mediasoupManager
                         .resumeConsumer(consumer.id)
                         .then(() => {
-                        // Consumer resumed successfully
+                        console.log(`🎧 [SDK] ✅ Consumer ${consumer.id.substring(0, 8)} resumed successfully`);
                     })
-                        .catch(() => {
-                        // Failed to resume consumer - will be handled by transport recovery
+                        .catch((err) => {
+                        console.error(`🎧 [SDK] ❌ Failed to resume consumer ${consumer.id.substring(0, 8)}:`, err);
                     });
                 }
                 else if (track.kind === "video") {

package/package.json

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