livekit-client 1.14.0 → 1.14.2

package/src/room/RTCEngine.ts

@@ -108,7 +108,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private subscriberPrimary: boolean = false;
 
-  private primaryPC?: RTCPeerConnection;
+  private primaryTransport?: PCTransport;
 
   private pcState: PCState = PCState.New;
 
@@ -247,12 +247,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   async cleanupPeerConnections() {
-    if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
-      this.publisher.pc.getSenders().forEach((sender) => {
+    if (this.publisher && this.publisher.getSignallingState() !== 'closed') {
+      this.publisher.getSenders().forEach((sender) => {
         try {
           // TODO: react-native-webrtc doesn't have removeTrack yet.
-          if (this.publisher?.pc.removeTrack) {
-            this.publisher?.pc.removeTrack(sender);
+          if (this.publisher?.canRemoveTrack()) {
+            this.publisher?.removeTrack(sender);
           }
         } catch (e) {
           log.warn('could not removeTrack', { error: e });
@@ -268,7 +268,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.subscriber = undefined;
     }
     this.hasPublished = false;
-    this.primaryPC = undefined;
+    this.primaryTransport = undefined;
 
     const dcCleanup = (dc: RTCDataChannel | undefined) => {
       if (!dc) return;
@@ -336,7 +336,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       delete this.pendingTrackResolvers[sender.track.id];
     }
     try {
-      this.publisher?.pc.removeTrack(sender);
+      this.publisher?.removeTrack(sender);
       return true;
     } catch (e: unknown) {
       log.warn('failed to remove track', { error: e, method: 'removeTrack' });
@@ -353,10 +353,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   async getConnectedServerAddress(): Promise<string | undefined> {
-    if (this.primaryPC === undefined) {
+    if (this.primaryTransport === undefined) {
       return undefined;
     }
-    return getConnectedAddress(this.primaryPC);
+    return this.primaryTransport.getConnectedAddress();
   }
 
   /* @internal */
@@ -387,40 +387,38 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.emit(EngineEvent.TransportsCreated, this.publisher, this.subscriber);
 
-    this.publisher.pc.onicecandidate = (ev) => {
-      if (!ev.candidate) return;
-      log.trace('adding ICE candidate for peer', ev.candidate);
-      this.client.sendIceCandidate(ev.candidate, SignalTarget.PUBLISHER);
+    this.publisher.onIceCandidate = (candidate) => {
+      log.trace('adding ICE candidate for peer', candidate);
+      this.client.sendIceCandidate(candidate, SignalTarget.PUBLISHER);
     };
 
-    this.subscriber.pc.onicecandidate = (ev) => {
-      if (!ev.candidate) return;
-      this.client.sendIceCandidate(ev.candidate, SignalTarget.SUBSCRIBER);
+    this.subscriber.onIceCandidate = (candidate) => {
+      this.client.sendIceCandidate(candidate, SignalTarget.SUBSCRIBER);
     };
 
     this.publisher.onOffer = (offer) => {
       this.client.sendOffer(offer);
     };
 
-    let primaryPC = this.publisher.pc;
-    let secondaryPC = this.subscriber.pc;
+    let primaryTransport = this.publisher;
+    let secondaryTransport = this.subscriber;
     let subscriberPrimary = joinResponse.subscriberPrimary;
     if (subscriberPrimary) {
-      primaryPC = this.subscriber.pc;
-      secondaryPC = this.publisher.pc;
+      primaryTransport = this.subscriber;
+      secondaryTransport = this.publisher;
       // in subscriber primary mode, server side opens sub data channels.
-      this.subscriber.pc.ondatachannel = this.handleDataChannel;
+      this.subscriber.onDataChannel = this.handleDataChannel;
     }
-    this.primaryPC = primaryPC;
-    primaryPC.onconnectionstatechange = async () => {
-      log.debug(`primary PC state changed ${primaryPC.connectionState}`);
-      if (primaryPC.connectionState === 'connected') {
+    this.primaryTransport = primaryTransport;
+    primaryTransport.onConnectionStateChange = async (connectionState) => {
+      log.debug(`primary PC state changed ${connectionState}`);
+      if (connectionState === 'connected') {
         const shouldEmit = this.pcState === PCState.New;
         this.pcState = PCState.Connected;
         if (shouldEmit) {
           this.emit(EngineEvent.Connected, joinResponse);
         }
-      } else if (primaryPC.connectionState === 'failed') {
+      } else if (connectionState === 'failed') {
         // on Safari, PeerConnection will switch to 'disconnected' during renegotiation
         if (this.pcState === PCState.Connected) {
           this.pcState = PCState.Disconnected;
@@ -434,10 +432,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
       }
     };
-    secondaryPC.onconnectionstatechange = async () => {
-      log.debug(`secondary PC state changed ${secondaryPC.connectionState}`);
+    secondaryTransport.onConnectionStateChange = async (connectionState) => {
+      log.debug(`secondary PC state changed ${connectionState}`);
       // also reconnect if secondary peerconnection fails
-      if (secondaryPC.connectionState === 'failed') {
+      if (connectionState === 'failed') {
         this.handleDisconnect(
           'secondary peerconnection',
           subscriberPrimary
@@ -447,7 +445,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
     };
 
-    this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
+    this.subscriber.onTrack = (ev: RTCTrackEvent) => {
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
     };
 
@@ -462,7 +460,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       log.debug('received server answer', {
         RTCSdpType: sd.type,
-        signalingState: this.publisher.pc.signalingState.toString(),
+        signalingState: this.publisher.getSignallingState().toString(),
       });
       await this.publisher.setRemoteDescription(sd);
     };
@@ -487,7 +485,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
       log.debug('received server offer', {
         RTCSdpType: sd.type,
-        signalingState: this.subscriber.pc.signalingState.toString(),
+        signalingState: this.subscriber.getSignallingState().toString(),
       });
       await this.subscriber.setRemoteDescription(sd);
 
@@ -518,7 +516,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.client.onLeave = (leave?: LeaveRequest) => {
       if (leave?.canReconnect) {
         this.fullReconnectOnNext = true;
-        this.primaryPC = undefined;
+        this.primaryTransport = undefined;
         // reconnect immediately instead of waiting for next attempt
         this.handleDisconnect(leaveReconnect);
       } else {
@@ -579,12 +577,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     // create data channels
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
+    this.lossyDC = this.publisher.createDataChannel(lossyDataChannel, {
       // will drop older packets that arrive
       ordered: true,
       maxRetransmits: 0,
     });
-    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
+    this.reliableDC = this.publisher.createDataChannel(reliableDataChannel, {
       ordered: true,
     });
 
@@ -765,7 +763,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       transceiverInit.sendEncodings = encodings;
     }
     // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-    const transceiver = await this.publisher.pc.addTransceiver(
+    const transceiver = await this.publisher.addTransceiver(
       track.mediaStreamTrack,
       transceiverInit,
     );
@@ -791,7 +789,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       transceiverInit.sendEncodings = encodings;
     }
     // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
-    const transceiver = await this.publisher.pc.addTransceiver(
+    const transceiver = await this.publisher.addTransceiver(
       simulcastTrack.mediaStreamTrack,
       transceiverInit,
     );
@@ -807,7 +805,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.publisher) {
       throw new UnexpectedConnectionState('publisher is closed');
     }
-    return this.publisher.pc.addTrack(track);
+    return this.publisher.addTrack(track);
   }
 
   // websocket reconnect behavior. if websocket is interrupted, and the PeerConnection
@@ -872,7 +870,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED ||
       // signaling state could change to closed due to hardware sleep
       // those connections cannot be resumed
-      (this.primaryPC?.signalingState ?? 'closed') === 'closed'
+      (this.primaryTransport?.getSignallingState() ?? 'closed') === 'closed'
     ) {
       this.fullReconnectOnNext = true;
     }
@@ -999,8 +997,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       const res = await this.client.reconnect(this.url, this.token, this.participantSid, reason);
       if (res) {
         const rtcConfig = this.makeRTCConfiguration(res);
-        this.publisher.pc.setConfiguration(rtcConfig);
-        this.subscriber.pc.setConfiguration(rtcConfig);
+        this.publisher.setConfiguration(rtcConfig);
+        this.subscriber.setConfiguration(rtcConfig);
       }
     } catch (e) {
       let message = '';
@@ -1084,7 +1082,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     log.debug('waiting for peer connection to reconnect');
     while (now - startTime < this.peerConnectionTimeout) {
-      if (this.primaryPC === undefined) {
+      if (this.primaryTransport === undefined) {
         // we can abort early, connection is hosed
         break;
       } else if (
@@ -1092,8 +1090,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         // this means we'd have to check its status manually and update address
         // manually
         now - startTime > minReconnectWait &&
-        this.primaryPC?.connectionState === 'connected' &&
-        (!this.hasPublished || this.publisher?.pc.connectionState === 'connected')
+        this.primaryTransport?.getConnectionState() === 'connected' &&
+        (!this.hasPublished || this.publisher?.getConnectionState() === 'connected')
       ) {
         this.pcState = PCState.Connected;
       }
@@ -1172,7 +1170,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (
       !subscriber &&
       !this.publisher?.isICEConnected &&
-      this.publisher?.pc.iceConnectionState !== 'checking'
+      this.publisher?.getICEConnectionState() !== 'checking'
     ) {
       // start negotiation
       this.negotiate();
@@ -1196,7 +1194,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
 
     throw new ConnectionError(
-      `could not establish ${transportName} connection, state: ${transport.pc.iceConnectionState}`,
+      `could not establish ${transportName} connection, state: ${transport.getICEConnectionState()}`,
     );
   }
 
@@ -1207,12 +1205,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /* @internal */
   verifyTransport(): boolean {
     // primary connection
-    if (!this.primaryPC) {
+    if (!this.primaryTransport) {
       return false;
     }
     if (
-      this.primaryPC.connectionState === 'closed' ||
-      this.primaryPC.connectionState === 'failed'
+      this.primaryTransport.getConnectionState() === 'closed' ||
+      this.primaryTransport.getConnectionState() === 'failed'
     ) {
       return false;
     }
@@ -1223,8 +1221,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         return false;
       }
       if (
-        this.publisher.pc.connectionState === 'closed' ||
-        this.publisher.pc.connectionState === 'failed'
+        this.publisher.getConnectionState() === 'closed' ||
+        this.publisher.getConnectionState() === 'failed'
       ) {
         return false;
       }
@@ -1355,40 +1353,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 }
 
-async function getConnectedAddress(pc: RTCPeerConnection): Promise<string | undefined> {
-  let selectedCandidatePairId = '';
-  const candidatePairs = new Map<string, RTCIceCandidatePairStats>();
-  // id -> candidate ip
-  const candidates = new Map<string, string>();
-  const stats: RTCStatsReport = await pc.getStats();
-  stats.forEach((v) => {
-    switch (v.type) {
-      case 'transport':
-        selectedCandidatePairId = v.selectedCandidatePairId;
-        break;
-      case 'candidate-pair':
-        if (selectedCandidatePairId === '' && v.selected) {
-          selectedCandidatePairId = v.id;
-        }
-        candidatePairs.set(v.id, v);
-        break;
-      case 'remote-candidate':
-        candidates.set(v.id, `${v.address}:${v.port}`);
-        break;
-      default:
-    }
-  });
-
-  if (selectedCandidatePairId === '') {
-    return undefined;
-  }
-  const selectedID = candidatePairs.get(selectedCandidatePairId)?.remoteCandidateId;
-  if (selectedID === undefined) {
-    return undefined;
-  }
-  return candidates.get(selectedID);
-}
-
 class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {

package/src/room/Room.ts

@@ -452,6 +452,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
               error instanceof ConnectionError &&
               (error.status === 401 || error.reason === ConnectionErrorReason.Cancelled)
             ) {
+              this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
               reject(error);
               return;
             }
@@ -462,9 +463,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             );
             await connectFn(resolve, reject, nextUrl);
           } else {
+            this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
             reject(e);
           }
         } else {
+          this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
           reject(e);
         }
       }
@@ -593,8 +596,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.setupLocalParticipantEvents();
       this.emit(RoomEvent.SignalConnected);
     } catch (err) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       const resultingError = new ConnectionError(`could not establish signal connection`);
       if (err instanceof Error) {
         resultingError.message = `${resultingError.message}: ${err.message}`;
@@ -608,8 +611,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
 
     if (abortController.signal.aborted) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       throw new ConnectionError(`Connection attempt aborted`);
     }
 
@@ -619,8 +622,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         abortController,
       );
     } catch (e) {
+      await this.engine.close();
       this.recreateEngine();
-      this.handleDisconnect(this.options.stopLocalTrackOnUnpublish);
       throw e;
     }
 
@@ -1018,8 +1021,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
-    let trackId = parts[1];
-    if (!trackId || trackId === '') trackId = mediaTrack.id;
+    let streamId = parts[1];
+    let trackId = mediaTrack.id;
+    // firefox will get streamId (pID|trackId) instead of (pID|streamId) as it doesn't support sync tracks by stream
+    // and generates its own track id instead of infer from sdp track id.
+    if (streamId && streamId.startsWith('TR')) trackId = streamId;
 
     if (participantId === this.localParticipant.sid) {
       log.warn('tried to create RemoteParticipant for local participant');
@@ -1543,14 +1549,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private sendSyncState() {
-    if (
-      this.engine.subscriber === undefined ||
-      this.engine.subscriber.pc.localDescription === null
-    ) {
+    const previousAnswer = this.engine.subscriber?.getLocalDescription();
+    const previousOffer = this.engine.subscriber?.getRemoteDescription();
+
+    if (!previousAnswer) {
       return;
     }
-    const previousAnswer = this.engine.subscriber.pc.localDescription;
-    const previousOffer = this.engine.subscriber.pc.remoteDescription;
 
     /* 1. autosubscribe on, so subscribed tracks = all tracks - unsub tracks,
           in this case, we send unsub tracks, so server add all tracks to this

package/src/room/defaults.ts

@@ -1,11 +1,13 @@
 import type { InternalRoomConnectOptions, InternalRoomOptions } from '../options';
 import DefaultReconnectPolicy from './DefaultReconnectPolicy';
-import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
 import type {
   AudioCaptureOptions,
   TrackPublishDefaults,
   VideoCaptureOptions,
 } from './track/options';
+import { AudioPresets, ScreenSharePresets, VideoPresets } from './track/options';
+
+export const defaultVideoCodec = 'vp8';
 
 export const publishDefaults: TrackPublishDefaults = {
   /**
@@ -19,7 +21,7 @@ export const publishDefaults: TrackPublishDefaults = {
   simulcast: true,
   screenShareEncoding: ScreenSharePresets.h1080fps15.encoding,
   stopMicTrackOnMute: false,
-  videoCodec: 'vp8',
+  videoCodec: defaultVideoCodec,
   backupCodec: false,
 } as const;
 

package/src/room/events.ts

@@ -223,7 +223,7 @@ export enum RoomEvent {
    * be emitted.
    *
    * args: (pub: [[RemoteTrackPublication]],
-   *        status: [[TrackPublication.SubscriptionStatus]],
+   *        status: [[TrackPublication.PermissionStatus]],
    *        participant: [[RemoteParticipant]])
    */
   TrackSubscriptionPermissionChanged = 'trackSubscriptionPermissionChanged',

package/src/room/participant/LocalParticipant.ts

@@ -18,6 +18,7 @@ import {
   TrackUnpublishedResponse,
 } from '../../proto/livekit_rtc_pb';
 import type RTCEngine from '../RTCEngine';
+import { defaultVideoCodec } from '../defaults';
 import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
 import LocalAudioTrack from '../track/LocalAudioTrack';
@@ -33,10 +34,11 @@ import type {
   TrackPublishOptions,
   VideoCaptureOptions,
 } from '../track/options';
-import { VideoPresets, isBackupCodec, isCodecEqual } from '../track/options';
+import { VideoPresets, isBackupCodec } from '../track/options';
 import {
   constraintsForOptions,
   mergeDefaultOptions,
+  mimeTypeToVideoCodecString,
   screenCaptureToDisplayMediaStreamOptions,
 } from '../track/utils';
 import type { DataPublishOptions } from '../types';
@@ -629,6 +631,10 @@ export default class LocalParticipant extends Participant {
     if (opts.videoCodec === 'vp9' && !supportsVP9()) {
       opts.videoCodec = undefined;
     }
+    if (opts.videoCodec === undefined) {
+      opts.videoCodec = defaultVideoCodec;
+    }
+    const videoCodec = opts.videoCodec;
 
     // handle track actions
     track.on(TrackEvent.Muted, this.onTrackMuted);
@@ -649,11 +655,11 @@ export default class LocalParticipant extends Participant {
       encryption: this.encryptionType,
       stereo: isStereo,
       disableRed: this.isE2EEEnabled || !(opts.red ?? true),
+      stream: opts?.stream,
     });
 
     // compute encodings and layers for video
     let encodings: RTCRtpEncodingParameters[] | undefined;
-    let simEncodings: RTCRtpEncodingParameters[] | undefined;
     if (track.kind === Track.Kind.Video) {
       let dims: Track.Dimensions = {
         width: 0,
@@ -678,53 +684,40 @@ export default class LocalParticipant extends Participant {
       req.height = dims.height;
       // for svc codecs, disable simulcast and use vp8 for backup codec
       if (track instanceof LocalVideoTrack) {
-        if (isSVCCodec(opts.videoCodec)) {
+        if (isSVCCodec(videoCodec)) {
           // vp9 svc with screenshare has problem to encode, always use L1T3 here
-          if (track.source === Track.Source.ScreenShare && opts.videoCodec === 'vp9') {
+          if (track.source === Track.Source.ScreenShare && videoCodec === 'vp9') {
             opts.scalabilityMode = 'L1T3';
           }
           // set scalabilityMode to 'L3T3_KEY' by default
           opts.scalabilityMode = opts.scalabilityMode ?? 'L3T3_KEY';
         }
 
+        req.simulcastCodecs = [
+          new SimulcastCodec({
+            codec: videoCodec,
+            cid: track.mediaStreamTrack.id,
+          }),
+        ];
+
         // set up backup
-        if (opts.videoCodec && opts.backupCodec && opts.videoCodec !== opts.backupCodec.codec) {
+        if (opts.backupCodec && videoCodec !== opts.backupCodec.codec) {
           if (!this.roomOptions.dynacast) {
             this.roomOptions.dynacast = true;
           }
-          const simOpts = { ...opts };
-          simOpts.simulcast = true;
-          simEncodings = computeTrackBackupEncodings(track, opts.backupCodec.codec, simOpts);
-
-          req.simulcastCodecs = [
-            new SimulcastCodec({
-              codec: opts.videoCodec,
-              cid: track.mediaStreamTrack.id,
-              enableSimulcastLayers: true,
-            }),
+          req.simulcastCodecs.push(
             new SimulcastCodec({
               codec: opts.backupCodec.codec,
               cid: '',
-              enableSimulcastLayers: true,
             }),
-          ];
-        } else if (opts.videoCodec) {
-          // pass codec info to sfu so it can prefer codec for the client which don't support
-          // setCodecPreferences
-          req.simulcastCodecs = [
-            new SimulcastCodec({
-              codec: opts.videoCodec,
-              cid: track.mediaStreamTrack.id,
-              enableSimulcastLayers: opts.simulcast ?? false,
-            }),
-          ];
+          );
         }
       }
 
       encodings = computeVideoEncodings(
         track.source === Track.Source.ScreenShare,
-        dims.width,
-        dims.height,
+        req.width,
+        req.height,
         opts,
       );
       req.layers = videoLayersFromEncodings(
@@ -748,30 +741,28 @@ export default class LocalParticipant extends Participant {
     }
 
     const ti = await this.engine.addTrack(req);
-    let primaryCodecSupported = false;
-    let backupCodecSupported = false;
-    ti.codecs.forEach((c) => {
-      if (isCodecEqual(c.mimeType, opts.videoCodec)) {
-        primaryCodecSupported = true;
-      } else if (opts.backupCodec && isCodecEqual(c.mimeType, opts.backupCodec.codec)) {
-        backupCodecSupported = true;
+    // server might not support the codec the client has requested, in that case, fallback
+    // to a supported codec
+    let primaryCodecMime: string | undefined;
+    ti.codecs.forEach((codec) => {
+      if (primaryCodecMime === undefined) {
+        primaryCodecMime = codec.mimeType;
       }
     });
-
-    if (req.simulcastCodecs.length > 0) {
-      if (!primaryCodecSupported && !backupCodecSupported) {
-        throw Error('cannot publish track, codec not supported by server');
-      }
-
-      if (!primaryCodecSupported && opts.backupCodec) {
-        const backupCodec = opts.backupCodec;
-        opts = { ...opts };
-        log.debug(
-          `primary codec ${opts.videoCodec} not supported, fallback to ${backupCodec.codec}`,
+    if (primaryCodecMime && track.kind === Track.Kind.Video) {
+      const updatedCodec = mimeTypeToVideoCodecString(primaryCodecMime);
+      if (updatedCodec !== videoCodec) {
+        log.debug('falling back to server selected codec', { codec: updatedCodec });
+        /* @ts-ignore */
+        opts.videoCodec = updatedCodec;
+
+        // recompute encodings since bitrates/etc could have changed
+        encodings = computeVideoEncodings(
+          track.source === Track.Source.ScreenShare,
+          req.width,
+          req.height,
+          opts,
         );
-        opts.videoCodec = backupCodec.codec;
-        opts.videoEncoding = backupCodec.encoding;
-        encodings = simEncodings;
       }
     }
 
@@ -785,20 +776,19 @@ export default class LocalParticipant extends Participant {
     }
     log.debug(`publishing ${track.kind} with encodings`, { encodings, trackInfo: ti });
 
-    // store RTPSender
     track.sender = await this.engine.createSender(track, opts, encodings);
 
     if (encodings) {
       if (isFireFox() && track.kind === Track.Kind.Audio) {
         /* Refer to RFC https://datatracker.ietf.org/doc/html/rfc7587#section-6.1,
-           livekit-server uses maxaveragebitrate=510000in the answer sdp to permit client to
+           livekit-server uses maxaveragebitrate=510000 in the answer sdp to permit client to
            publish high quality audio track. But firefox always uses this value as the actual
            bitrates, causing the audio bitrates to rise to 510Kbps in any stereo case unexpectedly.
            So the client need to modify maxaverragebitrates in answer sdp to user provided value to
            fix the issue.
          */
         let trackTransceiver: RTCRtpTransceiver | undefined = undefined;
-        for (const transceiver of this.engine.publisher.pc.getTransceivers()) {
+        for (const transceiver of this.engine.publisher.getTransceivers()) {
           if (transceiver.sender === track.sender) {
             trackTransceiver = transceiver;
             break;
@@ -888,7 +878,6 @@ export default class LocalParticipant extends Participant {
         {
           codec: opts.videoCodec,
           cid: simulcastTrack.mediaStreamTrack.id,
-          enableSimulcastLayers: opts.simulcast,
         },
       ],
     });
@@ -946,11 +935,11 @@ export default class LocalParticipant extends Participant {
     track.sender = undefined;
     if (
       this.engine.publisher &&
-      this.engine.publisher.pc.connectionState !== 'closed' &&
+      this.engine.publisher.getConnectionState() !== 'closed' &&
       trackSender
     ) {
       try {
-        for (const transceiver of this.engine.publisher.pc.getTransceivers()) {
+        for (const transceiver of this.engine.publisher.getTransceivers()) {
           // if sender is not currently sending (after replaceTrack(null))
           // removeTrack would have no effect.
           // to ensure we end up successfully removing the track, manually set

package/src/room/track/LocalAudioTrack.ts

@@ -138,7 +138,7 @@ export default class LocalAudioTrack extends LocalTrack {
     this.prevStats = stats;
   };
 
-  async setProcessor(processor: TrackProcessor<typeof this.kind>) {
+  async setProcessor(processor: TrackProcessor<this['kind']>) {
     const unlock = await this.processorLock.lock();
     try {
       if (!this.audioContext) {