@torrent-tv/proxy 2.87.8 → 2.87.9

package/services/encode/RunProgress.js

@@ -1,84 +1,84 @@
-/**
- * @file Progress reported by one encoder run, placed on the source timeline.
- *
- * ffmpeg reports time relative to the start of each run on both the re-encode
- * and copy branches. `-output_ts_offset` and `-copyts` change muxed timestamps,
- * not the `-progress` clock. Every reading is therefore rebased by this run's
- * own start, never by an output-wide value shared with another run.
- */
-
-function parseTimestamp(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return null;
-  }
-  const parts = value.split(":");
-  if (parts.length !== 3) {
-    return null;
-  }
-  const [hours, minutes, seconds] = parts.map(Number);
-  return [hours, minutes, seconds].every(Number.isFinite)
-    ? hours * 3600 + minutes * 60 + seconds
-    : null;
-}
-
-export class RunProgress {
-  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now } = {}) {
-    this.startPositionSeconds = Number.isFinite(startSeconds) ? Math.max(0, startSeconds) : 0;
-    this.processedSeconds = this.startPositionSeconds;
-    this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
-    this.percent = null;
-    this.remainingSeconds = this.totalSeconds;
-    this.speed = "";
-    this.updatedAt = now();
-    this.lastLoggedAt = 0;
-    this.now = now;
-    this.#derive();
-  }
-
-  note({ processedSeconds = null, outTime, speed = null }) {
-    const relative = Number.isFinite(processedSeconds)
-      ? processedSeconds
-      : parseTimestamp(outTime);
-    if (relative !== null) {
-      this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
-    }
-    if (typeof speed === "string") {
-      this.speed = speed;
-    }
-    this.updatedAt = this.now();
-    this.#derive();
-    return this.snapshot();
-  }
-
-  shouldLog(everyMs) {
-    if (this.percent === null || this.updatedAt - this.lastLoggedAt < everyMs) {
-      return false;
-    }
-    this.lastLoggedAt = this.updatedAt;
-    return true;
-  }
-
-  snapshot() {
-    return {
-      processedSeconds: this.processedSeconds,
-      startPositionSeconds: this.startPositionSeconds,
-      totalSeconds: this.totalSeconds,
-      percent: this.percent,
-      remainingSeconds: this.remainingSeconds,
-      speed: this.speed,
-      updatedAt: this.updatedAt
-    };
-  }
-
-  #derive() {
-    if (this.totalSeconds === null) {
-      this.percent = null;
-      this.remainingSeconds = null;
-      return;
-    }
-    const span = Math.max(1, this.totalSeconds - this.startPositionSeconds);
-    const processed = Math.max(0, this.processedSeconds - this.startPositionSeconds);
-    this.percent = Math.max(0, Math.min(100, (processed / span) * 100));
-    this.remainingSeconds = Math.max(0, this.totalSeconds - this.processedSeconds);
-  }
-}
+/**
+ * @file Progress reported by one encoder run, placed on the source timeline.
+ *
+ * ffmpeg reports time relative to the start of each run on both the re-encode
+ * and copy branches. `-output_ts_offset` and `-copyts` change muxed timestamps,
+ * not the `-progress` clock. Every reading is therefore rebased by this run's
+ * own start, never by an output-wide value shared with another run.
+ */
+
+function parseTimestamp(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parts = value.split(":");
+  if (parts.length !== 3) {
+    return null;
+  }
+  const [hours, minutes, seconds] = parts.map(Number);
+  return [hours, minutes, seconds].every(Number.isFinite)
+    ? hours * 3600 + minutes * 60 + seconds
+    : null;
+}
+
+export class RunProgress {
+  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now } = {}) {
+    this.startPositionSeconds = Number.isFinite(startSeconds) ? Math.max(0, startSeconds) : 0;
+    this.processedSeconds = this.startPositionSeconds;
+    this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
+    this.percent = null;
+    this.remainingSeconds = this.totalSeconds;
+    this.speed = "";
+    this.updatedAt = now();
+    this.lastLoggedAt = 0;
+    this.now = now;
+    this.#derive();
+  }
+
+  note({ processedSeconds = null, outTime, speed = null }) {
+    const relative = Number.isFinite(processedSeconds)
+      ? processedSeconds
+      : parseTimestamp(outTime);
+    if (relative !== null) {
+      this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
+    }
+    if (typeof speed === "string") {
+      this.speed = speed;
+    }
+    this.updatedAt = this.now();
+    this.#derive();
+    return this.snapshot();
+  }
+
+  shouldLog(everyMs) {
+    if (this.percent === null || this.updatedAt - this.lastLoggedAt < everyMs) {
+      return false;
+    }
+    this.lastLoggedAt = this.updatedAt;
+    return true;
+  }
+
+  snapshot() {
+    return {
+      processedSeconds: this.processedSeconds,
+      startPositionSeconds: this.startPositionSeconds,
+      totalSeconds: this.totalSeconds,
+      percent: this.percent,
+      remainingSeconds: this.remainingSeconds,
+      speed: this.speed,
+      updatedAt: this.updatedAt
+    };
+  }
+
+  #derive() {
+    if (this.totalSeconds === null) {
+      this.percent = null;
+      this.remainingSeconds = null;
+      return;
+    }
+    const span = Math.max(1, this.totalSeconds - this.startPositionSeconds);
+    const processed = Math.max(0, this.processedSeconds - this.startPositionSeconds);
+    this.percent = Math.max(0, Math.min(100, (processed / span) * 100));
+    this.remainingSeconds = Math.max(0, this.totalSeconds - this.processedSeconds);
+  }
+}

