livekit-client 2.18.8 → 2.18.10

package/src/packetTrailer/PacketTrailerManager.ts

@@ -0,0 +1,250 @@
+import type { TrackInfo } from '@livekit/protocol';
+import log from '../logger';
+import type Room from '../room/Room';
+import { RoomEvent } from '../room/events';
+import { PacketTrailerExtractor } from '../room/track/PacketTrailerExtractor';
+import type RemoteTrack from '../room/track/RemoteTrack';
+import RemoteVideoTrack from '../room/track/RemoteVideoTrack';
+import type { PTDecodeMessage, PTUpdateTrackIdMessage, PTWorkerMessage } from './types';
+import { isPacketTrailerSupported, shouldUsePacketTrailerScriptTransform } from './utils';
+
+export interface PacketTrailerOptions {
+  /**
+   * Dedicated worker for extracting packet trailers off the main thread.
+   *
+   * Encoded video streams are transferred to the worker for processing, which
+   * avoids per-frame work on the main thread.
+   */
+  worker: Worker;
+}
+
+/**
+ * Manages packet trailer extraction for received video tracks.
+ *
+ * When a track's TrackInfo indicates packet trailer features, the manager
+ * wires up an encoded frame transform to strip the trailer from encoded frames
+ * and cache the metadata for lookup.
+ *
+ * Packet trailer extraction is worker-only. If no worker is configured, the
+ * SDK does not advertise packet trailer support and skips extraction.
+ *
+ * When E2EE is active, the E2EE FrameCryptor worker handles trailer
+ * extraction directly (before decryption), so this manager only creates
+ * the extractor/metadata cache — no separate pipeline is installed.
+ *
+ * @experimental
+ */
+export class PacketTrailerManager {
+  private worker?: Worker;
+
+  private room?: Room;
+
+  private extractors = new Map<string, PacketTrailerExtractor>();
+
+  /**
+   * Tracks the trackId associated with each receiver that has had its
+   * encoded streams handed off to the worker. Used to detect receiver
+   * reuse (transceiver recycling) so we can remap trackIds instead of
+   * re-transferring already-consumed streams.
+   */
+  private workerPipelines = new Map<RTCRtpReceiver, string>();
+
+  constructor(options?: PacketTrailerOptions) {
+    this.worker = options?.worker;
+  }
+
+  /** @internal */
+  setup(room: Room) {
+    if (room === this.room) {
+      return;
+    }
+    this.room = room;
+
+    if (this.worker) {
+      this.worker.onmessage = this.onWorkerMessage;
+      this.worker.onerror = this.onWorkerError;
+      this.worker.postMessage({ kind: 'init' });
+    }
+
+    room
+      .on(RoomEvent.TrackSubscribed, (track, pub, _participant) => {
+        if (track.kind !== 'video') {
+          return;
+        }
+        this.setupReceiver(track as unknown as RemoteVideoTrack, pub.trackInfo);
+      })
+      .on(RoomEvent.TrackUnsubscribed, (track) => {
+        this.teardownTrack(track);
+      })
+      .on(RoomEvent.Disconnected, () => {
+        this.cleanup();
+      });
+  }
+
+  private setupReceiver(track: RemoteVideoTrack, trackInfo?: TrackInfo) {
+    const receiver = track.receiver;
+    if (!receiver) {
+      return;
+    }
+
+    // Only install a pipeline for tracks that actually advertise packet
+    // trailer features. This keeps us out of the way for tracks published by
+    // clients on older protocols or that don't opt into the feature.
+    const hasFeatures =
+      !!trackInfo?.packetTrailerFeatures && trackInfo.packetTrailerFeatures.length > 0;
+    if (!hasFeatures) {
+      if (!this.room?.hasE2EESetup) {
+        this.setupPassthroughReceiver(receiver, track.mediaStreamID);
+      }
+      return;
+    }
+
+    if (
+      !isPacketTrailerSupported(this.worker ? { worker: this.worker } : undefined) &&
+      !this.room?.hasE2EESetup
+    ) {
+      log.warn('packet trailer transform not supported; skipping extraction');
+      return;
+    }
+
+    const extractor = new PacketTrailerExtractor();
+    const trackId = track.mediaStreamID;
+
+    this.extractors.set(trackId, extractor);
+    track.packetTrailerExtractor = extractor;
+
+    if (this.room?.hasE2EESetup) {
+      // E2EE worker strips the trailer and injects metadata directly into
+      // the extractor via E2eeManager; no pipeline is needed here.
+      return;
+    }
+
+    this.setupWorkerReceiver(receiver, trackId, true);
+  }
+
+  private setupPassthroughReceiver(receiver: RTCRtpReceiver, trackId: string) {
+    if (shouldUsePacketTrailerScriptTransform()) {
+      if ('transform' in receiver) {
+        // @ts-ignore
+        receiver.transform = null;
+      }
+      return;
+    }
+
+    if (
+      this.worker &&
+      isPacketTrailerSupported({ worker: this.worker }) &&
+      !this.workerPipelines.has(receiver)
+    ) {
+      this.setupWorkerReceiver(receiver, trackId, false);
+      return;
+    }
+
+    if (this.worker && this.workerPipelines.has(receiver)) {
+      this.setupWorkerReceiver(receiver, trackId, false);
+    }
+  }
+
+  private setupWorkerReceiver(
+    receiver: RTCRtpReceiver,
+    newTrackId: string,
+    hasPacketTrailer = true,
+  ) {
+    const worker = this.worker;
+    if (!worker) {
+      return;
+    }
+
+    if (shouldUsePacketTrailerScriptTransform()) {
+      // @ts-ignore
+      receiver.transform = new RTCRtpScriptTransform(worker, {
+        kind: 'decode',
+        trackId: newTrackId,
+      });
+      return;
+    }
+
+    const existingTrackId = this.workerPipelines.get(receiver);
+
+    if (existingTrackId) {
+      // Receiver is reused (transceiver recycled). The worker already owns
+      // the encoded streams — just remap the trackId so metadata is keyed
+      // correctly and re-activate processing.
+      const msg: PTUpdateTrackIdMessage = {
+        kind: 'updateTrackId',
+        data: { oldTrackId: existingTrackId, newTrackId, hasPacketTrailer },
+      };
+      worker.postMessage(msg);
+      this.workerPipelines.set(receiver, newTrackId);
+      return;
+    }
+
+    if (!('createEncodedStreams' in receiver)) {
+      log.warn('createEncodedStreams not supported');
+      return;
+    }
+
+    let streams: { readable: ReadableStream; writable: WritableStream };
+    try {
+      // @ts-ignore — createEncodedStreams is not in standard typings
+      streams = receiver.createEncodedStreams();
+    } catch (err) {
+      log.warn('failed to create encoded streams', { error: err });
+      return;
+    }
+
+    const msg: PTDecodeMessage = {
+      kind: 'decode',
+      data: {
+        readableStream: streams.readable,
+        writableStream: streams.writable,
+        trackId: newTrackId,
+        hasPacketTrailer,
+      },
+    };
+    worker.postMessage(msg, [streams.readable, streams.writable]);
+    this.workerPipelines.set(receiver, newTrackId);
+  }
+
+  private teardownTrack(track: RemoteTrack) {
+    const trackId = track.mediaStreamID;
+    const extractor = this.extractors.get(trackId);
+    if (extractor) {
+      extractor.dispose();
+      this.extractors.delete(trackId);
+    }
+
+    if (track instanceof RemoteVideoTrack) {
+      track.packetTrailerExtractor = undefined;
+    }
+
+    // The receiver pipeline is intentionally left running. If the receiver is
+    // reused for a new track, `setupReceiver` will remap it. If the room
+    // disconnects, `cleanup` drops all state. Any metadata produced in the
+    // meantime is harmless — the extractor above has already been disposed and
+    // is no longer reachable from any track.
+  }
+
+  private cleanup() {
+    for (const extractor of this.extractors.values()) {
+      extractor.dispose();
+    }
+    this.extractors.clear();
+    this.workerPipelines.clear();
+    this.worker?.terminate();
+  }
+
+  private onWorkerMessage = (ev: MessageEvent<PTWorkerMessage>) => {
+    const msg = ev.data;
+    if (msg.kind === 'metadata') {
+      const extractor = this.extractors.get(msg.data.trackId);
+      if (extractor) {
+        extractor.storeMetadata(msg.data.rtpTimestamp, msg.data.ssrc, msg.data.metadata);
+      }
+    }
+  };
+
+  private onWorkerError = (ev: ErrorEvent) => {
+    log.error('packet trailer worker encountered an error:', { error: ev.error });
+  };
+}

