@torrent-tv/proxy 2.85.1 → 2.87.0

package/test/rate-control-in-the-output.test.js

@@ -0,0 +1,180 @@
+/**
+ * @file The bitrate limit and the level are decided with the rest of an
+ * output's format, before it is named — roadmap item 97, step 10.
+ *
+ * Nothing here starts ffmpeg, a torrent or a worker: the decision is a pure
+ * function of values.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { decideOutputFormat } from "../services/encode/quality/output-format.js";
+import { nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
+import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/encode/output/OutputSpec.js";
+
+/**
+ * A 720p output asked for exactly, from a 1080p source, on the encoder given.
+ *
+ * @param {{ kind: string, name: string }} encoder
+ * @param {number | null} [capKbps]
+ * @returns {ReturnType<typeof decideOutputFormat>}
+ */
+function decide(encoder, capKbps = null) {
+  return decideOutputFormat({
+    encodesPicture: true,
+    exact: true,
+    target: { width: 1280, height: 720 },
+    source: { width: 1920, height: 1080, megabitsPerSecond: 8, decode: null },
+    fps: 24,
+    encoder,
+    benchmark: null,
+    cost: { decodeModel: null, observedDecodeCostSec: null, requiredSpeed: null },
+    chooseBudget: () => null,
+    tonemap: false,
+    capKbps,
+    specWith: (encode) => new OutputSpec({
+      sourceKey: "torrent:abc",
+      segmentFormatId: "fmp4",
+      grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+      video: new VideoOutput({ fileIndex: 0, encode }),
+      audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+    }),
+    serving: { mode: "manual", linkMbps: null, keys: [], readyAt: () => false }
+  });
+}
+
+const SOFTWARE = { kind: "software", name: "libx264" };
+const HARDWARE = { kind: "nvenc", name: "h264_nvenc" };
+
+test("a software output is bounded at its size's nominal rate unless a lower limit is asked for", () => {
+  const plain = decide(SOFTWARE).spec.video.encode.rateControl;
+  const lower = decide(SOFTWARE, 1400).spec.video.encode.rateControl;
+
+  assert.deepEqual(plain, softwareRateControlFor({ width: 1280, height: 720, fps: 24 }));
+  assert.deepEqual(lower, softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 }));
+  assert.equal(lower.level, plain.level, "both are declared at the nominal output's level");
+  assert.notEqual(decide(SOFTWARE).spec.toKey(), decide(SOFTWARE, 1400).spec.toKey(), "and are two outputs");
+});
+
+test("a limit named in the request is not answered by an output of another limit already here", () => {
+  // The nominal 720p output exists and is ready, and it suits this viewer —
+  // which is exactly what a move to a lower limit is for leaving.
+  const nominal = decide(SOFTWARE).spec.toKey();
+  const asked = decideOutputFormat({
+    encodesPicture: true,
+    exact: true,
+    target: { width: 1280, height: 720 },
+    source: { width: 1920, height: 1080, megabitsPerSecond: 8, decode: null },
+    fps: 24,
+    encoder: SOFTWARE,
+    benchmark: null,
+    cost: { decodeModel: null, observedDecodeCostSec: null, requiredSpeed: null },
+    chooseBudget: () => null,
+    tonemap: false,
+    capKbps: 1400,
+    specWith: (encode) => new OutputSpec({
+      sourceKey: "torrent:abc",
+      segmentFormatId: "fmp4",
+      grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+      video: new VideoOutput({ fileIndex: 0, encode }),
+      audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+    }),
+    serving: { mode: "manual", linkMbps: null, keys: [nominal], readyAt: () => true }
+  });
+  assert.equal(asked.reusedKey, null);
+  assert.deepEqual(asked.spec.video.encode.rateControl, softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 }));
+});
+
+test("a hardware output states no limit, because it is given none", () => {
+  assert.equal(decide(HARDWARE).spec.video.encode.rateControl, null);
+  assert.ok(decide(HARDWARE).spec.toKey().endsWith("/vbv=-:a=0/0/aac"));
+});
+
+test("a limit above the size's own is refused rather than lowered", () => {
+  assert.throws(() => decide(SOFTWARE, nominalKbpsFor({ width: 1280, height: 720 }) + 1), RangeError);
+  assert.throws(() => decide(SOFTWARE, 0), RangeError, "and a limit that is not a positive rate is not a limit");
+});
+
+// ---------------------------------------------------------------------------
+// Step 11: the viewer's own link decides whether a format may be given at all.
+// ---------------------------------------------------------------------------
+
+/**
+ * A 720p output of a 1080p source for a viewer whose link measured `linkMbps`.
+ *
+ * @param {{ mode?: "auto" | "manual", linkMbps?: number | null, limits?: number[], encoder?: object, audioLoad?: object | null }} how
+ */
+function decideFor({ mode = "manual", linkMbps = null, limits = null, encoder = SOFTWARE, audioLoad = null } = {}) {
+  return decideOutputFormat({
+    encodesPicture: true,
+    exact: true,
+    target: { width: 1280, height: 720 },
+    source: { width: 1920, height: 1080, megabitsPerSecond: 8, decode: null },
+    fps: 24,
+    encoder,
+    benchmark: null,
+    cost: { decodeModel: null, observedDecodeCostSec: null, requiredSpeed: null },
+    chooseBudget: () => null,
+    tonemap: false,
+    ...(limits ? { limitsFor: (frame) => (frame.height === 720 ? limits : [nominalKbpsFor(frame)]) } : {}),
+    audioLoad,
+    specWith: (encode) => new OutputSpec({
+      sourceKey: "torrent:abc",
+      segmentFormatId: "fmp4",
+      grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+      video: new VideoOutput({ fileIndex: 0, encode }),
+      audio: null
+    }),
+    serving: { mode, linkMbps, keys: [], readyAt: () => false }
+  });
+}
+
+test("a size picked by hand keeps its height and takes the highest limit the link admits", () => {
+  // 720p nominal peaks at 3.64 Mbit/s; a 3 Mbit/s link admits 2.4 of it.
+  const decided = decideFor({ mode: "manual", linkMbps: 3, limits: [2800, 1400] });
+  assert.equal(decided.unavailable, null);
+  assert.equal(decided.spec.video.encode.height, 720, "the height picked by hand is kept");
+  assert.deepEqual(
+    decided.spec.video.encode.rateControl,
+    softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 })
+  );
+  assert.equal(decided.answer.verdict, "fits");
+});
+
+test("AUTO moves to a smaller rung only when that rung's own load is admitted", () => {
+  // Nothing at 720p fits 3 Mbit/s with only the nominal limit, and 480p's
+  // nominal peak (1.82 Mbit/s) does.
+  const decided = decideFor({ mode: "auto", linkMbps: 3 });
+  assert.equal(decided.unavailable, null);
+  assert.ok(decided.spec.video.encode.height < 720, "a smaller rung");
+  assert.ok(decided.answer.admitted, "whose own load the link admits");
+  assert.equal(
+    decideFor({ mode: "auto", linkMbps: 0.3 }).unavailable?.reason?.length > 0,
+    true,
+    "and with nothing admitted at any rung, nothing is handed over"
+  );
+});
+
+test("nothing admitted is answered as unavailable, with the figures, and names no output", () => {
+  const decided = decideFor({ mode: "manual", linkMbps: 3 });
+  assert.equal(decided.spec, null, "a format known not to fit is never handed over");
+  assert.ok(decided.unavailable.reason.length > 0);
+  assert.equal(decided.unavailable.figures.verdict, "does not fit");
+  assert.equal(decided.unavailable.figures.linkMbps, 3);
+});
+
+test("a hardware output is unavailable against a measured link, and given while nothing measured it", () => {
+  assert.equal(decideFor({ encoder: HARDWARE, linkMbps: 50 }).unavailable.figures.verdict, "no safe bound");
+  assert.equal(decideFor({ encoder: HARDWARE, linkMbps: null }).answer.verdict, "no measurement");
+});
+
+test("the soundtrack the viewer hears counts toward what their link carries", () => {
+  // 720p nominal peaks at 3.64 Mbit/s. A 4.6 Mbit/s link admits 3.68 of it:
+  // enough for the picture, not for the picture and 128 kbit/s of sound.
+  const linkMbps = 4.6;
+  assert.equal(decideFor({ mode: "manual", linkMbps }).answer.verdict, "fits");
+  assert.ok(
+    decideFor({ mode: "manual", linkMbps, audioLoad: { mbps: 0.128, peakClass: "known" } }).unavailable,
+    "with the sound it no longer fits"
+  );
+});

