@torrent-tv/proxy 2.88.4 → 2.88.5

package/services/viewer/positions.js

@@ -1,126 +1,126 @@
-/**
- * @file Where the viewers of one output stand.
- *
- * Asked by whatever has to give disk back: what lies behind every viewer has
- * been played and will not be wanted again unless somebody seeks back, and what
- * lies ahead of the furthest will be wanted eventually. So an answer of "nobody"
- * is the strongest statement there is — everything that output holds is worth
- * less than anything anybody is on their way to.
- *
- * Pure: it is handed the outputs, the clock and a way to turn seconds into a
- * segment number, and it holds none of them.
- */
-
-/**
- * @param {object} params
- * @param {Iterable<{ outputKey?: string }>} params.outputs - Every live output.
- * @param {string} params.outputKey - The output being asked about.
- * @param {(session: object, seconds: number) => number} params.segmentAt - Which
- *   segment of THAT session's timeline a moment of film falls in.
- * @param {number} params.now
- * @param {{ forOutput: (output: object) => Map<string, object> }} params.viewers - The registry that
- *   holds who watches what.
- * @returns {number[]} A segment number per present viewer, unsorted.
- */
-export function viewerSegmentsOn({ outputs, outputKey, segmentAt, now, viewers }) {
-  const at = [];
-  for (const session of outputs) {
-    if (session.outputKey !== outputKey) {
-      continue;
-    }
-    for (const viewer of viewers.forOutput(session).values()) {
-      if (!viewer.isPresent()) {
-        continue;
-      }
-      const seconds = viewer.positionSeconds(now);
-      if (!Number.isFinite(seconds)) {
-        continue;
-      }
-      const index = segmentAt(session, /** @type {number} */ (seconds));
-      if (Number.isInteger(index) && index >= 0) {
-        at.push(index);
-      }
-    }
-  }
-  return at;
-}
-
-/**
- * Where a viewer of one output is, in seconds of film, NOW.
- *
- * One reading with one owner, and a function of time rather than a stored
- * number: a viewer states where their picture is, and the clock carries it
- * forward between statements.
- *
- * Three readings ranked by priority used to answer this — a seek, the start of
- * the last segment requested, the position the output was opened at — with a
- * second function saying which had answered. They were three different
- * quantities wearing one name, two of them written at different rates, so the
- * answer alternated between them several times a second and every encoder
- * followed it.
- *
- * Without a name, the FURTHEST viewer: what lies behind them has already been
- * made, so that is what a reading about no particular person wants. With
- * nobody present at all, zero. Creation registers the requesting viewer and
- * their initial position before any encoder is planned.
- *
- * @param {{ forOutput: (output: object) => Map<string, object> }} viewers - The registry.
- * @param {object} session
- * @param {string} [consumerId] - Whose position.
- * @param {number} [now]
- * @returns {number} Seconds, never negative.
- */
-export function viewerSecondsOn(viewers, session, consumerId = "", now = Date.now()) {
-  if (!session) {
-    return 0;
-  }
-  const watching = viewers.forOutput(session);
-  const named = watching.get(consumerId) ?? null;
-  if (named) {
-    return Math.max(0, named.positionSeconds(now) ?? 0);
-  }
-  let furthest = null;
-  for (const viewer of watching.values()) {
-    if (!viewer.isPresent()) {
-      continue;
-    }
-    const seconds = viewer.positionSeconds(now);
-    if (Number.isFinite(seconds)) {
-      furthest = furthest === null ? seconds : Math.max(furthest, seconds);
-    }
-  }
-  return Math.max(0, furthest ?? 0);
-}
-
-/**
- * The earliest film anybody present is standing on, across several outputs.
- *
- * WHAT IT IS FOR: a soundtrack is created at a position, and a track begun
- * where the leader stands has nothing to give the viewer behind them. So the
- * earliest, and across every rung of the picture, because two viewers of one
- * film may be on different ones.
- *
- * This is a fact about PEOPLE and it decides one parameter of an output. It
- * does not place encoders: which encoder works where is the priority map's
- * answer and nothing here is consulted for it.
- *
- * @param {{ forOutput: (output: object) => Map<string, object> }} viewers - The registry.
- * @param {Iterable<object>} sessions
- * @param {number} [now]
- * @returns {number | null} Seconds, or null when nobody is present.
- */
-export function earliestViewerSecondsOn(viewers, sessions, now = Date.now()) {
-  let earliest = null;
-  for (const session of sessions ?? []) {
-    for (const viewer of viewers.forOutput(session).values()) {
-      if (!viewer.isPresent()) {
-        continue;
-      }
-      const seconds = viewer.positionSeconds(now);
-      if (Number.isFinite(seconds)) {
-        earliest = earliest === null ? seconds : Math.min(earliest, seconds);
-      }
-    }
-  }
-  return earliest;
-}
+/**
+ * @file Where the viewers of one output stand.
+ *
+ * Asked by whatever has to give disk back: what lies behind every viewer has
+ * been played and will not be wanted again unless somebody seeks back, and what
+ * lies ahead of the furthest will be wanted eventually. So an answer of "nobody"
+ * is the strongest statement there is — everything that output holds is worth
+ * less than anything anybody is on their way to.
+ *
+ * Pure: it is handed the outputs, the clock and a way to turn seconds into a
+ * segment number, and it holds none of them.
+ */
+
+/**
+ * @param {object} params
+ * @param {Iterable<{ outputKey?: string }>} params.outputs - Every live output.
+ * @param {string} params.outputKey - The output being asked about.
+ * @param {(session: object, seconds: number) => number} params.segmentAt - Which
+ *   segment of THAT session's timeline a moment of film falls in.
+ * @param {number} params.now
+ * @param {{ forOutput: (output: object) => Map<string, object> }} params.viewers - The registry that
+ *   holds who watches what.
+ * @returns {number[]} A segment number per present viewer, unsorted.
+ */
+export function viewerSegmentsOn({ outputs, outputKey, segmentAt, now, viewers }) {
+  const at = [];
+  for (const session of outputs) {
+    if (session.outputKey !== outputKey) {
+      continue;
+    }
+    for (const viewer of viewers.forOutput(session).values()) {
+      if (!viewer.isPresent()) {
+        continue;
+      }
+      const seconds = viewer.positionSeconds(now);
+      if (!Number.isFinite(seconds)) {
+        continue;
+      }
+      const index = segmentAt(session, /** @type {number} */ (seconds));
+      if (Number.isInteger(index) && index >= 0) {
+        at.push(index);
+      }
+    }
+  }
+  return at;
+}
+
+/**
+ * Where a viewer of one output is, in seconds of film, NOW.
+ *
+ * One reading with one owner, and a function of time rather than a stored
+ * number: a viewer states where their picture is, and the clock carries it
+ * forward between statements.
+ *
+ * Three readings ranked by priority used to answer this — a seek, the start of
+ * the last segment requested, the position the output was opened at — with a
+ * second function saying which had answered. They were three different
+ * quantities wearing one name, two of them written at different rates, so the
+ * answer alternated between them several times a second and every encoder
+ * followed it.
+ *
+ * Without a name, the FURTHEST viewer: what lies behind them has already been
+ * made, so that is what a reading about no particular person wants. With
+ * nobody present at all, zero. Creation registers the requesting viewer and
+ * their initial position before any encoder is planned.
+ *
+ * @param {{ forOutput: (output: object) => Map<string, object> }} viewers - The registry.
+ * @param {object} session
+ * @param {string} [consumerId] - Whose position.
+ * @param {number} [now]
+ * @returns {number} Seconds, never negative.
+ */
+export function viewerSecondsOn(viewers, session, consumerId = "", now = Date.now()) {
+  if (!session) {
+    return 0;
+  }
+  const watching = viewers.forOutput(session);
+  const named = watching.get(consumerId) ?? null;
+  if (named) {
+    return Math.max(0, named.positionSeconds(now) ?? 0);
+  }
+  let furthest = null;
+  for (const viewer of watching.values()) {
+    if (!viewer.isPresent()) {
+      continue;
+    }
+    const seconds = viewer.positionSeconds(now);
+    if (Number.isFinite(seconds)) {
+      furthest = furthest === null ? seconds : Math.max(furthest, seconds);
+    }
+  }
+  return Math.max(0, furthest ?? 0);
+}
+
+/**
+ * The earliest film anybody present is standing on, across several outputs.
+ *
+ * WHAT IT IS FOR: a soundtrack is created at a position, and a track begun
+ * where the leader stands has nothing to give the viewer behind them. So the
+ * earliest, and across every rung of the picture, because two viewers of one
+ * film may be on different ones.
+ *
+ * This is a fact about PEOPLE and it decides one parameter of an output. It
+ * does not place encoders: which encoder works where is the priority map's
+ * answer and nothing here is consulted for it.
+ *
+ * @param {{ forOutput: (output: object) => Map<string, object> }} viewers - The registry.
+ * @param {Iterable<object>} sessions
+ * @param {number} [now]
+ * @returns {number | null} Seconds, or null when nobody is present.
+ */
+export function earliestViewerSecondsOn(viewers, sessions, now = Date.now()) {
+  let earliest = null;
+  for (const session of sessions ?? []) {
+    for (const viewer of viewers.forOutput(session).values()) {
+      if (!viewer.isPresent()) {
+        continue;
+      }
+      const seconds = viewer.positionSeconds(now);
+      if (Number.isFinite(seconds)) {
+        earliest = earliest === null ? seconds : Math.min(earliest, seconds);
+      }
+    }
+  }
+  return earliest;
+}

