@torrent-tv/proxy 2.90.0 → 2.92.0

package/services/media/container/h264-elementary-index.js

@@ -0,0 +1,245 @@
+import { avcConfigurationFromUnits, avcOrderParameters } from "./h264-configuration.js";
+import { AvcPictureOrder } from "./avc-picture-order.js";
+import { CadencedPictureOrder } from "./CadencedPictureOrder.js";
+
+/** Incremental AVC access units, retaining addresses rather than frame payloads. */
+export class H264ElementaryIndex {
+  #track;
+  #index;
+  #position = 0;
+  #zeroes = 0;
+  #nal = null;
+  #mappings = [];
+  #stamps = [];
+  #sets = new Map();
+  #frame = null;
+  #prefix = 0;
+  #recent = [];
+  #picStruct = null;
+  #order = null;
+  #orderUsesClockTicks = false;
+  #anchor = null;
+  #cadenced = null;
+
+  constructor(track, index) {
+    this.#track = track; this.#index = index;
+    if (track.presentationCadenceSeconds > 0) this.#cadenced = new CadencedPictureOrder(track, index);
+  }
+
+  push(bytes, sourceStart, stamp) {
+    const from = this.#position;
+    this.#mappings.push({ from, to: from + bytes.length, sourceStart });
+    if (stamp?.pts !== null && stamp?.pts !== undefined) this.#stamps.push({ position: from, pts: stamp.pts, dts: stamp.dts ?? stamp.pts });
+    for (const byte of bytes) {
+      if (byte === 1 && this.#zeroes >= 2) {
+        const start = this.#position - this.#zeroes;
+        if (this.#nal) this.#finishNal(start);
+        this.#nal = { start, payloadStart: this.#position + 1, bytes: [], type: null, sei: null, seiZeroes: 0 };
+      } else if (this.#nal) {
+        if (this.#nal.type === null) {
+          if (byte & 128 || !(byte & 31)) throw new Error("AVC NAL header is invalid.");
+          this.#nal.type = byte & 31;
+          if (this.#nal.type === 6) this.#nal.sei = new SeiTiming();
+        } else if (this.#nal.sei) {
+          if (byte === 0) this.#nal.seiZeroes++;
+          else {
+            while (this.#nal.seiZeroes > 0) {
+              this.#nal.sei.push(0);
+              this.#nal.seiZeroes--;
+            }
+            this.#nal.sei.push(byte);
+          }
+        }
+        // Retain only the slice prefix needed for macroblock and picture order.
+        const limit = [7, 8].includes(this.#nal.type) ? 65535 : 64;
+        if (this.#nal.bytes.length < limit) this.#nal.bytes.push(byte);
+        else if ([7, 8].includes(this.#nal.type)) throw new Error("AVC parameter set exceeds its decoder declaration.");
+      } else if (byte !== 0) throw new Error("AVC bytes precede their first start code.");
+      this.#zeroes = byte === 0 ? this.#zeroes + 1 : 0;
+      this.#position++;
+    }
+  }
+
+  complete() {
+    if (this.#nal) this.#finishNal(this.#position - this.#zeroes);
+    if (this.#track.picStructPresent && this.#frame?.picStruct === null) throw new Error("AVC final access-unit duration requires its SEI picture structure.");
+    const ticks = this.#frame?.picStruct === null ? this.#track.frameOnly ? 2 : null
+      : [2, 1, 1, 2, 2, 3, 3, 4, 6][this.#frame?.picStruct];
+    const finalDuration = ticks && this.#track.timingTickSeconds > 0
+      ? ticks * this.#track.timingTickSeconds : this.#track.fps > 0 ? 1 / this.#track.fps : null;
+    if (this.#frame) this.#close(this.#position - this.#zeroes, finalDuration);
+    this.#cadenced?.finish();
+    this.#index.complete(this.#track.trackNumber);
+  }
+
+  #finishNal(end) {
+    const nal = this.#nal;
+    if (end <= nal.payloadStart || nal.type === null) throw new Error("AVC NAL unit is empty.");
+    if ([2, 3, 4, 19, 20, 21].includes(nal.type)) throw new Error("AVC partitioned or extended pictures require their own access-unit indexing.");
+    const size = end - nal.payloadStart;
+    const bytes = Buffer.from(nal.bytes.slice(0, size));
+    if (nal.sei) {
+      const timing = nal.sei.finish();
+      if (timing && this.#track.picStructPresent) this.#picStruct = readPicStruct(timing, this.#track.seiDelayBits ?? 0);
+    }
+    if ([7, 8].includes(nal.type)) {
+      const previous = this.#sets.get(nal.type);
+      if (previous && !previous.equals(bytes)) throw new Error("AVC parameter-set changes require packet-specific declarations.");
+      this.#sets.set(nal.type, bytes);
+      if (this.#sets.has(7) && this.#sets.has(8)) Object.assign(this.#track,
+        avcConfigurationFromUnits(this.#sets.get(7), this.#sets.get(8)));
+      if (this.#sets.has(7) && this.#sets.has(8) && !this.#order) {
+        const parameters = avcOrderParameters(this.#sets.get(7), this.#sets.get(8));
+        this.#order = new AvcPictureOrder(parameters);
+        // Types 1/2 declare order, not proportional elapsed clock ticks.
+        this.#orderUsesClockTicks = parameters.type === 0;
+      }
+    }
+    if ([6, 7, 8, 9].includes(nal.type) && this.#frame) {
+      if (this.#prefix === null) this.#prefix = nal.start;
+      return;
+    }
+    if (![1, 5].includes(nal.type)) return;
+    const firstMacroblock = firstUe(bytes.subarray(1));
+    if (this.#frame && firstMacroblock !== 0) {
+      this.#frame.keyframe ||= nal.type === 5;
+      return;
+    }
+    if (!this.#track.codecPrivateB64) throw new Error("AVC picture precedes its decoder configuration.");
+    const start = this.#prefix ?? nal.start;
+    let stamp = null;
+    while (this.#stamps[0]?.position <= nal.start) stamp = this.#stamps.shift();
+    let pictureOrder = null;
+    if (this.#track.frameOnly && !this.#track.picStructPresent) {
+      try { pictureOrder = this.#order?.read(bytes); }
+      catch (error) { if (!stamp) throw error; }
+    }
+    if (pictureOrder?.idr) this.#anchor = null;
+    if (stamp && pictureOrder) this.#anchor = { count: pictureOrder.count, pts: stamp.pts };
+    if (this.#cadenced) {
+      if (!pictureOrder) throw new Error("Cadenced AVC requires complete progressive picture order.");
+      stamp = { pts: 0, dts: this.#frame ? this.#frame.dts + this.#track.presentationCadenceSeconds : this.#track.startTimeSeconds };
+    } else if (!stamp) {
+      if (!pictureOrder || !this.#orderUsesClockTicks || !this.#anchor || !this.#frame || !(this.#track.timingTickSeconds > 0)) {
+        throw new Error("AVC access unit has neither a PES timestamp nor complete timing declarations.");
+      }
+      stamp = { pts: this.#anchor.pts + (pictureOrder.count - this.#anchor.count) * this.#track.timingTickSeconds,
+        dts: this.#frame.dts + 2 * this.#track.timingTickSeconds };
+    }
+    if (this.#frame) {
+      const duration = stamp.dts - this.#frame.dts;
+      if (!(duration > 0)) throw new Error("AVC decode timestamps do not advance.");
+      this.#close(start, duration);
+    }
+    this.#frame = { start, pts: stamp.pts, dts: stamp.dts, keyframe: nal.type === 5, picStruct: this.#picStruct,
+      pictureOrder: pictureOrder?.count, orderReset: pictureOrder?.idr };
+    this.#picStruct = null;
+    this.#prefix = null;
+  }
+
+  #close(end, duration) {
+    if (!(duration > 0)) throw new Error("AVC final access-unit duration is unavailable.");
+    const { start, picStruct: _picStruct, pictureOrder, orderReset, ...timing } = this.#frame;
+    const ranges = this.#mappings.filter(range => range.from < end && range.to > start).map(range => [
+      range.sourceStart + Math.max(start, range.from) - range.from,
+      range.sourceStart + Math.min(end, range.to) - range.from - 1]);
+    if (ranges.reduce((sum, [a, b]) => sum + b - a + 1, 0) !== end - start) throw new Error("AVC access-unit addresses are incomplete.");
+    const packet = { ...timing, duration, ranges };
+    if (this.#cadenced) this.#cadenced.push(packet, pictureOrder, orderReset);
+    else this.#index.append(this.#track.trackNumber, packet);
+    if (!this.#cadenced) this.#recent.push(timing.pts);
+    const depth = this.#track.reorderDepth;
+    if (!this.#cadenced && Number.isSafeInteger(depth) && this.#recent.length > depth + 1) {
+      const earliest = Math.min(...this.#recent);
+      this.#recent.splice(this.#recent.indexOf(earliest), 1);
+      this.#index.coverThrough(this.#track.trackNumber, Math.max(0, earliest + duration));
+    }
+    this.#mappings = this.#mappings.filter(range => range.to > end);
+  }
+}
+
+/** Skip unrelated SEI payloads without retaining them; timing needs at most 9 bytes. */
+class SeiTiming {
+  #phase = "type";
+  #type = 0;
+  #size = 0;
+  #remaining = 0;
+  #bytes = [];
+  #timing = null;
+  #zeroes = 0;
+  #escaped = false;
+
+  push(byte) {
+    if (this.#zeroes >= 2 && byte === 3) {
+      this.#zeroes = 0;
+      this.#escaped = true;
+      return;
+    }
+    if (this.#escaped && byte > 3) throw new Error("AVC SEI escape byte is invalid.");
+    this.#escaped = false;
+    this.#zeroes = byte === 0 ? this.#zeroes + 1 : 0;
+    if (this.#phase === "type") {
+      this.#type += byte;
+      if (byte !== 255) this.#phase = "size";
+    } else if (this.#phase === "size") {
+      this.#size += byte;
+      if (byte !== 255) {
+        this.#remaining = this.#size;
+        this.#phase = "payload";
+        if (this.#remaining === 0) this.#next();
+      }
+    } else {
+      if (this.#type === 1 && this.#bytes.length < 9) this.#bytes.push(byte);
+      if (--this.#remaining === 0) this.#next();
+    }
+  }
+
+  #next() {
+    if (this.#type === 1) this.#timing = Buffer.from(this.#bytes);
+    this.#bytes = [];
+    this.#type = 0;
+    this.#size = 0;
+    this.#phase = "type";
+  }
+
+  finish() {
+    if (this.#escaped || !(this.#phase === "size" && this.#type === 128 && this.#size === 0)) {
+      throw new Error("AVC SEI payload or trailing bits are incomplete.");
+    }
+    return this.#timing;
+  }
+}
+
+function readPicStruct(bytes, offset) {
+  if (offset + 4 > bytes.length * 8) throw new Error("AVC SEI picture timing is truncated.");
+  let value = 0;
+  for (let at = offset; at < offset + 4; at++) value = value * 2 + ((bytes[at >> 3] >> (7 - (at & 7))) & 1);
+  if (value > 8) throw new Error("AVC SEI picture structure is reserved.");
+  return value;
+}
+
+function firstUe(bytes) {
+  const raw = [];
+  for (let at = 0, zeroes = 0; at < bytes.length; at++) {
+    const byte = bytes[at];
+    if (zeroes >= 2 && byte === 3) {
+      if (at + 1 >= bytes.length || bytes[at + 1] > 3) throw new Error("AVC slice escape byte is invalid.");
+      zeroes = 0;
+      continue;
+    }
+    raw.push(byte);
+    zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  bytes = Buffer.from(raw);
+  let position = 0, zeroes = 0;
+  const bit = () => {
+    if (position >= bytes.length * 8) throw new Error("AVC slice header is truncated.");
+    const value = (bytes[position >> 3] >> (7 - (position & 7))) & 1;
+    position++;
+    return value;
+  };
+  while (!bit()) if (++zeroes > 31) throw new Error("AVC first macroblock is invalid.");
+  let value = 0;
+  for (let at = 0; at < zeroes; at++) value = value * 2 + bit();
+  return 2 ** zeroes - 1 + value;
+}

package/services/media/container/hevc-configuration.js

@@ -0,0 +1,165 @@
+import { Bits } from "./h264-configuration.js";
+
+/** HEVC SPS ordering limits are declared for every temporal sublayer (H.265 7.3.2.2). */
+export function hevcConfiguration(hvcc) {
+  if (!Buffer.isBuffer(hvcc) || hvcc.length < 23 || hvcc[0] !== 1) throw new Error("HEVC decoder configuration is invalid.");
+  const sequences = [];
+  let at = 23;
+  for (let array = 0; array < hvcc[22]; array++) {
+    if (at + 3 > hvcc.length) throw new Error("HEVC parameter-set array is truncated.");
+    const type = hvcc[at++] & 63;
+    const count = hvcc.readUInt16BE(at); at += 2;
+    for (let index = 0; index < count; index++) {
+      if (at + 2 > hvcc.length) throw new Error("HEVC parameter-set length is truncated.");
+      const size = hvcc.readUInt16BE(at); at += 2;
+      if (size < 2 || at + size > hvcc.length) throw new Error("HEVC parameter set exceeds its configuration.");
+      const unit = hvcc.subarray(at, at + size); at += size;
+      if (((unit[0] >> 1) & 63) !== type) throw new Error("HEVC parameter-set array type does not match its NAL unit.");
+      if (type === 33) sequences.push(hevcSequence(unit));
+    }
+  }
+  if (!sequences.length || at !== hvcc.length) throw new Error("HEVC configuration has no SPS or has trailing bytes.");
+  const first = sequences[0];
+  if (sequences.some(sequence => sequence.width !== first.width || sequence.height !== first.height || sequence.bitDepth !== first.bitDepth)) {
+    throw new Error("HEVC SPS changes require packet-specific decoder configuration.");
+  }
+  return { ...first, reorderDepth: Math.max(...sequences.map(sequence => sequence.reorderDepth)), nalLengthBytes: (hvcc[21] & 3) + 1 };
+}
+
+export function hevcSequence(nal) {
+  if ((nal[0] & 128) || ((nal[0] >> 1) & 63) !== 33 || !(nal[1] & 7)) throw new Error("HEVC SPS NAL header is invalid.");
+  if ((nal[0] & 1) || (nal[1] >> 3)) throw new Error("HEVC multilayer SPS requires layer-specific configuration.");
+  const bytes = [];
+  for (let at = 2, zeroes = 0; at < nal.length; at++) {
+    const byte = nal[at];
+    if (zeroes >= 2 && byte === 3) {
+      if (at + 1 >= nal.length || nal[at + 1] > 3) throw new Error("HEVC escape byte is invalid.");
+      zeroes = 0; continue;
+    }
+    bytes.push(byte); zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  const bits = new Bits(Buffer.from(bytes), "HEVC");
+  bits.uint(4);
+  const layers = bits.uint(3);
+  if (layers > 6) throw new Error("HEVC temporal sublayer count is invalid.");
+  bits.uint(1);
+  skip(bits, 96);
+  const profiles = [], levels = [];
+  for (let layer = 0; layer < layers; layer++) { profiles.push(bits.uint(1)); levels.push(bits.uint(1)); }
+  if (layers) skip(bits, (8 - layers) * 2);
+  for (let layer = 0; layer < layers; layer++) {
+    if (profiles[layer]) skip(bits, 88);
+    if (levels[layer]) skip(bits, 8);
+  }
+  const sequenceId = bits.ue(), chroma = bits.ue();
+  if (sequenceId > 15 || chroma > 3) throw new Error("HEVC SPS identity or chroma format is invalid.");
+  const separate = chroma === 3 ? bits.uint(1) : 0;
+  const codedWidth = bits.ue(), codedHeight = bits.ue();
+  let left = 0, right = 0, top = 0, bottom = 0;
+  if (bits.uint(1)) { left = bits.ue(); right = bits.ue(); top = bits.ue(); bottom = bits.ue(); }
+  const luma = bits.ue(), chromaDepth = bits.ue();
+  if (luma > 8 || chromaDepth > 8) throw new Error("HEVC sample bit depth is invalid.");
+  const orderBits = bits.ue() + 4;
+  if (orderBits > 16) throw new Error("HEVC picture-order width is invalid.");
+  const orderingPresent = bits.uint(1);
+  let reorderDepth = 0, buffering = 0;
+  for (let layer = orderingPresent ? 0 : layers; layer <= layers; layer++) {
+    const capacity = bits.ue() + 1, reorder = bits.ue(); bits.ue();
+    if (capacity > 16 || reorder >= capacity || capacity < buffering || reorder < reorderDepth) throw new Error("HEVC reorder-buffer declaration is invalid.");
+    buffering = capacity; reorderDepth = reorder;
+  }
+  const chromaArray = separate ? 0 : chroma;
+  const width = codedWidth - (left + right) * ([1, 2].includes(chromaArray) ? 2 : 1);
+  const height = codedHeight - (top + bottom) * (chromaArray === 1 ? 2 : 1);
+  if (!(width > 0) || !(height > 0)) throw new Error("HEVC conformance window removes the entire picture.");
+  return { width, height, bitDepth: luma + 8, chromaBitDepth: chromaDepth + 8, chromaFormat: chroma, separateColourPlane: separate === 1, reorderDepth, orderBits,
+    ...sequenceTiming(bits, orderBits) };
+}
+
+function skip(bits, count) { for (let left = count; left > 0; left -= 32) bits.uint(Math.min(32, left)); }
+
+function sequenceTiming(bits, orderBits) {
+  for (let field = 0; field < 6; field++) bits.ue();
+  if (bits.uint(1) && bits.uint(1)) {
+    for (let size = 0; size < 4; size++) for (let matrix = 0; matrix < 6; matrix += size === 3 ? 3 : 1) {
+      if (!bits.uint(1)) bits.ue();
+      else {
+        if (size > 1) bits.se();
+        for (let coefficient = 0; coefficient < Math.min(64, 2 ** (4 + 2 * size)); coefficient++) bits.se();
+      }
+    }
+  }
+  bits.uint(1); bits.uint(1);
+  if (bits.uint(1)) { bits.uint(8); bits.ue(); bits.ue(); bits.uint(1); }
+  const sets = bits.ue();
+  if (sets > 64) throw new Error("HEVC short-term reference count is invalid.");
+  const previous = [];
+  for (let set = 0; set < sets; set++) {
+    const deltas = [];
+    if (set > 0 && bits.uint(1)) {
+      const sign = bits.uint(1), delta = (bits.ue() + 1) * (sign ? -1 : 1);
+      for (const before of [...previous[set - 1], 0]) {
+        const used = bits.uint(1), retained = used || bits.uint(1);
+        if (retained && before + delta !== 0) deltas.push(before + delta);
+      }
+    } else {
+      const negative = bits.ue(), positive = bits.ue();
+      if (negative + positive > 16) throw new Error("HEVC reference picture set exceeds its buffer.");
+      let value = 0;
+      for (let pic = 0; pic < negative; pic++) { value -= bits.ue() + 1; bits.uint(1); deltas.push(value); }
+      value = 0;
+      for (let pic = 0; pic < positive; pic++) { value += bits.ue() + 1; bits.uint(1); deltas.push(value); }
+    }
+    if (deltas.length > 16) throw new Error("HEVC predicted reference set exceeds its buffer.");
+    previous.push([...deltas.filter(delta => delta < 0).sort((a, b) => b - a),
+      ...deltas.filter(delta => delta > 0).sort((a, b) => a - b)]);
+  }
+  if (bits.uint(1)) {
+    const count = bits.ue();
+    if (count > 32) throw new Error("HEVC long-term reference count is invalid.");
+    for (let pic = 0; pic < count; pic++) { bits.uint(orderBits); bits.uint(1); }
+  }
+  bits.uint(1); bits.uint(1);
+  if (!bits.uint(1)) return {};
+  if (bits.uint(1) && bits.uint(8) === 255) { bits.uint(16); bits.uint(16); }
+  if (bits.uint(1)) bits.uint(1);
+  if (bits.uint(1)) { bits.uint(4); if (bits.uint(1)) skip(bits, 24); }
+  if (bits.uint(1)) { bits.ue(); bits.ue(); }
+  bits.uint(1);
+  const fieldSequence = bits.uint(1), frameFieldInfo = bits.uint(1);
+  if (bits.uint(1)) for (let side = 0; side < 4; side++) bits.ue();
+  if (!bits.uint(1)) return { fieldSequence: fieldSequence === 1, frameFieldInfo: frameFieldInfo === 1 };
+  const units = bits.uint(32), scale = bits.uint(32);
+  const proportional = bits.uint(1), ticks = proportional ? bits.ue() + 1 : 1;
+  if (!(units > 0) || !(scale > 0)) throw new Error("HEVC timing declaration is invalid.");
+  return { timingTickSeconds: units / scale, fps: scale / (units * ticks),
+    fieldSequence: fieldSequence === 1, frameFieldInfo: frameFieldInfo === 1,
+    pocProportional: proportional === 1, ticksPerPicture: ticks };
+}
+
+/** Construct hvcC from complete in-band parameter sets without keeping picture bytes. */
+export function hevcConfigurationFromUnits(vps, sps, pps) {
+  const facts = hevcSequence(sps);
+  const raw = [];
+  for (let at = 2, zeroes = 0; at < sps.length; at++) {
+    const byte = sps[at];
+    if (zeroes >= 2 && byte === 3) { zeroes = 0; continue; }
+    raw.push(byte); zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  const header = Buffer.alloc(23);
+  header[0] = 1;
+  Buffer.from(raw).copy(header, 1, 1, 13);
+  header[13] = 0xf0; header[15] = 0xfc;
+  header[16] = 0xfc | facts.chromaFormat;
+  header[17] = 0xf8 | (facts.bitDepth - 8); header[18] = 0xf8 | (facts.chromaBitDepth - 8);
+  header[21] = ((((raw[0] >> 1) & 7) + 1) << 3) | ((raw[0] & 1) << 2) | 3;
+  header[22] = 3;
+  const arrays = [vps, sps, pps].map((unit, index) => {
+    if (!Buffer.isBuffer(unit) || unit.length < 2 || unit.length > 65535 || ((unit[0] >> 1) & 63) !== index + 32) {
+      throw new Error("HEVC parameter-set declaration is invalid.");
+    }
+    return Buffer.concat([Buffer.from([0x80 | (index + 32), 0, 1, unit.length >> 8, unit.length & 255]), unit]);
+  });
+  const bytes = Buffer.concat([header, ...arrays]);
+  return { ...facts, codecPrivateB64: bytes.toString("base64"), packetFraming: "annex-b" };
+}

package/services/media/container/hevc-elementary-index.js

@@ -0,0 +1,132 @@
+import { hevcConfigurationFromUnits } from "./hevc-configuration.js";
+import { HevcPictureOrder } from "./hevc-picture-order.js";
+import { CadencedPictureOrder } from "./CadencedPictureOrder.js";
+
+/** HEVC access units keep exact source addresses and the PES presentation/decode clocks. */
+export class HevcElementaryIndex {
+  #track;
+  #index;
+  #position = 0;
+  #zeroes = 0;
+  #nal = null;
+  #mappings = [];
+  #stamps = [];
+  #sets = new Map();
+  #frame = null;
+  #prefix = 0;
+  #recent = [];
+  #order = null;
+  #anchor = null;
+  #cadenced = null;
+
+  constructor(track, index) {
+    this.#track = track; this.#index = index;
+    if (track.presentationCadenceSeconds > 0) this.#cadenced = new CadencedPictureOrder(track, index);
+  }
+
+  push(bytes, sourceStart, stamp) {
+    const from = this.#position;
+    this.#mappings.push({ from, to: from + bytes.length, sourceStart });
+    if (stamp?.pts !== null && stamp?.pts !== undefined) this.#stamps.push({ position: from, pts: stamp.pts, dts: stamp.dts ?? stamp.pts });
+    for (const byte of bytes) {
+      if (byte === 1 && this.#zeroes >= 2) {
+        const start = this.#position - this.#zeroes;
+        if (this.#nal) this.#finishNal(start);
+        this.#nal = { start, payloadStart: this.#position + 1, bytes: [], type: null };
+      } else if (this.#nal) {
+        if (this.#nal.type === null) {
+          if (byte & 128) throw new Error("HEVC NAL header is invalid.");
+          this.#nal.type = (byte >> 1) & 63;
+        }
+        const limit = [32, 33, 34].includes(this.#nal.type) ? 65535 : 64;
+        if (this.#nal.bytes.length < limit) this.#nal.bytes.push(byte);
+        else if ([32, 33, 34].includes(this.#nal.type)) throw new Error("HEVC parameter set exceeds its decoder declaration.");
+      } else if (byte !== 0) throw new Error("HEVC bytes precede their first start code.");
+      this.#zeroes = byte === 0 ? this.#zeroes + 1 : 0;
+      this.#position++;
+    }
+  }
+
+  complete() {
+    if (this.#nal) this.#finishNal(this.#position - this.#zeroes);
+    if (this.#frame) {
+      if (!(this.#track.fps > 0) || this.#track.fieldSequence) throw new Error("HEVC final frame timing is not declared.");
+      this.#close(this.#position - this.#zeroes, 1 / this.#track.fps);
+    }
+    this.#cadenced?.finish();
+    this.#index.complete(this.#track.trackNumber);
+  }
+
+  #finishNal(end) {
+    const nal = this.#nal;
+    if (end < nal.payloadStart + 2 || nal.bytes.length < 2) throw new Error("HEVC NAL unit is truncated.");
+    const bytes = Buffer.from(nal.bytes.slice(0, end - nal.payloadStart));
+    if (!(bytes[1] & 7) || (bytes[0] & 1) || (bytes[1] >> 3)) throw new Error("HEVC NAL temporal identity or layer is invalid.");
+    if ([32, 33, 34].includes(nal.type)) {
+      const previous = this.#sets.get(nal.type);
+      if (previous && !previous.equals(bytes)) throw new Error("HEVC parameter-set changes require packet-specific declarations.");
+      this.#sets.set(nal.type, bytes);
+      if ([32, 33, 34].every(type => this.#sets.has(type))) {
+        Object.assign(this.#track, hevcConfigurationFromUnits(this.#sets.get(32), this.#sets.get(33), this.#sets.get(34)));
+        this.#order ??= new HevcPictureOrder(this.#track, this.#sets.get(34));
+      }
+    }
+    if ([32, 33, 34, 35, 39].includes(nal.type) && this.#frame) {
+      if (this.#prefix === null) this.#prefix = nal.start;
+      return;
+    }
+    if (nal.type > 31) return;
+    if (bytes.length < 3) throw new Error("HEVC slice header is truncated.");
+    const firstSlice = (bytes[2] & 128) !== 0;
+    if (!firstSlice) {
+      if (!this.#frame) throw new Error("HEVC access unit starts with a dependent slice.");
+      return;
+    }
+    if (!this.#track.codecPrivateB64) throw new Error("HEVC picture precedes its decoder configuration.");
+    const start = this.#prefix ?? nal.start;
+    let stamp = null;
+    while (this.#stamps[0]?.position <= nal.start) stamp = this.#stamps.shift();
+    let pictureOrder = null;
+    try { pictureOrder = this.#order?.read(bytes); }
+    catch (error) { if (!stamp) throw error; }
+    if (pictureOrder?.reset) this.#anchor = null;
+    if (stamp && pictureOrder) this.#anchor = { count: pictureOrder.count, pts: stamp.pts };
+    if (this.#cadenced) {
+      if (!pictureOrder || this.#track.fieldSequence || this.#track.frameFieldInfo) throw new Error("Cadenced HEVC requires complete progressive picture order.");
+      stamp = { pts: 0, dts: this.#frame ? this.#frame.dts + this.#track.presentationCadenceSeconds : this.#track.startTimeSeconds };
+    }
+    if (!stamp) {
+      if (!pictureOrder || !this.#anchor || !this.#frame || !this.#track.pocProportional ||
+        this.#track.fieldSequence || this.#track.frameFieldInfo || !(this.#track.fps > 0)) {
+        throw new Error("HEVC access unit has neither a PES timestamp nor complete picture-order timing declarations.");
+      }
+      stamp = { pts: this.#anchor.pts + (pictureOrder.count - this.#anchor.count) / this.#track.fps,
+        dts: this.#frame.dts + 1 / this.#track.fps };
+    }
+    if (this.#frame) {
+      const duration = stamp.dts - this.#frame.dts;
+      if (!(duration > 0)) throw new Error("HEVC decode timestamps do not advance.");
+      this.#close(start, duration);
+    }
+    this.#frame = { start, pts: stamp.pts, dts: stamp.dts, keyframe: nal.type >= 16 && nal.type <= 21,
+      ...(this.#cadenced ? { pictureOrder: pictureOrder.count, orderReset: pictureOrder.reset } : {}) };
+    this.#prefix = null;
+  }
+
+  #close(end, duration) {
+    const { start, pictureOrder, orderReset, ...timing } = this.#frame;
+    const ranges = this.#mappings.filter(range => range.from < end && range.to > start).map(range => [
+      range.sourceStart + Math.max(start, range.from) - range.from,
+      range.sourceStart + Math.min(end, range.to) - range.from - 1]);
+    if (ranges.reduce((sum, [a, b]) => sum + b - a + 1, 0) !== end - start) throw new Error("HEVC access-unit addresses are incomplete.");
+    if (this.#cadenced) this.#cadenced.push({ ...timing, duration, ranges }, pictureOrder, orderReset);
+    else this.#index.append(this.#track.trackNumber, { ...timing, duration, ranges });
+    if (!this.#cadenced) this.#recent.push(timing.pts);
+    if (!this.#cadenced && this.#recent.length > this.#track.reorderDepth + 1) {
+      const earliest = Math.min(...this.#recent);
+      this.#recent.splice(this.#recent.indexOf(earliest), 1);
+      this.#index.coverThrough(this.#track.trackNumber, Math.max(0, earliest + duration));
+    }
+    this.#mappings = this.#mappings.filter(range => range.to > end);
+  }
+}

package/services/media/container/hevc-picture-order.js

@@ -0,0 +1,66 @@
+import { Bits } from "./h264-configuration.js";
+
+/** HEVC first-slice picture order, using the previous reference TemporalId 0 picture. */
+export class HevcPictureOrder {
+  #sequence;
+  #picture;
+  #lsb = 0;
+  #msb = 0;
+  #first = true;
+
+  constructor(sequence, pps) {
+    if (!Number.isSafeInteger(sequence.orderBits) || sequence.orderBits < 4 || sequence.orderBits > 16 ||
+      pps.length < 3 || ((pps[0] >> 1) & 63) !== 34 || (pps[0] & 129) || (pps[1] >> 3) || !(pps[1] & 7)) {
+      throw new Error("HEVC picture-order declarations are invalid.");
+    }
+    this.#sequence = sequence;
+    const bits = new Bits(rbsp(pps), "HEVC");
+    const id = bits.ue(), sequenceId = bits.ue();
+    if (id > 63 || sequenceId > 15) throw new Error("HEVC PPS identity is invalid.");
+    const dependentSlices = bits.uint(1), outputFlag = bits.uint(1), extraBits = bits.uint(3);
+    this.#picture = { id, dependentSlices, outputFlag, extraBits };
+  }
+
+  read(nal) {
+    const type = (nal[0] >> 1) & 63, temporalId = (nal[1] & 7) - 1;
+    if (type > 31 || temporalId < 0 || (nal[0] & 129) || (nal[1] >> 3)) throw new Error("HEVC slice identity is invalid.");
+    const bits = new Bits(rbsp(nal), "HEVC");
+    if (!bits.uint(1)) throw new Error("HEVC picture order requires its first slice.");
+    const irap = type >= 16 && type <= 23;
+    if (irap) bits.uint(1);
+    if (bits.ue() !== this.#picture.id) throw new Error("HEVC slice names an undeclared PPS.");
+    bits.uint(this.#picture.extraBits);
+    if (bits.ue() > 2) throw new Error("HEVC slice type is invalid.");
+    if (this.#picture.outputFlag) bits.uint(1);
+    if (this.#sequence.separateColourPlane) bits.uint(2);
+    const idr = type === 19 || type === 20;
+    const lsb = idr ? 0 : bits.uint(this.#sequence.orderBits), cycle = 2 ** this.#sequence.orderBits;
+    const reset = idr || (type >= 16 && type <= 18) || (irap && this.#first);
+    let msb = reset ? 0 : this.#msb;
+    if (!reset) {
+      if (lsb < this.#lsb && this.#lsb - lsb >= cycle / 2) msb += cycle;
+      else if (lsb > this.#lsb && lsb - this.#lsb > cycle / 2) msb -= cycle;
+    }
+    if (temporalId === 0 && ![0, 2, 4, 6, 7, 8, 9].includes(type)) {
+      this.#lsb = lsb;
+      this.#msb = msb;
+    }
+    this.#first = false;
+    return { count: msb + lsb, reset };
+  }
+}
+
+function rbsp(nal) {
+  const bytes = [];
+  for (let at = 2, zeroes = 0; at < nal.length; at++) {
+    const byte = nal[at];
+    if (zeroes >= 2 && byte === 3) {
+      if (at + 1 >= nal.length || nal[at + 1] > 3) throw new Error("HEVC escape byte is invalid.");
+      zeroes = 0;
+      continue;
+    }
+    bytes.push(byte);
+    zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  return Buffer.from(bytes);
+}