@stream-io/video-client 1.7.1 → 1.7.2

package/dist/src/devices/CameraManager.d.ts

@@ -2,29 +2,21 @@ import { Observable } from 'rxjs';
 import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
-import { PublishOptions } from '../types';
-type PreferredCodec = 'vp8' | 'h264' | string;
+import { PreferredCodec, PublishOptions } from '../types';
 export declare class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
     private targetResolution;
     /**
-     * The preferred codec for encoding the video.
+     * The options to use when publishing the video stream.
      *
-     * @internal internal use only, not part of the public API.
+     * @internal
      */
-    preferredCodec: PreferredCodec | undefined;
+    publishOptions: PublishOptions | undefined;
     /**
-     * The preferred bitrate for encoding the video.
+     * Constructs a new CameraManager.
      *
-     * @internal internal use only, not part of the public API.
+     * @param call the call instance.
      */
-    preferredBitrate: number | undefined;
     constructor(call: Call);
-    /**
-     * The publish options for the camera.
-     *
-     * @internal internal use only, not part of the public API.
-     */
-    get publishOptions(): PublishOptions;
     /**
      * Select the camera direction.
      *
@@ -51,17 +43,24 @@ export declare class CameraManager extends InputMediaDeviceManager<CameraManager
      * @internal internal use only, not part of the public API.
      * @param codec the codec to use for encoding the video.
      */
-    setPreferredCodec(codec: 'vp8' | 'h264' | string | undefined): void;
+    setPreferredCodec(codec: PreferredCodec | undefined): void;
     /**
-     * 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: PublishOptions): void;
+    /**
+     * Returns the capture resolution of the camera.
      */
-    setPreferredBitrate(bitrate: number | undefined): void;
+    getCaptureResolution(): {
+        width: number | undefined;
+        height: number | undefined;
+        frameRate: number | undefined;
+    } | undefined;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;
     protected stopPublishStream(stopTracks: boolean): Promise<void>;
 }
-export {};

package/dist/src/rtc/videoLayers.d.ts

@@ -1,4 +1,4 @@
-import { ScreenShareSettings } from '../types';
+import { PublishOptions } from '../types';
 import { TargetResolutionResponse } from '../gen/shims';
 export type OptimalVideoLayer = RTCRtpEncodingParameters & {
     width: number;
@@ -10,9 +10,9 @@ export type OptimalVideoLayer = RTCRtpEncodingParameters & {
  *
  * @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.
  */
-export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targetResolution: TargetResolutionResponse | undefined, preferredBitrate: number | undefined) => OptimalVideoLayer[];
+export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targetResolution?: TargetResolutionResponse, publishOptions?: PublishOptions) => OptimalVideoLayer[];
 /**
  * Computes the maximum bitrate for a given resolution.
  * If the current resolution is lower than the target resolution,
@@ -26,4 +26,4 @@ export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targ
  * @param preferredBitrate the preferred bitrate for the track.
  */
 export declare const getComputedMaxBitrate: (targetResolution: TargetResolutionResponse, currentWidth: number, currentHeight: number, preferredBitrate: number | undefined) => number;
-export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack, preferences?: ScreenShareSettings, defaultMaxBitrate?: number) => OptimalVideoLayer[];
+export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack, publishOptions?: PublishOptions, defaultMaxBitrate?: number) => OptimalVideoLayer[];

package/dist/src/types.d.ts

