@stream-io/video-client 1.22.0 → 1.22.1

package/dist/src/gen/video/sfu/models/models.d.ts

@@ -285,6 +285,14 @@ export interface PublishOption {
      * @generated from protobuf field: int32 id = 8;
      */
     id: number;
+    /**
+     * If true, instructs the publisher to send only the highest available simulcast layer,
+     * disabling all lower layers. This applies to simulcast encodings.
+     * For SVC codecs, prefer using the L1T3 (single spatial, 3 temporal layers) mode instead.
+     *
+     * @generated from protobuf field: bool use_single_layer = 9;
+     */
+    useSingleLayer: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec

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

@@ -43,5 +43,6 @@ export declare class SfuStatsReporter {
     private run;
     start: () => void;
     stop: () => void;
+    flush: () => void;
     scheduleOne: (timeout: number) => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.22.0",
+  "version": "1.22.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -591,6 +591,7 @@ export class Call {
       this.statsReporter?.stop();
       this.statsReporter = undefined;
 
+      this.sfuStatsReporter?.flush();
       this.sfuStatsReporter?.stop();
       this.sfuStatsReporter = undefined;
 
@@ -1013,7 +1014,7 @@ export class Call {
       );
     }
 
-    if (performingRejoin) {
+    if (performingRejoin && isWsHealthy) {
       const strategy = WebsocketReconnectStrategy[this.reconnectStrategy];
       await previousSfuClient?.leaveAndClose(
         `Closing previous WS after reconnect with strategy: ${strategy}`,
@@ -1338,16 +1339,12 @@ export class Call {
   ): Promise<void> => {
     if (
       this.state.callingState === CallingState.RECONNECTING ||
+      this.state.callingState === CallingState.MIGRATING ||
       this.state.callingState === CallingState.RECONNECTING_FAILED
     )
       return;
 
     return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
-      this.logger(
-        'info',
-        `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[strategy]}`,
-      );
-
       const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
       this.reconnectReason = reason;
@@ -1374,6 +1371,12 @@ export class Call {
         try {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
+
+          this.logger(
+            'info',
+            `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`,
+          );
+
           switch (this.reconnectStrategy) {
             case WebsocketReconnectStrategy.UNSPECIFIED:
             case WebsocketReconnectStrategy.DISCONNECT:
@@ -1428,6 +1431,7 @@ export class Call {
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
       );
+      this.logger('info', '[Reconnect] Reconnection flow finished');
     });
   };
 

package/src/gen/video/sfu/models/models.ts

@@ -289,6 +289,14 @@ export interface PublishOption {
    * @generated from protobuf field: int32 id = 8;
    */
   id: number;
+  /**
+   * If true, instructs the publisher to send only the highest available simulcast layer,
+   * disabling all lower layers. This applies to simulcast encodings.
+   * For SVC codecs, prefer using the L1T3 (single spatial, 3 temporal layers) mode instead.
+   *
+   * @generated from protobuf field: bool use_single_layer = 9;
+   */
+  useSingleLayer: boolean;
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.Codec
@@ -1314,6 +1322,12 @@ class PublishOption$Type extends MessageType<PublishOption> {
         T: () => VideoDimension,
       },
       { no: 8, name: 'id', kind: 'scalar', T: 5 /*ScalarType.INT32*/ },
+      {
+        no: 9,
+        name: 'use_single_layer',
+        kind: 'scalar',
+        T: 8 /*ScalarType.BOOL*/,
+      },
     ]);
   }
 }

package/src/rtc/BasePeerConnection.ts

@@ -258,10 +258,11 @@ export abstract class BasePeerConnection {
     // do nothing when ICE is restarting
     if (this.isIceRestarting) return;
 
-    if (state === 'failed' || state === 'disconnected') {
+    if (state === 'failed') {
+      this.onUnrecoverableError?.('ICE connection failed');
+    } else if (state === 'disconnected') {
       this.logger('debug', `Attempting to restart ICE`);
       this.restartIce().catch((e) => {
-        if (this.isDisposed) return;
         const reason = `ICE restart failed`;
         this.logger('error', reason, e);
         this.onUnrecoverableError?.(`${reason}: ${e}`);

package/src/rtc/Publisher.ts

@@ -122,6 +122,10 @@ export class Publisher extends BasePeerConnection {
       sendEncodings,
     });
 
+    const params = transceiver.sender.getParameters();
+    params.degradationPreference = 'maintain-framerate';
+    await transceiver.sender.setParameters(params);
+
     const trackType = publishOption.trackType;
     this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
     this.transceiverCache.add(publishOption, transceiver);

package/src/rtc/__tests__/Publisher.test.ts

@@ -243,11 +243,11 @@ describe('Publisher', () => {
     });
 
     it(`should perform ICE restart when connection state changes to 'failed'`, () => {
-      vi.spyOn(publisher, 'restartIce').mockResolvedValue();
+      publisher['onUnrecoverableError'] = vi.fn();
       // @ts-expect-error private api
       publisher['pc'].iceConnectionState = 'failed';
       publisher['onIceConnectionStateChange']();
-      expect(publisher.restartIce).toHaveBeenCalled();
+      expect(publisher['onUnrecoverableError']).toHaveBeenCalled();
     });
 
     it(`should perform ICE restart when connection state changes to 'disconnected'`, () => {

package/src/rtc/__tests__/Subscriber.test.ts

@@ -103,11 +103,11 @@ describe('Subscriber', () => {
     });
 
     it(`should perform ICE restart when connection state changes to 'failed'`, () => {
-      vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
+      subscriber['onUnrecoverableError'] = vi.fn();
       // @ts-expect-error - private field
       subscriber['pc'].iceConnectionState = 'failed';
       subscriber['onIceConnectionStateChange']();
-      expect(subscriber.restartIce).toHaveBeenCalled();
+      expect(subscriber['onUnrecoverableError']).toHaveBeenCalled();
     });
 
     it(`should perform ICE restart when connection state changes to 'disconnected'`, () => {

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -55,7 +55,7 @@ const RTCRtpTransceiverMock = vi.fn((): Partial<RTCRtpTransceiver> => {
     sender: {
       track: null,
       replaceTrack: vi.fn(),
-      getParameters: vi.fn(),
+      getParameters: vi.fn().mockReturnValue({}),
       setParameters: vi.fn(),
     },
     setCodecPreferences: vi.fn(),

package/src/rtc/__tests__/videoLayers.test.ts

@@ -170,6 +170,50 @@ describe('videoLayers', () => {
     expect(layers[2].rid).toBe('f');
   });
 
+  it('should activate only a single layer when useSingleLayer is true', () => {
+    const track = new MediaStreamTrack();
+    // @ts-expect-error - incomplete data
+    const layers = computeVideoLayers(track, { useSingleLayer: true });
+    expect(layers.length).toBe(3);
+    expect(layers[0].active).toBe(false);
+    expect(layers[0].rid).toBe('q');
+    expect(layers[1].active).toBe(false);
+    expect(layers[1].rid).toBe('h');
+    expect(layers[2].active).toBe(true);
+    expect(layers[2].rid).toBe('f');
+  });
+
+  it('should activate only a single layer when useSingleLayer is true in single layer mode', () => {
+    const track = new MediaStreamTrack();
+    vi.spyOn(track, 'getSettings').mockReturnValue({ width: 320, height: 180 });
+    // @ts-expect-error - incomplete data
+    const layers = computeVideoLayers(track, { useSingleLayer: true });
+    expect(layers.length).toBe(1);
+    expect(layers[0].active).toBe(true);
+    expect(layers[0].rid).toBe('q');
+  });
+
+  it('should activate only one temporal layer when useSingleLayer is true for SVC', () => {
+    const track = new MediaStreamTrack();
+    const layers = computeVideoLayers(track, {
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp9' },
+      maxSpatialLayers: 3,
+      maxTemporalLayers: 3,
+      useSingleLayer: true,
+    });
+    expect(layers.length).toBe(3);
+    expect(layers[0].rid).toBe('q');
+    expect(layers[0].active).toBe(false);
+    expect(layers[0].scalabilityMode).toBe('L1T3');
+    expect(layers[1].active).toBe(false);
+    expect(layers[1].rid).toBe('h');
+    expect(layers[1].scalabilityMode).toBe('L1T3');
+    expect(layers[2].active).toBe(true);
+    expect(layers[2].rid).toBe('f');
+    expect(layers[2].scalabilityMode).toBe('L1T3');
+  });
+
   it('should map rids to VideoQuality', () => {
     expect(ridToVideoQuality('q')).toBe(VideoQuality.LOW_UNSPECIFIED);
     expect(ridToVideoQuality('h')).toBe(VideoQuality.MID);

package/src/rtc/videoLayers.ts

@@ -93,6 +93,7 @@ export const computeVideoLayers = (
     maxSpatialLayers = 3,
     maxTemporalLayers = 3,
     videoDimension = { width: 1280, height: 720 },
+    useSingleLayer,
   } = publishOption;
   const maxBitrate = getComputedMaxBitrate(
     videoDimension,
@@ -117,7 +118,7 @@ export const computeVideoLayers = (
       // for SVC codecs, we need to set the scalability mode, and the
       // codec will handle the rest (layers, temporal layers, etc.)
       layer.scalabilityMode = toScalabilityMode(
-        maxSpatialLayers,
+        useSingleLayer ? 1 : maxSpatialLayers,
         maxTemporalLayers,
       );
     } else {
@@ -136,7 +137,7 @@ export const computeVideoLayers = (
 
   // for simplicity, we start with all layers enabled, then this function
   // will clear/reassign the layers that are not needed
-  return withSimulcastConstraints(settings, optimalVideoLayers);
+  return withSimulcastConstraints(settings, optimalVideoLayers, useSingleLayer);
 };
 
 /**
@@ -180,6 +181,7 @@ export const getComputedMaxBitrate = (
 const withSimulcastConstraints = (
   settings: MediaTrackSettings,
   optimalVideoLayers: OptimalVideoLayer[],
+  useSingleLayer: boolean,
 ) => {
   let layers: OptimalVideoLayer[];
 
@@ -196,8 +198,9 @@ const withSimulcastConstraints = (
   }
 
   const ridMapping = ['q', 'h', 'f'];
-  return layers.map<OptimalVideoLayer>((layer, index) => ({
+  return layers.map<OptimalVideoLayer>((layer, index, arr) => ({
     ...layer,
     rid: ridMapping[index], // reassign rid
+    active: useSingleLayer && index < arr.length - 1 ? false : layer.active,
   }));
 };

package/src/stats/SfuStatsReporter.ts

@@ -235,6 +235,12 @@ export class SfuStatsReporter {
     this.timeoutId = undefined;
   };
 
+  flush = () => {
+    this.run().catch((err) => {
+      this.logger('warn', 'Failed to flush report stats', err);
+    });
+  };
+
   scheduleOne = (timeout: number) => {
     clearTimeout(this.timeoutId);
     this.timeoutId = setTimeout(() => {