livekit-client 2.13.7 → 2.14.0

package/dist/ts4.2/src/room/utils.d.ts

@@ -34,7 +34,7 @@ export declare function isFireFox(): boolean;
 export declare function isChromiumBased(): boolean;
 export declare function isSafari(): boolean;
 export declare function isSafariBased(): boolean;
-export declare function isSafari17(): boolean;
+export declare function isSafari17Based(): boolean;
 export declare function isSafariSvcApi(browser?: BrowserDetails): boolean;
 export declare function isMobile(): boolean;
 export declare function isE2EESimulcastSupported(): boolean | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.13.7",
+  "version": "2.14.0",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",

package/src/e2ee/E2eeManager.ts

@@ -25,6 +25,7 @@ import type {
   RTPVideoMapMessage,
   RatchetRequestMessage,
   RemoveTransformMessage,
+  ScriptTransformOptions,
   SetKeyMessage,
   SifTrailerMessage,
   UpdateCodecMessage,
@@ -220,8 +221,9 @@ export class E2EEManager
           this.room.localParticipant.identity,
         );
       });
-    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, async (publication) => {
-      this.setupE2EESender(publication.track!, publication.track!.sender!);
+
+    room.localParticipant.on(ParticipantEvent.LocalSenderCreated, async (sender, track) => {
+      this.setupE2EESender(track, sender);
     });
 
     keyProvider
@@ -345,7 +347,7 @@ export class E2EEManager
     }
 
     if (isScriptTransformSupported()) {
-      const options = {
+      const options: ScriptTransformOptions = {
         kind: 'decode',
         participantIdentity,
         trackId,
@@ -371,6 +373,7 @@ export class E2EEManager
       let writable: WritableStream = receiver.writableStream;
       // @ts-ignore
       let readable: ReadableStream = receiver.readableStream;
+
       if (!writable || !readable) {
         // @ts-ignore
         const receiverStreams = receiver.createEncodedStreams();
@@ -390,6 +393,7 @@ export class E2EEManager
           trackId: trackId,
           codec,
           participantIdentity: participantIdentity,
+          isReuse: E2EE_FLAG in receiver,
         },
       };
       this.worker.postMessage(msg, [readable, writable]);
@@ -435,6 +439,7 @@ export class E2EEManager
           codec,
           trackId,
           participantIdentity: this.room.localParticipant.identity,
+          isReuse: false,
         },
       };
       this.worker.postMessage(msg, [senderStreams.readable, senderStreams.writable]);

package/src/e2ee/types.ts

@@ -49,6 +49,7 @@ export interface EncodeMessage extends BaseMessage {
     writableStream: WritableStream;
     trackId: string;
     codec?: VideoCodec;
+    isReuse: boolean;
   };
 }
 
@@ -162,3 +163,10 @@ export type DecodeRatchetOptions = {
   /** ratcheted key to try */
   encryptionKey?: CryptoKey;
 };
+
+export type ScriptTransformOptions = {
+  kind: 'decode' | 'encode';
+  participantIdentity: string;
+  trackId: string;
+  codec?: VideoCodec;
+};

package/src/e2ee/worker/FrameCryptor.ts

@@ -69,6 +69,8 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private detectedCodec?: VideoCodec;
 
+  private isTransformActive: boolean = false;
+
   constructor(opts: {
     keys: ParticipantKeyHandler;
     participantIdentity: string;
@@ -159,6 +161,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     readable: ReadableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>,
     writable: WritableStream<RTCEncodedVideoFrame | RTCEncodedAudioFrame>,
     trackId: string,
+    isReuse: boolean,
     codec?: VideoCodec,
   ) {
     if (codec) {
@@ -173,11 +176,20 @@ export class FrameCryptor extends BaseFrameCryptor {
       ...this.logContext,
     });
 
+    if (isReuse && this.isTransformActive) {
+      workerLogger.debug('reuse transform', {
+        ...this.logContext,
+      });
+      return;
+    }
+
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this),
     });
 
