@stream-io/video-client 1.15.5 → 1.15.7

package/dist/index.cjs.js

@@ -5500,7 +5500,7 @@ const computeVideoLayers = (videoTrack, publishOption) => {
             rid,
             width: Math.round(width / downscaleFactor),
             height: Math.round(height / downscaleFactor),
-            maxBitrate: maxBitrate / bitrateFactor || defaultBitratePerRid[rid],
+            maxBitrate: Math.round(maxBitrate / bitrateFactor) || defaultBitratePerRid[rid],
             maxFramerate: fps,
         };
         if (svcCodec) {
@@ -7358,7 +7358,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.15.5";
+const version = "1.15.7";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -9339,7 +9339,7 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
 }
 
 const DETECTION_FREQUENCY_IN_MS = 500;
-const AUDIO_LEVEL_THRESHOLD$1 = 150;
+const AUDIO_LEVEL_THRESHOLD = 150;
 const FFT_SIZE = 128;
 /**
  * Creates a new sound detector.
@@ -9350,7 +9350,7 @@ const FFT_SIZE = 128;
  * @returns a clean-up function which once invoked stops the sound detector.
  */
 const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options = {}) => {
-    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD$1, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
+    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
     const audioContext = new AudioContext();
     const analyser = audioContext.createAnalyser();
     analyser.fftSize = fftSize;
@@ -9391,7 +9391,6 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
-const AUDIO_LEVEL_THRESHOLD = 0.2;
 class RNSpeechDetector {
     constructor() {
         this.pc1 = new RTCPeerConnection({});
@@ -9400,7 +9399,7 @@ class RNSpeechDetector {
     /**
      * Starts the speech detection.
      */
-    async start() {
+    async start(onSoundDetectedStateChanged) {
         try {
             this.cleanupAudioStream();
             const audioStream = await navigator.mediaDevices.getUserMedia({
@@ -9413,6 +9412,14 @@ class RNSpeechDetector {
             this.pc2.addEventListener('icecandidate', async (e) => {
                 await this.pc1.addIceCandidate(e.candidate);
             });
+            this.pc2.addEventListener('track', (e) => {
+                e.streams[0].getTracks().forEach((track) => {
+                    // In RN, the remote track is automatically added to the audio output device
+                    // so we need to mute it to avoid hearing the audio back
+                    // @ts-ignore _setVolume is a private method in react-native-webrtc
+                    track._setVolume(0);
+                });
+            });
             audioStream
                 .getTracks()
                 .forEach((track) => this.pc1.addTrack(track, audioStream));
@@ -9422,12 +9429,16 @@ class RNSpeechDetector {
             const answer = await this.pc2.createAnswer();
             await this.pc1.setRemoteDescription(answer);
             await this.pc2.setLocalDescription(answer);
-            const audioTracks = audioStream.getAudioTracks();
-            // We need to mute the audio track for this temporary stream, or else you will hear yourself twice while in the call.
-            audioTracks.forEach((track) => (track.enabled = false));
+            const unsub = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
+            return () => {
+                unsub();
+                this.stop();
+            };
         }
         catch (error) {
-            console.error('Error connecting and negotiating between PeerConnections:', error);
+            const logger = getLogger(['RNSpeechDetector']);
+            logger('error', 'error handling permissions: ', error);
+            return () => { };
         }
     }
     /**
@@ -9437,40 +9448,85 @@ class RNSpeechDetector {
         this.pc1.close();
         this.pc2.close();
         this.cleanupAudioStream();
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-        }
     }
     /**
      * Public method that detects the audio levels and returns the status.
      */
     onSpeakingDetectedStateChange(onSoundDetectedStateChanged) {
-        this.intervalId = setInterval(async () => {
-            const stats = (await this.pc1.getStats());
-            const report = flatten(stats);
-            // Audio levels are present inside stats of type `media-source` and of kind `audio`
-            const audioMediaSourceStats = report.find((stat) => stat.type === 'media-source' &&
-                stat.kind === 'audio');
-            if (audioMediaSourceStats) {
-                const { audioLevel } = audioMediaSourceStats;
-                if (audioLevel) {
-                    if (audioLevel >= AUDIO_LEVEL_THRESHOLD) {
-                        onSoundDetectedStateChanged({
-                            isSoundDetected: true,
-                            audioLevel,
-                        });
-                    }
-                    else {
-                        onSoundDetectedStateChanged({
-                            isSoundDetected: false,
-                            audioLevel: 0,
-                        });
+        const initialBaselineNoiseLevel = 0.13;
+        let baselineNoiseLevel = initialBaselineNoiseLevel;
+        let speechDetected = false;
+        let intervalId;
+        let speechTimer;
+        let silenceTimer;
+        let audioLevelHistory = []; // Store recent audio levels for smoother detection
+        const historyLength = 10;
+        const silenceThreshold = 1.1;
+        const resetThreshold = 0.9;
+        const speechTimeout = 500; // Speech is set to true after 500ms of audio detection
+        const silenceTimeout = 5000; // Reset baseline after 5 seconds of silence
+        const checkAudioLevel = async () => {
+            try {
+                const stats = (await this.pc1.getStats());
+                const report = flatten(stats);
+                // Audio levels are present inside stats of type `media-source` and of kind `audio`
+                const audioMediaSourceStats = report.find((stat) => stat.type === 'media-source' &&
+                    stat.kind === 'audio');
+                if (audioMediaSourceStats) {
+                    const { audioLevel } = audioMediaSourceStats;
+                    if (audioLevel) {
+                        // Update audio level history (with max historyLength sized array)
+                        audioLevelHistory.push(audioLevel);
+                        if (audioLevelHistory.length > historyLength) {
+                            audioLevelHistory.shift();
+                        }
+                        // Calculate average audio level
+                        const avgAudioLevel = audioLevelHistory.reduce((a, b) => a + b, 0) /
+                            audioLevelHistory.length;
+                        // Update baseline (if necessary) based on silence detection
+                        if (avgAudioLevel < baselineNoiseLevel * silenceThreshold) {
+                            if (!silenceTimer) {
+                                silenceTimer = setTimeout(() => {
+                                    baselineNoiseLevel = Math.min(avgAudioLevel * resetThreshold, initialBaselineNoiseLevel);
+                                }, silenceTimeout);
+                            }
+                        }
+                        else {
+                            clearTimeout(silenceTimer);
+                            silenceTimer = undefined;
+                        }
+                        // Speech detection with hysteresis
+                        if (avgAudioLevel > baselineNoiseLevel * 1.5) {
+                            if (!speechDetected) {
+                                speechDetected = true;
+                                onSoundDetectedStateChanged({
+                                    isSoundDetected: true,
+                                    audioLevel,
+                                });
+                            }
+                            clearTimeout(speechTimer);
+                            speechTimer = setTimeout(() => {
+                                speechDetected = false;
+                                onSoundDetectedStateChanged({
+                                    isSoundDetected: false,
+                                    audioLevel: 0,
+                                });
+                            }, speechTimeout);
+                        }
                     }
                 }
             }
-        }, 1000);
+            catch (error) {
+                const logger = getLogger(['RNSpeechDetector']);
+                logger('error', 'error checking audio level from stats', error);
+            }
+        };
+        // Call checkAudioLevel periodically (every 100ms)
+        intervalId = setInterval(checkAudioLevel, 100);
         return () => {
-            clearInterval(this.intervalId);
+            clearInterval(intervalId);
+            clearTimeout(speechTimer);
+            clearTimeout(silenceTimer);
         };
     }
     cleanupAudioStream() {
@@ -9488,9 +9544,7 @@ class RNSpeechDetector {
 }
 
 class MicrophoneManager extends InputMediaDeviceManager {
-    constructor(call, disableMode = isReactNative()
-        ? 'disable-tracks'
-        : 'stop-tracks') {
+    constructor(call, disableMode = 'stop-tracks') {
         super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
         this.speakingWhileMutedNotificationEnabled = true;
         this.soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
@@ -9671,13 +9725,11 @@ class MicrophoneManager extends InputMediaDeviceManager {
             await this.stopSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 this.rnSpeechDetector = new RNSpeechDetector();
-                await this.rnSpeechDetector.start();
-                const unsubscribe = this.rnSpeechDetector?.onSpeakingDetectedStateChange((event) => {
+                const unsubscribe = await this.rnSpeechDetector.start((event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
                 this.soundDetectorCleanup = () => {
                     unsubscribe();
-                    this.rnSpeechDetector?.stop();
                     this.rnSpeechDetector = undefined;
                 };
             }
@@ -12863,7 +12915,7 @@ class StreamClient {
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
-            const version = "1.15.5";
+            const version = "1.15.7";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };