livekit-client 0.16.5 → 0.17.1

package/src/room/participant/RemoteParticipant.ts

@@ -10,9 +10,8 @@ import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
-import { TrackPublication } from '../track/TrackPublication';
-import { RemoteTrack } from '../track/types';
-import Participant from './Participant';
+import { AdaptiveStreamSettings, RemoteTrack } from '../track/types';
+import Participant, { ParticipantEventCallbacks } from './Participant';
 
 export default class RemoteParticipant extends Participant {
   audioTracks: Map<string, RemoteTrackPublication>;
@@ -42,7 +41,7 @@ export default class RemoteParticipant extends Participant {
     this.videoTracks = new Map();
   }
 
-  protected addTrackPublication(publication: TrackPublication) {
+  protected addTrackPublication(publication: RemoteTrackPublication) {
     super.addTrackPublication(publication);
 
     // register action events
@@ -83,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
@@ -115,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;
     }
@@ -123,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);
     }
@@ -234,7 +233,10 @@ export default class RemoteParticipant extends Participant {
   }
 
   /** @internal */
-  emit(event: string | symbol, ...args: any[]): boolean {
+  emit<E extends keyof ParticipantEventCallbacks>(
+    event: E,
+    ...args: Parameters<ParticipantEventCallbacks[E]>
+  ): boolean {
     log.trace('participant event', this.sid, event, ...args);
     return super.emit(event, ...args);
   }

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;
+  });
+}

package/src/room/track/LocalAudioTrack.ts

@@ -1,9 +1,10 @@
 import log from '../../logger';
+import { TrackEvent } from '../events';
 import { AudioSenderStats, computeBitrate, monitorFrequency } from '../stats';
 import LocalTrack from './LocalTrack';
 import { AudioCaptureOptions } from './options';
 import { Track } from './Track';
