@stream-io/video-client 1.7.1 → 1.7.2

package/dist/index.cjs.js

@@ -3034,7 +3034,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.7.1";
+const version = "1.7.2";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -3311,14 +3311,16 @@ const defaultBitratePerRid = {
  *
  * @param videoTrack the video track to find optimal layers for.
  * @param targetResolution the expected target resolution.
- * @param preferredBitrate the preferred bitrate for the video track.
+ * @param publishOptions the publish options for the track.
  */
-const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetResolution, preferredBitrate) => {
+const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetResolution, publishOptions) => {
     const optimalVideoLayers = [];
     const settings = videoTrack.getSettings();
     const { width: w = 0, height: h = 0 } = settings;
+    const { preferredBitrate, bitrateDownscaleFactor = 2 } = publishOptions || {};
     const maxBitrate = getComputedMaxBitrate(targetResolution, w, h, preferredBitrate);
     let downscaleFactor = 1;
+    let bitrateFactor = 1;
     ['f', 'h', 'q'].forEach((rid) => {
         // Reversing the order [f, h, q] to [q, h, f] as Chrome uses encoding index
         // when deciding which layer to disable when CPU or bandwidth is constrained.
@@ -3328,11 +3330,12 @@ const findOptimalVideoLayers = (videoTrack, targetResolution = defaultTargetReso
             rid,
             width: Math.round(w / downscaleFactor),
             height: Math.round(h / downscaleFactor),
-            maxBitrate: Math.round(maxBitrate / downscaleFactor) || defaultBitratePerRid[rid],
+            maxBitrate: Math.round(maxBitrate / bitrateFactor) || defaultBitratePerRid[rid],
             scaleResolutionDownBy: downscaleFactor,
             maxFramerate: 30,
         });
         downscaleFactor *= 2;
+        bitrateFactor *= bitrateDownscaleFactor;
     });
     // for simplicity, we start with all layers enabled, then this function
     // will clear/reassign the layers that are not needed
@@ -3392,7 +3395,8 @@ const withSimulcastConstraints = (settings, optimalVideoLayers) => {
         rid: ridMapping[index], // reassign rid
     }));
 };
-const findOptimalScreenSharingLayers = (videoTrack, preferences, defaultMaxBitrate = 3000000) => {
+const findOptimalScreenSharingLayers = (videoTrack, publishOptions, defaultMaxBitrate = 3000000) => {
+    const { screenShareSettings: preferences } = publishOptions || {};
     const settings = videoTrack.getSettings();
     return [
         {
@@ -5173,11 +5177,10 @@ class Publisher {
                 const targetResolution = settings?.video
                     .target_resolution;
                 const screenShareBitrate = settings?.screensharing.target_resolution?.bitrate;
-                const { preferredBitrate, preferredCodec, screenShareSettings } = opts;
                 const videoEncodings = trackType === TrackType.VIDEO
-                    ? findOptimalVideoLayers(track, targetResolution, preferredBitrate)
+                    ? findOptimalVideoLayers(track, targetResolution, opts)
                     : trackType === TrackType.SCREEN_SHARE
-                        ? findOptimalScreenSharingLayers(track, screenShareSettings, screenShareBitrate)
+                        ? findOptimalScreenSharingLayers(track, opts, screenShareBitrate)
                         : undefined;
                 // listen for 'ended' event on the track as it might be ended abruptly
                 // by an external factor as permission revokes, device disconnected, etc.
@@ -5197,6 +5200,7 @@ class Publisher {
                 this.transceiverInitOrder.push(trackType);
                 this.transceiverRegistry[trackType] = transceiver;
                 this.publishOptionsPerTrackType.set(trackType, opts);
+                const { preferredCodec } = opts;
                 const codec = isReactNative() && trackType === TrackType.VIDEO && !preferredCodec
                     ? getRNOptimalCodec()
                     : preferredCodec;
@@ -5515,9 +5519,9 @@ class Publisher {
                     const publishOpts = this.publishOptionsPerTrackType.get(trackType);
                     optimalLayers =
                         trackType === TrackType.VIDEO
-                            ? findOptimalVideoLayers(track, targetResolution, publishOpts?.preferredBitrate)
+                            ? findOptimalVideoLayers(track, targetResolution, publishOpts)
                             : trackType === TrackType.SCREEN_SHARE
-                                ? findOptimalScreenSharingLayers(track, publishOpts?.screenShareSettings)
+                                ? findOptimalScreenSharingLayers(track, publishOpts)
                                 : [];
                     this.trackLayersCache[trackType] = optimalLayers;
                 }
@@ -8401,6 +8405,11 @@ class CameraManagerState extends InputMediaDeviceManagerState {
 }
 
 class CameraManager extends InputMediaDeviceManager {
+    /**
+     * Constructs a new CameraManager.
+     *
+     * @param call the call instance.
+     */
     constructor(call) {
         super(call, new CameraManagerState(), TrackType.VIDEO);
         this.targetResolution = {
@@ -8408,17 +8417,6 @@ class CameraManager extends InputMediaDeviceManager {
             height: 720,
         };
     }
-    /**
-     * The publish options for the camera.
-     *
-     * @internal internal use only, not part of the public API.
-     */
-    get publishOptions() {
-        return {
-            preferredCodec: this.preferredCodec,
-            preferredBitrate: this.preferredBitrate,
-        };
-    }
     /**
      * Select the camera direction.
      *
@@ -8473,16 +8471,33 @@ class CameraManager extends InputMediaDeviceManager {
      * @param codec the codec to use for encoding the video.
      */
     setPreferredCodec(codec) {
-        this.preferredCodec = codec;
+        this.updatePublishOptions({ preferredCodec: codec });
     }
     /**
-     * Sets the preferred bitrate for encoding the video.
+     * Updates the preferred publish options for the video stream.
      *
-     * @internal internal use only, not part of the public API.
-     * @param bitrate the bitrate to use for encoding the video.
+     * @internal
+     * @param options the options to use.
+     */
+    updatePublishOptions(options) {
+        this.publishOptions = { ...this.publishOptions, ...options };
+    }
+    /**
+     * Returns the capture resolution of the camera.
      */
-    setPreferredBitrate(bitrate) {
-        this.preferredBitrate = bitrate;
+    getCaptureResolution() {
+        const { mediaStream } = this.state;
+        if (!mediaStream)
+            return;
+        const [videoTrack] = mediaStream.getVideoTracks();
+        if (!videoTrack)
+            return;
+        const settings = videoTrack.getSettings();
+        return {
+            width: settings.width,
+            height: settings.height,
+            frameRate: settings.frameRate,
+        };
     }
     getDevices() {
         return getVideoDevices();
@@ -12342,7 +12357,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.7.1";
+            const version = "1.7.2";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };