@torrent-tv/proxy 2.86.0 → 2.87.0

package/services/viewer/active-output.js

@@ -1,54 +1,37 @@
-/**
- * @file Which output a viewer has on screen.
- *
- * Every request that names the picture's session — a seek, a progress poll, a
- * link report, a release — means the stream the viewer is actually watching,
- * and after a quality change that is another session. The browser is never told
- * about the swap: it holds one session id for the whole file, which is what
- * keeps the switch out of the state machine on that side.
- *
- * KEPT PER VIEWER, because one picture is shared by everyone watching it and a
- * quality step is a session of its own. With one answer for the session, a step
- * taken by one viewer moved the other one's stream, and that viewer's next seek
- * was forwarded to a rung they never chose. The session's own field remains the
- * answer for a viewer who cannot name themselves, and is the last rung anybody
- * moved to.
- *
- * It is handed the picture, a name, the live sessions and the registry of
- * viewers, and it HOLDS none of them — but it is not read-only: finding a rung
- * that has been disposed, it puts both remembers back on the picture, or the
- * next question gets the same dead answer. It lives in the VIEWER layer because
- * the question is about a person — which of several equally live outputs is
- * theirs — and it knows nothing of encoders, files or heights.
- */
-
-/**
- * @param {object} params
- * @param {object} params.base - The picture's own session.
- * @param {string} [params.consumerId] - Whose screen. Empty asks about the
- *   session's own last answer, which is what an unnamed browser gets.
- * @param {{ get: (id: string) => object | undefined }} params.sessions - Every live session, by id.
- * @param {{ of: (session: object, consumerId: string) => { activeVariantId: string | null } }} params.viewers
- * @returns {object} A live session, never a disposed one.
- */
-export function activeOutputFor({ base, consumerId = "", sessions, viewers }) {
-  const named = consumerId ? base.viewers?.get(consumerId)?.activeVariantId ?? null : null;
-  const activeId = named ?? base.activeVariantId;
-  if (!activeId || activeId === base.id) {
-    return base;
-  }
-  const active = sessions.get(activeId);
-  if (!active || active.state === "disposed") {
-    // The rung is gone, so the viewer is watching the picture again. Said in
-    // both places that remember it, or the next question gets the same dead
-    // answer.
-    if (named) {
-      viewers.of(base, consumerId).activeVariantId = null;
-    }
-    if (base.activeVariantId === activeId) {
-      base.activeVariantId = base.id;
-    }
-    return base;
-  }
-  return active;
-}
+/**
+ * @file Which output a viewer has on screen.
+ *
+ * The browser addresses the picture output for the whole film. After a quality
+ * change, the viewer's record identifies the selected output. Keeping this per
+ * viewer prevents one viewer's quality change from changing another viewer's
+ * selection.
+ *
+ * A request that names nobody has the picture itself on screen. This module
+ * stores no output, viewer or encoder state.
+ */
+
+/**
+ * @param {object} params
+ * @param {object} params.base - The picture output.
+ * @param {string} [params.consumerId] - Whose screen. Empty names nobody, and
+ *   the answer is the picture.
+ * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
+ * @param {{ getForOutput: (output: object, consumerId: string) => object | null }} params.viewers
+ * @returns {object} A live output, never a disposed one.
+ */
+export function activeOutputFor({ base, consumerId = "", outputs, viewers }) {
+  const viewer = viewers.getForOutput(base, consumerId);
+  const activeId = viewer?.activeVariantId ?? null;
+  if (!activeId || activeId === base.id) {
+    return base;
+  }
+  const active = outputs.get(activeId);
+  if (!active) {
+    // The rung is gone, so the viewer is watching the picture again.
+    if (viewer) {
+      viewer.activeVariantId = null;
+    }
+    return base;
+  }
+  return active;
+}

package/services/viewer/audio-start.js

@@ -18,7 +18,7 @@
  *
  * It decides ONE PARAMETER of an output and places no encoder: where an encoder
  * works is the priority map's answer. Pure over plain values — the outputs of
