@torrent-tv/proxy 2.89.7 → 2.89.8

package/services/encode/audio-calibration.js

@@ -1,67 +1,67 @@
-/** Short startup measurements of packaged audio samples. */
-import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-import { AUDIO_TRANSCODE_KBPS } from "./args.js";
-import { ENCODE_BENCHMARK_TIMEOUT_MS } from "./hwaccel.js";
-
-const SAMPLE_DIRECTORY = fileURLToPath(new URL("../../assets/calibration/audio/", import.meta.url));
-
-function measure(ffmpegBin, file, operation, signal) {
-  return new Promise((resolve) => {
-    const startedAt = performance.now();
-    let mediaSeconds = 0;
-    let text = "";
-    let diagnostics = "";
-    const child = spawn(ffmpegBin, ["-hide_banner", "-loglevel", "info", "-nostats", "-benchmark",
-      "-i", file, "-map", "0:a:0", "-vn", "-c:a", operation,
-      ...(operation === "aac" ? ["-b:a", `${AUDIO_TRANSCODE_KBPS}k`, "-ac", "2"] : []),
-      "-f", "null", "-", "-progress", "pipe:1"],
-    { stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
-      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS)]) :
-        AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS) });
-    child.stdout.on("data", (data) => {
-      text += String(data);
-      const rows = text.split("\n");
-      text = rows.pop();
-      for (const row of rows) {
-        if (row.startsWith("out_time_us=")) {
-          const value = Number(row.slice("out_time_us=".length)) / 1e6;
-          if (Number.isFinite(value) && value > 0) mediaSeconds = value;
-        }
-      }
-    });
-    child.stderr.on("data", (data) => { diagnostics += String(data); });
-    child.on("error", () => resolve(null));
-    child.on("close", (code) => {
-      const elapsed = (performance.now() - startedAt) / 1000;
-      const runtime = diagnostics.match(/bench:.*rtime=(\d+\.(\d+))s/);
-      // The reported decimal precision bounds timing uncertainty, including a
-      // runtime printed as zero. This is a clock-resolution bound, not a weight.
-      const processingSeconds = runtime ? Number(runtime[1]) + 10 ** -runtime[2].length : null;
-      resolve(code === 0 && mediaSeconds > 0 && processingSeconds > 0 ?
-        { speed: mediaSeconds / processingSeconds, work: mediaSeconds, elapsed, processingSeconds,
-          startupSeconds: Math.max(0, elapsed - processingSeconds) } : null);
-    });
-  });
-}
-
-export async function benchmarkAudio({ ffmpegBin, logger, signal, sampleDirectory = SAMPLE_DIRECTORY }) {
-  const samples = JSON.parse(await readFile(path.join(sampleDirectory, "manifest.json"), "utf8"));
-  const readings = [];
-  const startedAt = performance.now();
-  for (const sample of samples) {
-    for (const operation of ["copy", "aac"]) {
-      if (signal?.aborted) return readings;
-      const reading = await measure(ffmpegBin, path.join(sampleDirectory, sample.file), operation, signal);
-      if (reading) readings.push({ ...sample, operation, ...reading });
-      else logger?.warn(`audio calibration ${sample.codec}->${operation} could not be measured`);
-    }
-  }
-  logger?.info(`audio calibration: ${readings.length} short packaged-sample measurements in ` +
-    `${((performance.now() - startedAt) / 1000).toFixed(2)}s`);
-  return readings;
-}
-
-export { audioReadingFor } from "./audio-work-rate.js";
+/** Short startup measurements of packaged audio samples. */
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { AUDIO_TRANSCODE_KBPS } from "./args.js";
+import { ENCODE_BENCHMARK_TIMEOUT_MS } from "./hwaccel.js";
+
+const SAMPLE_DIRECTORY = fileURLToPath(new URL("../../assets/calibration/audio/", import.meta.url));
+
+function measure(ffmpegBin, file, operation, signal) {
+  return new Promise((resolve) => {
+    const startedAt = performance.now();
+    let mediaSeconds = 0;
+    let text = "";
+    let diagnostics = "";
+    const child = spawn(ffmpegBin, ["-hide_banner", "-loglevel", "info", "-nostats", "-benchmark",
+      "-i", file, "-map", "0:a:0", "-vn", "-c:a", operation,
+      ...(operation === "aac" ? ["-b:a", `${AUDIO_TRANSCODE_KBPS}k`, "-ac", "2"] : []),
+      "-f", "null", "-", "-progress", "pipe:1"],
+    { stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS)]) :
+        AbortSignal.timeout(ENCODE_BENCHMARK_TIMEOUT_MS) });
+    child.stdout.on("data", (data) => {
+      text += String(data);
+      const rows = text.split("\n");
+      text = rows.pop();
+      for (const row of rows) {
+        if (row.startsWith("out_time_us=")) {
+          const value = Number(row.slice("out_time_us=".length)) / 1e6;
+          if (Number.isFinite(value) && value > 0) mediaSeconds = value;
+        }
+      }
+    });
+    child.stderr.on("data", (data) => { diagnostics += String(data); });
+    child.on("error", () => resolve(null));
+    child.on("close", (code) => {
+      const elapsed = (performance.now() - startedAt) / 1000;
+      const runtime = diagnostics.match(/bench:.*rtime=(\d+\.(\d+))s/);
+      // The reported decimal precision bounds timing uncertainty, including a
+      // runtime printed as zero. This is a clock-resolution bound, not a weight.
+      const processingSeconds = runtime ? Number(runtime[1]) + 10 ** -runtime[2].length : null;
+      resolve(code === 0 && mediaSeconds > 0 && processingSeconds > 0 ?
+        { speed: mediaSeconds / processingSeconds, work: mediaSeconds, elapsed, processingSeconds,
+          startupSeconds: Math.max(0, elapsed - processingSeconds) } : null);
+    });
+  });
+}
+
+export async function benchmarkAudio({ ffmpegBin, logger, signal, sampleDirectory = SAMPLE_DIRECTORY }) {
+  const samples = JSON.parse(await readFile(path.join(sampleDirectory, "manifest.json"), "utf8"));
+  const readings = [];
+  const startedAt = performance.now();
+  for (const sample of samples) {
+    for (const operation of ["copy", "aac"]) {
+      if (signal?.aborted) return readings;
+      const reading = await measure(ffmpegBin, path.join(sampleDirectory, sample.file), operation, signal);
+      if (reading) readings.push({ ...sample, operation, ...reading });
+      else logger?.warn(`audio calibration ${sample.codec}->${operation} could not be measured`);
+    }
+  }
+  logger?.info(`audio calibration: ${readings.length} short packaged-sample measurements in ` +
+    `${((performance.now() - startedAt) / 1000).toFixed(2)}s`);
+  return readings;
+}
+
+export { audioReadingFor } from "./audio-work-rate.js";

