@torrent-tv/proxy 2.91.0 → 2.92.1

package/services/media/container/MpegPsContainer.js

@@ -0,0 +1,281 @@
+import { pesPayload } from "./pes-header.js";
+export { pesPayload } from "./pes-header.js";
+import { Container } from "./Container.js";
+import { VideoTrack } from "../tracks/VideoTrack.js";
+import { AudioTrack } from "../tracks/AudioTrack.js";
+import { ContainerTrack } from "../tracks/ContainerTrack.js";
+import { mpegSectionCrc } from "./MpegTsContainer.js";
+import { mpegVideoConfiguration } from "./mpeg-video-configuration.js";
+import { MpegElementaryIndex } from "./mpeg-elementary-index.js";
+import { ready } from "./mpeg-ts-packets.js";
+
+const TYPES = new Map([[1, ["video", "mpeg1video"]], [2, ["video", "mpeg2video"]],
+  [0x10, ["video", "mpeg4"]], [0x1b, ["video", "h264"]], [0x24, ["video", "hevc"]],
+  [3, ["audio", "mp2"]], [4, ["audio", "mp2"]], [0x0f, ["audio", "aac"]],
+  [0x81, ["audio", "ac3"]], [0x87, ["audio", "eac3"]]]);
+
+/** Program stream declarations and PES headers, without source-read waits. */
+export class MpegPsContainer extends Container {
+  #offset = 0;
+  #streams = new Map();
+  #tracks = null;
+  #mapRead = false;
+  #firstTime = null;
+  #lastTime = null;
+  #videoPrefixes = new Map();
+  #packetState = { offset: 0, current: null, elementary: null, complete: false };
+  #duration = null;
+
+  get formatName() { return "mpegps"; }
+  packetIndexBytes() { return this.#packetState.elementary?.index.allocatedBytes() ?? 0; }
+  static detect(head) {
+    return head.length >= 5 && head[0] === 0 && head[1] === 0 && head[2] === 1 &&
+      (head[3] === 0xba || head[3] === 0xbb);
+  }
+
+  async readTracks() {
+    if (this.#tracks) return this.#tracks;
+    await this.#scan(true);
+    const counts = new Map();
+    this.#tracks = [...this.#streams].map(([trackNumber, stream]) => {
+      const declaredIndex = counts.get(stream.type) ?? 0;
+      counts.set(stream.type, declaredIndex + 1);
+      const params = { ...stream, trackNumber, declaredIndex, isEnabled: true, isDefault: false, declaresDefault: false };
+      return stream.type === "video" ? new VideoTrack(params) : stream.type === "audio" ? new AudioTrack(params) : new ContainerTrack(params);
+    });
+    return this.#tracks;
+  }
+
+  async readMediaInfo() {
+    const tracks = await this.readTracks();
+    const picture = tracks.find(track => track.type === "video");
+    if (["h264", "hevc"].includes(picture?.codecId)) {
+      const index = await this.#readPackets(tracks, null, () => picture.codecPrivateB64 &&
+        this.#packetState.elementary.index.boundsOf(picture.trackNumber) !== null);
+      const bounds = index.boundsOf(picture.trackNumber);
+      return { format: this.formatName, startTimeSeconds: bounds?.start ?? null,
+        durationSeconds: this.#duration };
+    }
+    if (picture && (this.#videoPrefixes.size === 0 || this.#firstTime === null)) await this.#scan(false, true);
+    for (const track of tracks.filter(track => track.type === "video")) {
+      const prefix = this.#videoPrefixes.get(track.trackNumber);
+      const facts = prefix && mpegVideoConfiguration(prefix);
+      if (facts) Object.assign(track, facts, { codecId: track.codecId || facts.codecId });
+    }
+    return { format: this.formatName, startTimeSeconds: this.#firstTime,
+      durationSeconds: this.#duration };
+  }
+
+  async readPacketIndex(interval) {
+    const tracks = await this.readTracks();
+    await this.readMediaInfo();
+    return this.#readPackets(tracks, interval);
+  }
+
+  async #readPackets(tracks, interval, stopWhen = null) {
+    const state = this.#packetState;
+    state.elementary ??= new MpegElementaryIndex(tracks, { packetMemory: this.packetMemory });
+    state.elementary.index.flushPending();
+    if (state.complete) {
+      this.#noteDuration(state.elementary.index, tracks);
+      return state.elementary.index;
+    }
+    if (interval && ready(state.elementary.index, tracks, interval)) return state.elementary.index;
+    while (state.offset < this.fileSize) {
+      if (!state.current) {
+        const prefix = await this.readRange(state.offset, state.offset + 3);
+        if (prefix.length !== 4 || prefix[0] !== 0 || prefix[1] !== 0 || prefix[2] !== 1) throw new Error("MPEG-PS lost packet synchronization.");
+        const id = prefix[3];
+        if (id === 0xb9) { state.offset += 4; break; }
+        if (id === 0xba) {
+          const version = await this.readRange(state.offset + 4, state.offset + 4);
+          let size;
+          if ((version[0] & 0xc0) === 0x40) {
+            const pack = await this.readRange(state.offset + 4, state.offset + 13);
+            size = 14 + (pack[9] & 7);
+          } else if ((version[0] & 0xf0) === 0x20) size = 12;
+          else throw new Error("MPEG-PS pack version is invalid.");
+          if (state.offset + size > this.fileSize) throw new Error("MPEG-PS pack exceeds the file.");
+          state.offset += size;
+          continue;
+        }
+        const sizeBytes = await this.readRange(state.offset + 4, state.offset + 5);
+        const size = sizeBytes.readUInt16BE();
+        if (!size && (id < 0xe0 || id > 0xef)) throw new Error("Only MPEG-PS video PES may omit its length.");
+        const end = size ? state.offset + 6 + size : await this.#nextPacket(state.offset + 6);
+        if (end > this.fileSize) throw new Error("MPEG-PS packet exceeds the file.");
+        if (id !== 0xbd && !tracks.some(track => track.trackNumber === id && ["video", "audio"].includes(track.type))) {
+          state.offset = end;
+          continue;
+        }
+        const headerBytes = await this.readRange(state.offset + 6, Math.min(end - 1, state.offset + 270));
+        const header = pesPayload(headerBytes);
+        let start = state.offset + 6 + header.offset;
+        let trackId = id;
+        if (id === 0xbd) {
+          if (start + 4 > end) throw new Error("MPEG-PS private audio header is truncated.");
+          const privateHeader = await this.readRange(start, start + 3);
+          trackId = privateHeader[0];
+          if (!tracks.some(track => track.trackNumber === trackId && track.type === "audio" && ["ac3", "dts"].includes(track.codecId))) {
+            state.offset = end;
+            continue;
+          }
+          start += 4;
+        }
+        if (start > end) throw new Error("MPEG-PS PES header exceeds its packet.");
+        state.current = { id: trackId, end, cursor: start, header, timestampGiven: false };
+      }
+      const current = state.current;
+      while (current.cursor < current.end) {
+        const size = Math.min(current.end - current.cursor, this.portionBytes);
+        const bytes = await this.readRange(current.cursor, current.cursor + size - 1);
+        state.elementary.push(current.id, bytes, current.cursor, current.timestampGiven ? {} : current.header);
+        current.timestampGiven = true;
+        current.cursor += size;
+        state.elementary.index.flushPending();
+        if (stopWhen?.()) return state.elementary.index;
+      }
+      state.offset = current.end;
+      state.current = null;
+      if (interval && ready(state.elementary.index, tracks, interval)) return state.elementary.index;
+    }
+    if (state.offset !== this.fileSize) throw new Error("MPEG-PS has bytes after its program end.");
+    const index = state.elementary.complete();
+    state.complete = true;
+    index.flushPending();
+    this.#noteDuration(index, tracks);
+    return index;
+  }
+
+  #noteDuration(index, tracks) {
+    const timed = tracks.find(track => track.type === "video") ?? tracks.find(track => track.type === "audio");
+    const bounds = timed && index.boundsOf(timed.trackNumber);
+    if (bounds) {
+      this.#firstTime = bounds.start;
+      this.#duration = bounds.end - bounds.start;
+    }
+  }
+
+  async #scan(stopAtMap, stopAtPicture = false) {
+    while (this.#offset < this.fileSize) {
+      if (this.#offset + 4 > this.fileSize) throw new Error("MPEG-PS start code is truncated.");
+      const prefix = await this.readRange(this.#offset, this.#offset + 3);
+      if (prefix[0] !== 0 || prefix[1] !== 0 || prefix[2] !== 1) throw new Error("MPEG-PS lost packet synchronization.");
+      const id = prefix[3];
+      if (id === 0xb9) { this.#offset += 4; break; }
+      if (id === 0xba) {
+        const version = await this.readRange(this.#offset + 4, this.#offset + 4);
+        let size;
+        if ((version[0] & 0xc0) === 0x40) {
+          const pack = await this.readRange(this.#offset + 4, this.#offset + 13);
+          size = 14 + (pack[9] & 7);
+        } else if ((version[0] & 0xf0) === 0x20) size = 12;
+        else throw new Error("MPEG-PS pack version is invalid.");
+        if (this.#offset + size > this.fileSize) throw new Error("MPEG-PS pack exceeds the file.");
+        this.#offset += size;
+        continue;
+      }
+      const lengthBytes = await this.readRange(this.#offset + 4, this.#offset + 5);
+      const length = lengthBytes.readUInt16BE();
+      if (length === 0 && (id < 0xe0 || id > 0xef)) throw new Error("Only MPEG-PS video PES may omit its length.");
+      const end = length === 0 ? await this.#nextPacket(this.#offset + 6) : this.#offset + 6 + length;
+      if (end > this.fileSize) throw new Error("MPEG-PS packet exceeds the file.");
+      if (id === 0xbc) {
+        const map = await this.readRange(this.#offset, end - 1);
+        this.#programMap(map);
+      } else if ((id >= 0xc0 && id <= 0xef) || id === 0xbd || id === 0xfd) {
+        const bytes = await this.readRange(this.#offset + 6, Math.min(end - 1, this.#offset + 6 + 264));
+        const payload = pesPayload(bytes);
+        if (id >= 0xe0 && id <= 0xef && !this.#videoPrefixes.has(id) &&
+          bytes.indexOf(Buffer.from([0, 0, 1, 0xb3]), payload.offset) >= 0) {
+          this.#videoPrefixes.set(id, Buffer.from(bytes.subarray(payload.offset)));
+        }
+        if (payload.pts !== null) {
+          if (this.#firstTime === null) this.#firstTime = payload.pts;
+          this.#lastTime = Math.max(this.#lastTime ?? payload.pts, payload.pts);
+        }
+        if (!this.#mapRead) {
+          if (id >= 0xe0 && id <= 0xef) this.#streams.set(id, { type: "video", codecId: this.#streams.get(id)?.codecId || videoCodec(bytes.subarray(payload.offset)) });
+          else if (id >= 0xc0 && id <= 0xdf) this.#streams.set(id, { type: "audio", codecId: this.#streams.get(id)?.codecId || audioCodec(bytes.subarray(payload.offset)) });
+          else if (id === 0xfd) this.#streams.set(id, { type: "video", codecId: "" });
+          else if (payload.offset < bytes.length) {
+            const substream = bytes[payload.offset];
+            if (substream >= 0x80 && substream <= 0x87) this.#streams.set(substream, { type: "audio", codecId: "ac3" });
+            else if (substream >= 0x88 && substream <= 0x8f) this.#streams.set(substream, { type: "audio", codecId: "dts" });
+            else if (substream >= 0xa0 && substream <= 0xaf) this.#streams.set(substream, { type: "audio", codecId: "pcm_dvd" });
+            else if (substream >= 0x20 && substream <= 0x3f) this.#streams.set(substream, { type: "subtitle", codecId: "dvd_subtitle" });
+          }
+        }
+      }
+      this.#offset = end;
+      if (stopAtMap && this.#mapRead) break;
+      if (stopAtPicture && this.#videoPrefixes.size > 0 && this.#firstTime !== null) break;
+    }
+  }
+
+  async #nextPacket(start) {
+    let cursor = start, carry = Buffer.alloc(0);
+    while (cursor < this.fileSize) {
+      const width = Math.min(this.fileSize - cursor, this.portionBytes);
+      const chunk = await this.readRange(cursor, cursor + width - 1);
+      const bytes = Buffer.concat([carry, chunk]);
+      for (let at = 0; at + 3 < bytes.length; at++) {
+        // Elementary picture, sequence and GOP start codes remain PES payload.
+        if (bytes[at] === 0 && bytes[at + 1] === 0 && bytes[at + 2] === 1 && bytes[at + 3] >= 0xb9) {
+          return cursor - carry.length + at;
+        }
+      }
+      carry = Buffer.from(bytes.subarray(Math.max(0, bytes.length - 3)));
+      cursor += width;
+    }
+    return this.fileSize;
+  }
+
+  #programMap(bytes) {
+    if (bytes.length < 16 || mpegSectionCrc(bytes) !== 0) throw new Error("MPEG-PS program map is invalid.");
+    if (!(bytes[6] & 0x80)) return;
+    const infoLength = bytes.readUInt16BE(8);
+    let at = 10 + infoLength;
+    if (at + 2 > bytes.length - 4) throw new Error("MPEG-PS program descriptors exceed its map.");
+    const end = at + 2 + bytes.readUInt16BE(at);
+    at += 2;
+    if (end !== bytes.length - 4) throw new Error("MPEG-PS elementary map length is invalid.");
+    const streams = new Map();
+    while (at < end) {
+      if (at + 4 > end) throw new Error("MPEG-PS stream declaration is truncated.");
+      const [type, codecId] = TYPES.get(bytes[at]) ?? ["other", ""];
+      const number = bytes[at + 1];
+      const next = at + 4 + bytes.readUInt16BE(at + 2);
+      if (next > end) throw new Error("MPEG-PS stream descriptors exceed its map.");
+      streams.set(number, { type, codecId });
+      at = next;
+    }
+    this.#streams = streams;
+    this.#mapRead = true;
+  }
+}
+
+function videoCodec(bytes) {
+  for (let at = 0; at + 4 < bytes.length; at++) {
+    if (bytes[at] === 0 && bytes[at + 1] === 0 && bytes[at + 2] === 1 &&
+      (bytes[at + 3] & 0x9f) === 7) return "h264";
+  }
+  const sequence = bytes.indexOf(Buffer.from([0, 0, 1, 0xb3]));
+  if (sequence < 0) return "";
+  const extension = bytes.indexOf(Buffer.from([0, 0, 1, 0xb5]), sequence + 4);
+  if (extension >= 0 && (bytes[extension + 4] >> 4) === 1) return "mpeg2video";
+  if (bytes.indexOf(Buffer.from([0, 0, 1, 0xb8]), sequence + 4) >= 0 ||
+    bytes.indexOf(Buffer.from([0, 0, 1, 0]), sequence + 4) >= 0) return "mpeg1video";
+  return "";
+}
+
+function audioCodec(bytes) {
+  for (let at = 0; at + 3 < bytes.length; at++) {
+    if (bytes[at] !== 0xff || (bytes[at + 1] & 0xe0) !== 0xe0) continue;
+    const layer = (bytes[at + 1] >> 1) & 3;
+    const version = (bytes[at + 1] >> 3) & 3;
+    if (version === 1 || layer === 0 || (bytes[at + 2] >> 4) === 15 || ((bytes[at + 2] >> 2) & 3) === 3) continue;
+    return layer === 1 ? "mp3" : layer === 2 ? "mp2" : "mp1";
+  }
+  return "";
+}

package/services/media/container/MpegTsContainer.js

@@ -0,0 +1,277 @@
+import { Container } from "./Container.js";
+import { VideoTrack } from "../tracks/VideoTrack.js";
+import { AudioTrack } from "../tracks/AudioTrack.js";
+import { ContainerTrack } from "../tracks/ContainerTrack.js";
+import { pesPayload } from "./pes-header.js";
+import { MpegSequenceReader } from "./mpeg-sequence-reader.js";
+import { readMpegTsPackets } from "./mpeg-ts-packets.js";
+
+// ISO/IEC 13818-1 stream_type values; private streams are identified by descriptors.
+const STREAM_TYPES = new Map([
+  [0x01, ["video", "mpeg1video"]], [0x02, ["video", "mpeg2video"]],
+  [0x10, ["video", "mpeg4"]], [0x1b, ["video", "h264"]], [0x24, ["video", "hevc"]],
+  [0x03, ["audio", "mp2"]], [0x04, ["audio", "mp2"]],
+  [0x0f, ["audio", "aac"]], [0x11, ["audio", "aac_latm"]],
+  [0x81, ["audio", "ac3"]], [0x87, ["audio", "eac3"]], [0x8a, ["audio", "dts"]]
+]);
+
+/** Program and track declarations read packet by packet from existing bytes. */
+export class MpegTsContainer extends Container {
+  #layout = null;
+  #offset = 0;
+  #sections = new Map();
+  #programs = new Map();
+  #programTables = new Map();
+  #patSections = new Set();
+  #lastPatSection = null;
+  #tracks = null;
+  #mediaOffset = 0;
+  #mediaPrefixes = new Map();
+  #mediaStart = null;
+  #mediaRead = false;
+  #packetState = {};
+  #duration = null;
+
+  get formatName() { return "mpegts"; }
+  packetIndexBytes() { return this.#packetState.elementary?.index.allocatedBytes() ?? 0; }
+
+  static detect(head) {
+    return (head[0] === 0x47 && (head[3] & 0x30) !== 0) ||
+      (head[4] === 0x47 && (head[7] & 0x30) !== 0);
+  }
+
+  async #packetLayout() {
+    if (this.#layout) return this.#layout;
+    const head = await this.readRange(0, Math.min(7, this.fileSize - 1));
+    const sync = head[0] === 0x47 ? 0 : head[4] === 0x47 ? 4 : -1;
+    if (sync < 0) throw new Error("MPEG-TS sync byte is absent.");
+    const widths = sync === 4 ? [192] : [188, 204];
+    for (const width of widths) {
+      const next = width + sync;
+      if (next >= this.fileSize) continue;
+      const byte = await this.readRange(next, next);
+      if (byte[0] !== 0x47) continue;
+      if (next + width < this.fileSize) {
+        const following = await this.readRange(next + width, next + width);
+        if (following[0] !== 0x47) continue;
+      }
+      this.#layout = { width, sync };
+      return this.#layout;
+    }
+    throw new Error("MPEG-TS packet spacing is invalid.");
+  }
+
+  async readTracks() {
+    if (this.#tracks) return this.#tracks;
+    const { width, sync } = await this.#packetLayout();
+    while (this.#offset + width <= this.fileSize) {
+      const raw = await this.readRange(this.#offset + sync, this.#offset + sync + 187);
+      this.#consumePacket(raw);
+      this.#offset += width;
+      const patComplete = this.#lastPatSection !== null && this.#patSections.size === this.#lastPatSection + 1;
+      if (!patComplete || this.#programs.size === 0 ||
+        [...this.#programs.keys()].some(program => !this.#programTables.has(program))) continue;
+      const streams = [...this.#programs.keys()].flatMap(program => this.#programTables.get(program));
+      const counts = new Map();
+      this.#tracks = streams.map(stream => {
+        const declaredIndex = counts.get(stream.type) ?? 0;
+        counts.set(stream.type, declaredIndex + 1);
+        const params = { ...stream, trackNumber: stream.pid, declaredIndex, isEnabled: true, isDefault: false, declaresDefault: false };
+        if (stream.type === "video") return new VideoTrack(params);
+        if (stream.type === "audio") return new AudioTrack(params);
+        return new ContainerTrack(params);
+      });
+      return this.#tracks;
+    }
+    throw new Error("MPEG-TS ends before its program tables are complete.");
+  }
+
+  async readMediaInfo() {
+    const tracks = await this.readTracks();
+    if (this.#mediaRead) return { format: this.formatName, durationSeconds: this.#duration, startTimeSeconds: this.#mediaStart };
+    const video = tracks.find(track => track.type === "video");
+    if (["h264", "hevc"].includes(video?.codecId)) {
+      const index = await readMpegTsPackets({ readRange: this.readRange, fileSize: this.fileSize,
+        packetMemory: this.packetMemory,
+        layout: await this.#packetLayout(), tracks, state: this.#packetState,
+        stopWhen: value => video.codecPrivateB64 && value.boundsOf(video.trackNumber) !== null });
+      const bounds = index.boundsOf(video.trackNumber);
+      if (bounds) {
+        this.#mediaStart = bounds.start;
+        this.#mediaRead = true;
+        if (index.isComplete()) this.#duration = bounds.end - bounds.start;
+      }
+      return { format: this.formatName, durationSeconds: this.#duration, startTimeSeconds: this.#mediaStart };
+    }
+    if (!video) {
+      this.#mediaRead = true;
+      return { format: this.formatName, durationSeconds: null, startTimeSeconds: null };
+    }
+    const { width, sync } = await this.#packetLayout();
+    while (this.#mediaOffset + width <= this.fileSize) {
+      const packet = await this.readRange(this.#mediaOffset + sync, this.#mediaOffset + sync + 187);
+      const pid = ((packet[1] & 31) << 8) | packet[2];
+      if (packet[0] !== 0x47 || packet[1] & 0x80) throw new Error("MPEG-TS media packet is damaged.");
+      const control = (packet[3] >> 4) & 3;
+      if (!control) throw new Error("MPEG-TS adaptation control is invalid.");
+      const offset = control === 3 ? 5 + packet[4] : 4;
+      if (offset > 188) throw new Error("MPEG-TS adaptation field exceeds its packet.");
+      if (pid === video.trackNumber && control !== 2 && offset < 188) {
+        if (packet[3] & 0xc0) throw new Error("MPEG-TS media is scrambled.");
+        const payload = packet.subarray(offset);
+        let state = this.#mediaPrefixes.get(pid);
+        const counter = packet[3] & 15;
+        if (packet[1] & 0x40) state = { bytes: Buffer.alloc(0), header: null,
+          sequence: state?.sequence ?? new MpegSequenceReader(video.codecId), counter: (counter + 15) & 15 };
+        if (state && counter !== state.counter) {
+          if (counter !== ((state.counter + 1) & 15)) throw new Error("MPEG-TS media has missing packets.");
+          let elementary = payload;
+          if (!state.header) {
+            const prefix = Buffer.concat([state.bytes, payload]);
+            if (prefix.length >= 9) {
+              if (prefix[0] !== 0 || prefix[1] !== 0 || prefix[2] !== 1) throw new Error("MPEG-TS PES prefix is invalid.");
+              if ((prefix[6] & 0xc0) !== 0x80) throw new Error("MPEG-TS requires an MPEG-2 PES header.");
+              if (prefix.length >= 9 + prefix[8]) {
+                state.header = pesPayload(prefix.subarray(6));
+                elementary = prefix.subarray(6 + state.header.offset);
+              }
+            }
+            state.bytes = state.header ? Buffer.alloc(0) : Buffer.from(prefix);
+            if (!state.header) elementary = Buffer.alloc(0);
+          }
+          const facts = ["mpeg1video", "mpeg2video"].includes(video.codecId) ? state.sequence.push(elementary) : null;
+          state.counter = counter;
+          this.#mediaPrefixes.set(pid, state);
+          if (state.header?.pts !== null && state.header?.pts !== undefined && this.#mediaStart === null) this.#mediaStart = state.header.pts;
+          if (facts) {
+            Object.assign(video, facts, { codecId: video.codecId || facts.codecId });
+            this.#mediaRead = true;
+          }
+        }
+      }
+      this.#mediaOffset += width;
+      if (this.#mediaRead) break;
+    }
+    return { format: this.formatName, durationSeconds: null, startTimeSeconds: this.#mediaStart };
+  }
+
+  async readPacketIndex(interval) {
+    const tracks = await this.readTracks();
+    await this.readMediaInfo();
+    const index = await readMpegTsPackets({ readRange: this.readRange, fileSize: this.fileSize,
+      packetMemory: this.packetMemory,
+      layout: await this.#packetLayout(), tracks, state: this.#packetState, interval });
+    const timed = tracks.find(track => track.type === "video") ?? tracks.find(track => track.type === "audio");
+    if (timed && index.boundsOf(timed.trackNumber)) {
+      const bounds = index.boundsOf(timed.trackNumber);
+      this.#mediaStart = bounds.start;
+      if (index.isComplete()) this.#duration = bounds.end - bounds.start;
+    }
+    return index;
+  }
+
+  #consumePacket(packet) {
+    if (packet[0] !== 0x47) throw new Error("MPEG-TS packet lost synchronization.");
+    if (packet[1] & 0x80) throw new Error("MPEG-TS packet declares a transport error.");
+    const pid = ((packet[1] & 0x1f) << 8) | packet[2];
+    if (pid !== 0 && ![...this.#programs.values()].includes(pid)) return;
+    const control = (packet[3] >> 4) & 3;
+    if (control === 0) throw new Error("MPEG-TS adaptation control is invalid.");
+    if (control === 2) return;
+    if (packet[3] & 0xc0) throw new Error("MPEG-TS program table is scrambled.");
+    const offset = control === 3 ? 5 + packet[4] : 4;
+    if (offset > 188) throw new Error("MPEG-TS adaptation field exceeds its packet.");
+    if (offset === 188) return;
+    let state = this.#sections.get(pid);
+    if (!state) {
+      state = { bytes: Buffer.alloc(0), counter: null };
+      this.#sections.set(pid, state);
+    }
+    const counter = packet[3] & 15;
+    if (counter === state.counter) return;
+    const start = (packet[1] & 0x40) !== 0;
+    if (state.counter !== null && counter !== ((state.counter + 1) & 15) && state.bytes.length > 0) {
+      throw new Error("MPEG-TS program table has missing packets.");
+    }
+    state.counter = counter;
+    const payload = packet.subarray(offset);
+    if (start) {
+      const pointer = payload[0];
+      if (pointer + 1 > payload.length) throw new Error("MPEG-TS section pointer exceeds its packet.");
+      if (state.bytes.length) this.#appendSections(pid, state, payload.subarray(1, pointer + 1));
+      if (state.bytes.length) throw new Error("MPEG-TS section ended before its declared length.");
+      this.#appendSections(pid, state, payload.subarray(pointer + 1));
+    } else if (state.bytes.length) {
+      this.#appendSections(pid, state, payload);
+    }
+  }
+
+  #appendSections(pid, state, bytes) {
+    state.bytes = Buffer.concat([state.bytes, bytes]);
+    while (state.bytes.length > 0) {
+      if (state.bytes[0] === 0xff) { state.bytes = Buffer.alloc(0); return; }
+      if (state.bytes.length < 3) return;
+      const length = 3 + (((state.bytes[1] & 15) << 8) | state.bytes[2]);
+      if (length < 12 || length > 1024) throw new Error("MPEG-TS program section length is invalid.");
+      if (state.bytes.length < length) return;
+      const section = state.bytes.subarray(0, length);
+      state.bytes = state.bytes.subarray(length);
+      if (mpegSectionCrc(section) !== 0) throw new Error("MPEG-TS program section CRC is invalid.");
+      if (!(section[5] & 1)) continue;
+      if (pid === 0 && section[0] === 0) this.#readPat(section);
+      else if (section[0] === 2) this.#readPmt(section);
+    }
+  }
+
+  #readPat(section) {
+    this.#lastPatSection = section[7];
+    this.#patSections.add(section[6]);
+    for (let offset = 8; offset + 4 <= section.length - 4; offset += 4) {
+      const program = section.readUInt16BE(offset);
+      if (program !== 0) this.#programs.set(program, section.readUInt16BE(offset + 2) & 0x1fff);
+    }
+  }
+
+  #readPmt(section) {
+    const program = section.readUInt16BE(3);
+    if (!this.#programs.has(program)) return;
+    if (section[6] !== 0 || section[7] !== 0) throw new Error("MPEG-TS PMT section numbering is invalid.");
+    const streams = [];
+    let offset = 12 + (section.readUInt16BE(10) & 0x0fff);
+    while (offset < section.length - 4) {
+      if (offset + 5 > section.length - 4) throw new Error("MPEG-TS stream declaration is truncated.");
+      const streamType = section[offset];
+      const pid = section.readUInt16BE(offset + 1) & 0x1fff;
+      const end = offset + 5 + (section.readUInt16BE(offset + 3) & 0x0fff);
+      if (end > section.length - 4) throw new Error("MPEG-TS descriptor exceeds its section.");
+      let [type, codecId] = STREAM_TYPES.get(streamType) ?? ["other", ""];
+      let language = "";
+      for (let at = offset + 5; at < end;) {
+        if (at + 2 > end || at + 2 + section[at + 1] > end) throw new Error("MPEG-TS descriptor is truncated.");
+        const tag = section[at];
+        const data = section.subarray(at + 2, at + 2 + section[at + 1]);
+        if (tag === 0x0a && data.length >= 4) language = data.subarray(0, 3).toString("ascii");
+        if (streamType === 0x06) {
+          if (tag === 0x6a) [type, codecId] = ["audio", "ac3"];
+          if (tag === 0x7a) [type, codecId] = ["audio", "eac3"];
+          if (tag === 0x7b) [type, codecId] = ["audio", "dts"];
+          if (tag === 0x59) [type, codecId] = ["subtitle", "dvb_subtitle"];
+        }
+        at += 2 + data.length;
+      }
+      streams.push({ pid, type, codecId, language, declaresLanguage: language.length > 0 });
+      offset = end;
+    }
+    this.#programTables.set(program, streams);
+  }
+}
+
+/** MPEG-2 section CRC-32: polynomial 0x04c11db7, no reflection or final XOR. */
+export function mpegSectionCrc(bytes) {
+  let crc = 0xffffffff;
+  for (const byte of bytes) {
+    crc ^= byte << 24;
+    for (let bit = 0; bit < 8; bit++) crc = (crc << 1) ^ (crc & 0x80000000 ? 0x04c11db7 : 0);
+  }
+  return crc >>> 0;
+}