package/src/packetTrailer/packetTrailer.test.ts

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  appendPacketTrailer,
+  appendPacketTrailerToEncodedFrame,
+  extractPacketTrailer,
+  processPacketTrailer,
+} from './packetTrailer';
+
+describe('packetTrailer', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('extracts user timestamp and frame id from packet trailer', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const trailer = appendPacketTrailer(payload, 1_744_249_600_123_456n, 42);
+    const extracted = extractPacketTrailer(trailer);
+
+    expect(Array.from(extracted.data)).toEqual(Array.from(payload));
+    expect(extracted.metadata).toEqual({
+      userTimestamp: 1_744_249_600_123_456n,
+      frameId: 42,
+    });
+  });
+
+  it('extracts timestamp-only trailer when frameId is 0', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const trailer = appendPacketTrailer(payload, 1_744_249_600_123_456n, 0);
+    const extracted = extractPacketTrailer(trailer);
+
+    expect(Array.from(extracted.data)).toEqual(Array.from(payload));
+    expect(extracted.metadata).toEqual({
+      userTimestamp: 1_744_249_600_123_456n,
+      frameId: 0,
+    });
+  });
+
+  it('extracts frameId-only trailer when timestamp is 0', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const trailer = appendPacketTrailer(payload, 0n, 42);
+    const extracted = extractPacketTrailer(trailer);
+
+    expect(Array.from(extracted.data)).toEqual(Array.from(payload));
+    expect(extracted.metadata).toEqual({
+      userTimestamp: 0n,
+      frameId: 42,
+    });
+  });
+
+  it('returns data unchanged when both timestamp and frameId are 0', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const result = appendPacketTrailer(payload, 0n, 0);
+
+    expect(Array.from(result)).toEqual(Array.from(payload));
+  });
+
+  it('passes frames through when there is no valid trailer', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4, 5]);
+    const extracted = extractPacketTrailer(payload);
+
+    expect(Array.from(extracted.data)).toEqual(Array.from(payload));
+    expect(extracted.metadata).toBeUndefined();
+  });
+
+  it('uses the encoded frame timestamp when metadata does not include an RTP timestamp', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const trailer = appendPacketTrailer(payload, 1_744_249_600_123_456n, 42);
+    const frame = {
+      data: trailer.buffer,
+      timestamp: 1234,
+      getMetadata() {
+        return {};
+      },
+    } as unknown as RTCEncodedVideoFrame;
+
+    const result = processPacketTrailer(frame, 'track-id');
+
+    expect(result.payload).toEqual({
+      trackId: 'track-id',
+      rtpTimestamp: 1234,
+      ssrc: 0,
+      metadata: {
+        userTimestamp: 1_744_249_600_123_456n,
+        frameId: 42,
+      },
+    });
+  });
+
+  it('appends timestamp-only packet trailer to encoded frames', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-04-10T12:00:00.123Z'));
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const frame = { data: payload.buffer } as RTCEncodedVideoFrame;
+
+    appendPacketTrailerToEncodedFrame(frame, { timestamp: true }, 0);
+    const extracted = extractPacketTrailer(frame.data);
+
+    expect(Array.from(extracted.data)).toEqual(Array.from(payload));
+    expect(frame.data.byteLength).toBe(payload.byteLength + 15);
+    expect(extracted.metadata).toEqual({
+      userTimestamp: BigInt(Date.now()) * BigInt(1000),
+      frameId: 0,
+    });
+  });
+
+  it('appends frame-id-only packet trailer to encoded frames', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const firstFrame = { data: payload.buffer.slice(0) } as RTCEncodedVideoFrame;
+    const secondFrame = { data: payload.buffer.slice(0) } as RTCEncodedVideoFrame;
+
+    appendPacketTrailerToEncodedFrame(firstFrame, { frameId: true }, 1);
+    appendPacketTrailerToEncodedFrame(secondFrame, { frameId: true }, 2);
+
+    expect(firstFrame.data.byteLength).toBe(payload.byteLength + 11);
+    expect(secondFrame.data.byteLength).toBe(payload.byteLength + 11);
+    expect(extractPacketTrailer(firstFrame.data).metadata).toEqual({
+      userTimestamp: 0n,
+      frameId: 1,
+    });
+    expect(extractPacketTrailer(secondFrame.data).metadata).toEqual({
+      userTimestamp: 0n,
+      frameId: 2,
+    });
+  });
+
+  it('appends both timestamp and frame id to encoded frames', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-04-10T12:00:00.123Z'));
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const frame = { data: payload.buffer } as RTCEncodedVideoFrame;
+
+    appendPacketTrailerToEncodedFrame(frame, { timestamp: true, frameId: true }, 7);
+
+    expect(extractPacketTrailer(frame.data).metadata).toEqual({
+      userTimestamp: BigInt(Date.now()) * BigInt(1000),
+      frameId: 7,
+    });
+  });
+
+  it.each([{}, { timestamp: false, frameId: false }])(
+    'passes encoded frames through when no write features are enabled: %o',
+    (packetTrailer) => {
+      const payload = Uint8Array.from([1, 2, 3, 4]);
+      const frame = { data: payload.buffer } as RTCEncodedVideoFrame;
+
+      const changed = appendPacketTrailerToEncodedFrame(frame, packetTrailer, 1);
+
+      expect(changed).toBe(false);
+      expect(frame.data).toBe(payload.buffer);
+      expect(extractPacketTrailer(frame.data).metadata).toBeUndefined();
+    },
+  );
+
+  it('passes encoded frames through when publish options omit enabled features', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const frame = { data: payload.buffer } as RTCEncodedVideoFrame;
+
+    const changed = appendPacketTrailerToEncodedFrame(frame, { timestamp: false }, 1);
+
+    expect(changed).toBe(false);
+    expect(frame.data).toBe(payload.buffer);
+    expect(extractPacketTrailer(frame.data).metadata).toBeUndefined();
+  });
+
+  it('passes encoded frames through when publish options are undefined', () => {
+    const payload = Uint8Array.from([1, 2, 3, 4]);
+    const frame = { data: payload.buffer } as RTCEncodedVideoFrame;
+
+    const changed = appendPacketTrailerToEncodedFrame(frame, undefined, 1);
+
+    expect(changed).toBe(false);
+    expect(frame.data).toBe(payload.buffer);
+  });
+});

