livekit-client 0.16.6 → 0.17.2

package/src/room/RTCEngine.ts

@@ -3,6 +3,8 @@ import type TypedEventEmitter from 'typed-emitter';
 import { SignalClient, SignalOptions } from '../api/SignalClient';
 import log from '../logger';
 import {
+  ClientConfigSetting,
+  ClientConfiguration,
   DataPacket, DataPacket_Kind, SpeakerInfo, TrackInfo, UserPacket,
 } from '../proto/livekit_models';
 import {
@@ -14,7 +16,7 @@ import {
 import { ConnectionError, TrackInvalidError, UnexpectedConnectionState } from './errors';
 import { EngineEvent } from './events';
 import PCTransport from './PCTransport';
-import { isFireFox, sleep } from './utils';
+import { isFireFox, isWeb, sleep } from './utils';
 
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
@@ -70,7 +72,9 @@ export default class RTCEngine extends (
 
   private reconnectStart: number = 0;
 
-  private fullReconnect: boolean = false;
+  private fullReconnectOnNext: boolean = false;
+
+  private clientConfiguration?: ClientConfiguration;
 
   private connectedServerAddr?: string;
 
@@ -96,6 +100,7 @@ export default class RTCEngine extends (
     if (!this.subscriberPrimary) {
       this.negotiate();
     }
+    this.clientConfiguration = joinResponse.clientConfiguration;
 
     return joinResponse;
   }
@@ -107,7 +112,10 @@ export default class RTCEngine extends (
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
       this.publisher.pc.getSenders().forEach((sender) => {
         try {
-          this.publisher?.pc.removeTrack(sender);
+          // TODO: react-native-webrtc doesn't have removeTrack yet.
+          if (this.publisher?.pc.removeTrack) {
+            this.publisher?.pc.removeTrack(sender);
+          }
         } catch (e) {
           log.warn('could not removeTrack', e);
         }
@@ -166,6 +174,11 @@ export default class RTCEngine extends (
       this.rtcConfig.iceServers = rtcIceServers;
     }
 
+    // @ts-ignore
+    this.rtcConfig.sdpSemantics = 'unified-plan';
+    // @ts-ignore
+    this.rtcConfig.continualGatheringPolicy = 'gather_continually';
+
     this.publisher = new PCTransport(this.rtcConfig);
     this.subscriber = new PCTransport(this.rtcConfig);
 
@@ -216,10 +229,18 @@ export default class RTCEngine extends (
       }
     };
 
-    this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
-      this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
-    };
-
+    if (isWeb()) {
+      this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
+        this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
+      };
+    } else {
+      // TODO: react-native-webrtc doesn't have ontrack yet, replace when ready.
+      // @ts-ignore
+      this.subscriber.pc.onaddstream = (ev: { stream: MediaStream }) => {
+        const track = ev.stream.getTracks()[0];
+        this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
+      };
+    }
     // data channels
     this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
       // will drop older packets that arrive
@@ -303,7 +324,7 @@ export default class RTCEngine extends (
 
     this.client.onLeave = (leave?: LeaveRequest) => {
       if (leave?.canReconnect) {
-        this.fullReconnect = true;
+        this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
         this.emit(EngineEvent.Disconnected);
@@ -376,19 +397,19 @@ export default class RTCEngine extends (
       if (this.isClosed) {
         return;
       }
-      if (isFireFox()) {
-        // FF does not support DTLS restart.
-        this.fullReconnect = true;
+      if (isFireFox() // TODO remove once clientConfiguration handles firefox case server side
+        || this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED) {
+        this.fullReconnectOnNext = true;
       }
 
       try {
-        if (this.fullReconnect) {
+        if (this.fullReconnectOnNext) {
           await this.restartConnection();
         } else {
           await this.resumeConnection();
         }
         this.reconnectAttempts = 0;
-        this.fullReconnect = false;
+        this.fullReconnectOnNext = false;
       } catch (e) {
         this.reconnectAttempts += 1;
         let recoverable = true;
@@ -398,7 +419,7 @@ export default class RTCEngine extends (
           recoverable = false;
         } else if (!(e instanceof SignalReconnectError)) {
           // cannot resume
-          this.fullReconnect = true;
+          this.fullReconnectOnNext = true;
         }
 
         const duration = Date.now() - this.reconnectStart;
@@ -444,6 +465,7 @@ export default class RTCEngine extends (
     }
 
     await this.waitForPCConnected();
+    this.client.setReconnected();
 
     // reconnect success
     this.emit(EngineEvent.Restarted, joinResponse);
@@ -478,6 +500,7 @@ export default class RTCEngine extends (
     }
 
     await this.waitForPCConnected();
+    this.client.setReconnected();
 
     // resume success
     this.emit(EngineEvent.Resumed);
@@ -564,7 +587,7 @@ export default class RTCEngine extends (
     this.publisher.negotiate();
   }
 
-  private dataChannelForKind(kind: DataPacket_Kind): RTCDataChannel | undefined {
+  dataChannelForKind(kind: DataPacket_Kind): RTCDataChannel | undefined {
     if (kind === DataPacket_Kind.LOSSY) {
       return this.lossyDC;
     } if (kind === DataPacket_Kind.RELIABLE) {
@@ -621,7 +644,7 @@ export type EngineEventCallbacks = {
   mediaTrackAdded: (
     track: MediaStreamTrack,
     streams: MediaStream,
-    receiver: RTCRtpReceiver
+    receiver?: RTCRtpReceiver
   ) => void,
   activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void,
   dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void,

package/src/room/Room.ts

@@ -28,8 +28,9 @@ import LocalTrackPublication from './track/LocalTrackPublication';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import { TrackPublication } from './track/TrackPublication';
-import { RemoteTrack } from './track/types';
-import { unpackStreamId } from './utils';
+import { AdaptiveStreamSettings, RemoteTrack } from './track/types';
+import { getNewAudioContext } from './track/utils';
+import { isWeb, unpackStreamId } from './utils';
 
 export enum RoomState {
   Disconnected = 'disconnected',
@@ -195,7 +196,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     try {
       const joinResponse = await this.engine.join(url, token, opts);
-      log.debug('connected to Livekit Server', joinResponse.serverVersion);
+      log.debug(`connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`);
 
       if (!joinResponse.serverVersion) {
         throw new UnsupportedServer('unknown server version');
@@ -270,8 +271,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         clearTimeout(connectTimeout);
 
         // also hook unload event
-        window.addEventListener('beforeunload', this.onBeforeUnload);
-        navigator.mediaDevices.addEventListener('devicechange', this.handleDeviceChange);
+        if (isWeb()) {
+          window.addEventListener('beforeunload', this.onBeforeUnload);
+          navigator.mediaDevices.addEventListener('devicechange', this.handleDeviceChange);
+        }
 
         resolve(this);
       });
@@ -437,12 +440,20 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     if (!trackId || trackId === '') trackId = mediaTrack.id;
 
     const participant = this.getOrCreateParticipant(participantId);
+    let adaptiveStreamSettings: AdaptiveStreamSettings | undefined;
+    if (this.options.adaptiveStream) {
+      if (typeof this.options.adaptiveStream === 'object') {
+        adaptiveStreamSettings = this.options.adaptiveStream;
+      } else {
+        adaptiveStreamSettings = {};
+      }
+    }
     participant.addSubscribedMediaTrack(
       mediaTrack,
       trackId,
       stream,
       receiver,
-      this.options.adaptiveStream,
+      adaptiveStreamSettings,
     );
   }
 
@@ -458,6 +469,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleRestarted = async (joinResponse: JoinResponse) => {
+    log.debug('reconnected to server region', joinResponse.serverRegion);
     this.state = RoomState.Connected;
     this.emit(RoomEvent.Reconnected);
     this.emit(RoomEvent.StateChanged, this.state);
@@ -511,8 +523,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.audioContext.close();
       this.audioContext = undefined;
     }
-    window.removeEventListener('beforeunload', this.onBeforeUnload);
-    navigator.mediaDevices.removeEventListener('devicechange', this.handleDeviceChange);
+    if (isWeb()) {
+      window.removeEventListener('beforeunload', this.onBeforeUnload);
+      navigator.mediaDevices.removeEventListener('devicechange', this.handleDeviceChange);
+    }
     this.state = RoomState.Disconnected;
     this.emit(RoomEvent.Disconnected);
     this.emit(RoomEvent.StateChanged, this.state);
@@ -522,7 +536,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // handle changes to participant state, and send events
     participantInfos.forEach((info) => {
       if (info.sid === this.localParticipant.sid
-          || info.identity === this.localParticipant.identity) {
+        || info.identity === this.localParticipant.identity) {
         this.localParticipant.updateInfo(info);
         return;
       }
@@ -717,10 +731,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     // by using an AudioContext, it reduces lag on audio elements
     // https://stackoverflow.com/questions/9811429/html5-audio-tag-on-safari-has-a-delay/54119854#54119854
-    // @ts-ignore
-    const AudioContext = window.AudioContext || window.webkitAudioContext;
-    if (AudioContext) {
-      this.audioContext = new AudioContext();
+    const ctx = getNewAudioContext();
+    if (ctx) {
+      this.audioContext = ctx;
     }
   }
 
@@ -826,6 +839,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         participantTracks: [],
       },
       publishTracks: this.localParticipant.publishedTracksInfo(),
+      dataChannels: this.localParticipant.dataChannelsInfo(),
     });
   }
 

package/src/room/events.ts

@@ -185,7 +185,7 @@ export enum RoomEvent {
   ConnectionQualityChanged = 'connectionQualityChanged',
 
   /**
-   * StreamState indicates if a subscribed track has been paused by the SFU
+   * StreamState indicates if a subscribed (remote) track has been paused by the SFU
    * (typically this happens because of subscriber's bandwidth constraints)
    *
    * When bandwidth conditions allow, the track will be resumed automatically.
@@ -400,6 +400,11 @@ export enum TrackEvent {
   AudioPlaybackStarted = 'audioPlaybackStarted',
   /** @internal */
   AudioPlaybackFailed = 'audioPlaybackFailed',
+  /**
+   * @internal
+   * Only fires on LocalAudioTrack instances
+  */
+  AudioSilenceDetected = 'audioSilenceDetected',
   /** @internal */
   VisibilityChanged = 'visibilityChanged',
   /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -3,7 +3,9 @@ import { RoomOptions } from '../../options';
 import {
   DataPacket, DataPacket_Kind,
 } from '../../proto/livekit_models';
-import { AddTrackRequest, SubscribedQualityUpdate, TrackPublishedResponse } from '../../proto/livekit_rtc';
+import {
+  AddTrackRequest, DataChannelInfo, SubscribedQualityUpdate, TrackPublishedResponse,
+} from '../../proto/livekit_rtc';
 import {
   TrackInvalidError,
   UnexpectedConnectionState,
@@ -17,10 +19,12 @@ import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTr
 import {
   CreateLocalTracksOptions,
   ScreenShareCaptureOptions,
-  TrackPublishOptions, VideoCodec, VideoPresets,
+  ScreenSharePresets,
+  TrackPublishOptions, VideoCodec,
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
+import { isFireFox } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import { computeVideoEncodings, mediaTrackToLocalTrack } from './publishUtils';
@@ -256,6 +260,7 @@ export default class LocalParticipant extends Participant {
       } else if (track.kind === Track.Kind.Audio) {
         track.source = Track.Source.Microphone;
       }
+      track.mediaStream = stream;
       return track;
     });
   }
@@ -272,7 +277,7 @@ export default class LocalParticipant extends Participant {
       options = {};
     }
     if (options.resolution === undefined) {
-      options.resolution = VideoPresets.fhd.resolution;
+      options.resolution = ScreenSharePresets.h1080fps15.resolution;
     }
 
     let videoConstraints: MediaTrackConstraints | boolean = true;
@@ -355,6 +360,12 @@ export default class LocalParticipant extends Participant {
       track.stopOnMute = true;
     }
 
+    if (track.source === Track.Source.ScreenShare && isFireFox()) {
+      // Firefox does not work well with simulcasted screen share
+      // we frequently get no data on layer 0 when enabled
+      opts.simulcast = false;
+    }
+
     // handle track actions
     track.on(TrackEvent.Muted, this.onTrackMuted);
     track.on(TrackEvent.Unmuted, this.onTrackUnmuted);
@@ -525,7 +536,7 @@ export default class LocalParticipant extends Participant {
     destination?: RemoteParticipant[] | string[]) {
     const dest: string[] = [];
     if (destination !== undefined) {
-      destination.forEach((val : any) => {
+      destination.forEach((val: any) => {
         if (val instanceof RemoteParticipant) {
           dest.push(val.sid);
         } else {
@@ -681,4 +692,20 @@ export default class LocalParticipant extends Participant {
     });
     return infos;
   }
+
+  /** @internal */
+  dataChannelsInfo(): DataChannelInfo[] {
+    const infos: DataChannelInfo[] = [];
+    const getInfo = (dc: RTCDataChannel | undefined) => {
+      if (dc?.id !== undefined && dc.id !== null) {
+        infos.push({
+          label: dc.label,
+          id: dc.id,
+        });
+      }
+    };
+    getInfo(this.engine.dataChannelForKind(DataPacket_Kind.LOSSY));
+    getInfo(this.engine.dataChannelForKind(DataPacket_Kind.RELIABLE));
+    return infos;
+  }
 }

package/src/room/participant/RemoteParticipant.ts

@@ -10,7 +10,7 @@ import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
-import { RemoteTrack } from '../track/types';
+import { AdaptiveStreamSettings, RemoteTrack } from '../track/types';
 import Participant, { ParticipantEventCallbacks } from './Participant';
 
 export default class RemoteParticipant extends Participant {
@@ -82,7 +82,7 @@ export default class RemoteParticipant extends Participant {
     sid: Track.SID,
     mediaStream: MediaStream,
     receiver?: RTCRtpReceiver,
-    adaptiveStream?: boolean,
+    adaptiveStreamSettings?: AdaptiveStreamSettings,
     triesLeft?: number,
   ) {
     // find the track publication
@@ -114,7 +114,7 @@ export default class RemoteParticipant extends Participant {
       if (triesLeft === undefined) triesLeft = 20;
       setTimeout(() => {
         this.addSubscribedMediaTrack(mediaTrack, sid, mediaStream,
-          receiver, adaptiveStream, triesLeft! - 1);
+          receiver, adaptiveStreamSettings, triesLeft! - 1);
       }, 150);
       return;
     }
@@ -122,7 +122,7 @@ export default class RemoteParticipant extends Participant {
     const isVideo = mediaTrack.kind === 'video';
     let track: RemoteTrack;
     if (isVideo) {
-      track = new RemoteVideoTrack(mediaTrack, sid, receiver, adaptiveStream);
+      track = new RemoteVideoTrack(mediaTrack, sid, receiver, adaptiveStreamSettings);
     } else {
       track = new RemoteAudioTrack(mediaTrack, sid, receiver);
     }

package/src/room/participant/publishUtils.test.ts

@@ -1,11 +1,15 @@
-import { VideoPresets, VideoPresets43 } from '../track/options';
 import {
+  ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43,
+} from '../track/options';
+import {
+  computeDefaultScreenShareSimulcastPresets,
   computeVideoEncodings,
   determineAppropriateEncoding,
   presets169,
   presets43,
   presetsForResolution,
   presetsScreenShare,
+  sortPresets,
 } from './publishUtils';
 
 describe('presetsForResolution', () => {
@@ -63,7 +67,7 @@ describe('computeVideoEncodings', () => {
 
     // ensure they are what we expect
     expect(encodings![0].rid).toBe('q');
-    expect(encodings![0].maxBitrate).toBe(VideoPresets.qvga.encoding.maxBitrate);
+    expect(encodings![0].maxBitrate).toBe(VideoPresets.h180.encoding.maxBitrate);
     expect(encodings![0].scaleResolutionDownBy).toBe(3);
     expect(encodings![1].rid).toBe('h');
     expect(encodings![1].scaleResolutionDownBy).toBe(1.5);
@@ -77,7 +81,7 @@ describe('computeVideoEncodings', () => {
     expect(encodings).toHaveLength(3);
     expect(encodings![0].scaleResolutionDownBy).toBe(3);
     expect(encodings![1].scaleResolutionDownBy).toBe(1.5);
-    expect(encodings![2].maxBitrate).toBe(VideoPresets.qhd.encoding.maxBitrate);
+    expect(encodings![2].maxBitrate).toBe(VideoPresets.h540.encoding.maxBitrate);
   });
 
   it('returns two encodings for lower-res simulcast', () => {
@@ -88,9 +92,9 @@ describe('computeVideoEncodings', () => {
 
     // ensure they are what we expect
     expect(encodings![0].rid).toBe('q');
-    expect(encodings![0].maxBitrate).toBe(VideoPresets.qvga.encoding.maxBitrate);
+    expect(encodings![0].maxBitrate).toBe(VideoPresets.h180.encoding.maxBitrate);
     expect(encodings![1].rid).toBe('h');
-    expect(encodings![1].maxBitrate).toBe(VideoPresets.vga.encoding.maxBitrate);
+    expect(encodings![1].maxBitrate).toBe(VideoPresets.h360.encoding.maxBitrate);
   });
 
   it('respects provided min resolution', () => {
@@ -99,7 +103,43 @@ describe('computeVideoEncodings', () => {
     });
     expect(encodings).toHaveLength(1);
     expect(encodings![0].rid).toBe('q');
-    expect(encodings![0].maxBitrate).toBe(VideoPresets43.qvga.encoding.maxBitrate);
+    expect(encodings![0].maxBitrate).toBe(VideoPresets43.h120.encoding.maxBitrate);
     expect(encodings![0].scaleResolutionDownBy).toBe(1);
   });
 });
+
+describe('customSimulcastLayers', () => {
+  it('sorts presets from lowest to highest', () => {
+    const sortedPresets = sortPresets(
+      [VideoPresets.h1440, VideoPresets.h360, VideoPresets.h1080, VideoPresets.h90],
+    ) as Array<VideoPreset>;
+    expect(sortPresets).not.toBeUndefined();
+    expect(sortedPresets[0]).toBe(VideoPresets.h90);
+    expect(sortedPresets[1]).toBe(VideoPresets.h360);
+    expect(sortedPresets[2]).toBe(VideoPresets.h1080);
+    expect(sortedPresets[3]).toBe(VideoPresets.h1440);
+  });
+  it('sorts presets from lowest to highest, even when dimensions are the same', () => {
+    const sortedPresets = sortPresets([
+      new VideoPreset(1920, 1080, 3_000_000, 20),
+      new VideoPreset(1920, 1080, 2_000_000, 15),
+      new VideoPreset(1920, 1080, 3_000_000, 15),
+    ]) as Array<VideoPreset>;
+    expect(sortPresets).not.toBeUndefined();
+    expect(sortedPresets[0].encoding.maxBitrate).toBe(2_000_000);
+    expect(sortedPresets[1].encoding.maxFramerate).toBe(15);
+    expect(sortedPresets[2].encoding.maxFramerate).toBe(20);
+  });
+});
+
+describe('screenShareSimulcastDefaults', () => {
+  it('computes appropriate bitrate from original preset', () => {
+    const defaultSimulcastLayers = computeDefaultScreenShareSimulcastPresets(
+      ScreenSharePresets.h720fps15,
+    );
+    expect(defaultSimulcastLayers[0].width).toBe(640);
+    expect(defaultSimulcastLayers[0].height).toBe(360);
+    expect(defaultSimulcastLayers[0].encoding.maxFramerate).toBe(3);
+    expect(defaultSimulcastLayers[0].encoding.maxBitrate).toBe(150_000);
+  });
+});

package/src/room/participant/publishUtils.ts

@@ -26,32 +26,38 @@ export function mediaTrackToLocalTrack(
 }
 
 /* @internal */
-export const presets169 = [
-  VideoPresets.qvga,
-  VideoPresets.vga,
-  VideoPresets.qhd,
-  VideoPresets.hd,
-  VideoPresets.fhd,
-];
+export const presets169 = Object.values(VideoPresets);
+
+/* @internal */
+export const presets43 = Object.values(VideoPresets43);
+
+/* @internal */
+export const presetsScreenShare = Object.values(ScreenSharePresets);
 
 /* @internal */
-export const presets43 = [
-  VideoPresets43.qvga,
-  VideoPresets43.vga,
-  VideoPresets43.qhd,
-  VideoPresets43.hd,
-  VideoPresets43.fhd,
+export const defaultSimulcastPresets169 = [
+  VideoPresets.h180,
+  VideoPresets.h360,
 ];
 
 /* @internal */
-export const presetsScreenShare = [
-  ScreenSharePresets.vga,
-  ScreenSharePresets.hd_8,
-  ScreenSharePresets.hd_15,
-  ScreenSharePresets.fhd_15,
-  ScreenSharePresets.fhd_30,
+export const defaultSimulcastPresets43 = [
+  VideoPresets43.h180,
+  VideoPresets43.h360,
 ];
 
+/* @internal */
+export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPreset) => {
+  const layers = [{ scaleResolutionDownBy: 2, fps: 3 }];
+  return layers.map((t) => new VideoPreset(
+    Math.floor(fromPreset.width / t.scaleResolutionDownBy),
+    Math.floor(fromPreset.height / t.scaleResolutionDownBy),
+    Math.max(150_000, Math.floor(fromPreset.encoding.maxBitrate
+      / (t.scaleResolutionDownBy ** 2 * ((fromPreset.encoding.maxFramerate ?? 30) / t.fps)))),
+    t.fps,
+  ));
+};
+
 const videoRids = ['q', 'h', 'f'];
 
 /* @internal */
@@ -65,7 +71,7 @@ export function computeVideoEncodings(
   if (isScreenShare) {
     videoEncoding = options?.screenShareEncoding;
   }
-  const useSimulcast = !isScreenShare && options?.simulcast;
+  const useSimulcast = options?.simulcast;
 
   if ((!videoEncoding && !useSimulcast) || !width || !height) {
     // when we aren't simulcasting, will need to return a single encoding without
@@ -82,16 +88,22 @@ export function computeVideoEncodings(
   if (!useSimulcast) {
     return [videoEncoding];
   }
-
-  const presets = presetsForResolution(isScreenShare, width, height);
+  const original = new VideoPreset(
+    width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate,
+  );
+  let presets: Array<VideoPreset> = [];
+  if (isScreenShare) {
+    presets = sortPresets(options?.screenShareSimulcastLayers)
+      ?? defaultSimulcastLayers(isScreenShare, original);
+  } else {
+    presets = sortPresets(options?.videoSimulcastLayers)
+      ?? defaultSimulcastLayers(isScreenShare, original);
+  }
   let midPreset: VideoPreset | undefined;
   const lowPreset = presets[0];
   if (presets.length > 1) {
-    [,midPreset] = presets;
+    [, midPreset] = presets;
   }
-  const original = new VideoPreset(
-    width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate,
-  );
 
   // NOTE:
   //   1. Ordering of these encodings is important. Chrome seems
@@ -108,7 +120,7 @@ export function computeVideoEncodings(
       lowPreset, midPreset, original,
     ]);
   }
-  if (size >= 500) {
+  if (size >= 480) {
     return encodingsFromPresets(width, height, [
       lowPreset, original,
     ]);
@@ -155,6 +167,21 @@ export function presetsForResolution(
   return presets43;
 }
 
+/* @internal */
+export function defaultSimulcastLayers(
+  isScreenShare: boolean, original: VideoPreset,
+): VideoPreset[] {
+  if (isScreenShare) {
+    return computeDefaultScreenShareSimulcastPresets(original);
+  }
+  const { width, height } = original;
+  const aspect = width > height ? width / height : height / width;
+  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
+    return defaultSimulcastPresets169;
+  }
+  return defaultSimulcastPresets43;
+}
+
 // presets should be ordered by low, medium, high
 function encodingsFromPresets(
   width: number,
@@ -178,3 +205,21 @@ function encodingsFromPresets(
   });
   return encodings;
 }
+
+/** @internal */
+export function sortPresets(presets: Array<VideoPreset> | undefined) {
+  if (!presets) return;
+  return presets.sort((a, b) => {
+    const { encoding: aEnc } = a;
+    const { encoding: bEnc } = b;
+
+    if (aEnc.maxBitrate > bEnc.maxBitrate) {
+      return 1;
+    }
+    if (aEnc.maxBitrate < bEnc.maxBitrate) return -1;
+    if (aEnc.maxBitrate === bEnc.maxBitrate && aEnc.maxFramerate && bEnc.maxFramerate) {
+      return aEnc.maxFramerate > bEnc.maxFramerate ? 1 : -1;
+    }
+    return 0;
+  });
+}