@torrent-tv/proxy 2.22.0 → 2.24.0

package/test/quality-variants.test.js

@@ -15,7 +15,7 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { computeSegmentBoundaries, HlsSessionManager } from "../services/hls-session-manager.js";
+import { computeSegmentBoundaries, costKindForSession, HlsSessionManager } from "../services/hls-session-manager.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const BASE_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
@@ -736,3 +736,69 @@ test("an audio track is prepared at the position the switch will land on", async
     "and the track is pointed at the switch position, one back for the preceding keyframe"
   );
 });
+
+test("a reading from a soundtrack is priced as one", () => {
+  // The fault this pins: an audio rendition reached no learner at all. One
+  // guard refused renditions a reading, and the only call that would have
+  // priced one sat behind a second guard its caller had already made — so a
+  // soundtrack ran for the whole film and was charged at nothing, which is the
+  // half of roadmap item 6 that was left owing.
+  assert.equal(costKindForSession({ audioOnly: true, transcodeVideo: false }), "audio");
+  assert.equal(
+    costKindForSession({ audioOnly: true, transcodeVideo: true }),
+    "audio",
+    "a rendition carries no picture, whatever the flag it inherited says"
+  );
+  assert.equal(costKindForSession({ transcodeVideo: true }), "decode");
+  assert.equal(costKindForSession({ transcodeVideo: false }), "copy");
+});
+
+test("a quality step being warmed is not refused by its own cost", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "warm-cost-"));
+  // The addon host's own figures, so the arithmetic below is the field's and
+  // not an invention. Without a benchmark the check returns every height
+  // untouched and a test over it would pass while proving nothing.
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    softwarePresetBenchmark: [
+      { preset: "fast", pixelsPerSec: 17.0e6 },
+      { preset: "ultrafast", pixelsPerSec: 67.5e6 }
+    ],
+    decodeCostModel: { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 }
+  });
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // A copied 1080p picture, and a 240p step warmed beside it for a switch —
+  // which is what every quality change does, two encoders on purpose.
+  const base = fakeSession({ id: BASE_ID, encodeHeight: 0, dirPath, transcodeVideo: false });
+  base.variantHeight = 1080;
+  // What this source costs to decode — 1080p24 at 8 Mbit/s, the field file.
+  // Without it nothing can be priced and every height comes back offerable for
+  // want of a measurement, which would make the assertion hold for the wrong
+  // reason.
+  base.sourceDecode = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
+  const warming = fakeSession({ id: VARIANT_ID, encodeHeight: 240, dirPath });
+  warming.variantHeight = 240;
+  warming.sourceDecode = base.sourceDecode;
+  base.variants = new Map([[240, VARIANT_ID]]);
+  warming.variantBases = new Set([BASE_ID]);
+  // Running, and running well: it says of itself that it holds twice realtime,
+  // i.e. half a second of work per second of video.
+  warming.ffmpeg = fakeEncoder();
+  warming.lastAloneSpeed = 2;
+  manager.sessionsById.set(BASE_ID, base);
+  manager.sessionsById.set(VARIANT_ID, warming);
+
+  const offered = manager.offeredHeights(base);
+
+  assert.ok(
+    offered.includes(240),
+    "charged its own cost while being judged, the step the viewer just asked for is dropped from the " +
+      "offer by the act of warming it — and its next segment 404s on a stream that is playing"
+  );
+});

package/test/run-graph-drift.test.js

@@ -0,0 +1,37 @@
+/**
+ * @file The drawing cannot disagree with the table.
+ *
+ * `docs/encode-run-state.md` is generated from `services/encode-run-state.js`.
+ * A picture kept beside the code drifts — this repository has the receipts —
+ * so the check is mechanical: regenerate it and compare. A behavioural change
+ * to the table that forgets `npm run graph` fails here, in the same commit.
+ */
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+import { GRAPH_DOC_PATH, renderRunGraphMarkdown } from "../scripts/render-run-graph.js";
+
+/**
+ * Line endings are not part of the comparison. Git is configured with
+ * `autocrlf=true` on the machine this is developed on, so the same file is LF
+ * in the index and CRLF in the working tree — and a test failing on that would
+ * point at the generator, whose output is always LF, and be unfixable by the
+ * remedy it suggests.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function withoutLineEndings(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+test("the committed picture is the one the table produces", () => {
+  const committed = readFileSync(GRAPH_DOC_PATH, "utf8");
+  assert.equal(
+    withoutLineEndings(committed),
+    withoutLineEndings(renderRunGraphMarkdown()),
+    "docs/encode-run-state.md is out of date — run `npm run graph` and commit the result"
+  );
+});

package/test/segment-serve-wiring.test.js

@@ -21,6 +21,7 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { ENCODE_RUN_STATE } from "../services/encode-run-state.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const MOVIE_TIMESCALE = 1000;
@@ -276,3 +277,48 @@ test("a segment is found in the run directory that produced it, newest run first
     "the newest run's output must win — the older file here is the 8-byte stub a killed run leaves"
   );
 });
+
+test("serving a run's own segment moves the run out of STARTING", async (t) => {
+  const { manager, session, dirPath } = await managerWithReadySegment();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // The table lives in `encode-run-state.js` and is tested there as a graph.
+  // What this pins is that a real serve REACHES it: a state nothing writes
+  // describes every run as still starting, for ever, and the log built on it
+  // would say so too.
+  session.runState = ENCODE_RUN_STATE.STARTING;
+  // Where the run in force is writing. The fixture's segments live directly in
+  // the session directory, which is exactly what a single run's directory is
+  // here.
+  session.runDirPath = dirPath;
+
+  await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+
+  assert.equal(session.runState, ENCODE_RUN_STATE.PRODUCING);
+});
+
+test("a segment left by an earlier run does not claim the new run has produced", async (t) => {
+  const { manager, session, dirPath } = await managerWithReadySegment();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  // A seek places the new run in a directory of its own; the previous run's
+  // segments stay servable and are served from theirs. They say nothing about
+  // what the run now starting has done — and a run believed to be producing is
+  // one the look-ahead may suspend and the seek path may wave through as
+  // "already covered by the running encode".
+  //
+  // Deliberately a segment ABOVE the new run's start index, because that is the
+  // case an index comparison gets wrong: after a backward seek the old run's
+  // output sits ahead of the new run's beginning.
+  session.runState = ENCODE_RUN_STATE.STARTING;
+  session.encodeStartIndex = 0;
+  session.runDirPath = path.join(dirPath, "run-7");
+
+  await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
+
+  assert.equal(session.runState, ENCODE_RUN_STATE.STARTING);
+});