@torrent-tv/proxy 2.107.25 → 2.107.27

package/package.json

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

package/services/encode/EncodeAdmission.js

@@ -194,9 +194,10 @@ export class EncodeAdmission {
   }
 
   /**
-   * Whether a not-yet-opened format can take a place on the whole machine.
-   * The output choice calls this for each candidate rung; the final claim uses
-   * `admitsWatching` with the same arithmetic after registering the output.
+   * Whether an output candidate can take a place on the whole machine. A
+   * partial output already in the catalogue uses its measured cost; a
+   * not-yet-opened output uses the same candidate estimate as before. The final
+   * claim uses `admitsWatching` after registering the output.
    *
    * @param {object} spec
    * @param {object} file
@@ -207,13 +208,22 @@ export class EncodeAdmission {
     if (!address) {
       return { admitted: false, reason: "the output has no address", speedX: null };
     }
+    if (this.#host.finished?.(address) === true) {
+      return { admitted: true, reason: "everything it serves is already made", speedX: null };
+    }
     if ((this.#host.liveRunsByAddress().get(address) ?? 0) > 0) {
       return { admitted: true, reason: "an encoder already runs there", speedX: null };
     }
     if (this.#heldWithoutRun().has(address)) {
       return { admitted: true, reason: "it already holds a place for another viewer", speedX: null };
     }
-    const load = this.#host.loadForCandidate?.(spec, file) ?? null;
+    // A partial output already in the catalogue has its measured rate. Use it
+    // before the candidate estimate; completed outputs took the return above.
+    const existing = this.#host.loadOf(address);
+    const hasMeasuredExistingCost = Number.isFinite(existing?.costSec) && existing.costSec > 0;
+    const load = hasMeasuredExistingCost
+      ? existing
+      : this.#host.loadForCandidate?.(spec, file) ?? existing;
     return this.#assessCandidate(address, load);
   }
 

package/services/encode/quality/output-format.js

@@ -228,6 +228,20 @@ export function decideOutputFormat({
       rateControl: limit === null ? null : softwareRateControlFor({ width: w, height: h, fps, source, capKbps: limit })
     }));
   };
+  let machineRefusal = null;
+  const machineAdmissionFor = (spec) => typeof machineAdmission === "function" ? machineAdmission(spec) : null;
+  const machineCanContinue = (spec) => machineAdmissionFor(spec)?.admitted !== false;
+  const admittedByMachine = (spec) => {
+    if (!machineCan(spec.video?.encode?.width ?? 0, spec.video?.encode?.height ?? 0)) {
+      return false;
+    }
+    const answer = machineAdmissionFor(spec);
+    if (answer?.admitted === false) {
+      machineRefusal ??= answer;
+      return false;
+    }
+    return true;
+  };
   const wantedFormats = formatsAt(width, height);
   const wantedSpec = wantedFormats[0];
   const wantedKey = wantedSpec.toKey();
@@ -247,6 +261,7 @@ export function decideOutputFormat({
       wanted: { width, height },
       nextLowerArea: nextRungAreaBelow(buildResolutionLadder(ceiling.w, ceiling.h), height),
       atRisk: measured && !canSustainOutput({ benchmark, ...priced, outputPixelsPerSec: width * height * fps, frame: { width, height } }).sustainable,
+      canProduce: (candidate) => machineCanContinue(candidate.spec),
       judge: (candidate) => judge(candidate.spec),
       candidates: servingCandidates({
         wanted: wantedSpec,
@@ -262,18 +277,6 @@ export function decideOutputFormat({
   }
 
   let anySizeHeld = false;
-  let machineRefusal = null;
-  const admittedByMachine = (spec) => {
-    if (!machineCan(spec.video?.encode?.width ?? 0, spec.video?.encode?.height ?? 0)) {
-      return false;
-    }
-    const answer = typeof machineAdmission === "function" ? machineAdmission(spec) : null;
-    if (answer?.admitted === false) {
-      machineRefusal ??= answer;
-      return false;
-    }
-    return true;
-  };
   if (machineCan(width, height)) {
     for (const spec of wantedFormats) {
       if (!admittedByMachine(spec)) {

package/services/encode/quality/serving-output.js

@@ -48,15 +48,17 @@ import { admissionRank } from "./link-budget.js";
  *   on this viewer's own ladder; zero when there is none.
  * @param {boolean} params.atRisk - Producing `wanted` here is measured not to
  *   keep up with what the file needs. False where nothing measured it.
+ * @param {(candidate: Candidate) => boolean} [params.canProduce] - Whether
+ *   this machine can keep producing an output that is not finished.
  * @param {(candidate: Candidate) => { admitted: boolean, load: object }} params.judge -
  *   What this viewer's link does with the candidate's whole load.
  * @param {Candidate[]} params.candidates
  * @returns {{ key: string, answer: object } | null} The output to serve, or
  *   null to produce `wanted`.
  */
