livekit-client 2.0.2 → 2.0.4

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -3,6 +3,7 @@ import { Mutex } from '../utils';
 import { Track } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
+import type { ReplaceTrackOptions } from './types';
 export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Kind> extends Track<TrackKind> {
     /** @internal */
     sender?: RTCRtpSender;
@@ -18,6 +19,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     protected processor?: TrackProcessor<TrackKind, any>;
     protected processorLock: Mutex;
     protected audioContext?: AudioContext;
+    private restartLock;
     /**
      *
      * @param mediaTrack
@@ -40,7 +42,8 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     getDeviceId(): Promise<string | undefined>;
     mute(): Promise<this>;
     unmute(): Promise<this>;
-    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<this>;
+    replaceTrack(track: MediaStreamTrack, options?: ReplaceTrackOptions): Promise<typeof this>;
+    replaceTrack(track: MediaStreamTrack, userProvidedTrack?: boolean): Promise<typeof this>;
     protected restart(constraints?: MediaTrackConstraints): Promise<this>;
     protected setTrackMuted(muted: boolean): void;
     protected get needsReAcquisition(): boolean;

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -4,6 +4,7 @@ import { StructuredLogger } from '../../logger';
 import { TrackSource, TrackType } from '../../proto/livekit_models_pb';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
 import type { LoggerOptions } from '../types';
+import type { TrackProcessor } from './processor/types';
 export declare enum VideoQuality {
     LOW = 0,
     MEDIUM = 1,
@@ -135,6 +136,7 @@ export type TrackEventCallbacks = {
     elementDetached: (element: HTMLMediaElement) => void;
     upstreamPaused: (track: any) => void;
     upstreamResumed: (track: any) => void;
+    trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
 };
 export {};
 //# sourceMappingURL=Track.d.ts.map

package/dist/ts4.2/src/room/track/options.d.ts

@@ -220,10 +220,20 @@ export interface VideoEncoding {
     maxFramerate?: number;
     priority?: RTCPriorityType;
 }
+export interface VideoPresetOptions {
+    width: number;
+    height: number;
+    aspectRatio?: number;
+    maxBitrate: number;
+    maxFramerate?: number;
+    priority?: RTCPriorityType;
+}
 export declare class VideoPreset {
     encoding: VideoEncoding;
     width: number;
     height: number;
+    aspectRatio?: number;
+    constructor(videoPresetOptions: VideoPresetOptions);
     constructor(width: number, height: number, maxBitrate: number, maxFramerate?: number, priority?: RTCPriorityType);
     get resolution(): VideoResolution;
 }

package/dist/ts4.2/src/room/track/types.d.ts

@@ -21,4 +21,8 @@ export type AdaptiveStreamSettings = {
      */
     pauseVideoInBackground?: boolean;
 };
+export interface ReplaceTrackOptions {
+    userProvidedTrack?: boolean;
+    stopProcessor?: boolean;
+}
 //# sourceMappingURL=types.d.ts.map

package/package.json

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

package/src/api/SignalClient.ts

