@torrent-tv/proxy 2.100.7 → 2.100.9

package/package.json

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

package/services/encode/quality/QualityController.js

@@ -502,13 +502,21 @@ export class QualityController {
       remainingSec: Number.isFinite(buffer?.positionSec) && session.file?.durationSeconds > 0
         ? Math.max(0, session.file.durationSeconds - buffer.positionSec) : null
     });
-    if (!threat) {
+    // A viewer whose picture has not moved yet — at the start or after a seek —
+    // is held for the material a draining buffer would run out of, while their
+    // buffer grows: the trend says nothing about them. The same two reasons
+    // then decide. Held this way on Home Assistant, a picture made at 0.92-0.96x
+    // was moved to a faster setting 11 s after the start, which had waited 30 s
+    // for it (r70, torrent-tv/meta#178).
+    const held = !threat && buffer?.waiting === true;
+    if (!threat && !held) {
       return false;
     }
+    const why = held ? "their picture is held" : "their buffer is draining";
     // Whatever else happens, a step UP prepared for them is not what they need.
-    this.#dropUpAsk(session, consumerId, "their buffer is draining");
+    this.#dropUpAsk(session, consumerId, why);
     if (this.#host.sameHeightSwitchDirection(consumerId) === "up") {
-      this.#host.cancelSameHeightSwitch(consumerId, "their buffer is draining");
+      this.#host.cancelSameHeightSwitch(consumerId, why);
     }
     const report = this.#host.linkReportOf(session, consumerId);
     const observed = report ? await this.observedStreamMbps(session) : null;
@@ -524,7 +532,8 @@ export class QualityController {
     const reasonText =
       (linkShort ? `link=${report.linkMbps.toFixed(2)}Mbps stream=${observed.toFixed(2)}Mbps ` : "") +
       (machineShort ? `CPU-bound speed=${speed.toFixed(2)}x ` : "") +
-      `buffer=${(buffer?.bufferedSec ?? 0).toFixed(1)}s empty in ${secondsToEmpty === null ? "?" : secondsToEmpty.toFixed(1)}s ` +
+      `buffer=${(buffer?.bufferedSec ?? 0).toFixed(1)}s ` +
+      (held ? "held before it moves " : `empty in ${secondsToEmpty === null ? "?" : secondsToEmpty.toFixed(1)}s `) +
       `for ${consumerId}`;
     if (linkShort) {
       const move = await this.#host.prepareSameHeightSwitch(session, consumerId, "down", `viewer-link-bound ${reasonText}`);

package/services/storage/segment-store/SegmentStore.js

@@ -104,6 +104,17 @@ export class SegmentStore {
 
   /** Output key → how to read its file names. @type {Map<string, object>} */
   #formats = new Map();
+  /**
+   * The outputs whose served pieces this store names itself, in `publish`.
+   * Their record is complete by construction: a piece arrives through
+   * `publish` and leaves through this store's removals. Only an output whose
+   * muxer renames its own pieces into place (the `hls` branch, taken where
+   * there is no grid of cuts) can hold a piece the record has not been told
+   * of yet, and only there does `pathOf` look at the disk.
+   *
+   * @type {Set<string>}
+   */
+  #publishing = new Set();
   #reads = new Map();
 
   /** Hold physical material while a read is prepared or its stream is open. */
@@ -668,6 +679,7 @@ export class SegmentStore {
     }
     // Publication registers the material even after the previous directory was dropped.
     this.useFormat(key, format);
+    this.#publishing.add(key);
     // What the directory holds has changed by this one piece.
     if (index >= 0) this.#heldArrived(key, index);
     else this.#held.delete(key);
@@ -1135,10 +1147,15 @@ export class SegmentStore {
     this.#touched.set(key, this.#now());
     const contents = this.refresh(key);
     const found = contents.byNumber.get(index);
-    if (found || !contents.followed) return found ?? null;
+    // An output this store publishes answers from its record alone. Looking
+    // at the disk for every piece not made, as it did for every output, cost
+    // the main thread 12.6 s of 300 s at a cold start on Home Assistant, the
+    // forecast asking about each piece of the film on every poll (r61,
+    // torrent-tv/meta#178).
+    if (found || !contents.followed || this.#publishing.has(key)) return found ?? null;
     // A reading kept up piece by piece answers from what it was told, and a
-    // change the watch failed to deliver would leave a closed piece absent for
-    // good. The one file asked about is looked at — a `stat`, not a listing.
+    // piece a muxer renamed into place may not have been told of yet. The one
+    // file asked about is looked at — a `stat`, not a listing.
     this.#heldArrived(key, index);
     return contents.byNumber.get(index) ?? null;
   }
@@ -1178,6 +1195,7 @@ export class SegmentStore {
     }
     this.#held.delete(key);
     this.#formats.delete(key);
+    this.#publishing.delete(key);
     this.#mediaRanges.delete(key);
     this.#touched.delete(key);
     this.#inits.delete(key);

package/services/viewer/choices.js

@@ -327,7 +327,7 @@ export function visiblePictureOf(viewers, output, consumerId) {
  * @param {object} output
  * @param {string} consumerId
  * @param {number} spanSec - The segment duration of the output they watch.
- * @returns {{ bufferedSec: number, slope: number | null, reportGapSec: number } | null}
+ * @returns {{ bufferedSec: number, slope: number | null, reportGapSec: number, positionSec: number | null, waiting: boolean } | null}
  *   Null for nobody of that name; `slope` null while their reports do not yet
  *   span one segment.
  */
@@ -339,7 +339,9 @@ export function bufferOf(viewers, output, consumerId, spanSec) {
   const trend = viewer.bufferTrend(spanSec);
   const held = Number.isFinite(viewer.bufferedSeconds) ? Math.max(0, viewer.bufferedSeconds) : 0;
   return { bufferedSec: held, slope: trend?.slope ?? null, reportGapSec: trend?.reportGapSec ?? 0,
-    positionSec: viewer.positionSeconds() ?? null };
+    positionSec: viewer.positionSeconds() ?? null,
+    // Blocked on material owed to them, with their picture not moving.
+    waiting: viewer.waiting === true && viewer.playing !== true };
 }
 
 /**