@torrent-tv/proxy 2.107.20 → 2.107.22

package/package.json

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

package/services/encode/EncodeRun.js

@@ -187,9 +187,12 @@ export class EncodeRun {
   /** The film made and the run's own working time, as of the last progress report. */
   #workSample = null;
 
-  /** The work sample taken when this run last measured its speed. */
+  /** Baseline work sample for this run's next speed reading. */
   #pieceSample = null;
 
+  /** A closed, published piece is waiting for a usable progress sample. */
+  #speedMeasurementPending = false;
+
   /** @type {{ speed: number, at: number } | null} */
   #speedReading = null;
 
@@ -302,6 +305,7 @@ export class EncodeRun {
     this.progress = new RunProgress({ startSeconds, totalSeconds, now: this.now });
     /** Where this run's time went: its own work, or waiting, or stopped. */
     this.clock = new RunClock({ now: this.now });
+    this.#pieceSample = { at: this.now(), producedSeconds: 0, workingMs: 0 };
     this.onEnded = typeof onEnded === "function" ? onEnded : () => {};
     this.onProgress = typeof onProgress === "function" ? onProgress : () => {};
     this.onProduced = typeof onProduced === "function" ? onProduced : () => {};
@@ -338,9 +342,9 @@ export class EncodeRun {
   }
 
   /**
-   * This run's processing speed: film made over its own working time between
-   * two closed pieces, with the time its input waited and the time it was
-   * stopped taken out (`RunClock`). Zero until two pieces have closed.
+   * This run's processing speed: film made over its own working time since the
+   * last baseline, with the time its input waited and the time it was stopped
+   * taken out (`RunClock`). Zero until a closed piece has enough progress data.
    *
    * @returns {number}
    */
@@ -349,8 +353,8 @@ export class EncodeRun {
   }
 
   /**
-   * The same speed with the moment it was measured, or null before a second
-   * piece has closed.
+   * The same speed with the moment it was measured, or null before a closed
+   * piece has enough progress data.
    *
    * @returns {{ speed: number, at: number } | null}
    */
@@ -452,6 +456,16 @@ export class EncodeRun {
   /** An input read of this run has its bytes. */
   inputWaitEnds() {
     this.clock.inputWaitEnds();
+    if (this.#speedReading === null && this.#workSample !== null) {
+      // Progress made while an input read was waiting belongs to the wait, not
+      // to the encoder's rate. Start the first measurement from the latest
+      // progress known when the input resumes.
+      this.#pieceSample = {
+        ...this.#workSample,
+        at: this.now(),
+        workingMs: this.clock.workingMs()
+      };
+    }
   }
 
   /** @returns {boolean} Whether an input read of this run is waiting for bytes now. */
@@ -589,6 +603,7 @@ export class EncodeRun {
         producedSeconds: Math.max(0, this.progress.processedSeconds - this.progress.startPositionSeconds),
         workingMs: this.clock.workingMs(at)
       };
+      if (this.#speedMeasurementPending) this.#measureSpeed();
     }
     this.onProgress(this.progress.snapshot());
   }
@@ -682,7 +697,6 @@ export class EncodeRun {
   }
 
   #publishClosed(name, following = null, { quiet = false, tentative = false } = {}) {
-      if (!tentative) this.#measureSpeed();
       // ITS SERVED NAME, which is what whoever owns the disk gives it in answer.
       // ffmpeg writes a piece under a working name and reports that; the piece
       // becomes servable by being renamed, and everything below works in the
@@ -718,7 +732,8 @@ export class EncodeRun {
       }
 
       if (!served) return false;
-      if (tentative) this.#measureSpeed();
+      this.#speedMeasurementPending = true;
+      this.#measureSpeed();
       if (!this.#stopping) {
         this.#provenName = served;
       }
@@ -738,26 +753,22 @@ 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.
+   * A published piece is measured against this run's last baseline over its
+   * own working time. The initial baseline is the run start, advanced to the
+   * latest known progress when input resumes, so a one-piece run can be
+   * measured even when FFmpeg reports progress only once. Input waits remain
+   * excluded by RunClock.
    */
   #measureSpeed() {
     const sample = this.#workSample;
     if (sample === null) {
       return;
     }
-    if (this.#pieceSample === null) {
-      this.#pieceSample = sample;
-      return;
-    }
     const speed = speedFromWork(this.#pieceSample, sample);
     if (speed !== null) {
       this.#speedReading = { speed, at: sample.at };
       this.#pieceSample = sample;
+      this.#speedMeasurementPending = false;
       this.onSpeedMeasured(this.speedReading);
     }
   }

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