@stream-io/video-client 1.8.4 → 1.9.0

package/dist/src/Call.d.ts

@@ -2,7 +2,6 @@ import { Publisher, Subscriber } from './rtc';
 import { CallState } from './store';
 import type { AcceptCallResponse, BlockUserResponse, CollectUserFeedbackResponse, EndCallResponse, GetCallResponse, GetCallStatsResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopHLSBroadcastingResponse, StopLiveResponse, StopRecordingResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse, VideoResolution } from './gen/coordinator';
 import { AudioTrackType, CallConstructor, CallLeaveOptions, JoinCallData, PublishOptions, TrackMuteType, VideoTrackType } from './types';
-import { VideoLayerSetting } from './gen/video/sfu/event/events';
 import { TrackType } from './gen/video/sfu/models/models';
 import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
@@ -70,6 +69,7 @@ export declare class Call {
      * @private
      */
     private readonly dispatcher;
+    private publishOptions?;
     private statsReporter?;
     private sfuStatsReporter?;
     private dropTimeout;
@@ -282,9 +282,8 @@ export declare class Call {
      * The previous video stream will be stopped.
      *
      * @param videoStream the video stream to publish.
-     * @param opts the options to use when publishing the stream.
      */
-    publishVideoStream: (videoStream: MediaStream, opts?: PublishOptions) => Promise<void>;
+    publishVideoStream: (videoStream: MediaStream) => Promise<void>;
     /**
      * Starts publishing the given audio stream to the call.
      * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -302,9 +301,8 @@ export declare class Call {
      * The previous screen-share stream will be stopped.
      *
      * @param screenShareStream the screen-share stream to publish.
-     * @param opts the options to use when publishing the stream.
      */
-    publishScreenShareStream: (screenShareStream: MediaStream, opts?: PublishOptions) => Promise<void>;
+    publishScreenShareStream: (screenShareStream: MediaStream) => Promise<void>;
     /**
      * Stops publishing the given track type to the call, if it is currently being published.
      * Underlying track will be stopped and removed from the publisher.
@@ -313,6 +311,13 @@ export declare class Call {
      * @param stopTrack if `true` the track will be stopped, else it will be just disabled
      */
     stopPublish: (trackType: TrackType, stopTrack?: boolean) => Promise<void>;
+    /**
+     * Updates the preferred publishing options
+     *
+     * @internal
+     * @param options the options to use.
+     */
+    updatePublishOptions(options: PublishOptions): void;
     /**
      * Notifies the SFU that a noise cancellation process has started.
      *
@@ -351,13 +356,6 @@ export declare class Call {
      * @param criteria the list of criteria to sort the participants by.
      */
     setSortParticipantsBy: CallState['setSortParticipantsBy'];
-    /**
-     * Updates the list of video layers to publish.
-     *
-     * @internal
-     * @param enabledLayers the list of layers to enable.
-     */
-    updatePublishQuality: (enabledLayers: VideoLayerSetting[]) => Promise<void | undefined>;
     /**
      * Sends a reaction to the other call participants.
      *

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

@@ -2,15 +2,9 @@ import { Observable } from 'rxjs';
 import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
-import { PreferredCodec, PublishOptions } from '../types';
+import { PreferredCodec } from '../types';
 export declare class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
     private targetResolution;
-    /**
-     * The options to use when publishing the video stream.
-     *
-     * @internal
-     */
-    publishOptions: PublishOptions | undefined;
     /**
      * Constructs a new CameraManager.
      *
@@ -41,24 +35,10 @@ export declare class CameraManager extends InputMediaDeviceManager<CameraManager
      * Sets the preferred codec for encoding the video.
      *
      * @internal internal use only, not part of the public API.
+     * @deprecated use {@link call.updatePublishOptions} instead.
      * @param codec the codec to use for encoding the video.
      */
     setPreferredCodec(codec: PreferredCodec | undefined): void;
-    /**
-     * Updates the preferred publish options for the video stream.
-     *
-     * @internal
-     * @param options the options to use.
-     */
-    updatePublishOptions(options: PublishOptions): void;
-    /**
-     * Returns the capture resolution of the camera.
-     */
-    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>;

package/dist/src/events/internal.d.ts

@@ -2,10 +2,6 @@ import { Dispatcher } from '../rtc';
 import { Call } from '../Call';
 import { CallState } from '../store';
 import type { PinsChanged } from '../gen/video/sfu/event/events';
-/**
- * An event responder which handles the `changePublishQuality` event.
- */
-export declare const watchChangePublishQuality: (dispatcher: Dispatcher, call: Call) => () => void;
 export declare const watchConnectionQualityChanged: (dispatcher: Dispatcher, state: CallState) => () => void;
 /**
  * Updates the approximate number of participants in the call by peeking at the

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -635,45 +635,15 @@ export interface AudioLevelChanged {
      */
     audioLevels: AudioLevel[];
 }
-/**
- * @generated from protobuf message stream.video.sfu.event.AudioMediaRequest
- */
-export interface AudioMediaRequest {
-    /**
-     * @generated from protobuf field: int32 channel_count = 1;
-     */
-    channelCount: number;
-}
 /**
  * @generated from protobuf message stream.video.sfu.event.AudioSender
  */
 export interface AudioSender {
-    /**
-     * @generated from protobuf field: stream.video.sfu.event.AudioMediaRequest media_request = 1;
-     */
-    mediaRequest?: AudioMediaRequest;
     /**
      * @generated from protobuf field: stream.video.sfu.models.Codec codec = 2;
      */
     codec?: Codec;
 }
-/**
- * @generated from protobuf message stream.video.sfu.event.VideoMediaRequest
- */
-export interface VideoMediaRequest {
-    /**
-     * @generated from protobuf field: int32 ideal_height = 1;
-     */
-    idealHeight: number;
-    /**
-     * @generated from protobuf field: int32 ideal_width = 2;
-     */
-    idealWidth: number;
-    /**
-     * @generated from protobuf field: int32 ideal_frame_rate = 3;
-     */
-    idealFrameRate: number;
-}
 /**
  * VideoLayerSetting is used to specify various parameters of a particular encoding in simulcast.
  * The parameters are specified here - https://developer.mozilla.org/en-US/docs/Web/API/RTCRtpEncodingParameters
@@ -698,10 +668,6 @@ export interface VideoLayerSetting {
      * @generated from protobuf field: float scale_resolution_down_by = 4;
      */
     scaleResolutionDownBy: number;
-    /**
-     * @generated from protobuf field: stream.video.sfu.event.VideoLayerSetting.Priority priority = 5;
-     */
-    priority: VideoLayerSetting_Priority;
     /**
      * @generated from protobuf field: stream.video.sfu.models.Codec codec = 6;
      */
@@ -710,36 +676,15 @@ export interface VideoLayerSetting {
      * @generated from protobuf field: uint32 max_framerate = 7;
      */
     maxFramerate: number;
-}
-/**
- * @generated from protobuf enum stream.video.sfu.event.VideoLayerSetting.Priority
- */
-export declare enum VideoLayerSetting_Priority {
     /**
-     * @generated from protobuf enum value: PRIORITY_HIGH_UNSPECIFIED = 0;
+     * @generated from protobuf field: string scalability_mode = 8;
      */
-    HIGH_UNSPECIFIED = 0,
-    /**
-     * @generated from protobuf enum value: PRIORITY_LOW = 1;
-     */
-    LOW = 1,
-    /**
-     * @generated from protobuf enum value: PRIORITY_MEDIUM = 2;
-     */
-    MEDIUM = 2,
-    /**
-     * @generated from protobuf enum value: PRIORITY_VERY_LOW = 3;
-     */
-    VERY_LOW = 3
+    scalabilityMode: string;
 }
 /**
  * @generated from protobuf message stream.video.sfu.event.VideoSender
  */
 export interface VideoSender {
-    /**
-     * @generated from protobuf field: stream.video.sfu.event.VideoMediaRequest media_request = 1;
-     */
-    mediaRequest?: VideoMediaRequest;
     /**
      * @generated from protobuf field: stream.video.sfu.models.Codec codec = 2;
      */
@@ -1000,13 +945,6 @@ declare class AudioLevelChanged$Type extends MessageType<AudioLevelChanged> {
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioLevelChanged
  */
 export declare const AudioLevelChanged: AudioLevelChanged$Type;
-declare class AudioMediaRequest$Type extends MessageType<AudioMediaRequest> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message stream.video.sfu.event.AudioMediaRequest
- */
-export declare const AudioMediaRequest: AudioMediaRequest$Type;
 declare class AudioSender$Type extends MessageType<AudioSender> {
     constructor();
 }
@@ -1014,13 +952,6 @@ declare class AudioSender$Type extends MessageType<AudioSender> {
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioSender
  */
 export declare const AudioSender: AudioSender$Type;
-declare class VideoMediaRequest$Type extends MessageType<VideoMediaRequest> {
-    constructor();
-}
-/**
- * @generated MessageType for protobuf message stream.video.sfu.event.VideoMediaRequest
- */
-export declare const VideoMediaRequest: VideoMediaRequest$Type;
 declare class VideoLayerSetting$Type extends MessageType<VideoLayerSetting> {
     constructor();
 }

package/dist/src/helpers/sdp-munging.d.ts

@@ -10,3 +10,11 @@ export declare const toggleDtx: (sdp: string, enable: boolean) => string;
  * @param maxBitrate the max bitrate to set.
  */
 export declare const enableHighQualityAudio: (sdp: string, trackMid: string, maxBitrate?: number) => string;
+/**
+ * Extracts the mid from the transceiver or the SDP.
+ *
+ * @param transceiver the transceiver.
+ * @param transceiverInitIndex the index of the transceiver in the transceiver's init array.
+ * @param sdp the SDP.
+ */
+export declare const extractMid: (transceiver: RTCRtpTransceiver, transceiverInitIndex: number, sdp: string | undefined) => string;

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

@@ -3,7 +3,6 @@ import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 import { CallState } from '../store';
 import { PublishOptions } from '../types';
 import { Dispatcher } from './Dispatcher';
-import { VideoLayerSetting } from '../gen/video/sfu/event/events';
 export type PublisherConstructorOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
@@ -23,8 +22,9 @@ export declare class Publisher {
     private readonly logger;
     private pc;
     private readonly state;
-    private readonly transceiverRegistry;
-    private readonly publishOptionsPerTrackType;
+    private readonly transceiverCache;
+    private readonly trackLayersCache;
+    private readonly publishOptsForTrack;
     /**
      * An array maintaining the order how transceivers were added to the peer connection.
      * This is needed because some browsers (Firefox) don't reliably report
@@ -33,29 +33,15 @@ export declare class Publisher {
      * @internal
      */
     private readonly transceiverInitOrder;
-    private readonly trackKindMapping;
-    private readonly trackLayersCache;
     private readonly isDtxEnabled;
     private readonly isRedEnabled;
     private readonly unsubscribeOnIceRestart;
+    private readonly unsubscribeChangePublishQuality;
     private readonly onUnrecoverableError?;
     private isIceRestarting;
-    /**
-     * The SFU client instance to use for publishing and signaling.
-     */
-    sfuClient: StreamSfuClient;
+    private sfuClient;
     /**
      * Constructs a new `Publisher` instance.
-     *
-     * @param connectionConfig the connection configuration to use.
-     * @param sfuClient the SFU client to use.
-     * @param state the call state to use.
-     * @param dispatcher the dispatcher to use.
-     * @param isDtxEnabled whether DTX is enabled.
-     * @param isRedEnabled whether RED is enabled.
-     * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
-     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
-     * @param logTag the log tag to use.
      */
     constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, onUnrecoverableError, logTag, }: PublisherConstructorOpts);
     private createPeerConnection;
@@ -83,6 +69,17 @@ export declare class Publisher {
      * @param opts the optional publish options to use.
      */
     publishStream: (mediaStream: MediaStream, track: MediaStreamTrack, trackType: TrackType, opts?: PublishOptions) => Promise<void>;
+    /**
+     * Adds a new transceiver to the peer connection.
+     * This needs to be called when a new track kind is added to the peer connection.
+     * In other cases, use `updateTransceiver` method.
+     */
+    private addTransceiver;
+    /**
+     * Updates the given transceiver with the new track.
+     * Stops the previous track and replaces it with the new one.
+     */
+    private updateTransceiver;
     /**
      * Stops publishing the given track type to the SFU, if it is currently being published.
      * Underlying track will be stopped and removed from the publisher.
@@ -101,7 +98,7 @@ export declare class Publisher {
      * Stops publishing all tracks and stop all tracks.
      */
     private stopPublishing;
-    updateVideoPublishQuality: (enabledLayers: VideoLayerSetting[]) => Promise<void>;
+    private changePublishQuality;
     /**
      * Returns the result of the `RTCPeerConnection.getStats()` method
      * @param selector
@@ -128,8 +125,6 @@ export declare class Publisher {
      */
     private negotiate;
     private enableHighQualityAudio;
-    private mungeCodecs;
-    private extractMid;
     /**
      * Returns a list of tracks that are currently being published.
      *
@@ -137,9 +132,9 @@ export declare class Publisher {
      * @param sdp an optional SDP to extract the `mid` from.
      */
     getAnnouncedTracks: (sdp?: string) => TrackInfo[];
+    private computeLayers;
     private onIceCandidateError;
     private onIceConnectionStateChange;
     private onIceGatheringStateChange;
     private onSignalingStateChange;
-    private ridToVideoQuality;
 }

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

@@ -0,0 +1,2 @@
+import { PreferredCodec } from '../types';
+export declare const getOptimalBitrate: (codec: PreferredCodec, frameHeight: number) => number;

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

@@ -1,3 +1,4 @@
+import type { PreferredCodec } from '../types';
 /**
  * Returns back a list of sorted codecs, with the preferred codec first.
  *
@@ -15,6 +16,12 @@ export declare const getPreferredCodecs: (kind: "audio" | "video", preferredCode
  */
 export declare const getGenericSdp: (direction: RTCRtpTransceiverDirection) => Promise<string>;
 /**
- * Returns the optimal codec for RN.
+ * Returns the optimal video codec for the device.
  */
-export declare const getRNOptimalCodec: () => "h264" | "vp8" | undefined;
+export declare const getOptimalVideoCodec: (preferredCodec: PreferredCodec | undefined) => PreferredCodec;
+/**
+ * Returns whether the codec is an SVC codec.
+ *
+ * @param codecOrMimeType the codec to check.
+ */
+export declare const isSvcCodec: (codecOrMimeType: string | undefined) => boolean;

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

@@ -1,18 +1,44 @@
-import { PublishOptions } from '../types';
+import { PreferredCodec, PublishOptions } from '../types';
 import { TargetResolutionResponse } from '../gen/shims';
+import { VideoQuality } from '../gen/video/sfu/models/models';
 export type OptimalVideoLayer = RTCRtpEncodingParameters & {
     width: number;
     height: number;
+    scalabilityMode?: string;
 };
+/**
+ * In SVC, we need to send only one video encoding (layer).
+ * this layer will have the additional spatial and temporal layers
+ * defined via the scalabilityMode property.
+ *
+ * @param layers the layers to process.
+ */
+export declare const toSvcEncodings: (layers: OptimalVideoLayer[] | undefined) => {
+    rid: string;
+    active?: boolean;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    networkPriority?: RTCPriorityType;
+    priority?: RTCPriorityType;
+    scaleResolutionDownBy?: number;
+    width: number;
+    height: number;
+    scalabilityMode?: string;
+}[] | undefined;
+/**
+ * Converts the rid to a video quality.
+ */
+export declare const ridToVideoQuality: (rid: string) => VideoQuality;
 /**
  * Determines the most optimal video layers for simulcasting
  * for the given track.
  *
  * @param videoTrack the video track to find optimal layers for.
  * @param targetResolution the expected target resolution.
+ * @param codecInUse the codec in use.
  * @param publishOptions the publish options for the track.
  */
-export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targetResolution?: TargetResolutionResponse, publishOptions?: PublishOptions) => OptimalVideoLayer[];
+export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targetResolution?: TargetResolutionResponse, codecInUse?: PreferredCodec, publishOptions?: PublishOptions) => OptimalVideoLayer[];
 /**
  * Computes the maximum bitrate for a given resolution.
  * If the current resolution is lower than the target resolution,
@@ -23,7 +49,8 @@ export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targ
  * @param targetResolution the target resolution.
  * @param currentWidth the current width of the track.
  * @param currentHeight the current height of the track.
- * @param preferredBitrate the preferred bitrate for the track.
+ * @param codecInUse the codec in use.
+ * @param publishOptions the publish options.
  */
-export declare const getComputedMaxBitrate: (targetResolution: TargetResolutionResponse, currentWidth: number, currentHeight: number, preferredBitrate: number | undefined) => number;
+export declare const getComputedMaxBitrate: (targetResolution: TargetResolutionResponse, currentWidth: number, currentHeight: number, codecInUse?: PreferredCodec, publishOptions?: PublishOptions) => number;
 export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack, publishOptions?: PublishOptions, defaultMaxBitrate?: number) => OptimalVideoLayer[];

