@torrent-tv/proxy 2.74.1 → 2.76.0

package/services/audio-inventory.js

@@ -28,222 +28,12 @@
  * worse than a missing one, because `0:a:N` is what the encoder is given.
  */
 
-/**
- * Language codes that carry no information, so cannot confirm a pairing. Same
- * rule and same reasoning as `subtitle-defaults.js`: ffmpeg prints `und` for a
- * stream with no language, while Matroska's own default for `Language` is `eng`
- * — which is also a real answer, so it is compared like any other.
- */
-const EMPTY_LANGUAGES = new Set(["", "und", "unknown"]);
 
-/**
- * @param {unknown} value
- * @returns {string}
- */
-function normalise(value) {
-  return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
+import { AudioTrack } from "./tracks/AudioTrack.js";
 
-/**
- * Whether one banner stream and one container track can be the same track.
- *
- * Agreement on either the language or the title is enough; both sides saying
- * nothing is not agreement, but it is not disagreement either — a file may name
- * neither, and then this pair simply adds no support to the alignment.
- *
- * @param {{ language?: string, title?: string }} banner
- * @param {{ language?: string, name?: string }} container
- * @returns {boolean}
- */
-export function audioPairingHolds(banner, container) {
-  const bannerLanguage = normalise(banner?.language);
-  const containerLanguage = normalise(container?.language);
-  if (
-    !EMPTY_LANGUAGES.has(bannerLanguage) &&
-    !EMPTY_LANGUAGES.has(containerLanguage) &&
-    bannerLanguage === containerLanguage
-  ) {
-    return true;
-  }
-  const bannerTitle = normalise(banner?.title);
-  const containerName = normalise(container?.name);
-  if (bannerTitle.length > 0 && bannerTitle === containerName) {
-    return true;
-  }
-  return (
-    (EMPTY_LANGUAGES.has(bannerLanguage) || EMPTY_LANGUAGES.has(containerLanguage)) &&
-    (bannerTitle.length === 0 || containerName.length === 0)
-  );
-}
 
-/**
- * The banner's audio streams, with what the container declares about each.
- *
- * @param {Array<{ index?: number, language?: string, title?: string, isDefault?: boolean, codec?: string }>} bannerTracks
- * @param {Array<object>} declared - `AudioTrack`s in container order.
- * @returns {{ tracks: object[], aligned: boolean, reason: string }}
- */
-export function mergeContainerAudioFlags(bannerTracks, declared) {
-  const banner = Array.isArray(bannerTracks) ? bannerTracks : [];
-  const container = Array.isArray(declared) ? declared : [];
-  const undecided = () => ({
-    // Nothing of the container reading is used, flags included — attributing
-    // them to the wrong track is the failure this guard exists to prevent.
-    tracks: banner.map((track) => ({
-      ...track,
-      declaresDefault: false,
-      isOriginal: false,
-      isCommentary: false,
-      isVisualImpaired: false,
-      // Not "the container says this track is unusable": the container has not
-      // been heard from. A track is offered unless it was read to say otherwise.
-      isEnabled: true,
-      languageBcp47: "",
-      channels: null
-    }))
-  });
-  if (banner.length === 0) {
-    return { tracks: [], aligned: false, reason: "the probe found no audio stream" };
-  }
-  if (container.length === 0) {
-    return { ...undecided(), aligned: false, reason: "the container declares no audio track" };
-  }
-  if (container.length !== banner.length) {
-    return {
-      ...undecided(),
-      aligned: false,
-      reason: `the container declares ${container.length} audio tracks and the probe found ${banner.length}`
-    };
-  }
-  for (const [order, track] of banner.entries()) {
-    if (!audioPairingHolds(track, container[order])) {
-      return {
-        ...undecided(),
-        aligned: false,
-        reason:
-          `audio ${order} is "${normalise(track?.title) || "-"}"/${normalise(track?.language) || "-"} ` +
-          `in the probe and "${normalise(container[order]?.name) || "-"}"/` +
-          `${normalise(container[order]?.language) || "-"} in the container`
-      };
-    }
-  }
-  return {
-    tracks: banner.map((track, order) => ({
-      ...track,
-      // Read from the file itself (RFC 9559 §5.1.4.1). None of these four
-      // reaches ffmpeg's banner, which is where every other field here is from.
-      isOriginal: container[order].isOriginal === true,
-      isCommentary: container[order].isCommentary === true,
-      isVisualImpaired: container[order].isVisualImpaired === true,
-      isEnabled: container[order].isEnabled !== false,
-      // FlagDefault, and whether the file actually WROTE it. Matroska defaults
-      // the flag to 1 and ffmpeg prints the applied default, so the banner
-      // cannot tell "every track marked" from "the file has no opinion".
-      isDefault: container[order].isDefault === true,
-      declaresDefault: container[order].declaresDefault === true,
-      languageBcp47:
-        typeof container[order].languageBcp47 === "string" ? container[order].languageBcp47 : "",
-      channels: Number.isFinite(container[order].channels) ? container[order].channels : null,
-      title:
-        typeof track?.title === "string" && track.title.length > 0
-          ? track.title
-          : (typeof container[order].name === "string" ? container[order].name : "")
-    })),
-    aligned: true,
-    reason: ""
-  };
-}
 
-/**
- * Codec identifiers as containers write them, against the name ffmpeg prints.
- *
- * Needed because the browser decides whether it can play a soundtrack from that
- * name, and for a sidecar file there is no ffmpeg banner to read it from — the
- * track came from the container's own table, where Matroska writes `A_AC3` and
- * MP4 writes `ac-3` for the thing ffmpeg calls `ac3`. Only what a soundtrack can
- * actually be is listed; an identifier not here is reported as it was written,
- * which the browser treats as one it does not know and therefore transcodes.
- */
-const CODEC_NAMES = new Map([
-  ["A_AAC", "aac"],
-  ["A_AC3", "ac3"],
-  ["A_EAC3", "eac3"],
-  ["A_DTS", "dts"],
-  ["A_FLAC", "flac"],
-  ["A_OPUS", "opus"],
-  ["A_VORBIS", "vorbis"],
-  ["A_TRUEHD", "truehd"],
-  ["A_MPEG/L3", "mp3"],
-  ["A_MPEG/L2", "mp2"],
-  ["A_ALAC", "alac"],
-  ["mp4a", "aac"],
-  ["ac-3", "ac3"],
-  ["ec-3", "eac3"],
-  ["alac", "alac"],
-  ["opus", "opus"],
-  ["Opus", "opus"],
-  ["fLaC", "flac"],
-  ["flac", "flac"]
-]);
-
-/**
- * Extensions of raw elementary streams, against the codec they carry.
- *
- * A bare `.ac3` has no track table to read, and its extension is the only thing
- * that states its codec — which for an elementary stream is exactly what the
- * extension means.
- */
-const CODEC_BY_EXTENSION = new Map([
-  [".aac", "aac"],
-  [".ac3", "ac3"],
-  [".eac3", "eac3"],
-  [".dts", "dts"],
-  [".dtshd", "dts"],
-  [".flac", "flac"],
-  [".mp3", "mp3"],
-  [".mp2", "mp2"],
-  [".opus", "opus"],
-  [".ogg", "vorbis"],
-  [".oga", "vorbis"],
-  [".wav", "pcm"],
-  [".thd", "truehd"],
-  [".mlp", "truehd"],
-  [".m4a", "aac"]
-]);
 
-/**
- * The ffmpeg-side codec name for one track, from whatever the reading gave.
- *
- * @param {{ codec?: string, codecId?: string }} track
- * @param {string} [extension] - The sidecar file's extension, when the track
- *   came from a file with no readable table.
- * @returns {string}
- */
-export function codecNameOf(track, extension = "") {
-  const fromBanner = typeof track?.codec === "string" ? track.codec.trim() : "";
-  if (fromBanner.length > 0) {
-    return fromBanner.toLowerCase();
-  }
-  const codecId = typeof track?.codecId === "string" ? track.codecId.trim() : "";
-  if (codecId.length > 0) {
-    const known = CODEC_NAMES.get(codecId);
-    if (known) {
-      return known;
-    }
-    // Matroska allows a suffix — `A_AAC/MPEG4/LC`, `A_PCM/INT/LIT` — so the
-    // family is what the first two segments say.
-    const family = codecId.split("/").slice(0, 2).join("/");
-    const byFamily = CODEC_NAMES.get(family) ?? CODEC_NAMES.get(codecId.split("/")[0]);
-    if (byFamily) {
-      return byFamily;
-    }
-    if (codecId.startsWith("A_PCM")) {
-      return "pcm";
-    }
-    return codecId.toLowerCase();
-  }
-  return CODEC_BY_EXTENSION.get(extension) ?? "";
-}
 
 /**
  * @typedef {object} AudioInventoryEntry
@@ -283,7 +73,7 @@ export function codecNameOf(track, extension = "") {
  * @param {object} params
  * @param {object[]} params.embedded - Merged banner+container tracks of the video.
  * @param {number} params.videoFileIndex
- * @param {Array<{ file: import("./sidecar-files.js").SidecarFile, tracks: object[] }>} params.sidecars
+ * @param {Array<{ file: import("./torrent/files.js").SidecarFile, tracks: object[] }>} params.sidecars
  *   Each sidecar file with the audio tracks IT holds. A file whose container
  *   could not be read contributes one track, which is what a bare elementary
  *   stream is.
@@ -301,7 +91,7 @@ export function buildAudioInventory({ embedded, videoFileIndex, sidecars }) {
       // The name the browser judges "can I play this?" by. For an embedded
       // track it is ffmpeg's own; for a sidecar it is translated from what the
       // container wrote, or from the extension when there was no table to read.
-      codec: codecNameOf(track, file?.extension ?? ""),
+      codec: AudioTrack.codecNameOf(track, file?.extension ?? ""),
       language: typeof track?.language === "string" ? track.language : "",
       languageBcp47: typeof track?.languageBcp47 === "string" ? track.languageBcp47 : "",
       title:
@@ -316,7 +106,12 @@ export function buildAudioInventory({ embedded, videoFileIndex, sidecars }) {
       isEnabled: track?.isEnabled !== false,
       channels: Number.isFinite(track?.channels) ? track.channels : null,
       fileName: kind === "sidecar" ? (file?.name ?? "") : "",
-      folders: kind === "sidecar" && Array.isArray(file?.folders) ? file.folders : []
+      folders: kind === "sidecar" && Array.isArray(file?.folders) ? file.folders : [],
+      // What the file's own path says, for a track that ships as its own file:
+      // read here, by the grammar that also decided this file belongs to this
+      // picture. The browser used to read the same path again to build the
+      // label, which is one name read twice by two rules.
+      naming: kind === "sidecar" ? (file?.naming ?? null) : null
     });
   };
 

package/services/container/AviContainer.js

@@ -1,81 +1,266 @@
-/**
- * @file AVI container — RIFF.
- *
- * Minimal: only keyframe index via idx1 (AVIIF_KEYFRAME). Tracks are not
- * used by current product beyond video — expose a single VideoTrack if needed.
- * Spec: RIFF AVI, idx1 chunk at file end, OpenDML may lack idx1 → no index.
- */
-
-import { Container } from "./Container.js";
-import { isAvi, readAviKeyframeTimes } from "../container-index/avi.js";
-import { VideoTrack } from "../tracks/VideoTrack.js";
-
-export class AviContainer extends Container {
-  get formatName() {
-    return "avi";
-  }
-
-  static detect(head) {
-    return isAvi(head);
-  }
-
-  async readTracks() {
-    const head = await this.readRange(0, Math.min(4095, this.fileSize - 1));
-    if (!head || !isAvi(head)) return [];
-    // AVI track table is minimal — expose one video track for uniformity.
-    return [new VideoTrack({
-      trackNumber: 1,
-      declaredIndex: 0,
-      codecId: "",
-      language: "",
-      languageBcp47: "",
-      name: "",
-      isEnabled: true,
-      isDefault: true,
-      declaresDefault: false
-    })];
-  }
-
-  /**
-   * Duration from the main AVI header, per the RIFF AVI specification: the
-   * header states microseconds per frame and the total number of frames, and
-   * their product is the length.
-   *
-   * An AVI has no edit list and no timeline offset of any kind, so its start is
-   * zero — a declaration of the format itself, not an absence.
-   *
-   * @returns {Promise<import("./Container.js").ContainerMediaInfo>}
-   */
-  async readMediaInfo() {
-    if (this.mediaInfo) {
-      return this.mediaInfo;
-    }
-    /** @type {import("./Container.js").ContainerMediaInfo} */
-    const info = { format: this.formatName, durationSeconds: null, startTimeSeconds: 0 };
-    this.mediaInfo = info;
-    const head = await this.readRange(0, Math.min(4095, this.fileSize - 1));
-    if (!head || !isAvi(head)) {
-      return info;
-    }
-    // RIFF("AVI ") -> LIST("hdrl") -> avih. The avih chunk's payload begins with
-    // dwMicroSecPerFrame and its fifth field is dwTotalFrames.
-    const at = head.indexOf("avih", 0, "latin1");
-    if (at < 0 || at + 8 + 20 > head.length) {
-      return info;
-    }
-    const payload = at + 8;
-    const microsecondsPerFrame = head.readUInt32LE(payload);
-    const totalFrames = head.readUInt32LE(payload + 16);
-    if (microsecondsPerFrame > 0 && totalFrames > 0) {
-      info.durationSeconds = (microsecondsPerFrame * totalFrames) / 1e6;
-    }
-    return info;
-  }
-
-  async readKeyframeIndex() {
-    const r = await readAviKeyframeTimes(this.readRange, this.fileSize);
-    if (!r) return null;
-    if (Array.isArray(r)) return { times: r, tolerance: 0 };
-    return r;
-  }
-}
+/**
+ * @file AVI container — RIFF.
+ *
+ * Minimal: only keyframe index via idx1 (AVIIF_KEYFRAME). Tracks are not
+ * used by current product beyond video — expose a single VideoTrack if needed.
+ * Spec: RIFF AVI, idx1 chunk at file end, OpenDML may lack idx1 → no index.
+ */
+
+import { Container } from "./Container.js";
+import { VideoTrack } from "../tracks/VideoTrack.js";
+
+export class AviContainer extends Container {
+  get formatName() {
+    return "avi";
+  }
+
+  static detect(head) {
+    return isAvi(head);
+  }
+
+  /**
+   * The keyframe times this container's own index states, in ascending seconds.
+   *
+   * Static so a caller that has bytes and no container can ask; the instance
+   * form is {@link Container#readKeyframeIndex}.
+   *
+   * @param {(start:number,end:number)=>Promise<Buffer|null>} readRange
+   * @param {number} fileSize
+   * @returns {Promise<number[]|null>} Null where the container has no index.
+   */
+  static readKeyframeTimes(readRange, fileSize) {
+    return readAviKeyframeTimes(readRange, fileSize);
+  }
+
+  async readTracks() {
+    const head = await this.readRange(0, Math.min(4095, this.fileSize - 1));
+    if (!head || !isAvi(head)) return [];
+    // AVI track table is minimal — expose one video track for uniformity.
+    return [new VideoTrack({
+      trackNumber: 1,
+      declaredIndex: 0,
+      codecId: "",
+      language: "",
+      languageBcp47: "",
+      name: "",
+      isEnabled: true,
+      isDefault: true,
+      declaresDefault: false
+    })];
+  }
+
+  /**
+   * Duration from the main AVI header, per the RIFF AVI specification: the
+   * header states microseconds per frame and the total number of frames, and
+   * their product is the length.
+   *
+   * An AVI has no edit list and no timeline offset of any kind, so its start is
+   * zero — a declaration of the format itself, not an absence.
+   *
+   * @returns {Promise<import("./Container.js").ContainerMediaInfo>}
+   */
+  async readMediaInfo() {
+    if (this.mediaInfo) {
+      return this.mediaInfo;
+    }
+    /** @type {import("./Container.js").ContainerMediaInfo} */
+    const info = { format: this.formatName, durationSeconds: null, startTimeSeconds: 0 };
+    this.mediaInfo = info;
+    const head = await this.readRange(0, Math.min(4095, this.fileSize - 1));
+    if (!head || !isAvi(head)) {
+      return info;
+    }
+    // RIFF("AVI ") -> LIST("hdrl") -> avih. The avih chunk's payload begins with
+    // dwMicroSecPerFrame and its fifth field is dwTotalFrames.
+    const at = head.indexOf("avih", 0, "latin1");
+    if (at < 0 || at + 8 + 20 > head.length) {
+      return info;
+    }
+    const payload = at + 8;
+    const microsecondsPerFrame = head.readUInt32LE(payload);
+    const totalFrames = head.readUInt32LE(payload + 16);
+    if (microsecondsPerFrame > 0 && totalFrames > 0) {
+      info.durationSeconds = (microsecondsPerFrame * totalFrames) / 1e6;
+    }
+    return info;
+  }
+
+  async parseKeyframeIndex() {
+    const r = await readAviKeyframeTimes(this.readRange, this.fileSize);
+    if (!r) return null;
+    if (Array.isArray(r)) return { times: r, tolerance: 0 };
+    return r;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// RIFF speaking about AVI: the idx1 index and its keyframe flag.
+// Here because the class is the only way in.
+// ---------------------------------------------------------------------------
+/**
+ * @file Keyframe index for AVI, read without downloading the file.
+ *
+ * AVI ends with an `idx1` chunk: one fixed-size entry per stream chunk, each
+ * carrying a flags word whose keyframe bit says whether that chunk starts a
+ * keyframe. Frame number times the video stream's frame duration gives the
+ * time, so the index alone is enough — no media has to be read.
+ *
+ * `idx1` lives at the end of the file and the top-level chunk headers state
+ * their sizes, so it is reached by stepping over headers (typically two hops:
+ * `LIST hdrl`, `LIST movi`), not by scanning.
+ *
+ * Still relevant despite the format's age: older releases are largely XviD in
+ * AVI, and those are exactly the files that get copied rather than re-encoded.
+ */
+
+const HEADER_BYTES = 8;
+const PROBE_BYTES = 4096;
+// Keyframe flag in an idx1 entry's flags word (AVIIF_KEYFRAME).
+const KEYFRAME_FLAG = 0x10;
+const IDX1_ENTRY_BYTES = 16;
+// Cap on the idx1 read. One entry per chunk, 16 bytes each — a long film runs
+// to a few MB; beyond this is not a normal index.
+const MAX_IDX1_BYTES = 64 * 1024 * 1024;
+
+/**
+ * Whether this looks like AVI: a RIFF container whose form type is `AVI `.
+ *
+ * @param {Buffer} head
+ * @returns {boolean}
+ */
+function isAvi(head) {
+  return (
+    head.length >= 12 &&
+    head.toString("latin1", 0, 4) === "RIFF" &&
+    head.toString("latin1", 8, 12) === "AVI "
+  );
+}
+
+/**
+ * Microseconds per frame and the video stream's chunk id prefix, from the main
+ * header. Both live in the `hdrl` list near the file start.
+ *
+ * @param {Buffer} head
+ * @returns {{ microsecondsPerFrame: number } | null}
+ */
+function readMainHeader(head) {
+  // Top-level: "RIFF" size "AVI " then chunks. `avih` sits inside `LIST hdrl`.
+  let offset = 12;
+  while (offset + HEADER_BYTES <= head.length) {
+    const id = head.toString("latin1", offset, offset + 4);
+    const size = head.readUInt32LE(offset + 4);
+    if (size <= 0) {
+      return null;
+    }
+    if (id === "LIST") {
+      // Descend: list type follows the header, then its own chunks.
+      const listType = head.toString("latin1", offset + 8, offset + 12);
+      if (listType === "hdrl") {
+        let inner = offset + 12;
+        while (inner + HEADER_BYTES <= Math.min(head.length, offset + 8 + size)) {
+          const innerId = head.toString("latin1", inner, inner + 4);
+          const innerSize = head.readUInt32LE(inner + 4);
+          if (innerSize <= 0) {
+            return null;
+          }
+          if (innerId === "avih" && inner + 8 + 4 <= head.length) {
+            return { microsecondsPerFrame: head.readUInt32LE(inner + 8) };
+          }
+          inner += HEADER_BYTES + innerSize + (innerSize % 2);
+        }
+      }
+      offset += HEADER_BYTES + 4 + (size - 4) + ((size - 4) % 2);
+      continue;
+    }
+    offset += HEADER_BYTES + size + (size % 2);
+  }
+  return null;
+}
+
+/**
+ * Step over top-level chunks to find `idx1`.
+ *
+ * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
+ * @param {number} fileSize
+ * @returns {Promise<{ offset: number, size: number } | null>}
+ */
+async function findIdx1(readRange, fileSize) {
+  let offset = 12; // Past "RIFF" size "AVI ".
+  while (offset + HEADER_BYTES < fileSize) {
+    const probe = await readRange(offset, Math.min(fileSize - 1, offset + HEADER_BYTES - 1));
+    if (!probe || probe.length < HEADER_BYTES) {
+      return null;
+    }
+    const id = probe.toString("latin1", 0, 4);
+    const size = probe.readUInt32LE(4);
+    if (size <= 0) {
+      return null;
+    }
+    if (id === "idx1") {
+      return { offset: offset + HEADER_BYTES, size };
+    }
+    // Chunks are word-aligned; a LIST carries its type inside the payload, so
+    // the same size arithmetic covers both cases.
+    offset += HEADER_BYTES + size + (size % 2);
+  }
+  return null;
+}
+
+/**
+ * Read the keyframe times of an AVI file.
+ *
+ * @param {(start: number, end: number) => Promise<Buffer | null>} readRange
+ * @param {number} fileSize
+ * @returns {Promise<number[] | null>} Ascending seconds, or null when the file
+ *   has no `idx1` (OpenDML-only index, interrupted write, damaged upload).
+ */
+async function readAviKeyframeTimes(readRange, fileSize) {
+  const head = await readRange(0, Math.min(PROBE_BYTES - 1, fileSize - 1));
+  if (!head || !isAvi(head)) {
+    return null;
+  }
+  const mainHeader = readMainHeader(head);
+  if (!mainHeader || !mainHeader.microsecondsPerFrame) {
+    return null;
+  }
+
+  const idx1 = await findIdx1(readRange, fileSize);
+  if (!idx1 || idx1.size > MAX_IDX1_BYTES) {
+    return null;
+  }
+
+  const table = await readRange(idx1.offset, Math.min(fileSize - 1, idx1.offset + idx1.size - 1));
+  if (!table || table.length < IDX1_ENTRY_BYTES) {
+    return null;
+  }
+
+  const secondsPerFrame = mainHeader.microsecondsPerFrame / 1e6;
+  const times = [];
+  let videoFrame = 0;
+  for (let at = 0; at + IDX1_ENTRY_BYTES <= table.length; at += IDX1_ENTRY_BYTES) {
+    const chunkId = table.toString("latin1", at, at + 4);
+    // Video chunks are "##db" (uncompressed) or "##dc" (compressed); audio is
+    // "##wb" and must not advance the frame counter.
+    const isVideo = chunkId.endsWith("db") || chunkId.endsWith("dc");
+    if (!isVideo) {
+      continue;
+    }
+    const flags = table.readUInt32LE(at + 4);
+    if ((flags & KEYFRAME_FLAG) !== 0) {
+      times.push(videoFrame * secondsPerFrame);
+    }
+    videoFrame += 1;
+  }
+  if (times.length === 0) {
+    return null;
+  }
+  // AVI names a keyframe by its FRAME NUMBER, and the time above is that number
+  // multiplied by the frame duration the header declares. The frames are the
+  // right ones — measured 2026-08-21 against the files themselves, 1196 index
+  // entries against 1196 real keyframes and 901 against 901, exactly — but the
+  // names are 10-44 ms away from the presentation times the demuxer computes,
+  // always under one frame. So the caller is told how far a time here may be
+  // from the instant it refers to, and can ask for a seek late enough that it
+  // still lands on the frame rather than on the one before it.
+  return { times, tolerance: secondsPerFrame };
+}