- * one picture, where it was opened, and how long a piece is — so it knows
+ * one picture, the viewer registry, where it was opened, and how long a piece is — so it knows
  * nothing of ffmpeg, cut grids or the disk.
  */
 
@@ -31,10 +31,11 @@ import { earliestViewerSecondsOn } from "./positions.js";
  * @param {number} params.openedAtSeconds - Where the picture was opened, which
  *   is the answer while nobody has stated a position yet.
  * @param {number} params.segmentSeconds - How long one piece is.
+ * @param {{ forOutput: (output: object) => Map<string, object> }} params.viewers - The registry.
  * @returns {number} Seconds, never negative.
  */
-export function audioStartSecondsFor({ family, openedAtSeconds, segmentSeconds }) {
-  const earliest = earliestViewerSecondsOn(family);
+export function audioStartSecondsFor({ family, openedAtSeconds, segmentSeconds, viewers }) {
+  const earliest = earliestViewerSecondsOn(viewers, family, Date.now());
   const opened = Number(openedAtSeconds);
   const from = earliest ?? (Number.isFinite(opened) ? opened : 0);
   // ONE PIECE BACK, and that is not a margin: a cut grid places the

package/services/viewer/buffer-trend.js

@@ -0,0 +1,81 @@
+/**
+ * @file Which way a viewer's buffer is going, from what their page said about
+ * it (roadmap item 98).
+ *
+ * The buffer does not move smoothly: it rises a whole segment at a time when a
+ * segment arrives and falls a second per second while the picture plays. So one
+ * reading against the next says nothing — it catches either the rise or the
+ * fall. The trend is taken over the SHORTEST run of recent readings that spans
+ * at least one segment's duration, which is the period of that rise and fall,
+ * and fitted by least squares. Nothing here is chosen: the span is the segment
+ * duration of the output the viewer watches, and the caller supplies it.
+ *
+ * Fewer than two readings, or readings that do not yet span one segment, say
+ * nothing, and the answer is null.
+ */
+
+/**
+ * @typedef {{ at: number, seconds: number }} BufferReading - When the page said
+ *   it (ms) and the seconds of film it held.
+ */
+
+/**
+ * The index of the oldest reading of the shortest run, ending at the newest,
+ * whose time span is at least `spanSec`; -1 when no run spans it.
+ *
+ * @param {BufferReading[]} readings - Oldest first.
+ * @param {number} spanSec
+ * @returns {number}
+ */
+export function trendRunStart(readings, spanSec) {
+  if (!Array.isArray(readings) || readings.length < 2 || !(spanSec > 0)) {
+    return -1;
+  }
+  const newest = readings[readings.length - 1].at;
+  for (let index = readings.length - 2; index >= 0; index -= 1) {
+    if ((newest - readings[index].at) / 1000 >= spanSec) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The buffer's trend in seconds of film per second of time — negative while it
+ * is draining — and the interval between the viewer's last two reports, which
+ * is how long it will be before this viewer is heard from again.
+ *
+ * @param {BufferReading[]} readings - Oldest first.
+ * @param {number} spanSec - The segment duration of the output they watch.
+ * @returns {{ slope: number, reportGapSec: number } | null}
+ */
+export function bufferTrend(readings, spanSec) {
+  const start = trendRunStart(readings, spanSec);
+  if (start < 0) {
+    return null;
+  }
+  const run = readings.slice(start);
+  const origin = run[0].at;
+  const count = run.length;
+  let sumT = 0;
+  let sumB = 0;
+  for (const reading of run) {
+    sumT += (reading.at - origin) / 1000;
+    sumB += reading.seconds;
+  }
+  const meanT = sumT / count;
+  const meanB = sumB / count;
+  let numerator = 0;
+  let denominator = 0;
+  for (const reading of run) {
+    const t = (reading.at - origin) / 1000 - meanT;
+    numerator += t * (reading.seconds - meanB);
+    denominator += t * t;
+  }
+  if (!(denominator > 0)) {
+    return null;
+  }
+  const last = readings[readings.length - 1].at;
+  const beforeLast = readings[readings.length - 2].at;
+  return { slope: numerator / denominator, reportGapSec: Math.max(0, (last - beforeLast) / 1000) };
+}