@torrent-tv/proxy 2.107.21 → 2.107.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.21",
+  "version": "2.107.23",
   "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,12 +603,7 @@ 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;
-      }
+      if (this.#speedMeasurementPending) this.#measureSpeed();
     }
     this.onProgress(this.progress.snapshot());
   }
@@ -688,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
@@ -724,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;
       }
@@ -744,25 +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. 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.
+   * 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) {
-      if (sample.producedSeconds > 0) 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/viewer/playback-readiness.js

@@ -552,7 +552,9 @@ export function predictPlaybackReadiness(input = {}) {
     let after = contiguousEnd(delivered, at);
     for (const completion of completions.filter((item) => item.trackIndex === trackIndex)) {
       const before = after;
-      for (const range of completion.segment.ranges) addMediaRange(delivered, range);
+      const ranges = compare(before, at) === 0
+        ? withSeekStartTolerance(completion.segment.ranges, at, unit) : completion.segment.ranges;
+      for (const range of ranges) addMediaRange(delivered, range);
       after = contiguousEnd(delivered, at);
       const ahead = secondsAhead(earliest(before, trackEnd), at);
       constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false,
@@ -581,7 +583,9 @@ export function predictPlaybackReadiness(input = {}) {
     }
     for (const production of productions.filter((item) => item.trackIndex === trackIndex)) {
       const before = contiguousEnd(prepared, at);
-      for (const range of production.segment.ranges) addMediaRange(prepared, range);
+      const ranges = compare(before, at) === 0
+        ? withSeekStartTolerance(production.segment.ranges, at, unit) : production.segment.ranges;
+      for (const range of ranges) addMediaRange(prepared, range);
       // Supply interruption coverage is stock held by the proxy as well as
       // the browser. It is not a browser buffer-size admission rule.
       // The reserve is bounded by what is left of the track, not of the window.
@@ -851,6 +855,25 @@ function heldRanges(ranges, segments, unit, position) {
   return held;
 }
 
+/**
+ * Include the first arriving range when its start is within the media
+ * element's allowance for a seek target. This does not bridge later gaps.
+ *
+ * @param {import("./media-time.js").MediaRange[]} ranges
+ * @param {import("./media-time.js").MediaTime} position
+ * @param {bigint} unit
+ * @returns {import("./media-time.js").MediaRange[]}
+ */
+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));
+  if (!first || compare(first.start, position) <= 0 || compare(first.start, toleranceEnd) > 0) {
+    return ranges;
+  }
+  return ranges.map((range) => range === first ? { ...range, start: position } : range);
+}
+
 /**
  * The pieces of a track this forecast places in exact time: those still to
  * play (ending after `position`) that start before `horizonEnd`, the first