package/services/viewer/report-intake.js

@@ -1,46 +1,46 @@
-/**
- * @file A viewer's statement about itself, taken in.
- *
- * The VIEWER layer's own entry point, and the whole of what happens when a page
- * says where it is: the output the reporter has on screen is resolved, and the
- * statement reaches the person it is about. Nothing expires here — a link
- * reading is the last thing known about that link, and whether it is still
- * somebody's is presence's answer (`Viewer.linkReading`).
- *
- * It lived in the session manager, which is a description of an OUTPUT, and the
- * two questions were tangled there: whether this is a measurement of a LINK,
- * and whether this is a statement by a VIEWER. Required to be both, a page that
- * had measured nothing could say nothing — see `Viewer.report`.
- *
- * Given the outputs and the viewer registry as plain values, so nothing here
- * knows how an output is found, what a variant is, or that there is an encoder.
- */
-
-import { activeOutputFor } from "./active-output.js";
-
-/**
- * Take one report from one viewer.
- *
- * @param {object} params
- * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
- * @param {{ of: (session: object, consumerId: string) => import("./Viewer.js").Viewer }} params.viewers
- * @param {string} params.sessionId - The session the page addresses, which is
- *   always the picture's: the browser is not told which rung it is on.
- * @param {object} params.report - What they said about themselves.
- * @param {number} [params.now]
- * @returns {boolean} False when no such session is live, which is the page
- *   reporting into one that has been disposed.
- */
-export function recordViewerReport({ outputs, viewers, sessionId, report, now = Date.now() }) {
-  const named = outputs.get(sessionId);
-  const consumerId = typeof report?.consumerId === "string" ? report.consumerId : "";
-  // A report that names nobody is a reading of nobody's link.
-  if (!named || !consumerId) {
-    return false;
-  }
-  // The stream on screen is the reporter's own: with two viewers on two rungs,
-  // one report says nothing about the other's encoder.
-  const session = activeOutputFor({ base: named, consumerId, outputs, viewers });
-  viewers.of(session, consumerId).report(report, now);
-  return true;
-}
+/**
+ * @file A viewer's statement about itself, taken in.
+ *
+ * The VIEWER layer's own entry point, and the whole of what happens when a page
+ * says where it is: the output the reporter has on screen is resolved, and the
+ * statement reaches the person it is about. Nothing expires here — a link
+ * reading is the last thing known about that link, and whether it is still
+ * somebody's is presence's answer (`Viewer.linkReading`).
+ *
+ * It lived in the session manager, which is a description of an OUTPUT, and the
+ * two questions were tangled there: whether this is a measurement of a LINK,
+ * and whether this is a statement by a VIEWER. Required to be both, a page that
+ * had measured nothing could say nothing — see `Viewer.report`.
+ *
+ * Given the outputs and the viewer registry as plain values, so nothing here
+ * knows how an output is found, what a variant is, or that there is an encoder.
+ */
+
+import { activeOutputFor } from "./active-output.js";
+
+/**
+ * Take one report from one viewer.
+ *
+ * @param {object} params
+ * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
+ * @param {{ of: (session: object, consumerId: string) => import("./Viewer.js").Viewer }} params.viewers
+ * @param {string} params.sessionId - The session the page addresses, which is
+ *   always the picture's: the browser is not told which rung it is on.
+ * @param {object} params.report - What they said about themselves.
+ * @param {number} [params.now]
+ * @returns {boolean} False when no such session is live, which is the page
+ *   reporting into one that has been disposed.
+ */
+export function recordViewerReport({ outputs, viewers, sessionId, report, now = Date.now() }) {
+  const named = outputs.get(sessionId);
+  const consumerId = typeof report?.consumerId === "string" ? report.consumerId : "";
+  // A report that names nobody is a reading of nobody's link.
+  if (!named || !consumerId) {
+    return false;
+  }
+  // The stream on screen is the reporter's own: with two viewers on two rungs,
+  // one report says nothing about the other's encoder.
+  const session = activeOutputFor({ base: named, consumerId, outputs, viewers });
+  viewers.of(session, consumerId).report(report, now);
+  return true;
+}