+    this.isTransformActive = true;
+
     readable
       .pipeThrough(transformStream)
       .pipeTo(writable)
@@ -189,6 +201,9 @@ export class FrameCryptor extends BaseFrameCryptor {
             ? e
             : new CryptorError(e.message, undefined, this.participantIdentity),
         );
+      })
+      .finally(() => {
+        this.isTransformActive = false;
       });
     this.trackId = trackId;
   }

package/src/e2ee/worker/e2ee.worker.ts

@@ -12,6 +12,7 @@ import type {
   RatchetMessage,
   RatchetRequestMessage,
   RatchetResult,
+  ScriptTransformOptions,
 } from '../types';
 import { FrameCryptor, encryptionEnabledMap } from './FrameCryptor';
 import { ParticipantKeyHandler } from './ParticipantKeyHandler';
@@ -65,6 +66,7 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
+          data.isReuse,
           data.codec,
         );
         break;
@@ -75,6 +77,7 @@ onmessage = (ev) => {
           data.readableStream,
           data.writableStream,
           data.trackId,
+          data.isReuse,
           data.codec,
         );
         break;
@@ -259,14 +262,14 @@ if (self.RTCTransformEvent) {
   workerLogger.debug('setup transform event');
   // @ts-ignore
   self.onrtctransform = (event: RTCTransformEvent) => {
-    // @ts-ignore .transformer property is part of RTCTransformEvent
+    // @ts-ignore
     const transformer = event.transformer;
     workerLogger.debug('transformer', transformer);
-    // @ts-ignore monkey patching non standard flag
-    transformer.handled = true;
-    const { kind, participantIdentity, trackId, codec } = transformer.options;
+
+    const { kind, participantIdentity, trackId, codec } =
+      transformer.options as ScriptTransformOptions;
     const cryptor = getTrackCryptor(participantIdentity, trackId);
     workerLogger.debug('transform', { codec });
-    cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, codec);
+    cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, false, codec);
   };
 }

package/src/room/PCTransport.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import { EventEmitter } from 'events';
 import type { MediaDescription, SessionDescription } from 'sdp-transform';
 import { parse, write } from 'sdp-transform';