package/services/encode/SegmentDemand.js

@@ -1,95 +1,95 @@
-/**
- * @file What is wanted of one output, in ITS OWN segment numbers.
- *
- * One map per output and nothing else. The map itself is built once, per film,
- * by the layer that knows where the viewers are; this holds the copy converted
- * into an output's own numbering, because two outputs of one film are cut
- * independently — 454 pieces against 401 on the field file — so the same second
- * is a different number in each.
- *
- * **No viewer appears here.** It used to hold a window per viewer per band and
- * merge them itself, which was the priority layer's work done a second time in
- * the wrong place, and it carried the viewer's name as the key of a claim —
- * against the rule that the encoding and the viewer are not connected at all.
- * What arrives now is already merged and already anonymous.
- */
-
-export class SegmentDemand {
-  /** Output address to what is wanted of it. @type {Map<string, object[]>} */
-  #maps = new Map();
-
-  /**
-   * What is wanted of one output, replacing whatever was wanted before.
-   *
-   * An EMPTY map is a statement and is stored as one: it says nobody is coming
-   * anywhere in this output, which is what stops the encoders on it.
-   *
-   * @param {string} address
-   * @param {{ from: number, to: number, priority: number, withinSeconds: number }[]} zones
-   */
-  state(address, zones) {
-    this.#maps.set(address, Array.isArray(zones) ? zones : []);
-  }
-
-  /**
-   * An output nobody has anything to say about any more.
-   *
-   * @param {string} address
-   */
-  forget(address) {
-    this.#maps.delete(address);
-  }
-
-  /**
-   * Every output anything is wanted of.
-   *
-   * @returns {string[]}
-   */
-  addresses() {
-    return [...this.#maps.keys()];
-  }
-
-  /**
-   * What is wanted of one output.
-   *
-   * @param {string} address
-   * @returns {{ from: number, to: number, priority: number, withinSeconds: number }[]}
-   */
-  mapOn(address) {
-    return this.#maps.get(address) ?? [];
-  }
-
-  /**
-   * What the map says about one segment, and about the map it sits in.
-   *
-   * Asked by whoever MEASURES how well the map is being served: a wait means
-   * one thing at the top rank and another at the bottom, and telling them apart
-   * needs both the segment's own rank and the highest rank stated — a rank is a
-   * position in this map, not an absolute number.
-   *
-   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
-   * when the segment's own is zero. A top rank of zero says the map has not been
-   * built yet — a session created a moment ago, before the first pass — and that
-   * is a different thing from "nobody is coming". Conflated, every request
-   * behind the run reads as absent for as long as a fresh session has no map.
-   *
-   * @param {string} address
-   * @param {number} index
-   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
-   *   nobody's zone, which is a statement: nothing is coming for it.
-   */
-  rankOf(address, index) {
-    const zones = this.mapOn(address);
-    let rank = 0;
-    let topRank = 0;
-    for (const zone of zones) {
-      if (zone.priority > topRank) {
-        topRank = zone.priority;
-      }
-      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
-        rank = zone.priority;
-      }
-    }
-    return { rank, topRank };
-  }
-}
+/**
+ * @file What is wanted of one output, in ITS OWN segment numbers.
+ *
+ * One map per output and nothing else. The map itself is built once, per film,
+ * by the layer that knows where the viewers are; this holds the copy converted
+ * into an output's own numbering, because two outputs of one film are cut
+ * independently — 454 pieces against 401 on the field file — so the same second
+ * is a different number in each.
+ *
+ * **No viewer appears here.** It used to hold a window per viewer per band and
+ * merge them itself, which was the priority layer's work done a second time in
+ * the wrong place, and it carried the viewer's name as the key of a claim —
+ * against the rule that the encoding and the viewer are not connected at all.
+ * What arrives now is already merged and already anonymous.
+ */
+
+export class SegmentDemand {
+  /** Output address to what is wanted of it. @type {Map<string, object[]>} */
+  #maps = new Map();
+
+  /**
+   * What is wanted of one output, replacing whatever was wanted before.
+   *
+   * An EMPTY map is a statement and is stored as one: it says nobody is coming
+   * anywhere in this output, which is what stops the encoders on it.
+   *
+   * @param {string} address
+   * @param {{ from: number, to: number, priority: number, withinSeconds: number }[]} zones
+   */
+  state(address, zones) {
+    this.#maps.set(address, Array.isArray(zones) ? zones : []);
+  }
+
+  /**
+   * An output nobody has anything to say about any more.
+   *
+   * @param {string} address
+   */
+  forget(address) {
+    this.#maps.delete(address);
+  }
+
+  /**
+   * Every output anything is wanted of.
+   *
+   * @returns {string[]}
+   */
+  addresses() {
+    return [...this.#maps.keys()];
+  }
+
+  /**
+   * What is wanted of one output.
+   *
+   * @param {string} address
+   * @returns {{ from: number, to: number, priority: number, withinSeconds: number }[]}
+   */
+  mapOn(address) {
+    return this.#maps.get(address) ?? [];
+  }
+
+  /**
+   * What the map says about one segment, and about the map it sits in.
+   *
+   * Asked by whoever MEASURES how well the map is being served: a wait means
+   * one thing at the top rank and another at the bottom, and telling them apart
+   * needs both the segment's own rank and the highest rank stated — a rank is a
+   * position in this map, not an absolute number.
+   *
+   * AND AN EMPTY MAP IS NOT AN ANSWER, which is why the top rank comes back even
+   * when the segment's own is zero. A top rank of zero says the map has not been
+   * built yet — a session created a moment ago, before the first pass — and that
+   * is a different thing from "nobody is coming". Conflated, every request
+   * behind the run reads as absent for as long as a fresh session has no map.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @returns {{ rank: number, topRank: number }} Rank zero for a number in
+   *   nobody's zone, which is a statement: nothing is coming for it.
+   */
+  rankOf(address, index) {
+    const zones = this.mapOn(address);
+    let rank = 0;
+    let topRank = 0;
+    for (const zone of zones) {
+      if (zone.priority > topRank) {
+        topRank = zone.priority;
+      }
+      if (index >= zone.from && index <= zone.to && zone.priority > rank) {
+        rank = zone.priority;
+      }
+    }
+    return { rank, topRank };
+  }
+}

package/services/encode/SoftwareEncoder.js

@@ -1,121 +1,121 @@
-/**
- * @file libx264 — the encoder every host has and the only one whose ladder of
- * speed settings is measured at startup.
- */
-
-import { Encoder } from "./Encoder.js";
-import {
-  CPU_THREADS,
-  hasForcedTimes,
-  keyFrameArgs,
-  rateControlArgs,
-  safeDimensions,
-  SOFTWARE_CRF,
-  SOFTWARE_PRESET,
-  TONEMAP_FILTER_CHAIN,
-  TRANSCODE_FPS
-} from "./args.js";
-
-/**
- * The presets the startup benchmark walks, slowest first.
- *
- * The same list `benchmarkSoftwarePresets` measures and `pickSoftwarePreset`
- * chooses from; it is stated here because it is a property of this kind, and
- * the four hardware kinds beside it show what its absence looks like.
- */
-const PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
-
-export class SoftwareEncoder extends Encoder {
-  constructor() {
-    super({ name: "libx264", kind: "software", device: null, inputArgs: [] });
-  }
-
-  /** @returns {import("./Encoder.js").SpeedLadder} */
-  get speedLadder() {
-    return {
-      flag: "-preset",
-      values: PRESETS,
-      measured: true,
-      note:
-        "Measured on every host at startup by `benchmarkSoftwarePresets`, in " +
-        "pixels per second per preset, and chosen from by `pickSoftwarePreset`."
-    };
-  }
-
-  /** Every preset: `buildVideoArgs` passes whichever the offer chose. */
-  get selectableRungs() {
-    return PRESETS;
-  }
-
-  /** @param {string | null} rung @returns {string[]} */
-  benchmarkArgs(rung = null) {
-    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
-  }
-
-  buildVideoArgs({
-    targetWidth,
-    targetHeight,
-    segmentDurationSec,
-    preset,
-    fps,
-    tonemap,
-    forcedKeyframeTimes,
-    rateControl = null
-  }) {
-    const { w, h } = safeDimensions(targetWidth, targetHeight);
-    const chosenPreset = typeof preset === "string" && preset.length > 0 ? preset : SOFTWARE_PRESET;
-    // Output frame rate: inherited from the source (rounded/capped) by the
-    // session manager, TRANSCODE_FPS by default. MUST be an integer and MUST
-    // equal the value used in the GOP below, or keyframes drift off the grid.
-    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
-    // HDR→SDR tone-map, inserted AFTER the downscale so it runs on the smaller
-    // frame (cheaper on ARM); only when the source is HDR and the filters are
-    // present (session manager gates on both).
-    const tonemapPart = tonemap === true ? `,${TONEMAP_FILTER_CHAIN}` : "";
-    return [
-      // Never upscale: cap the target box to the source size (min with
-      // iw/ih), so a small source (e.g. 720x400) is encoded at its own
-      // resolution instead of being scaled up to the viewport — far fewer
-      // pixels, much faster on ARM. force_original_aspect_ratio keeps aspect.
-      "-vf",
-      `scale='min(${w},iw)':'min(${h},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2${tonemapPart},fps=${outFps}`,
-      "-c:v", "libx264",
-      // Preset is chosen per stream by the session manager from the startup
-      // benchmark (highest quality that still encodes the source resolution
-      // faster than realtime); falls back to the static default.
-      "-preset", chosenPreset,
-      "-crf", SOFTWARE_CRF,
-      // Constrained CRF: bound peak bitrate so a complex scene cannot produce
-      // segments a thin viewer link (cellular) can't download in time. The
-      // figures and the level are the OUTPUT's own, named by its key
-      // (`OutputSpec`), and are not worked out again here.
-      ...rateControlArgs(rateControl),
-      "-threads", String(CPU_THREADS),
-      "-pix_fmt", "yuv420p",
-      // Fixed GOP: a keyframe exactly every (segmentDurationSec × fps) frames,
-      // scene-cut keyframes disabled. This is frame-count based, so it is
-      // independent of the PTS offset used on seek-restart — every HLS segment
-      // is exactly segmentDurationSec long and starts on a keyframe, so segment
-      // boundaries line up with the synthetic playlist with no gaps. (The old
-      // the OLD `expr:` form of -force_key_frames broke after a seek, because
-      // the `t` it reads is shifted by `-output_ts_offset`.)
-      //
-      // An explicit cut LIST is a different thing and does work: verified by
-      // running it, its times are on the run's own timeline — the same one
-      // `-segment_times` is measured on — so both are given one list and
-      // cannot drift apart. It replaces the frame-count GOP, which cannot
-      // describe the source's keyframes because they are not evenly spaced.
-      // `-g` stays as an upper bound on the interval: an extra keyframe
-      // inside a segment costs a little bitrate and cuts nothing, while
-      // leaving the interval unbounded means a driver that ignores the list
-      // produces one enormous segment instead of a wrong but cut one.
-      // `-keyint_min` goes, since a MINIMUM interval is the one thing that
-      // could argue with a forced keyframe.
-      "-g", String(segmentDurationSec * outFps),
-      ...(hasForcedTimes(forcedKeyframeTimes)
-        ? keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
-        : ["-keyint_min", String(segmentDurationSec * outFps)]),
-      "-sc_threshold", "0"
-    ];
-  }
-}
+/**
+ * @file libx264 — the encoder every host has and the only one whose ladder of
+ * speed settings is measured at startup.
+ */
+
+import { Encoder } from "./Encoder.js";
+import {
+  CPU_THREADS,
+  hasForcedTimes,
+  keyFrameArgs,
+  rateControlArgs,
+  safeDimensions,
+  SOFTWARE_CRF,
+  SOFTWARE_PRESET,
+  TONEMAP_FILTER_CHAIN,
+  TRANSCODE_FPS
+} from "./args.js";
+
+/**
+ * The presets the startup benchmark walks, slowest first.
+ *
+ * The same list `benchmarkSoftwarePresets` measures and `pickSoftwarePreset`
+ * chooses from; it is stated here because it is a property of this kind, and
+ * the four hardware kinds beside it show what its absence looks like.
+ */
+const PRESETS = ["fast", "faster", "veryfast", "superfast", "ultrafast"];
+
+export class SoftwareEncoder extends Encoder {
+  constructor() {
+    super({ name: "libx264", kind: "software", device: null, inputArgs: [] });
+  }
+
+  /** @returns {import("./Encoder.js").SpeedLadder} */
+  get speedLadder() {
+    return {
+      flag: "-preset",
+      values: PRESETS,
+      measured: true,
+      note:
+        "Measured on every host at startup by `benchmarkSoftwarePresets`, in " +
+        "pixels per second per preset, and chosen from by `pickSoftwarePreset`."
+    };
+  }
+
+  /** Every preset: `buildVideoArgs` passes whichever the offer chose. */
+  get selectableRungs() {
+    return PRESETS;
+  }
+
+  /** @param {string | null} rung @returns {string[]} */
+  benchmarkArgs(rung = null) {
+    return ["-c:v", "libx264", "-preset", rung ?? SOFTWARE_PRESET, "-crf", SOFTWARE_CRF, "-pix_fmt", "yuv420p"];
+  }
+
+  buildVideoArgs({
+    targetWidth,
+    targetHeight,
+    segmentDurationSec,
+    preset,
+    fps,
+    tonemap,
+    forcedKeyframeTimes,
+    rateControl = null
+  }) {
+    const { w, h } = safeDimensions(targetWidth, targetHeight);
+    const chosenPreset = typeof preset === "string" && preset.length > 0 ? preset : SOFTWARE_PRESET;
+    // Output frame rate: inherited from the source (rounded/capped) by the
+    // session manager, TRANSCODE_FPS by default. MUST be an integer and MUST
+    // equal the value used in the GOP below, or keyframes drift off the grid.
+    const outFps = Number.isInteger(fps) && fps > 0 ? fps : TRANSCODE_FPS;
+    // HDR→SDR tone-map, inserted AFTER the downscale so it runs on the smaller
+    // frame (cheaper on ARM); only when the source is HDR and the filters are
+    // present (session manager gates on both).
+    const tonemapPart = tonemap === true ? `,${TONEMAP_FILTER_CHAIN}` : "";
+    return [
+      // Never upscale: cap the target box to the source size (min with
+      // iw/ih), so a small source (e.g. 720x400) is encoded at its own
+      // resolution instead of being scaled up to the viewport — far fewer
+      // pixels, much faster on ARM. force_original_aspect_ratio keeps aspect.
+      "-vf",
+      `scale='min(${w},iw)':'min(${h},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2${tonemapPart},fps=${outFps}`,
+      "-c:v", "libx264",
+      // Preset is chosen per stream by the session manager from the startup
+      // benchmark (highest quality that still encodes the source resolution
+      // faster than realtime); falls back to the static default.
+      "-preset", chosenPreset,
+      "-crf", SOFTWARE_CRF,
+      // Constrained CRF: bound peak bitrate so a complex scene cannot produce
+      // segments a thin viewer link (cellular) can't download in time. The
+      // figures and the level are the OUTPUT's own, named by its key
+      // (`OutputSpec`), and are not worked out again here.
+      ...rateControlArgs(rateControl),
+      "-threads", String(CPU_THREADS),
+      "-pix_fmt", "yuv420p",
+      // Fixed GOP: a keyframe exactly every (segmentDurationSec × fps) frames,
+      // scene-cut keyframes disabled. This is frame-count based, so it is
+      // independent of the PTS offset used on seek-restart — every HLS segment
+      // is exactly segmentDurationSec long and starts on a keyframe, so segment
+      // boundaries line up with the synthetic playlist with no gaps. (The old
+      // the OLD `expr:` form of -force_key_frames broke after a seek, because
+      // the `t` it reads is shifted by `-output_ts_offset`.)
+      //
+      // An explicit cut LIST is a different thing and does work: verified by
+      // running it, its times are on the run's own timeline — the same one
+      // `-segment_times` is measured on — so both are given one list and
+      // cannot drift apart. It replaces the frame-count GOP, which cannot
+      // describe the source's keyframes because they are not evenly spaced.
+      // `-g` stays as an upper bound on the interval: an extra keyframe
+      // inside a segment costs a little bitrate and cuts nothing, while
+      // leaving the interval unbounded means a driver that ignores the list
+      // produces one enormous segment instead of a wrong but cut one.
+      // `-keyint_min` goes, since a MINIMUM interval is the one thing that
+      // could argue with a forced keyframe.
+      "-g", String(segmentDurationSec * outFps),
+      ...(hasForcedTimes(forcedKeyframeTimes)
+        ? keyFrameArgs(segmentDurationSec, forcedKeyframeTimes)
+        : ["-keyint_min", String(segmentDurationSec * outFps)]),
+      "-sc_threshold", "0"
+    ];
+  }
+}