@moqtap/codec 0.2.1 → 0.2.3

package/src/core/buffer-reader.ts

@@ -1,114 +1,130 @@
-import { DecodeError } from "./types.js";
-
-export class BufferReader {
-  private readonly view: DataView;
-  private pos: number;
-
-  constructor(
-    readonly buffer: Uint8Array,
-    offset = 0,
-  ) {
-    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    this.pos = offset;
-  }
-
-  get offset(): number {
-    return this.pos;
-  }
-
-  get remaining(): number {
-    return this.buffer.byteLength - this.pos;
-  }
-
-  readUint8(): number {
-    if (this.remaining < 1) {
-      throw new DecodeError("UNEXPECTED_END", "Not enough bytes to read uint8", this.pos);
-    }
-    const value = this.view.getUint8(this.pos);
-    this.pos += 1;
-    return value;
-  }
-
-  readBytes(length: number): Uint8Array<ArrayBuffer> {
-    if (this.remaining < length) {
-      throw new DecodeError(
-        "UNEXPECTED_END",
-        `Not enough bytes: need ${length}, have ${this.remaining}`,
-        this.pos,
-      );
-    }
-    const slice = this.buffer.slice(this.pos, this.pos + length);
-    this.pos += length;
-    return slice;
-  }
-
-  readVarInt(): bigint {
-    if (this.remaining < 1) {
-      throw new DecodeError("UNEXPECTED_END", "Not enough bytes for varint", this.pos);
-    }
-    const first = this.view.getUint8(this.pos);
-    const prefix = first >> 6;
-    let length: number;
-    let value: bigint;
-
-    switch (prefix) {
-      case 0:
-        length = 1;
-        value = BigInt(first & 0x3f);
-        break;
-      case 1:
-        length = 2;
-        if (this.remaining < 2) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 2-byte varint", this.pos);
-        }
-        value = BigInt(this.view.getUint16(this.pos) & 0x3fff);
-        break;
-      case 2:
-        length = 4;
-        if (this.remaining < 4) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 4-byte varint", this.pos);
-        }
-        value = BigInt(this.view.getUint32(this.pos)) & 0x3fffffffn;
-        break;
-      case 3:
-        length = 8;
-        if (this.remaining < 8) {
-          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 8-byte varint", this.pos);
-        }
-        value = this.view.getBigUint64(this.pos) & 0x3fffffffffffffffn;
-        break;
-      default:
-        throw new DecodeError("INVALID_VARINT", "Invalid varint prefix", this.pos);
-    }
-
-    this.pos += length;
-    return value;
-  }
-
-  readString(): string {
-    const length = Number(this.readVarInt());
-    const bytes = this.readBytes(length);
-    return new TextDecoder().decode(bytes);
-  }
-
-  readTuple(): string[] {
-    const count = Number(this.readVarInt());
-    const result: string[] = [];
-    for (let i = 0; i < count; i++) {
-      result.push(this.readString());
-    }
-    return result;
-  }
-
-  readParameters(): Map<bigint, Uint8Array> {
-    const count = Number(this.readVarInt());
-    const params = new Map<bigint, Uint8Array>();
-    for (let i = 0; i < count; i++) {
-      const key = this.readVarInt();
-      const length = Number(this.readVarInt());
-      const value = this.readBytes(length);
-      params.set(key, value);
-    }
-    return params;
-  }
-}
+import { DecodeError } from "./types.js";
+
+const textDecoder = /* @__PURE__ */ new TextDecoder();
+
+export class BufferReader {
+  private readonly view: DataView;
+  private pos: number;
+
+  constructor(
+    readonly buffer: Uint8Array,
+    offset = 0,
+  ) {
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.pos = offset;
+  }
+
+  get offset(): number {
+    return this.pos;
+  }
+
+  get remaining(): number {
+    return this.buffer.byteLength - this.pos;
+  }
+
+  readUint8(): number {
+    if (this.remaining < 1) {
+      throw new DecodeError("UNEXPECTED_END", "Not enough bytes to read uint8", this.pos);
+    }
+    const value = this.view.getUint8(this.pos);
+    this.pos += 1;
+    return value;
+  }
+
+  readBytes(length: number): Uint8Array<ArrayBuffer> {
+    if (this.remaining < length) {
+      throw new DecodeError(
+        "UNEXPECTED_END",
+        `Not enough bytes: need ${length}, have ${this.remaining}`,
+        this.pos,
+      );
+    }
+    const slice = this.buffer.slice(this.pos, this.pos + length);
+    this.pos += length;
+    return slice;
+  }
+
+  /** Zero-copy read: returns a view into the underlying buffer. */
+  readBytesView(length: number): Uint8Array<ArrayBuffer> {
+    if (this.remaining < length) {
+      throw new DecodeError(
+        "UNEXPECTED_END",
+        `Not enough bytes: need ${length}, have ${this.remaining}`,
+        this.pos,
+      );
+    }
+    const view = this.buffer.subarray(this.pos, this.pos + length);
+    this.pos += length;
+    return view as Uint8Array<ArrayBuffer>;
+  }
+
+  readVarInt(): bigint {
+    if (this.remaining < 1) {
+      throw new DecodeError("UNEXPECTED_END", "Not enough bytes for varint", this.pos);
+    }
+    const first = this.view.getUint8(this.pos);
+    const prefix = first >> 6;
+    let length: number;
+    let value: bigint;
+
+    switch (prefix) {
+      case 0:
+        length = 1;
+        value = BigInt(first & 0x3f);
+        break;
+      case 1:
+        length = 2;
+        if (this.remaining < 2) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 2-byte varint", this.pos);
+        }
+        value = BigInt(this.view.getUint16(this.pos) & 0x3fff);
+        break;
+      case 2:
+        length = 4;
+        if (this.remaining < 4) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 4-byte varint", this.pos);
+        }
+        value = BigInt(this.view.getUint32(this.pos)) & 0x3fffffffn;
+        break;
+      case 3:
+        length = 8;
+        if (this.remaining < 8) {
+          throw new DecodeError("UNEXPECTED_END", "Not enough bytes for 8-byte varint", this.pos);
+        }
+        value = this.view.getBigUint64(this.pos) & 0x3fffffffffffffffn;
+        break;
+      default:
+        throw new DecodeError("INVALID_VARINT", "Invalid varint prefix", this.pos);
+    }
+
+    this.pos += length;
+    return value;
+  }
+
+  readString(): string {
+    const length = Number(this.readVarInt());
+    const bytes = this.readBytesView(length);
+    return textDecoder.decode(bytes);
+  }
+
+  readTuple(): string[] {
+    const count = Number(this.readVarInt());
+    const result: string[] = [];
+    for (let i = 0; i < count; i++) {
+      result.push(this.readString());
+    }
+    return result;
+  }
+
+  readParameters(): Map<bigint, Uint8Array> {
+    const count = Number(this.readVarInt());
+    const params = new Map<bigint, Uint8Array>();
+    for (let i = 0; i < count; i++) {
+      const key = this.readVarInt();
+      const length = Number(this.readVarInt());
+      const value = this.readBytes(length);
+      params.set(key, value);
+    }
+    return params;
+  }
+}