package/services/encode/audio-work-rate.js

@@ -1,15 +1,15 @@
-/** Initial per-codec work model, replaced by the track's actual speed. */
-export function audioReadingFor(readings, { codec, transcode, channels, samplingFrequency, bitrateKbps }) {
-  const operation = transcode ? "aac" : "copy";
-  const normalized = String(codec ?? "").replace(/^pcm_.*/, "pcm");
-  const reference = readings?.find((reading) => reading.codec === normalized && reading.operation === operation);
-  if (!reference) return null;
-  const referenceBytesPerSecond = reference.bytes / reference.durationSeconds;
-  // Copy work is encoded bytes; processing work is audio samples. Unstated
-  // dimensions retain the reference measurement, rather than invented values.
-  const workRatio = !transcode && bitrateKbps > 0 ? (bitrateKbps * 1000 / 8) / referenceBytesPerSecond :
-    transcode && channels > 0 && samplingFrequency > 0 ?
-      (channels * samplingFrequency) / (reference.channels * reference.samplingFrequency) : 1;
-  return { ...reference, speed: reference.speed / workRatio,
-    basis: workRatio === 1 ? "measured-reference" : transcode ? "audio-samples" : "encoded-bytes" };
-}
+/** Initial per-codec work model, replaced by the track's actual speed. */
+export function audioReadingFor(readings, { codec, transcode, channels, samplingFrequency, bitrateKbps }) {
+  const operation = transcode ? "aac" : "copy";
+  const normalized = String(codec ?? "").replace(/^pcm_.*/, "pcm");
+  const reference = readings?.find((reading) => reading.codec === normalized && reading.operation === operation);
+  if (!reference) return null;
+  const referenceBytesPerSecond = reference.bytes / reference.durationSeconds;
+  // Copy work is encoded bytes; processing work is audio samples. Unstated
+  // dimensions retain the reference measurement, rather than invented values.
+  const workRatio = !transcode && bitrateKbps > 0 ? (bitrateKbps * 1000 / 8) / referenceBytesPerSecond :
+    transcode && channels > 0 && samplingFrequency > 0 ?
+      (channels * samplingFrequency) / (reference.channels * reference.samplingFrequency) : 1;
+  return { ...reference, speed: reference.speed / workRatio,
+    basis: workRatio === 1 ? "measured-reference" : transcode ? "audio-samples" : "encoded-bytes" };
+}