package/test/read-survives-withdrawal.test.js

@@ -15,8 +15,8 @@ import { EventEmitter } from "node:events";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { readFragments } from "../services/torrent-worker/piece-reader.js";
-import { SharedPieceStore } from "../services/piece-store/shared-piece-store.js";
+import { readFragments } from "../services/torrent/worker/piece-reader.js";
+import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
 
 const PIECE = 1024;
 const TOTAL = 4 * PIECE;

package/test/read-window.test.js

@@ -31,8 +31,8 @@ import {
   nextWindowPieces,
   readFragments,
   readWindowFor
-} from "../services/torrent-worker/piece-reader.js";
-import { SharedPieceStore } from "../services/piece-store/shared-piece-store.js";
+} from "../services/torrent/worker/piece-reader.js";
+import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
 
 const PIECE = 1024;
 // The production window is 32 MB against 8 MiB pieces — four of them. Sized
@@ -47,9 +47,16 @@ const WINDOW_PIECES = 4;
 async function recordingTorrent({ pieceCount, present = () => true }) {
   const directory = await fs.mkdtemp(path.join(os.tmpdir(), "read-window-test-"));
   const totalLength = pieceCount * PIECE;
+  // ROOM FOR THE WHOLE FIXTURE, because none of these tests is about eviction.
+  // At 64 pieces of memory an 8000-piece fixture spilled 7936 of them to disk —
+  // a file each — and read most of them back, so four checks about which piece
+  // RANGES a reader claims cost 25-28 seconds apiece and this one file took
+  // 132 s of a 140 s suite. The store's own behaviour under pressure is
+  // measured where that is the subject (`piece-store-eviction`,
+  // `piece-lru`, `piece-disk-store`).
   const store = new SharedPieceStore(PIECE, {
     length: totalLength,
-    memoryBytes: 64 * PIECE,
+    memoryBytes: totalLength,
     path: directory,
     name: "test"
   });

package/test/resume-warm.test.js

@@ -12,7 +12,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { resumeByteOffset } from "../services/torrent-worker/container-tracks.js";
+import { resumeByteOffset } from "../services/torrent/worker/resume-warm.js";
 
 test("a position halfway through a film is halfway through its file", () => {
   assert.equal(resumeByteOffset(1000, 100, 50), 500);

package/test/run-inputs.test.js

@@ -0,0 +1,80 @@
+/**
+ * @file What an encoder is told to read.
+ *
+ * The encoder's own read of its source is the one read that tracks where the
+ * viewer is (`reader=playback`), and the only one sized in seconds of playback
+ * (`windowBytes`). Both travel on the input address. When the address stopped
+ * being kept on the session and started being built per run, both were left
+ * off it: every encoder read looked to the stream route like a probe, and the
+ * read window fell back to the reader's default.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { encoderInputs } from "../services/encode/run-inputs.js";
+
+const BASE = "http://127.0.0.1:9090";
+
+function file(fileIndex) {
+  return {
+    fileIndex,
+    streamUrl(baseUrl, { sessionId = "" } = {}) {
+      const url = new URL("/stream", `${baseUrl}/`);
+      url.searchParams.set("fileIndex", String(fileIndex));
+      if (sessionId) {
+        url.searchParams.set("session", sessionId);
+      }
+      return url;
+    }
+  };
+}
+
+test("the picture's read says it is the playback read, with its window", () => {
+  const picture = file(0);
+  const { inputUrl } = encoderInputs({
+    picture,
+    soundtrack: picture,
+    carries: "video-only",
+    audioSeparate: true,
+    sessionId: "aaaaaaaabbbbcccc",
+    readWindowBytes: 32_000_000,
+    baseUrl: BASE
+  });
+  const url = new URL(inputUrl);
+  assert.equal(url.searchParams.get("reader"), "playback");
+  assert.equal(url.searchParams.get("windowBytes"), "32000000");
+  assert.equal(url.searchParams.get("session"), "aaaaaaaabbbbcccc");
+});
+
+test("with no window measured the read states neither parameter", () => {
+  const picture = file(0);
+  const { inputUrl } = encoderInputs({
+    picture,
+    soundtrack: picture,
+    carries: "muxed",
+    audioSeparate: false,
+    sessionId: "aaaaaaaabbbbcccc",
+    readWindowBytes: 0,
+    baseUrl: BASE
+  });
+  const url = new URL(inputUrl);
+  assert.equal(url.searchParams.get("windowBytes"), null);
+  assert.equal(url.searchParams.get("reader"), null, "exactly as before: both are set together or neither");
+});
+
+test("a soundtrack in its own file is read directly by its rendition, and is a second input only when muxed", () => {
+  const picture = file(0);
+  const dub = file(3);
+  const rendition = encoderInputs({
+    picture, soundtrack: dub, carries: "audio-only", audioSeparate: true,
+    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
+  });
+  assert.equal(new URL(rendition.inputUrl).searchParams.get("fileIndex"), "3");
+  assert.equal(rendition.audioInputUrl, "");
+  const muxed = encoderInputs({
+    picture, soundtrack: dub, carries: "muxed", audioSeparate: false,
+    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
+  });
+  assert.equal(new URL(muxed.inputUrl).searchParams.get("fileIndex"), "0");
+  assert.equal(new URL(muxed.audioInputUrl).searchParams.get("fileIndex"), "3");
+});

package/test/run-position-follows-published-grid.test.js

@@ -19,10 +19,12 @@
  */
 
 import assert from "node:assert/strict";
-import { Timeline } from "../services/output/Timeline.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import test from "node:test";
 
-import { HlsSessionManager, describeGridDrift, segmentCutTimesFrom } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { segmentCutTimesFrom } from "../services/encode/run-command.js";
+import { describeGridDrift } from "../services/encode/OutputTimes.js";
 
 /** What the playlist in the player's hands says. */
 const PUBLISHED = [0, 8.342, 16.684, 25.026, 33.368, 41.71];
@@ -30,10 +32,10 @@ const PUBLISHED = [0, 8.342, 16.684, 25.026, 33.368, 41.71];
 const CORRECTED = [0, 8.342, 14.682, 25.026, 31.366, 41.71];
 
 /**
- * @returns {{ manager: HlsSessionManager, session: object }}
+ * @returns {{ manager: object, session: object }}
  */
 function sessionWithDriftedGrid() {
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -48,14 +50,14 @@ function sessionWithDriftedGrid() {
 
 test("a run starts at the time the player was told, not at the corrected one", () => {
   const { manager, session } = sessionWithDriftedGrid();
-  assert.equal(manager.runStartTimeFor(session, 2), 16.684);
-  assert.notEqual(manager.runStartTimeFor(session, 2), session.timeline.boundaries[2]);
+  assert.equal(manager.outputTimes.runStartTimeFor(session, 2), 16.684);
+  assert.notEqual(manager.outputTimes.runStartTimeFor(session, 2), session.timeline.boundaries[2]);
 });
 
 test("position and cut list come from the same table", () => {
   const { manager, session } = sessionWithDriftedGrid();
-  const grid = manager.publishedGridFor(session);
-  const start = manager.runStartTimeFor(session, 2);
+  const grid = manager.outputTimes.publishedGridFor(session);
+  const start = manager.outputTimes.runStartTimeFor(session, 2);
   // The cut list is stated as offsets from where the run begins. Adding the
   // position back must land on the published boundaries exactly — which is the
   // property that was false while the two came from different tables.
@@ -66,13 +68,13 @@ test("position and cut list come from the same table", () => {
 test("a session that published no grid positions on the live one", () => {
   const { manager } = sessionWithDriftedGrid();
   const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
-  assert.equal(manager.runStartTimeFor(session, 2), CORRECTED[2]);
+  assert.equal(manager.outputTimes.runStartTimeFor(session, 2), CORRECTED[2]);
 });
 
 test("an index beyond the table is clamped rather than returning nothing", () => {
   const { manager, session } = sessionWithDriftedGrid();
-  assert.equal(manager.runStartTimeFor(session, 9999), PUBLISHED[PUBLISHED.length - 1]);
-  assert.equal(manager.runStartTimeFor(session, -3), PUBLISHED[0]);
+  assert.equal(manager.outputTimes.runStartTimeFor(session, 9999), PUBLISHED[PUBLISHED.length - 1]);
+  assert.equal(manager.outputTimes.runStartTimeFor(session, -3), PUBLISHED[0]);
 });
 
 test("the drift between the two tables is stated in full", () => {

package/test/run-progress.test.js

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RunProgress } from "../services/encode/RunProgress.js";
+import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
+
+function orchestrator() {
+  return new EncodeOrchestrator({
+    maxRunsFor: () => 2,
+    makeRun: () => null,
+    segmentSeconds: 4,
+    logger: { info() {}, warn() {} }
+  });
+}
+
+test("a run rebases ffmpeg's relative clock onto its own source position", () => {
+  let now = 10;
+  const progress = new RunProgress({ startSeconds: 600, totalSeconds: 1000, now: () => now });
+  now = 20;
+  progress.note({ processedSeconds: 12.5, speed: "2.0x" });
+
+  assert.deepEqual(progress.snapshot(), {
+    processedSeconds: 612.5,
+    startPositionSeconds: 600,
+    totalSeconds: 1000,
+    percent: 3.125,
+    remainingSeconds: 387.5,
+    speed: "2.0x",
+    updatedAt: 20
+  });
+});
+
+test("two runs of one output retain separate clocks", () => {
+  const made = orchestrator();
+  const first = { from: 0, to: 49, isAlive: true, progress: new RunProgress({ startSeconds: 0 }) };
+  const second = { from: 50, to: 99, isAlive: true, progress: new RunProgress({ startSeconds: 200 }) };
+  first.progress.note({ processedSeconds: 40, speed: "1.0x" });
+  second.progress.note({ processedSeconds: 8, speed: "2.0x" });
+  made.adopt("picture", first);
+  made.adopt("picture", second);
+
+  assert.equal(made.progressOf("picture", 20).processedSeconds, 40);
+  assert.equal(made.progressOf("picture", 60).processedSeconds, 208);
+});
+
+test("the last run's progress remains available after it ends", () => {
+  const made = orchestrator();
+  const progress = new RunProgress({ startSeconds: 100 });
+  progress.note({ processedSeconds: 5, speed: "1.5x" });
+  const run = { from: 25, to: 30, isAlive: false, state: "ENDED_COMPLETE", progress };
+  made.adopt("picture", run);
+  made.noteEnded({
+    address: "picture",
+    run,
+    ending: "complete",
+    because: "the assigned stretch was completed",
+    from: 25,
+    to: 30,
+    reached: 30,
+    livedMs: 1000,
+    normal: true,
+    lastError: ""
+  });
+
+  assert.equal(made.progressOf("picture").processedSeconds, 105);
+});