@@ -109,9 +109,15 @@ export type SubscriptionChange = {
 export type SubscriptionChanges = {
     [sessionId: string]: SubscriptionChange;
 };
+/**
+ * A preferred codec to use when publishing a video track.
+ * @internal
+ */
+export type PreferredCodec = 'vp8' | 'h264' | string;
 export type PublishOptions = {
-    preferredCodec?: string | null;
+    preferredCodec?: PreferredCodec | null;
     preferredBitrate?: number;
+    bitrateDownscaleFactor?: number;
     screenShareSettings?: ScreenShareSettings;
 };
 export type ScreenShareSettings = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/devices/CameraManager.ts

@@ -4,9 +4,7 @@ import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { getVideoDevices, getVideoStream } from './devices';
 import { TrackType } from '../gen/video/sfu/models/models';
-import { PublishOptions } from '../types';
-
-type PreferredCodec = 'vp8' | 'h264' | string;
+import { PreferredCodec, PublishOptions } from '../types';
 
 export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
   private targetResolution = {
@@ -15,35 +13,21 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
   };
 
   /**
-   * The preferred codec for encoding the video.
+   * The options to use when publishing the video stream.
    *
-   * @internal internal use only, not part of the public API.
+   * @internal
    */
-  preferredCodec: PreferredCodec | undefined;
+  publishOptions: PublishOptions | undefined;
 
   /**
-   * The preferred bitrate for encoding the video.
+   * Constructs a new CameraManager.
    *
-   * @internal internal use only, not part of the public API.
+   * @param call the call instance.
    */
-  preferredBitrate: number | undefined;
-
   constructor(call: Call) {
     super(call, new CameraManagerState(), TrackType.VIDEO);
   }
 
-  /**
-   * The publish options for the camera.
-   *
-   * @internal internal use only, not part of the public API.
-   */
-  get publishOptions(): PublishOptions {
-    return {
-      preferredCodec: this.preferredCodec,
-      preferredBitrate: this.preferredBitrate,
-    };
-  }
-
   /**
    * Select the camera direction.
    *
@@ -104,18 +88,36 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
    * @internal internal use only, not part of the public API.
    * @param codec the codec to use for encoding the video.
    */
-  setPreferredCodec(codec: 'vp8' | 'h264' | string | undefined) {
-    this.preferredCodec = codec;
+  setPreferredCodec(codec: PreferredCodec | undefined) {
+    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.
    */
-  setPreferredBitrate(bitrate: number | undefined) {
-    this.preferredBitrate = bitrate;
+  updatePublishOptions(options: PublishOptions) {
+    this.publishOptions = { ...this.publishOptions, ...options };
+  }
+
+  /**
+   * Returns the capture resolution of the camera.
+   */
+  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,
+    };
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {

package/src/devices/__tests__/CameraManager.test.ts

@@ -82,9 +82,7 @@ describe('CameraManager', () => {
 
     expect(manager['call'].publishVideoStream).toHaveBeenCalledWith(
       manager.state.mediaStream,
-      {
-        preferredCodec: undefined,
-      },
+      undefined,
     );
   });
 

package/src/rtc/Publisher.ts

@@ -259,16 +259,11 @@ export class Publisher {
       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
@@ -293,6 +288,7 @@ export class Publisher {
       this.transceiverRegistry[trackType] = transceiver;
       this.publishOptionsPerTrackType.set(trackType, opts);
 
+      const { preferredCodec } = opts;
       const codec =
         isReactNative() && trackType === TrackType.VIDEO && !preferredCodec
           ? getRNOptimalCodec()
@@ -713,16 +709,9 @@ export 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;
         } else {

package/src/rtc/videoLayers.ts

@@ -1,4 +1,4 @@
-import { ScreenShareSettings } from '../types';
+import { PublishOptions } from '../types';
 import { TargetResolutionResponse } from '../gen/shims';
 
 export type OptimalVideoLayer = RTCRtpEncodingParameters & {
@@ -25,17 +25,17 @@ const defaultBitratePerRid: Record<string, number> = {
  *
  * @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.
  */
 export const findOptimalVideoLayers = (
   videoTrack: MediaStreamTrack,
   targetResolution: TargetResolutionResponse = defaultTargetResolution,
-  preferredBitrate: number | undefined,
+  publishOptions?: PublishOptions,
 ) => {
   const optimalVideoLayers: OptimalVideoLayer[] = [];
   const settings = videoTrack.getSettings();
   const { width: w = 0, height: h = 0 } = settings;
-
+  const { preferredBitrate, bitrateDownscaleFactor = 2 } = publishOptions || {};
   const maxBitrate = getComputedMaxBitrate(
     targetResolution,
     w,
@@ -43,6 +43,7 @@ export const findOptimalVideoLayers = (
     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.
@@ -53,11 +54,12 @@ export const findOptimalVideoLayers = (
       width: Math.round(w / downscaleFactor),
       height: Math.round(h / downscaleFactor),
       maxBitrate:
-        Math.round(maxBitrate / downscaleFactor) || defaultBitratePerRid[rid],
+        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
@@ -135,9 +137,10 @@ const withSimulcastConstraints = (
 
 export const findOptimalScreenSharingLayers = (
   videoTrack: MediaStreamTrack,
-  preferences?: ScreenShareSettings,
+  publishOptions?: PublishOptions,
   defaultMaxBitrate = 3000000,
 ): OptimalVideoLayer[] => {
+  const { screenShareSettings: preferences } = publishOptions || {};
   const settings = videoTrack.getSettings();
   return [
     {

package/src/types.ts

@@ -146,9 +146,16 @@ export type SubscriptionChanges = {
   [sessionId: string]: SubscriptionChange;
 };
 
+/**
+ * A preferred codec to use when publishing a video track.
+ * @internal
+ */
+export type PreferredCodec = 'vp8' | 'h264' | string;
+
 export type PublishOptions = {
-  preferredCodec?: string | null;
+  preferredCodec?: PreferredCodec | null;
   preferredBitrate?: number;
+  bitrateDownscaleFactor?: number;
   screenShareSettings?: ScreenShareSettings;
 };