@torrent-tv/proxy 2.80.9 → 2.80.11

package/test/contention.test.js

@@ -10,7 +10,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { contentionPenalty, costWithContention, penaltiesFrom } from "../services/contention.js";
+import { contentionPenalty, costWithContention, penaltiesFrom } from "../services/encode/contention.js";
 
 /** The addon host's own readings. */
 const ALONE = 2.2;

package/test/decode-cost-fit.test.js

@@ -143,3 +143,60 @@ test("what a model prices a film at", () => {
   // Which is a decode speed of 1/cost — the figure the quality offer rests on.
   assert.ok(1 / cost > 1 && 1 / cost < 10, `decodes at ${(1 / cost).toFixed(2)}x`);
 });
+
+/**
+ * THE ORDERINGS, STATED WHERE THEY ARE DETERMINISTIC.
+ *
+ * What the quality offer needs of this model is not precision but ORDER: a
+ * bigger, richer, dearer-to-decode source must never be priced cheaper, because
+ * the model is asked about rungs nobody has decoded. That is a property of the
+ * fit, and it is a property of the fit whatever machine runs the test.
+ *
+ * These three used to be asserted over LIVE readings — decode two clips through
+ * real ffmpeg and require the smaller to come back faster. That measures the
+ * scheduler, not the code: four failures in one day, and the worst of them read
+ * 480p at 8.4x against 1080p at 20.8x, an inversion of two and a half times
+ * with nothing wrong. The readings themselves are unavailable to a test at all,
+ * since a clip that "said nothing" under load makes the whole benchmark answer
+ * with nothing.
+ */
+
+test("a bigger picture is priced dearer than a smaller one of the same bitrate", () => {
+  const model = fitDecodeCost(wellConditionedSet({ pixel: 0.0055, bitrate: 0.0099, constant: 0.057 }));
+  const big = decodeCostOf(model, { megapixelsPerSecond: (1920 * 1080 * FPS) / 1e6, megabitsPerSecond: 4 });
+  const small = decodeCostOf(model, { megapixelsPerSecond: (854 * 480 * FPS) / 1e6, megabitsPerSecond: 4 });
+
+  assert.ok(big > small, `1080p at ${big.toFixed(4)} s/s against 480p at ${small.toFixed(4)}`);
+});
+
+test("a thicker stream is priced dearer than a thin one of the same size", () => {
+  const model = fitDecodeCost(wellConditionedSet({ pixel: 0.0055, bitrate: 0.0099, constant: 0.057 }));
+  const pixels = (854 * 480 * FPS) / 1e6;
+  const thick = decodeCostOf(model, { megapixelsPerSecond: pixels, megabitsPerSecond: 9.5 });
+  const thin = decodeCostOf(model, { megapixelsPerSecond: pixels, megabitsPerSecond: 1.1 });
+
+  assert.ok(thick > thin, `9.5 Mbit/s at ${thick.toFixed(4)} s/s against 1.1 at ${thin.toFixed(4)}`);
+});
+
+test("a family measured to be dearer prices its own sources dearer", () => {
+  // Why the model is fitted per codec family at all: HEVC costs more than H.264
+  // for the same picture on the same machine, so a source that has to be
+  // re-encoded — which is usually one the browser could not decode — must be
+  // priced by its own family and not by H.264's.
+  const cheap = { pixel: 0.0055, bitrate: 0.0099, constant: 0.057 };
+  const dear = { pixel: 0.011, bitrate: 0.0198, constant: 0.114 };
+  const model = {
+    ...fitDecodeCost(wellConditionedSet(cheap)),
+    families: {
+      h264: fitDecodeCost(wellConditionedSet(cheap)),
+      hevc: fitDecodeCost(wellConditionedSet(dear))
+    }
+  };
+  const source = { megapixelsPerSecond: (854 * 480 * FPS) / 1e6, megabitsPerSecond: 1.1 };
+
+  assert.ok(
+    decodeCostOf(model, { ...source, codec: "hevc" }) >
+      decodeCostOf(model, { ...source, codec: "h264" }),
+    "the family chooses the terms, and the dearer family answers dearer"
+  );
+});

package/test/decode-cost.test.js

@@ -6,10 +6,19 @@
  * claiming the host cleared the bar 2.5 times over — the error on that rung was
  * 209 %. The decode term brings a controlled measurement to within 5 %.
  *