-export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, judge, candidates }) {
+export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, canProduce = () => true, judge, candidates }) {
   const admitted = (candidates ?? [])
-    .filter((candidate) => candidate.readyHere === true)
+    .filter((candidate) => candidate.readyHere === true && canProduce(candidate))
     .map((candidate) => ({ candidate, answer: judge(candidate) }))
     .filter((one) => one.answer.admitted);
   const areaOf = (one) => one.candidate.width * one.candidate.height;

package/services/server/ViewerRequests.js

@@ -1282,11 +1282,12 @@ export class ViewerRequests {
       const ranges = inventory.has(index) ? this.#host.encodeRuns.finishedMediaRangesOf(output, index) : undefined;
       const mediaRanges = ranges && output.segmentFormat?.servedMediaRanges ?
         output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined;
-      // At a playlist boundary the player can request the fragment ending
-      // exactly at its seek target. It is work needed to reach the target,
-      // even though it adds no media after the viewer's position.
+      // The player can request a fragment whose media timestamps extend a few
+      // frames past its nominal playlist end while seeking to the next piece.
       if (index !== 0 && mediaRanges === undefined && !inventory.has(index) &&
-        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) && endSeconds < positionSeconds) {
+        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) &&
+        !this.#host.playbackReadiness.endsWithinPlayerSeekTolerance(endSeconds, positionSeconds) &&
+        endSeconds < positionSeconds) {
         continue;
       }
       const startSeconds = timeline.publishedStartOf(index);

package/services/server/wire-outputs.js

@@ -72,7 +72,7 @@ import { ViewerRequests } from "./ViewerRequests.js";
 import { OutputLifecycle } from "./OutputLifecycle.js";
 import { SegmentServing } from "./SegmentServing.js";
 import { audioStartSecondsFor } from "../viewer/audio-start.js";