package/src/core/buffer-writer.ts

@@ -1,91 +1,100 @@
-export class BufferWriter {
-  private buffer: Uint8Array;
-  private view: DataView;
-  private pos: number;
-
-  constructor(initialSize = 256) {
-    this.buffer = new Uint8Array(initialSize);
-    this.view = new DataView(this.buffer.buffer);
-    this.pos = 0;
-  }
-
-  get offset(): number {
-    return this.pos;
-  }
-
-  private ensureCapacity(needed: number): void {
-    const required = this.pos + needed;
-    if (required <= this.buffer.byteLength) return;
-
-    let newSize = this.buffer.byteLength * 2;
-    while (newSize < required) newSize *= 2;
-
-    const newBuffer = new Uint8Array(newSize);
-    newBuffer.set(this.buffer);
-    this.buffer = newBuffer;
-    this.view = new DataView(this.buffer.buffer);
-  }
-
-  writeUint8(value: number): void {
-    this.ensureCapacity(1);
-    this.view.setUint8(this.pos, value);
-    this.pos += 1;
-  }
-
-  writeBytes(bytes: Uint8Array): void {
-    this.ensureCapacity(bytes.byteLength);
-    this.buffer.set(bytes, this.pos);
-    this.pos += bytes.byteLength;
-  }
-
-  writeVarInt(value: number | bigint): void {
-    const v = BigInt(value);
-    if (v < 0n) throw new Error("VarInt value must be non-negative");
-
-    if (v < 0x40n) {
-      this.ensureCapacity(1);
-      this.view.setUint8(this.pos, Number(v));
-      this.pos += 1;
-    } else if (v < 0x4000n) {
-      this.ensureCapacity(2);
-      this.view.setUint16(this.pos, Number(v) | 0x4000);
-      this.pos += 2;
-    } else if (v < 0x40000000n) {
-      this.ensureCapacity(4);
-      this.view.setUint32(this.pos, Number(v) | 0x80000000);
-      this.pos += 4;
-    } else if (v < 0x4000000000000000n) {
-      this.ensureCapacity(8);
-      this.view.setBigUint64(this.pos, v | 0xc000000000000000n);
-      this.pos += 8;
-    } else {
-      throw new Error("VarInt value exceeds 62-bit range");
-    }
-  }
-
-  writeString(str: string): void {
-    const encoded = new TextEncoder().encode(str);
-    this.writeVarInt(encoded.byteLength);
-    this.writeBytes(encoded);
-  }
-
-  writeTuple(values: string[]): void {
-    this.writeVarInt(values.length);
-    for (const v of values) {
-      this.writeString(v);
-    }
-  }
-
-  writeParameters(params: Map<bigint, Uint8Array>): void {
-    this.writeVarInt(params.size);
-    for (const [key, value] of params) {
-      this.writeVarInt(key);
-      this.writeVarInt(value.byteLength);
-      this.writeBytes(value);
-    }
-  }
-
-  finish(): Uint8Array {
-    return this.buffer.slice(0, this.pos);
-  }
-}
+const textEncoder = /* @__PURE__ */ new TextEncoder();
+
+export class BufferWriter {
+  private buffer: Uint8Array;
+  private view: DataView;
+  private pos: number;
+
+  constructor(initialSize = 256) {
+    this.buffer = new Uint8Array(initialSize);
+    this.view = new DataView(this.buffer.buffer);
+    this.pos = 0;
+  }
+
+  get offset(): number {
+    return this.pos;
+  }
+
+  private ensureCapacity(needed: number): void {
+    const required = this.pos + needed;
+    if (required <= this.buffer.byteLength) return;
+
+    let newSize = this.buffer.byteLength * 2;
+    while (newSize < required) newSize *= 2;
+
+    const newBuffer = new Uint8Array(newSize);
+    newBuffer.set(this.buffer);
+    this.buffer = newBuffer;
+    this.view = new DataView(this.buffer.buffer);
+  }
+
+  writeUint8(value: number): void {
+    this.ensureCapacity(1);
+    this.view.setUint8(this.pos, value);
+    this.pos += 1;
+  }
+
+  writeBytes(bytes: Uint8Array): void {
+    this.ensureCapacity(bytes.byteLength);
+    this.buffer.set(bytes, this.pos);
+    this.pos += bytes.byteLength;
+  }
+
+  writeVarInt(value: number | bigint): void {
+    const v = BigInt(value);
+    if (v < 0n) throw new Error("VarInt value must be non-negative");
+
+    if (v < 0x40n) {
+      this.ensureCapacity(1);
+      this.view.setUint8(this.pos, Number(v));
+      this.pos += 1;
+    } else if (v < 0x4000n) {
+      this.ensureCapacity(2);
+      this.view.setUint16(this.pos, Number(v) | 0x4000);
+      this.pos += 2;
+    } else if (v < 0x40000000n) {
+      this.ensureCapacity(4);
+      this.view.setUint32(this.pos, Number(v) | 0x80000000);
+      this.pos += 4;
+    } else if (v < 0x4000000000000000n) {
+      this.ensureCapacity(8);
+      this.view.setBigUint64(this.pos, v | 0xc000000000000000n);
+      this.pos += 8;
+    } else {
+      throw new Error("VarInt value exceeds 62-bit range");
+    }
+  }
+
+  writeString(str: string): void {
+    const encoded = textEncoder.encode(str);
+    this.writeVarInt(encoded.byteLength);
+    this.writeBytes(encoded);
+  }
+
+  writeTuple(values: string[]): void {
+    this.writeVarInt(values.length);
+    for (const v of values) {
+      this.writeString(v);
+    }
+  }
+
+  writeParameters(params: Map<bigint, Uint8Array>): void {
+    this.writeVarInt(params.size);
+    for (const [key, value] of params) {
+      this.writeVarInt(key);
+      this.writeVarInt(value.byteLength);
+      this.writeBytes(value);
+    }
+  }
+
+  /** Returns an owned copy of the written bytes. */
+  finish(): Uint8Array {
+    if (this.pos === this.buffer.byteLength) return this.buffer;
+    return this.buffer.slice(0, this.pos);
+  }
+
+  /** Returns a zero-copy view of the written bytes. Valid only until the next write. */
+  finishView(): Uint8Array {
+    return this.buffer.subarray(0, this.pos);
+  }
+}