-import { constraintsForOptions } from './utils';
+import { constraintsForOptions, detectSilence } from './utils';
 
 export default class LocalAudioTrack extends LocalTrack {
   sender?: RTCRtpSender;
@@ -18,6 +19,7 @@ export default class LocalAudioTrack extends LocalTrack {
     constraints?: MediaTrackConstraints,
   ) {
     super(mediaTrack, Track.Kind.Audio, constraints);
+    this.checkForSilence();
   }
 
   async setDeviceId(deviceId: string) {
@@ -61,6 +63,12 @@ export default class LocalAudioTrack extends LocalTrack {
     await this.restart(constraints);
   }
 
+  protected async restart(constraints?: MediaTrackConstraints): Promise<LocalTrack> {
+    const track = await super.restart(constraints);
+    this.checkForSilence();
+    return track;
+  }
+
   /* @internal */
   startMonitor() {
     setTimeout(() => {
@@ -116,4 +124,14 @@ export default class LocalAudioTrack extends LocalTrack {
 
     return audioStats;
   }
+
+  async checkForSilence() {
+    const trackIsSilent = await detectSilence(this);
+    if (trackIsSilent) {
+      if (!this.isMuted) {
+        log.warn('silence detected on local audio track');
+      }
+      this.emit(TrackEvent.AudioSilenceDetected);
+    }
+  }
 }

package/src/room/track/LocalTrack.ts

@@ -2,6 +2,7 @@ import log from '../../logger';
 import DeviceManager from '../DeviceManager';
 import { TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
+import { isMobile } from '../utils';
 import { attachToElement, detachTrack, Track } from './Track';
 
 export default class LocalTrack extends Track {
@@ -10,12 +11,18 @@ export default class LocalTrack extends Track {
 
   protected constraints: MediaTrackConstraints;
 
+  protected wasMuted: boolean;
+
+  protected reacquireTrack: boolean;
+
   protected constructor(
     mediaTrack: MediaStreamTrack, kind: Track.Kind, constraints?: MediaTrackConstraints,
   ) {
     super(mediaTrack, kind);
     this.mediaStreamTrack.addEventListener('ended', this.handleEnded);
     this.constraints = constraints ?? mediaTrack.getConstraints();
+    this.reacquireTrack = false;
+    this.wasMuted = false;
   }
 
   get id(): string {
@@ -118,7 +125,36 @@ export default class LocalTrack extends Track {
     this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
   }
 
+  protected get needsReAcquisition(): boolean {
+    return this.mediaStreamTrack.readyState !== 'live'
+      || this.mediaStreamTrack.muted
+      || !this.mediaStreamTrack.enabled
+      || this.reacquireTrack;
+  }
+
+  protected async handleAppVisibilityChanged() {
+    await super.handleAppVisibilityChanged();
+    if (!isMobile()) return;
+    log.debug('visibility changed, is in Background: ', this.isInBackground);
+
+    if (!this.isInBackground && this.needsReAcquisition) {
+      log.debug('track needs to be reaquired, restarting', this.source);
+      await this.restart();
+      this.reacquireTrack = false;
+      // Restore muted state if had to be restarted
+      this.setTrackMuted(this.wasMuted);
+    }
+
+    // store muted state each time app goes to background
+    if (this.isInBackground) {
+      this.wasMuted = this.isMuted;
+    }
+  }
+
   private handleEnded = () => {
+    if (this.isInBackground) {
+      this.reacquireTrack = true;
+    }
     this.emit(TrackEvent.Ended, this);
   };
 }

package/src/room/track/LocalVideoTrack.ts

@@ -3,7 +3,7 @@ import log from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models';
 import { SubscribedQuality } from '../../proto/livekit_rtc';
 import { computeBitrate, monitorFrequency, VideoSenderStats } from '../stats';
-import { isFireFox } from '../utils';
+import { isFireFox, isMobile } from '../utils';
 import LocalTrack from './LocalTrack';
 import { VideoCaptureOptions } from './options';
 import { Track } from './Track';
@@ -238,6 +238,14 @@ export default class LocalVideoTrack extends LocalTrack {
       this.monitorSender();
     }, monitorFrequency);
   };
+
+  protected async handleAppVisibilityChanged() {
+    await super.handleAppVisibilityChanged();
+    if (!isMobile()) return;
+    if (this.isInBackground && this.source === Track.Source.Camera) {
+      this.mediaStreamTrack.enabled = false;
+    }
+  }
 }
 
 export function videoQualityForRid(rid: string): VideoQuality {

package/src/room/track/RemoteTrack.ts

@@ -6,6 +6,8 @@ export default abstract class RemoteTrack extends Track {
   /** @internal */
   receiver?: RTCRtpReceiver;
 
+  streamState: Track.StreamState = Track.StreamState.Active;
+
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,

package/src/room/track/RemoteVideoTrack.ts

@@ -1,9 +1,12 @@
 import { debounce } from 'ts-debounce';
 import { TrackEvent } from '../events';
 import { computeBitrate, monitorFrequency, VideoReceiverStats } from '../stats';
-import { getIntersectionObserver, getResizeObserver, ObservableMediaElement } from '../utils';
+import {
+  getIntersectionObserver, getResizeObserver, isMobile, ObservableMediaElement,
+} from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { attachToElement, detachTrack, Track } from './Track';
+import { AdaptiveStreamSettings } from './types';
 
 const REACTION_DELAY = 100;
 
@@ -15,7 +18,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
 
   private elementInfos: ElementInfo[] = [];
 
-  private adaptiveStream?: boolean;
+  private adaptiveStreamSettings?: AdaptiveStreamSettings;
 
   private lastVisible?: boolean;
 
@@ -25,14 +28,14 @@ export default class RemoteVideoTrack extends RemoteTrack {
     mediaTrack: MediaStreamTrack,
     sid: string,
     receiver?: RTCRtpReceiver,
-    adaptiveStream?: boolean,
+    adaptiveStreamSettings?: AdaptiveStreamSettings,
   ) {
     super(mediaTrack, sid, Track.Kind.Video, receiver);
-    this.adaptiveStream = adaptiveStream;
+    this.adaptiveStreamSettings = adaptiveStreamSettings;
   }
 
   get isAdaptiveStream(): boolean {
-    return this.adaptiveStream ?? false;
+    return this.adaptiveStreamSettings !== undefined;
   }
 
   /** @internal */
@@ -60,7 +63,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
 
     // It's possible attach is called multiple times on an element. When that's
     // the case, we'd want to avoid adding duplicate elementInfos
-    if (this.adaptiveStream
+    if (this.adaptiveStreamSettings
       && this.elementInfos.find((info) => info.element === element) === undefined
     ) {
       this.elementInfos.push({
@@ -164,6 +167,14 @@ export default class RemoteVideoTrack extends RemoteTrack {
     this.updateVisibility();
   };
 
+  protected async handleAppVisibilityChanged() {
+    await super.handleAppVisibilityChanged();
+    if (!this.isAdaptiveStream) return;
+    // on desktop don't pause when tab is backgrounded
+    if (!isMobile()) return;
+    this.updateVisibility();
+  }
+
   private readonly debouncedHandleResize = debounce(() => {
     this.updateDimensions();
   }, REACTION_DELAY);
@@ -173,7 +184,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
       (prev, info) => Math.max(prev, info.visibilityChangedAt || 0),
       0,
     );
-    const isVisible = this.elementInfos.some((info) => info.visible);
+    const isVisible = this.elementInfos.some((info) => info.visible) && !this.isInBackground;
 
     if (this.lastVisible === isVisible) {
       return;
@@ -195,8 +206,10 @@ export default class RemoteVideoTrack extends RemoteTrack {
     let maxWidth = 0;
     let maxHeight = 0;
     for (const info of this.elementInfos) {
-      const currentElementWidth = info.element.clientWidth * (window.devicePixelRatio ?? 1);
-      const currentElementHeight = info.element.clientHeight * (window.devicePixelRatio ?? 1);
+      const pixelDensity = this.adaptiveStreamSettings?.pixelDensity ?? 1;
+      const pixelDensityValue = pixelDensity === 'screen' ? window.devicePixelRatio : pixelDensity;
+      const currentElementWidth = info.element.clientWidth * pixelDensityValue;
+      const currentElementHeight = info.element.clientHeight * pixelDensityValue;
       if (currentElementWidth + currentElementHeight > maxWidth + maxHeight) {
         maxWidth = currentElementWidth;
         maxHeight = currentElementHeight;

package/src/room/track/Track.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
 import { TrackSource, TrackType } from '../../proto/livekit_models';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc';
 import { TrackEvent } from '../events';
@@ -8,7 +9,7 @@ import { isFireFox, isSafari } from '../utils';
 // Safari tracks which audio elements have been "blessed" by the user.
 const recycledElements: Array<HTMLAudioElement> = [];
 
-export class Track extends EventEmitter {
+export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
   kind: Track.Kind;
 
   mediaStreamTrack: MediaStreamTrack;
@@ -17,10 +18,10 @@ export class Track extends EventEmitter {
 
   isMuted: boolean = false;
 
-  streamState: Track.StreamState = Track.StreamState.Active;
-
   source: Track.Source;
 
+  protected isInBackground: boolean;
+
   /**
    * sid is set after track is published to server, or if it's a remote track
    */
@@ -33,6 +34,8 @@ export class Track extends EventEmitter {
     this.kind = kind;
     this.mediaStreamTrack = mediaTrack;
     this.source = Track.Source.Unknown;
+    this.isInBackground = document.visibilityState === 'hidden';
+    document.addEventListener('visibilitychange', this.appVisibilityChangedListener);
   }
 
   /** current receive bits per second */
@@ -130,6 +133,7 @@ export class Track extends EventEmitter {
 
   stop() {
     this.mediaStreamTrack.stop();
+    document.removeEventListener('visibilitychange', this.appVisibilityChangedListener);
   }
 
   protected enable() {
@@ -155,6 +159,14 @@ export class Track extends EventEmitter {
       }
     }
   }
+
+  appVisibilityChangedListener = () => {
+    this.handleAppVisibilityChanged();
+  };
+
+  protected async handleAppVisibilityChanged() {
+    this.isInBackground = document.visibilityState === 'hidden';
+  }
 }
 
 /** @internal */
@@ -307,3 +319,17 @@ export namespace Track {
     }
   }
 }
+
+export type TrackEventCallbacks = {
+  message: () => void,
+  muted: (track?: any) => void,
+  unmuted: (track?: any) => void,
+  ended: (track?: any) => void,
+  updateSettings: () => void,
+  updateSubscription: () => void,
+  audioPlaybackStarted: () => void,
+  audioPlaybackFailed: (error: Error) => void,
+  audioSilenceDetected: () => void,
+  visibilityChanged: (visible: boolean, track?: any) => void,
+  videoDimensionsChanged: (dimensions: Track.Dimensions, track?: any) => void,
+};

package/src/room/track/defaults.ts

@@ -7,7 +7,7 @@ export const publishDefaults: TrackPublishDefaults = {
   audioBitrate: AudioPresets.speech.maxBitrate,
   dtx: true,
   simulcast: true,
-  screenShareEncoding: ScreenSharePresets.hd_15.encoding,
+  screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
 };
 
@@ -19,5 +19,5 @@ export const audioDefaults: AudioCaptureOptions = {
 };
 
 export const videoDefaults: VideoCaptureOptions = {
-  resolution: VideoPresets.qhd.resolution,
+  resolution: VideoPresets.h540.resolution,
 };