@@ -52,6 +53,8 @@ export default class PCTransport extends EventEmitter {
 
   private latestOfferId: number = 0;
 
+  private offerLock: Mutex;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -86,6 +89,7 @@ export default class PCTransport extends EventEmitter {
     this.loggerOptions = loggerOptions;
     this.config = config;
     this._pc = this.createPC();
+    this.offerLock = new Mutex();
   }
 
   private createPC() {
@@ -251,101 +255,108 @@ export default class PCTransport extends EventEmitter {
   }, debounceInterval);
 
   async createAndSendOffer(options?: RTCOfferOptions) {
-    // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
-    const offerId = this.latestOfferId + 1;
-    this.latestOfferId = offerId;
-    if (this.onOffer === undefined) {
-      return;
-    }
+    const unlock = await this.offerLock.lock();
 
-    if (options?.iceRestart) {
-      this.log.debug('restarting ICE', this.logContext);
-      this.restartingIce = true;
-    }
+    try {
+      // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
+      const offerId = this.latestOfferId + 1;
+      this.latestOfferId = offerId;
 
-    if (this._pc && this._pc.signalingState === 'have-local-offer') {
-      // we're waiting for the peer to accept our offer, so we'll just wait
-      // the only exception to this is when ICE restart is needed
-      const currentSD = this._pc.remoteDescription;
-      if (options?.iceRestart && currentSD) {
-        // TODO: handle when ICE restart is needed but we don't have a remote description
-        // the best thing to do is to recreate the peerconnection
-        await this._pc.setRemoteDescription(currentSD);
-      } else {
-        this.renegotiate = true;
+      if (this.onOffer === undefined) {
         return;
       }
-    } else if (!this._pc || this._pc.signalingState === 'closed') {
-      this.log.warn('could not createOffer with closed peer connection', this.logContext);
-      return;
-    }
 
-    // actually negotiate
-    this.log.debug('starting to negotiate', this.logContext);
-    const offer = await this.pc.createOffer(options);
-    this.log.debug('original offer', { sdp: offer.sdp, ...this.logContext });
+      if (options?.iceRestart) {
+        this.log.debug('restarting ICE', this.logContext);
+        this.restartingIce = true;
+      }
 
-    const sdpParsed = parse(offer.sdp ?? '');
-    sdpParsed.media.forEach((media) => {
-      ensureIPAddrMatchVersion(media);
-      if (media.type === 'audio') {
-        ensureAudioNackAndStereo(media, [], []);
-      } else if (media.type === 'video') {
-        this.trackBitrates.some((trackbr): boolean => {
-          if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
-            return false;
-          }
+      if (this._pc && this._pc.signalingState === 'have-local-offer') {
+        // we're waiting for the peer to accept our offer, so we'll just wait
+        // the only exception to this is when ICE restart is needed
+        const currentSD = this._pc.remoteDescription;
+        if (options?.iceRestart && currentSD) {
+          // TODO: handle when ICE restart is needed but we don't have a remote description
+          // the best thing to do is to recreate the peerconnection
+          await this._pc.setRemoteDescription(currentSD);
+        } else {
+          this.renegotiate = true;
+          return;
+        }
+      } else if (!this._pc || this._pc.signalingState === 'closed') {
+        this.log.warn('could not createOffer with closed peer connection', this.logContext);
+        return;
+      }
 
-          let codecPayload = 0;
-          media.rtp.some((rtp): boolean => {
-            if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
-              codecPayload = rtp.payload;
-              return true;
+      // actually negotiate
+      this.log.debug('starting to negotiate', this.logContext);
+      const offer = await this.pc.createOffer(options);
+      this.log.debug('original offer', { sdp: offer.sdp, ...this.logContext });
+
+      const sdpParsed = parse(offer.sdp ?? '');
+      sdpParsed.media.forEach((media) => {
+        ensureIPAddrMatchVersion(media);
+        if (media.type === 'audio') {
+          ensureAudioNackAndStereo(media, [], []);
+        } else if (media.type === 'video') {
+          this.trackBitrates.some((trackbr): boolean => {
+            if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
+              return false;
             }
-            return false;
-          });
 
-          if (codecPayload === 0) {
-            return true;
-          }
+            let codecPayload = 0;
+            media.rtp.some((rtp): boolean => {
+              if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
+                codecPayload = rtp.payload;
+                return true;
+              }
+              return false;
+            });
 
-          if (isSVCCodec(trackbr.codec)) {
-            this.ensureVideoDDExtensionForSVC(media, sdpParsed);
-          }
+            if (codecPayload === 0) {
+              return true;
+            }
 
-          // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
-          // mung sdp for av1 bitrate setting that can't apply by sendEncoding
-          if (trackbr.codec !== 'av1') {
-            return true;
-          }
+            if (isSVCCodec(trackbr.codec)) {
+              this.ensureVideoDDExtensionForSVC(media, sdpParsed);
+            }
+
+            // TODO: av1 slow starting issue already fixed in chrome 124, clean this after some versions
+            // mung sdp for av1 bitrate setting that can't apply by sendEncoding
+            if (trackbr.codec !== 'av1') {
+              return true;
+            }
 
-          const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
+            const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
 
-          for (const fmtp of media.fmtp) {
-            if (fmtp.payload === codecPayload) {
-              // if another track's fmtp already is set, we cannot override the bitrate
-              // this has the unfortunate consequence of being forced to use the
-              // initial track's bitrate for all tracks
-              if (!fmtp.config.includes('x-google-start-bitrate')) {
-                fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
+            for (const fmtp of media.fmtp) {
+              if (fmtp.payload === codecPayload) {
+                // if another track's fmtp already is set, we cannot override the bitrate
+                // this has the unfortunate consequence of being forced to use the
+                // initial track's bitrate for all tracks
+                if (!fmtp.config.includes('x-google-start-bitrate')) {
+                  fmtp.config += `;x-google-start-bitrate=${startBitrate}`;
+                }
+                break;
               }
-              break;
             }
-          }
-          return true;
+            return true;
+          });
+        }
+      });
+      if (this.latestOfferId > offerId) {
+        this.log.warn('latestOfferId mismatch', {
+          ...this.logContext,
+          latestOfferId: this.latestOfferId,
+          offerId,
         });
+        return;
       }
-    });
-    if (this.latestOfferId > offerId) {
-      this.log.warn('latestOfferId mismatch', {
-        ...this.logContext,
-        latestOfferId: this.latestOfferId,
-        offerId,
-      });
-      return;
+      await this.setMungedSDP(offer, write(sdpParsed));
+      this.onOffer(offer, this.latestOfferId);
+    } finally {
+      unlock();
     }
-    await this.setMungedSDP(offer, write(sdpParsed));
-    this.onOffer(offer, this.latestOfferId);
   }
 
   async createAndSetAnswer(): Promise<RTCSessionDescriptionInit> {

package/src/room/events.ts

@@ -429,6 +429,21 @@ export enum ParticipantEvent {
    */
   LocalTrackUnpublished = 'localTrackUnpublished',
 
+  /**
+   * A local track has been constrained by cpu.
+   * This event is useful to know when to reduce the capture resolution of the track.
+   *
+   * This event is emitted on the local participant.
+   *
+   * args: ([[LocalVideoTrack]], [[LocalTrackPublication]])
+   */
+  LocalTrackCpuConstrained = 'localTrackCpuConstrained',
+
+  /**
+   * @internal
+   */
+  LocalSenderCreated = 'localSenderCreated',
+
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -515,6 +530,11 @@ export enum ParticipantEvent {
    */
   TrackSubscriptionStatusChanged = 'trackSubscriptionStatusChanged',
 
+  /**
+   * a local track has been constrained by cpu
+   */
+  TrackCpuConstrained = 'trackCpuConstrained',
+
   // fired only on LocalParticipant
   /** @internal */
   MediaDevicesError = 'mediaDevicesError',
@@ -599,6 +619,7 @@ export enum TrackEvent {
   Ended = 'ended',
   Subscribed = 'subscribed',
   Unsubscribed = 'unsubscribed',
+  CpuConstrained = 'cpuConstrained',
   /** @internal */
   UpdateSettings = 'updateSettings',
   /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -93,7 +93,7 @@ import {
   isLocalTrack,
   isLocalVideoTrack,
   isSVCCodec,
-  isSafari17,
+  isSafari17Based,
   isVideoTrack,
   isWeb,
   numberToBigInt,
@@ -708,7 +708,7 @@ export default class LocalParticipant extends Participant {
       throw new DeviceUnsupportedError('getDisplayMedia not supported');
     }
 
-    if (options.resolution === undefined && !isSafari17()) {
+    if (options.resolution === undefined && !isSafari17Based()) {
       // we need to constrain the dimensions, otherwise it could lead to low bitrate
       // due to encoding a huge video. Encoding such large surfaces is really expensive
       // unfortunately Safari 17 has a but and cannot be constrained by default
@@ -1169,6 +1169,7 @@ export default class LocalParticipant extends Participant {
       }
 
       track.sender = await this.engine.createSender(track, opts, encodings);
+      this.emit(ParticipantEvent.LocalSenderCreated, track.sender, track);
 
       if (isLocalVideoTrack(track)) {
         opts.degradationPreference ??= getDefaultDegradationPreference(track);
@@ -1271,6 +1272,9 @@ export default class LocalParticipant extends Participant {
       loggerName: this.roomOptions.loggerName,
       loggerContextCb: () => this.logContext,
     });
+    publication.on(TrackEvent.CpuConstrained, (constrainedTrack) =>
+      this.onTrackCpuConstrained(constrainedTrack, publication),
+    );
     // save options for when it needs to be republished again
     publication.options = opts;
     track.sid = ti.sid;
@@ -2329,6 +2333,14 @@ export default class LocalParticipant extends Participant {
     this.engine.client.sendUpdateLocalAudioTrack(pub.trackSid, pub.getTrackFeatures());
   };
 
+  private onTrackCpuConstrained = (track: LocalVideoTrack, publication: LocalTrackPublication) => {
+    this.log.debug('track cpu constrained', {
+      ...this.logContext,
+      ...getLogContextFromTrack(publication),
+    });
+    this.emit(ParticipantEvent.LocalTrackCpuConstrained, track, publication);
+  };
+
   private handleSubscribedQualityUpdate = async (update: SubscribedQualityUpdate) => {
     if (!this.roomOptions?.dynacast) {
       return;

package/src/room/participant/Participant.ts

@@ -13,6 +13,7 @@ import type TypedEmitter from 'typed-emitter';
 import log, { LoggerNames, type StructuredLogger, getLogger } from '../../logger';
 import { ParticipantEvent, TrackEvent } from '../events';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
+import type LocalVideoTrack from '../track/LocalVideoTrack';
 import type RemoteTrack from '../track/RemoteTrack';
 import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
@@ -403,6 +404,8 @@ export type ParticipantEventCallbacks = {
   trackUnmuted: (publication: TrackPublication) => void;
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
+  localTrackCpuConstrained: (track: LocalVideoTrack, publication: LocalTrackPublication) => void;
+  localSenderCreated: (sender: RTCRtpSender, track: Track) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantNameChanged: (name: string) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;

package/src/room/participant/publishUtils.ts

@@ -18,7 +18,7 @@ import {
   isFireFox,
   isReactNative,
   isSVCCodec,
-  isSafari,
+  isSafariBased,
   isSafariSvcApi,
   unwrapConstraint,
 } from '../utils';
@@ -151,7 +151,7 @@ export function computeVideoEncodings(
     // Announced here: https://groups.google.com/g/discuss-webrtc/c/-QQ3pxrl-fw?pli=1
     const browser = getBrowser();
     if (
-      isSafari() ||
+      isSafariBased() ||
       // Even tho RN runs M114, it does not produce SVC layers when a single encoding
       // is provided. So we'll use the legacy SVC specification for now.
       // TODO: when we upstream libwebrtc, this will need additional verification

package/src/room/track/LocalTrackPublication.ts

@@ -1,7 +1,7 @@
 import { AudioTrackFeature, TrackInfo } from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
-import { isAudioTrack } from '../utils';
+import { isAudioTrack, isVideoTrack } from '../utils';
 import LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
@@ -28,12 +28,14 @@ export default class LocalTrackPublication extends TrackPublication {
   setTrack(track?: Track) {
     if (this.track) {
       this.track.off(TrackEvent.Ended, this.handleTrackEnded);
+      this.track.off(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
 
     super.setTrack(track);
 
     if (track) {
       track.on(TrackEvent.Ended, this.handleTrackEnded);
+      track.on(TrackEvent.CpuConstrained, this.handleCpuConstrained);
     }
   }
 
@@ -116,4 +118,10 @@ export default class LocalTrackPublication extends TrackPublication {
   handleTrackEnded = () => {
     this.emit(TrackEvent.Ended);
   };
+
+  private handleCpuConstrained = () => {
+    if (this.track && isVideoTrack(this.track)) {
+      this.emit(TrackEvent.CpuConstrained, this.track);
+    }
+  };
 }

package/src/room/track/LocalVideoTrack.ts

@@ -7,6 +7,7 @@ import {
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import type { StructuredLogger } from '../../logger';
+import { TrackEvent } from '../events';
 import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
@@ -56,6 +57,10 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
 
   private degradationPreference: RTCDegradationPreference = 'balanced';
 
+  private isCpuConstrained: boolean = false;
+
+  private optimizeForPerformance: boolean = false;
+
   get sender(): RTCRtpSender | undefined {
     return this._sender;
   }
@@ -251,6 +256,9 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     }
     await this.restart(constraints);
 
+    // reset cpu constrained state after track is restarted
+    this.isCpuConstrained = false;
+
     for await (const sc of this.simulcastCodecs.values()) {
       if (sc.sender && sc.sender.transport?.state !== 'closed') {
         sc.mediaStreamTrack = this.mediaStreamTrack.clone();
@@ -334,6 +342,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     // only enable simulcast codec for preference codec setted
     if (!this.codec && codecs.length > 0) {
       await this.setPublishingLayers(isSVCCodec(codecs[0].codec), codecs[0].qualities);
+
       return [];
     }
 
@@ -378,6 +387,13 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
    * Sets layers that should be publishing
    */
   async setPublishingLayers(isSvc: boolean, qualities: SubscribedQuality[]) {
+    if (this.optimizeForPerformance) {
+      this.log.info('skipping setPublishingLayers due to optimized publishing performance', {
+        ...this.logContext,
+        qualities,
+      });
+      return;
+    }
     this.log.debug('setting publishing layers', { ...this.logContext, qualities });
     if (!this.sender || !this.encodings) {
       return;
@@ -394,6 +410,49 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     );
   }
 
+  /**
+   * Designed for lower powered devices, reduces video publishing quality and disables simulcast.
+   * @experimental
+   */
+  async prioritizePerformance() {
+    if (!this.sender) {
+      throw new Error('sender not found');
+    }
+
+    const unlock = await this.senderLock.lock();
+
+    try {
+      this.optimizeForPerformance = true;
+      const params = this.sender.getParameters();
+
+      params.encodings = params.encodings.map((e, idx) => ({
+        ...e,
+        active: idx === 0,
+        scaleResolutionDownBy: Math.max(
+          1,
+          Math.ceil((this.mediaStreamTrack.getSettings().height ?? 360) / 360),
+        ),
+        scalabilityMode: idx === 0 && isSVCCodec(this.codec) ? 'L1T3' : undefined,
+        maxFramerate: idx === 0 ? 15 : 0,
+        maxBitrate: idx === 0 ? e.maxBitrate : 0,
+      }));
+      this.log.debug('setting performance optimised encodings', {
+        ...this.logContext,
+        encodings: params.encodings,
+      });
+      this.encodings = params.encodings;
+      await this.sender.setParameters(params);
+    } catch (e) {
+      this.log.error('failed to set performance optimised encodings', {
+        ...this.logContext,
+        error: e,
+      });
+      this.optimizeForPerformance = false;
+    } finally {
+      unlock();
+    }
+  }
+
   protected monitorSender = async () => {
     if (!this.sender) {
       this._currentBitrate = 0;
@@ -404,11 +463,19 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     try {
       stats = await this.getSenderStats();
     } catch (e) {
-      this.log.error('could not get audio sender stats', { ...this.logContext, error: e });
+      this.log.error('could not get video sender stats', { ...this.logContext, error: e });
       return;
     }
     const statsMap = new Map<string, VideoSenderStats>(stats.map((s) => [s.rid, s]));
 
+    const isCpuConstrained = stats.some((s) => s.qualityLimitationReason === 'cpu');
+    if (isCpuConstrained !== this.isCpuConstrained) {
+      this.isCpuConstrained = isCpuConstrained;
+      if (this.isCpuConstrained) {
+        this.emit(TrackEvent.CpuConstrained);
+      }
+    }
+
     if (this.prevStats) {
       let totalBitrate = 0;
       statsMap.forEach((s, key) => {