livekit-client 2.18.0 → 2.18.2

package/src/room/data-track/outgoing/OutgoingDataTrackManager.ts

@@ -1,27 +1,27 @@
 import { EventEmitter } from 'events';
 import type { Throws } from '@livekit/throws-transformer/throws';
 import type TypedEmitter from 'typed-emitter';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
 import { LoggerNames, getLogger } from '../../../logger';
 import { abortSignalAny, abortSignalTimeout } from '../../../utils/abort-signal-polyfill';
 import { Future } from '../../utils';
 import LocalDataTrack from '../LocalDataTrack';
-import { type EncryptionProvider } from '../e2ee';
-import type { DataTrackFrame } from '../frame';
+import type { DataTrackFrameInternal } from '../frame';
 import { DataTrackHandle, DataTrackHandleAllocator } from '../handle';
-import { DataTrackExtensions } from '../packet/extensions';
 import { type DataTrackInfo } from '../types';
 import {
   DataTrackPublishError,
-  DataTrackPublishErrorReason,
   DataTrackPushFrameError,
   DataTrackPushFrameErrorReason,
 } from './errors';
 import DataTrackOutgoingPipeline from './pipeline';
 import {
   type DataTrackOptions,
-  type EventPacketsAvailable,
+  type EventPacketAvailable,
   type EventSfuPublishRequest,
   type EventSfuUnpublishRequest,
+  type EventTrackPublished,
+  type EventTrackUnpublished,
   type SfuPublishResponseResult,
 } from './types';
 
@@ -29,20 +29,15 @@ const log = getLogger(LoggerNames.DataTracks);
 
 export type PendingDescriptor = {
   type: 'pending';
-  completionFuture: Future<
-    LocalDataTrack,
-    | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
-    | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Timeout>
-    | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>
-    | DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>
-  >;
+  /** Resolves when the descriptor is fully published. */
+  completionFuture: Future<void, DataTrackPublishError>;
 };
 export type ActiveDescriptor = {
   type: 'active';
   info: DataTrackInfo;
 
+  publishState: 'published' | 'republishing' | 'unpublished';
+
   pipeline: DataTrackOutgoingPipeline;
 
   /** Resolves when the descriptor is unpublished. */
@@ -57,11 +52,12 @@ export const Descriptor = {
       completionFuture: new Future(),
     };
   },
