@torrent-tv/proxy 2.89.3 → 2.89.5

package/services/encode/quality/link-budget.js

@@ -24,21 +24,6 @@
 
 import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor } from "../args.js";
 
-/**
- * How much of a measured link may be spent on the stream.
- *
- * The rest is what the link does when it is not being perfect: transport
- * framing, retransmission, the other tabs, the moment somebody else in the
- * house starts something. A load sized to the whole reading stalls on the
- * first of those.
- *
- * Chosen, not measured, and written as a constant rather than dressed up as a
- * measurement. What would replace it is a reading of the transport's own
- * overhead and of how far a link's throughput varies over a session, which
- * nothing takes.
- */
-export const LINK_SAFETY = 0.8;
-
 /** How far a figure in a load can be trusted. */
 export const PEAK_CLASS = Object.freeze({
   KNOWN: "known",
@@ -279,7 +264,11 @@ export function linkCouldCarry(linkMbps, load) {
   if (load.peakClass === PEAK_CLASS.UNKNOWN) {
     return answer(LINK_VERDICT.NO_SAFE_BOUND, false, false);
   }
-  if (linkMbps * LINK_SAFETY < load.totalMbps) {
+  // The measured link against the whole load, with no share held back. The
+  // reading is what the link carried while it carried a piece, and the stream
+  // needs that on average; what a link does when it is not perfect — a pause,
+  // another tab — is what the viewer's buffer and `drain-threat.js` measure.
+  if (linkMbps < load.totalMbps) {
     return answer(LINK_VERDICT.DOES_NOT_FIT, false, false);
   }
   return load.peakClass === PEAK_CLASS.KNOWN
@@ -338,7 +327,6 @@ export function linkAnswerFigures(answer) {
   return {
     verdict: answer.verdict,
     linkMbps: answer.linkMbps,
-    linkSafety: LINK_SAFETY,
     videoMbps: answer.load.video?.mbps ?? null,
     videoClass: answer.load.video?.peakClass ?? null,
     audioMbps: answer.load.audio?.mbps ?? null,

package/services/encode/run-inputs.js

@@ -11,6 +11,9 @@
  * sized in seconds of playback by whoever knows the file's byte rate.
  */
 
+/** The query parameter naming which run of an output a read feeds. */
+const RUN_PARAMETER = "run";
+
 /**
  * @param {object} params
  * @param {{ fileIndex: number, streamUrl: (baseUrl: string, options?: { sessionId?: string }) => URL }} params.picture
@@ -20,15 +23,23 @@
  * @param {"video-only" | "audio-only" | "muxed" | "empty"} params.carries
  * @param {boolean} params.audioSeparate - The picture's sound travels as its own output.
  * @param {string} params.sessionId - Which output this read feeds.
+ * @param {number} [params.runToken] - Which run of that output the read feeds,
+ *   so the time its input waits is charged to that run and not to another one
+ *   working on the same output.
  * @param {number} params.readWindowBytes - Zero when no window was measured.
  * @param {string} params.baseUrl
  * @returns {{ inputFile: object, audioFile: object, inputUrl: string, audioInputUrl: string }}
  */
-export function encoderInputs({ picture, soundtrack, carries, audioSeparate, sessionId, readWindowBytes, baseUrl }) {
+export function encoderInputs({ picture, soundtrack, carries, audioSeparate, sessionId, runToken, readWindowBytes, baseUrl }) {
   // A soundtrack shipped as its own file is encoded FROM that file, so a
   // rendition of it reads nothing else.
   const inputFile = carries === "audio-only" && soundtrack !== picture ? soundtrack : picture;
   const input = inputFile.streamUrl(baseUrl, { sessionId });
+  const forRun = (url) => {
+    if (Number.isInteger(runToken)) url.searchParams.set(RUN_PARAMETER, String(runToken));
+    return url;
+  };
+  forRun(input);
   if (Number.isFinite(readWindowBytes) && readWindowBytes > 0) {
     input.searchParams.set("windowBytes", String(readWindowBytes));
     input.searchParams.set("reader", "playback");
@@ -36,7 +47,7 @@ export function encoderInputs({ picture, soundtrack, carries, audioSeparate, ses
   // The second input exists only for a picture that carries its sound inside
   // itself when that sound is in another file.
   const audioInputUrl = carries !== "audio-only" && !audioSeparate && soundtrack !== inputFile
-    ? soundtrack.streamUrl(baseUrl, { sessionId }).toString()
+    ? forRun(soundtrack.streamUrl(baseUrl, { sessionId })).toString()
     : "";
   return { inputFile, audioFile: soundtrack, inputUrl: input.toString(), audioInputUrl };
 }

package/services/server/SegmentServing.js

@@ -607,7 +607,9 @@ export class SegmentServing {
       : this.#host.runStartTimeFor(session, this.#host.encodeRuns.earliestStartOf(session) ?? 0);
     const position = Number(progress?.processedSeconds);
     const produced = Number.isFinite(position) ? position - runStartSeconds : null;
-    const speed = progress?.speed || "n/a";
+    const measured = this.#host.encodeRuns.liveRunsOf(session)
+      .reduce((best, run) => Math.max(best, run.speedX || 0), 0);
+    const speed = measured > 0 ? `${measured.toFixed(2)}x` : "n/a";
     logger.warn(
       `transcode ${session.id} holding ${fileName}: ${reason} ` +
       `(runs from #${this.#host.encodeRuns.earliestStartOf(session) ?? "?"}, viewer at #${this.#host.outputTimes.segmentIndexForTime(session, this.#host.viewerSecondsOn(session))}, ` +

package/services/server/ViewerRequests.js

@@ -8,7 +8,7 @@
  */
 
 import { logger } from "../../utils/logger.js";
-import { isOutputName, SEGMENT_CUT_TIME_DELTA_SECONDS } from "../encode/output/index.js";
+import { isOutputName } from "../encode/output/index.js";
 
 function isWarmupTimeoutError(error) {
   if (!(error instanceof Error)) {
@@ -484,7 +484,6 @@ export class ViewerRequests {
       // segment (the only thing it waits for before playback starts) instead
       // of a percentage of the whole-file transcode.
       segmentDurationSec: this.#host.segmentDurationSec,
-      speed: progress.speed,
       outputMbps,
       playbackReadiness,
       // The height the viewer is WATCHING right now, which is what the menu
@@ -566,11 +565,7 @@ export class ViewerRequests {
       const timeline = output.timeline;
       const trackName = output === session ? "video" : "audio";
       const nativeRanges = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) =>
-        this.#host.segmentStore.mediaRangesOf(output.outputKey, index, {
-          startSeconds: timeline.publishedStartOf(index),
-          endSeconds: index < timeline.segmentCount - 1 ?
-            timeline.publishedStartOf(index + 1) - SEGMENT_CUT_TIME_DELTA_SECONDS : undefined
-        }));
+        this.#host.encodeRuns.finishedMediaRangesOf(output, index));
       // The page states the offset its player applied to this track, and the
       // init it applied it to is the session's. Until both are known, the
       // pieces stay on their own presentation timeline: there is nothing yet

package/services/server/wire-outputs.js

@@ -247,7 +247,10 @@ export function wireOutputs({
     pathFor: (address) => parts.segmentStore.pathFor(address),
     initOf: (address) => parts.segmentStore.initOf(address),
     directoryFor: (address) => parts.segmentStore.directoryFor(address),
-    publish: (address, makingName, format, coverage) => parts.segmentStore.publish(address, makingName, format, coverage)
+    publish: (address, makingName, format, read) => parts.segmentStore.publish(address, makingName, format, read),
+    closedBytesOf: (address, makingName) => parts.segmentStore.closedBytesOf(address, makingName),
+    mediaRangesOf: (address, index, where) => parts.segmentStore.mediaRangesOf(address, index, where),
+    remove: (address, index, because) => parts.segmentStore.remove(address, index, because)
   };
   const segmentOutputFiles = {
     addresses: () => parts.segmentStore.addresses(),
@@ -257,7 +260,8 @@ export function wireOutputs({
     useFormat: (address, format) => parts.segmentStore.useFormat(address, format)
   };
   const segmentPaths = {
-    pathOf: (address, index) => parts.segmentStore.pathOf(address, index)
+    pathOf: (address, index) => parts.segmentStore.pathOf(address, index),
+    sizesOf: (address) => parts.segmentStore.sizesOf(address)
   };
   /**
    * Whether everything this output will ever serve is made: every segment of
@@ -303,6 +307,11 @@ export function wireOutputs({
   // The encoders of this proxy: built where the plan places them, followed while they run, accounted when they end.
   parts.encodeRuns = new EncodeRuns({
     logger,
+    // What this host is doing with an encode is learned each time a run has
+    // measured its processing speed, on every host.
+    noteRunSpeedMeasured: (session, run) => {
+      void parts.encodeCost.learnFrom(session, run);
+    },
     // What an admitted encode was seen to do, filed under its configuration.
     observeEncodeEnded: (session) => {
       if (!parts.localObservations || !session?.spec?.video?.encode) {
@@ -317,7 +326,6 @@ export function wireOutputs({
       });
     },
     viewerSecondsOn: (output, consumerId, now) => viewerSecondsOn(parts.viewers, output, consumerId, now),
-    noteRunStarting: (output) => parts.quality.noteRunStarting(output),
     inputOf: (...args) => parts.renditions.inputOf(...args),
     producedNumbers: (...args) => parts.serving.producedNumbers(...args),
     servesAudioSeparately: (...args) => parts.renditions.servesAudioSeparately(...args),
@@ -809,11 +817,8 @@ export function wireOutputs({
     runningEncoders: () => parts.encodeOrchestrator.runningCount(),
     encodersRunningNow: () => parts.encodeOrchestrator.runningCount(),
     torrentCostSecFor: (session) => parts.hostLoad.torrentCostSecFor(session),
-    boundBy: (session) => parts.quality.classifyTranscodeBound(session),
     runsFor: (session) => parts.encodeRuns.runsOf(session),
-    stateFor: (session) => parts.encodeRuns.runStateOf(session),
-    // The run's OWN progress: a speed is a pair of readings of one process.
-    progressFor: (_session, run) => run?.progress?.snapshot?.() ?? null
+    stateFor: (session) => parts.encodeRuns.runStateOf(session)
   });
   // WHICH HEIGHTS ARE ON THE MENU, which is the arithmetic above plus three
   // things that are nothing to do with it: whose answer it is, what may never