package/store/source-registry.js

@@ -1,71 +1,71 @@
-/**
- * @file In-memory registry of torrent sources.
- *
- * Sources are stored under the torrent infohash, independent of magnet URI
- * names or tracker lists.
- * The registry is bounded: when `maxSources` is exceeded, the oldest entries
- * are evicted to keep memory usage predictable.
- */
-
-import { deriveSourceKey } from "../utils/torrent-source-key.js";
-
-/**
- * @typedef {Object} SourceRecord
- * @property {"magnet" | "torrent"} sourceType - Encoding of the `source` field.
- * @property {string} source      - Magnet URI or base64-encoded .torrent bytes.
- * @property {number} updatedAt   - Unix ms timestamp of the last upsert.
- */
-
-/**
- * Create a bounded in-memory source registry.
- *
- * @param {number} [maxSources=200] - Maximum number of entries to retain.
- * @returns {{
- *   upsert: (sourceType: string, source: string) => Promise<string>,
- *   get:    (sourceKey: string) => SourceRecord | null
- * }}
- */
-export function createSourceRegistry(maxSources = 200) {
-  /** @type {Map<string, SourceRecord>} */
-  const sources = new Map();
-
-  return {
-    /**
-     * Insert or refresh a source entry and return its key.
-     * Evicts the oldest entries if the map exceeds `maxSources`.
-     *
-     * @param {string} sourceType
-     * @param {string} source
-     * @returns {Promise<string>} Canonical `torrent:<infohash>` key.
-     */
-    async upsert(sourceType, source) {
-      const sourceKey = await deriveSourceKey(sourceType, source);
-
-      sources.set(sourceKey, {
-        sourceType,
-        source,
-        updatedAt: Date.now()
-      });
-
-      if (sources.size > maxSources) {
-        const oldest = Array.from(sources.entries()).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
-        for (const [key] of oldest.slice(0, sources.size - maxSources)) {
-          sources.delete(key);
-        }
-      }
-
-      return sourceKey;
-    },
-
-    /**
-     * Look up a source by its key.
-     * Returns `null` if the key is not registered.
-     *
-     * @param {string} sourceKey
-     * @returns {SourceRecord | null}
-     */
-    get(sourceKey) {
-      return sources.get(sourceKey) ?? null;
-    }
-  };
-}
+/**
+ * @file In-memory registry of torrent sources.
+ *
+ * Sources are stored under the torrent infohash, independent of magnet URI
+ * names or tracker lists.
+ * The registry is bounded: when `maxSources` is exceeded, the oldest entries
+ * are evicted to keep memory usage predictable.
+ */
+
+import { deriveSourceKey } from "../utils/torrent-source-key.js";
+
+/**
+ * @typedef {Object} SourceRecord
+ * @property {"magnet" | "torrent"} sourceType - Encoding of the `source` field.
+ * @property {string} source      - Magnet URI or base64-encoded .torrent bytes.
+ * @property {number} updatedAt   - Unix ms timestamp of the last upsert.
+ */
+
+/**
+ * Create a bounded in-memory source registry.
+ *
+ * @param {number} [maxSources=200] - Maximum number of entries to retain.
+ * @returns {{
+ *   upsert: (sourceType: string, source: string) => Promise<string>,
+ *   get:    (sourceKey: string) => SourceRecord | null
+ * }}
+ */
+export function createSourceRegistry(maxSources = 200) {
+  /** @type {Map<string, SourceRecord>} */
+  const sources = new Map();
+
+  return {
+    /**
+     * Insert or refresh a source entry and return its key.
+     * Evicts the oldest entries if the map exceeds `maxSources`.
+     *
+     * @param {string} sourceType
+     * @param {string} source
+     * @returns {Promise<string>} Canonical `torrent:<infohash>` key.
+     */
+    async upsert(sourceType, source) {
+      const sourceKey = await deriveSourceKey(sourceType, source);
+
+      sources.set(sourceKey, {
+        sourceType,
+        source,
+        updatedAt: Date.now()
+      });
+
+      if (sources.size > maxSources) {
+        const oldest = Array.from(sources.entries()).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+        for (const [key] of oldest.slice(0, sources.size - maxSources)) {
+          sources.delete(key);
+        }
+      }
+
+      return sourceKey;
+    },
+
+    /**
+     * Look up a source by its key.
+     * Returns `null` if the key is not registered.
+     *
+     * @param {string} sourceKey
+     * @returns {SourceRecord | null}
+     */
+    get(sourceKey) {
+      return sources.get(sourceKey) ?? null;
+    }
+  };
+}

