@stream-io/video-client 1.13.1 → 1.15.0

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/store/CallState.d.ts

@@ -1,9 +1,9 @@
 import { Observable } from 'rxjs';
 import type { Patch } from './rxUtils';
 import { CallingState } from './CallingState';
-import { type StreamVideoParticipant, type StreamVideoParticipantPatch, type StreamVideoParticipantPatches, type SubscriptionChanges, VideoTrackType } from '../types';
+import { type ClosedCaptionsSettings, type StreamVideoParticipant, type StreamVideoParticipantPatch, type StreamVideoParticipantPatches, type SubscriptionChanges, VideoTrackType } from '../types';
 import { CallStatsReport } from '../stats';
-import { CallIngressResponse, CallResponse, CallSessionResponse, CallSettingsResponse, EgressResponse, MemberResponse, OwnCapability, ThumbnailResponse, UserResponse, WSEvent } from '../gen/coordinator';
+import { CallClosedCaption, CallIngressResponse, CallResponse, CallSessionResponse, CallSettingsResponse, EgressResponse, MemberResponse, OwnCapability, ThumbnailResponse, UserResponse, WSEvent } from '../gen/coordinator';
 import { ReconnectDetails } from '../gen/video/sfu/event/events';
 import { CallState as SfuCallState, Pin, TrackType } from '../gen/video/sfu/models/models';
 import { Comparator } from '../sorting';
@@ -32,6 +32,7 @@ export declare class CallState {
     private sessionSubject;
     private settingsSubject;
     private transcribingSubject;
+    private captioningSubject;
     private endedBySubject;
     private thumbnailsSubject;
     private membersSubject;
@@ -42,6 +43,7 @@ export declare class CallState {
     private anonymousParticipantCountSubject;
     private participantsSubject;
     private callStatsReportSubject;
+    private closedCaptionsSubject;
     private orphanedTracks;
     /**
      * The time the call session actually started.
@@ -165,6 +167,10 @@ export declare class CallState {
      * Will provide the transcribing state of this call.
      */
     transcribing$: Observable<boolean>;
+    /**
+     * Will provide the closed captioning state of this call.
+     */
+    captioning$: Observable<boolean>;
     /**
      * Will provide the user who ended this call.
      */
@@ -173,19 +179,30 @@ export declare class CallState {
      * Will provide the thumbnails of this call.
      */
     thumbnails$: Observable<ThumbnailResponse | undefined>;
+    /**
+     * The queue of closed captions.
+     */
+    closedCaptions$: Observable<CallClosedCaption[]>;
     readonly logger: import("../..").Logger;
     /**
      * A list of comparators that are used to sort the participants.
-     *
-     * @private
      */
     private sortParticipantsBy;
+    /**
+     * The closed captions configuration.
+     */
+    private closedCaptionsSettings;
+    private closedCaptionsTasks;
     private readonly eventHandlers;
     /**
      * Creates a new instance of the CallState class.
      *
      */
     constructor();
+    /**
+     * Runs the cleanup tasks.
+     */
+    dispose: () => void;
     /**
      * Sets the list of criteria that are used to sort the participants.
      * To disable sorting, you can pass `noopComparator()`.
@@ -236,6 +253,21 @@ export declare class CallState {
      * @param startedAt the time the call session actually started.
      */
     setStartedAt: (startedAt: Patch<Date | undefined>) => Date | undefined;
+    /**
+     * Returns whether closed captions are enabled in the current call.
+     */
+    get captioning(): boolean;
+    /**
+     * Sets the closed captioning state of the current call.
+     *
+     * @internal
+     * @param captioning the closed captioning state.
+     */
+    setCaptioning: (captioning: boolean) => {
+        lastValue: boolean;
+        value: boolean;
+        rollback: () => boolean;
+    };
     /**
      * The server-side counted number of anonymous participants connected to the current call.
      * This number includes the anonymous participants as well.
@@ -393,6 +425,10 @@ export declare class CallState {
      * Will provide the thumbnails of this call, if enabled in the call settings.
      */
     get thumbnails(): ThumbnailResponse | undefined;
+    /**
+     * Returns the current queue of closed captions.
+     */
+    get closedCaptions(): CallClosedCaption[];
     /**
      * Will try to find the participant with the given sessionId in the current call.
      *
@@ -443,7 +479,6 @@ export declare class CallState {
      *
      * @param trackType the kind of subscription to update.
      * @param changes the list of subscription changes to do.
-     * @param type the debounce type to use for the update.
      */
     updateParticipantTracks: (trackType: VideoTrackType, changes: SubscriptionChanges) => StreamVideoParticipant[];
     /**
@@ -485,6 +520,12 @@ export declare class CallState {
      * @param trackLookupPrefix the track lookup prefix to match the orphaned tracks by.
      */
     takeOrphanedTracks: (trackLookupPrefix: string) => OrphanedTrack[];
+    /**
+     * Updates the closed captions settings.
+     *
+     * @param config the new closed captions settings.
+     */
+    updateClosedCaptionSettings: (config: Partial<ClosedCaptionsSettings>) => void;
     /**
      * Updates the call state with the data received from the server.
      *
@@ -517,5 +558,6 @@ export declare class CallState {
     private unblockUser;
     private blockUser;
     private updateOwnCapabilities;
+    private updateFromClosedCaptions;
 }
 export {};

package/dist/src/store/rxUtils.d.ts

@@ -1,4 +1,4 @@
-import { Observable, Subject } from 'rxjs';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
 type FunctionPatch<T> = (currentValue: T) => T;
 /**
  * A value or a function which takes the current value and returns a new value.
@@ -21,6 +21,20 @@ export declare const getCurrentValue: <T>(observable$: Observable<T>) => T;
  * @return the updated value.
  */
 export declare const setCurrentValue: <T>(subject: Subject<T>, update: Patch<T>) => T;
+/**
+ * Updates the value of the provided Subject and returns the previous value
+ * and a function to roll back the update.
+ * This is useful when you want to optimistically update a value
+ * and roll back the update if an error occurs.
+ *
+ * @param subject the subject to update.
+ * @param update the update to apply to the subject.
+ */
+export declare const updateValue: <T>(subject: BehaviorSubject<T>, update: Patch<T>) => {
+    lastValue: T;
+    value: T;
+    rollback: () => T;
+};
 /**
  * Creates a subscription and returns a function to unsubscribe.
  *

package/dist/src/types.d.ts

@@ -89,6 +89,20 @@ export type ParticipantPin = {
      */
     pinnedAt: number;
 };
+export type ClosedCaptionsSettings = {
+    /**
+     * The time in milliseconds to keep a closed caption in the state (visible).
+     * Default is 2700 ms.
+     */
+    visibilityDurationMs?: number;
+    /**
+     * The maximum number of closed captions to keep in the state (visible).
+     * When the maximum number is reached, the oldest closed caption is removed.
+     *
+     * Default is 2.
+     */
+    maxVisibleCaptions?: number;
+};
 /**
  * A partial representation of the StreamVideoParticipant.
  */
@@ -110,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';
@@ -118,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.
-     */
-    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.
+     * The fmtp line for the video codec.
      */
-    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.13.1",
+  "version": "1.15.0",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",