@torrent-tv/proxy 2.80.19 → 2.81.1

package/services/torrent-worker/client.js

@@ -676,6 +676,38 @@ export class TorrentWorkerClient {
    *
    * @returns {Promise<void>}
    */
+  /**
+   * What the spilled pieces weigh, as of the last revision. Zero until one has
+   * happened, which is what "we have not asked yet" means.
+   *
+   * @type {number}
+   */
+  spilledBytes = 0;
+
+  /**
+   * Say how much disk the spilled pieces on this thread may take between them.
+   *
+   * Best effort and never awaited by anything that matters: a share that does
+   * not arrive leaves the ceiling where it was, and the next revision is a
+   * minute away.
+   *
+   * @param {number} bytes
+   * @returns {Promise<void>}
+   */
+  async allowSpillBytes(bytes) {
+    try {
+      const revised = await this.#caller.call(Command.SPILL_ALLOWANCE, { bytes });
+      // The reply says what those stores actually hold, which is what the owner
+      // of the disk needs for the next division. One exchange, both directions.
+      this.spilledBytes = Array.isArray(revised)
+        ? revised.reduce((sum, store) => sum + (Number(store?.bytes) || 0), 0)
+        : this.spilledBytes;
+    } catch {
+      // The thread is gone or busy; the next revision says it again.
+    }
+    return this.spilledBytes;
+  }
+
   async destroyAll() {
     this.#stopping = true;
     try {

package/services/torrent-worker/pool-adapter.js

@@ -70,6 +70,21 @@ export class WorkerTorrentPool {
    * @param {number} fileIndex
    * @returns {() => void}
    */
+  /** What the spilled pieces weigh on the torrent thread, as last revised. */
+  get spilledBytes() {
+    return this.#client.spilledBytes;
+  }
+
+  /**
+   * Say how much disk those spilled pieces may take between them.
+   *
+   * @param {number} bytes
+   * @returns {Promise<number>} What they hold now.
+   */
+  allowSpillBytes(bytes) {
+    return this.#client.allowSpillBytes(bytes);
+  }
+
   acquireFile(torrent, fileIndex) {
     const sourceKey = torrent?.sourceKey;
     if (!sourceKey) {

package/services/torrent-worker/protocol.js

@@ -115,6 +115,15 @@ export const Command = {
   /** Cues of one subtitle track, from the clusters already downloaded. */
   SUBTITLE_CUES: "subtitle-cues",
   /** Shut the client down, optionally deleting downloaded data. */
+  /**
+   * How much disk the spilled pieces may take between them.
+   *
+   * Sent from the main thread, because the disk has one owner and this store is
+   * not its only user: the segments an encoder produces are on the same disk,
+   * and a ceiling one of two users sets for itself is not a ceiling. The worker
+   * divides its share between the stores it holds.
+   */
+  SPILL_ALLOWANCE: "spill-allowance",
   DESTROY_ALL: "destroy-all"
 };
 

package/services/torrent-worker/worker.js

@@ -65,7 +65,7 @@ forwardLogsTo((_level, message) => {
 // the hook above had a chance to register. Verified the hard way: with a static
 // import the process still aborted, and the stack named the genuine polyfill.
 const { TorrentPool, resolveDhtBootstrap } = await import("../torrent-pool.js");
-const { collectStoreStats, machineReserveBytes, pieceBufferCollection, reviseStoreBudgets } =
+const { collectStoreStats, machineReserveBytes, pieceBufferCollection, reviseSpillBudgets, reviseStoreBudgets } =
   await import("../piece-store/shared-piece-store.js");
 
 // Resolved before the client exists, because the client builds its DHT in its
@@ -580,6 +580,13 @@ async function runCommand(command, params, id) {
       return true;
     }
 
+    case Command.SPILL_ALLOWANCE: {
+      // The disk has one owner and it is on the main thread, where the segments
+      // are. What arrives is this thread’s whole share; the stores divide it
+      // between themselves.
+      return reviseSpillBudgets(Number(params.bytes));
+    }
+
     case Command.DESTROY_ALL: {
       fileClaims.closeAll();
       torrentsByKey.clear();

package/services/viewer/positions.js

@@ -0,0 +1,48 @@
+/**
+ * @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 sessions, the clock and a way to turn seconds into a
+ * segment number, and it holds none of them.
+ */
+
+import { viewersOf } from "./Viewer.js";
+
+/**
+ * @param {object} params
+ * @param {Iterable<{ outputKey?: string }>} params.sessions - Every live session.
+ * @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 {number} params.staleAfterMs - Silence longer than any a watching
+ *   viewer can produce.
+ * @returns {number[]} A segment number per present viewer, unsorted.
+ */
+export function viewerSegmentsOn({ sessions, outputKey, segmentAt, now, staleAfterMs }) {
+  const at = [];
+  for (const session of sessions) {
+    if (session.outputKey !== outputKey) {
+      continue;
+    }
+    for (const viewer of viewersOf(session).values()) {
+      if (!viewer.isPresent(now, staleAfterMs)) {
+        continue;
+      }
+      const seconds = viewer.positionSeconds();
+      if (!Number.isFinite(seconds)) {
+        continue;
+      }
+      const index = segmentAt(session, /** @type {number} */ (seconds));
+      if (Number.isInteger(index) && index >= 0) {
+        at.push(index);
+      }
+    }
+  }
+  return at;
+}

package/test/audio-inventory.test.js

@@ -1,176 +1,176 @@
-/**
- * @file One numbered list of soundtracks, from two readings of the same file.
- *
- * Two things are being pinned here, and each has cost a real failure elsewhere
- * in this project:
- *
- * 1. **The alignment guard.** The container reading is used ONLY when it can be
- *    lined up with ffmpeg's own numbering, because `0:a:N` is what the encoder
- *    is handed — a flag attributed to the wrong track is worse than a missing
- *    one. Same discipline as `subtitle-defaults.js`, for the same reason.
- * 2. **The flat numbering.** The browser's menu, the `audioTrackIndex` on a
- *    session request and the `a/<n>/` address of a rendition are one number.
- *    Embedded tracks must keep the numbers they have always had, so that a
- *    session created against an older cached plan means the same thing.
- */
-
-import test from "node:test";
-import { Container } from "../services/container/Container.js";
-import { AudioTrack } from "../services/tracks/AudioTrack.js";
-import assert from "node:assert/strict";
-import {
-  audioRenditionName,
-  buildAudioInventory,
-  resolveAudioIndex
-} from "../services/audio-inventory.js";
-
-test("a pair agreeing on language is accepted", () => {
-  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "jpn" }), true);
-});
-
-test("a pair disagreeing on language is refused", () => {
-  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "rus" }), false);
-});
-
-test("two tracks that say nothing about themselves do not break the alignment", () => {
-  assert.equal(Container.pairingHolds({ language: "und", title: "" }, { language: "", name: "" }), true);
-});
-
-test("the container's own flags reach the merged track", () => {
-  const merged = Container.mergeAudioFlags(
-    [
-      { index: 0, language: "eng", title: "", isDefault: true, codec: "aac" },
-      { index: 1, language: "eng", title: "Director", isDefault: true, codec: "ac3" }
-    ],
-    [
-      { language: "eng", name: "", isOriginal: true, isDefault: true, declaresDefault: true, channels: 6 },
-      { language: "eng", name: "Director", isCommentary: true, isDefault: false, declaresDefault: true, channels: 2 }
-    ]
-  );
-  assert.equal(merged.aligned, true);
-  assert.equal(merged.tracks[0].isOriginal, true);
-  assert.equal(merged.tracks[0].channels, 6);
-  assert.equal(merged.tracks[1].isCommentary, true);
-  // Matroska defaults FlagDefault to 1 and ffmpeg prints the applied default, so
-  // the banner said both tracks were default. The container says otherwise.
-  assert.equal(merged.tracks[1].isDefault, false);
-});
-
-test("a count that differs drops the container reading whole", () => {
-  const merged = Container.mergeAudioFlags(
-    [{ index: 0, language: "eng", isDefault: true }],
-    [{ language: "eng" }, { language: "rus" }]
-  );
-  assert.equal(merged.aligned, false);
-  assert.match(merged.reason, /declares 2 audio tracks and the probe found 1/);
-  // Nothing of it is used — not even the flags that happened to line up.
-  assert.equal(merged.tracks[0].isCommentary, false);
-  assert.equal(merged.tracks[0].declaresDefault, false);
-});
-
-test("one pair that agrees on neither language nor title drops it too", () => {
-  const merged = Container.mergeAudioFlags(
-    [{ index: 0, language: "jpn", title: "" }, { index: 1, language: "rus", title: "" }],
-    [{ language: "jpn", name: "" }, { language: "eng", name: "" }]
-  );
-  assert.equal(merged.aligned, false);
-  assert.match(merged.reason, /audio 1 is/);
-});
-
-test("embedded tracks keep the numbers they have always had, sidecars follow", () => {
-  const inventory = buildAudioInventory({
-    embedded: [
-      { language: "jpn", codec: "aac", isDefault: true },
-      { language: "eng", codec: "ac3", title: "Commentary", isCommentary: true }
-    ],
-    videoFileIndex: 24,
-    sidecars: [
-      {
-        file: { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" },
-        tracks: [{ language: "rus", codecId: "A_AC3", channels: 6 }]
-      }
-    ]
-  });
-
-  assert.deepEqual(inventory.map((entry) => entry.index), [0, 1, 2]);
-  assert.deepEqual(inventory.map((entry) => entry.fileIndex), [24, 24, 12]);
-  assert.deepEqual(inventory.map((entry) => entry.sourceTrackIndex), [0, 1, 0]);
-  assert.deepEqual(inventory.map((entry) => entry.kind), ["embedded", "embedded", "sidecar"]);
-  assert.equal(inventory[2].codec, "ac3");
-  assert.deepEqual(inventory[2].folders, ["Rus Sound"]);
-  assert.equal(inventory[2].fileName, "ep.mka");
-});
-
-test("a sidecar whose table could not be read is still offered, as one track", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "eng", codec: "aac" }],
-    videoFileIndex: 0,
-    sidecars: [{ file: { fileIndex: 1, name: "dub.ac3", folders: [], extension: ".ac3" }, tracks: [] }]
-  });
-  assert.equal(inventory.length, 2);
-  assert.equal(inventory[1].sourceTrackIndex, 0);
-  // The extension of a bare elementary stream IS its codec.
-  assert.equal(inventory[1].codec, "ac3");
-});
-
-test("a sidecar carrying two tracks contributes both", () => {
-  const inventory = buildAudioInventory({
-    embedded: [],
-    videoFileIndex: 0,
-    sidecars: [
-      {
-        file: { fileIndex: 3, name: "dubs.mka", folders: [], extension: ".mka" },
-        tracks: [{ language: "rus" }, { language: "ukr" }]
-      }
-    ]
-  });
-  assert.deepEqual(inventory.map((entry) => [entry.index, entry.sourceTrackIndex]), [[0, 0], [1, 1]]);
-});
-
-test("the flat number resolves back to a file and a track inside it", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "jpn" }],
-    videoFileIndex: 24,
-    sidecars: [{ file: { fileIndex: 12, name: "ep.mka", folders: [], extension: ".mka" }, tracks: [{}] }]
-  });
-  assert.equal(resolveAudioIndex(inventory, 1).fileIndex, 12);
-  assert.equal(resolveAudioIndex(inventory, 1).sourceTrackIndex, 0);
-  assert.equal(resolveAudioIndex(inventory, 9), null);
-});
-
-test("codec identifiers are translated to the names the browser judges by", () => {
-  assert.equal(AudioTrack.codecNameOf({ codec: "AAC" }), "aac");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AC3" }), "ac3");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AAC/MPEG4/LC" }), "aac");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_PCM/INT/LIT" }), "pcm");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "ec-3" }), "eac3");
-  assert.equal(AudioTrack.codecNameOf({}, ".dts"), "dts");
-  assert.equal(AudioTrack.codecNameOf({}, ".unknown"), "");
-});
-
-test("a rendition is named by what the file says, and two never share a name", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "jpn" }],
-    videoFileIndex: 0,
-    sidecars: [
-      { file: { fileIndex: 1, name: "a.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] },
-      { file: { fileIndex: 2, name: "b.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] }
-    ]
-  });
-  assert.equal(audioRenditionName(inventory[0], inventory), "jpn");
-  // Both sidecars sit in the same folder and neither names itself, so the names
-  // would collide — and hls.js groups renditions by name.
-  assert.notEqual(
-    audioRenditionName(inventory[1], inventory),
-    audioRenditionName(inventory[2], inventory)
-  );
-});
-
-test("a commentary says so in its rendition name", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "eng" }, { language: "eng", title: "Director", isCommentary: true }],
-    videoFileIndex: 0,
-    sidecars: []
-  });
-  assert.match(audioRenditionName(inventory[1], inventory), /commentary/);
-});
+/**
+ * @file One numbered list of soundtracks, from two readings of the same file.
+ *
+ * Two things are being pinned here, and each has cost a real failure elsewhere
+ * in this project:
+ *
+ * 1. **The alignment guard.** The container reading is used ONLY when it can be
+ *    lined up with ffmpeg's own numbering, because `0:a:N` is what the encoder
+ *    is handed — a flag attributed to the wrong track is worse than a missing
+ *    one. Same discipline as `subtitle-defaults.js`, for the same reason.
+ * 2. **The flat numbering.** The browser's menu, the `audioTrackIndex` on a
+ *    session request and the `a/<n>/` address of a rendition are one number.
+ *    Embedded tracks must keep the numbers they have always had, so that a
+ *    session created against an older cached plan means the same thing.
+ */
+
+import test from "node:test";
+import { Container } from "../services/container/Container.js";
+import { AudioTrack } from "../services/tracks/AudioTrack.js";
+import assert from "node:assert/strict";
+import {
+  audioRenditionName,
+  buildAudioInventory,
+  resolveAudioIndex
+} from "../services/audio-inventory.js";
+
+test("a pair agreeing on language is accepted", () => {
+  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "jpn" }), true);
+});
+
+test("a pair disagreeing on language is refused", () => {
+  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "rus" }), false);
+});
+
+test("two tracks that say nothing about themselves do not break the alignment", () => {
+  assert.equal(Container.pairingHolds({ language: "und", title: "" }, { language: "", name: "" }), true);
+});
+
+test("the container's own flags reach the merged track", () => {
+  const merged = Container.mergeAudioFlags(
+    [
+      { index: 0, language: "eng", title: "", isDefault: true, codec: "aac" },
+      { index: 1, language: "eng", title: "Director", isDefault: true, codec: "ac3" }
+    ],
+    [
+      { language: "eng", name: "", isOriginal: true, isDefault: true, declaresDefault: true, channels: 6 },
+      { language: "eng", name: "Director", isCommentary: true, isDefault: false, declaresDefault: true, channels: 2 }
+    ]
+  );
+  assert.equal(merged.aligned, true);
+  assert.equal(merged.tracks[0].isOriginal, true);
+  assert.equal(merged.tracks[0].channels, 6);
+  assert.equal(merged.tracks[1].isCommentary, true);
+  // Matroska defaults FlagDefault to 1 and ffmpeg prints the applied default, so
+  // the banner said both tracks were default. The container says otherwise.
+  assert.equal(merged.tracks[1].isDefault, false);
+});
+
+test("a count that differs drops the container reading whole", () => {
+  const merged = Container.mergeAudioFlags(
+    [{ index: 0, language: "eng", isDefault: true }],
+    [{ language: "eng" }, { language: "rus" }]
+  );
+  assert.equal(merged.aligned, false);
+  assert.match(merged.reason, /declares 2 audio tracks and the probe found 1/);
+  // Nothing of it is used — not even the flags that happened to line up.
+  assert.equal(merged.tracks[0].isCommentary, false);
+  assert.equal(merged.tracks[0].declaresDefault, false);
+});
+
+test("one pair that agrees on neither language nor title drops it too", () => {
+  const merged = Container.mergeAudioFlags(
+    [{ index: 0, language: "jpn", title: "" }, { index: 1, language: "rus", title: "" }],
+    [{ language: "jpn", name: "" }, { language: "eng", name: "" }]
+  );
+  assert.equal(merged.aligned, false);
+  assert.match(merged.reason, /audio 1 is/);
+});
+
+test("embedded tracks keep the numbers they have always had, sidecars follow", () => {
+  const inventory = buildAudioInventory({
+    embedded: [
+      { language: "jpn", codec: "aac", isDefault: true },
+      { language: "eng", codec: "ac3", title: "Commentary", isCommentary: true }
+    ],
+    videoFileIndex: 24,
+    sidecars: [
+      {
+        file: { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" },
+        tracks: [{ language: "rus", codecId: "A_AC3", channels: 6 }]
+      }
+    ]
+  });
+
+  assert.deepEqual(inventory.map((entry) => entry.index), [0, 1, 2]);
+  assert.deepEqual(inventory.map((entry) => entry.fileIndex), [24, 24, 12]);
+  assert.deepEqual(inventory.map((entry) => entry.sourceTrackIndex), [0, 1, 0]);
+  assert.deepEqual(inventory.map((entry) => entry.kind), ["embedded", "embedded", "sidecar"]);
+  assert.equal(inventory[2].codec, "ac3");
+  assert.deepEqual(inventory[2].folders, ["Rus Sound"]);
+  assert.equal(inventory[2].fileName, "ep.mka");
+});
+
+test("a sidecar whose table could not be read is still offered, as one track", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "eng", codec: "aac" }],
+    videoFileIndex: 0,
+    sidecars: [{ file: { fileIndex: 1, name: "dub.ac3", folders: [], extension: ".ac3" }, tracks: [] }]
+  });
+  assert.equal(inventory.length, 2);
+  assert.equal(inventory[1].sourceTrackIndex, 0);
+  // The extension of a bare elementary stream IS its codec.
+  assert.equal(inventory[1].codec, "ac3");
+});
+
+test("a sidecar carrying two tracks contributes both", () => {
+  const inventory = buildAudioInventory({
+    embedded: [],
+    videoFileIndex: 0,
+    sidecars: [
+      {
+        file: { fileIndex: 3, name: "dubs.mka", folders: [], extension: ".mka" },
+        tracks: [{ language: "rus" }, { language: "ukr" }]
+      }
+    ]
+  });
+  assert.deepEqual(inventory.map((entry) => [entry.index, entry.sourceTrackIndex]), [[0, 0], [1, 1]]);
+});
+
+test("the flat number resolves back to a file and a track inside it", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "jpn" }],
+    videoFileIndex: 24,
+    sidecars: [{ file: { fileIndex: 12, name: "ep.mka", folders: [], extension: ".mka" }, tracks: [{}] }]
+  });
+  assert.equal(resolveAudioIndex(inventory, 1).fileIndex, 12);
+  assert.equal(resolveAudioIndex(inventory, 1).sourceTrackIndex, 0);
+  assert.equal(resolveAudioIndex(inventory, 9), null);
+});
+
+test("codec identifiers are translated to the names the browser judges by", () => {
+  assert.equal(AudioTrack.codecNameOf({ codec: "AAC" }), "aac");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AC3" }), "ac3");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AAC/MPEG4/LC" }), "aac");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_PCM/INT/LIT" }), "pcm");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "ec-3" }), "eac3");
+  assert.equal(AudioTrack.codecNameOf({}, ".dts"), "dts");
+  assert.equal(AudioTrack.codecNameOf({}, ".unknown"), "");
+});
+
+test("a rendition is named by what the file says, and two never share a name", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "jpn" }],
+    videoFileIndex: 0,
+    sidecars: [
+      { file: { fileIndex: 1, name: "a.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] },
+      { file: { fileIndex: 2, name: "b.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] }
+    ]
+  });
+  assert.equal(audioRenditionName(inventory[0], inventory), "jpn");
+  // Both sidecars sit in the same folder and neither names itself, so the names
+  // would collide — and hls.js groups renditions by name.
+  assert.notEqual(
+    audioRenditionName(inventory[1], inventory),
+    audioRenditionName(inventory[2], inventory)
+  );
+});
+
+test("a commentary says so in its rendition name", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "eng" }, { language: "eng", title: "Director", isCommentary: true }],
+    videoFileIndex: 0,
+    sidecars: []
+  });
+  assert.match(audioRenditionName(inventory[1], inventory), /commentary/);
+});