@stream-io/video-client 1.40.3 → 1.41.0

package/src/rtc/helpers/__tests__/sdp.startBitrate.test.ts

@@ -109,4 +109,109 @@ a=fmtp:103 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001
       'a=fmtp:103 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f;x-google-start-bitrate=1050',
     );
   });
+
+  it('clamps to 300kbps when factor is 0', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+a=fmtp:98 profile-id=0
+`;
+
+    const result = setStartBitrate(offerSdp, 1500, 0, '0'); // 0 -> clamped to 300
+    expect(result).toContain(
+      'a=fmtp:98 profile-id=0;x-google-start-bitrate=300',
+    );
+  });
+
+  it('uses max bitrate when factor is 1', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+a=fmtp:98 profile-id=0
+`;
+
+    const result = setStartBitrate(offerSdp, 1500, 1, '0'); // should be 1500
+    expect(result).toContain(
+      'a=fmtp:98 profile-id=0;x-google-start-bitrate=1500',
+    );
+  });
+
+  it('clamps to max bitrate when factor exceeds 1', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+a=fmtp:98 profile-id=0
+`;
+
+    const result = setStartBitrate(offerSdp, 1500, 1.5, '0'); // 2250 -> clamped to 1500
+    expect(result).toContain(
+      'a=fmtp:98 profile-id=0;x-google-start-bitrate=1500',
+    );
+  });
+
+  it('creates fmtp line when none exists for target codec', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+`;
+
+    const result = setStartBitrate(offerSdp, 1500, 0.5, '0'); // 750kbps
+    expect(result).toContain('a=fmtp:98 x-google-start-bitrate=750');
+  });
+
+  it('creates fmtp lines for multiple codecs without existing fmtp', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98 103
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+a=rtpmap:103 H264/90000
+`;
+
+    const result = setStartBitrate(offerSdp, 1500, 0.5, '0'); // 750kbps
+    expect(result).toContain('a=fmtp:98 x-google-start-bitrate=750');
+    expect(result).toContain('a=fmtp:103 x-google-start-bitrate=750');
+  });
+
+  it('never exceeds maxBitrateKbps even when it is below 300', () => {
+    const offerSdp = `v=0
+o=- 123 2 IN IP4 127.0.0.1
+s=-
+t=0 0
+m=video 9 UDP/TLS/RTP/SAVPF 98
+c=IN IP4 0.0.0.0
+a=mid:0
+a=rtpmap:98 VP9/90000
+a=fmtp:98 profile-id=0
+`;
+
+    // maxBitrateKbps (200) is less than minimum (300), should clamp to maxBitrateKbps
+    const result = setStartBitrate(offerSdp, 200, 1, '0');
+    expect(result).toContain(
+      'a=fmtp:98 profile-id=0;x-google-start-bitrate=200',
+    );
+  });
 });

package/src/rtc/helpers/sdp.ts

@@ -29,11 +29,13 @@ export const extractMid = (
   return String(transceiverInitIndex);
 };
 
-/*
- * Sets the start bitrate for the VP9 and H264 codecs in the SDP.
+/**
+ * Sets the start bitrate for the VP9, H264, and AV1 codecs in the SDP.
  *
  * @param offerSdp the offer SDP to modify.
- * @param startBitrate the start bitrate in kbps to set. Default is 1000 kbps.
+ * @param maxBitrateKbps the maximum bitrate in kbps.
+ * @param startBitrateFactor the factor (0-1) to multiply with maxBitrateKbps to get the start bitrate.
+ * @param targetMid the media ID to target.
  */
 export const setStartBitrate = (
   offerSdp: string,
@@ -42,9 +44,10 @@ export const setStartBitrate = (
   targetMid: string,
 ): string => {
   // start bitrate should be between 300kbps and max-bitrate-kbps
-  const startBitrate = Math.max(
-    Math.min(maxBitrateKbps, startBitrateFactor * maxBitrateKbps),
-    300,
+  // Clamp to max first, then ensure minimum of 300 (but never exceed max)
+  const startBitrate = Math.min(
+    maxBitrateKbps,
+    Math.max(300, startBitrateFactor * maxBitrateKbps),
   );
   const parsedSdp = parse(offerSdp);
   const targetCodecs = new Set(['av1', 'vp9', 'h264']);
@@ -56,13 +59,28 @@ export const setStartBitrate = (
     for (const rtp of media.rtp) {
       if (!targetCodecs.has(rtp.codec.toLowerCase())) continue;
 
-      for (const fmtp of media.fmtp) {
-        if (fmtp.payload === rtp.payload) {
-          if (!fmtp.config.includes('x-google-start-bitrate')) {
-            fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
-          }
-          break;
+      // Find existing fmtp entry for this payload
+      // Guard against media.fmtp being undefined when SDP has no a=fmtp lines
+      const fmtpList = media.fmtp ?? (media.fmtp = []);
+      const existingFmtp = fmtpList.find(
+        (fmtp) => fmtp.payload === rtp.payload,
+      );
+
+      if (existingFmtp) {
+        // Append to existing fmtp if not already present
+        // Guard against undefined or empty config from malformed SDP
+        const config = existingFmtp.config ?? '';
+        if (!config.includes('x-google-start-bitrate')) {
+          existingFmtp.config = config
+            ? `${config};x-google-start-bitrate=${startBitrate}`
+            : `x-google-start-bitrate=${startBitrate}`;
         }
+      } else {
+        // Create new fmtp entry if none exists
+        fmtpList.push({
+          payload: rtp.payload,
+          config: `x-google-start-bitrate=${startBitrate}`,
+        });
       }
     }
   }

package/src/store/CallState.ts

@@ -12,6 +12,7 @@ import type { Patch } from './rxUtils';
 import * as RxUtils from './rxUtils';
 import { CallingState } from './CallingState';
 import {
+  type CallRecordingType,
   type ClosedCaptionsSettings,
   type StreamVideoParticipant,
   type StreamVideoParticipantPatch,
@@ -49,12 +50,13 @@ import {
 import { Timestamp } from '../gen/google/protobuf/timestamp';
 import { ReconnectDetails } from '../gen/video/sfu/event/events';
 import {
+  CallGrants,
   CallState as SfuCallState,
   Pin,
   TrackType,
-  CallGrants,
 } from '../gen/video/sfu/models/models';
 import { Comparator, defaultSortPreset } from '../sorting';
+import { ensureExhausted } from '../helpers/ensureExhausted';
 import { hasScreenShare } from '../helpers/participantUtils';
 import { videoLoggerSystem } from '../logger';
 
@@ -96,6 +98,8 @@ export class CallState {
     undefined,
   );
   private recordingSubject = new BehaviorSubject<boolean>(false);
+  private individualRecordingSubject = new BehaviorSubject<boolean>(false);
+  private rawRecordingSubject = new BehaviorSubject<boolean>(false);
   private sessionSubject = new BehaviorSubject<CallSessionResponse | undefined>(
     undefined,
   );
@@ -277,6 +281,16 @@ export class CallState {
    */
   recording$: Observable<boolean>;
 
+  /**
+   * Will provide the recording state of this call.
+   */
+  individualRecording$: Observable<boolean>;
+
+  /**
+   * Will provide the recording state of this call.
+   */
+  rawRecording$: Observable<boolean>;
+
   /**
    * Will provide the session data of this call.
    */
@@ -462,6 +476,8 @@ export class CallState {
     );
     this.participantCount$ = duc(this.participantCountSubject);
     this.recording$ = duc(this.recordingSubject);
+    this.individualRecording$ = duc(this.individualRecordingSubject);
+    this.rawRecording$ = duc(this.rawRecordingSubject);
     this.transcribing$ = duc(this.transcribingSubject);
     this.captioning$ = duc(this.captioningSubject);
 
@@ -530,12 +546,15 @@ export class CallState {
       },
       'call.permissions_updated': this.updateOwnCapabilities,
       'call.reaction_new': this.updateParticipantReaction,
-      'call.recording_started': () =>
-        this.setCurrentValue(this.recordingSubject, true),
-      'call.recording_stopped': () =>
-        this.setCurrentValue(this.recordingSubject, false),
-      'call.recording_failed': () =>
-        this.setCurrentValue(this.recordingSubject, false),
+      'call.recording_started': (e) => {
+        this.updateFromRecordingEvent(e.recording_type, true);
+      },
+      'call.recording_stopped': (e) => {
+        this.updateFromRecordingEvent(e.recording_type, false);
+      },
+      'call.recording_failed': (e) => {
+        this.updateFromRecordingEvent(e.recording_type, false);
+      },
       'call.rejected': (e) => this.updateFromCallResponse(e.call),
       'call.ring': (e) => this.updateFromCallResponse(e.call),
       'call.missed': (e) => this.updateFromCallResponse(e.call),
@@ -919,12 +938,26 @@ export class CallState {
   }
 
   /**
-   * Will provide the recording state of this call.
+   * Will provide the composite recording state of this call.
    */
   get recording() {
     return this.getCurrentValue(this.recording$);
   }
 
+  /**
+   * Will provide the individual recording state of this call.
+   */
+  get individualRecording() {
+    return this.getCurrentValue(this.individualRecording$);
+  }
+
+  /**
+   * Will provide the raw recording state of this call.
+   */
+  get rawRecording() {
+    return this.getCurrentValue(this.rawRecording$);
+  }
+
   /**
    * Will provide the session data of this call.
    */
@@ -1272,7 +1305,21 @@ export class CallState {
     this.setCurrentValue(this.customSubject, call.custom);
     this.setCurrentValue(this.egressSubject, call.egress);
     this.setCurrentValue(this.ingressSubject, call.ingress);
-    this.setCurrentValue(this.recordingSubject, call.recording);
+    const { individual_recording, composite_recording, raw_recording } =
+      call.egress;
+    this.setCurrentValue(
+      this.recordingSubject,
+      call.recording || composite_recording?.status === 'running',
+    );
+    this.setCurrentValue(
+      this.individualRecordingSubject,
+      individual_recording?.status === 'running',
+    );
+    this.setCurrentValue(
+      this.rawRecordingSubject,
+      raw_recording?.status === 'running',
+    );
+
     const s = this.setCurrentValue(this.sessionSubject, call.session);
     this.updateParticipantCountFromSession(s);
     this.setCurrentValue(this.settingsSubject, call.settings);
@@ -1363,6 +1410,22 @@ export class CallState {
     }));
   };
 
+  private updateFromRecordingEvent = (
+    type: CallRecordingType | undefined,
+    running: boolean,
+  ) => {
+    // handle the legacy format, where `type` is absent in the emitted events
+    if (type === undefined || type === 'composite') {
+      this.setCurrentValue(this.recordingSubject, running);
+    } else if (type === 'individual') {
+      this.setCurrentValue(this.individualRecordingSubject, running);
+    } else if (type === 'raw') {
+      this.setCurrentValue(this.rawRecordingSubject, running);
+    } else {
+      ensureExhausted(type, 'Unknown recording type');
+    }
+  };
+
   private updateParticipantCountFromSession = (
     session: CallSessionResponse | undefined,
   ) => {