@stream-io/video-client 1.14.0 → 1.15.0

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

@@ -5,7 +5,7 @@ import { DispatchableMessage, Dispatcher } from '../Dispatcher';
 import { StreamSfuClient } from '../../StreamSfuClient';
 import { Subscriber } from '../Subscriber';
 import { CallState } from '../../store';
-import { SfuEvent } from '../../gen/video/sfu/event/events';
+import { SfuEvent, SubscriberOffer } from '../../gen/video/sfu/event/events';
 import { PeerType, TrackType } from '../../gen/video/sfu/models/models';
 import { IceTrickleBuffer } from '../IceTrickleBuffer';
 import { StreamClient } from '../../coordinator/connection/client';
@@ -55,44 +55,10 @@ describe('Subscriber', () => {
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();
-    dispatcher.offAll();
+    subscriber.dispose();
   });
 
   describe('Subscriber ICE restart', () => {
-    it('should perform ICE restart when iceRestart event is received', () => {
-      sfuClient.iceRestart = vi.fn();
-      dispatcher.dispatch(
-        SfuEvent.create({
-          eventPayload: {
-            oneofKind: 'iceRestart',
-            iceRestart: {
-              peerType: PeerType.SUBSCRIBER,
-            },
-          },
-        }) as DispatchableMessage<'iceRestart'>,
-      );
-
-      expect(sfuClient.iceRestart).toHaveBeenCalledWith({
-        peerType: PeerType.SUBSCRIBER,
-      });
-    });
-
-    it('should not perform ICE restart when iceRestart event is received for a different peer type', () => {
-      sfuClient.iceRestart = vi.fn();
-      dispatcher.dispatch(
-        SfuEvent.create({
-          eventPayload: {
-            oneofKind: 'iceRestart',
-            iceRestart: {
-              peerType: PeerType.PUBLISHER_UNSPECIFIED,
-            },
-          },
-        }) as DispatchableMessage<'iceRestart'>,
-      );
-
-      expect(sfuClient.iceRestart).not.toHaveBeenCalled();
-    });
-
     it(`should drop consequent ICE restart requests`, async () => {
       sfuClient.iceRestart = vi.fn();
       // @ts-ignore
@@ -111,6 +77,17 @@ describe('Subscriber', () => {
       expect(sfuClient.iceRestart).not.toHaveBeenCalled();
     });
 
+    it('should ask the SFU for ICE restart', async () => {
+      sfuClient.iceRestart = vi.fn();
+      // @ts-ignore
+      subscriber['pc'].connectionState = 'connected';
+
+      await subscriber.restartIce();
+      expect(sfuClient.iceRestart).toHaveBeenCalledWith({
+        peerType: PeerType.SUBSCRIBER,
+      });
+    });
+
     it(`should perform ICE restart when connection state changes to 'failed'`, () => {
       vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
       // @ts-ignore
@@ -175,5 +152,80 @@ describe('Subscriber', () => {
         videoStream: mediaStream,
       });
     });
+
+    it('should replace participant stream when a new one arrives', () => {
+      const mediaStream = new MediaStream();
+      const mediaStreamTrack = new MediaStreamTrack();
+      // @ts-ignore - mock
+      mediaStream.id = '123:TRACK_TYPE_VIDEO';
+
+      const updateParticipantSpy = vi.spyOn(state, 'updateParticipant');
+
+      const baseStream = new MediaStream();
+      const baseTrack = new MediaStreamTrack();
+      vi.spyOn(baseStream, 'getTracks').mockReturnValue([baseTrack]);
+      // @ts-expect-error - incomplete mock
+      state.updateOrAddParticipant('session-id', {
+        sessionId: 'session-id',
+        trackLookupPrefix: '123',
+        videoStream: baseStream,
+      });
+
+      const onTrack = subscriber['handleOnTrack'];
+      // @ts-expect-error - incomplete mock
+      onTrack({ streams: [mediaStream], track: mediaStreamTrack });
+
+      expect(updateParticipantSpy).toHaveBeenCalledWith('session-id', {
+        videoStream: mediaStream,
+      });
+      expect(baseStream.getTracks).toHaveBeenCalled();
+      expect(baseTrack.stop).toHaveBeenCalled();
+      expect(baseStream.removeTrack).toHaveBeenCalledWith(baseTrack);
+    });
+  });
+
+  describe('Negotiation', () => {
+    it('negotiates with the SFU', async () => {
+      sfuClient.sendAnswer = vi.fn();
+      subscriber['pc'].createAnswer = vi
+        .fn()
+        .mockResolvedValue({ sdp: 'answer-sdp' });
+
+      const offer = SubscriberOffer.create({ sdp: 'offer-sdp' });
+      // @ts-expect-error - private method
+      await subscriber.negotiate(offer);
+      expect(subscriber['pc'].setRemoteDescription).toHaveBeenCalledWith({
+        type: 'offer',
+        sdp: 'offer-sdp',
+      });
+
+      expect(subscriber['pc'].createAnswer).toHaveBeenCalled();
+      expect(sfuClient.sendAnswer).toHaveBeenCalledWith({
+        peerType: PeerType.SUBSCRIBER,
+        sdp: 'answer-sdp',
+      });
+    });
+  });
+
+  describe('Event handling', () => {
+    it('handles SubscriberOffer', async () => {
+      // @ts-expect-error - private method
+      subscriber.negotiate = vi.fn();
+      const subscriberOffer = SubscriberOffer.create({
+        sdp: 'offer-sdp',
+        iceRestart: false,
+      });
+      dispatcher.dispatch(
+        SfuEvent.create({
+          eventPayload: {
+            oneofKind: 'subscriberOffer',
+            subscriberOffer,
+          },
+        }) as DispatchableMessage<'subscriberOffer'>,
+      );
+
+      // @ts-expect-error - private method
+      expect(subscriber.negotiate).toHaveBeenCalledWith(subscriberOffer);
+    });
   });
 });

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

