@torrent-tv/proxy 2.107.7 → 2.107.8

package/package.json

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

package/services/server/ViewerRequests.js

@@ -905,7 +905,7 @@ export class ViewerRequests {
     const tracks = [];
     for (const output of outputs) {
       const trackProgress = output === session ? progress : this.#host.encodeRuns.progressOf(output);
-      const trackRates = this.#trackRateReadings(output, now);
+      const trackRates = this.#trackRateReadings(output, now, trackProgress, measurement);
       const trackName = output === session ? "video" : "audio";
       // 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
@@ -1244,7 +1244,8 @@ export class ViewerRequests {
     const id = typeof consumerId === "string" ? consumerId : "";
     let state = byViewer.get(id);
     if (!state) {
-      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), sources: new Map() };
+      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), sources: new Map(),
+        trackProgress: new WeakMap() };
       byViewer.set(id, state);
     }
     return state;
@@ -1257,23 +1258,34 @@ export class ViewerRequests {
    * runs of one output can report out of order, so a summary kept and added to
    * would drop the later-told, earlier-taken one (torrent-tv/meta#178).
    */
-  #trackRateReadings(output, now) {
+  #trackRateReadings(output, now, progress, measurement) {
     const readings = (this.#host.encodeSpeedReadingsOf?.(output) ?? []).filter(reading => reading.at <= now);
     const summary = readings.length > 0 ? this.#host.playbackReadiness.rateSummaryOf(readings) : null;
-    if (!summary) {
-      // ONLY UNTIL A PIECE IS MEASURED does the prediction stand for the
-      // encoder, and it is not kept among the readings. Added on every poll
-      // between runs, it put the machine's share of that moment — 1 % at a
-      // cold start — on the whole film, and the forecast read 0.03x
-      // (torrent-tv/meta#178).
-      const projected = Number(this.#host.predictedEncodeSpeedOf?.(output) ?? this.#host.projectedEncodeSpeedOf?.(output));
-      if (Number.isFinite(projected) && projected > 0) {
-        const seed = new this.#host.playbackReadiness.RateTrend();
-        seed.add(now, projected);
-        return seed.snapshot();
+    if (summary) return summary;
+    // ONLY UNTIL A PIECE IS MEASURED does the prediction stand for the
+    // encoder, and it is not kept among the readings. Added on every poll
+    // between runs, it put the machine's share of that moment — 1 % at a
+    // cold start — on the whole film, and the forecast read 0.03x
+    // (torrent-tv/meta#178).
+    const projected = Number(this.#host.predictedEncodeSpeedOf?.(output) ?? this.#host.projectedEncodeSpeedOf?.(output));
+    if (Number.isFinite(projected) && projected > 0) {
+      const seed = new this.#host.playbackReadiness.RateTrend();
+      seed.add(now, projected);
+      return seed.snapshot();
+    }
+    // A separate soundtrack may have no calibrated codec reading and no
+    // completed segment yet. Its progress is still a measured rate: retain the
+    // time since the previous advance so source waits reduce, rather than
+    // inflate, the speed used by the forecast.
+    if (output?.spec?.carries === "audio-only") {
+      let trend = measurement.trackProgress.get(output);
+      if (!trend) {
+        trend = new this.#host.playbackReadiness.ProgressRate(this.#host.lookaheadSeconds);
+        measurement.trackProgress.set(output, trend);
       }
+      return trend.note(now, progress?.processedSeconds, progress?.startPositionSeconds);
     }
-    return summary;
+    return null;
   }
 
   /**

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 { forecastRate, rateSummaryOf, predictPlaybackReadiness, ProgressRate, 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,7 @@ 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, ProgressRate },
     // 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

@@ -108,6 +108,38 @@ export class RateTrend {
   }
 }
 
+/**
+ * Rates the media an output actually produced between progress reports.
+ * Unchanged progress keeps its original time, so a source wait is included
+ * instead of being mistaken for encoder throughput.
+ */
+export class ProgressRate {
+  #trend;
+  #horizonSeconds;
+  #previous = null;
+
+  constructor(horizonSeconds) {
+    this.#horizonSeconds = horizonSeconds;
+    this.#trend = new RateTrend(horizonSeconds);
+  }
+
+  note(at, processedSeconds, startPositionSeconds) {
+    if (!Number.isFinite(at) || !Number.isFinite(processedSeconds)) return this.#trend.snapshot();
+    const start = Number.isFinite(startPositionSeconds) ? startPositionSeconds : 0;
+    if (!this.#previous || this.#previous.start !== start || processedSeconds < this.#previous.processedSeconds) {
+      this.#previous = { at, processedSeconds, start };
+      this.#trend = new RateTrend(this.#horizonSeconds);
+      return this.#trend.snapshot();
+    }
+    const elapsedMs = at - this.#previous.at;
+    if (processedSeconds > this.#previous.processedSeconds && elapsedMs > 0) {
+      this.#trend.add(at, (processedSeconds - this.#previous.processedSeconds) * 1000 / elapsedMs);
+      this.#previous = { at, processedSeconds, start };
+    }
+    return this.#trend.snapshot();
+  }
+}
+
 /**
  * @param {object} input
  * @param {number} input.positionSeconds