@torrent-tv/proxy 2.89.7 → 2.89.9

package/services/encode/segment-formats/mpegts.js

@@ -1,134 +1,134 @@
-/**
- * @file MPEG-TS segment format — self-contained `.ts` segments, no init segment.
- *
- * This is the pre-fMP4 behaviour (recovered from the switch commit `dd1ce09`),
- * kept as a selectable alternative rather than deleted. Each segment carries
- * its own parameter sets and its own timestamps, so it is valid on its own —
- * there is no shared init segment that a seek-restart can invalidate, and
- * therefore none of the timeline problems the fMP4 path has to correct for.
- *
- * Trade-off vs fMP4: higher container overhead, and encoders that do not repeat
- * SPS/PPS (CM4 `h264_v4l2m2m`) emit segments after the first with no parameter
- * sets, which is exactly why fMP4 became the default.
- *
- * See {@link SegmentFormat} in `./index.js` for the interface contract.
- */
-
-// What a piece is called while it is still being written. See
-// `makingFileNameTemplate`.
-const MAKING_PATTERN = /^making-([0-9a-z]+)-(\d{5})\.ts$/;
-const SEGMENT_PATTERN = /^segment-(\d{5})\.ts$/;
-
-/**
- * @type {import("./index.js").SegmentFormat}
- */
-export const mpegtsFormat = {
-  id: "mpegts",
-  // No init segment: every `.ts` segment is self-describing.
-  initFileName: null,
-  initContentType: null,
-  segmentContentType: "video/mp2t",
-  playlistVersion: 3,
-
-  muxerArgs() {
-    return ["-hls_segment_filename", "segment-%05d.ts"];
-  },
-
-  /**
-   * Arguments for cutting at times we choose rather than times ffmpeg picks.
-   *
-   * The `hls` muxer takes only a target duration and finds its own cut points,
-   * which is why the playlist and the real segments drifted apart; the `segment`
-   * muxer takes the list. Self-contained segments make this straightforward
-   * here: no init segment to reconcile, so the only difference is the container
-   * and the file name template.
-   *
-   * @returns {string[]}
-   */
-  explicitTimesMuxerArgs() {
-    return ["-segment_format", "mpegts"];
-  },
-
-  /** The output path template for the `segment` muxer. */
-  /**
-   * The name ffmpeg is told to write a piece under WHILE IT IS MAKING IT.
-   *
-   * Not the name it is served under. A piece being written is not a piece, and
-   * under its final name it is indistinguishable from one — which is how half a
-   * segment came to be served: the proof of completeness was "the next file
-   * exists", true of one writer walking forward and false the moment two runs
-   * share an output, because the next file is then written by another process.
-   * Field 2026-09-08: `segment-00057.mp4` served at 2 268 361 bytes and then at
-   * 4 510 940, and the browser refused the whole one for the rest of the session.
-   *
-   * With a working name, the served name appears only when the encoder has said
-   * the piece is closed, and existence under it IS the proof — one rule, the
-   * same for every branch, and true whether or not our own process is alive.
-   *
-   * @returns {string}
-   */
-  makingFileNameTemplate(tag) {
-    return `making-${String(tag ?? "0").replace(/[^0-9a-z]/g, "")}-%05d.ts`;
-  },
-
-  /**
-   * Which run is writing this working name, or null when the name is not one.
-   *
-   * The tag is what makes clearing up after a dead run possible without
-   * guessing: several runs write into one directory, so "the unfinished pieces"
-   * is only a well-formed question per run. It used to be answered by looking
-   * for the highest SERVED name inside the stretch the ended run was given and
-   * judging its bytes — a guess, and under the naming rule above it would remove
-   * a complete piece somebody else had closed.
-   *
-   * @param {string} name
-   * @returns {string | null}
-   */
-  makingTagOf(name) {
-    const match = MAKING_PATTERN.exec(String(name ?? "").trim());
-    return match ? match[1] : null;
-  },
-
-  /**
-   * The name a piece just closed under a working name is served as, or null when
-   * the name is not one of ours.
-   *
-   * @param {string} makingName
-   * @returns {string | null}
-   */
-  servedNameOf(makingName) {
-    const match = MAKING_PATTERN.exec(String(makingName ?? "").trim());
-    return match ? this.segmentFileName(Number(match[2])) : null;
-  },
-
-  segmentFileNameTemplate() {
-    return "segment-%05d.ts";
-  },
-
-  playlistHeaderLines() {
-    return []; // no `#EXT-X-MAP`
-  },
-
-  segmentFileName(index) {
-    return `segment-${String(index).padStart(5, "0")}.ts`;
-  },
-
-  isSegmentFileName(fileName) {
-    return SEGMENT_PATTERN.test(fileName);
-  },
-
-  segmentIndexFromName(fileName) {
-    const match = SEGMENT_PATTERN.exec(fileName);
-    return match ? Number(match[1]) : -1;
-  },
-
-  /**
-   * MPEG-TS segments carry their own timestamps and need no correction, so they
-   * are streamed straight from disk (no read-into-memory step).
-   */
-  needsSegmentRewrite: false,
-
-  prepareSegmentBytes(bytes) {
-    return bytes;
-  }
-};
+/**
+ * @file MPEG-TS segment format — self-contained `.ts` segments, no init segment.
+ *
+ * This is the pre-fMP4 behaviour (recovered from the switch commit `dd1ce09`),
+ * kept as a selectable alternative rather than deleted. Each segment carries
+ * its own parameter sets and its own timestamps, so it is valid on its own —
+ * there is no shared init segment that a seek-restart can invalidate, and
+ * therefore none of the timeline problems the fMP4 path has to correct for.
+ *
+ * Trade-off vs fMP4: higher container overhead, and encoders that do not repeat
+ * SPS/PPS (CM4 `h264_v4l2m2m`) emit segments after the first with no parameter
+ * sets, which is exactly why fMP4 became the default.
+ *
+ * See {@link SegmentFormat} in `./index.js` for the interface contract.
+ */
+
+// What a piece is called while it is still being written. See
+// `makingFileNameTemplate`.
+const MAKING_PATTERN = /^making-([0-9a-z]+)-(\d{5})\.ts$/;
+const SEGMENT_PATTERN = /^segment-(\d{5})\.ts$/;
+
+/**
+ * @type {import("./index.js").SegmentFormat}
+ */
+export const mpegtsFormat = {
+  id: "mpegts",
+  // No init segment: every `.ts` segment is self-describing.
+  initFileName: null,
+  initContentType: null,
+  segmentContentType: "video/mp2t",
+  playlistVersion: 3,
+
+  muxerArgs() {
+    return ["-hls_segment_filename", "segment-%05d.ts"];
+  },
+
+  /**
+   * Arguments for cutting at times we choose rather than times ffmpeg picks.
+   *
+   * The `hls` muxer takes only a target duration and finds its own cut points,
+   * which is why the playlist and the real segments drifted apart; the `segment`
+   * muxer takes the list. Self-contained segments make this straightforward
+   * here: no init segment to reconcile, so the only difference is the container
+   * and the file name template.
+   *
+   * @returns {string[]}
+   */
+  explicitTimesMuxerArgs() {
+    return ["-segment_format", "mpegts"];
+  },
+
+  /** The output path template for the `segment` muxer. */
+  /**
+   * The name ffmpeg is told to write a piece under WHILE IT IS MAKING IT.
+   *
+   * Not the name it is served under. A piece being written is not a piece, and
+   * under its final name it is indistinguishable from one — which is how half a
+   * segment came to be served: the proof of completeness was "the next file
+   * exists", true of one writer walking forward and false the moment two runs
+   * share an output, because the next file is then written by another process.
+   * Field 2026-09-08: `segment-00057.mp4` served at 2 268 361 bytes and then at
+   * 4 510 940, and the browser refused the whole one for the rest of the session.
+   *
+   * With a working name, the served name appears only when the encoder has said
+   * the piece is closed, and existence under it IS the proof — one rule, the
+   * same for every branch, and true whether or not our own process is alive.
+   *
+   * @returns {string}
+   */
+  makingFileNameTemplate(tag) {
+    return `making-${String(tag ?? "0").replace(/[^0-9a-z]/g, "")}-%05d.ts`;
+  },
+
+  /**
+   * Which run is writing this working name, or null when the name is not one.
+   *
+   * The tag is what makes clearing up after a dead run possible without
+   * guessing: several runs write into one directory, so "the unfinished pieces"
+   * is only a well-formed question per run. It used to be answered by looking
+   * for the highest SERVED name inside the stretch the ended run was given and
+   * judging its bytes — a guess, and under the naming rule above it would remove
+   * a complete piece somebody else had closed.
+   *
+   * @param {string} name
+   * @returns {string | null}
+   */
+  makingTagOf(name) {
+    const match = MAKING_PATTERN.exec(String(name ?? "").trim());
+    return match ? match[1] : null;
+  },
+
+  /**
+   * The name a piece just closed under a working name is served as, or null when
+   * the name is not one of ours.
+   *
+   * @param {string} makingName
+   * @returns {string | null}
+   */
+  servedNameOf(makingName) {
+    const match = MAKING_PATTERN.exec(String(makingName ?? "").trim());
+    return match ? this.segmentFileName(Number(match[2])) : null;
+  },
+
+  segmentFileNameTemplate() {
+    return "segment-%05d.ts";
+  },
+
+  playlistHeaderLines() {
+    return []; // no `#EXT-X-MAP`
+  },
+
+  segmentFileName(index) {
+    return `segment-${String(index).padStart(5, "0")}.ts`;
+  },
+
+  isSegmentFileName(fileName) {
+    return SEGMENT_PATTERN.test(fileName);
+  },
+
+  segmentIndexFromName(fileName) {
+    const match = SEGMENT_PATTERN.exec(fileName);
+    return match ? Number(match[1]) : -1;
+  },
+
+  /**
+   * MPEG-TS segments carry their own timestamps and need no correction, so they
+   * are streamed straight from disk (no read-into-memory step).
+   */
+  needsSegmentRewrite: false,
+
+  prepareSegmentBytes(bytes) {
+    return bytes;
+  }
+};