package/src/core/hex.ts

@@ -1,10 +1,14 @@
+const HEX_TABLE = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>
+  i.toString(16).padStart(2, "0"),
+);
+
 /** Convert a Uint8Array to a lowercase hex string. */
 export function bytesToHex(bytes: Uint8Array): string {
-  let hex = "";
+  const parts = new Array<string>(bytes.byteLength);
   for (let i = 0; i < bytes.byteLength; i++) {
-    hex += (bytes[i] as number).toString(16).padStart(2, "0");
+    parts[i] = HEX_TABLE[bytes[i]!]!;
   }
-  return hex;
+  return parts.join("");
 }
 
 /** Convert a hex string to a Uint8Array. */

package/src/drafts/draft07/codec.ts

@@ -670,7 +670,7 @@ function decodeObjectDatagram(reader: BufferReader): ObjectDatagram {
       payload: new Uint8Array(0),
     };
   }
-  const payload = reader.readBytes(payloadLength);
+  const payload = reader.readBytesView(payloadLength);
   return {
     type: "object_datagram" as const,
     trackAlias,
@@ -768,10 +768,10 @@ function encodeMessageImpl(message: MoqtMessage): Uint8Array {
   // Encode payload first
   const payloadWriter = new BufferWriter();
   controlEncoder(message as never, payloadWriter);
-  const payload = payloadWriter.finish();
+  const payload = payloadWriter.finishView();
 
   // Write type + length + payload
-  const frameWriter = new BufferWriter();
+  const frameWriter = new BufferWriter(payload.byteLength + 16);
   frameWriter.writeVarInt(MESSAGE_TYPE_TO_WIRE[message.type as ControlMessageType]);
   frameWriter.writeVarInt(payload.byteLength);
   frameWriter.writeBytes(payload);
@@ -843,18 +843,23 @@ function decodeMessageImpl(bytes: Uint8Array): DecodeResult<MoqtMessage> {
 
 function createStreamDecoderImpl(): TransformStream<Uint8Array, MoqtMessage> {
   let buffer = new Uint8Array(0);
+  let offset = 0;
 
   return new TransformStream<Uint8Array, MoqtMessage>({
     transform(chunk, controller) {
-      // Accumulate incoming data
+      // Compact before accumulating new data
+      if (offset > 0) {
+        buffer = buffer.subarray(offset);
+        offset = 0;
+      }
       const newBuffer = new Uint8Array(buffer.length + chunk.length);
       newBuffer.set(buffer, 0);
       newBuffer.set(chunk, buffer.length);
       buffer = newBuffer;
 
       // Try to decode messages from the buffer
-      while (buffer.length > 0) {
-        const result = decodeMessageImpl(buffer);
+      while (offset < buffer.length) {
+        const result = decodeMessageImpl(buffer.subarray(offset));
         if (!result.ok) {
           if (result.error.code === "UNEXPECTED_END") {
             // Need more data -- wait for next chunk
@@ -865,14 +870,14 @@ function createStreamDecoderImpl(): TransformStream<Uint8Array, MoqtMessage> {
           return;
         }
         controller.enqueue(result.value);
-        // Advance the buffer past the consumed bytes
-        buffer = buffer.slice(result.bytesRead);
+        // Advance offset past the consumed bytes
+        offset += result.bytesRead;
       }
     },
 
     flush(controller) {
       // If there is remaining data in the buffer, it is a truncated message
-      if (buffer.length > 0) {
+      if (offset < buffer.length) {
         controller.error(
           new DecodeError("UNEXPECTED_END", "Stream ended with incomplete message data", 0),
         );