-  active(info: DataTrackInfo, encryptionProvider: EncryptionProvider | null): ActiveDescriptor {
+  active(info: DataTrackInfo, e2eeManager: BaseE2EEManager | null): ActiveDescriptor {
     return {
       type: 'active',
       info,
-      pipeline: new DataTrackOutgoingPipeline({ info, encryptionProvider }),
+      publishState: 'published',
+      pipeline: new DataTrackOutgoingPipeline({ info, e2eeManager }),
       unpublishingFuture: new Future(),
     };
   },
@@ -72,24 +68,28 @@ export type DataTrackOutgoingManagerCallbacks = {
   sfuPublishRequest: (event: EventSfuPublishRequest) => void;
   /** Request sent to the SFU to unpublish a track. */
   sfuUnpublishRequest: (event: EventSfuUnpublishRequest) => void;
-  /** Serialized packets are ready to be sent over the transport. */
-  packetsAvailable: (event: EventPacketsAvailable) => void;
+  /** A serialized packet is ready to be sent over the transport. */
+  packetAvailable: (event: EventPacketAvailable) => void;
+  /** A new {@link LocalDataTrack} has been published */
+  trackPublished: (event: EventTrackPublished) => void;
+  /** A {@link LocalDataTrack} has been unpublished */
+  trackUnpublished: (event: EventTrackUnpublished) => void;
 };
 
 type OutgoingDataTrackManagerOptions = {
   /**
    * Provider to use for encrypting outgoing frame payloads.
    *
-   * If none, end-to-end encryption will be disabled for all published tracks.
+   * If null, end-to-end encryption will be disabled for all published tracks.
    */
-  encryptionProvider?: EncryptionProvider;
+  e2eeManager?: BaseE2EEManager;
 };
 
 /** How long to wait when attempting to publish before timing out. */
 const PUBLISH_TIMEOUT_MILLISECONDS = 10_000;
 
 export default class OutgoingDataTrackManager extends (EventEmitter as new () => TypedEmitter<DataTrackOutgoingManagerCallbacks>) {
-  private encryptionProvider: EncryptionProvider | null;
+  private e2eeManager: BaseE2EEManager | null;
 
   private handleAllocator = new DataTrackHandleAllocator();
 
@@ -97,7 +97,7 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
 
   constructor(options?: OutgoingDataTrackManagerOptions) {
     super();
-    this.encryptionProvider = options?.encryptionProvider ?? null;
+    this.e2eeManager = options?.e2eeManager ?? null;
   }
 
   static withDescriptors(descriptors: Map<DataTrackHandle, Descriptor>) {
@@ -106,6 +106,18 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return manager;
   }
 
+  /** @internal */
+  updateE2eeManager(e2eeManager: BaseE2EEManager | null) {
+    this.e2eeManager = e2eeManager;
+
+    // Propegate downwards to all pre-existing pipelines
+    for (const descriptor of this.descriptors.values()) {
+      if (descriptor.type === 'active') {
+        descriptor.pipeline.updateE2eeManager(e2eeManager);
+      }
+    }
+  }
+
   /**
    * Used by attached {@link LocalDataTrack} instances to query their associated descriptor info.
    * @internal
@@ -114,39 +126,35 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return this.descriptors.get(handle) ?? null;
   }
 
-  createLocalDataTrack(handle: DataTrackHandle) {
-    const descriptor = this.getDescriptor(handle);
-    if (descriptor?.type !== 'active') {
-      return null;
-    }
-    return new LocalDataTrack(descriptor.info, this);
-  }
-
   /** Used by attached {@link LocalDataTrack} instances to broadcast data track packets to other
    * subscribers.
    * @internal
    */
-  tryProcessAndSend(
+  async tryProcessAndSend(
     handle: DataTrackHandle,
-    payload: Uint8Array,
-  ): Throws<
-    void,
-    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>
-    | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>
+    frame: DataTrackFrameInternal,
+  ): Promise<
+    Throws<
+      void,
+      | DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>
+      | DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>
+    >
   > {
     const descriptor = this.getDescriptor(handle);
     if (descriptor?.type !== 'active') {
       throw DataTrackPushFrameError.trackUnpublished();
     }
 
-    const frame: DataTrackFrame = {
-      payload,
-      extensions: new DataTrackExtensions(),
-    };
+    if (descriptor.publishState === 'unpublished') {
+      throw DataTrackPushFrameError.trackUnpublished();
+    }
+    if (descriptor.publishState === 'republishing') {
+      throw DataTrackPushFrameError.dropped('Data track republishing');
+    }
 
     try {
-      for (const packet of descriptor.pipeline.processFrame(frame)) {
-        this.emit('packetsAvailable', { bytes: packet.toBinary() });
+      for await (const packet of descriptor.pipeline.processFrame(frame)) {
+        this.emit('packetAvailable', { bytes: packet.toBinary() });
       }
     } catch (err) {
       // NOTE: In the rust implementation this "dropped" error means something different (not enough room
@@ -155,8 +163,18 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     }
   }
 
-  /** Client requested to publish a track. */
-  async publishRequest(options: DataTrackOptions, signal?: AbortSignal) {
+  /**
+   * Client requested to publish a track.
+   *
+   * If the LiveKit server is too old and doesn't support data tracks, a
+   * {@link DataTrackPublishError#timeout} will be thrown.
+   *
+   * @internal
+   **/
+  async publishRequest(
+    options: DataTrackOptions,
+    signal?: AbortSignal,
+  ): Promise<Throws<DataTrackHandle, DataTrackPublishError>> {
     const handle = this.handleAllocator.get();
     if (!handle) {
       throw DataTrackPublishError.limitReached();
@@ -195,23 +213,33 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     };
     if (combinedSignal.aborted) {
       onAbort(); // NOTE: this rejects `completionFuture`; the next line just returns the rejection
-      return descriptor.completionFuture.promise;
+      return descriptor.completionFuture.promise.then(
+        () => handle /* no-op, makes typescript happy */,
+      );
     }
     combinedSignal.addEventListener('abort', onAbort);
 
     this.emit('sfuPublishRequest', {
       handle,
       name: options.name,
-      usesE2ee: this.encryptionProvider !== null,
+      usesE2ee: this.e2eeManager !== null,
     });
 
-    const localDataTrack = await descriptor.completionFuture.promise;
+    await descriptor.completionFuture.promise;
     combinedSignal.removeEventListener('abort', onAbort);
-    return localDataTrack;
+
+    this.emit('trackPublished', {
+      track: LocalDataTrack.withExplicitHandle(options, this, handle),
+    });
+
+    return handle;
   }
 
-  /** Get information about all currently published tracks. */
-  async queryPublished() {
+  /**
+   * Get information about all currently published tracks.
+   * @internal
+   **/
+  queryPublished() {
     const descriptorInfos = Array.from(this.descriptors.values())
       .filter((descriptor): descriptor is ActiveDescriptor => descriptor.type === 'active')
       .map((descriptor) => descriptor.info);
@@ -219,7 +247,10 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     return descriptorInfos;
   }
 
-  /** Client request to unpublish a track. */
+  /**
+   * Client request to unpublish a track.
+   * @internal
+   **/
   async unpublishRequest(handle: DataTrackHandle) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -234,9 +265,14 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     this.emit('sfuUnpublishRequest', { handle });
 
     await descriptor.unpublishingFuture.promise;
+
+    this.emit('trackUnpublished', { sid: descriptor.info.sid });
   }
 
-  /** SFU responded to a request to publish a data track. */
+  /**
+   * SFU responded to a request to publish a data track.
+   * @internal
+   **/
   receivedSfuPublishResponse(handle: DataTrackHandle, result: SfuPublishResponseResult) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -245,32 +281,41 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
     }
     this.descriptors.delete(handle);
 
-    if (descriptor.type !== 'pending') {
-      log.warn(`Track ${handle} already active`);
-      return;
-    }
-
-    if (result.type === 'ok') {
-      const info = result.data;
-
-      const encryptionProvider = info.usesE2ee ? this.encryptionProvider : null;
-      this.descriptors.set(info.pubHandle, Descriptor.active(info, encryptionProvider));
-
-      const localDataTrack = this.createLocalDataTrack(info.pubHandle);
-      if (!localDataTrack) {
-        // @throws-transformer ignore - this should be treated as a "panic" and not be caught
-        throw new Error(
-          'DataTrackOutgoingManager.handleSfuPublishResponse: localDataTrack was not created after active descriptor stored.',
-        );
+    switch (descriptor.type) {
+      case 'pending': {
+        if (result.type === 'ok') {
+          const info = result.data;
+          const e2eeManager = info.usesE2ee ? this.e2eeManager : null;
+          this.descriptors.set(info.pubHandle, Descriptor.active(info, e2eeManager));
+
+          descriptor.completionFuture.resolve?.();
+        } else {
+          descriptor.completionFuture.reject?.(result.error);
+        }
+        return;
+      }
+      case 'active': {
+        if (descriptor.publishState !== 'republishing') {
+          log.warn(`Track ${handle} already active`);
+          return;
+        }
+        if (result.type === 'error') {
+          log.warn(`Republish failed for track ${handle}`);
+          return;
+        }
+
+        log.debug(`Track ${handle} republished`);
+        descriptor.info.sid = result.data.sid;
+        descriptor.publishState = 'published';
+        this.descriptors.set(descriptor.info.pubHandle, descriptor);
       }
-
-      descriptor.completionFuture.resolve?.(localDataTrack);
-    } else {
-      descriptor.completionFuture.reject?.(result.error);
     }
   }
 
-  /** SFU notification that a track has been unpublished. */
+  /**
+   * SFU notification that a track has been unpublished.
+   * @internal
+   **/
   receivedSfuUnpublishResponse(handle: DataTrackHandle) {
     const descriptor = this.descriptors.get(handle);
     if (!descriptor) {
@@ -284,10 +329,40 @@ export default class OutgoingDataTrackManager extends (EventEmitter as new () =>
       return;
     }
 
+    descriptor.publishState = 'unpublished';
     descriptor.unpublishingFuture.resolve?.();
   }
 
-  /** Shuts down the manager and all associated tracks. */
+  /** Republish all tracks.
+   *
+   * This must be sent after a full reconnect in order for existing publications
+   * to be recognized by the SFU. Each republished track will be assigned a new SID.
+   * @internal
+   */
+  sfuWillRepublishTracks() {
+    for (const [handle, descriptor] of this.descriptors.entries()) {
+      switch (descriptor.type) {
+        case 'pending':
+          // TODO: support republish for pending publications
+          this.descriptors.delete(handle);
+          descriptor.completionFuture.reject?.(DataTrackPublishError.disconnected());
+          break;
+        case 'active':
+          descriptor.publishState = 'republishing';
+
+          this.emit('sfuPublishRequest', {
+            handle: descriptor.info.pubHandle,
+            name: descriptor.info.name,
+            usesE2ee: descriptor.info.usesE2ee,
+          });
+      }
+    }
+  }
+
+  /**
+   * Shuts down the manager and all associated tracks.
+   * @internal
+   **/
   async shutdown() {
     for (const descriptor of this.descriptors.values()) {
       switch (descriptor.type) {

package/src/room/data-track/outgoing/errors.ts

@@ -23,10 +23,17 @@ export enum DataTrackPublishErrorReason {
 
   // NOTE: this was introduced by web / there isn't a corresponding case in the rust version.
   Cancelled = 5,
+
+  /** The name requested is not able to be used when creating the data track. */
+  InvalidName = 6,
+
+  /** There was an error publishing, but it was not something that could be sorted into a known
+   * category. */
+  Unknown = 7,
 }
 
 export class DataTrackPublishError<
-  Reason extends DataTrackPublishErrorReason,
+  Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason,
 > extends LivekitReasonedError<Reason> {
   readonly name = 'DataTrackPublishError';
 
@@ -34,37 +41,59 @@ export class DataTrackPublishError<
 
   reasonName: string;
 
-  constructor(message: string, reason: Reason, options?: { cause?: unknown }) {
+  /** Underling message from the SFU, if one was provided */
+  rawMessage?: string;
+
+  constructor(message: string, reason: Reason, options?: { rawMessage?: string; cause?: unknown }) {
     super(21, message, options);
     this.reason = reason;
     this.reasonName = DataTrackPublishErrorReason[reason];
+    this.rawMessage = options?.rawMessage;
   }
 
-  static notAllowed() {
+  static notAllowed(rawMessage?: string) {
     return new DataTrackPublishError(
       'Data track publishing unauthorized',
       DataTrackPublishErrorReason.NotAllowed,
+      { rawMessage },
     );
   }
 
-  static duplicateName() {
+  static duplicateName(rawMessage?: string) {
     return new DataTrackPublishError(
       'Track name already taken',
       DataTrackPublishErrorReason.DuplicateName,
+      { rawMessage },
+    );
+  }
+
+  static invalidName(rawMessage?: string) {
+    return new DataTrackPublishError(
+      'Track name is invalid',
+      DataTrackPublishErrorReason.InvalidName,
+      { rawMessage },
     );
   }
 
   static timeout() {
     return new DataTrackPublishError(
-      'Publish data track timed-out',
+      'Publish data track timed-out. Does the LiveKit server support data tracks?',
       DataTrackPublishErrorReason.Timeout,
     );
   }
 
-  static limitReached() {
+  static limitReached(rawMessage?: string) {
     return new DataTrackPublishError(
       'Data track publication limit reached',
       DataTrackPublishErrorReason.LimitReached,
+      { rawMessage },
+    );
+  }
+
+  static unknown(reason: number, message: string) {
+    return new DataTrackPublishError(
+      `Received RequestResponse for publishDataTrack, but reason was unrecognised (${reason}, ${message})`,
+      DataTrackPublishErrorReason.Unknown,
     );
   }
 
@@ -112,7 +141,7 @@ export class DataTrackPushFrameError<
     );
   }
 
-  static dropped(cause: unknown) {
+  static dropped(cause?: unknown) {
     return new DataTrackPushFrameError('Frame was dropped', DataTrackPushFrameErrorReason.Dropped, {
       cause,
     });

package/src/room/data-track/outgoing/pipeline.ts

@@ -1,6 +1,6 @@
 import { type Throws } from '@livekit/throws-transformer/throws';
-import { type EncryptedPayload, type EncryptionProvider } from '../e2ee';
-import { type DataTrackFrame } from '../frame';
+import type { BaseE2EEManager } from '../../../e2ee/E2eeManager';
+import { type DataTrackFrameInternal } from '../frame';
 import { DataTrackPacket } from '../packet';
 import { DataTrackE2eeExtension } from '../packet/extensions';
 import DataTrackPacketizer, { DataTrackPacketizerError } from '../packetizer';
@@ -9,12 +9,12 @@ import { DataTrackOutgoingPipelineError, DataTrackOutgoingPipelineErrorReason }
 
 type Options = {
   info: DataTrackInfo;
-  encryptionProvider: EncryptionProvider | null;
+  e2eeManager: BaseE2EEManager | null;
 };
 
 /** Processes outgoing frames into final packets for distribution to the SFU. */
 export default class DataTrackOutgoingPipeline {
-  private encryptionProvider: EncryptionProvider | null;
+  private e2eeManager: BaseE2EEManager | null;
 
   private packetizer: DataTrackPacketizer;
 
@@ -22,17 +22,21 @@ export default class DataTrackOutgoingPipeline {
   private static TRANSPORT_MTU_BYTES = 16_000;
 
   constructor(options: Options) {
-    this.encryptionProvider = options.encryptionProvider;
+    this.e2eeManager = options.e2eeManager;
     this.packetizer = new DataTrackPacketizer(
       options.info.pubHandle,
       DataTrackOutgoingPipeline.TRANSPORT_MTU_BYTES,
     );
   }
 
-  *processFrame(
-    frame: DataTrackFrame,
-  ): Throws<Generator<DataTrackPacket>, DataTrackOutgoingPipelineError> {
-    const encryptedFrame = this.encryptIfNeeded(frame);
+  updateE2eeManager(e2eeManager: BaseE2EEManager | null) {
+    this.e2eeManager = e2eeManager;
+  }
+
+  async *processFrame(
+    frame: DataTrackFrameInternal,
+  ): Throws<AsyncGenerator<DataTrackPacket>, DataTrackOutgoingPipelineError> {
+    const encryptedFrame = await this.encryptIfNeeded(frame);
 
     try {
       yield* this.packetizer.packetize(encryptedFrame);
@@ -44,19 +48,21 @@ export default class DataTrackOutgoingPipeline {
     }
   }
 
-  encryptIfNeeded(
-    frame: DataTrackFrame,
-  ): Throws<
-    DataTrackFrame,
-    DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+  async encryptIfNeeded(
+    frame: DataTrackFrameInternal,
+  ): Promise<
+    Throws<
+      DataTrackFrameInternal,
+      DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>
+    >
   > {
-    if (!this.encryptionProvider) {
+    if (!this.e2eeManager) {
       return frame;
     }
 
-    let encryptedResult: EncryptedPayload;
+    let encryptedResult;
     try {
-      encryptedResult = this.encryptionProvider.encrypt(frame.payload);
+      encryptedResult = await this.e2eeManager.encryptData(frame.payload);
     } catch (err) {
       throw DataTrackOutgoingPipelineError.encryption(err);
     }

package/src/room/data-track/outgoing/types.ts

@@ -1,5 +1,6 @@
+import type LocalDataTrack from '../LocalDataTrack';
 import { type DataTrackHandle } from '../handle';
-import { type DataTrackInfo } from '../types';
+import { type DataTrackInfo, type DataTrackSid } from '../types';
 import { type DataTrackPublishError, type DataTrackPublishErrorReason } from './errors';
 
 /** Options for publishing a data track. */
@@ -15,6 +16,7 @@ export type SfuPublishResponseResult =
       error:
         | DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>
         | DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>
+        | DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>
         | DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
     };
 
@@ -30,7 +32,14 @@ export type EventSfuUnpublishRequest = {
   handle: DataTrackHandle;
 };
 
-/** Serialized packets are ready to be sent over the transport. */
-export type EventPacketsAvailable = {
+/** A serialized packet is ready to be sent over the transport. */
+export type EventPacketAvailable = {
   bytes: Uint8Array;
 };
+
+/** A track has been created by a local participant and is available to be
+ * subscribed to. */
+export type EventTrackPublished = { track: LocalDataTrack };
+
+/** A track has been unpublished by a remote participant and can no longer be subscribed to. */
+export type EventTrackUnpublished = { sid: DataTrackSid };

package/src/room/data-track/packet/extensions.ts

@@ -1,6 +1,6 @@
 import { type Throws } from '@livekit/throws-transformer/throws';
 import { coerceToDataView } from '../utils';
-import { EXT_TAG_PADDING, U8_LENGTH_BYTES, U16_LENGTH_BYTES, U64_LENGTH_BYTES } from './constants';
+import { EXT_TAG_PADDING, U8_LENGTH_BYTES, U64_LENGTH_BYTES } from './constants';
 import { DataTrackDeserializeError, DataTrackDeserializeErrorReason } from './errors';
 import Serializable from './serializable';
 
@@ -29,8 +29,8 @@ export class DataTrackUserTimestampExtension extends DataTrackExtension {
 
   toBinaryLengthBytes(): number {
     return (
-      U16_LENGTH_BYTES /* tag */ +
-      U16_LENGTH_BYTES /* length */ +
+      U8_LENGTH_BYTES /* tag */ +
+      U8_LENGTH_BYTES /* length */ +
       DataTrackUserTimestampExtension.lengthBytes
     );
   }
@@ -38,12 +38,11 @@ export class DataTrackUserTimestampExtension extends DataTrackExtension {
   toBinaryInto(dataView: DataView): Throws<number, never> {
     let byteIndex = 0;
 
-    dataView.setUint16(byteIndex, DataTrackUserTimestampExtension.tag);
-    byteIndex += U16_LENGTH_BYTES;
+    dataView.setUint8(byteIndex, DataTrackUserTimestampExtension.tag);
+    byteIndex += U8_LENGTH_BYTES;
 
-    const rtpOrientedLength = DataTrackUserTimestampExtension.lengthBytes - 1;
-    dataView.setUint16(byteIndex, rtpOrientedLength);
-    byteIndex += U16_LENGTH_BYTES;
+    dataView.setUint8(byteIndex, DataTrackUserTimestampExtension.lengthBytes);
+    byteIndex += U8_LENGTH_BYTES;
 
     dataView.setBigUint64(byteIndex, this.timestamp);
     byteIndex += U64_LENGTH_BYTES;
@@ -86,21 +85,18 @@ export class DataTrackE2eeExtension extends DataTrackExtension {
 
   toBinaryLengthBytes(): number {
     return (
-      U16_LENGTH_BYTES /* tag */ +
-      U16_LENGTH_BYTES /* length */ +
-      DataTrackE2eeExtension.lengthBytes
+      U8_LENGTH_BYTES /* tag */ + U8_LENGTH_BYTES /* length */ + DataTrackE2eeExtension.lengthBytes
     );
   }
 
   toBinaryInto(dataView: DataView): Throws<number, never> {
     let byteIndex = 0;
 
-    dataView.setUint16(byteIndex, DataTrackE2eeExtension.tag);
-    byteIndex += U16_LENGTH_BYTES;
+    dataView.setUint8(byteIndex, DataTrackE2eeExtension.tag);
+    byteIndex += U8_LENGTH_BYTES;
 
-    const rtpOrientedLength = DataTrackE2eeExtension.lengthBytes - 1;
-    dataView.setUint16(byteIndex, rtpOrientedLength);
-    byteIndex += U16_LENGTH_BYTES;
+    dataView.setUint8(byteIndex, DataTrackE2eeExtension.lengthBytes);
+    byteIndex += U8_LENGTH_BYTES;
 
     dataView.setUint8(byteIndex, this.keyIndex);
     byteIndex += U8_LENGTH_BYTES;
@@ -194,13 +190,12 @@ export class DataTrackExtensions extends Serializable {
     let e2ee: DataTrackE2eeExtension | undefined;
 
     let byteIndex = 0;
-    while (dataView.byteLength - byteIndex >= U16_LENGTH_BYTES + U16_LENGTH_BYTES) {
-      const tag = dataView.getUint16(byteIndex);
-      byteIndex += U16_LENGTH_BYTES;
+    while (dataView.byteLength - byteIndex >= U8_LENGTH_BYTES + U8_LENGTH_BYTES) {
+      const tag = dataView.getUint8(byteIndex);
+      byteIndex += U8_LENGTH_BYTES;
 
-      const rtpOrientedLength = dataView.getUint16(byteIndex);
-      const lengthBytes = rtpOrientedLength + 1;
-      byteIndex += U16_LENGTH_BYTES;
+      const lengthBytes = dataView.getUint8(byteIndex);
+      byteIndex += U8_LENGTH_BYTES;
 
       if (tag === EXT_TAG_PADDING) {
         // Skip padding