@torrent-tv/proxy 2.107.20 → 2.107.21

package/package.json

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

package/services/encode/EncodeRun.js

@@ -589,6 +589,12 @@ export class EncodeRun {
         producedSeconds: Math.max(0, this.progress.processedSeconds - this.progress.startPositionSeconds),
         workingMs: this.clock.workingMs(at)
       };
+      // A run can be admitted for exactly one segment. Establish its baseline
+      // on the first media progress report so closing that segment yields a
+      // processing rate without counting the preceding input wait.
+      if (this.#pieceSample === null && this.#workSample.producedSeconds > 0) {
+        this.#pieceSample = this.#workSample;
+      }
     }
     this.onProgress(this.progress.snapshot());
   }
@@ -739,11 +745,10 @@ export class EncodeRun {
 
   /**
    * A closed piece is the moment this run's speed is read: what it made since
-   * the last reading, over its own working time. Measured from the first
-   * closed piece rather than from the spawn, so the process start and the wait
-   * for its first input bytes, which are charged once as startup, are not
-   * counted as processing. A stretch with no progress keeps the earlier sample,
-   * and the next reading spans both.
+   * the last reading, over its own working time. The first baseline is the
+   * first positive progress report, so a one-piece run can be measured without
+   * charging the wait for its first input bytes as processing. A stretch with
+   * no progress keeps the earlier sample, and the next reading spans both.
    */
   #measureSpeed() {
     const sample = this.#workSample;
@@ -751,7 +756,7 @@ export class EncodeRun {
       return;
     }
     if (this.#pieceSample === null) {
-      this.#pieceSample = sample;
+      if (sample.producedSeconds > 0) this.#pieceSample = sample;
       return;
     }
     const speed = speedFromWork(this.#pieceSample, sample);

package/services/server/ViewerRequests.js

@@ -936,7 +936,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, trackProgress, measurement);
+      const trackRates = this.#trackRateReadings(output, now);
       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
@@ -1311,8 +1311,7 @@ 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(),
-        trackProgress: new WeakMap() };
+      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), sources: new Map() };
       byViewer.set(id, state);
     }
     return state;
@@ -1325,7 +1324,7 @@ 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, progress, measurement) {
+  #trackRateReadings(output, now) {
     const readings = (this.#host.encodeSpeedReadingsOf?.(output) ?? []).filter(reading => reading.at <= now);
     const summary = readings.length > 0 ? this.#host.playbackReadiness.rateSummaryOf(readings) : null;
     if (summary) return summary;
@@ -1340,21 +1339,9 @@ export class ViewerRequests {
       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,
-          this.#host.segmentDurationSec
-        );
-        measurement.trackProgress.set(output, trend);
-      }
-      return trend.note(now, progress?.processedSeconds, progress?.startPositionSeconds);
-    }
+    // Progress over wall time includes source waits, which the forecast prices
+    // separately. Keep the rate unknown until a measured or calibrated
+    // processing rate exists; single-piece runs now publish their own rate.
     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, ProgressRate, RateTrend } from "../viewer/playback-readiness.js";
+import { 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,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, ProgressRate },
+    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend },
     // 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

@@ -110,44 +110,6 @@ 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;
-  #adjacentRunSeconds;
-  #previous = null;
-
-  constructor(horizonSeconds, adjacentRunSeconds = 4) {
-    this.#horizonSeconds = horizonSeconds;
-    this.#adjacentRunSeconds = Number.isFinite(adjacentRunSeconds) && adjacentRunSeconds > 0
-      ? adjacentRunSeconds
-      : 4;
-    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;
-    const discontinuousStart = this.#previous && start !== this.#previous.start &&
-      (start < this.#previous.start || start > this.#previous.processedSeconds + this.#adjacentRunSeconds);
-    if (!this.#previous || discontinuousStart || 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