@torrent-tv/proxy 2.16.0 → 2.18.0

package/test/concurrent-cost.test.js

@@ -0,0 +1,82 @@
+/**
+ * @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);
+});

package/test/encode-slope.test.js

@@ -0,0 +1,46 @@
+/**
+ * @file The slope that turns ffmpeg's progress reports into a preset's speed.
+ *
+ * Written against the faults a review found in it on 2026-08-15, each of which
+ * would have opened the quality ladder rather than closing it: a window of no
+ * width at all, and a position ffmpeg reports as the smallest signed 64-bit
+ * integer when it has none yet.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { slopeOf } from "../services/hwaccel.js";
+
+const at = (wallSec, outSec) => ({ wallSec, outSec });
+
+test("a steady run measures its own speed", () => {
+  assert.equal(slopeOf([at(1, 10), at(2, 14)]), 4);
+});
+
+test("a window of no width is refused, however tempting the numbers", () => {
+  // Two reports a millisecond apart: 0.042 s of video over 0.001 s of clock is
+  // 42x, on a host that may be doing 3x.
+  assert.equal(slopeOf([at(1.0, 10), at(1.001, 10.042)], 0.2), null);
+});
+
+test("a run that produced nothing between two reports says nothing", () => {
+  assert.equal(slopeOf([at(1, 10), at(3, 10)]), null);
+});
+
+test("one report is not a measurement", () => {
+  assert.equal(slopeOf([at(1, 10)]), null);
+  assert.equal(slopeOf([]), null);
+});
+
+test("an impossible speed is a fault, not a fast machine", () => {
+  // Nothing encodes 640x360 five thousand times realtime; a reading that says
+  // so is a measurement fault, and letting it through raises the bar every
+  // ladder decision is taken from.
+  assert.equal(slopeOf([at(1, 0), at(2, 5000)]), null);
+});
+
+test("the narrowest allowed window is honoured", () => {
+  assert.equal(slopeOf([at(1.0, 10), at(1.3, 11)], 0.5), null);
+  assert.ok(slopeOf([at(1.0, 10), at(1.6, 12)], 0.5) > 0);
+});