@@ -283,6 +283,7 @@ export class SignalClient {
 
         this.ws.onerror = async (ev: Event) => {
           if (this.state !== SignalConnectionState.CONNECTED) {
+            this.state = SignalConnectionState.DISCONNECTED;
             clearTimeout(wsTimeout);
             try {
               const resp = await fetch(`http${url.substring(2)}/validate${params}`);

package/src/e2ee/E2eeManager.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
-import log from '../logger';
+import log, { LogLevel, workerLogger } from '../logger';
 import { Encryption_Type, TrackInfo } from '../proto/livekit_models_pb';
 import type RTCEngine from '../room/RTCEngine';
 import type Room from '../room/Room';
@@ -68,6 +68,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
         kind: 'init',
         data: {
           keyProviderOptions: this.keyProvider.getOptions(),
+          loglevel: workerLogger.getLevel() as LogLevel,
         },
       };
       if (this.worker) {

package/src/e2ee/KeyProvider.ts

@@ -12,7 +12,7 @@ import { createKeyMaterialFromBuffer, createKeyMaterialFromString } from './util
 export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitter<KeyProviderCallbacks>) {
   private keyInfoMap: Map<string, KeyInfo>;
 
-  private options: KeyProviderOptions;
+  private readonly options: KeyProviderOptions;
 
   constructor(options: Partial<KeyProviderOptions> = {}) {
     super();
@@ -29,6 +29,11 @@ export class BaseKeyProvider extends (EventEmitter as new () => TypedEventEmitte
    */
   protected onSetEncryptionKey(key: CryptoKey, participantIdentity?: string, keyIndex?: number) {
     const keyInfo: KeyInfo = { key, participantIdentity, keyIndex };
+    if (!this.options.sharedKey && !participantIdentity) {
+      throw new Error(
+        'participant identity needs to be passed for encryption key if sharedKey option is false',
+      );
+    }
     this.keyInfoMap.set(`${participantIdentity ?? 'shared'}-${keyIndex ?? 0}`, keyInfo);
     this.emit(KeyProviderEvent.SetKey, keyInfo);
   }

package/src/e2ee/types.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from '../logger';
 import type { VideoCodec } from '../room/track/options';
 import type { BaseKeyProvider } from './KeyProvider';
 
@@ -10,6 +11,7 @@ export interface InitMessage extends BaseMessage {
   kind: 'init';
   data: {
     keyProviderOptions: KeyProviderOptions;
+    loglevel: LogLevel;
   };
 }
 

package/src/e2ee/worker/FrameCryptor.ts

@@ -83,6 +83,14 @@ export class FrameCryptor extends BaseFrameCryptor {
     this.sifGuard = new SifGuard();
   }
 
+  private get logContext() {
+    return {
+      identity: this.participantIdentity,
+      trackId: this.trackId,
+      fallbackCodec: this.videoCodec,
+    };
+  }
+
   /**
    * Assign a different participant to the cryptor.
    * useful for transceiver re-use
@@ -96,6 +104,7 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 
   unsetParticipant() {
+    workerLogger.debug('unsetting participant', this.logContext);
     this.participantIdentity = undefined;
   }
 
@@ -143,6 +152,13 @@ export class FrameCryptor extends BaseFrameCryptor {
       this.videoCodec = codec;
     }
 
+    workerLogger.debug('Setting up frame cryptor transform', {
+      operation,
+      passedTrackId: trackId,
+      codec,
+      ...this.logContext,
+    });
+
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
       transform: transformFn.bind(this),
@@ -159,6 +175,7 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 
   setSifTrailer(trailer: Uint8Array) {
+    workerLogger.debug('setting SIF trailer', { ...this.logContext, trailer });
     this.sifTrailer = trailer;
   }
 
@@ -212,6 +229,8 @@ export class FrameCryptor extends BaseFrameCryptor {
         encodedFrame.timestamp,
       );
       let frameInfo = this.getUnencryptedBytes(encodedFrame);
+      workerLogger.debug('frameInfo for encoded frame', { ...frameInfo, ...this.logContext });
+
       // Thіs is not encrypted and contains the VP8 payload descriptor or the Opus TOC byte.
       const frameHeader = new Uint8Array(encodedFrame.data, 0, frameInfo.unencryptedBytes);
 
@@ -262,6 +281,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         workerLogger.error(e);
       }
     } else {
+      workerLogger.debug('failed to decrypt, emitting error', this.logContext);
       this.emit(
         CryptorEvent.Error,
         new CryptorError(`encryption key missing for encoding`, CryptorErrorReason.MissingKey),
@@ -284,11 +304,13 @@ export class FrameCryptor extends BaseFrameCryptor {
       // skip for decryption for empty dtx frames
       encodedFrame.data.byteLength === 0
     ) {
+      workerLogger.debug('skipping empty frame', this.logContext);
       this.sifGuard.recordUserFrame();
       return controller.enqueue(encodedFrame);
     }
 
     if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
+      workerLogger.debug('enqueue SIF', this.logContext);
       this.sifGuard.recordSif();
 
       if (this.sifGuard.isSifAllowed()) {
@@ -312,6 +334,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         const decodedFrame = await this.decryptFrame(encodedFrame, keyIndex);
         this.keys.decryptionSuccess();
         if (decodedFrame) {
+          workerLogger.debug('enqueue decrypted frame', this.logContext);
           return controller.enqueue(decodedFrame);
         }
       } catch (error) {
@@ -352,6 +375,8 @@ export class FrameCryptor extends BaseFrameCryptor {
       throw new TypeError(`no encryption key found for decryption of ${this.participantIdentity}`);
     }
     let frameInfo = this.getUnencryptedBytes(encodedFrame);
+    workerLogger.debug('frameInfo for decoded frame', { ...frameInfo, ...this.logContext });
+
     // Construct frame trailer. Similar to the frame header described in
     // https://tools.ietf.org/html/draft-omara-sframe-00#section-4.2
     // but we put it at the end.
@@ -566,6 +591,7 @@ export class FrameCryptor extends BaseFrameCryptor {
     // @ts-expect-error payloadType is not yet part of the typescript definition and currently not supported in Safari
     const payloadType = frame.getMetadata().payloadType;
     const codec = payloadType ? this.rtpMap.get(payloadType) : undefined;
+    workerLogger.debug('reading codec from frame', { codec, ...this.logContext });
     return codec;
   }
 }

package/src/e2ee/worker/ParticipantKeyHandler.ts

@@ -133,15 +133,19 @@ export class ParticipantKeyHandler extends (EventEmitter as new () => TypedEvent
 
   /**
    * takes in a key material with `deriveBits` and `deriveKey` set as key usages
-   * and derives encryption keys from the material and sets it on the key ring buffer
+   * and derives encryption keys from the material and sets it on the key ring buffers
    * together with the material
    * also updates the currentKeyIndex
    */
-  async setKeyFromMaterial(material: CryptoKey, keyIndex = 0, emitRatchetEvent = false) {
-    const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : -1;
-    workerLogger.debug(`setting new key with index ${newIndex}`);
+  async setKeyFromMaterial(material: CryptoKey, keyIndex: number, emitRatchetEvent = false) {
     const keySet = await deriveKeys(material, this.keyProviderOptions.ratchetSalt);
-    this.setKeySet(keySet, newIndex >= 0 ? newIndex : this.currentKeyIndex, emitRatchetEvent);
+    const newIndex = keyIndex >= 0 ? keyIndex % this.cryptoKeyRing.length : this.currentKeyIndex;
+    workerLogger.debug(`setting new key with index ${keyIndex}`, {
+      usage: material.usages,
+      algorithm: material.algorithm,
+      ratchetSalt: this.keyProviderOptions.ratchetSalt,
+    });
+    this.setKeySet(keySet, newIndex, emitRatchetEvent);
     if (newIndex >= 0) this.currentKeyIndex = newIndex;
   }
 

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

@@ -21,8 +21,6 @@ let isEncryptionEnabled: boolean = false;
 
 let useSharedKey: boolean = false;
 
-let sharedKey: CryptoKey | undefined;
-
 let sifTrailer: Uint8Array | undefined;
 
 let keyProviderOptions: KeyProviderOptions = KEY_PROVIDER_DEFAULTS;
@@ -34,6 +32,7 @@ onmessage = (ev) => {
 
   switch (kind) {
     case 'init':
+      workerLogger.setLevel(data.loglevel);
       workerLogger.info('worker initialized');
       keyProviderOptions = data.keyProviderOptions;
       useSharedKey = !!data.keyProviderOptions.sharedKey;
@@ -72,10 +71,9 @@ onmessage = (ev) => {
       break;
     case 'setKey':
       if (useSharedKey) {
-        workerLogger.warn('set shared key');
         setSharedKey(data.key, data.keyIndex);
       } else if (data.participantIdentity) {
-        workerLogger.warn(
+        workerLogger.info(
           `set participant sender key ${data.participantIdentity} index ${data.keyIndex}`,
         );
         getParticipantKeyHandler(data.participantIdentity).setKey(data.key, data.keyIndex);
@@ -125,9 +123,7 @@ async function handleRatchetRequest(data: RatchetRequestMessage['data']) {
 }
 
 function getTrackCryptor(participantIdentity: string, trackId: string) {
-  let cryptor = participantCryptors.find(
-    (c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId,
-  );
+  let cryptor = participantCryptors.find((c) => c.getTrackId() === trackId);
   if (!cryptor) {
     workerLogger.info('creating new cryptor for', { participantIdentity });
     if (!keyProviderOptions) {
@@ -146,8 +142,7 @@ function getTrackCryptor(participantIdentity: string, trackId: string) {
     // assign new participant id to track cryptor and pass in correct key handler
     cryptor.setParticipant(participantIdentity, getParticipantKeyHandler(participantIdentity));
   }
-  if (sharedKey) {
-  }
+
   return cryptor;
 }
 
@@ -158,9 +153,6 @@ function getParticipantKeyHandler(participantIdentity: string) {
   let keys = participantKeys.get(participantIdentity);
   if (!keys) {
     keys = new ParticipantKeyHandler(participantIdentity, keyProviderOptions);
-    if (sharedKey) {
-      keys.setKey(sharedKey);
-    }
     keys.on(KeyHandlerEvent.KeyRatcheted, emitRatchetedKeys);
     participantKeys.set(participantIdentity, keys);
   }
@@ -169,24 +161,32 @@ function getParticipantKeyHandler(participantIdentity: string) {
 
 function getSharedKeyHandler() {
   if (!sharedKeyHandler) {
+    workerLogger.debug('creating new shared key handler');
     sharedKeyHandler = new ParticipantKeyHandler('shared-key', keyProviderOptions);
   }
   return sharedKeyHandler;
 }
 
 function unsetCryptorParticipant(trackId: string, participantIdentity: string) {
-  participantCryptors
-    .find((c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId)
-    ?.unsetParticipant();
+  const cryptor = participantCryptors.find(
+    (c) => c.getParticipantIdentity() === participantIdentity && c.getTrackId() === trackId,
+  );
+  if (!cryptor) {
+    workerLogger.warn('Could not unset participant on cryptor', { trackId, participantIdentity });
+  } else {
+    cryptor.unsetParticipant();
+  }
 }
 
 function setEncryptionEnabled(enable: boolean, participantIdentity: string) {
+  workerLogger.debug(`setting encryption enabled for all tracks of ${participantIdentity}`, {
+    enable,
+  });
   encryptionEnabledMap.set(participantIdentity, enable);
 }
 
 function setSharedKey(key: CryptoKey, index?: number) {
-  workerLogger.debug('setting shared key');
-  sharedKey = key;
+  workerLogger.info('set shared key', { index });
   getSharedKeyHandler().setKey(key, index);
 }
 

package/src/index.ts

@@ -1,4 +1,4 @@
-import { LogLevel, getLogger, setLogExtension, setLogLevel } from './logger';
+import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import { DataPacket_Kind, DisconnectReason } from './proto/livekit_models_pb';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import Room, { ConnectionState } from './room/Room';
@@ -55,6 +55,7 @@ export {
   supportsVP9,
   createAudioAnalyser,
   LogLevel,
+  LoggerNames,
   getLogger,
   Room,
   ConnectionState,

package/src/logger.ts

@@ -31,6 +31,8 @@ export type StructuredLogger = {
   warn: (msg: string, context?: object) => void;
   error: (msg: string, context?: object) => void;
   setDefaultLevel: (level: log.LogLevelDesc) => void;
+  setLevel: (level: log.LogLevelDesc) => void;
+  getLevel: () => number;
 };
 
 let livekitLogger = log.getLogger('livekit');

package/src/room/DeviceManager.ts

@@ -80,7 +80,16 @@ export default class DeviceManager {
     // device has been chosen
     const devices = await this.getDevices(kind);
 
-    const device = devices.find((d) => d.groupId === groupId && d.deviceId !== defaultId);
+    // `default` devices will have the same groupId as the entry with the actual device id so we store the counts for each group id
+    const groupIdCounts = new Map(devices.map((d) => [d.groupId, 0]));
+
+    devices.forEach((d) => groupIdCounts.set(d.groupId, (groupIdCounts.get(d.groupId) ?? 0) + 1));
+
+    const device = devices.find(
+      (d) =>
+        (groupId === d.groupId || (groupIdCounts.get(d.groupId) ?? 0) > 1) &&
+        d.deviceId !== defaultId,
+    );
 
     return device?.deviceId;
   }

package/src/room/RTCEngine.ts

@@ -418,6 +418,19 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           );
         }
       }
+
+      // detect cases where both signal client and peer connection are severed and assume that user has lost network connection
+      const isSignalSevered =
+        this.client.isDisconnected ||
+        this.client.currentState === SignalConnectionState.RECONNECTING;
+      const isPCSevered = [
+        PCTransportState.FAILED,
+        PCTransportState.CLOSING,
+        PCTransportState.CLOSED,
+      ].includes(connectionState);
+      if (isSignalSevered && isPCSevered && !this._isClosed) {
+        this.emit(EngineEvent.Offline);
+      }
     };
     this.pcManager.onTrack = (ev: RTCTrackEvent) => {
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
@@ -1400,4 +1413,5 @@ export type EngineEventCallbacks = {
   subscribedQualityUpdate: (update: SubscribedQualityUpdate) => void;
   localTrackUnpublished: (unpublishedResponse: TrackUnpublishedResponse) => void;
   remoteMute: (trackSid: string, muted: boolean) => void;
+  offline: () => void;
 };

package/src/room/Room.ts

@@ -60,6 +60,7 @@ import type RemoteTrack from './track/RemoteTrack';
 import RemoteTrackPublication from './track/RemoteTrackPublication';
 import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
+import type { TrackProcessor } from './track/processor/types';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext, sourceToKind } from './track/utils';
 import type { SimulationOptions, SimulationScenario } from './types';
@@ -348,6 +349,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
       .on(EngineEvent.SignalRestarted, this.handleSignalRestarted)
+      .on(EngineEvent.Offline, () => {
+        if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+          this.emit(RoomEvent.Reconnecting);
+        }
+      })
       .on(EngineEvent.DCBufferStatusChanged, (status, kind) => {
         this.emit(RoomEvent.DCBufferStatusChanged, status, kind);
       });
@@ -573,16 +579,23 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant.sid = pi.sid;
     this.localParticipant.identity = pi.identity;
 
+    if (this.options.e2ee && this.e2eeManager) {
+      try {
+        this.e2eeManager.setSifTrailer(joinResponse.sifTrailer);
+      } catch (e: any) {
+        this.log.error(e instanceof Error ? e.message : 'Could not set SifTrailer', {
+          ...this.logContext,
+          error: e,
+        });
+      }
+    }
+
     // populate remote participants, these should not trigger new events
     this.handleParticipantUpdates([pi, ...joinResponse.otherParticipants]);
 
     if (joinResponse.room) {
       this.handleRoomUpdate(joinResponse.room);
     }
-
-    if (this.options.e2ee && this.e2eeManager) {
-      this.e2eeManager.setSifTrailer(joinResponse.sifTrailer);
-    }
   };
 
   private attemptConnection = async (
@@ -857,6 +870,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private onPageLeave = async () => {
+    this.log.info('Page leave detected, disconnecting', this.logContext);
     await this.disconnect();
   };
 
@@ -1034,6 +1048,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       ) {
         throw new Error('cannot switch audio output, setSinkId not supported');
       }
+      if (this.options.webAudioMix) {
+        // setting `default` for web audio output doesn't work, so we need to normalize the id before
+        deviceId =
+          (await DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) ?? '';
+      }
       this.options.audioOutput ??= {};
       const prevDeviceId = this.options.audioOutput.deviceId;
       this.options.audioOutput.deviceId = deviceId;
@@ -1775,7 +1794,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.TrackUnmuted, pub, this.localParticipant);
   };
 
+  private onTrackProcessorUpdate = (processor?: TrackProcessor<Track.Kind, any>) => {
+    processor?.onPublish?.(this);
+  };
+
   private onLocalTrackPublished = async (pub: LocalTrackPublication) => {
+    pub.track?.on(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
     pub.track?.getProcessor()?.onPublish?.(this);
 
     this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
@@ -1799,6 +1823,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private onLocalTrackUnpublished = (pub: LocalTrackPublication) => {
+    pub.track?.off(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
     this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
   };
 

package/src/room/events.ts

@@ -491,6 +491,7 @@ export enum EngineEvent {
   RemoteMute = 'remoteMute',
   SubscribedQualityUpdate = 'subscribedQualityUpdate',
   LocalTrackUnpublished = 'localTrackUnpublished',
+  Offline = 'offline',
 }
 
 export enum TrackEvent {
@@ -552,4 +553,8 @@ export enum TrackEvent {
    * Fires on RemoteTrackPublication
    */
   SubscriptionFailed = 'subscriptionFailed',
+  /**
+   * @internal
+   */
+  TrackProcessorUpdate = 'trackProcessorUpdate',
 }

package/src/room/participant/LocalParticipant.ts

@@ -513,6 +513,10 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     options?: TrackPublishOptions,
   ): Promise<LocalTrackPublication> {
+    if (track instanceof LocalAudioTrack) {
+      track.setAudioContext(this.audioContext);
+    }
+
     await this.reconnectFuture?.promise;
     if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
@@ -566,10 +570,6 @@ export default class LocalParticipant extends Participant {
       });
     }
 
-    if (track instanceof LocalAudioTrack) {
-      track.setAudioContext(this.audioContext);
-    }
-
     // is it already published? if so skip
     let existingPublication: LocalTrackPublication | undefined;
     this.trackPublications.forEach((publication) => {

package/src/room/track/LocalAudioTrack.ts

@@ -51,6 +51,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async mute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (this.isMuted) {
+        this.log.debug('Track already muted', this.logContext);
+        return this;
+      }
+
       // disabled special handling as it will cause BT headsets to switch communication modes
       if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
         this.log.debug('stopping mic track', this.logContext);
@@ -67,6 +72,11 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async unmute(): Promise<typeof this> {
     const unlock = await this.muteLock.lock();
     try {
+      if (!this.isMuted) {
+        this.log.debug('Track already unmuted', this.logContext);
+        return this;
+      }
+
       const deviceHasChanged =
         this._constraints.deviceId &&
         this._mediaStreamTrack.getSettings().deviceId !==
@@ -163,6 +173,7 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
       if (this.processor.processedTrack) {
         await this.sender?.replaceTrack(this.processor.processedTrack);
       }
+      this.emit(TrackEvent.TrackProcessorUpdate, this.processor);
     } finally {
       unlock();
     }