@stream-io/video-client 1.14.0 → 1.15.0

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

@@ -5,7 +5,8 @@ import { ICETrickle } from '../gen/video/sfu/event/events';
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
  */
 export declare class IceTrickleBuffer {
-    readonly subscriberCandidates: ReplaySubject<ICETrickle>;
-    readonly publisherCandidates: ReplaySubject<ICETrickle>;
+    readonly subscriberCandidates: ReplaySubject<RTCIceCandidateInit>;
+    readonly publisherCandidates: ReplaySubject<RTCIceCandidateInit>;
     push: (iceTrickle: ICETrickle) => void;
+    dispose: () => void;
 }

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

@@ -1,118 +1,59 @@
-import { StreamSfuClient } from '../StreamSfuClient';
-import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
-import { CallState } from '../store';
-import { PublishOptions } from '../types';
-import { Dispatcher } from './Dispatcher';
-export type PublisherConstructorOpts = {
-    sfuClient: StreamSfuClient;
-    state: CallState;
-    dispatcher: Dispatcher;
-    connectionConfig?: RTCConfiguration;
-    isDtxEnabled: boolean;
-    isRedEnabled: boolean;
-    onUnrecoverableError?: () => void;
-    logTag: string;
+import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
+import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
+export type PublisherConstructorOpts = BasePeerConnectionOpts & {
+    publishOptions: PublishOption[];
 };
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *
  * @internal
  */
-export declare class Publisher {
-    private readonly logger;
-    private pc;
-    private readonly state;
+export declare class Publisher extends BasePeerConnection {
     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
-     * trackId and `mid` parameters.
-     *
-     * @internal
-     */
-    private readonly transceiverInitOrder;
-    private readonly isDtxEnabled;
-    private readonly isRedEnabled;
-    private readonly unsubscribeOnIceRestart;
-    private readonly unsubscribeChangePublishQuality;
-    private readonly onUnrecoverableError?;
-    private isIceRestarting;
-    private sfuClient;
+    private publishOptions;
     /**
      * Constructs a new `Publisher` instance.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, onUnrecoverableError, logTag, }: PublisherConstructorOpts);
-    private createPeerConnection;
-    /**
-     * Closes the publisher PeerConnection and cleans up the resources.
-     */
-    close: ({ stopTracks }: {
-        stopTracks: boolean;
-    }) => void;
+    constructor({ publishOptions, ...baseOptions }: PublisherConstructorOpts);
     /**
      * Detaches the event handlers from the `RTCPeerConnection`.
      * This is useful when we want to replace the `RTCPeerConnection`
      * instance with a new one (in case of migration).
      */
-    detachEventHandlers: () => void;
+    detachEventHandlers(): void;
     /**
      * Starts publishing the given track of the given media stream.
      *
      * Consecutive calls to this method will replace the stream.
      * The previous stream will be stopped.
      *
-     * @param mediaStream the media stream to publish.
      * @param track the track to publish.
      * @param trackType the track type to publish.
-     * @param opts the optional publish options to use.
      */
-    publishStream: (mediaStream: MediaStream, track: MediaStreamTrack, trackType: TrackType, opts?: PublishOptions) => Promise<void>;
+    publish: (track: MediaStreamTrack, trackType: TrackType) => 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.
+     * Adds a new transceiver carrying the given track to the peer connection.
      */
     private addTransceiver;
     /**
-     * Updates the given transceiver with the new track.
-     * Stops the previous track and replaces it with the new one.
+     * Synchronizes the current Publisher state with the provided publish options.
      */
-    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.
-     * @param trackType the track type to unpublish.
-     * @param stopTrack specifies whether track should be stopped or just disabled
-     */
-    unpublishStream: (trackType: TrackType, stopTrack: boolean) => Promise<void>;
+    private syncPublishOptions;
     /**
      * Returns true if the given track type is currently being published to the SFU.
      *
      * @param trackType the track type to check.
      */
     isPublishing: (trackType: TrackType) => boolean;
-    private notifyTrackMuteStateChanged;
     /**
-     * Stops publishing all tracks and stop all tracks.
+     * Maps the given track ID to the corresponding track type.
      */
-    private stopPublishing;
-    private changePublishQuality;
+    getTrackType: (trackId: string) => TrackType | undefined;
     /**
-     * Returns the result of the `RTCPeerConnection.getStats()` method
-     * @param selector
-     * @returns
-     */
-    getStats: (selector?: MediaStreamTrack | null | undefined) => Promise<RTCStatsReport>;
-    private getCodecPreferences;
-    private onIceCandidate;
-    /**
-     * Sets the SFU client to use.
-     *
-     * @param sfuClient the SFU client to use.
+     * Stops the cloned track that is being published to the SFU.
      */
-    setSfuClient: (sfuClient: StreamSfuClient) => void;
+    stopTracks: (...trackTypes: TrackType[]) => void;
+    private changePublishQuality;
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
      */
@@ -124,18 +65,23 @@ export declare class Publisher {
      * @param options the optional offer options to use.
      */
     private negotiate;
-    private removeUnpreferredCodecs;
-    private enableHighQualityAudio;
     /**
      * Returns a list of tracks that are currently being published.
-     *
-     * @internal
+     */
+    getPublishedTracks: () => MediaStreamTrack[];
+    /**
+     * Returns a list of tracks that are currently being published.
      * @param sdp an optional SDP to extract the `mid` from.
      */
-    getAnnouncedTracks: (sdp?: string) => TrackInfo[];
-    private computeLayers;
-    private onIceCandidateError;
-    private onIceConnectionStateChange;
-    private onIceGatheringStateChange;
-    private onSignalingStateChange;
+    getAnnouncedTracks: (sdp: string | undefined) => TrackInfo[];
+    /**
+     * Returns a list of tracks that are currently being published.
+     * This method shall be used for the reconnection flow.
+     * There we shouldn't announce the tracks that have been stopped due to a codec switch.
+     */
+    getAnnouncedTracksForReconnect: () => TrackInfo[];
+    /**
+     * Converts the given transceiver to a `TrackInfo` object.
+     */
+    private toTrackInfo;
 }

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

@@ -1,77 +1,25 @@
-import { StreamSfuClient } from '../StreamSfuClient';
-import { Dispatcher } from './Dispatcher';
-import { CallState } from '../store';
-export type SubscriberOpts = {
-    sfuClient: StreamSfuClient;
-    dispatcher: Dispatcher;
-    state: CallState;
-    connectionConfig?: RTCConfiguration;
-    onUnrecoverableError?: () => void;
-    logTag: string;
-};
+import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
  * media streams from the SFU.
  *
  * @internal
  */
-export declare class Subscriber {
-    private readonly logger;
-    private pc;
-    private sfuClient;
-    private state;
-    private readonly unregisterOnSubscriberOffer;
-    private readonly unregisterOnIceRestart;
-    private readonly onUnrecoverableError?;
-    private isIceRestarting;
+export declare class Subscriber extends BasePeerConnection {
     /**
      * Constructs a new `Subscriber` instance.
-     *
-     * @param sfuClient the SFU client to use.
-     * @param dispatcher the dispatcher to use.
-     * @param state the state of the call.
-     * @param connectionConfig the connection configuration to use.
-     * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
-     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
-     * @param logTag a tag to use for logging.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, onUnrecoverableError, logTag, }: SubscriberOpts);
-    /**
-     * Creates a new `RTCPeerConnection` instance with the given configuration.
-     *
-     * @param connectionConfig the connection configuration to use.
-     */
-    private createPeerConnection;
-    /**
-     * Closes the `RTCPeerConnection` and unsubscribes from the dispatcher.
-     */
-    close: () => void;
+    constructor(opts: BasePeerConnectionOpts);
     /**
      * Detaches the event handlers from the `RTCPeerConnection`.
      * This is useful when we want to replace the `RTCPeerConnection`
      * instance with a new one (in case of migration).
      */
-    detachEventHandlers: () => void;
-    /**
-     * Returns the result of the `RTCPeerConnection.getStats()` method
-     * @param selector
-     * @returns
-     */
-    getStats: (selector?: MediaStreamTrack | null | undefined) => Promise<RTCStatsReport>;
-    /**
-     * Sets the SFU client to use.
-     *
-     * @param sfuClient the SFU client to use.
-     */
-    setSfuClient: (sfuClient: StreamSfuClient) => void;
+    detachEventHandlers(): void;
     /**
      * Restarts the ICE connection and renegotiates with the SFU.
      */
     restartIce: () => Promise<void>;
     private handleOnTrack;
-    private onIceCandidate;
     private negotiate;
-    private onIceConnectionStateChange;
-    private onIceGatheringStateChange;
-    private onIceCandidateError;
 }

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

@@ -0,0 +1,55 @@
+import { PublishOption, TrackType } from '../gen/video/sfu/models/models';
+import { OptimalVideoLayer } from './videoLayers';
+type TransceiverId = {
+    publishOption: PublishOption;
+    transceiver: RTCRtpTransceiver;
+};
+export declare class TransceiverCache {
+    private readonly cache;
+    private readonly layers;
+    /**
+     * An array maintaining the order how transceivers were added to the peer connection.
+     * This is needed because some browsers (Firefox) don't reliably report
+     * trackId and `mid` parameters.
+     */
+    private readonly transceiverOrder;
+    /**
+     * Adds a transceiver to the cache.
+     */
+    add: (publishOption: PublishOption, transceiver: RTCRtpTransceiver) => void;
+    /**
+     * Gets the transceiver for the given publish option.
+     */
+    get: (publishOption: PublishOption) => RTCRtpTransceiver | undefined;
+    /**
+     * Gets the last transceiver for the given track type and publish option id.
+     */
+    getWith: (trackType: TrackType, id: number) => RTCRtpTransceiver | undefined;
+    /**
+     * Checks if the cache has the given publish option.
+     */
+    has: (publishOption: PublishOption) => boolean;
+    /**
+     * Finds the first transceiver that satisfies the given predicate.
+     */
+    find: (predicate: (item: TransceiverId) => boolean) => TransceiverId | undefined;
+    /**
+     * Provides all the items in the cache.
+     */
+    items: () => TransceiverId[];
+    /**
+     * Init index of the transceiver in the cache.
+     */
+    indexOf: (transceiver: RTCRtpTransceiver) => number;
+    /**
+     * Gets cached video layers for the given track.
+     */
+    getLayers: (publishOption: PublishOption) => OptimalVideoLayer[] | undefined;
+    /**
+     * Sets the video layers for the given track.
+     */
+    setLayers: (publishOption: PublishOption, layers?: OptimalVideoLayer[]) => void;
+    private findTransceiver;
+    private findLayer;
+}
+export {};

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

@@ -1,25 +1,11 @@
-import type { PreferredCodec } from '../types';
-/**
- * Returns back a list of sorted codecs, with the preferred codec first.
- *
- * @param kind the kind of codec to get.
- * @param preferredCodec the codec to prioritize (vp8, h264, vp9, av1...).
- * @param codecToRemove the codec to exclude from the list.
- * @param codecPreferencesSource the source of the codec preferences.
- */
-export declare const getPreferredCodecs: (kind: "audio" | "video", preferredCodec: string, codecToRemove: string | undefined, codecPreferencesSource: "sender" | "receiver") => RTCRtpCodec[] | undefined;
 /**
  * Returns a generic SDP for the given direction.
  * We use this SDP to send it as part of our JoinRequest so that the SFU
- * can use it to determine client's codec capabilities.
+ * can use it to determine the client's codec capabilities.
  *
  * @param direction the direction of the transceiver.
  */
 export declare const getGenericSdp: (direction: RTCRtpTransceiverDirection) => Promise<string>;
-/**
- * Returns the optimal video codec for the device.
- */
-export declare const getOptimalVideoCodec: (preferredCodec: PreferredCodec | undefined) => PreferredCodec;
 /**
  * Returns whether the codec is an SVC codec.
  *

package/dist/src/rtc/helpers/sdp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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/helpers/tracks.d.ts

@@ -3,3 +3,4 @@ import { TrackMuteType } from '../../types';
 export declare const trackTypeToParticipantStreamKey: (trackType: TrackType) => "audioStream" | "videoStream" | "screenShareStream" | "screenShareAudioStream" | undefined;
 export declare const muteTypeToTrackType: (muteType: TrackMuteType) => TrackType | undefined;
 export declare const toTrackType: (trackType: string) => TrackType | undefined;
+export declare const isAudioTrackType: (trackType: TrackType) => boolean;

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

@@ -5,3 +5,6 @@ export * from './Publisher';
 export * from './Subscriber';
 export * from './signal';
 export * from './videoLayers';
+export * from './helpers/sdp';
+export * from './helpers/tracks';
+export * from './helpers/rtcConfiguration';

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

@@ -1,6 +1,4 @@
-import { PreferredCodec, PublishOptions } from '../types';
-import { TargetResolutionResponse } from '../gen/shims';
-import { VideoQuality } from '../gen/video/sfu/models/models';
+import { PublishOption, VideoDimension, VideoLayer, VideoQuality } from '../gen/video/sfu/models/models';
 export type OptimalVideoLayer = RTCRtpEncodingParameters & {
     width: number;
     height: number;
@@ -13,32 +11,22 @@ export type OptimalVideoLayer = RTCRtpEncodingParameters & {
  *
  * @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;
+export declare const toSvcEncodings: (layers: OptimalVideoLayer[] | undefined) => RTCRtpEncodingParameters[] | 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.
+ * Converts the given video layers to SFU video layers.
+ */
+export declare const toVideoLayers: (layers?: OptimalVideoLayer[] | undefined) => VideoLayer[];
+/**
+ * Determines the most optimal video layers 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.
+ * @param publishOption the publish options for the track.
  */
-export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targetResolution?: TargetResolutionResponse, codecInUse?: PreferredCodec, publishOptions?: PublishOptions) => OptimalVideoLayer[];
+export declare const computeVideoLayers: (videoTrack: MediaStreamTrack, publishOption: PublishOption) => OptimalVideoLayer[] | undefined;
 /**
  * Computes the maximum bitrate for a given resolution.
  * If the current resolution is lower than the target resolution,
@@ -49,8 +37,6 @@ 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 codecInUse the codec in use.
- * @param publishOptions the publish options.
+ * @param bitrate the target bitrate.
  */
-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[];
+export declare const getComputedMaxBitrate: (targetResolution: VideoDimension, currentWidth: number, currentHeight: number, bitrate: number) => number;

package/dist/src/stats/{stateStoreStatsReporter.d.ts → CallStateStatsReporter.d.ts}

@@ -28,7 +28,7 @@ export type StatsReporter = {
      * @param kind the peer connection kind (subscriber or publisher).
      * @param mediaStream the media stream.
      */
-    getStatsForStream: (kind: 'subscriber' | 'publisher', mediaStream: MediaStream) => Promise<StatsReport[]>;
+    getStatsForStream: (kind: 'subscriber' | 'publisher', tracks: MediaStreamTrack[]) => Promise<StatsReport[]>;
     /**
      * Helper method for retrieving raw stats for a given peer connection kind.
      *
@@ -54,4 +54,8 @@ export type StatsTransformOpts = {
      * The kind of peer connection we are transforming stats for.
      */
     kind: 'subscriber' | 'publisher';
+    /**
+     * The publisher instance.
+     */
+    publisher: Publisher | undefined;
 };

package/dist/src/stats/SfuStatsReporter.d.ts

@@ -2,9 +2,9 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { StatsOptions } from '../gen/coordinator';
 import { Publisher, Subscriber } from '../rtc';
 import { LocalClientDetailsType } from '../client-details';
+import { WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
 import { CameraManager, MicrophoneManager } from '../devices';
 import { CallState } from '../store';
-import { Telemetry } from '../gen/video/sfu/signal_rpc/signal';
 export type SfuStatsReporterOptions = {
     options: StatsOptions;
     clientDetails: LocalClientDetailsType;
@@ -32,7 +32,9 @@ export declare class SfuStatsReporter {
     private readonly inputDevices;
     constructor(sfuClient: StreamSfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, }: SfuStatsReporterOptions);
     private observeDevice;
-    sendTelemetryData: (telemetryData: Telemetry) => Promise<void>;
+    sendConnectionTime: (connectionTimeSeconds: number) => void;
+    sendReconnectionTime: (strategy: WebsocketReconnectStrategy, timeSeconds: number) => void;
+    private sendTelemetryData;
     private run;
     start: () => void;
     stop: () => void;

package/dist/src/stats/index.d.ts

@@ -1,3 +1,3 @@
-export * from './stateStoreStatsReporter';
+export * from './CallStateStatsReporter';
 export * from './SfuStatsReporter';
 export * from './types';

package/dist/src/stats/types.d.ts

@@ -1,3 +1,4 @@
+import { TrackType } from '../gen/video/sfu/models/models';
 export type BaseStats = {
     audioLevel?: number;
     bytesSent?: number;
@@ -9,9 +10,11 @@ export type BaseStats = {
     framesPerSecond?: number;
     jitter?: number;
     kind?: string;
+    mediaSourceId?: string;
     qualityLimitationReason?: string;
     rid?: string;
     ssrc?: number;
+    trackType?: TrackType;
 };
 export type StatsReport = {
     rawStats?: RTCStatsReport;
@@ -28,6 +31,7 @@ export type AggregatedStatsReport = {
     highestFrameHeight: number;
     highestFramesPerSecond: number;
     codec: string;
+    codecPerTrackType: Partial<Record<TrackType, string>>;
     timestamp: number;
     rawReport: StatsReport;
 };
@@ -43,3 +47,7 @@ export type CallStatsReport = {
     participants: ParticipantsStatsReport;
     timestamp: number;
 };
+export interface RTCMediaSourceStats {
+    kind: string;
+    trackIdentifier: string;
+}

package/dist/src/types.d.ts

@@ -124,7 +124,7 @@ export type SubscriptionChanges = {
     [sessionId: string]: SubscriptionChange;
 };
 /**
- * A preferred codec to use when publishing a video track.
+ * A preferred codec to use when publishing a video or audio track.
  * @internal
  */
 export type PreferredCodec = 'vp8' | 'h264' | 'vp9' | 'av1';
@@ -132,41 +132,31 @@ export type PreferredCodec = 'vp8' | 'h264' | 'vp9' | 'av1';
  * A collection of track publication options.
  * @internal
  */
-export type PublishOptions = {
+export type ClientPublishOptions = {
     /**
      * 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.
+     * The fmtp line for the video codec.
      */
-    forceCodec?: PreferredCodec;
-    /**
-     * When using a preferred codec, force the use of a single codec.
-     * Enabling this, it will remove all other supported codecs from the SDP.
-     * Defaults to false.
-     */
-    forceSingleCodec?: boolean;
-    /**
-     * The preferred scalability to use when publishing the video stream.
-     * Applicable only for SVC codecs.
-     */
-    scalabilityMode?: string;
+    fmtpLine?: 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;
     /**
      * The maximum number of simulcast layers to use when publishing the video stream.
      */
     maxSimulcastLayers?: number;
+    /**
+     * The preferred subscription (incoming video stream) codec.
+     */
+    subscriberCodec?: PreferredCodec;
+    /**
+     * The fmtp line for the subscriber codec.
+     */
+    subscriberFmtpLine?: string;
     /**
      * Screen share settings.
      */

package/package.json

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