- * The first test runs the real benchmark against the shipped clips with the
- * real ffmpeg, because a fit that only ever runs against invented numbers can
- * be wrong in every way that matters (2.9.124: a module tested only through its
- * own exports missed the caller that never called it).
+ * WHAT IS ASSERTED HERE IS ARITHMETIC, over constants that were measured once
+ * on the addon host and written down. The live benchmark used to run here too —
+ * on the reasoning that a fit which only ever meets invented numbers can be
+ * wrong in every way that matters — and it could not be asserted about: a clip
+ * that "said nothing" under load makes the whole benchmark answer with nothing,
+ * so the very first line of that test failed by luck. The orderings it was for
+ * are held over the fit itself, deterministically, in `decode-cost-fit.test.js`.
+ *
+ * What no test covers as a result is the live path — lifting a clip out of its
+ * container, feeding it through the pipe, reading the slope. That is integration
+ * over real ffmpeg, and it belongs to a stand run before a release rather than
+ * to a check that measures whatever else the machine was doing (roadmap item
+ * 52).
  */
 
 import test from "node:test";
@@ -23,7 +32,6 @@ import { Output } from "../services/output/Output.js";
 import os from "node:os";
 import path from "node:path";
 import {
-  benchmarkDecodeCost,
   canSustainOutput,
   decodeSpeedFor,
   predictedRealtimeSpeed,
@@ -45,37 +53,6 @@ const ADDON_HOST_MODEL = { pixelTerm: 0.005555, bitrateTerm: 0.00990, constantTe
 // The film measured that day: 1920x1080 at 24 fps, about 8 Mbit/s.
 const MEASURED_FILM = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
 
-test("the fit comes out of the real clips, and predicts one of them back", async () => {
-  const model = await benchmarkDecodeCost({ ffmpegBin });
-
-  assert.ok(model, "the clips ship with the package and this host has ffmpeg");
-  assert.ok(model.pixelTerm > 0, "more pixels cannot decode faster");
-  assert.ok(Number.isFinite(model.bitrateTerm) && Number.isFinite(model.constantTerm));
-
-  // What the model must get right is how cost SCALES from one source to
-  // another — that is the whole of its job, since it is asked about rungs
-  // nobody has decoded. So: a bigger, richer source is never cheaper.
-  //
-  // Deliberately not a numeric bound. This suite runs its files in parallel and
-  // the benchmark is a live measurement, so the fit it produces depends on what
-  // else the machine was doing: on this desktop the same clips have solved to
-  // pixels+bitrate+constant, to pixels alone, and — under load — to a
-  // constant-dominated shape whose 720p/1080p ratio was 1.32 rather than the
-  // ~2.4 of a quiet run. That instability is real and is recorded against
-  // roadmap item 1; pinning a number here would only pin how busy the machine
-  // happened to be. What the FIGURES are worth is checked where it is quiet:
-  // against the addon host's recorded constants below, and against the real
-  // film in the field.
-  const clip720 = { megapixelsPerSecond: (1280 * 720 * 24) / 1e6, megabitsPerSecond: 2.248 };
-  const clip1080 = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 11.375 };
-  const ratio = decodeSpeedFor(model, clip720) / decodeSpeedFor(model, clip1080);
-
-  assert.ok(
-    ratio >= 1,
-    `720p at a fifth of the bitrate cannot decode slower than 1080p; the fit says ${ratio.toFixed(2)}x`
-  );
-});
-
 test("decode cost prices the film it was checked against", () => {
   const speed = decodeSpeedFor(ADDON_HOST_MODEL, MEASURED_FILM);
 

package/test/encode-orchestrator.test.js

@@ -15,7 +15,7 @@ import { EncodeRun } from "../services/encode/EncodeRun.js";
 import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
 import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
-import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
+import { penaltiesFrom } from "../services/encode/contention.js";
 
 // WHAT A SECOND ENCODER COSTS THE FIRST — measured, never a formula.
 //
@@ -25,7 +25,6 @@ import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
 // so nothing here invents a shape: beyond what was measured the reading is held
 // rather than extrapolated.
 const MEASURED_PENALTIES = penaltiesFrom(7.12, [{ others: 1, speed: 4.18 }]);
-const penaltyFor = (others) => contentionPenalty(others, MEASURED_PENALTIES).penalty;
 
 // What a start and a stop cost, measured on the same host: a spawn with its
 // input open is 0.12 s there.

package/test/encode-plan-viewers.test.js

@@ -31,7 +31,7 @@ import { EncodeRun } from "../services/encode/EncodeRun.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
 import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
 import { mapForViewer, mergeMaps, runsOf } from "../services/priority/PriorityMap.js";
-import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
+import { penaltiesFrom } from "../services/encode/contention.js";
 
 // WHAT A SECOND ENCODER COSTS THE FIRST — measured, never a formula.
 //
@@ -41,7 +41,6 @@ import { contentionPenalty, penaltiesFrom } from "../services/contention.js";
 // so nothing here invents a shape: beyond what was measured the reading is held
 // rather than extrapolated.
 const MEASURED_PENALTIES = penaltiesFrom(7.12, [{ others: 1, speed: 4.18 }]);
-const penaltyFor = (others) => contentionPenalty(others, MEASURED_PENALTIES).penalty;
 
 // What a start and a stop cost, measured on the same host: a spawn with its
 // input open is 0.12 s there.
@@ -195,7 +194,7 @@ function assertNoOverlap(made) {
 // ---------------------------------------------------------------- one viewer
 
 test("one viewer playing: one encoder, exactly where they are", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   assert.deepEqual(placements(made), [100], "at their own position, 400s / 4s");
@@ -206,7 +205,7 @@ test("one viewer playing: the encoder keeping up buys no second one", () => {
   // The peak moves forward on its own as they watch, and an encoder that stays
   // in front of it is never late. This is the case that must NOT spend a
   // process, and the one the old head-as-a-barrier rule got wrong.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   const [run] = made.runsOn(PICTURE);
@@ -223,7 +222,7 @@ test("one viewer playing: the encoder keeping up buys no second one", () => {
 });
 
 test("one viewer seeking far ahead: an encoder is placed there", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -241,7 +240,7 @@ test("one viewer paused: nothing is late, so no encoder is added", () => {
   // A paused viewer states the whole film at one undifferentiated rank and no
   // time by which any of it must exist. The encoder already working goes on
   // encoding the track; nothing justifies a second process.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -280,7 +279,7 @@ test("one viewer paused states no deadline anywhere", () => {
 test("two viewers close together share one encoder", () => {
   // Film both of them want is made once. This is what merging the map is for,
   // and it must survive the deadline being carried alongside the rank.
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 408 });
   made.reconcile();
@@ -293,7 +292,7 @@ test("two viewers close together share one encoder", () => {
 });
 
 test("two viewers far apart get an encoder each", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -308,7 +307,7 @@ test("two viewers far apart get an encoder each", () => {
 });
 
 test("two viewers: one seeking does not take the other's encoder", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   made.reconcile();
   // A speed has to be measured before a second encoder can be justified: how
@@ -338,7 +337,7 @@ test("two viewers: one seeking does not take the other's encoder", () => {
 });
 
 test("two viewers: one pausing leaves the other served", () => {
-  const { made, watches, leaves } = orchestrator();
+  const { made, watches } = orchestrator();
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 3000 });
   made.reconcile();
@@ -374,7 +373,7 @@ test("two viewers: the one who leaves takes nothing from the one who stays", ()
 // ------------------------------------------------------------- three viewers
 
 test("three viewers far apart get an encoder each when the machine affords it", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   watches("three", { atSeconds: 3600 });
@@ -397,7 +396,7 @@ test("three viewers, a machine that affords two: the budget binds, not the map",
   // machine can hold. Which two are served follows from the order the work is
   // taken in; what must not happen is a third process on a host that cannot
   // hold it, or two processes writing one number.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 2 });
+  const { made, watches } = orchestrator({ maxRuns: 2 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   watches("three", { atSeconds: 3600 });
@@ -413,7 +412,7 @@ test("three viewers, a machine that affords two: the budget binds, not the map",
 });
 
 test("three viewers: one seeks onto another, and the two of them share", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -436,7 +435,7 @@ test("three viewers: one seeks onto another, and the two of them share", () => {
 });
 
 test("three viewers: all paused, and no encoder is added for any of them", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -457,7 +456,7 @@ test("three viewers: all paused, and no encoder is added for any of them", () =>
 test("the plan is a function of the state: the same state twice gives the same answer", () => {
   // What stops a moving map from becoming a thrash: the decision is arithmetic
   // over the state, so a pass that finds nothing changed changes nothing.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 2000 });
   made.reconcile();
@@ -481,7 +480,7 @@ test("exactly realtime arrives exactly on time, and no second encoder is bought"
   // something quite different — `speed / (1 - speed)` divides by zero here and
   // claims the encoder stays ahead FOR EVER, which is the same answer arrived
   // at by nonsense.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(1);
@@ -525,7 +524,7 @@ test("two viewers arriving together on a cold output get one encoder, then are m
   // would take to reach the second viewer is not a known quantity. Buying a
   // process on that is buying it on no evidence, which is refused; one is placed
   // and the speed it reports is what justifies the next.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   watches("two", { atSeconds: 3000 });
   made.reconcile();
@@ -540,7 +539,7 @@ test("two viewers arriving together on a cold output get one encoder, then are m
 });
 
 test("an encoder comfortably faster than realtime is left to do the whole stretch", () => {
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   made.runsOn(PICTURE)[0].noteSpeed(6);
@@ -556,7 +555,7 @@ test("a swarm that feeds one encoder moves it to whoever is late, rather than se
   // the viewer left — so it is moved to the soonest number that IS due. Without
   // this the viewer who seeked was served by nobody at all: the run kept its
   // road because nothing covered what lay in front of IT.
-  const { made, watches, leaves } = orchestrator({ maxRuns: 3 });
+  const { made, watches } = orchestrator({ maxRuns: 3 });
   watches("one", { atSeconds: 400 });
   made.reconcile();
   const [run] = made.runsOn(PICTURE);