livekit-client 2.22.0 → 2.22.2

package/dist/livekit-client.e2ee.worker.mjs

@@ -381,6 +381,7 @@ var LoggerNames;
   LoggerNames["DataTracks"] = "livekit-data-tracks";
   LoggerNames["Region"] = "livekit-region";
   LoggerNames["ICE"] = "livekit-ice";
+  LoggerNames["Stats"] = "livekit-stats";
 })(LoggerNames || (LoggerNames = {}));
 let livekitLogger = loglevelExports.getLogger(LoggerNames.Default);
 Object.values(LoggerNames).map(name => loglevelExports.getLogger(name));
@@ -4866,7 +4867,7 @@ var RoomEvent;
    * When a [[RemoteParticipant]] leaves *after* the local
    * participant has joined.
    *
-   * args: ([[RemoteParticipant]])
+   * args: ([[RemoteParticipant]], [[DisconnectReason]] | undefined)
    */
   RoomEvent["ParticipantDisconnected"] = "participantDisconnected";
   /**
@@ -5436,6 +5437,172 @@ var TrackEvent;
   TrackEvent["PreConnectBufferFlushed"] = "preConnectBufferFlushed";
 })(TrackEvent || (TrackEvent = {}));
 
+function compact(summary) {
+  const compacted = {};
+  for (const _ref of Object.entries(summary)) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    const key = _ref2[0];
+    const value = _ref2[1];
+    if (value !== undefined) {
+      compacted[key] = value;
+    }
+  }
+  return compacted;
+}
+function resolution(width, height) {
+  return width && height ? "".concat(width, "x").concat(height) : undefined;
+}
+/** keeps the derived durations readable; reported values are logged as they are */
+function round(seconds) {
+  return Math.round(seconds * 10000) / 10000;
+}
+/**
+ * Average time media spent in the jitter buffer, in s. Both counters are
+ * cumulative, so this is the average over the lifetime of the stream.
+ */
+function jitterBuffer(stat) {
+  const delay = stat.jitterBufferDelay;
+  const emitted = stat.jitterBufferEmittedCount;
+  return delay !== undefined && emitted ? round(delay / emitted) : undefined;
+}
+/**
+ * Playout delay in s. Video receive reports it directly, the audio path keeps it
+ * in the linked `media-playout` stats summed over the samples played out. Pairs
+ * with `RemoteTrack.setPlayoutDelay`.
+ */
+function playoutDelay(stat, playout) {
+  if (stat.playoutDelay !== undefined) {
+    return round(stat.playoutDelay);
+  }
+  const total = playout === null || playout === void 0 ? void 0 : playout.totalPlayoutDelay;
+  const samples = playout === null || playout === void 0 ? void 0 : playout.totalSamplesCount;
+  return total !== undefined && samples ? round(total / samples) : undefined;
+}
+/**
+ * Picks the interesting fields out of a `getStats()` report and groups them by
+ * RTP stream, so a stats dump can be read without unfolding the raw report.
+ */
+function summarizeStatsReport(report) {
+  var _a, _b;
+  const byId = new Map();
+  const candidatePairs = [];
+  const inbound = [];
+  const outbound = [];
+  let transport;
+  report.forEach(stat => byId.set(stat.id, stat));
+  const codecOf = stat => {
+    var _a;
+    return stat.codecId ? (_a = byId.get(stat.codecId)) === null || _a === void 0 ? void 0 : _a.mimeType : undefined;
+  };
+  const relatedOf = (stat, key) => stat[key] ? byId.get(stat[key]) : undefined;
+  report.forEach(stat => {
+    switch (stat.type) {
+      case 'inbound-rtp':
+        {
+          const playout = relatedOf(stat, 'playoutId');
+          inbound.push(compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            // matches `streamTrackID` in the track's own log context
+            trackId: stat.trackIdentifier,
+            codec: codecOf(stat),
+            decoder: stat.decoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            bytesReceived: stat.bytesReceived,
+            packetsReceived: stat.packetsReceived,
+            packetsLost: stat.packetsLost,
+            packetsDiscarded: stat.packetsDiscarded,
+            // frames received without frames decoded is a decode failure
+            framesReceived: stat.framesReceived,
+            framesDecoded: stat.framesDecoded,
+            framesDropped: stat.framesDropped,
+            keyFramesDecoded: stat.keyFramesDecoded,
+            freezeCount: stat.freezeCount,
+            totalFreezesDuration: stat.totalFreezesDuration,
+            pauseCount: stat.pauseCount,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            jitter: stat.jitter,
+            jitterBuffer: jitterBuffer(stat),
+            playoutDelay: playoutDelay(stat, playout),
+            audioLevel: stat.audioLevel,
+            totalSamplesReceived: stat.totalSamplesReceived,
+            concealedSamples: stat.concealedSamples
+          }));
+          break;
+        }
+      case 'outbound-rtp':
+        {
+          const remote = relatedOf(stat, 'remoteId');
+          const source = relatedOf(stat, 'mediaSourceId');
+          outbound.push(compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            rid: stat.rid,
+            trackId: source === null || source === void 0 ? void 0 : source.trackIdentifier,
+            active: stat.active,
+            codec: codecOf(stat),
+            encoder: stat.encoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            // what the source produces, to tell a stalled capture from a stalled encoder
+            captureResolution: resolution(source === null || source === void 0 ? void 0 : source.width, source === null || source === void 0 ? void 0 : source.height),
+            captureFps: source === null || source === void 0 ? void 0 : source.framesPerSecond,
+            audioLevel: source === null || source === void 0 ? void 0 : source.audioLevel,
+            targetBitrate: stat.targetBitrate,
+            bytesSent: stat.bytesSent,
+            packetsSent: stat.packetsSent,
+            retransmittedPacketsSent: stat.retransmittedPacketsSent,
+            framesEncoded: stat.framesEncoded,
+            keyFramesEncoded: stat.keyFramesEncoded,
+            limitedBy: stat.qualityLimitationReason === 'none' ? undefined : stat.qualityLimitationReason,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            // loss, jitter and RTT are only known from what the remote reports
+            remotePacketsLost: remote === null || remote === void 0 ? void 0 : remote.packetsLost,
+            remoteFractionLost: remote === null || remote === void 0 ? void 0 : remote.fractionLost,
+            remoteJitter: remote === null || remote === void 0 ? void 0 : remote.jitter,
+            remoteRoundTripTime: remote === null || remote === void 0 ? void 0 : remote.roundTripTime
+          }));
+          break;
+        }
+      case 'transport':
+        transport = stat;
+        break;
+      case 'candidate-pair':
+        candidatePairs.push(stat);
+        break;
+    }
+  });
+  const selectedPairId = transport === null || transport === void 0 ? void 0 : transport.selectedCandidatePairId;
+  const pair = (_b = (_a = selectedPairId ? byId.get(selectedPairId) : undefined) !== null && _a !== void 0 ? _a : candidatePairs.find(candidate => candidate.selected)) !== null && _b !== void 0 ? _b : candidatePairs.find(candidate => candidate.nominated);
+  const local = (pair === null || pair === void 0 ? void 0 : pair.localCandidateId) ? byId.get(pair.localCandidateId) : undefined;
+  const remote = (pair === null || pair === void 0 ? void 0 : pair.remoteCandidateId) ? byId.get(pair.remoteCandidateId) : undefined;
+  const connection = compact({
+    ice: transport === null || transport === void 0 ? void 0 : transport.iceState,
+    dtls: transport === null || transport === void 0 ? void 0 : transport.dtlsState,
+    route: local && remote ? "".concat(local.candidateType, "/").concat(local.protocol, " -> ").concat(remote.candidateType) : undefined,
+    network: local === null || local === void 0 ? void 0 : local.networkType,
+    currentRoundTripTime: pair === null || pair === void 0 ? void 0 : pair.currentRoundTripTime,
+    // the send bandwidth estimate; no RTP stream reports it
+    availableOutgoingBitrate: pair === null || pair === void 0 ? void 0 : pair.availableOutgoingBitrate,
+    availableIncomingBitrate: pair === null || pair === void 0 ? void 0 : pair.availableIncomingBitrate,
+    bytesSent: pair === null || pair === void 0 ? void 0 : pair.bytesSent,
+    bytesReceived: pair === null || pair === void 0 ? void 0 : pair.bytesReceived,
+    candidatePairChanges: transport === null || transport === void 0 ? void 0 : transport.selectedCandidatePairChanges
+  });
+  return {
+    connection: Object.keys(connection).length > 0 ? connection : undefined,
+    outbound: outbound.length > 0 ? outbound : undefined,
+    inbound: inbound.length > 0 ? inbound : undefined
+  };
+}
+
 class VideoPreset {
   constructor(widthOrOptions, height, maxBitrate, maxFramerate, priority) {
     if (typeof widthOrOptions === 'object') {
@@ -5604,6 +5771,7 @@ class Track extends eventsExports.EventEmitter {
     this._streamState = Track.StreamState.Active;
     this.isInBackground = false;
     this._currentBitrate = 0;
+    this.finalStatsLogged = false;
     this.log = livekitLogger;
     this.appVisibilityChangedListener = () => {
       if (this.backgroundTimeout) {
@@ -5752,6 +5920,24 @@ class Track extends eventsExports.EventEmitter {
       cancelAnimationFrame(this.timeSyncHandle);
       this.timeSyncHandle = undefined;
     }
+    this.logFinalStats();
+  }
+  /**
+   * Dumps the raw stats of the track as it ends, once: a track that stops
+   * between two of the room's stats dumps is gone by the time the next one runs.
+   */
+  logFinalStats() {
+    if (this.finalStatsLogged) {
+      return;
+    }
+    this.finalStatsLogged = true;
+    this.getRTCStatsReport().then(report => {
+      if (report) {
+        this.log.info('final track stats', summarizeStatsReport(report));
+      }
+    }).catch(error => this.log.debug('could not collect final track stats', {
+      error
+    }));
   }
   /** @internal */
   updateLoggerOptions(loggerOptions) {
@@ -6508,6 +6694,8 @@ class FrameCryptor extends BaseFrameCryptor {
     this.ERROR_THROTTLE_MS = 1000; // Emit error at most once per second
     this.MAX_ERRORS_PER_MINUTE = 5; // Maximum errors to emit per minute per key
     this.ERROR_WINDOW_MS = 60000; // 1 minute window
+    /** grace period for a teardown or a resubscribe to land before we report a stalled track */
+    this.UNDECRYPTED_TRACK_GRACE_MS = 2000;
     /**
      * Tracks (participant, trackId, payloadType) tuples for which we've already logged a NALU
      * fallback, so a persistent bad state doesn't flood the console (Firefox doesn't filter debug).
@@ -6552,9 +6740,13 @@ class FrameCryptor extends BaseFrameCryptor {
   }
   unsetParticipant() {
     workerLogger.debug('unsetting participant', this.logContext);
-    if (this.currentTransform) {
-      this.currentTransform = undefined;
-    }
+    // NOTE: deliberately does not clear `currentTransform`. Nothing here cancels
+    // the pipe, so the transform really is still running and clearing it would
+    // desync our bookkeeping from reality -- which previously let a later
+    // resubscribe skip setup while frames kept flowing through a cryptor with no
+    // participant assigned.
+    clearTimeout(this.undecryptedTrackTimeout);
+    this.undecryptedTrackTimeout = undefined;
     this.participantIdentity = undefined;
     this.lastErrorTimestamp = new Map();
     this.errorCounts = new Map();
@@ -6572,6 +6764,72 @@ class FrameCryptor extends BaseFrameCryptor {
   getTrackId() {
     return this.trackId;
   }
+  /**
+   * Re-point this cryptor at a new trackId, keeping its (already transferred)
+   * encoded streams. Used when a transceiver is reused for a new track.
+   */
+  setTrackId(trackId) {
+    if (this.trackId === trackId) {
+      return;
+    }
+    workerLogger.debug('re-pointing cryptor at new trackId', Object.assign(Object.assign({}, this.logContext), {
+      newTrackId: trackId
+    }));
+    this.trackId = trackId;
+  }
+  hasActiveTransform() {
+    return !!this.currentTransform;
+  }
+  /**
+   * A track that is subscribed and known to be encrypted, but has no transform to
+   * decrypt it, will never produce a decodable frame again. That state used to be
+   * completely silent (a black tile and endless PLIs), so report it.
+   *
+   * Deferred, because on teardown the encoded streams routinely close before the
+   * 'removeTransform' message arrives -- checking immediately would cry wolf on
+   * every unsubscribe.
+   *
+   * Only meaningful while decoding: a sender's pipe closing on unpublish is
+   * routine and has no 'removeTransform' equivalent to quiet it down.
+   */
+  scheduleUndecryptedTrackWatchdog(operation) {
+    clearTimeout(this.undecryptedTrackTimeout);
+    this.undecryptedTrackTimeout = undefined;
+    if (operation !== 'decode') {
+      return;
+    }
+    this.undecryptedTrackTimeout = setTimeout(() => {
+      if (this.currentTransform || !this.isEnabled()) {
+        return;
+      }
+      workerLogger.warn('encrypted track has no active decrypt transform', this.logContext);
+      this.emitThrottledError(new CryptorError("no active decrypt transform for encrypted track ".concat(this.trackId), CryptorErrorReason.InternalError, this.participantIdentity));
+    }, this.UNDECRYPTED_TRACK_GRACE_MS);
+  }
+  /**
+   * Re-establish the transform if it is gone while we still own the encoded
+   * streams, e.g. after a pipe died on its own (the swallowed
+   * 'Destination stream closed') or when a reused transceiver never got a new
+   * pipeline. Without this the frames pile up in a readable nobody reads and the
+   * decoder starves, which shows up as a permanently black tile.
+   */
+  ensureTransform() {
+    if (this.currentTransform) {
+      return true;
+    }
+    if (!this.retainedStreams || this.trackId === undefined) {
+      workerLogger.warn('no streams retained, cannot re-establish transform', this.logContext);
+      return false;
+    }
+    const _this$retainedStreams = this.retainedStreams,
+      readable = _this$retainedStreams.readable,
+      writable = _this$retainedStreams.writable,
+      operation = _this$retainedStreams.operation;
+    workerLogger.info('re-establishing transform', Object.assign(Object.assign({}, this.logContext), {
+      operation
+    }));
+    return this.setupTransform(operation, readable, writable, this.trackId);
+  }
   /**
    * Update the video codec used by the mediaStreamTrack
    * @param codec
@@ -6598,7 +6856,8 @@ class FrameCryptor extends BaseFrameCryptor {
     this.frameMetadataOpts = frameMetadata;
     this.frameMetadataFrameId = 0;
   }
-  setupTransform(operation, readable, writable, trackId, isReuse, codec, frameMetadata) {
+  setupTransform(operation, readable, writable, trackId, codec, frameMetadata) {
+    var _a;
     if (codec) {
       workerLogger.info('setting codec on cryptor to', {
         codec
@@ -6612,18 +6871,17 @@ class FrameCryptor extends BaseFrameCryptor {
       operation,
       passedTrackId: trackId,
       codec,
-      isReuse,
       hasCurrentTransform: !!this.currentTransform
     }, this.logContext));
-    // Always update trackId, even on reuse
     this.trackId = trackId;
-    // If we're reusing and have an active transform skip setup
-    if (isReuse && this.currentTransform && readable === this.currentTransform.readable && writable === this.currentTransform.writable) {
-      workerLogger.debug('reusing existing transform', Object.assign(Object.assign({}, this.logContext), {
-        trackId
-      }));
-      return;
-    }
+    // Retain the streams so we can rebuild the pipe later even if this cryptor
+    // gets detached from its participant in between (see `ensureTransform`).
+    this.retainedStreams = {
+      readable,
+      writable,
+      operation
+    };
+    clearTimeout(this.undecryptedTrackTimeout);
     const symbol = Symbol('transform');
     const transformFn = operation === 'encode' ? this.encodeFunction : this.decodeFunction;
     const transformStream = new TransformStream({
@@ -6637,26 +6895,43 @@ class FrameCryptor extends BaseFrameCryptor {
       trackId,
       symbol
     };
-    readable.pipeThrough(transformStream).pipeTo(writable).catch(e => {
-      if (e instanceof TypeError && e.message === 'Destination stream closed') {
-        // this can happen when subscriptions happen in quick successions, but doesn't influence functionality
-        workerLogger.debug('destination stream closed');
-      } else {
-        workerLogger.warn('transform error', Object.assign({
-          error: e
-        }, this.logContext));
-        this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, undefined, this.participantIdentity));
-      }
-    }).finally(() => {
-      var _a;
-      // Only clear currentTransform if it's still the same one we started
+    // pipeThrough/pipeTo throw synchronously on an already locked stream, which
+    // would bypass the .catch below and leave us with no transform at all.
+    try {
+      readable.pipeThrough(transformStream).pipeTo(writable).catch(e => {
+        if (e instanceof TypeError && e.message === 'Destination stream closed') {
+          // this can happen when subscriptions happen in quick successions, but doesn't influence functionality
+          workerLogger.debug('destination stream closed');
+        } else {
+          workerLogger.warn('transform error', Object.assign({
+            error: e
+          }, this.logContext));
+          this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, undefined, this.participantIdentity));
+        }
+      }).finally(() => {
+        var _a;
+        // Only clear currentTransform if it's still the same one we started
+        if (((_a = this.currentTransform) === null || _a === void 0 ? void 0 : _a.symbol) === symbol) {
+          workerLogger.debug('transform completed', Object.assign(Object.assign({}, this.logContext), {
+            trackId
+          }));
+          this.currentTransform = undefined;
+        }
+        // A pipe ending while the track is still assigned to a participant that
+        // publishes encrypted media means we have silently stopped decrypting.
+        this.scheduleUndecryptedTrackWatchdog(operation);
+      });
+    } catch (e) {
       if (((_a = this.currentTransform) === null || _a === void 0 ? void 0 : _a.symbol) === symbol) {
-        workerLogger.debug('transform completed', Object.assign(Object.assign({}, this.logContext), {
-          trackId
-        }));
         this.currentTransform = undefined;
       }
-    });
+      workerLogger.error('failed to set up transform', Object.assign({
+        error: e
+      }, this.logContext));
+      this.emit(CryptorEvent.Error, e instanceof CryptorError ? e : new CryptorError(e.message, CryptorErrorReason.InternalError, this.participantIdentity));
+      return false;
+    }
+    return true;
   }
   setSifTrailer(trailer) {
     workerLogger.debug('setting SIF trailer', Object.assign(Object.assign({}, this.logContext), {
@@ -6837,9 +7112,29 @@ class FrameCryptor extends BaseFrameCryptor {
           // best-effort: never break the media pipeline if trailer parsing fails
         }
       }
-      if (!this.isEnabled() ||
-      // skip for decryption for empty dtx frames
-      encodedFrame.data.byteLength === 0) {
+      // skip decryption for empty dtx frames
+      if (encodedFrame.data.byteLength === 0) {
+        return controller.enqueue(encodedFrame);
+      }
+      const encryptionEnabled = this.isEnabled();
+      if (encryptionEnabled === undefined) {
+        // Either way we drop: forwarding would hand ciphertext straight to the
+        // decoder, which renders as a black frame and logs nothing.
+        if (this.participantIdentity === undefined) {
+          // The pipe outlived its subscription. Expected on unsubscribe/disconnect:
+          // we deliberately leave the pipe running so a reused transceiver can be
+          // re-pointed at a new track, so in-flight frames still arrive here for a
+          // moment. Not worth reporting -- the watchdog covers a track that stays
+          // subscribed without a transform.
+          workerLogger.debug('dropping frame for unassigned cryptor', this.logContext);
+          return;
+        }
+        // A live subscription whose encryption state we were never told about.
+        this.emitThrottledError(new CryptorError("encryption state unknown for track ".concat(this.trackId, ", dropping frame"), CryptorErrorReason.InternalError, this.participantIdentity));
+        return;
+      }
+      if (!encryptionEnabled) {
+        // participant is known to publish unencrypted media
         return controller.enqueue(encodedFrame);
       }
       if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
@@ -7341,12 +7636,12 @@ onmessage = ev => {
       case 'decode':
         let cryptor = getTrackCryptor(data.participantIdentity, data.trackId);
         cryptor.setHasFrameMetadata(data.hasPacketTrailer);
-        cryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.isReuse, data.codec);
+        cryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.codec);
         break;
       case 'encode':
         let pubCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
         pubCryptor.setHasFrameMetadata(data.hasPacketTrailer);
-        pubCryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.isReuse, data.codec, data.packetTrailer);
+        pubCryptor.setupTransform(kind, data.readableStream, data.writableStream, data.trackId, data.codec, data.packetTrailer);
         break;
       case 'encryptDataRequest':
         const _yield$DataCryptor$en = yield DataCryptor.encrypt(data.payload, getParticipantKeyHandler(data.participantIdentity)),
@@ -7409,15 +7704,28 @@ onmessage = ev => {
         unsetCryptorParticipant(data.trackId, data.participantIdentity);
         break;
       case 'updateCodec':
-        const trackCryptor = getTrackCryptor(data.participantIdentity, data.trackId);
-        trackCryptor.setVideoCodec(data.codec);
+        const trackCryptor = getTrackCryptor(data.participantIdentity, data.trackId, data.previousTrackId);
+        if (data.codec) {
+          trackCryptor.setVideoCodec(data.codec);
+        }
         trackCryptor.setHasFrameMetadata(data.hasPacketTrailer);
         workerLogger.info('updated codec', {
           participantIdentity: data.participantIdentity,
           trackId: data.trackId,
+          previousTrackId: data.previousTrackId,
           codec: data.codec,
           hasPacketTrailer: data.hasPacketTrailer
         });
+        // Sent on transceiver reuse, where the main thread cannot hand us a new
+        // pipeline. If the previous one died in the meantime we have to rebuild it
+        // here or no frame ever gets decrypted again.
+        if (data.previousTrackId !== undefined && !trackCryptor.ensureTransform()) {
+          workerLogger.error('could not re-establish transform for reused receiver', {
+            participantIdentity: data.participantIdentity,
+            trackId: data.trackId,
+            previousTrackId: data.previousTrackId
+          });
+        }
         break;
       case 'setRTPMap':
         // this is only used for the local participant
@@ -7452,8 +7760,24 @@ function handleRatchetRequest(data) {
     }
   });
 }
-function getTrackCryptor(participantIdentity, trackId) {
+function getTrackCryptor(participantIdentity, trackId, previousTrackId) {
   let cryptors = participantCryptors.filter(c => c.getTrackId() === trackId);
+  if (cryptors.length === 0 && previousTrackId !== undefined && previousTrackId !== trackId) {
+    // A reused transceiver carries a new trackId, but the cryptor that owns this
+    // receiver's encoded streams is still keyed on the old one. Re-point it instead
+    // of creating a fresh cryptor that has no pipeline (and leaving the old one
+    // piping frames with no participant assigned).
+    const previous = participantCryptors.filter(c => c.getTrackId() === previousTrackId);
+    if (previous.length > 0) {
+      workerLogger.info('reusing cryptor from previous trackId', {
+        participantIdentity,
+        trackId,
+        previousTrackId
+      });
+      previous[0].setTrackId(trackId);
+      cryptors = previous;
+    }
+  }
   if (cryptors.length > 1) {
     const debugInfo = cryptors.map(c => {
       return {
@@ -7589,7 +7913,7 @@ if (self.RTCTransformEvent) {
         trackId,
         codec
       });
-      cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, false, codec, kind === 'encode' ? options.packetTrailer : undefined);
+      cryptor.setupTransform(kind, transformer.readable, transformer.writable, trackId, codec, kind === 'encode' ? options.packetTrailer : undefined);
     }));
   };
 }