-import { forecastRate, rateSummaryOf, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
+import { endsWithinPlayerSeekTolerance, forecastRate, rateSummaryOf, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
 import { audioRenditionName } from "../media/audio-inventory.js";
 import { Renditions } from "../encode/Renditions.js";
 import { CushionReport, LOOKAHEAD_PAUSE_SECONDS } from "../encode/CushionReport.js";
@@ -640,7 +640,8 @@ export function wireOutputs({
     get encodeRuns() { return parts.encodeRuns; },
     // When this viewer's playback can start and run to the end: the viewer
     // component's forecast, which models the viewer's browser.
-    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend },
+    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend,
+      endsWithinPlayerSeekTolerance },
     // Whether the subtitle a viewer chose has been read where they stand — the
     // source preparation's answer, set on these parts by the assembly.
     subtitleReadyFor: (viewer) => parts.subtitleReadyFor?.(viewer) ?? true,

package/services/viewer/playback-readiness.js

@@ -38,9 +38,20 @@ import {
   ZERO
 } from "./media-time.js";
 
-// Match the media element's allowance for a range that starts a few frames
-// after its current position (see server/public/domain/buffer-metrics.js).
-const CLIENT_RANGE_START_TOLERANCE_SECONDS = 0.25;
+// Match the media element's allowance around a seek target. A fragment's
+// timestamps can extend slightly beyond its nominal playlist boundary.
+export const PLAYER_SEEK_TOLERANCE_SECONDS = 0.25;
+
+/**
+ * @param {number} segmentEndSeconds
+ * @param {number} positionSeconds
+ * @returns {boolean}
+ */
+export function endsWithinPlayerSeekTolerance(segmentEndSeconds, positionSeconds) {
+  return Number.isFinite(segmentEndSeconds) && Number.isFinite(positionSeconds) &&
+    segmentEndSeconds <= positionSeconds &&
+    positionSeconds - segmentEndSeconds <= PLAYER_SEEK_TOLERANCE_SECONDS;
+}
 
 /**
  * The mean rate predicted over a horizon by the integral of the measured rate.
@@ -223,7 +234,8 @@ export function predictPlaybackReadiness(input = {}) {
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
-      .filter((segment) => isPiece(segment) && segment.endSeconds >= position && segment.startSeconds < horizonEnd)
+      .filter((segment) => isPiece(segment) &&
+        segment.endSeconds >= position - PLAYER_SEEK_TOLERANCE_SECONDS && segment.startSeconds < horizonEnd)
       .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
     // The pieces after the near window, as the playlist cuts them, and the
     // offset the page's player placed them by.
@@ -290,11 +302,11 @@ export function predictPlaybackReadiness(input = {}) {
     for (const segment of segments) {
       // Media the page already holds is not transferred again: every range of
       // the piece still ahead of the viewer lies inside what the page holds.
-      const exactBoundaryPrerequisite = segment.endSeconds === position;
+      const boundaryPrerequisite = endsWithinPlayerSeekTolerance(segment.endSeconds, position);
       let held = segment.ranges.length > 0;
       for (const range of segment.ranges) {
-        const requiredStart = exactBoundaryPrerequisite ? range.start : latest(range.start, at);
-        if ((exactBoundaryPrerequisite || compare(range.end, at) > 0) &&
+        const requiredStart = boundaryPrerequisite ? range.start : latest(range.start, at);
+        if ((boundaryPrerequisite || compare(range.end, at) > 0) &&
           !contains(state.clientRanges, requiredStart, range.end)) {
           held = false;
           break;
@@ -843,7 +855,7 @@ function heldRanges(ranges, segments, unit, position) {
   const pieces = segments.flatMap((segment) => segment.ranges ?? []);
   const zero = mediaTime(0n, unit);
   const error = rescale(REPORTED_TIME_ERROR, unit);
-  const startTolerance = add(position, rescale(fromSeconds(CLIENT_RANGE_START_TOLERANCE_SECONDS), unit));
+  const startTolerance = add(position, rescale(fromSeconds(PLAYER_SEEK_TOLERANCE_SECONDS), unit));
   const held = [];
   for (const range of ranges) {
     const reportedStart = rescale(range.start, unit);
@@ -870,7 +882,7 @@ function heldRanges(ranges, segments, unit, position) {
 function withSeekStartTolerance(ranges, position, unit) {
   const first = ranges.reduce((earliestRange, range) =>
     !earliestRange || compare(range.start, earliestRange.start) < 0 ? range : earliestRange, null);
-  const toleranceEnd = add(position, rescale(fromSeconds(CLIENT_RANGE_START_TOLERANCE_SECONDS), unit));
+  const toleranceEnd = add(position, rescale(fromSeconds(PLAYER_SEEK_TOLERANCE_SECONDS), unit));
   if (!first || compare(first.start, position) <= 0 || compare(first.start, toleranceEnd) > 0) {
     return ranges;
   }
@@ -879,10 +891,11 @@ function withSeekStartTolerance(ranges, position, unit) {
 
 /**
  * The pieces of a track this forecast places in exact time: those still to
- * play (ending at or after `position`) that start before `horizonEnd`, the first
- * piece, every piece that has been read and every piece that is made. The piece
- * ending exactly at a seek position is kept as a prerequisite: the playlist
- * player can request it before the piece starting at that position. A piece
+ * play (ending within the player's seek tolerance of `position`) that start
+ * before `horizonEnd`, the first piece, every piece that has been read and
+ * every piece that is made. A piece ending just before a seek target is kept
+ * as a prerequisite because its media timestamps can extend past its nominal
+ * playlist boundary. A piece
  * that is none of these changes no exact answer: after the near window it is
  * scheduled in seconds, it is not where the track starts, no unread piece is
  * placed by it (only read pieces are), it lends no frame to what the page
@@ -896,7 +909,8 @@ function withSeekStartTolerance(ranges, position, unit) {
 function piecesThatMatter(track, position, horizonEnd = Number.POSITIVE_INFINITY) {
   const made = new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []);
   const kept = track.segments.filter((segment) => segment?.index === 0 || segment?.mediaRanges !== undefined ||
-    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) && segment.endSeconds < position) &&
+    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) &&
+      segment.endSeconds < position - PLAYER_SEEK_TOLERANCE_SECONDS) &&
       !(Number.isFinite(segment?.startSeconds) && segment.startSeconds >= horizonEnd)));
   return kept.length === track.segments.length ? track.segments : kept;
 }