package/services/encode/available-share.js

@@ -1,89 +1,89 @@
-/**
- * @file How much of the machine a new encoder can actually have.
- *
- * The encoder benchmark measures a QUIET host: one ffmpeg, nothing else. A real
- * encode runs on a machine that is also downloading, hashing and serving, and
- * on the addon host that machine was measured 99 % busy — `ffmpeg=52-60%
- * proxy=17-24% system=99%` — while a step predicted at 1.83x ran at 1.01-1.12x
- * (2026-08-17).
- *
- * What this corrects is ONLY the part nobody has been charged for. That
- * distinction is the whole of the file, because the alternative has already
- * shipped once and broke the product: in 2.21.0 the budget ADDED what else was
- * running while the per-file costs were being LEARNED from runs that already
- * contained that other work, so every cost was counted twice, every re-encoded
- * step was refused, and the quality menu emptied itself down to the one copied
- * height (fixed in 2.21.1).
- *
- * So: our own encoders are priced by the concurrency arithmetic, and the
- * proxy's own work — the torrent, the hashing, the delivery — is priced per
- * megabyte moved. Both are already in the budget. What is NOT in it is
- * everything else the machine does: the kernel, the container runtime, whatever
- * else the owner runs on their box. That is what is subtracted here, and
- * nothing more.
- */
-
-/**
- * The share of the machine available to a new encoder.
- *
- * @param {object} reading - Fractions of the WHOLE machine (all cores), as
- *   `shareOfMachine` reports them.
- * @param {number | null} reading.systemBusy - Everything the machine is doing.
- * @param {number | null} reading.encoderShare - Our own ffmpeg processes.
- * @param {number | null} reading.proxyShare - The proxy process itself.
- * @returns {{ share: number, unattributed: number, known: boolean }}
- *   `known` is false when the host does not report its own load — then the
- *   share is 1 and the caller must say it is uncorrected rather than pretend.
- */
-export function availableShareFrom(reading = {}) {
-  const systemBusy = finite(reading.systemBusy);
-  if (systemBusy === null) {
-    // No reading at all: not every host has /proc. An uncorrected prediction is
-    // the honest answer, and the caller says so.
-    return { share: 1, unattributed: 0, known: false };
-  }
-  const ours = (finite(reading.encoderShare) ?? 0) + (finite(reading.proxyShare) ?? 0);
-  // Rounding, and the two readings being taken microseconds apart, can put our
-  // own share fractionally above the system total. Below zero is not a
-  // measurement of anything.
-  const unattributed = clamp(systemBusy - ours, 0, 1);
-  return { share: clamp(1 - unattributed, 0, 1), unattributed, known: true };
-}
-
-/**
- * Apply the correction to a predicted speed.
- *
- * A speed is work per unit time, so a machine that can give a new encoder only
- * `share` of itself produces `share ×` the speed the benchmark measured alone.
- *
- * @param {number} predictedSpeed - From the quiet-host benchmark.
- * @param {{ share: number, known: boolean }} availability
- * @returns {number}
- */
-export function correctForAvailability(predictedSpeed, availability) {
-  if (!Number.isFinite(predictedSpeed) || predictedSpeed <= 0) {
-    return predictedSpeed;
-  }
-  if (!availability?.known) {
-    return predictedSpeed;
-  }
-  return predictedSpeed * availability.share;
-}
-
-/**
- * @param {unknown} value
- * @returns {number | null}
- */
-function finite(value) {
-  return Number.isFinite(value) ? Number(value) : null;
-}
-
-/**
- * @param {number} value
- * @param {number} low
- * @param {number} high
- * @returns {number}
- */
-function clamp(value, low, high) {
-  return Math.min(high, Math.max(low, value));
-}
+/**
+ * @file How much of the machine a new encoder can actually have.
+ *
+ * The encoder benchmark measures a QUIET host: one ffmpeg, nothing else. A real
+ * encode runs on a machine that is also downloading, hashing and serving, and
+ * on the addon host that machine was measured 99 % busy — `ffmpeg=52-60%
+ * proxy=17-24% system=99%` — while a step predicted at 1.83x ran at 1.01-1.12x
+ * (2026-08-17).
+ *
+ * What this corrects is ONLY the part nobody has been charged for. That
+ * distinction is the whole of the file, because the alternative has already
+ * shipped once and broke the product: in 2.21.0 the budget ADDED what else was
+ * running while the per-file costs were being LEARNED from runs that already
+ * contained that other work, so every cost was counted twice, every re-encoded
+ * step was refused, and the quality menu emptied itself down to the one copied
+ * height (fixed in 2.21.1).
+ *
+ * So: our own encoders are priced by the concurrency arithmetic, and the
+ * proxy's own work — the torrent, the hashing, the delivery — is priced per
+ * megabyte moved. Both are already in the budget. What is NOT in it is
+ * everything else the machine does: the kernel, the container runtime, whatever
+ * else the owner runs on their box. That is what is subtracted here, and
+ * nothing more.
+ */
+
+/**
+ * The share of the machine available to a new encoder.
+ *
+ * @param {object} reading - Fractions of the WHOLE machine (all cores), as
+ *   `shareOfMachine` reports them.
+ * @param {number | null} reading.systemBusy - Everything the machine is doing.
+ * @param {number | null} reading.encoderShare - Our own ffmpeg processes.
+ * @param {number | null} reading.proxyShare - The proxy process itself.
+ * @returns {{ share: number, unattributed: number, known: boolean }}
+ *   `known` is false when the host does not report its own load — then the
+ *   share is 1 and the caller must say it is uncorrected rather than pretend.
+ */
+export function availableShareFrom(reading = {}) {
+  const systemBusy = finite(reading.systemBusy);
+  if (systemBusy === null) {
+    // No reading at all: not every host has /proc. An uncorrected prediction is
+    // the honest answer, and the caller says so.
+    return { share: 1, unattributed: 0, known: false };
+  }
+  const ours = (finite(reading.encoderShare) ?? 0) + (finite(reading.proxyShare) ?? 0);
+  // Rounding, and the two readings being taken microseconds apart, can put our
+  // own share fractionally above the system total. Below zero is not a
+  // measurement of anything.
+  const unattributed = clamp(systemBusy - ours, 0, 1);
+  return { share: clamp(1 - unattributed, 0, 1), unattributed, known: true };
+}
+
+/**
+ * Apply the correction to a predicted speed.
+ *
+ * A speed is work per unit time, so a machine that can give a new encoder only
+ * `share` of itself produces `share ×` the speed the benchmark measured alone.
+ *
+ * @param {number} predictedSpeed - From the quiet-host benchmark.
+ * @param {{ share: number, known: boolean }} availability
+ * @returns {number}
+ */
+export function correctForAvailability(predictedSpeed, availability) {
+  if (!Number.isFinite(predictedSpeed) || predictedSpeed <= 0) {
+    return predictedSpeed;
+  }
+  if (!availability?.known) {
+    return predictedSpeed;
+  }
+  return predictedSpeed * availability.share;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {number | null}
+ */
+function finite(value) {
+  return Number.isFinite(value) ? Number(value) : null;
+}
+
+/**
+ * @param {number} value
+ * @param {number} low
+ * @param {number} high
+ * @returns {number}
+ */
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}