@torrent-tv/proxy 2.23.0 → 2.24.0

package/test/concurrent-cost.test.js

@@ -1,82 +1,138 @@
-/**
- * @file A rung is judged against the machine it will actually have.
- *
- * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
- * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
- * about 1.05, and the two together are more than the one second per second the
- * machine has. The budget priced the copy at nothing, offered the rung, and the
- * viewer watched it fail.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { canSustainOutput } from "../services/hwaccel.js";
-
-// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
-// 1080p24 at 2.6x — the addon host's own figures.
-const BENCHMARK = [
-  { preset: "fast", pixelsPerSec: 17.0e6 },
-  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
-];
-const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
-const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
-const RUNG_240P = 426 * 240 * 24;
-
-test("a rung is judged on the machine it will have, not on an empty one", () => {
-  const alone = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  const beside = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    // The picture is being copied beside it, at the cost the field measured.
-    concurrentCostSec: 0.125
-  });
-  assert.ok(alone.speed !== null && beside.speed !== null);
-  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
-});
-
-test("nothing else running leaves the answer exactly as it was", () => {
-  const withZero = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0
-  });
-  const without = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  assert.equal(withZero.speed, without.speed);
-});
-
-test("a host with nothing measured still refuses nothing", () => {
-  const answer = canSustainOutput({
-    benchmark: [],
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.125
-  });
-  assert.equal(answer.sustainable, true);
-  assert.equal(answer.speed, null);
-});
-
-test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
-  const answer = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.9
-  });
-  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
-  assert.equal(answer.sustainable, false);
-});
+/**
+ * @file A rung is judged against the machine it will actually have.
+ *
+ * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
+ * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
+ * about 1.05, and the two together are more than the one second per second the
+ * machine has. The budget priced the copy at nothing, offered the rung, and the
+ * viewer watched it fail.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { canSustainOutput } from "../services/hwaccel.js";
+
+// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
+// 1080p24 at 2.6x — the addon host's own figures.
+const BENCHMARK = [
+  { preset: "fast", pixelsPerSec: 17.0e6 },
+  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
+];
+const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
+const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
+const RUNG_240P = 426 * 240 * 24;
+
+test("a rung is judged on the machine it will have, not on an empty one", () => {
+  const alone = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  const beside = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // The picture is being copied beside it, at the cost the field measured.
+    concurrentCostSec: 0.125
+  });
+  assert.ok(alone.speed !== null && beside.speed !== null);
+  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
+});
+
+test("nothing else running leaves the answer exactly as it was", () => {
+  const withZero = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0
+  });
+  const without = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P
+  });
+  assert.equal(withZero.speed, without.speed);
+});
+
+test("a host with nothing measured still refuses nothing", () => {
+  const answer = canSustainOutput({
+    benchmark: [],
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  assert.equal(answer.sustainable, true);
+  assert.equal(answer.speed, null);
+});
+
+test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
+  const answer = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.9
+  });
+  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
+  assert.equal(answer.sustainable, false);
+});
+
+test("a soundtrack encoder is not free once it has been measured", () => {
+  // The second half of roadmap item 6. An audio rendition runs for as long as
+  // the picture does — it is a second encoder by construction, not an extra —
+  // and the budget counted it at nothing. Small beside a picture, and small is
+  // not zero: on a host where a rung needs almost the whole machine, this is
+  // the difference between offering it and refusing it.
+  const withoutAudio = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0.125
+  });
+  const withAudio = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // The copy, plus a soundtrack measured at about twenty times realtime.
+    concurrentCostSec: 0.125 + 0.05
+  });
+  assert.ok(
+    withAudio.speed < withoutAudio.speed,
+    "charging for the soundtrack must lower what the machine has left for the picture"
+  );
+});
+
+test("two pictures encoding at once are charged as two", () => {
+  // The warm-up that makes a quality switch seamless runs two encoders on
+  // purpose. Measured 2026-08-15: the new rung ran at 0.504x for its first four
+  // seconds, against 0.90-0.99x once it had the machine to itself and 1.58x
+  // predicted for an idle one. Priced as though it were alone, the budget
+  // describes a machine that does not exist at the moment the viewer switches.
+  const alone = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    concurrentCostSec: 0
+  });
+  const besideAnother = canSustainOutput({
+    benchmark: BENCHMARK,
+    decodeModel: DECODE_MODEL,
+    source: SOURCE,
+    outputPixelsPerSec: RUNG_240P,
+    // Another rung of the same family, already running at about realtime.
+    concurrentCostSec: 1 / 1.05
+  });
+  assert.ok(alone.sustainable, "the rung must be offerable on an idle machine, or the case is not the one meant");
+  assert.equal(
+    besideAnother.sustainable,
+    false,
+    "a machine already spending a second per second of video has nothing left for a second picture"
+  );
+});

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"
+  );
+});