@torrent-tv/proxy 2.98.16 → 2.98.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.98.16",
+  "version": "2.98.17",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/encode/EncodeRuns.js

@@ -1319,8 +1319,13 @@ export class EncodeRuns {
   /**
    * How long this run took to open its original input, for sizing the next
    * stretch: from its spawn to the name of its first closed piece, less what
-   * encoding that piece costs at the run's speed — its own where it measured
-   * one, else the output's. Nothing is noted where either is unknown.
+   * encoding that piece costs at a measured speed — the run's own where it
+   * closed two pieces, else the output's newest reading, which is taken
+   * between two closed pieces of a run too. Never a predicted speed: the
+   * output's starting figure, scaled by a machine share that missed short
+   * runs, read 0.08x on Home Assistant and recorded opens of 0.00 s (r41,
+   * torrent-tv/meta#178). Nothing is noted where no speed was measured or the
+   * rest is negative, and the open estimated before stands.
    *
    * @param {object} session
    * @param {import("./EncodeRun.js").EncodeRun} run
@@ -1330,14 +1335,21 @@ export class EncodeRuns {
   #noteOpen(session, run, ended) {
     const grid = session.timeline?.published ?? session.timeline?.boundaries;
     const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
-    const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
+    const speed = run.speedX > 0 ? run.speedX : this.#speedReadings.windowOf(session).at(-1)?.speed ?? 0;
     // FFmpeg's reads may have waited for the stretch being copied; that wait
     // is the copy's, and the stretch is sized from the open (`run-open.js`).
     const open = runOpenOf({
       firstNamedMs: ended.firstNamedMs, firstNamedWallMs: ended.firstNamedWallMs, startedAt: run.startedAt,
       waitedBefore: run.originalInput?.waitedBefore, pieceSeconds, speed
     });
-    if (!open) return;
+    if (!open) {
+      if (Number.isFinite(ended.firstNamedMs) && pieceSeconds > 0) {
+        this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: open not measured ` +
+          `(first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film, ` +
+          `${speed > 0 ? `at a measured ${speed.toFixed(2)}x the piece takes longer than that` : "no speed measured between two closed pieces"})`);
+      }
+      return;
+    }
     const { openSeconds, waitedMs } = open;
     this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +

package/services/encode/run-open.js

@@ -8,6 +8,14 @@
  * wall clock, so they are taken up to the wall-clock moment the first piece
  * was named — the run's start plus its time to that name, not that time alone,
  * which as a moment lay before every wait and counted none of them.
+ *
+ * THE SPEED IS A MEASURED ONE, between two closed pieces, and a negative rest
+ * is no open at all: on Home Assistant runs of one piece took 6.0-7.5 s to it
+ * for 4 s of film, were priced at a speed of 0.08x that no run had measured,
+ * and recorded opens of 0.00 s; the next inputs were sized from them to one
+ * piece, and the runs stayed one piece each (r41, torrent-tv/meta#178). A rest
+ * below zero says the speed does not describe that piece, and nothing is
+ * recorded: the open estimated before stands.
  */
 
 /**
@@ -18,12 +26,14 @@
  * @param {((until: number) => number) | null | undefined} params.waitedBefore - The input's wall-clock waits for its copy before `until`, ms.
  * @param {number} params.pieceSeconds - The first piece's film.
  * @param {number} params.speed - Film seconds per second; 0 when not known.
- * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is unknown.
+ * @returns {{ openSeconds: number, waitedMs: number } | null} Null where any term is
+ *   unknown, or where the piece's encoding at that speed exceeds the time to it.
  */
 export function runOpenOf({ firstNamedMs, firstNamedWallMs, startedAt, waitedBefore, pieceSeconds, speed }) {
   if (!Number.isFinite(firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return null;
   const waitedMs = Number.isFinite(firstNamedWallMs) && startedAt > 0 && typeof waitedBefore === "function"
     ? waitedBefore(startedAt + firstNamedWallMs)
     : 0;
-  return { waitedMs, openSeconds: Math.max(0, (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed) };
+  const openSeconds = (firstNamedMs - waitedMs) / 1000 - pieceSeconds / speed;
+  return openSeconds >= 0 ? { waitedMs, openSeconds } : null;
 }