@stream-io/video-client 1.11.3 → 1.11.5

package/src/helpers/promise.ts

@@ -0,0 +1,47 @@
+export interface SafePromise<T> {
+  (): Promise<T>;
+  checkPending(): boolean;
+}
+
+type Fulfillment<T> =
+  | {
+      status: 'resolved';
+      result: T;
+    }
+  | {
+      status: 'rejected';
+      error: unknown;
+    };
+
+/**
+ * Saving a long-lived reference to a promise that can reject can be unsafe,
+ * since rejecting the promise causes an unhandled rejection error (even if the
+ * rejection is handled everywhere promise result is expected).
+ *
+ * To avoid that, we add both resolution and rejection handlers to the promise.
+ * That way, the saved promise never rejects. A callback is provided as return
+ * value to build a *new* promise, that resolves and rejects along with
+ * the original promise.
+ * @param promise Promise to wrap, which possibly rejects
+ * @returns Callback to build a new promise, which resolves and rejects along
+ * with the original promise
+ */
+export function makeSafePromise<T>(promise: Promise<T>): SafePromise<T> {
+  let isPending = true;
+
+  const safePromise: Promise<Fulfillment<T>> = promise
+    .then(
+      (result) => ({ status: 'resolved' as const, result }),
+      (error) => ({ status: 'rejected' as const, error }),
+    )
+    .finally(() => (isPending = false));
+
+  const unwrapPromise = () =>
+    safePromise.then((fulfillment) => {
+      if (fulfillment.status === 'rejected') throw fulfillment.error;
+      return fulfillment.result;
+    });
+
+  unwrapPromise.checkPending = () => isPending;
+  return unwrapPromise;
+}

package/src/helpers/sdp-munging.ts

@@ -129,6 +129,61 @@ export const toggleDtx = (sdp: string, enable: boolean): string => {
   return sdp.replace(opusFmtp.original, newFmtp);
 };
 
+/**
+ * Returns and SDP with all the codecs except the given codec removed.
+ */
+export const preserveCodec = (
+  sdp: string,
+  mid: string,
+  codec: RTCRtpCodec,
+): string => {
+  const [kind, codecName] = codec.mimeType.toLowerCase().split('/');
+
+  const toSet = (fmtpLine: string) =>
+    new Set(fmtpLine.split(';').map((f) => f.trim().toLowerCase()));
+
+  const equal = (a: Set<string>, b: Set<string>) => {
+    if (a.size !== b.size) return false;
+    for (const item of a) if (!b.has(item)) return false;
+    return true;
+  };
+
+  const codecFmtp = toSet(codec.sdpFmtpLine || '');
+  const parsedSdp = SDP.parse(sdp);
+  for (const media of parsedSdp.media) {
+    if (media.type !== kind || String(media.mid) !== mid) continue;
+
+    // find the payload id of the desired codec
+    const payloads = new Set<number>();
+    for (const rtp of media.rtp) {
+      if (
+        rtp.codec.toLowerCase() === codecName &&
+        media.fmtp.some(
+          (f) => f.payload === rtp.payload && equal(toSet(f.config), codecFmtp),
+        )
+      ) {
+        payloads.add(rtp.payload);
+      }
+    }
+
+    // find the corresponding rtx codec by matching apt=<preserved-codec-payload>
+    for (const fmtp of media.fmtp) {
+      const match = fmtp.config.match(/(apt)=(\d+)/);
+      if (!match) continue;
+      const [, , preservedCodecPayload] = match;
+      if (payloads.has(Number(preservedCodecPayload))) {
+        payloads.add(fmtp.payload);
+      }
+    }
+
+    media.rtp = media.rtp.filter((r) => payloads.has(r.payload));
+    media.fmtp = media.fmtp.filter((f) => payloads.has(f.payload));
+    media.rtcpFb = media.rtcpFb?.filter((f) => payloads.has(f.payload));
+    media.payloads = Array.from(payloads).join(' ');
+  }
+  return SDP.write(parsedSdp);
+};
+
 /**
  * Enables high-quality audio through SDP munging for the given trackMid.
  *

package/src/rtc/Publisher.ts

@@ -20,6 +20,7 @@ import { PublishOptions } from '../types';
 import {
   enableHighQualityAudio,
   extractMid,
+  preserveCodec,
   toggleDtx,
 } from '../helpers/sdp-munging';
 import { Logger } from '../coordinator/connection/types';
@@ -530,6 +531,12 @@ export class Publisher {
       if (this.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
         offer.sdp = this.enableHighQualityAudio(offer.sdp);
       }
+      if (this.isPublishing(TrackType.VIDEO)) {
+        // Hotfix for platforms that don't respect the ordered codec list
+        // (Firefox, Android, Linux, etc...).
+        // We remove all the codecs from the SDP except the one we want to use.
+        offer.sdp = this.removeUnpreferredCodecs(offer.sdp, TrackType.VIDEO);
+      }
     }
 
     const trackInfos = this.getAnnouncedTracks(offer.sdp);
@@ -564,6 +571,23 @@ export class Publisher {
     );
   };
 
+  private removeUnpreferredCodecs(sdp: string, trackType: TrackType): string {
+    const opts = this.publishOptsForTrack.get(trackType);
+    if (!opts || !opts.forceSingleCodec) return sdp;
+
+    const codec = opts.forceCodec || opts.preferredCodec;
+    const orderedCodecs = this.getCodecPreferences(trackType, codec);
+    if (!orderedCodecs || orderedCodecs.length === 0) return sdp;
+
+    const transceiver = this.transceiverCache.get(trackType);
+    if (!transceiver) return sdp;
+
+    const index = this.transceiverInitOrder.indexOf(trackType);
+    const mid = extractMid(transceiver, index, sdp);
+    const [codecToPreserve] = orderedCodecs;
+    return preserveCodec(sdp, mid, codecToPreserve);
+  }
+
   private enableHighQualityAudio = (sdp: string) => {
     const transceiver = this.transceiverCache.get(TrackType.SCREEN_SHARE_AUDIO);
     if (!transceiver) return sdp;

package/src/rtc/codecs.ts

@@ -50,7 +50,7 @@ export const getPreferredCodecs = (
     }
 
     const sdpFmtpLine = codec.sdpFmtpLine;
-    if (!sdpFmtpLine || !sdpFmtpLine.includes('profile-level-id=42e01f')) {
+    if (!sdpFmtpLine || !sdpFmtpLine.includes('profile-level-id=42')) {
       // this is not the baseline h264 codec, prioritize it lower
       partiallyPreferred.push(codec);
       continue;

package/src/types.ts

@@ -167,6 +167,12 @@ export type PublishOptions = {
    * 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.
+   */
+  forceSingleCodec?: boolean;
   /**
    * The preferred scalability to use when publishing the video stream.
    * Applicable only for SVC codecs.