package/dist/src/types.d.ts

@@ -113,11 +113,39 @@ export type SubscriptionChanges = {
  * A preferred codec to use when publishing a video track.
  * @internal
  */
-export type PreferredCodec = 'vp8' | 'h264' | string;
+export type PreferredCodec = 'vp8' | 'h264' | 'vp9' | 'av1';
+/**
+ * A collection of track publication options.
+ * @internal
+ */
 export type PublishOptions = {
-    preferredCodec?: PreferredCodec | null;
+    /**
+     * The preferred codec to use when publishing the video stream.
+     */
+    preferredCodec?: PreferredCodec;
+    /**
+     * Force the codec to use when publishing the video stream.
+     * This will override the preferred codec and the internal codec selection logic.
+     * Use with caution.
+     */
+    forceCodec?: PreferredCodec;
+    /**
+     * The preferred scalability to use when publishing the video stream.
+     * Applicable only for SVC codecs.
+     */
+    scalabilityMode?: string;
+    /**
+     * The preferred bitrate to use when publishing the video stream.
+     */
     preferredBitrate?: number;
+    /**
+     * The preferred downscale factor to use when publishing the video stream
+     * in simulcast mode (non-SVC).
+     */
     bitrateDownscaleFactor?: number;
+    /**
+     * Screen share settings.
+     */
     screenShareSettings?: ScreenShareSettings;
 };
 export type ScreenShareSettings = {

package/package.json

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

package/src/Call.ts

@@ -87,10 +87,7 @@ import {
   VideoTrackType,
 } from './types';
 import { BehaviorSubject, Subject, takeWhile } from 'rxjs';
-import {
-  ReconnectDetails,
-  VideoLayerSetting,
-} from './gen/video/sfu/event/events';
+import { ReconnectDetails } from './gen/video/sfu/event/events';
 import {
   ClientDetails,
   TrackType,
@@ -202,6 +199,7 @@ export class Call {
    */
   private readonly dispatcher = new Dispatcher();
 
+  private publishOptions?: PublishOptions;
   private statsReporter?: StatsReporter;
   private sfuStatsReporter?: SfuStatsReporter;
   private dropTimeout: ReturnType<typeof setTimeout> | undefined;
@@ -1292,19 +1290,12 @@ export class Call {
           break;
         case TrackType.VIDEO:
           const videoStream = this.camera.state.mediaStream;
-          if (videoStream) {
-            await this.publishVideoStream(
-              videoStream,
-              this.camera.publishOptions,
-            );
-          }
+          if (videoStream) await this.publishVideoStream(videoStream);
           break;
         case TrackType.SCREEN_SHARE:
           const screenShareStream = this.screenShare.state.mediaStream;
           if (screenShareStream) {
-            await this.publishScreenShareStream(screenShareStream, {
-              screenShareSettings: this.screenShare.getSettings(),
-            });
+            await this.publishScreenShareStream(screenShareStream);
           }
           break;
         // screen share audio can't exist without a screen share, so we handle it there
@@ -1336,12 +1327,8 @@ export class Call {
    * The previous video stream will be stopped.
    *
    * @param videoStream the video stream to publish.
-   * @param opts the options to use when publishing the stream.
    */
-  publishVideoStream = async (
-    videoStream: MediaStream,
-    opts: PublishOptions = {},
-  ) => {
+  publishVideoStream = async (videoStream: MediaStream) => {
     if (!this.sfuClient) throw new Error(`Call not joined yet.`);
     // joining is in progress, and we should wait until the client is ready
     await this.sfuClient.joinTask;
@@ -1363,7 +1350,7 @@ export class Call {
       videoStream,
       videoTrack,
       TrackType.VIDEO,
-      opts,
+      this.publishOptions,
     );
   };
 
@@ -1407,12 +1394,8 @@ export class Call {
    * The previous screen-share stream will be stopped.
    *
    * @param screenShareStream the screen-share stream to publish.
-   * @param opts the options to use when publishing the stream.
    */
-  publishScreenShareStream = async (
-    screenShareStream: MediaStream,
-    opts: PublishOptions = {},
-  ) => {
+  publishScreenShareStream = async (screenShareStream: MediaStream) => {
     if (!this.sfuClient) throw new Error(`Call not joined yet.`);
     // joining is in progress, and we should wait until the client is ready
     await this.sfuClient.joinTask;
@@ -1431,6 +1414,9 @@ export class Call {
     if (!this.trackPublishOrder.includes(TrackType.SCREEN_SHARE)) {
       this.trackPublishOrder.push(TrackType.SCREEN_SHARE);
     }
+    const opts: PublishOptions = {
+      screenShareSettings: this.screenShare.getSettings(),
+    };
     await this.publisher.publishStream(
       screenShareStream,
       screenShareTrack,
@@ -1467,6 +1453,16 @@ export class Call {
     await this.publisher?.unpublishStream(trackType, stopTrack);
   };
 
+  /**
+   * Updates the preferred publishing options
+   *
+   * @internal
+   * @param options the options to use.
+   */
+  updatePublishOptions(options: PublishOptions) {
+    this.publishOptions = { ...this.publishOptions, ...options };
+  }
+
   /**
    * Notifies the SFU that a noise cancellation process has started.
    *
@@ -1529,16 +1525,6 @@ export class Call {
     return this.state.setSortParticipantsBy(criteria);
   };
 
-  /**
-   * Updates the list of video layers to publish.
-   *
-   * @internal
-   * @param enabledLayers the list of layers to enable.
-   */
-  updatePublishQuality = async (enabledLayers: VideoLayerSetting[]) => {
-    return this.publisher?.updateVideoPublishQuality(enabledLayers);
-  };
-
   /**
    * Sends a reaction to the other call participants.
    *
@@ -2098,10 +2084,7 @@ export class Call {
         this.camera.state.mediaStream &&
         !this.publisher?.isPublishing(TrackType.VIDEO)
       ) {
-        await this.publishVideoStream(
-          this.camera.state.mediaStream,
-          this.camera.publishOptions,
-        );
+        await this.publishVideoStream(this.camera.state.mediaStream);
       }
 
       // Start camera if backend config specifies, and there is no local setting