package/test/asset-paths.test.js

@@ -1,28 +1,28 @@
-/**
- * @file Paths a module builds from its own location still name what they meant.
- *
- * A file that joins `..` onto its own directory is right only at the depth it
- * was written at. Moving files into their components (2.87.0) left the gdb
- * script of the usrsctp reader pointing one directory short, and no check
- * noticed: the path is read only when a wedge is diagnosed.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { CALIBRATION_DIR } from "../services/encode/hwaccel.js";
-import { PROXY_ROOT } from "../services/encode/quality/HostTimings.js";
-import { SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
-
-test("the calibration clips are where the benchmark looks", () => {
-  assert.ok(existsSync(CALIBRATION_DIR), CALIBRATION_DIR);
-});
-
-test("the usrsctp state script is where the reader looks", () => {
-  assert.ok(existsSync(SCTPSTATE_SCRIPT_PATH), SCTPSTATE_SCRIPT_PATH);
-});
-
-test("the default place for host timings is the proxy's own directory", () => {
-  assert.ok(existsSync(path.join(PROXY_ROOT, "package.json")), PROXY_ROOT);
-});
+/**
+ * @file Paths a module builds from its own location still name what they meant.
+ *
+ * A file that joins `..` onto its own directory is right only at the depth it
+ * was written at. Moving files into their components (2.87.0) left the gdb
+ * script of the usrsctp reader pointing one directory short, and no check
+ * noticed: the path is read only when a wedge is diagnosed.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { CALIBRATION_DIR } from "../services/encode/hwaccel.js";
+import { PROXY_ROOT } from "../services/encode/quality/HostTimings.js";
+import { SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
+
+test("the calibration clips are where the benchmark looks", () => {
+  assert.ok(existsSync(CALIBRATION_DIR), CALIBRATION_DIR);
+});
+
+test("the usrsctp state script is where the reader looks", () => {
+  assert.ok(existsSync(SCTPSTATE_SCRIPT_PATH), SCTPSTATE_SCRIPT_PATH);
+});
+
+test("the default place for host timings is the proxy's own directory", () => {
+  assert.ok(existsSync(path.join(PROXY_ROOT, "package.json")), PROXY_ROOT);
+});

package/test/audio-calibration.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { audioReadingFor } from "../services/encode/audio-calibration.js";
+
+const readings = [
+  { codec: "ac3", operation: "aac", channels: 2, samplingFrequency: 48000, speed: 120 },
+  { codec: "aac", operation: "copy", channels: 2, samplingFrequency: 48000, speed: 200,
+    bytes: 64000, durationSeconds: 4 }
+];
+
+test("audio processing uses codec and sample work instead of a video-copy rate", () => {
+  assert.equal(audioReadingFor(readings, { codec: "ac3", transcode: true, channels: 6,
+    samplingFrequency: 48000 }).speed, 40);
+  assert.equal(audioReadingFor(readings, { codec: "ac3", transcode: true, channels: 2,
+    samplingFrequency: 24000 }).speed, 240);
+  assert.equal(audioReadingFor(readings, { codec: "dts", transcode: true }), null);
+});
+
+test("copying uses encoded byte work when the source declares its bitrate", () => {
+  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: false, bitrateKbps: 256 }).speed, 100);
+  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: false }).speed, 200);
+  assert.equal(audioReadingFor(readings, { codec: "aac", transcode: true }), null);
+});