livekit-client 1.12.2 → 1.12.3

package/dist/livekit-client.esm.mjs

@@ -11823,7 +11823,7 @@ function getMatch(exp, ua) {
   return match && match.length >= id && match[id] || '';
 }
 
-var version$1 = "1.12.2";
+var version$1 = "1.12.3";
 
 const version = version$1;
 const protocolVersion = 9;
@@ -11880,11 +11880,11 @@ var AudioPresets;
  * Sane presets for video resolution/encoding
  */
 const VideoPresets = {
-  h90: new VideoPreset(160, 90, 60000, 15),
-  h180: new VideoPreset(320, 180, 120000, 15),
-  h216: new VideoPreset(384, 216, 180000, 15),
-  h360: new VideoPreset(640, 360, 300000, 20),
-  h540: new VideoPreset(960, 540, 600000, 25),
+  h90: new VideoPreset(160, 90, 90000, 20),
+  h180: new VideoPreset(320, 180, 160000, 20),
+  h216: new VideoPreset(384, 216, 180000, 20),
+  h360: new VideoPreset(640, 360, 450000, 20),
+  h540: new VideoPreset(960, 540, 800000, 25),
   h720: new VideoPreset(1280, 720, 1700000, 30),
   h1080: new VideoPreset(1920, 1080, 3000000, 30),
   h1440: new VideoPreset(2560, 1440, 5000000, 30),
@@ -11894,22 +11894,23 @@ const VideoPresets = {
  * Four by three presets
  */
 const VideoPresets43 = {
-  h120: new VideoPreset(160, 120, 80000, 15),
-  h180: new VideoPreset(240, 180, 100000, 15),
-  h240: new VideoPreset(320, 240, 150000, 15),
+  h120: new VideoPreset(160, 120, 70000, 20),
+  h180: new VideoPreset(240, 180, 125000, 20),
+  h240: new VideoPreset(320, 240, 140000, 20),
   h360: new VideoPreset(480, 360, 225000, 20),
-  h480: new VideoPreset(640, 480, 300000, 20),
-  h540: new VideoPreset(720, 540, 450000, 25),
-  h720: new VideoPreset(960, 720, 1500000, 30),
-  h1080: new VideoPreset(1440, 1080, 2500000, 30),
-  h1440: new VideoPreset(1920, 1440, 3500000, 30)
+  h480: new VideoPreset(640, 480, 500000, 20),
+  h540: new VideoPreset(720, 540, 600000, 25),
+  h720: new VideoPreset(960, 720, 1300000, 30),
+  h1080: new VideoPreset(1440, 1080, 2300000, 30),
+  h1440: new VideoPreset(1920, 1440, 3800000, 30)
 };
 const ScreenSharePresets = {
   h360fps3: new VideoPreset(640, 360, 200000, 3, 'medium'),
   h720fps5: new VideoPreset(1280, 720, 400000, 5, 'medium'),
-  h720fps15: new VideoPreset(1280, 720, 1000000, 15, 'medium'),
-  h1080fps15: new VideoPreset(1920, 1080, 1500000, 15, 'medium'),
-  h1080fps30: new VideoPreset(1920, 1080, 3000000, 30, 'medium')
+  h720fps15: new VideoPreset(1280, 720, 1500000, 15, 'medium'),
+  h720fps30: new VideoPreset(1280, 720, 2000000, 30, 'medium'),
+  h1080fps15: new VideoPreset(1920, 1080, 2500000, 15, 'medium'),
+  h1080fps30: new VideoPreset(1920, 1080, 4000000, 30, 'medium')
 };
 
 /**
@@ -16029,13 +16030,13 @@ class RTCEngine extends eventsExports.EventEmitter {
     this.handleDataError = event => {
       const channel = event.currentTarget;
       const channelKind = channel.maxRetransmits === 0 ? 'lossy' : 'reliable';
-      if (event instanceof ErrorEvent) {
+      if (event instanceof ErrorEvent && event.error) {
         const {
           error
         } = event.error;
         livekitLogger.error("DataChannel error on ".concat(channelKind, ": ").concat(event.message), error);
       } else {
-        livekitLogger.error("Unknown DataChannel Error on ".concat(channelKind), event);
+        livekitLogger.error("Unknown DataChannel error on ".concat(channelKind), event);
       }
     };
     this.handleBufferedAmountLow = event => {
@@ -16423,13 +16424,13 @@ class RTCEngine extends eventsExports.EventEmitter {
     });
     this.client.onLocalTrackPublished = res => {
       livekitLogger.debug('received trackPublishedResponse', res);
-      const {
-        resolve
-      } = this.pendingTrackResolvers[res.cid];
-      if (!resolve) {
+      if (!this.pendingTrackResolvers[res.cid]) {
         livekitLogger.error("missing track resolver for ".concat(res.cid));
         return;
       }
+      const {
+        resolve
+      } = this.pendingTrackResolvers[res.cid];
       delete this.pendingTrackResolvers[res.cid];
       resolve(res.track);
     };
@@ -17312,251 +17313,551 @@ class LocalAudioTrack extends LocalTrack {
   }
 }
 
-const refreshSubscribedCodecAfterNewCodec = 5000;
-class LocalVideoTrack extends LocalTrack {
-  /**
-   *
-   * @param mediaTrack
-   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
-   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
-   */
-  constructor(mediaTrack, constraints) {
-    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
-    /* @internal */
-    this.simulcastCodecs = new Map();
-    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
-      if (!this.sender) {
-        this._currentBitrate = 0;
-        return;
-      }
-      let stats;
-      try {
-        stats = yield this.getSenderStats();
-      } catch (e) {
-        livekitLogger.error('could not get audio sender stats', {
-          error: e
-        });
-        return;
-      }
-      const statsMap = new Map(stats.map(s => [s.rid, s]));
-      if (this.prevStats) {
-        let totalBitrate = 0;
-        statsMap.forEach((s, key) => {
-          var _a;
-          const prev = (_a = this.prevStats) === null || _a === void 0 ? void 0 : _a.get(key);
-          totalBitrate += computeBitrate(s, prev);
-        });
-        this._currentBitrate = totalBitrate;
-      }
-      this.prevStats = statsMap;
-    });
-    this.senderLock = new Mutex();
+/** @internal */
+function mediaTrackToLocalTrack(mediaStreamTrack, constraints) {
+  switch (mediaStreamTrack.kind) {
+    case 'audio':
+      return new LocalAudioTrack(mediaStreamTrack, constraints, false);
+    case 'video':
+      return new LocalVideoTrack(mediaStreamTrack, constraints, false);
+    default:
+      throw new TrackInvalidError("unsupported track type: ".concat(mediaStreamTrack.kind));
   }
-  get isSimulcast() {
-    if (this.sender && this.sender.getParameters().encodings.length > 1) {
-      return true;
+}
+/* @internal */
+const presets169 = Object.values(VideoPresets);
+/* @internal */
+const presets43 = Object.values(VideoPresets43);
+/* @internal */
+const presetsScreenShare = Object.values(ScreenSharePresets);
+/* @internal */
+const defaultSimulcastPresets169 = [VideoPresets.h180, VideoPresets.h360];
+/* @internal */
+const defaultSimulcastPresets43 = [VideoPresets43.h180, VideoPresets43.h360];
+/* @internal */
+const computeDefaultScreenShareSimulcastPresets = fromPreset => {
+  const layers = [{
+    scaleResolutionDownBy: 2,
+    fps: 3
+  }];
+  return layers.map(t => {
+    var _a;
+    return new VideoPreset(Math.floor(fromPreset.width / t.scaleResolutionDownBy), Math.floor(fromPreset.height / t.scaleResolutionDownBy), Math.max(150000, Math.floor(fromPreset.encoding.maxBitrate / (Math.pow(t.scaleResolutionDownBy, 2) * (((_a = fromPreset.encoding.maxFramerate) !== null && _a !== void 0 ? _a : 30) / t.fps)))), t.fps, fromPreset.encoding.priority);
+  });
+};
+// /**
+//  *
+//  * @internal
+//  * @experimental
+//  */
+// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
+//   // use vp8 as a default
+//   const vp8 = determineAppropriateEncoding(false, width, height);
+//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
+//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
+//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
+//   return {
+//     vp8,
+//     vp9,
+//     h264,
+//     av1,
+//   };
+// };
+const videoRids = ['q', 'h', 'f'];
+/* @internal */
+function computeVideoEncodings(isScreenShare, width, height, options) {
+  var _a, _b;
+  let videoEncoding = options === null || options === void 0 ? void 0 : options.videoEncoding;
+  if (isScreenShare) {
+    videoEncoding = options === null || options === void 0 ? void 0 : options.screenShareEncoding;
+  }
+  const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
+  const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
+  const videoCodec = options === null || options === void 0 ? void 0 : options.videoCodec;
+  if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
+    // when we aren't simulcasting or svc, will need to return a single encoding without
+    // capping bandwidth. we always require a encoding for dynacast
+    return [{}];
+  }
+  if (!videoEncoding) {
+    // find the right encoding based on width/height
+    videoEncoding = determineAppropriateEncoding(isScreenShare, width, height, videoCodec);
+    livekitLogger.debug('using video encoding', videoEncoding);
+  }
+  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate, videoEncoding.priority);
+  if (scalabilityMode && isSVCCodec(videoCodec)) {
+    livekitLogger.debug("using svc with scalabilityMode ".concat(scalabilityMode));
+    const sm = new ScalabilityMode(scalabilityMode);
+    const encodings = [];
+    if (sm.spatial > 3) {
+      throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
     }
-    return false;
+    for (let i = 0; i < sm.spatial; i += 1) {
+      encodings.push({
+        rid: videoRids[2 - i],
+        maxBitrate: videoEncoding.maxBitrate / Math.pow(3, i),
+        /* @ts-ignore */
+        maxFramerate: original.encoding.maxFramerate
+      });
+    }
+    /* @ts-ignore */
+    encodings[0].scalabilityMode = scalabilityMode;
+    livekitLogger.debug('encodings', encodings);
+    return encodings;
   }
-  /* @internal */
-  startMonitor(signalClient) {
-    var _a;
-    this.signalClient = signalClient;
-    if (!isWeb()) {
-      return;
+  if (!useSimulcast) {
+    return [videoEncoding];
+  }
+  let presets = [];
+  if (isScreenShare) {
+    presets = (_a = sortPresets(options === null || options === void 0 ? void 0 : options.screenShareSimulcastLayers)) !== null && _a !== void 0 ? _a : defaultSimulcastLayers(isScreenShare, original);
+  } else {
+    presets = (_b = sortPresets(options === null || options === void 0 ? void 0 : options.videoSimulcastLayers)) !== null && _b !== void 0 ? _b : defaultSimulcastLayers(isScreenShare, original);
+  }
+  let midPreset;
+  if (presets.length > 0) {
+    const lowPreset = presets[0];
+    if (presets.length > 1) {
+      [, midPreset] = presets;
     }
-    // save original encodings
-    // TODO : merge simulcast tracks stats
-    const params = (_a = this.sender) === null || _a === void 0 ? void 0 : _a.getParameters();
-    if (params) {
-      this.encodings = params.encodings;
+    // NOTE:
+    //   1. Ordering of these encodings is important. Chrome seems
+    //      to use the index into encodings to decide which layer
+    //      to disable when CPU constrained.
+    //      So encodings should be ordered in increasing spatial
+    //      resolution order.
+    //   2. ion-sfu translates rids into layers. So, all encodings
+    //      should have the base layer `q` and then more added
+    //      based on other conditions.
+    const size = Math.max(width, height);
+    if (size >= 960 && midPreset) {
+      return encodingsFromPresets(width, height, [lowPreset, midPreset, original]);
     }
-    if (this.monitorInterval) {
-      return;
+    if (size >= 480) {
+      return encodingsFromPresets(width, height, [lowPreset, original]);
     }
-    this.monitorInterval = setInterval(() => {
-      this.monitorSender();
-    }, monitorFrequency);
-  }
-  stop() {
-    this._mediaStreamTrack.getConstraints();
-    this.simulcastCodecs.forEach(trackInfo => {
-      trackInfo.mediaStreamTrack.stop();
-    });
-    super.stop();
   }
-  mute() {
-    const _super = Object.create(null, {
-      mute: {
-        get: () => super.mute
-      }
-    });
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
-      try {
-        if (this.source === Track.Source.Camera && !this.isUserProvided) {
-          livekitLogger.debug('stopping camera track');
-          // also stop the track, so that camera indicator is turned off
-          this._mediaStreamTrack.stop();
-        }
-        yield _super.mute.call(this);
-        return this;
-      } finally {
-        unlock();
-      }
-    });
+  return encodingsFromPresets(width, height, [original]);
+}
+function computeTrackBackupEncodings(track, videoCodec, opts) {
+  var _a, _b, _c, _d;
+  if (!opts.backupCodec || opts.backupCodec.codec === opts.videoCodec) {
+    // backup codec publishing is disabled
+    return;
   }
-  unmute() {
-    const _super = Object.create(null, {
-      unmute: {
-        get: () => super.unmute
-      }
-    });
-    return __awaiter(this, void 0, void 0, function* () {
-      const unlock = yield this.muteLock.lock();
-      try {
-        if (this.source === Track.Source.Camera && !this.isUserProvided) {
-          livekitLogger.debug('reacquiring camera track');
-          yield this.restartTrack();
-        }
-        yield _super.unmute.call(this);
-        return this;
-      } finally {
-        unlock();
-      }
+  if (videoCodec !== opts.backupCodec.codec) {
+    livekitLogger.warn('requested a different codec than specified as backup', {
+      serverRequested: videoCodec,
+      backup: opts.backupCodec.codec
     });
   }
-  getSenderStats() {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
-        return [];
-      }
-      const items = [];
-      const stats = yield this.sender.getStats();
-      stats.forEach(v => {
-        var _a;
-        if (v.type === 'outbound-rtp') {
-          const vs = {
-            type: 'video',
-            streamId: v.id,
-            frameHeight: v.frameHeight,
-            frameWidth: v.frameWidth,
-            firCount: v.firCount,
-            pliCount: v.pliCount,
-            nackCount: v.nackCount,
-            packetsSent: v.packetsSent,
-            bytesSent: v.bytesSent,
-            framesSent: v.framesSent,
-            timestamp: v.timestamp,
-            rid: (_a = v.rid) !== null && _a !== void 0 ? _a : v.id,
-            retransmittedPacketsSent: v.retransmittedPacketsSent,
-            qualityLimitationReason: v.qualityLimitationReason,
-            qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges
-          };
-          // locate the appropriate remote-inbound-rtp item
-          const r = stats.get(v.remoteId);
-          if (r) {
-            vs.jitter = r.jitter;
-            vs.packetsLost = r.packetsLost;
-            vs.roundTripTime = r.roundTripTime;
-          }
-          items.push(vs);
-        }
-      });
-      return items;
-    });
+  opts.videoCodec = videoCodec;
+  // use backup encoding setting as videoEncoding for backup codec publishing
+  opts.videoEncoding = opts.backupCodec.encoding;
+  const settings = track.mediaStreamTrack.getSettings();
+  const width = (_a = settings.width) !== null && _a !== void 0 ? _a : (_b = track.dimensions) === null || _b === void 0 ? void 0 : _b.width;
+  const height = (_c = settings.height) !== null && _c !== void 0 ? _c : (_d = track.dimensions) === null || _d === void 0 ? void 0 : _d.height;
+  const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
+  return encodings;
+}
+/* @internal */
+function determineAppropriateEncoding(isScreenShare, width, height, codec) {
+  const presets = presetsForResolution(isScreenShare, width, height);
+  let {
+    encoding
+  } = presets[0];
+  // handle portrait by swapping dimensions
+  const size = Math.max(width, height);
+  for (let i = 0; i < presets.length; i += 1) {
+    const preset = presets[i];
+    encoding = preset.encoding;
+    if (preset.width >= size) {
+      break;
+    }
   }
-  setPublishingQuality(maxQuality) {
-    const qualities = [];
-    for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
-      qualities.push(new SubscribedQuality({
-        quality: q,
-        enabled: q <= maxQuality
-      }));
+  // presets are based on the assumption of vp8 as a codec
+  // for other codecs we adjust the maxBitrate if no specific videoEncoding has been provided
+  // users should override these with ones that are optimized for their use case
+  // NOTE: SVC codec bitrates are inclusive of all scalability layers. while
+  // bitrate for non-SVC codecs does not include other simulcast layers.
+  if (codec) {
+    switch (codec) {
+      case 'av1':
+        encoding = Object.assign({}, encoding);
+        encoding.maxBitrate = encoding.maxBitrate * 0.7;
+        break;
+      case 'vp9':
+        encoding = Object.assign({}, encoding);
+        encoding.maxBitrate = encoding.maxBitrate * 0.85;
+        break;
     }
-    livekitLogger.debug("setting publishing quality. max quality ".concat(maxQuality));
-    this.setPublishingLayers(qualities);
   }
-  setDeviceId(deviceId) {
-    return __awaiter(this, void 0, void 0, function* () {
-      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
-        return true;
-      }
-      this._constraints.deviceId = deviceId;
-      // when video is muted, underlying media stream track is stopped and
-      // will be restarted later
-      if (!this.isMuted) {
-        yield this.restartTrack();
+  return encoding;
+}
+/* @internal */
+function presetsForResolution(isScreenShare, width, height) {
+  if (isScreenShare) {
+    return presetsScreenShare;
+  }
+  const aspect = width > height ? width / height : height / width;
+  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
+    return presets169;
+  }
+  return presets43;
+}
+/* @internal */
+function defaultSimulcastLayers(isScreenShare, original) {
+  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, height, presets) {
+  const encodings = [];
+  presets.forEach((preset, idx) => {
+    if (idx >= videoRids.length) {
+      return;
+    }
+    const size = Math.min(width, height);
+    const rid = videoRids[idx];
+    const encoding = {
+      rid,
+      scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
+      maxBitrate: preset.encoding.maxBitrate
+    };
+    if (preset.encoding.maxFramerate) {
+      encoding.maxFramerate = preset.encoding.maxFramerate;
+    }
+    const canSetPriority = isFireFox() || idx === 0;
+    if (preset.encoding.priority && canSetPriority) {
+      encoding.priority = preset.encoding.priority;
+      encoding.networkPriority = preset.encoding.priority;
+    }
+    encodings.push(encoding);
+  });
+  // RN ios simulcast requires all same framerates.
+  if (isReactNative() && getReactNativeOs() === 'ios') {
+    let topFramerate = undefined;
+    encodings.forEach(encoding => {
+      if (!topFramerate) {
+        topFramerate = encoding.maxFramerate;
+      } else if (encoding.maxFramerate && encoding.maxFramerate > topFramerate) {
+        topFramerate = encoding.maxFramerate;
       }
-      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
     });
-  }
-  restartTrack(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-      let constraints;
-      if (options) {
-        const streamConstraints = constraintsForOptions({
-          video: options
-        });
-        if (typeof streamConstraints.video !== 'boolean') {
-          constraints = streamConstraints.video;
+    let notifyOnce = true;
+    encodings.forEach(encoding => {
+      var _a;
+      if (encoding.maxFramerate != topFramerate) {
+        if (notifyOnce) {
+          notifyOnce = false;
+          livekitLogger.info("Simulcast on iOS React-Native requires all encodings to share the same framerate.");
         }
+        livekitLogger.info("Setting framerate of encoding \"".concat((_a = encoding.rid) !== null && _a !== void 0 ? _a : '', "\" to ").concat(topFramerate));
+        encoding.maxFramerate = topFramerate;
       }
-      yield this.restart(constraints);
     });
   }
-  addSimulcastTrack(codec, encodings) {
-    if (this.simulcastCodecs.has(codec)) {
-      throw new Error("".concat(codec, " already added"));
+  return encodings;
+}
+/** @internal */
+function sortPresets(presets) {
+  if (!presets) return;
+  return presets.sort((a, b) => {
+    const {
+      encoding: aEnc
+    } = a;
+    const {
+      encoding: bEnc
+    } = b;
+    if (aEnc.maxBitrate > bEnc.maxBitrate) {
+      return 1;
     }
-    const simulcastCodecInfo = {
-      codec,
-      mediaStreamTrack: this.mediaStreamTrack.clone(),
-      sender: undefined,
-      encodings
-    };
-    this.simulcastCodecs.set(codec, simulcastCodecInfo);
-    return simulcastCodecInfo;
-  }
-  setSimulcastTrackSender(codec, sender) {
-    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
-    if (!simulcastCodecInfo) {
-      return;
+    if (aEnc.maxBitrate < bEnc.maxBitrate) return -1;
+    if (aEnc.maxBitrate === bEnc.maxBitrate && aEnc.maxFramerate && bEnc.maxFramerate) {
+      return aEnc.maxFramerate > bEnc.maxFramerate ? 1 : -1;
     }
-    simulcastCodecInfo.sender = sender;
-    // browser will reenable disabled codec/layers after new codec has been published,
-    // so refresh subscribedCodecs after publish a new codec
-    setTimeout(() => {
-      if (this.subscribedCodecs) {
-        this.setPublishingCodecs(this.subscribedCodecs);
+    return 0;
+  });
+}
+/** @internal */
+class ScalabilityMode {
+  constructor(scalabilityMode) {
+    const results = scalabilityMode.match(/^L(\d)T(\d)(h|_KEY|_KEY_SHIFT){0,1}$/);
+    if (!results) {
+      throw new Error('invalid scalability mode');
+    }
+    this.spatial = parseInt(results[1]);
+    this.temporal = parseInt(results[2]);
+    if (results.length > 3) {
+      switch (results[3]) {
+        case 'h':
+        case '_KEY':
+        case '_KEY_SHIFT':
+          this.suffix = results[3];
       }
-    }, refreshSubscribedCodecAfterNewCodec);
+    }
+  }
+  toString() {
+    var _a;
+    return "L".concat(this.spatial, "T").concat(this.temporal).concat((_a = this.suffix) !== null && _a !== void 0 ? _a : '');
   }
+}
+
+const refreshSubscribedCodecAfterNewCodec = 5000;
+class LocalVideoTrack extends LocalTrack {
   /**
-   * @internal
-   * Sets codecs that should be publishing
+   *
+   * @param mediaTrack
+   * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
+   * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
    */
-  setPublishingCodecs(codecs) {
-    var _a, codecs_1, codecs_1_1;
-    var _b, e_1, _c, _d;
-    return __awaiter(this, void 0, void 0, function* () {
-      livekitLogger.debug('setting publishing codecs', {
-        codecs,
-        currentCodec: this.codec
-      });
-      // only enable simulcast codec for preference codec setted
-      if (!this.codec && codecs.length > 0) {
-        yield this.setPublishingLayers(codecs[0].qualities);
-        return [];
+  constructor(mediaTrack, constraints) {
+    let userProvidedTrack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
+    /* @internal */
+    this.simulcastCodecs = new Map();
+    this.monitorSender = () => __awaiter(this, void 0, void 0, function* () {
+      if (!this.sender) {
+        this._currentBitrate = 0;
+        return;
       }
-      this.subscribedCodecs = codecs;
-      const newCodecs = [];
+      let stats;
       try {
-        for (_a = true, codecs_1 = __asyncValues(codecs); codecs_1_1 = yield codecs_1.next(), _b = codecs_1_1.done, !_b; _a = true) {
-          _d = codecs_1_1.value;
-          _a = false;
+        stats = yield this.getSenderStats();
+      } catch (e) {
+        livekitLogger.error('could not get audio sender stats', {
+          error: e
+        });
+        return;
+      }
+      const statsMap = new Map(stats.map(s => [s.rid, s]));
+      if (this.prevStats) {
+        let totalBitrate = 0;
+        statsMap.forEach((s, key) => {
+          var _a;
+          const prev = (_a = this.prevStats) === null || _a === void 0 ? void 0 : _a.get(key);
+          totalBitrate += computeBitrate(s, prev);
+        });
+        this._currentBitrate = totalBitrate;
+      }
+      this.prevStats = statsMap;
+    });
+    this.senderLock = new Mutex();
+  }
+  get isSimulcast() {
+    if (this.sender && this.sender.getParameters().encodings.length > 1) {
+      return true;
+    }
+    return false;
+  }
+  /* @internal */
+  startMonitor(signalClient) {
+    var _a;
+    this.signalClient = signalClient;
+    if (!isWeb()) {
+      return;
+    }
+    // save original encodings
+    // TODO : merge simulcast tracks stats
+    const params = (_a = this.sender) === null || _a === void 0 ? void 0 : _a.getParameters();
+    if (params) {
+      this.encodings = params.encodings;
+    }
+    if (this.monitorInterval) {
+      return;
+    }
+    this.monitorInterval = setInterval(() => {
+      this.monitorSender();
+    }, monitorFrequency);
+  }
+  stop() {
+    this._mediaStreamTrack.getConstraints();
+    this.simulcastCodecs.forEach(trackInfo => {
+      trackInfo.mediaStreamTrack.stop();
+    });
+    super.stop();
+  }
+  mute() {
+    const _super = Object.create(null, {
+      mute: {
+        get: () => super.mute
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.muteLock.lock();
+      try {
+        if (this.source === Track.Source.Camera && !this.isUserProvided) {
+          livekitLogger.debug('stopping camera track');
+          // also stop the track, so that camera indicator is turned off
+          this._mediaStreamTrack.stop();
+        }
+        yield _super.mute.call(this);
+        return this;
+      } finally {
+        unlock();
+      }
+    });
+  }
+  unmute() {
+    const _super = Object.create(null, {
+      unmute: {
+        get: () => super.unmute
+      }
+    });
+    return __awaiter(this, void 0, void 0, function* () {
+      const unlock = yield this.muteLock.lock();
+      try {
+        if (this.source === Track.Source.Camera && !this.isUserProvided) {
+          livekitLogger.debug('reacquiring camera track');
+          yield this.restartTrack();
+        }
+        yield _super.unmute.call(this);
+        return this;
+      } finally {
+        unlock();
+      }
+    });
+  }
+  getSenderStats() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!((_a = this.sender) === null || _a === void 0 ? void 0 : _a.getStats)) {
+        return [];
+      }
+      const items = [];
+      const stats = yield this.sender.getStats();
+      stats.forEach(v => {
+        var _a;
+        if (v.type === 'outbound-rtp') {
+          const vs = {
+            type: 'video',
+            streamId: v.id,
+            frameHeight: v.frameHeight,
+            frameWidth: v.frameWidth,
+            firCount: v.firCount,
+            pliCount: v.pliCount,
+            nackCount: v.nackCount,
+            packetsSent: v.packetsSent,
+            bytesSent: v.bytesSent,
+            framesSent: v.framesSent,
+            timestamp: v.timestamp,
+            rid: (_a = v.rid) !== null && _a !== void 0 ? _a : v.id,
+            retransmittedPacketsSent: v.retransmittedPacketsSent,
+            qualityLimitationReason: v.qualityLimitationReason,
+            qualityLimitationResolutionChanges: v.qualityLimitationResolutionChanges
+          };
+          // locate the appropriate remote-inbound-rtp item
+          const r = stats.get(v.remoteId);
+          if (r) {
+            vs.jitter = r.jitter;
+            vs.packetsLost = r.packetsLost;
+            vs.roundTripTime = r.roundTripTime;
+          }
+          items.push(vs);
+        }
+      });
+      return items;
+    });
+  }
+  setPublishingQuality(maxQuality) {
+    const qualities = [];
+    for (let q = VideoQuality.LOW; q <= VideoQuality.HIGH; q += 1) {
+      qualities.push(new SubscribedQuality({
+        quality: q,
+        enabled: q <= maxQuality
+      }));
+    }
+    livekitLogger.debug("setting publishing quality. max quality ".concat(maxQuality));
+    this.setPublishingLayers(qualities);
+  }
+  setDeviceId(deviceId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this._constraints.deviceId === deviceId && this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)) {
+        return true;
+      }
+      this._constraints.deviceId = deviceId;
+      // when video is muted, underlying media stream track is stopped and
+      // will be restarted later
+      if (!this.isMuted) {
+        yield this.restartTrack();
+      }
+      return this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
+    });
+  }
+  restartTrack(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      let constraints;
+      if (options) {
+        const streamConstraints = constraintsForOptions({
+          video: options
+        });
+        if (typeof streamConstraints.video !== 'boolean') {
+          constraints = streamConstraints.video;
+        }
+      }
+      yield this.restart(constraints);
+    });
+  }
+  addSimulcastTrack(codec, encodings) {
+    if (this.simulcastCodecs.has(codec)) {
+      throw new Error("".concat(codec, " already added"));
+    }
+    const simulcastCodecInfo = {
+      codec,
+      mediaStreamTrack: this.mediaStreamTrack.clone(),
+      sender: undefined,
+      encodings
+    };
+    this.simulcastCodecs.set(codec, simulcastCodecInfo);
+    return simulcastCodecInfo;
+  }
+  setSimulcastTrackSender(codec, sender) {
+    const simulcastCodecInfo = this.simulcastCodecs.get(codec);
+    if (!simulcastCodecInfo) {
+      return;
+    }
+    simulcastCodecInfo.sender = sender;
+    // browser will reenable disabled codec/layers after new codec has been published,
+    // so refresh subscribedCodecs after publish a new codec
+    setTimeout(() => {
+      if (this.subscribedCodecs) {
+        this.setPublishingCodecs(this.subscribedCodecs);
+      }
+    }, refreshSubscribedCodecAfterNewCodec);
+  }
+  /**
+   * @internal
+   * Sets codecs that should be publishing
+   */
+  setPublishingCodecs(codecs) {
+    var _a, codecs_1, codecs_1_1;
+    var _b, e_1, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+      livekitLogger.debug('setting publishing codecs', {
+        codecs,
+        currentCodec: this.codec
+      });
+      // only enable simulcast codec for preference codec setted
+      if (!this.codec && codecs.length > 0) {
+        yield this.setPublishingLayers(codecs[0].qualities);
+        return [];
+      }
+      this.subscribedCodecs = codecs;
+      const newCodecs = [];
+      try {
+        for (_a = true, codecs_1 = __asyncValues(codecs); codecs_1_1 = yield codecs_1.next(), _b = codecs_1_1.done, !_b; _a = true) {
+          _d = codecs_1_1.value;
+          _a = false;
           const codec = _d;
           if (!this.codec || this.codec === codec.codec) {
             yield this.setPublishingLayers(codec.qualities);
@@ -17716,14 +18017,15 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
   if (svc) {
     // svc layers
     /* @ts-ignore */
-    const sm = new ScalabilityMode(encodings[0].scalabilityMode);
+    const encodingSM = encodings[0].scalabilityMode;
+    const sm = new ScalabilityMode(encodingSM);
     const layers = [];
     for (let i = 0; i < sm.spatial; i += 1) {
       layers.push(new VideoLayer({
         quality: VideoQuality.HIGH - i,
-        width: width / Math.pow(2, i),
-        height: height / Math.pow(2, i),
-        bitrate: encodings[0].maxBitrate ? encodings[0].maxBitrate / Math.pow(3, i) : 0,
+        width: Math.ceil(width / Math.pow(2, i)),
+        height: Math.ceil(height / Math.pow(2, i)),
+        bitrate: encodings[0].maxBitrate ? Math.ceil(encodings[0].maxBitrate / Math.pow(3, i)) : 0,
         ssrc: 0
       }));
     }
@@ -17735,8 +18037,8 @@ function videoLayersFromEncodings(width, height, encodings, svc) {
     let quality = videoQualityForRid((_b = encoding.rid) !== null && _b !== void 0 ? _b : '');
     return new VideoLayer({
       quality,
-      width: width / scale,
-      height: height / scale,
+      width: Math.ceil(width / scale),
+      height: Math.ceil(height / scale),
       bitrate: (_c = encoding.maxBitrate) !== null && _c !== void 0 ? _c : 0,
       ssrc: 0
     });
@@ -19016,458 +19318,160 @@ class RemoteParticipant extends Participant {
       }, 150);
       return;
     }
-    if (mediaTrack.readyState === 'ended') {
-      livekitLogger.error('unable to subscribe because MediaStreamTrack is ended. Do not call MediaStreamTrack.stop()', {
-        participant: this.sid,
-        trackSid: sid
-      });
-      this.emit(ParticipantEvent.TrackSubscriptionFailed, sid);
-      return;
-    }
-    const isVideo = mediaTrack.kind === 'video';
-    let track;
-    if (isVideo) {
-      track = new RemoteVideoTrack(mediaTrack, sid, receiver, adaptiveStreamSettings);
-    } else {
-      track = new RemoteAudioTrack(mediaTrack, sid, receiver, this.audioContext, this.audioOutput);
-    }
-    // set track info
-    track.source = publication.source;
-    // keep publication's muted status
-    track.isMuted = publication.isMuted;
-    track.setMediaStream(mediaStream);
-    track.start();
-    publication.setTrack(track);
-    // set participant volumes on new audio tracks
-    if (this.volumeMap.has(publication.source) && track instanceof RemoteAudioTrack) {
-      track.setVolume(this.volumeMap.get(publication.source));
-    }
-    return publication;
-  }
-  /** @internal */
-  get hasMetadata() {
-    return !!this.participantInfo;
-  }
-  getTrackPublication(sid) {
-    return this.tracks.get(sid);
-  }
-  /** @internal */
-  updateInfo(info) {
-    if (!super.updateInfo(info)) {
-      return false;
-    }
-    // we are getting a list of all available tracks, reconcile in here
-    // and send out events for changes
-    // reconcile track publications, publish events only if metadata is already there
-    // i.e. changes since the local participant has joined
-    const validTracks = new Map();
-    const newTracks = new Map();
-    info.tracks.forEach(ti => {
-      var _a;
-      let publication = this.getTrackPublication(ti.sid);
-      if (!publication) {
-        // new publication
-        const kind = Track.kindFromProto(ti.type);
-        if (!kind) {
-          return;
-        }
-        publication = new RemoteTrackPublication(kind, ti, (_a = this.signalClient.connectOptions) === null || _a === void 0 ? void 0 : _a.autoSubscribe);
-        publication.updateInfo(ti);
-        newTracks.set(ti.sid, publication);
-        const existingTrackOfSource = Array.from(this.tracks.values()).find(publishedTrack => publishedTrack.source === (publication === null || publication === void 0 ? void 0 : publication.source));
-        if (existingTrackOfSource && publication.source !== Track.Source.Unknown) {
-          livekitLogger.debug("received a second track publication for ".concat(this.identity, " with the same source: ").concat(publication.source), {
-            oldTrack: existingTrackOfSource,
-            newTrack: publication,
-            participant: this,
-            participantInfo: info
-          });
-        }
-        this.addTrackPublication(publication);
-      } else {
-        publication.updateInfo(ti);
-      }
-      validTracks.set(ti.sid, publication);
-    });
-    // detect removed tracks
-    this.tracks.forEach(publication => {
-      if (!validTracks.has(publication.trackSid)) {
-        livekitLogger.trace('detected removed track on remote participant, unpublishing', {
-          publication,
-          participantSid: this.sid
-        });
-        this.unpublishTrack(publication.trackSid, true);
-      }
-    });
-    // always emit events for new publications, Room will not forward them unless it's ready
-    newTracks.forEach(publication => {
-      this.emit(ParticipantEvent.TrackPublished, publication);
-    });
-    return true;
-  }
-  /** @internal */
-  unpublishTrack(sid, sendUnpublish) {
-    const publication = this.tracks.get(sid);
-    if (!publication) {
-      return;
-    }
-    // also send unsubscribe, if track is actively subscribed
-    const {
-      track
-    } = publication;
-    if (track) {
-      track.stop();
-      publication.setTrack(undefined);
-    }
-    // remove track from maps only after unsubscribed has been fired
-    this.tracks.delete(sid);
-    // remove from the right type map
-    switch (publication.kind) {
-      case Track.Kind.Audio:
-        this.audioTracks.delete(sid);
-        break;
-      case Track.Kind.Video:
-        this.videoTracks.delete(sid);
-        break;
-    }
-    if (sendUnpublish) {
-      this.emit(ParticipantEvent.TrackUnpublished, publication);
-    }
-  }
-  /**
-   * @internal
-   */
-  setAudioContext(ctx) {
-    this.audioContext = ctx;
-    this.audioTracks.forEach(track => track.track instanceof RemoteAudioTrack && track.track.setAudioContext(ctx));
-  }
-  /**
-   * @internal
-   */
-  setAudioOutput(output) {
-    return __awaiter(this, void 0, void 0, function* () {
-      this.audioOutput = output;
-      const promises = [];
-      this.audioTracks.forEach(pub => {
-        var _a;
-        if (pub.track instanceof RemoteAudioTrack) {
-          promises.push(pub.track.setSinkId((_a = output.deviceId) !== null && _a !== void 0 ? _a : 'default'));
-        }
-      });
-      yield Promise.all(promises);
-    });
-  }
-  /** @internal */
-  emit(event) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-    livekitLogger.trace('participant event', {
-      participant: this.sid,
-      event,
-      args
-    });
-    return super.emit(event, ...args);
-  }
-}
-
-/** @internal */
-function mediaTrackToLocalTrack(mediaStreamTrack, constraints) {
-  switch (mediaStreamTrack.kind) {
-    case 'audio':
-      return new LocalAudioTrack(mediaStreamTrack, constraints, false);
-    case 'video':
-      return new LocalVideoTrack(mediaStreamTrack, constraints, false);
-    default:
-      throw new TrackInvalidError("unsupported track type: ".concat(mediaStreamTrack.kind));
-  }
-}
-/* @internal */
-const presets169 = Object.values(VideoPresets);
-/* @internal */
-const presets43 = Object.values(VideoPresets43);
-/* @internal */
-const presetsScreenShare = Object.values(ScreenSharePresets);
-/* @internal */
-const defaultSimulcastPresets169 = [VideoPresets.h180, VideoPresets.h360];
-/* @internal */
-const defaultSimulcastPresets43 = [VideoPresets43.h180, VideoPresets43.h360];
-/* @internal */
-const computeDefaultScreenShareSimulcastPresets = fromPreset => {
-  const layers = [{
-    scaleResolutionDownBy: 2,
-    fps: 3
-  }];
-  return layers.map(t => {
-    var _a;
-    return new VideoPreset(Math.floor(fromPreset.width / t.scaleResolutionDownBy), Math.floor(fromPreset.height / t.scaleResolutionDownBy), Math.max(150000, Math.floor(fromPreset.encoding.maxBitrate / (Math.pow(t.scaleResolutionDownBy, 2) * (((_a = fromPreset.encoding.maxFramerate) !== null && _a !== void 0 ? _a : 30) / t.fps)))), t.fps, fromPreset.encoding.priority);
-  });
-};
-// /**
-//  *
-//  * @internal
-//  * @experimental
-//  */
-// const computeDefaultMultiCodecSimulcastEncodings = (width: number, height: number) => {
-//   // use vp8 as a default
-//   const vp8 = determineAppropriateEncoding(false, width, height);
-//   const vp9 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.9 };
-//   const h264 = { ...vp8, maxBitrate: vp8.maxBitrate * 1.1 };
-//   const av1 = { ...vp8, maxBitrate: vp8.maxBitrate * 0.7 };
-//   return {
-//     vp8,
-//     vp9,
-//     h264,
-//     av1,
-//   };
-// };
-const videoRids = ['q', 'h', 'f'];
-/* @internal */
-function computeVideoEncodings(isScreenShare, width, height, options) {
-  var _a, _b;
-  let videoEncoding = options === null || options === void 0 ? void 0 : options.videoEncoding;
-  if (isScreenShare) {
-    videoEncoding = options === null || options === void 0 ? void 0 : options.screenShareEncoding;
-  }
-  const useSimulcast = options === null || options === void 0 ? void 0 : options.simulcast;
-  const scalabilityMode = options === null || options === void 0 ? void 0 : options.scalabilityMode;
-  const videoCodec = options === null || options === void 0 ? void 0 : options.videoCodec;
-  if (!videoEncoding && !useSimulcast && !scalabilityMode || !width || !height) {
-    // when we aren't simulcasting or svc, will need to return a single encoding without
-    // capping bandwidth. we always require a encoding for dynacast
-    return [{}];
-  }
-  if (!videoEncoding) {
-    // find the right encoding based on width/height
-    videoEncoding = determineAppropriateEncoding(isScreenShare, width, height, videoCodec);
-    livekitLogger.debug('using video encoding', videoEncoding);
-  }
-  const original = new VideoPreset(width, height, videoEncoding.maxBitrate, videoEncoding.maxFramerate, videoEncoding.priority);
-  if (scalabilityMode && isSVCCodec(videoCodec)) {
-    livekitLogger.debug("using svc with scalabilityMode ".concat(scalabilityMode));
-    const sm = new ScalabilityMode$1(scalabilityMode);
-    const encodings = [];
-    if (sm.spatial > 3) {
-      throw new Error("unsupported scalabilityMode: ".concat(scalabilityMode));
-    }
-    for (let i = 0; i < sm.spatial; i += 1) {
-      encodings.push({
-        rid: videoRids[2 - i],
-        maxBitrate: videoEncoding.maxBitrate / Math.pow(3, i),
-        /* @ts-ignore */
-        maxFramerate: original.encoding.maxFramerate
-      });
-    }
-    /* @ts-ignore */
-    encodings[0].scalabilityMode = scalabilityMode;
-    livekitLogger.debug('encodings', encodings);
-    return encodings;
-  }
-  if (!useSimulcast) {
-    return [videoEncoding];
-  }
-  let presets = [];
-  if (isScreenShare) {
-    presets = (_a = sortPresets(options === null || options === void 0 ? void 0 : options.screenShareSimulcastLayers)) !== null && _a !== void 0 ? _a : defaultSimulcastLayers(isScreenShare, original);
-  } else {
-    presets = (_b = sortPresets(options === null || options === void 0 ? void 0 : options.videoSimulcastLayers)) !== null && _b !== void 0 ? _b : defaultSimulcastLayers(isScreenShare, original);
-  }
-  let midPreset;
-  if (presets.length > 0) {
-    const lowPreset = presets[0];
-    if (presets.length > 1) {
-      [, midPreset] = presets;
-    }
-    // NOTE:
-    //   1. Ordering of these encodings is important. Chrome seems
-    //      to use the index into encodings to decide which layer
-    //      to disable when CPU constrained.
-    //      So encodings should be ordered in increasing spatial
-    //      resolution order.
-    //   2. ion-sfu translates rids into layers. So, all encodings
-    //      should have the base layer `q` and then more added
-    //      based on other conditions.
-    const size = Math.max(width, height);
-    if (size >= 960 && midPreset) {
-      return encodingsFromPresets(width, height, [lowPreset, midPreset, original]);
-    }
-    if (size >= 480) {
-      return encodingsFromPresets(width, height, [lowPreset, original]);
-    }
-  }
-  return encodingsFromPresets(width, height, [original]);
-}
-function computeTrackBackupEncodings(track, videoCodec, opts) {
-  var _a, _b, _c, _d;
-  if (!opts.backupCodec || opts.backupCodec.codec === opts.videoCodec) {
-    // backup codec publishing is disabled
-    return;
-  }
-  if (videoCodec !== opts.backupCodec.codec) {
-    livekitLogger.warn('requested a different codec than specified as backup', {
-      serverRequested: videoCodec,
-      backup: opts.backupCodec.codec
-    });
-  }
-  opts.videoCodec = videoCodec;
-  // use backup encoding setting as videoEncoding for backup codec publishing
-  opts.videoEncoding = opts.backupCodec.encoding;
-  const settings = track.mediaStreamTrack.getSettings();
-  const width = (_a = settings.width) !== null && _a !== void 0 ? _a : (_b = track.dimensions) === null || _b === void 0 ? void 0 : _b.width;
-  const height = (_c = settings.height) !== null && _c !== void 0 ? _c : (_d = track.dimensions) === null || _d === void 0 ? void 0 : _d.height;
-  const encodings = computeVideoEncodings(track.source === Track.Source.ScreenShare, width, height, opts);
-  return encodings;
-}
-/* @internal */
-function determineAppropriateEncoding(isScreenShare, width, height, codec) {
-  const presets = presetsForResolution(isScreenShare, width, height);
-  let {
-    encoding
-  } = presets[0];
-  // handle portrait by swapping dimensions
-  const size = Math.max(width, height);
-  for (let i = 0; i < presets.length; i += 1) {
-    const preset = presets[i];
-    encoding = preset.encoding;
-    if (preset.width >= size) {
-      break;
-    }
-  }
-  // presets are based on the assumption of vp8 as a codec
-  // for other codecs we adjust the maxBitrate if no specific videoEncoding has been provided
-  // TODO make the bitrate multipliers configurable per codec
-  if (codec) {
-    switch (codec) {
-      case 'av1':
-        encoding = Object.assign({}, encoding);
-        encoding.maxBitrate = encoding.maxBitrate * 0.7;
-        break;
-      case 'vp9':
-        encoding = Object.assign({}, encoding);
-        encoding.maxBitrate = encoding.maxBitrate * 0.85;
-        break;
+    if (mediaTrack.readyState === 'ended') {
+      livekitLogger.error('unable to subscribe because MediaStreamTrack is ended. Do not call MediaStreamTrack.stop()', {
+        participant: this.sid,
+        trackSid: sid
+      });
+      this.emit(ParticipantEvent.TrackSubscriptionFailed, sid);
+      return;
     }
+    const isVideo = mediaTrack.kind === 'video';
+    let track;
+    if (isVideo) {
+      track = new RemoteVideoTrack(mediaTrack, sid, receiver, adaptiveStreamSettings);
+    } else {
+      track = new RemoteAudioTrack(mediaTrack, sid, receiver, this.audioContext, this.audioOutput);
+    }
+    // set track info
+    track.source = publication.source;
+    // keep publication's muted status
+    track.isMuted = publication.isMuted;
+    track.setMediaStream(mediaStream);
+    track.start();
+    publication.setTrack(track);
+    // set participant volumes on new audio tracks
+    if (this.volumeMap.has(publication.source) && track instanceof RemoteAudioTrack) {
+      track.setVolume(this.volumeMap.get(publication.source));
+    }
+    return publication;
   }
-  return encoding;
-}
-/* @internal */
-function presetsForResolution(isScreenShare, width, height) {
-  if (isScreenShare) {
-    return presetsScreenShare;
-  }
-  const aspect = width > height ? width / height : height / width;
-  if (Math.abs(aspect - 16.0 / 9) < Math.abs(aspect - 4.0 / 3)) {
-    return presets169;
-  }
-  return presets43;
-}
-/* @internal */
-function defaultSimulcastLayers(isScreenShare, original) {
-  if (isScreenShare) {
-    return computeDefaultScreenShareSimulcastPresets(original);
+  /** @internal */
+  get hasMetadata() {
+    return !!this.participantInfo;
   }
-  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;
+  getTrackPublication(sid) {
+    return this.tracks.get(sid);
   }
-  return defaultSimulcastPresets43;
-}
-// presets should be ordered by low, medium, high
-function encodingsFromPresets(width, height, presets) {
-  const encodings = [];
-  presets.forEach((preset, idx) => {
-    if (idx >= videoRids.length) {
-      return;
-    }
-    const size = Math.min(width, height);
-    const rid = videoRids[idx];
-    const encoding = {
-      rid,
-      scaleResolutionDownBy: Math.max(1, size / Math.min(preset.width, preset.height)),
-      maxBitrate: preset.encoding.maxBitrate
-    };
-    if (preset.encoding.maxFramerate) {
-      encoding.maxFramerate = preset.encoding.maxFramerate;
-    }
-    const canSetPriority = isFireFox() || idx === 0;
-    if (preset.encoding.priority && canSetPriority) {
-      encoding.priority = preset.encoding.priority;
-      encoding.networkPriority = preset.encoding.priority;
+  /** @internal */
+  updateInfo(info) {
+    if (!super.updateInfo(info)) {
+      return false;
     }
-    encodings.push(encoding);
-  });
-  // RN ios simulcast requires all same framerates.
-  if (isReactNative() && getReactNativeOs() === 'ios') {
-    let topFramerate = undefined;
-    encodings.forEach(encoding => {
-      if (!topFramerate) {
-        topFramerate = encoding.maxFramerate;
-      } else if (encoding.maxFramerate && encoding.maxFramerate > topFramerate) {
-        topFramerate = encoding.maxFramerate;
-      }
-    });
-    let notifyOnce = true;
-    encodings.forEach(encoding => {
+    // we are getting a list of all available tracks, reconcile in here
+    // and send out events for changes
+    // reconcile track publications, publish events only if metadata is already there
+    // i.e. changes since the local participant has joined
+    const validTracks = new Map();
+    const newTracks = new Map();
+    info.tracks.forEach(ti => {
       var _a;
-      if (encoding.maxFramerate != topFramerate) {
-        if (notifyOnce) {
-          notifyOnce = false;
-          livekitLogger.info("Simulcast on iOS React-Native requires all encodings to share the same framerate.");
+      let publication = this.getTrackPublication(ti.sid);
+      if (!publication) {
+        // new publication
+        const kind = Track.kindFromProto(ti.type);
+        if (!kind) {
+          return;
         }
-        livekitLogger.info("Setting framerate of encoding \"".concat((_a = encoding.rid) !== null && _a !== void 0 ? _a : '', "\" to ").concat(topFramerate));
-        encoding.maxFramerate = topFramerate;
+        publication = new RemoteTrackPublication(kind, ti, (_a = this.signalClient.connectOptions) === null || _a === void 0 ? void 0 : _a.autoSubscribe);
+        publication.updateInfo(ti);
+        newTracks.set(ti.sid, publication);
+        const existingTrackOfSource = Array.from(this.tracks.values()).find(publishedTrack => publishedTrack.source === (publication === null || publication === void 0 ? void 0 : publication.source));
+        if (existingTrackOfSource && publication.source !== Track.Source.Unknown) {
+          livekitLogger.debug("received a second track publication for ".concat(this.identity, " with the same source: ").concat(publication.source), {
+            oldTrack: existingTrackOfSource,
+            newTrack: publication,
+            participant: this,
+            participantInfo: info
+          });
+        }
+        this.addTrackPublication(publication);
+      } else {
+        publication.updateInfo(ti);
+      }
+      validTracks.set(ti.sid, publication);
+    });
+    // detect removed tracks
+    this.tracks.forEach(publication => {
+      if (!validTracks.has(publication.trackSid)) {
+        livekitLogger.trace('detected removed track on remote participant, unpublishing', {
+          publication,
+          participantSid: this.sid
+        });
+        this.unpublishTrack(publication.trackSid, true);
       }
     });
+    // always emit events for new publications, Room will not forward them unless it's ready
+    newTracks.forEach(publication => {
+      this.emit(ParticipantEvent.TrackPublished, publication);
+    });
+    return true;
   }
-  return encodings;
-}
-/** @internal */
-function sortPresets(presets) {
-  if (!presets) return;
-  return presets.sort((a, b) => {
-    const {
-      encoding: aEnc
-    } = a;
-    const {
-      encoding: bEnc
-    } = b;
-    if (aEnc.maxBitrate > bEnc.maxBitrate) {
-      return 1;
+  /** @internal */
+  unpublishTrack(sid, sendUnpublish) {
+    const publication = this.tracks.get(sid);
+    if (!publication) {
+      return;
     }
-    if (aEnc.maxBitrate < bEnc.maxBitrate) return -1;
-    if (aEnc.maxBitrate === bEnc.maxBitrate && aEnc.maxFramerate && bEnc.maxFramerate) {
-      return aEnc.maxFramerate > bEnc.maxFramerate ? 1 : -1;
+    // also send unsubscribe, if track is actively subscribed
+    const {
+      track
+    } = publication;
+    if (track) {
+      track.stop();
+      publication.setTrack(undefined);
     }
-    return 0;
-  });
-}
-/** @internal */
-let ScalabilityMode$1 = class ScalabilityMode {
-  constructor(scalabilityMode) {
-    const results = scalabilityMode.match(/^L(\d)T(\d)(h|_KEY|_KEY_SHIFT){0,1}$/);
-    if (!results) {
-      throw new Error('invalid scalability mode');
+    // remove track from maps only after unsubscribed has been fired
+    this.tracks.delete(sid);
+    // remove from the right type map
+    switch (publication.kind) {
+      case Track.Kind.Audio:
+        this.audioTracks.delete(sid);
+        break;
+      case Track.Kind.Video:
+        this.videoTracks.delete(sid);
+        break;
     }
-    this.spatial = parseInt(results[1]);
-    this.temporal = parseInt(results[2]);
-    if (results.length > 3) {
-      switch (results[3]) {
-        case 'h':
-        case '_KEY':
-        case '_KEY_SHIFT':
-          this.suffix = results[3];
-      }
+    if (sendUnpublish) {
+      this.emit(ParticipantEvent.TrackUnpublished, publication);
     }
   }
-  toString() {
-    var _a;
-    return "L".concat(this.spatial, "T").concat(this.temporal).concat((_a = this.suffix) !== null && _a !== void 0 ? _a : '');
+  /**
+   * @internal
+   */
+  setAudioContext(ctx) {
+    this.audioContext = ctx;
+    this.audioTracks.forEach(track => track.track instanceof RemoteAudioTrack && track.track.setAudioContext(ctx));
   }
-};
+  /**
+   * @internal
+   */
+  setAudioOutput(output) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.audioOutput = output;
+      const promises = [];
+      this.audioTracks.forEach(pub => {
+        var _a;
+        if (pub.track instanceof RemoteAudioTrack) {
+          promises.push(pub.track.setSinkId((_a = output.deviceId) !== null && _a !== void 0 ? _a : 'default'));
+        }
+      });
+      yield Promise.all(promises);
+    });
+  }
+  /** @internal */
+  emit(event) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    livekitLogger.trace('participant event', {
+      participant: this.sid,
+      event,
+      args
+    });
+    return super.emit(event, ...args);
+  }
+}
 
 class LocalParticipant extends Participant {
   /** @internal */