@torrent-tv/proxy 2.97.4 → 2.97.5

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -17,7 +17,7 @@ import { computeOutputDimensions } from "./args.js";
 import { buildAdmittedCommand } from "./admitted-command.js";
 import { buildOriginalCommand } from "./source-command.js";
 import { writeAdmittedInput } from "./AdmittedInput.js";
-import { cutOf, cutShiftOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
+import { cutOf, cutShiftOf, judgeNeighbors, judgePiece, onItsCutClock } from "./piece-completeness.js";
 import { presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
 import { readProcessCpuSeconds } from "./host-load.js";
@@ -302,7 +302,13 @@ export class EncodeRuns {
   runStateOf(output) {
     if (this.#host.encodeInputs?.failureOf(output)) return ENCODE_RUN_STATE.ENDED_FAILED;
     if (output && this.liveRunsOf(output).length === 0 && this.#inputFailures.reason(output.outputKey)) return ENCODE_RUN_STATE.ENDED_FAILED;
-    return output ? this.#host.encodeOrchestrator.stateOf(output.outputKey) : runStateOf([]);
+    const state = output ? this.#host.encodeOrchestrator.stateOf(output.outputKey) : runStateOf([]);
+    // A piece of a longer input failed and is to be made from an input holding
+    // it alone: production has not ended, and a request for it is held rather
+    // than refused (torrent-tv/meta#178).
+    if (state === ENCODE_RUN_STATE.ENDED_FAILED && this.liveRunsOf(output).length === 0 &&
+      this.#inputFailures.retrying(output.outputKey)) return ENCODE_RUN_STATE.IDLE;
+    return state;
   }
 
   lastErrorOf(output) {
@@ -374,6 +380,9 @@ export class EncodeRuns {
       return null;
     }
     const address = session.outputKey ?? "";
+    // `bytes` is the piece the proxy cut again by presentation time at the
+    // published grid; without it the piece is as the muxer cut it.
+    const cutByProxy = bytes !== null;
     try {
       const mediaRanges = format.readMediaRanges(bytes ?? this.#host.segmentFiles.closedBytesOf(address, name));
 
@@ -390,16 +399,27 @@ export class EncodeRuns {
         // piece has closed, and holds for every piece after it. It is a fact
         // of each piece the run makes, so it travels with the piece.
         if (run.cutShiftSeconds === null && index === run.from) {
-          run.cutShiftSeconds = cutShiftOf(mediaRanges, grid?.[run.from], session.spec.carries !== "audio-only" ? "vide" : "soun",
+          // Read from the piece as the muxer closed it: a piece cut again by
+          // the proxy starts where the grid says, whatever the muxer did.
+          const asMuxed = cutByProxy ? format.readMediaRanges(this.#host.segmentFiles.closedBytesOf(address, name)) : mediaRanges;
+          run.cutShiftSeconds = cutShiftOf(asMuxed, grid?.[run.from], session.spec.carries !== "audio-only" ? "vide" : "soun",
             timing?.endMicros ?? null);
+          // Said once per run: a piece judged on the wrong clock is refused by
+          // a millisecond, and nothing else in the log says which clock it was
+          // judged on (torrent-tv/meta#178).
+          this.#host.logger.info(`encode-run #${run.from}..#${run.to} on ${address}: its muxer counts cuts ` +
+            (run.cutShiftSeconds === null ? "from a first packet more than a frame away from its start (shift unknown)"
+              : `${run.cutShiftSeconds.toFixed(6)}s from its start at ${grid?.[run.from]}s`) +
+            (cutByProxy ? "; its pieces are cut again by the proxy at the published grid, so the shift does not apply to them" : ""));
         }
-        if (mediaRanges && run.cutShiftSeconds !== null) mediaRanges.cutShiftSeconds = run.cutShiftSeconds;
+        onItsCutClock(mediaRanges, run.cutShiftSeconds, cutByProxy);
       }
       const { whole, throughSeconds, reason } = judgePiece(format, mediaRanges, cut, interval);
       if (!whole) {
         this.#host.logger.warn(
           `encode: not publishing piece ${index} of ${address.slice(0, 60)}: ` +
             (reason ?? (throughSeconds === null ? "it holds no playable media" : `produced through ${throughSeconds}s, cut ${cut}s`)) +
+            ` cutBy=${cutByProxy ? "proxy" : "muxer"} shift=${Number.isFinite(mediaRanges?.cutShiftSeconds) ? mediaRanges.cutShiftSeconds : "none"}` +
             (interval ? ` expected=${interval.from}..${interval.to} tracks=${JSON.stringify(mediaRanges.tracks.map(track => ({
               kind: track.kind, timescale: track.timescale, frame: track.productionFrame,
               first: track.ranges[0], last: track.ranges.at(-1), count: track.ranges.length })),
@@ -809,8 +829,11 @@ export class EncodeRuns {
     // really reaches is the input's answer. An original input is one copied
     // stretch, and the run is given exactly that stretch (torrent-tv/meta#158).
     const segmentCount = Number(session.timeline?.segmentCount) || 0;
-    const mayReach = Number.isInteger(ordered?.to) && ordered.to >= startIndex ? ordered.to
-      : segmentCount > startIndex ? segmentCount - 1 : startIndex;
+    // A piece whose longer input failed is made from an input holding it alone,
+    // so a run reaches no further than the number before it.
+    const mayReach = this.#inputFailures.boundFor(session.outputKey, startIndex,
+      Number.isInteger(ordered?.to) && ordered.to >= startIndex ? ordered.to
+        : segmentCount > startIndex ? segmentCount - 1 : startIndex);
     const admittedInput = this.#host.encodeInputs?.take(session, startIndex, mayReach) ?? null;
     if (!admittedInput) return null;
     const inputEnd = admittedInput.original ? admittedInput.to : startIndex;
@@ -1099,7 +1122,7 @@ export class EncodeRuns {
       if (inputKey && failedAdmittedInput({ ending: ENCODE_EXIT.FAILED,
         code: error.code ? null : 1, because: error.message },
         session.spec.transcodesVideo && this.#host.videoEncoder.kind !== "software")) {
-        this.#inputFailures.note(session.outputKey, startIndex, inputKey, error.message);
+        this.#inputFailures.note(session.outputKey, startIndex, inputKey, error.message, { pieces: inputEnd - startIndex + 1 });
         this.#host.invalidateWaits(session);
         this.#host.productionFailed(session);
       }
@@ -1234,8 +1257,11 @@ export class EncodeRuns {
       const index = run.head;
       const key = run.admittedInputKeys.get(index);
       if (key) {
-        this.#inputFailures.note(session.outputKey, index, key, ended.because);
-        this.#host.logger.warn(`encode: unchanged input will not be retried output=${session.outputKey} segment=${index} input=${key} reason=${ended.because}`);
+        const pieces = [...run.admittedInputKeys.values()].filter(held => held === key).length;
+        this.#inputFailures.note(session.outputKey, index, key, ended.because, { pieces });
+        this.#host.logger.warn(pieces > 1
+          ? `encode: piece ${index} will be made again from an input holding it alone output=${session.outputKey} input=${key} (held ${pieces} pieces) reason=${ended.because}`
+          : `encode: unchanged input will not be retried output=${session.outputKey} segment=${index} input=${key} reason=${ended.because}`);
       }
     }
     this.#host.encodeOrchestrator.noteEnded(ended);

package/services/encode/InputFailures.js

@@ -12,7 +12,18 @@ export function failedAdmittedInput(ended, hardwareEncode = false) {
   return ended.ending === ENCODE_EXIT.SHORT || ended.ending === ENCODE_EXIT.FAILED;
 }
 
-/** A failed input is retried only after its identity — source, file, ranges and what is stated about them — or the output parameters change. */
+/**
+ * A failed input is retried only after its identity — source, file, ranges and
+ * what is stated about them — or the output parameters change.
+ *
+ * A failure of an input that held more pieces than the one that failed is not
+ * the end of the output: the piece is made again from an input holding it
+ * alone, which is another input (`retryAlone`). Only the failure of that input
+ * — or of any input holding one piece — ends production. Field 2026-10-11,
+ * torrent-tv/meta#178: one refused piece of a six-piece copy ended the viewer's
+ * playback with a 500 while the same piece made alone was published in an
+ * earlier session.
+ */
 export class InputFailures {
   #failures = new Map();
 
@@ -28,11 +39,47 @@ export class InputFailures {
     return null;
   }
 
-  reason(address) { return this.#failures.get(address)?.values().next().value?.reason ?? null; }
+  /** Why production of this output has ended, or null while every failed piece can still be made alone. */
+  reason(address) {
+    for (const entry of this.#failures.get(address)?.values() ?? []) if (!entry.retryAlone) return entry.reason;
+    return null;
+  }
+
+  /** Whether a failed piece of this output waits to be made from an input holding it alone. */
+  retrying(address) {
+    for (const entry of this.#failures.get(address)?.values() ?? []) if (entry.retryAlone) return true;
+    return false;
+  }
+
+  /**
+   * The last number a run starting at `from` may reach so that a piece waiting
+   * to be made alone is not taken again inside a longer input: the number
+   * before it, or `from` itself when the run starts there.
+   *
+   * @param {string} address
+   * @param {number} from
+   * @param {number} to
+   * @returns {number}
+   */
+  boundFor(address, from, to) {
+    let bound = to;
+    for (const [index, entry] of this.#failures.get(address) ?? []) {
+      if (!entry.retryAlone || index < from || index > bound) continue;
+      bound = index === from ? from : index - 1;
+    }
+    return bound;
+  }
 
-  note(address, index, key, reason) {
+  /**
+   * @param {string} address
+   * @param {number} index - The piece that failed.
+   * @param {string} key
+   * @param {string} reason
+   * @param {{ pieces?: number }} [held] - How many pieces the failed input held.
+   */
+  note(address, index, key, reason, { pieces = 1 } = {}) {
     const entries = this.#failures.get(address) ?? new Map();
-    entries.set(index, { key, reason });
+    entries.set(index, { key, reason, retryAlone: pieces > 1 });
     this.#failures.set(address, entries);
   }
 

package/services/encode/piece-completeness.js

@@ -70,6 +70,29 @@ export function judgePiece(format, ranges, cutSeconds, interval) {
   return { whole: true, throughSeconds };
 }
 
+/**
+ * Put a piece on the clock it was cut by, for {@link judgePiece}.
+ *
+ * The run's cut shift ({@link cutShiftOf}) says where the segment MUXER counts
+ * its cuts from, so it belongs only to a piece the muxer cut. A copied picture
+ * read from the original file is cut again by the proxy, by presentation time
+ * at the published grid (`presentationSegment`), and that piece is judged on
+ * the grid as published. Field 2026-10-11, torrent-tv/meta#178: an open-GOP
+ * HEVC piece cut again at 2511.676..2521.686 holds the next keyframe, which its
+ * leading pictures need, and so ends one frame (672 of 16 000 ticks) past the
+ * cut, as it must; moved by the muxer's shift of −0.001 s the allowance ended
+ * one millisecond before that frame, the piece was refused and playback ended.
+ *
+ * @param {object | null | undefined} ranges - The piece's media intervals.
+ * @param {number | null} shift - The run's cut shift, or null when not known.
+ * @param {boolean} cutByProxy - Whether the proxy cut the piece again.
+ * @returns {object | null | undefined} The same intervals.
+ */
+export function onItsCutClock(ranges, shift, cutByProxy) {
+  if (ranges && !cutByProxy && Number.isFinite(shift)) ranges.cutShiftSeconds = shift;
+  return ranges;
+}
+
 /**
  * How far after its requested start a run's segment muxer counts its cuts
  * from, read from the run's FIRST piece, or `null` when that piece does not