package/services/encode/start-stop-cost.js

@@ -1,178 +1,178 @@
-/**
- * @file What starting and stopping an encoder costs on THIS host, measured
- * before any viewer exists.
- *
- * WHY IT HAS TO BE MEASURED AT STARTUP. Both figures decide one thing: whether
- * to leave an encoder where it stands or kill it and start another elsewhere.
- * The plan compares when the wanted pieces appear under each arrangement, and
- * for that it needs how long a fresh encoder takes to produce anything and how
- * long killing one takes.
- *
- * Until now both were learned only from runs that had ENDED, so at a cold open
- * they were zero — and zero does not read as "not measured", it reads as
- * "free". A warming encoder then owed one piece and a moved one owed
- * `0 + 0 + one piece`: the same figure to the millisecond. The tie fell to
- * position, so any advantage however small won, and the plan moved the encoder
- * on every pass. Field 2026-09-08, the first fifteen seconds of a session:
- * start at #68, a second later kill and start at #69, half a second later kill
- * and start at #68 again, each dying having produced nothing. Over two days,
- * 153 runs stopped that way and 68 of them made no segment at all.
- *
- * ONE RUN GIVES BOTH READINGS. An encoder is started on a generated picture
- * through the same pipeline a session uses, timed until it says it has closed
- * its first piece, then killed and timed until it exits. Nothing about the
- * measurement is chosen: it is the same encoder, the same muxer, the same
- * channel the encoder announces finished pieces on.
- */
-
-import { spawn } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-/**
- * How long the measurement may take before it is abandoned.
- *
- * Not a property of the host and not a figure anything is derived from: it
- * bounds a startup step so a machine that cannot produce a piece at all does not
- * hold the proxy closed. A host that hits it has said something useful — that
- * its first piece takes longer than this — and the plan is told the bound rather
- * than a zero.
- */
-const GIVE_UP_AFTER_MS = 30_000;
-
-/**
- * Measure a start and a stop on this host.
- *
- * @param {object} params
- * @param {string} params.ffmpegBin
- * @param {import("./Encoder.js").Encoder} params.encoder - The encoder this
- *   proxy has chosen, so the reading is of the thing that will actually run.
- * @param {number} [params.segmentDurationSec]
- * @param {{ info: Function, warn: Function }} [params.logger]
- * @param {() => number} [params.now]
- * @returns {Promise<{ firstByteWaitSec: number, killCostSec: number } | null>}
- *   Null where nothing could be measured, which is said rather than passed off
- *   as a zero.
- */
-export async function measureStartAndStop({
-  ffmpegBin,
-  encoder,
-  segmentDurationSec = 4,
-  logger = null,
-  now = Date.now
-}) {
-  const log = logger ?? { info: () => {}, warn: () => {} };
-  const dir = mkdtempSync(path.join(os.tmpdir(), "tt-startstop-"));
-  try {
-    const args = [
-      "-hide_banner",
-      "-nostats",
-      "-loglevel",
-      "error",
-      // The device, where the kind takes one.
-      ...(typeof encoder?.benchmarkInputArgs === "function" ? encoder.benchmarkInputArgs() : []),
-      // A generated picture: the reading is of this host's encoder and muxer,
-      // and a file would add its own reading and its own download.
-      "-f",
-      "lavfi",
-      "-i",
-      `testsrc2=size=640x360:rate=25`,
-      "-t",
-      String(segmentDurationSec * 4),
-      // The encoder this proxy has chosen, asked for its own arguments: the
-      // reading must be of the thing that will actually run, since what a start
-      // costs is mostly the encoder opening.
-      // The same arguments the throughput benchmark uses, for the same reason:
-      // a start is timed on the encoder itself, not on a scaler in front of it.
-      ...(typeof encoder?.benchmarkArgs === "function"
-        ? encoder.benchmarkArgs(null)
-        : ["-c:v", "libx264", "-preset", "ultrafast"]),
-      "-an",
-      "-f",
-      "segment",
-      "-segment_time",
-      String(segmentDurationSec),
-      // The channel the encoder names its finished pieces on — the same one a
-      // session reads, so "the first piece exists" means here what it means
-      // there.
-      "-segment_list",
-      "pipe:3",
-      "-segment_list_flags",
-      "+live",
-      "-segment_format",
-      "mp4",
-      path.join(dir, "seg-%05d.mp4")
-    ];
-
-    const spawnedAt = now();
-    const child = spawn(ffmpegBin, args, {
-      stdio: ["ignore", "ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-
-    const firstPiece = await new Promise((resolve) => {
-      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
-      timer.unref?.();
-      child.stdio?.[3]?.on("data", () => {
-        clearTimeout(timer);
-        resolve(now() - spawnedAt);
-      });
-      child.on("error", () => {
-        clearTimeout(timer);
-        resolve(null);
-      });
-      child.on("exit", () => {
-        clearTimeout(timer);
-        resolve(null);
-      });
-    });
-
-    if (firstPiece === null) {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-        // Already gone.
-      }
-      log.warn("hwaccel: a start could not be measured; the plan is told so rather than told zero");
-      return null;
-    }
-
-    const killedAt = now();
-    const died = await new Promise((resolve) => {
-      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
-      timer.unref?.();
-      child.on("exit", () => {
-        clearTimeout(timer);
-        resolve(now() - killedAt);
-      });
-      try {
-        child.kill("SIGTERM");
-      } catch {
-        clearTimeout(timer);
-        resolve(null);
-      }
-    });
-
-    const firstByteWaitSec = firstPiece / 1000;
-    const killCostSec = died === null ? 0 : died / 1000;
-    log.info(
-      `hwaccel: a start costs ${firstByteWaitSec.toFixed(2)}s to a first piece and ` +
-      `a stop ${killCostSec.toFixed(2)}s on this host — measured before any viewer, ` +
-      "because a plan told zero reads it as free and moves an encoder for nothing"
-    );
-    return { firstByteWaitSec, killCostSec };
-  } catch (error) {
-    log.warn(
-      `hwaccel: a start and a stop could not be measured: ` +
-      `${error instanceof Error ? error.message : String(error)}`
-    );
-    return null;
-  } finally {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // best effort
-    }
-  }
-}
+/**
+ * @file What starting and stopping an encoder costs on THIS host, measured
+ * before any viewer exists.
+ *
+ * WHY IT HAS TO BE MEASURED AT STARTUP. Both figures decide one thing: whether
+ * to leave an encoder where it stands or kill it and start another elsewhere.
+ * The plan compares when the wanted pieces appear under each arrangement, and
+ * for that it needs how long a fresh encoder takes to produce anything and how
+ * long killing one takes.
+ *
+ * Until now both were learned only from runs that had ENDED, so at a cold open
+ * they were zero — and zero does not read as "not measured", it reads as
+ * "free". A warming encoder then owed one piece and a moved one owed
+ * `0 + 0 + one piece`: the same figure to the millisecond. The tie fell to
+ * position, so any advantage however small won, and the plan moved the encoder
+ * on every pass. Field 2026-09-08, the first fifteen seconds of a session:
+ * start at #68, a second later kill and start at #69, half a second later kill
+ * and start at #68 again, each dying having produced nothing. Over two days,
+ * 153 runs stopped that way and 68 of them made no segment at all.
+ *
+ * ONE RUN GIVES BOTH READINGS. An encoder is started on a generated picture
+ * through the same pipeline a session uses, timed until it says it has closed
+ * its first piece, then killed and timed until it exits. Nothing about the
+ * measurement is chosen: it is the same encoder, the same muxer, the same
+ * channel the encoder announces finished pieces on.
+ */
+
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * How long the measurement may take before it is abandoned.
+ *
+ * Not a property of the host and not a figure anything is derived from: it
+ * bounds a startup step so a machine that cannot produce a piece at all does not
+ * hold the proxy closed. A host that hits it has said something useful — that
+ * its first piece takes longer than this — and the plan is told the bound rather
+ * than a zero.
+ */
+const GIVE_UP_AFTER_MS = 30_000;
+
+/**
+ * Measure a start and a stop on this host.
+ *
+ * @param {object} params
+ * @param {string} params.ffmpegBin
+ * @param {import("./Encoder.js").Encoder} params.encoder - The encoder this
+ *   proxy has chosen, so the reading is of the thing that will actually run.
+ * @param {number} [params.segmentDurationSec]
+ * @param {{ info: Function, warn: Function }} [params.logger]
+ * @param {() => number} [params.now]
+ * @returns {Promise<{ firstByteWaitSec: number, killCostSec: number } | null>}
+ *   Null where nothing could be measured, which is said rather than passed off
+ *   as a zero.
+ */
+export async function measureStartAndStop({
+  ffmpegBin,
+  encoder,
+  segmentDurationSec = 4,
+  logger = null,
+  now = Date.now
+}) {
+  const log = logger ?? { info: () => {}, warn: () => {} };
+  const dir = mkdtempSync(path.join(os.tmpdir(), "tt-startstop-"));
+  try {
+    const args = [
+      "-hide_banner",
+      "-nostats",
+      "-loglevel",
+      "error",
+      // The device, where the kind takes one.
+      ...(typeof encoder?.benchmarkInputArgs === "function" ? encoder.benchmarkInputArgs() : []),
+      // A generated picture: the reading is of this host's encoder and muxer,
+      // and a file would add its own reading and its own download.
+      "-f",
+      "lavfi",
+      "-i",
+      `testsrc2=size=640x360:rate=25`,
+      "-t",
+      String(segmentDurationSec * 4),
+      // The encoder this proxy has chosen, asked for its own arguments: the
+      // reading must be of the thing that will actually run, since what a start
+      // costs is mostly the encoder opening.
+      // The same arguments the throughput benchmark uses, for the same reason:
+      // a start is timed on the encoder itself, not on a scaler in front of it.
+      ...(typeof encoder?.benchmarkArgs === "function"
+        ? encoder.benchmarkArgs(null)
+        : ["-c:v", "libx264", "-preset", "ultrafast"]),
+      "-an",
+      "-f",
+      "segment",
+      "-segment_time",
+      String(segmentDurationSec),
+      // The channel the encoder names its finished pieces on — the same one a
+      // session reads, so "the first piece exists" means here what it means
+      // there.
+      "-segment_list",
+      "pipe:3",
+      "-segment_list_flags",
+      "+live",
+      "-segment_format",
+      "mp4",
+      path.join(dir, "seg-%05d.mp4")
+    ];
+
+    const spawnedAt = now();
+    const child = spawn(ffmpegBin, args, {
+      stdio: ["ignore", "ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+
+    const firstPiece = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.stdio?.[3]?.on("data", () => {
+        clearTimeout(timer);
+        resolve(now() - spawnedAt);
+      });
+      child.on("error", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+    });
+
+    if (firstPiece === null) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // Already gone.
+      }
+      log.warn("hwaccel: a start could not be measured; the plan is told so rather than told zero");
+      return null;
+    }
+
+    const killedAt = now();
+    const died = await new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), GIVE_UP_AFTER_MS);
+      timer.unref?.();
+      child.on("exit", () => {
+        clearTimeout(timer);
+        resolve(now() - killedAt);
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        clearTimeout(timer);
+        resolve(null);
+      }
+    });
+
+    const firstByteWaitSec = firstPiece / 1000;
+    const killCostSec = died === null ? 0 : died / 1000;
+    log.info(
+      `hwaccel: a start costs ${firstByteWaitSec.toFixed(2)}s to a first piece and ` +
+      `a stop ${killCostSec.toFixed(2)}s on this host — measured before any viewer, ` +
+      "because a plan told zero reads it as free and moves an encoder for nothing"
+    );
+    return { firstByteWaitSec, killCostSec };
+  } catch (error) {
+    log.warn(
+      `hwaccel: a start and a stop could not be measured: ` +
+      `${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best effort
+    }
+  }
+}