@@ -3,6 +3,7 @@ import { vi } from 'vitest';
 const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
   return {
     addEventListener: vi.fn(),
+    addIceCandidate: vi.fn(),
     removeEventListener: vi.fn(),
     getTransceivers: vi.fn(),
     addTransceiver: vi.fn(),
@@ -14,15 +15,21 @@ const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
     setRemoteDescription: vi.fn().mockResolvedValue({}),
     close: vi.fn(),
     connectionState: 'connected',
+    signalingState: 'stable',
     getReceivers: vi.fn(),
+    getSenders: vi.fn(),
+    removeTrack: vi.fn(),
   };
 });
 vi.stubGlobal('RTCPeerConnection', RTCPeerConnectionMock);
 
 const MediaStreamMock = vi.fn((): Partial<MediaStream> => {
   return {
-    getTracks: vi.fn(),
+    getTracks: vi.fn().mockReturnValue([]),
     addTrack: vi.fn(),
+    removeTrack: vi.fn(),
+    getAudioTracks: vi.fn().mockReturnValue([]),
+    getVideoTracks: vi.fn().mockReturnValue([]),
   };
 });
 vi.stubGlobal('MediaStream', MediaStreamMock);
@@ -31,10 +38,13 @@ const MediaStreamTrackMock = vi.fn((): Partial<MediaStreamTrack> => {
   return {
     addEventListener: vi.fn(),
     removeEventListener: vi.fn(),
-    getSettings: vi.fn(),
+    getSettings: vi.fn().mockReturnValue({ width: 1280, height: 720 }),
     stop: vi.fn(),
+    clone: vi.fn(),
     readyState: 'live',
     kind: 'video',
+    enabled: true,
+    id: crypto.randomUUID(),
   };
 });
 vi.stubGlobal('MediaStreamTrack', MediaStreamTrackMock);
@@ -49,6 +59,7 @@ const RTCRtpTransceiverMock = vi.fn((): Partial<RTCRtpTransceiver> => {
       setParameters: vi.fn(),
     },
     setCodecPreferences: vi.fn(),
+    mid: '',
   };
 });
 vi.stubGlobal('RTCRtpTransceiver', RTCRtpTransceiverMock);
@@ -69,3 +80,12 @@ const RTCRtpReceiverMock = vi.fn((): Partial<typeof RTCRtpReceiver> => {
   };
 });
 vi.stubGlobal('RTCRtpReceiver', RTCRtpReceiverMock);
