@torrent-tv/proxy 2.90.0 → 2.92.0

package/services/media/container/asf-packets.js

@@ -0,0 +1,153 @@
+import { PacketIndex } from "./PacketIndex.js";
+import { PacketRecords } from "./PacketRecords.js";
+import { followingPacketTime } from "./following-packet-time.js";
+import { isMp3Codec } from "./mp3-packet-dependencies.js";
+
+const DATA = "3626b2758e66cf11a6d900aa0062ce6c";
+
+/** ASF payload addresses, including fragmented and compressed media objects. */
+export async function readAsfPackets({ readRange, fileSize, tracks, info, firstPicture = false, packetMemory, state = {} }) {
+  if (!state.initialized) {
+  const at = info.dataOffset;
+  const data = await readRange(at, at + 49);
+  if (data.subarray(0, 16).toString("hex") !== DATA) throw new Error("ASF Data Object is absent.");
+  const size = Number(data.readBigUInt64LE(16));
+  const count = Number(data.readBigUInt64LE(40));
+  if (!Number.isSafeInteger(size) || size < 50 || at + size > fileSize || !Number.isSafeInteger(count)) {
+    throw new Error("ASF Data Object exceeds the file.");
+  }
+  Object.assign(state, { initialized: true, at: at + 50, end: at + size, count, packets: 0,
+    frames: new Map(tracks.map(track => [track.trackNumber, new PacketRecords(packetMemory)])), assembling: new Map() });
+  }
+  let { at, packets } = state;
+  const { end, count, frames, assembling } = state;
+  const declared = new Map(tracks.map(track => [track.trackNumber, track]));
+  while (at < end && (!count || packets < count)) {
+    const previousObjects = new Map([...assembling].map(([id, object]) => [id, { ...object, ranges: [...object.ranges] }]));
+    const previousLengths = new Map([...frames].map(([id, stream]) => [id, stream.length]));
+    try {
+    const fields = new Fields(readRange, at, end);
+    let flags = await fields.uint(1);
+    if (flags & 0x80) {
+      if (flags & 0x60) throw new Error("ASF error-correction length type is unsupported.");
+      fields.skip(flags & 15);
+      flags = await fields.uint(1);
+    }
+    const properties = await fields.uint(1);
+    const length = await fields.sized(flags >> 5, info.packetLength);
+    await fields.sized(flags >> 1, 0);
+    const padding = await fields.sized(flags >> 3, 0);
+    const timestamp = await fields.uint(4);
+    await fields.uint(2);
+    if (!length || length > end - at || padding >= length) throw new Error("ASF packet length or padding is invalid.");
+    const limit = at + length - padding;
+    fields.limit = limit;
+    const payloadFlags = flags & 1 ? await fields.uint(1) : 0x81;
+    const payloadCount = flags & 1 ? payloadFlags & 63 : 1;
+    if (!payloadCount) throw new Error("ASF packet has no payloads.");
+    for (let payload = 0; payload < payloadCount; payload++) {
+      const stream = await fields.uint(1);
+      const id = stream & 127, keyframe = (stream & 128) !== 0;
+      if (!declared.has(id)) throw new Error("ASF payload names an undeclared stream.");
+      const number = await fields.sized(properties >> 4, 0);
+      const offset = await fields.sized(properties >> 2, 0);
+      const replicaLength = await fields.sized(properties, 0);
+      let objectSize = null, time = timestamp, delta = null;
+      if (replicaLength >= 8) {
+        objectSize = await fields.uint(4);
+        time = await fields.uint(4);
+        fields.skip(replicaLength - 8);
+      } else if (replicaLength === 1) {
+        time = offset;
+        delta = await fields.uint(1);
+      } else if (replicaLength !== 0) throw new Error("ASF replicated payload data is invalid.");
+      const payloadSize = flags & 1 ? await fields.sized(payloadFlags >> 6, 0) : limit - fields.at;
+      if (!payloadSize || payloadSize > limit - fields.at) throw new Error("ASF payload exceeds its packet.");
+      const payloadEnd = fields.at + payloadSize;
+      if (delta !== null) {
+        while (fields.at < payloadEnd) {
+          const frameSize = await fields.uint(1);
+          if (!frameSize || frameSize > payloadEnd - fields.at) throw new Error("ASF compressed frame exceeds its payload.");
+          frames.get(id).push({ pts: time / 1000 - info.prerollSeconds, ...(delta > 0 ? { duration: delta / 1000 } : {}),
+            ...(isMp3Codec(declared.get(id)?.codecId) ? { decodeFromIndex: frames.get(id).length, decodeDependencyUnknown: true } : {}),
+            keyframe, ranges: [[fields.at, fields.at + frameSize - 1]] });
+          fields.skip(frameSize);
+          time += delta;
+        }
+      } else {
+        let object = assembling.get(id);
+        if (offset === 0) {
+          if (object) throw new Error("ASF media object ended before all fragments arrived.");
+          if (!(objectSize > 0)) throw new Error("ASF media object size is absent.");
+          object = { number, size: objectSize, received: 0, pts: time / 1000 - info.prerollSeconds, keyframe, ranges: [] };
+          assembling.set(id, object);
+        }
+        if (!object || object.number !== number || object.received !== offset ||
+          (objectSize !== null && object.size !== objectSize) || offset + payloadSize > object.size) {
+          throw new Error("ASF media object fragments are incomplete or inconsistent.");
+        }
+        object.ranges.push([fields.at, payloadEnd - 1]);
+        object.received += payloadSize;
+        fields.skip(payloadSize);
+        if (object.received === object.size) {
+          frames.get(id).push({ pts: object.pts, keyframe: object.keyframe, ranges: object.ranges,
+            ...(isMp3Codec(declared.get(id)?.codecId) ? { decodeFromIndex: frames.get(id).length, decodeDependencyUnknown: true } : {}) });
+          assembling.delete(id);
+        }
+      }
+    }
+    if (fields.at !== limit) throw new Error("ASF payload count differs from its packet size.");
+    at += Math.max(length, info.minimumPacketLength ?? length);
+    packets++;
+    state.at = at;
+    state.packets = packets;
+    if (firstPicture) {
+      const video = tracks.find(track => track.type === "video");
+      const stream = video && frames.get(video.trackNumber);
+      if (stream?.length) return { startTimeSeconds: stream.at(0).pts };
+    }
+    } catch (error) {
+      assembling.clear();
+      for (const [id, object] of previousObjects) assembling.set(id, object);
+      for (const [id, length] of previousLengths) frames.get(id).length = length;
+      throw error;
+    }
+  }
+  if ((count && packets !== count) || assembling.size) throw new Error("ASF Data Object ends with incomplete packets or media objects.");
+  if (firstPicture) return { startTimeSeconds: null };
+  const index = new PacketIndex();
+  for (const track of tracks) {
+    if (!["video", "audio"].includes(track.type)) continue;
+    const stream = frames.get(track.trackNumber);
+    index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, codecRanges: track.codecRanges ?? [],
+      prerollSeconds: track.seekPrerollSeconds ?? 0 });
+    const following = (track.defaultDurationSeconds === undefined || track.defaultDurationSeconds === null) && stream.some(frame => frame.duration === undefined)
+      ? followingPacketTime(stream, info.durationSeconds, packetMemory) : null;
+    try { for (let position = 0; position < stream.length; position++) {
+      const stated = stream.durationAt(position), pts = stream.ptsAt(position);
+      const duration = !Number.isNaN(stated) ? stated : track.defaultDurationSeconds ?? following(pts) - pts;
+      if (!(duration > 0)) throw new Error("ASF frame duration cannot be determined.");
+      if (duration !== stated) stream.setDuration(position, duration);
+    } } finally { following?.dispose(); }
+    index.sharePackets(track.trackNumber, stream);
+    index.complete(track.trackNumber);
+  }
+  return index;
+}
+
+class Fields {
+  constructor(read, at, limit) { this.read = read; this.at = at; this.limit = limit; }
+  skip(count) {
+    if (!Number.isSafeInteger(count) || count < 0 || count > this.limit - this.at) throw new Error("ASF packet field exceeds its bounds.");
+    this.at += count;
+  }
+  async uint(width) {
+    const at = this.at;
+    this.skip(width);
+    return (await this.read(at, at + width - 1)).readUIntLE(0, width);
+  }
+  sized(type, fallback) {
+    const width = [0, 1, 2, 4][type & 3];
+    return width ? this.uint(width) : fallback;
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Bits, unescapeNal } from "./h264-configuration.js";
+
+/** AVC frame picture-order counts, retaining reference and frame-number wraps. */
+export class AvcPictureOrder {
+  #params;
+  #msb = 0;
+  #lsb = 0;
+  #frameNumber = 0;
+  #frameOffset = 0;
+  constructor(params) { this.#params = params; }
+  read(nal) {
+    const params = this.#params;
+    if (![0, 1, 2].includes(params.type) || params.separateColourPlane || params.frameNumberBits > 16 ||
+        (params.type === 0 && params.pocBits > 16) ||
+        (params.type === 1 && !Array.isArray(params.referenceOffsets))) {
+      throw new Error("AVC missing timestamps require supported frame picture-order declarations.");
+    }
+    const bits = new Bits(unescapeNal(nal));
+    bits.ue(); bits.ue(); bits.ue();
+    const frameNumber = bits.uint(params.frameNumberBits);
+    const idr = (nal[0] & 31) === 5;
+    if (idr) { bits.ue(); this.#msb = 0; this.#lsb = 0; this.#frameNumber = 0; this.#frameOffset = 0; }
+    if (params.type !== 0) {
+      if (!idr && frameNumber < this.#frameNumber) this.#frameOffset += 2 ** params.frameNumberBits;
+      this.#frameNumber = frameNumber;
+      const reference = (nal[0] & 0x60) !== 0;
+      const absolute = this.#frameOffset + frameNumber;
+      if (params.type === 2) return { count: idr ? 0 : 2 * absolute - (reference ? 0 : 1), idr };
+      const cycle = params.referenceOffsets;
+      const frame = cycle.length ? Math.max(0, absolute - (reference ? 0 : 1)) : 0;
+      let expected = 0;
+      if (frame > 0) {
+        expected = Math.floor((frame - 1) / cycle.length) * cycle.reduce((sum, value) => sum + value, 0);
+        for (let index = 0; index <= (frame - 1) % cycle.length; index++) expected += cycle[index];
+      }
+      if (!reference) expected += params.nonReferenceOffset;
+      const top = expected + (params.deltaAlwaysZero ? 0 : bits.se());
+      const bottom = top + params.bottomOffset +
+        (!params.deltaAlwaysZero && params.bottomFieldOrderPresent ? bits.se() : 0);
+      return { count: Math.min(top, bottom), idr };
+    }
+    const lsb = bits.uint(params.pocBits), cycle = 2 ** params.pocBits;
+    let msb = this.#msb;
+    if (lsb < this.#lsb && this.#lsb - lsb >= cycle / 2) msb += cycle;
+    else if (lsb > this.#lsb && lsb - this.#lsb > cycle / 2) msb -= cycle;
+    const bottom = params.bottomFieldOrderPresent ? bits.se() : 0;
+    if (nal[0] & 0x60) { this.#msb = msb; this.#lsb = lsb; }
+    return { count: Math.min(msb + lsb, msb + lsb + bottom), idr };
+  }
+}

package/services/media/container/avi-open-dml.js

@@ -0,0 +1,47 @@
+/** OpenDML indexes address stream payloads directly, including later RIFF AVIX forms. */
+export async function* openDmlPackets({ readRange, fileSize, indexes, streamId }) {
+  const seen = new Set();
+  for (const chunk of indexes) yield* entries(chunk, false);
+
+  async function* entries(chunk, child) {
+    if (seen.has(chunk.start)) throw new Error("AVI OpenDML repeats an index address.");
+    seen.add(chunk.start);
+    if (chunk.start < 0 || chunk.end > fileSize || chunk.end - chunk.start < 24) throw new Error("AVI OpenDML index header is truncated.");
+    const header = await readRange(chunk.start, chunk.start + 23);
+    const words = header.readUInt16LE(), subtype = header[2], type = header[3];
+    const count = header.readUInt32LE(4), chunkId = header.toString("ascii", 8, 12);
+    if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId) || Number(chunkId.slice(0, 2)) !== streamId) throw new Error("AVI OpenDML index refers to another stream.");
+    const entryBytes = words * 4;
+    if (!entryBytes || count > Math.floor((chunk.end - chunk.start - 24) / entryBytes)) throw new Error("AVI OpenDML index entry count exceeds its chunk.");
+    if (type === 0) {
+      if (child || words !== 4 || subtype !== 0) throw new Error("AVI OpenDML super index structure is invalid.");
+      for (let at = 0; at < count; at++) {
+        const entry = await readRange(chunk.start + 24 + at * 16, chunk.start + 39 + at * 16);
+        const offset = safeOffset(entry.readBigUInt64LE()), size = entry.readUInt32LE(8);
+        if (!offset && !size) continue;
+        if (size < 32 || offset + size > fileSize) throw new Error("AVI OpenDML child index exceeds the file.");
+        const prefix = await readRange(offset, offset + 7);
+        if (!/^ix[0-9]{2}$/.test(prefix.toString("ascii", 0, 4)) || prefix.readUInt32LE(4) + 8 !== size) throw new Error("AVI OpenDML child index size disagrees with its header.");
+        yield* entries({ start: offset + 8, end: offset + size }, true);
+      }
+      return;
+    }
+    if (type !== 1 || !((subtype === 0 && words === 2) || (subtype === 1 && words === 3))) throw new Error("AVI OpenDML standard index structure is invalid.");
+    const base = safeOffset(header.readBigUInt64LE(12));
+    for (let at = 0; at < count; at++) {
+      const entry = await readRange(chunk.start + 24 + at * entryBytes, chunk.start + 23 + (at + 1) * entryBytes);
+      const start = base + entry.readUInt32LE(), encodedSize = entry.readUInt32LE(4), length = encodedSize & 0x7fffffff;
+      if (!Number.isSafeInteger(start) || start < 8 || start + length > fileSize) throw new Error("AVI OpenDML packet exceeds the file.");
+      if (subtype === 1 && entry.readUInt32LE(8) >= length) throw new Error("AVI OpenDML second field exceeds its frame.");
+      if (!length) { yield { chunkId, start, length, keyframe: false }; continue; }
+      const prefix = await readRange(start - 8, start - 1);
+      if (prefix.toString("ascii", 0, 4) !== chunkId || prefix.readUInt32LE(4) !== length) throw new Error("AVI OpenDML packet disagrees with its chunk header.");
+      yield { chunkId, start, length, keyframe: !(encodedSize & 0x80000000) };
+    }
+  }
+}
+
+function safeOffset(value) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("AVI OpenDML address exceeds exact integer precision.");
+  return Number(value);
+}

package/services/media/container/dts-frame.js

@@ -0,0 +1,51 @@
+/** DTS core headers declare physical frame length and PCM block duration. */
+export function dtsFrame(bytes) {
+  if (bytes.length < 24) throw new Error("DTS core header is truncated.");
+  const sync = bytes.readUInt32BE();
+  const packed = sync === 0x1fffe800 || sync === 0xff1f00e8;
+  const little = sync === 0xfe7f0180 || sync === 0xff1f00e8;
+  if (![0x7ffe8001, 0xfe7f0180, 0x1fffe800, 0xff1f00e8].includes(sync)) {
+    throw new Error("DTS core synchronization is invalid.");
+  }
+  let position = 32;
+  const bit = logical => {
+    const physical = packed ? Math.floor(logical / 14) * 16 + 2 + logical % 14 : logical;
+    let byte = physical >> 3;
+    if (little) byte ^= 1;
+    if (byte >= bytes.length) throw new Error("DTS core header is truncated.");
+    return (bytes[byte] >> (7 - (physical & 7))) & 1;
+  };
+  const read = count => {
+    let value = 0;
+    for (let at = 0; at < count; at++) value = value * 2 + bit(position++);
+    return value;
+  };
+  read(1);
+  if (read(5) !== 31) throw new Error("DTS deficit sample count is invalid.");
+  const crc = read(1);
+  const blocks = read(7) + 1;
+  if (blocks % 8 !== 0) throw new Error("DTS PCM block count is invalid.");
+  const logicalSize = read(14) + 1;
+  if (logicalSize < 96) throw new Error("DTS core frame length is invalid.");
+  const mode = read(6);
+  const channels = [1, 2, 2, 2, 2, 3, 3, 4, 4, 5][mode];
+  const sampleRate = [0, 8000, 16000, 32000, 0, 0, 11025, 22050, 44100, 0, 0, 12000, 24000, 48000, 96000, 192000][read(4)];
+  if (!channels || !sampleRate) throw new Error("DTS core audio format is invalid.");
+  read(5);
+  if (read(1)) throw new Error("DTS reserved header bit is set.");
+  read(4);
+  read(3);
+  const extended = read(1);
+  if (extended) throw new Error("DTS core extensions require extension-specific declarations.");
+  read(1);
+  const lfe = read(2);
+  if (lfe === 3) throw new Error("DTS LFE declaration is invalid.");
+  read(1);
+  if (crc) read(16);
+  read(1);
+  read(4);
+  read(2);
+  if ([4, 7].includes(read(3))) throw new Error("DTS PCM resolution is invalid.");
+  return { size: packed ? Math.ceil(logicalSize * 8 / 14) * 2 : logicalSize,
+    sampleRate, channels: channels + Number(lfe > 0), duration: blocks * 32 / sampleRate, codecId: "dts" };
+}

package/services/media/container/ebml-stream.js

@@ -130,7 +130,13 @@ export class ElementReader {
     if (room <= 1) {
       return null;
     }
-    const bytes = await this.bytes(at, Math.min(MAX_HEADER_BYTES, room));
+    const first = await this.bytes(at, 1);
+    const idWidth = vintWidth(first[0]);
+    if (!idWidth || idWidth > 4 || idWidth >= room) return null;
+    const beginning = await this.bytes(at, idWidth + 1);
+    const sizeWidth = vintWidth(beginning[idWidth]);
+    if (!sizeWidth || idWidth + sizeWidth > room) return null;
+    const bytes = await this.bytes(at, idWidth + sizeWidth);
     const id = readVint(bytes, 0, true);
     if (!id) {
       return null;
@@ -172,3 +178,8 @@ export class ElementReader {
     return this.bytes(element.dataOffset, available);
   }
 }
+
+function vintWidth(byte) {
+  for (let width = 1; width <= 8; width++) if (byte & (1 << (8 - width))) return width;
+  return 0;
+}

package/services/media/container/ffprobe-record.js

@@ -0,0 +1,45 @@
+/** Decode ffprobe's compact C-escaped records without splitting escaped separators. */
+export function ffprobeRecord(line) {
+  const fields = [];
+  let field = "", escaped = false;
+  for (const character of line.replace(/\r$/, "")) {
+    if (escaped) {
+      field += ({ n: "\n", r: "\r", t: "\t", f: "\f", b: "\b" })[character] ?? character;
+      escaped = false;
+    } else if (character === "\\") escaped = true;
+    else if (character === "|") { fields.push(field); field = ""; }
+    else field += character;
+  }
+  if (escaped) throw new Error("Truncated ffprobe escape.");
+  fields.push(field);
+  const kind = fields.shift();
+  const record = { kind };
+  for (const [position, value] of fields.entries()) {
+    // ffprobe 5 emits an empty nested section even when its entries are disabled.
+    if (value === "side_data" && fields.slice(position + 1).every(field => field === "")) break;
+    const separator = value.indexOf("=");
+    if (separator < 1) throw new Error(`Malformed ffprobe field: ${value.slice(0, 80)}`);
+    const key = value.slice(0, separator);
+    if (Object.hasOwn(record, key)) throw new Error(`Duplicate ffprobe field: ${key}`);
+    record[key] = value.slice(separator + 1);
+  }
+  return record;
+}
+
+/** Stream extradata's documented hexadecimal dump contains addresses and ASCII. */
+export function ffprobeExtradata(dump, expectedSize) {
+  const chunks = [];
+  let offset = 0;
+  for (const line of String(dump ?? "").split("\n")) {
+    if (!line.trim()) continue;
+    const match = /^([0-9a-fA-F]{8}):\s([0-9a-fA-F ]+?)\s{2,}/.exec(line);
+    if (!match || Number.parseInt(match[1], 16) !== offset) throw new Error("Invalid ffprobe extradata address.");
+    const hex = match[2].replaceAll(" ", "");
+    if (hex.length % 2) throw new Error("Truncated ffprobe extradata.");
+    const bytes = Buffer.from(hex, "hex");
+    chunks.push(bytes);
+    offset += bytes.length;
+  }
+  if (offset !== expectedSize) throw new Error("Incomplete ffprobe extradata.");
+  return Buffer.concat(chunks);
+}

package/services/media/container/flv-packet-ranges.js

@@ -0,0 +1,27 @@
+/** Adobe FLV 10.1 Annex E: demuxer positions name tags rather than their payload. */
+export async function flvPacketRanges({ readRange, fileSize, position, size, track, pts, dts }) {
+  if (position + 11 > fileSize) throw new Error("FLV tag header exceeds the source.");
+  const header = await readRange(position, position + 10);
+  const type = header[0];
+  if (type & 0xe0 || header.readUIntBE(8, 3) !== 0) throw new Error("Filtered, encrypted or reserved FLV tags are unsupported.");
+  if (type !== (track.type === "video" ? 9 : 8)) throw new Error("FLV tag does not contain the declared track.");
+  const dataSize = header.readUIntBE(1, 3);
+  const end = position + 11 + dataSize;
+  if (!dataSize || end + 4 > fileSize) throw new Error("FLV tag exceeds the source.");
+  const timestamp = (header.readUIntBE(4, 3) + header[7] * 0x1000000) / 1000;
+  if (Math.abs(timestamp - dts) > 1e-6) throw new Error("FLV tag and demuxer decode timestamps disagree.");
+  const framing = track.type === "video" ? 5 : track.codecId === "aac" ? 2 : track.codecId === "mp3" ? 1 : null;
+  if (framing === null || (track.type === "video" && track.codecId !== "h264")) throw new Error("FLV packet framing is unsupported for the declared codec.");
+  if (dataSize <= framing || dataSize - framing !== size) throw new Error("FLV tag and demuxer payload lengths disagree.");
+  const prefix = await readRange(position + 11, position + 10 + framing);
+  if (track.type === "video") {
+    if ((prefix[0] & 15) !== 7 || prefix[1] !== 1) throw new Error("FLV tag does not contain AVC frame data.");
+    const offset = prefix.readIntBE(2, 3) / 1000;
+    if (Math.abs(timestamp + offset - pts) > 1e-6) throw new Error("FLV composition time and demuxer presentation timestamp disagree.");
+  } else if (track.codecId === "aac") {
+    if ((prefix[0] >> 4) !== 10 || prefix[1] !== 1) throw new Error("FLV tag does not contain AAC frame data.");
+  } else if ((prefix[0] >> 4) !== 2) throw new Error("FLV tag does not contain MPEG layer III frame data.");
+  const previous = await readRange(end, end + 3);
+  if (previous.readUInt32BE(0) !== 11 + dataSize) throw new Error("FLV previous-tag size is invalid.");
+  return [[position + 11 + framing, end - 1]];
+}

package/services/media/container/following-packet-time.js

@@ -0,0 +1,37 @@
+import { IndexMemoryUnavailable } from "./memory-unavailable.js";
+
+/** Next distinct presentation timestamp, with admitted temporary sorting bytes. */
+export function followingPacketTime(records, endTime, memory = {}) {
+  let held = 0;
+  let times;
+  const owner = { dispose() {
+    if (held) allocation.release?.(held);
+    held = 0;
+    times = null;
+    allocation.dispose?.();
+  } };
+  const allocation = memory.forRecord?.(owner, "timing") ?? memory;
+  const bytes = records.length * Float64Array.BYTES_PER_ELEMENT;
+  if (allocation.reserve?.(bytes) === false) {
+    allocation.dispose?.();
+    throw new IndexMemoryUnavailable(bytes);
+  }
+  held = bytes;
+  try {
+    times = new Float64Array(records.length);
+    for (let index = 0; index < records.length; index++) times[index] = records.ptsAt(index);
+    times.sort();
+  }
+  catch (error) { owner.dispose(); throw error; }
+  const next = time => {
+    let left = 0, right = times.length;
+    while (left < right) {
+      const middle = left + Math.floor((right - left) / 2);
+      if (times[middle] <= time) left = middle + 1;
+      else right = middle;
+    }
+    return left < times.length ? times[left] : endTime;
+  };
+  next.dispose = owner.dispose;
+  return next;
+}

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

@@ -0,0 +1,183 @@
+/** H.264 SPS facts required to bound decode reordering and describe frames. */
+export function h264Configuration(avcc) {
+  if (!Buffer.isBuffer(avcc) || avcc.length < 7 || avcc[0] !== 1) throw new Error("AVC decoder configuration is invalid.");
+  if ((avcc[4] & 3) === 2) throw new Error("AVC NAL length size is reserved.");
+  const count = avcc[5] & 31;
+  if (!count) throw new Error("AVC configuration declares no SPS.");
+  let at = 6;
+  const sequences = [];
+  for (let index = 0; index < count; index++) {
+    if (at + 2 > avcc.length) throw new Error("AVC SPS length is truncated.");
+    const size = avcc.readUInt16BE(at); at += 2;
+    if (!size || at + size > avcc.length) throw new Error("AVC SPS exceeds its configuration.");
+    sequences.push(readSps(avcc.subarray(at, at + size))); at += size;
+  }
+  const first = sequences[0];
+  if (sequences.some(sequence => sequence.width !== first.width || sequence.height !== first.height || sequence.bitDepth !== first.bitDepth)) {
+    throw new Error("AVC SPS changes require packet-specific decoder configuration.");
+  }
+  return { ...first, reorderDepth: Math.max(...sequences.map(sequence => sequence.reorderDepth)), nalLengthBytes: (avcc[4] & 3) + 1 };
+}
+
+function readSps(nal, includeOrder = false) {
+  if ((nal[0] & 31) !== 7 || nal[0] & 128) throw new Error("AVC configuration entry is not an SPS.");
+  const bytes = [];
+  for (let at = 1, 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("AVC emulation prevention byte is invalid.");
+      zeroes = 0; continue;
+    }
+    bytes.push(byte); zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  const bits = new Bits(Buffer.from(bytes));
+  const profile = bits.uint(8), constraints = bits.uint(8), level = bits.uint(8);
+  bits.ue();
+  let chroma = 1, separate = 0, depth = 8;
+  if ([44, 83, 86, 100, 110, 118, 122, 128, 134, 135, 138, 139, 244].includes(profile)) {
+    chroma = bits.ue();
+    if (chroma > 3) throw new Error("AVC chroma format is invalid.");
+    if (chroma === 3) separate = bits.uint(1);
+    depth += bits.ue();
+    const chromaDepth = 8 + bits.ue();
+    if (depth > 14 || chromaDepth > 14) throw new Error("AVC bit depth is invalid.");
+    bits.uint(1);
+    if (bits.uint(1)) {
+      for (let index = 0; index < (chroma === 3 ? 12 : 8); index++) {
+        if (!bits.uint(1)) continue;
+        let last = 8, next = 8;
+        for (let sample = 0; sample < (index < 6 ? 16 : 64); sample++) {
+          if (next) next = (last + bits.se() + 256) % 256;
+          last = next || last;
+        }
+      }
+    }
+  }
+  const frameNumberBits = bits.ue() + 4;
+  const order = bits.ue();
+  let pocBits = null;
+  let orderCycle = null;
+  if (order === 0) pocBits = bits.ue() + 4;
+  else if (order === 1) {
+    const deltaAlwaysZero = bits.uint(1) === 1, nonReferenceOffset = bits.se(), bottomOffset = bits.se();
+    const cycle = bits.ue();
+    if (cycle > 255) throw new Error("AVC POC cycle is invalid.");
+    const referenceOffsets = [];
+    for (let index = 0; index < cycle; index++) referenceOffsets.push(bits.se());
+    orderCycle = { deltaAlwaysZero, nonReferenceOffset, bottomOffset, referenceOffsets };
+  } else if (order !== 2) throw new Error("AVC picture order count type is invalid.");
+  const references = bits.ue();
+  if (references > 16) throw new Error("AVC reference frame count is invalid.");
+  bits.uint(1);
+  const columns = bits.ue() + 1, rows = bits.ue() + 1;
+  const frameOnly = bits.uint(1);
+  const pictureMacroblocks = columns * rows * (2 - frameOnly);
+  if (!Number.isSafeInteger(pictureMacroblocks) || pictureMacroblocks > 696320) {
+    throw new Error("AVC picture exceeds the supported decode buffer bound.");
+  }
+  if (!frameOnly) bits.uint(1);
+  bits.uint(1);
+  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(); }
+  let fps = null, reorderDepth = null, timingTickSeconds = null, picStructPresent = false, seiDelayBits = 0;
+  if (bits.uint(1)) {
+    if (bits.uint(1)) { if (bits.uint(8) === 255) { bits.uint(16); bits.uint(16); } }
+    if (bits.uint(1)) bits.uint(1);
+    if (bits.uint(1)) { bits.uint(3); bits.uint(1); if (bits.uint(1)) { bits.uint(8); bits.uint(8); bits.uint(8); } }
+    if (bits.uint(1)) { bits.ue(); bits.ue(); }
+    if (bits.uint(1)) {
+      const tick = bits.uint(32), scale = bits.uint(32), fixed = bits.uint(1);
+      if (!tick || !scale) throw new Error("AVC timing declaration is invalid.");
+      timingTickSeconds = tick / scale;
+      if (fixed) fps = scale / (2 * tick);
+    }
+    const nalHrd = bits.uint(1);
+    const nalDelay = nalHrd ? hrd(bits) : 0;
+    const vclHrd = bits.uint(1);
+    const vclDelay = vclHrd ? hrd(bits) : 0;
+    seiDelayBits = nalHrd ? nalDelay : vclDelay;
+    if (nalHrd || vclHrd) bits.uint(1);
+    picStructPresent = bits.uint(1) === 1;
+    if (bits.uint(1)) {
+      bits.uint(1); bits.ue(); bits.ue(); bits.ue(); bits.ue();
+      reorderDepth = bits.ue();
+      const buffering = bits.ue();
+      if (reorderDepth > buffering || buffering > 16) throw new Error("AVC reorder buffer declaration is invalid.");
+    }
+  }
+  if (reorderDepth === null) {
+    const dpb = new Map([[10, 396], [11, 900], [12, 2376], [13, 2376], [20, 2376], [21, 4752], [22, 8100],
+      [30, 8100], [31, 18000], [32, 20480], [40, 32768], [41, 32768], [42, 34816], [50, 110400],
+      [51, 184320], [52, 184320], [60, 696320], [61, 696320], [62, 696320]]).get(level);
+    if (!dpb) throw new Error("AVC level has no declared decode buffer bound.");
+    const constrained = constraints & 16 && [44, 86, 100, 110, 122, 244].includes(profile);
+    reorderDepth = constrained ? 0 : Math.min(16, Math.floor(dpb / pictureMacroblocks));
+  }
+  const arrayType = separate ? 0 : chroma;
+  const cropX = arrayType === 1 || arrayType === 2 ? 2 : 1;
+  const cropY = (arrayType === 1 ? 2 : 1) * (2 - frameOnly);
+  const width = columns * 16 - (left + right) * cropX;
+  const height = rows * 16 * (2 - frameOnly) - (top + bottom) * cropY;
+  if (!(width > 0 && height > 0)) throw new Error("AVC crop exceeds its picture dimensions.");
+  return { width, height, fps, bitDepth: depth, reorderDepth, frameOnly: frameOnly === 1, timingTickSeconds, picStructPresent, seiDelayBits,
+    ...(includeOrder ? { pictureOrder: { type: order, frameNumberBits, pocBits, separateColourPlane: Boolean(separate),
+      ...(orderCycle ?? {}) } } : {}) };
+}
+
+export function avcOrderParameters(sps, pps) {
+  const facts = readSps(sps, true);
+  const bits = new Bits(unescapeNal(pps));
+  bits.ue(); bits.ue(); bits.uint(1);
+  return { ...facts.pictureOrder, bottomFieldOrderPresent: bits.uint(1) === 1 };
+}
+
+export function unescapeNal(nal) {
+  const bytes = [];
+  for (let at = 1, 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("AVC escape byte is invalid.");
+      zeroes = 0; continue;
+    }
+    bytes.push(byte);
+    zeroes = byte === 0 ? zeroes + 1 : 0;
+  }
+  return Buffer.from(bytes);
+}
+
+/** Build the decoder declaration from the complete in-band SPS and PPS units. */
+export function avcConfigurationFromUnits(sps, pps) {
+  if (!Buffer.isBuffer(sps) || !Buffer.isBuffer(pps) || sps.length < 4 || !pps.length ||
+    sps.length > 65535 || pps.length > 65535 || (pps[0] & 31) !== 8) throw new Error("AVC parameter-set lengths are invalid.");
+  const header = Buffer.from([1, sps[1], sps[2], sps[3], 0xff, 0xe1, sps.length >> 8, sps.length & 255]);
+  const tail = Buffer.from([1, pps.length >> 8, pps.length & 255]);
+  const bytes = Buffer.concat([header, sps, tail, pps]);
+  return { ...h264Configuration(bytes), codecPrivateB64: bytes.toString("base64"), packetFraming: "annex-b" };
+}
+
+function hrd(bits) {
+  const count = bits.ue() + 1;
+  if (count > 32) throw new Error("AVC HRD entry count is invalid.");
+  bits.uint(4); bits.uint(4);
+  for (let index = 0; index < count; index++) { bits.ue(); bits.ue(); bits.uint(1); }
+  bits.uint(5);
+  const removal = bits.uint(5) + 1, output = bits.uint(5) + 1;
+  bits.uint(5);
+  return removal + output;
+}
+
+export class Bits {
+  constructor(bytes, label = "AVC") { this.bytes = bytes; this.at = 0; this.label = label; }
+  uint(count) {
+    if (count < 0 || count > 32 || this.at + count > this.bytes.length * 8) throw new Error(`${this.label} SPS bits are truncated.`);
+    let value = 0;
+    for (let index = 0; index < count; index++, this.at++) value = value * 2 + ((this.bytes[this.at >> 3] >> (7 - (this.at & 7))) & 1);
+    return value;
+  }
+  ue() {
+    let zeroes = 0;
+    while (!this.uint(1)) if (++zeroes > 31) throw new Error(`${this.label} Exp-Golomb value is invalid.`);
+    return 2 ** zeroes - 1 + this.uint(zeroes);
+  }
+  se() { const code = this.ue(); return code & 1 ? (code + 1) / 2 : -code / 2; }
+}