@moqtap/codec 0.2.2 → 0.2.3

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),
         );