+
+const RTCRtpSenderMock = vi.fn((): Partial<typeof RTCRtpSender> => {
+  return {
+    getCapabilities: vi.fn(),
+    // @ts-ignore
+    track: vi.fn(),
+  };
+});
+vi.stubGlobal('RTCRtpSender', RTCRtpSenderMock);

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

@@ -1,48 +1,20 @@
 import './mocks/webrtc.mocks';
 import { describe, expect, it, vi } from 'vitest';
 import {
-  findOptimalScreenSharingLayers,
-  findOptimalVideoLayers,
+  PublishOption,
+  TrackType,
+  VideoQuality,
+} from '../../gen/video/sfu/models/models';
+import {
+  computeVideoLayers,
   getComputedMaxBitrate,
   OptimalVideoLayer,
   ridToVideoQuality,
   toSvcEncodings,
+  toVideoLayers,
 } from '../videoLayers';
-import { VideoQuality } from '../../gen/video/sfu/models/models';
 
 describe('videoLayers', () => {
-  it('should find optimal screen sharing layers', () => {
-    const track = new MediaStreamTrack();
-    vi.spyOn(track, 'getSettings').mockReturnValue({
-      width: 1920,
-      height: 1080,
-    });
-
-    const layers = findOptimalScreenSharingLayers(track);
-    expect(layers).toEqual([
-      {
-        active: true,
-        rid: 'q',
-        width: 1920,
-        height: 1080,
-        maxBitrate: 3000000,
-        scaleResolutionDownBy: 1,
-        maxFramerate: 30,
-      },
-    ]);
-  });
-
-  it('should use default max bitrate if none is provided in preferences', () => {
-    const track = new MediaStreamTrack();
-    vi.spyOn(track, 'getSettings').mockReturnValue({
-      width: 1920,
-      height: 1080,
-    });
-
-    const layers = findOptimalScreenSharingLayers(track, undefined, 192000);
-    expect(layers).toMatchObject([{ maxBitrate: 192000 }]);
-  });
-
   it('should find optimal video layers', () => {
     const track = new MediaStreamTrack();
     const width = 1920;
@@ -50,11 +22,14 @@ describe('videoLayers', () => {
     const targetBitrate = 3000000;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
 
-    const layers = findOptimalVideoLayers(track, {
-      width,
-      height,
+    const publishOption: PublishOption = {
       bitrate: targetBitrate,
-    });
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp8' },
+      videoDimension: { width, height },
+      fps: 30,
+    };
+    const layers = computeVideoLayers(track, publishOption);
     expect(layers).toEqual([
       {
         active: true,
@@ -86,13 +61,31 @@ describe('videoLayers', () => {
     ]);
   });
 
+  it('should return undefined for audio track', () => {
+    const track = new MediaStreamTrack();
+    expect(
+      // @ts-expect-error - incomplete data
+      computeVideoLayers(track, { trackType: TrackType.AUDIO }),
+    ).toBeUndefined();
+    expect(
+      // @ts-expect-error - incomplete data
+      computeVideoLayers(track, { trackType: TrackType.SCREEN_SHARE_AUDIO }),
+    ).toBeUndefined();
+  });
+
   it('should use predefined bitrate values when track dimensions cant be determined', () => {
     const width = 0;
     const height = 0;
     const bitrate = 3000000;
     const track = new MediaStreamTrack();
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = findOptimalVideoLayers(track, { width, height, bitrate });
+    const layers = computeVideoLayers(track, {
+      bitrate,
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp8' },
+      fps: 30,
+      videoDimension: { width, height },
+    });
     expect(layers).toEqual([
       {
         active: true,
@@ -111,7 +104,13 @@ describe('videoLayers', () => {
     const width = 320;
     const height = 240;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = findOptimalVideoLayers(track);
+    const layers = computeVideoLayers(track, {
+      bitrate: 0,
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp8' },
+      fps: 30,
+      videoDimension: { width, height },
+    });
     expect(layers.length).toBe(1);
     expect(layers[0].rid).toBe('q');
   });
@@ -121,7 +120,13 @@ describe('videoLayers', () => {
     const width = 640;
     const height = 480;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = findOptimalVideoLayers(track);
+    const layers = computeVideoLayers(track, {
+      bitrate: 0,
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp8' },
+      fps: 30,
+      videoDimension: { width, height },
+    });
     expect(layers.length).toBe(2);
     expect(layers[0].rid).toBe('q');
     expect(layers[1].rid).toBe('h');
@@ -132,7 +137,13 @@ describe('videoLayers', () => {
     const width = 1280;
     const height = 720;
     vi.spyOn(track, 'getSettings').mockReturnValue({ width, height });
-    const layers = findOptimalVideoLayers(track);
+    const layers = computeVideoLayers(track, {
+      bitrate: 0,
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp8' },
+      fps: 30,
+      videoDimension: { width, height },
+    });
     expect(layers.length).toBe(3);
     expect(layers[0].rid).toBe('q');
     expect(layers[1].rid).toBe('h');
@@ -145,12 +156,15 @@ describe('videoLayers', () => {
       width: 1280,
       height: 720,
     });
-    const layers = findOptimalVideoLayers(track, undefined, 'vp9', {
-      preferredCodec: 'vp9',
-      scalabilityMode: 'L3T3',
+    const layers = computeVideoLayers(track, {
+      maxTemporalLayers: 3,
+      maxSpatialLayers: 3,
+      // @ts-expect-error - incomplete data
+      codec: { name: 'vp9' },
+      videoDimension: { width: 1280, height: 720 },
     });
     expect(layers.length).toBe(3);
-    expect(layers[0].scalabilityMode).toBe('L3T3');
+    expect(layers[0].scalabilityMode).toBe('L3T3_KEY');
     expect(layers[0].rid).toBe('q');
     expect(layers[1].rid).toBe('h');
     expect(layers[2].rid).toBe('f');
@@ -163,7 +177,39 @@ describe('videoLayers', () => {
     expect(ridToVideoQuality('')).toBe(VideoQuality.HIGH);
   });
 
-  it('should map OptimalVideoLayer to SVC encodings', () => {
+  it('should map optimal video layers to SFU VideoLayers', () => {
+    const layers: Array<Partial<OptimalVideoLayer>> = [
+      { rid: 'f', width: 1920, height: 1080, maxBitrate: 3000000 },
+      { rid: 'h', width: 960, height: 540, maxBitrate: 750000 },
+      { rid: 'q', width: 480, height: 270, maxBitrate: 187500 },
+    ];
+
+    const videoLayers = toVideoLayers(layers as OptimalVideoLayer[]);
+    expect(videoLayers.length).toBe(3);
+    expect(videoLayers[0]).toEqual({
+      rid: 'f',
+      bitrate: 3000000,
+      fps: 0,
+      quality: VideoQuality.HIGH,
+      videoDimension: { width: 1920, height: 1080 },
+    });
+    expect(videoLayers[1]).toEqual({
+      rid: 'h',
+      bitrate: 750000,
+      fps: 0,
+      quality: VideoQuality.MID,
+      videoDimension: { width: 960, height: 540 },
+    });
+    expect(videoLayers[2]).toEqual({
+      rid: 'q',
+      bitrate: 187500,
+      fps: 0,
+      quality: VideoQuality.LOW_UNSPECIFIED,
+      videoDimension: { width: 480, height: 270 },
+    });
+  });
+
+  it('should map OptimalVideoLayer to SVC encodings (three layers)', () => {
     const layers: Array<Partial<OptimalVideoLayer>> = [
       { rid: 'f', width: 1920, height: 1080, maxBitrate: 3000000 },
       { rid: 'h', width: 960, height: 540, maxBitrate: 750000 },
@@ -180,10 +226,46 @@ describe('videoLayers', () => {
     });
   });
 
+  it('should map OptimalVideoLayer to SVC encodings (two layers)', () => {
+    const layers: Array<Partial<OptimalVideoLayer>> = [
+      { rid: 'h', width: 960, height: 540, maxBitrate: 750000 },
+      { rid: 'q', width: 480, height: 270, maxBitrate: 187500 },
+    ];
+
+    const svcLayers = toSvcEncodings(layers as OptimalVideoLayer[]);
+    expect(svcLayers.length).toBe(1);
+    expect(svcLayers[0]).toEqual({
+      rid: 'q',
+      width: 960,
+      height: 540,
+      maxBitrate: 750000,
+    });
+  });
+
+  it('should map OptimalVideoLayer to SVC encodings (two layers)', () => {
+    const layers: Array<Partial<OptimalVideoLayer>> = [
+      { rid: 'q', width: 480, height: 270, maxBitrate: 187500 },
+    ];
+
+    const svcLayers = toSvcEncodings(layers as OptimalVideoLayer[]);
+    expect(svcLayers.length).toBe(1);
+    expect(svcLayers[0]).toEqual({
+      rid: 'q',
+      width: 480,
+      height: 270,
+      maxBitrate: 187500,
+    });
+  });
+
   describe('getComputedMaxBitrate', () => {
     it('should scale target bitrate down if resolution is smaller than target resolution', () => {
       const targetResolution = { width: 1920, height: 1080, bitrate: 3000000 };
-      const scaledBitrate = getComputedMaxBitrate(targetResolution, 1280, 720);
+      const scaledBitrate = getComputedMaxBitrate(
+        targetResolution,
+        1280,
+        720,
+        3000000,
+      );
       expect(scaledBitrate).toBe(1333333);
     });
 
@@ -193,7 +275,12 @@ describe('videoLayers', () => {
       const targetBitrates = ['f', 'h', 'q'].map((rid) => {
         const width = targetResolution.width / downscaleFactor;
         const height = targetResolution.height / downscaleFactor;
-        const bitrate = getComputedMaxBitrate(targetResolution, width, height);
+        const bitrate = getComputedMaxBitrate(
+          targetResolution,
+          width,
+          height,
+          3000000,
+        );
         downscaleFactor *= 2;
         return {
           rid,
@@ -211,25 +298,45 @@ describe('videoLayers', () => {
 
     it('should not scale target bitrate if resolution is larger than target resolution', () => {
       const targetResolution = { width: 1280, height: 720, bitrate: 1000000 };
-      const scaledBitrate = getComputedMaxBitrate(targetResolution, 2560, 1440);
+      const scaledBitrate = getComputedMaxBitrate(
+        targetResolution,
+        2560,
+        1440,
+        1000000,
+      );
       expect(scaledBitrate).toBe(1000000);
     });
 
     it('should not scale target bitrate if resolution is equal to target resolution', () => {
       const targetResolution = { width: 1280, height: 720, bitrate: 1000000 };
-      const scaledBitrate = getComputedMaxBitrate(targetResolution, 1280, 720);
+      const scaledBitrate = getComputedMaxBitrate(
+        targetResolution,
+        1280,
+        720,
+        1000000,
+      );
       expect(scaledBitrate).toBe(1000000);
     });
 
     it('should handle 0 width and height', () => {
       const targetResolution = { width: 1280, height: 720, bitrate: 1000000 };
-      const scaledBitrate = getComputedMaxBitrate(targetResolution, 0, 0);
+      const scaledBitrate = getComputedMaxBitrate(
+        targetResolution,
+        0,
+        0,
+        1000000,
+      );
       expect(scaledBitrate).toBe(0);
     });
 
     it('should handle 4k target resolution', () => {
       const targetResolution = { width: 3840, height: 2160, bitrate: 15000000 };
-      const scaledBitrate = getComputedMaxBitrate(targetResolution, 1280, 720);
+      const scaledBitrate = getComputedMaxBitrate(
+        targetResolution,
+        1280,
+        720,
+        15000000,
+      );
       expect(scaledBitrate).toBe(1666667);
     });
   });

package/src/rtc/codecs.ts

@@ -1,80 +1,7 @@
-import { getOSInfo } from '../client-details';
-import { isReactNative } from '../helpers/platforms';
-import { isFirefox, isSafari } from '../helpers/browsers';
-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 const getPreferredCodecs = (
-  kind: 'audio' | 'video',
-  preferredCodec: string,
-  codecToRemove: string | undefined,
-  codecPreferencesSource: 'sender' | 'receiver',
-): RTCRtpCodec[] | undefined => {
-  const source =
-    codecPreferencesSource === 'receiver' ? RTCRtpReceiver : RTCRtpSender;
-  if (!('getCapabilities' in source)) return;
-
-  const capabilities = source.getCapabilities(kind);
-  if (!capabilities) return;
-
-  const preferred: RTCRtpCodecCapability[] = [];
-  const partiallyPreferred: RTCRtpCodecCapability[] = [];
-  const unpreferred: RTCRtpCodecCapability[] = [];
-
-  const preferredCodecMimeType = `${kind}/${preferredCodec.toLowerCase()}`;
-  const codecToRemoveMimeType =
-    codecToRemove && `${kind}/${codecToRemove.toLowerCase()}`;
-
-  for (const codec of capabilities.codecs) {
-    const codecMimeType = codec.mimeType.toLowerCase();
-
-    const shouldRemoveCodec = codecMimeType === codecToRemoveMimeType;
-    if (shouldRemoveCodec) continue; // skip this codec
-
-    const isPreferredCodec = codecMimeType === preferredCodecMimeType;
-    if (!isPreferredCodec) {
-      unpreferred.push(codec);
-      continue;
-    }
-
-    // h264 is a special case, we want to prioritize the baseline codec with
-    // profile-level-id is 42e01f and packetization-mode=0 for maximum
-    // cross-browser compatibility.
-    // this branch covers the other cases, such as vp8.
-    if (codecMimeType !== 'video/h264') {
-      preferred.push(codec);
-      continue;
-    }
-
-    const sdpFmtpLine = codec.sdpFmtpLine;
-    if (!sdpFmtpLine || !sdpFmtpLine.includes('profile-level-id=42')) {
-      // this is not the baseline h264 codec, prioritize it lower
-      partiallyPreferred.push(codec);
-      continue;
-    }
-
-    if (sdpFmtpLine.includes('packetization-mode=1')) {
-      preferred.unshift(codec);
-    } else {
-      preferred.push(codec);
-    }
-  }
-
-  // return a sorted list of codecs, with the preferred codecs first
-  return [...preferred, ...partiallyPreferred, ...unpreferred];
-};
-
 /**
  * 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.
  */
@@ -93,63 +20,6 @@ export const getGenericSdp = async (direction: RTCRtpTransceiverDirection) => {
   return sdp;
 };
 
-/**
- * Returns the optimal video codec for the device.
- */
-export const getOptimalVideoCodec = (
-  preferredCodec: PreferredCodec | undefined,
-): PreferredCodec => {
-  if (isReactNative()) {
-    const os = getOSInfo()?.name.toLowerCase();
-    if (os === 'android') return preferredOr(preferredCodec, 'vp8');
-    if (os === 'ios' || os === 'ipados') {
-      return supportsH264Baseline() ? 'h264' : 'vp8';
-    }
-    return preferredOr(preferredCodec, 'h264');
-  }
-  if (isSafari()) return 'h264';
-  if (isFirefox()) return 'vp8';
-  return preferredOr(preferredCodec, 'vp8');
-};
-
-/**
- * Determines if the platform supports the preferred codec.
- * If not, it returns the fallback codec.
- */
-const preferredOr = (
-  codec: PreferredCodec | undefined,
-  fallback: PreferredCodec,
-): PreferredCodec => {
-  if (!codec) return fallback;
-  if (!('getCapabilities' in RTCRtpSender)) return fallback;
-  const capabilities = RTCRtpSender.getCapabilities('video');
-  if (!capabilities) return fallback;
-
-  // Safari and Firefox do not have a good support encoding to SVC codecs,
-  // so we disable it for them.
-  if (isSvcCodec(codec) && (isSafari() || isFirefox())) return fallback;
-
-  const { codecs } = capabilities;
-  const codecMimeType = `video/${codec}`.toLowerCase();
-  return codecs.some((c) => c.mimeType.toLowerCase() === codecMimeType)
-    ? codec
-    : fallback;
-};
-
-/**
- * Returns whether the platform supports the H264 baseline codec.
- */
-const supportsH264Baseline = (): boolean => {
-  if (!('getCapabilities' in RTCRtpSender)) return false;
-  const capabilities = RTCRtpSender.getCapabilities('video');
-  if (!capabilities) return false;
-  return capabilities.codecs.some(
-    (c) =>
-      c.mimeType.toLowerCase() === 'video/h264' &&
-      c.sdpFmtpLine?.includes('profile-level-id=42e01f'),
-  );
-};
-
 /**
  * Returns whether the codec is an SVC codec.
  *