package/src/packetTrailer/packetTrailer.ts

@@ -0,0 +1,276 @@
+import type { PacketTrailerMetadata, PacketTrailerPublishOptions } from './types';
+import { hasPacketTrailerPublishOptions } from './utils';
+
+export const PACKET_TRAILER_MAGIC = Uint8Array.from([
+  'L'.charCodeAt(0),
+  'K'.charCodeAt(0),
+  'T'.charCodeAt(0),
+  'S'.charCodeAt(0),
+]);
+
+export const PACKET_TRAILER_TIMESTAMP_TAG = 0x01;
+export const PACKET_TRAILER_FRAME_ID_TAG = 0x02;
+export const PACKET_TRAILER_ENVELOPE_SIZE = 5;
+
+const TIMESTAMP_TLV_SIZE = 10;
+const FRAME_ID_TLV_SIZE = 6;
+
+export interface ExtractPacketTrailerResult {
+  data: Uint8Array;
+  metadata?: PacketTrailerMetadata;
+}
+
+export function appendPacketTrailer(
+  data: Uint8Array,
+  userTimestamp: bigint,
+  frameId: number,
+): Uint8Array {
+  const hasTimestamp = userTimestamp !== BigInt(0);
+  const hasFrameId = frameId !== 0;
+
+  if (!hasTimestamp && !hasFrameId) {
+    return data;
+  }
+
+  const trailerLength =
+    (hasTimestamp ? TIMESTAMP_TLV_SIZE : 0) +
+    (hasFrameId ? FRAME_ID_TLV_SIZE : 0) +
+    PACKET_TRAILER_ENVELOPE_SIZE;
+  const result = new Uint8Array(data.length + trailerLength);
+  let offset = 0;
+
+  result.set(data, offset);
+  offset += data.length;
+
+  if (hasTimestamp) {
+    result[offset++] = PACKET_TRAILER_TIMESTAMP_TAG ^ 0xff;
+    result[offset++] = 8 ^ 0xff;
+    writeUint64Xor(result, offset, userTimestamp);
+    offset += 8;
+  }
+
+  if (hasFrameId) {
+    result[offset++] = PACKET_TRAILER_FRAME_ID_TAG ^ 0xff;
+    result[offset++] = 4 ^ 0xff;
+    writeUint32Xor(result, offset, frameId);
+    offset += 4;
+  }
+
+  result[offset++] = trailerLength ^ 0xff;
+  result.set(PACKET_TRAILER_MAGIC, offset);
+
+  return result;
+}
+
+export function appendPacketTrailerToEncodedFrame(
+  frame: RTCEncodedVideoFrame,
+  options: PacketTrailerPublishOptions | undefined,
+  frameId: number,
+): boolean {
+  if (!hasPacketTrailerPublishOptions(options) || frame.data.byteLength === 0) {
+    return false;
+  }
+
+  const userTimestamp = options?.timestamp ? BigInt(Date.now()) * BigInt(1000) : BigInt(0);
+  const packetTrailerFrameId = options?.frameId ? frameId : 0;
+  const data = new Uint8Array(frame.data);
+  const result = appendPacketTrailer(data, userTimestamp, packetTrailerFrameId);
+
+  if (result.byteLength === data.byteLength) {
+    return false;
+  }
+
+  frame.data = result.buffer.slice(
+    result.byteOffset,
+    result.byteOffset + result.byteLength,
+  ) as ArrayBuffer;
+  return true;
+}
+
+export function extractPacketTrailer(data: ArrayBuffer | Uint8Array): ExtractPacketTrailerResult {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  if (bytes.length < PACKET_TRAILER_ENVELOPE_SIZE) {
+    return { data: bytes };
+  }
+
+  const magicOffset = bytes.length - PACKET_TRAILER_MAGIC.length;
+  if (!matchesMagic(bytes, magicOffset)) {
+    return { data: bytes };
+  }
+
+  const trailerLength = bytes[bytes.length - PACKET_TRAILER_ENVELOPE_SIZE] ^ 0xff;
+  if (trailerLength < PACKET_TRAILER_ENVELOPE_SIZE || trailerLength > bytes.length) {
+    return { data: bytes };
+  }
+
+  const trailerStart = bytes.length - trailerLength;
+  const trailerEnd = bytes.length - PACKET_TRAILER_ENVELOPE_SIZE;
+  const strippedData = bytes.subarray(0, trailerStart);
+  let offset = trailerStart;
+  let foundAny = false;
+  const metadata: PacketTrailerMetadata = {
+    userTimestamp: BigInt(0),
+    frameId: 0,
+  };
+
+  while (offset + 2 <= trailerEnd) {
+    const tag = bytes[offset++] ^ 0xff;
+    const length = bytes[offset++] ^ 0xff;
+
+    if (offset + length > trailerEnd) {
+      break;
+    }
+
+    if (tag === PACKET_TRAILER_TIMESTAMP_TAG && length === 8) {
+      metadata.userTimestamp = readUint64Xor(bytes, offset);
+      foundAny = true;
+    } else if (tag === PACKET_TRAILER_FRAME_ID_TAG && length === 4) {
+      metadata.frameId = readUint32Xor(bytes, offset, length);
+      foundAny = true;
+    }
+
+    offset += length;
+  }
+
+  if (!foundAny) {
+    return { data: bytes };
+  }
+
+  return { data: strippedData, metadata };
+}
+
+function matchesMagic(data: Uint8Array, offset: number) {
+  for (let index = 0; index < PACKET_TRAILER_MAGIC.length; index += 1) {
+    if (data[offset + index] !== PACKET_TRAILER_MAGIC[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function readUint64Xor(data: Uint8Array, offset: number): bigint {
+  const hi = BigInt(
+    (((data[offset] ^ 0xff) << 24) |
+      ((data[offset + 1] ^ 0xff) << 16) |
+      ((data[offset + 2] ^ 0xff) << 8) |
+      (data[offset + 3] ^ 0xff)) >>>
+      0,
+  );
+  const lo = BigInt(
+    (((data[offset + 4] ^ 0xff) << 24) |
+      ((data[offset + 5] ^ 0xff) << 16) |
+      ((data[offset + 6] ^ 0xff) << 8) |
+      (data[offset + 7] ^ 0xff)) >>>
+      0,
+  );
+  return (hi << BigInt(32)) | lo;
+}
+
+function readUint32Xor(data: Uint8Array, offset: number, length: number) {
+  let value = 0;
+  for (let index = 0; index < length; index += 1) {
+    value = (value << 8) | (data[offset + index] ^ 0xff);
+  }
+  return value >>> 0;
+}
+
+function writeUint64Xor(target: Uint8Array, offset: number, value: bigint) {
+  const hi = Number((value >> BigInt(32)) & BigInt(0xffffffff));
+  const lo = Number(value & BigInt(0xffffffff));
+  target[offset] = (hi >>> 24) ^ 0xff;
+  target[offset + 1] = ((hi >>> 16) & 0xff) ^ 0xff;
+  target[offset + 2] = ((hi >>> 8) & 0xff) ^ 0xff;
+  target[offset + 3] = (hi & 0xff) ^ 0xff;
+  target[offset + 4] = (lo >>> 24) ^ 0xff;
+  target[offset + 5] = ((lo >>> 16) & 0xff) ^ 0xff;
+  target[offset + 6] = ((lo >>> 8) & 0xff) ^ 0xff;
+  target[offset + 7] = (lo & 0xff) ^ 0xff;
+}
+
+function writeUint32Xor(target: Uint8Array, offset: number, value: number) {
+  for (let index = 3; index >= 0; index -= 1) {
+    target[offset + (3 - index)] = ((value >> (index * 8)) & 0xff) ^ 0xff;
+  }
+}
+
+export function getFrameRtpTimestamp(
+  frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame,
+): number | undefined {
+  try {
+    const metadata = frame.getMetadata() as Record<string, unknown>;
+    if (typeof metadata.rtpTimestamp === 'number') {
+      return metadata.rtpTimestamp;
+    }
+    if (typeof metadata.timestamp === 'number') {
+      return metadata.timestamp;
+    }
+  } catch {
+    // getMetadata() might not be available
+  }
+  if (typeof frame.timestamp === 'number') {
+    return frame.timestamp;
+  }
+  return undefined;
+}
+
+export function getFrameSsrc(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): number {
+  try {
+    const metadata = frame.getMetadata() as Record<string, unknown>;
+    if (typeof metadata.synchronizationSource === 'number') {
+      return metadata.synchronizationSource;
+    }
+  } catch {}
+  return 0;
+}
+
+export interface PacketTrailerFramePayload {
+  trackId: string;
+  rtpTimestamp: number;
+  ssrc: number;
+  metadata: PacketTrailerMetadata;
+}
+
+export interface ProcessPacketTrailerResult {
+  data?: ArrayBuffer;
+  payload?: PacketTrailerFramePayload;
+}
+
+/**
+ * Extracts a packet trailer from an encoded frame and returns the stripped
+ * frame data (if any) along with a ready-to-post metadata payload. Returns an
+ * empty object when no trailer is present, an RTP timestamp can't be read, or
+ * a trackId isn't available.
+ */
+export function processPacketTrailer(
+  frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame,
+  trackId: string | undefined,
+): ProcessPacketTrailerResult {
+  if (frame.data.byteLength === 0) {
+    return {};
+  }
+
+  const result = extractPacketTrailer(frame.data);
+  if (!result.metadata) {
+    return {};
+  }
+
+  const strippedData = (result.data.buffer as ArrayBuffer).slice(
+    result.data.byteOffset,
+    result.data.byteOffset + result.data.byteLength,
+  );
+
+  const rtpTimestamp = getFrameRtpTimestamp(frame);
+  if (rtpTimestamp === undefined || !trackId) {
+    return { data: strippedData };
+  }
+
+  return {
+    data: strippedData,
+    payload: {
+      trackId,
+      rtpTimestamp,
+      ssrc: getFrameSsrc(frame),
+      metadata: result.metadata,
+    },
+  };
+}