@torrent-tv/proxy 2.17.0 → 2.18.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.18.0
+
+- **New**: Copying the picture is no longer priced at nothing. It demuxes, re-encodes the audio and writes segments, and it is what runs BESIDE every rung warmed for a quality change — the field measured it at 7.92-8.02x, about an eighth of a second of work per second of video. The figure is not a constant: a session that is copying reports its own speed, and the reciprocal of that IS the cost, learned per file as the decode cost already is (median of recent readings, only from a run past its own start, never from a suspended one).
+- **New**: A rung is judged against the machine it will actually have. The cost of what the family is already committed to is added to the rung's own before the check, so the arithmetic of 2026-08-15 comes out as it did in the field: 0.125 for the copy plus about 1.05 for the 240p rung is more than the one second of work per second the machine has. Unmeasured means zero, so a host that has observed nothing is exactly as permissive as before.
+- **Fix**: A copy reading taken while the torrent is short is discarded. A re-encode near realtime may be the host's limit; a copy near realtime is a copy waiting for data, since copying runs at eight times realtime — and filing that as the price of copying would refuse rungs on the download's account. An audio rendition is excluded from this learning too: it carries no picture, and its speed is the price of a soundtrack, not of a copy.
+
 ## 2.17.0
 
 - **New**: The encoder is benchmarked on real footage instead of a generated test pattern, and measured by ffmpeg's own progress rather than by the clock around the process. The pattern has flat areas and no grain and encodes **1.23x** cheaper than film on the same machine and preset — an error that always points at offering a rung the host cannot hold. Timing whole runs was the second error: process startup is ~0.4 s, which put `fast` and `ultrafast` within 1.24x of each other when they differ by three times. The clip is decoded once to raw frames in a temp file (feeding them through a pipe measured the pipe: the fastest presets want hundreds of megabytes a second), each preset is read from the slope between two progress reports, and the run is stopped as soon as a second of it has been covered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/hls-session-manager.js

@@ -1194,6 +1194,15 @@ export class HlsSessionManager {
    * @type {Map<string, { costSec: number, version: number }>}
    */
   #observedDecodeCost = new Map();
+  /**
+   * What copying costs, per source file, learned the same way: `key ->
+   * { costSec, readings, version }`. A copy is what runs BESIDE a rung being
+   * warmed, and pricing it at nothing is what let a host be told it had a whole
+   * machine for the rung.
+   *
+   * @type {Map<string, { costSec: number, readings: number[], version: number }>}
+   */
+  #observedCopyCost = new Map();
   /** The previous reading of the machine, to compare the next one against. */
   #hostLoadSample = null;
 
@@ -4549,6 +4558,10 @@ export class HlsSessionManager {
       heights: ordered,
       ownHeight: own,
       playingHeight: playing,
+      // What the family is already spending while a rung is considered. The
+      // picture being COPIED is the common case and used to be priced at
+      // nothing; measured, it is about an eighth of the machine.
+      concurrentCostSec: this.#committedCostOf(owner),
       sourceWidth: Number(owner.sourceWidth) || 0,
       sourceHeight: Math.round(Number(owner.sourceHeight) || 0),
       fps: Number(owner.outputFps) || TRANSCODE_FPS,
@@ -4648,9 +4661,76 @@ export class HlsSessionManager {
     this.#learnDecodeCost(session, speed);
   }
 
+  /**
+   * What COPYING this file costs on this host, learned from a session that is
+   * doing it: seconds of work per second of video.
+   *
+   * A copy is not free. It demuxes, it re-encodes the audio, it writes
+   * segments, and it runs BESIDE every rung warmed for a quality change — so a
+   * budget that prices it at nothing predicts a machine that does not exist.
+   * The figure is the reciprocal of the speed the session reports, which is the
+   * measurement itself rather than a model of it.
+   *
+   * Median of recent readings, taken only from a run past its own start, for
+   * the same reasons as the decode cost beside it.
+   *
+   * @param {HlsSession} session
+   * @param {number} speed
+   */
+  async #learnCopyCost(session, speed) {
+    const runStartedAt = Number(session.encodeRunStartedAt);
+    if (!Number.isFinite(runStartedAt) || Date.now() - runStartedAt < DECODE_LEARNING_SETTLE_MS) {
+      return;
+    }
+    if (session.encoderPaused === true) {
+      return; // a suspended run reports a cumulative figure that is decaying
+    }
+    // Always asked, not only below realtime. A re-encode near 1x may be the
+    // host; a COPY near 1x is a copy waiting for the torrent, because copying
+    // is what a machine does at eight times realtime — and a starved reading
+    // filed as the price of copying would refuse rungs on the download's
+    // account.
+    if (await this.#classifyTranscodeBound(session) === "download") {
+      return;
+    }
+    const costSec = 1 / speed;
+    if (!(costSec > 0) || !Number.isFinite(costSec)) {
+      return;
+    }
+    const key = `${session.sourceKey}:${session.fileIndex}`;
+    const known = this.#observedCopyCost.get(key);
+    const readings = [...(known?.readings ?? []), costSec].slice(-DECODE_LEARNING_READINGS);
+    const sorted = [...readings].sort((left, right) => left - right);
+    const median = sorted[Math.floor(sorted.length / 2)];
+    if (known && Math.abs(median - known.costSec) / known.costSec < DECODE_LEARNING_CHANGE) {
+      this.#observedCopyCost.set(key, { ...known, readings });
+      return;
+    }
+    this.#observedCopyCost.set(key, { costSec: median, readings, version: (known?.version ?? 0) + 1 });
+    logger.info(
+      `transcode: ${session.fileName} copies at ${(1 / median).toFixed(2)}x on this host ` +
+        `(median of ${readings.length}, latest ${speed.toFixed(2)}x)`
+    );
+  }
+
   #learnDecodeCost(session, speed) {
-    if (session.transcodeVideo !== true || !(speed > 0)) {
-      return; // a copied video decodes nothing, so it says nothing about decoding
+    if (!(speed > 0)) {
+      return;
+    }
+    if (session.transcodeVideo !== true) {
+      // A copied video decodes nothing, so it says nothing about DECODING —
+      // but it says exactly what COPYING costs, which the budget has been
+      // treating as free. Field 2026-08-15: a copy ran at 7.92-8.02x, i.e.
+      // about an eighth of a second of work per second of video, while a rung
+      // warmed beside it needed the rest of the machine.
+      //
+      // An audio rendition also carries no video, and its speed is the cost of
+      // encoding a soundtrack — a different quantity that must not be filed
+      // under what copying the picture costs.
+      if (session.audioOnly !== true) {
+        void this.#learnCopyCost(session, speed);
+      }
+      return;
     }
     const runStartedAt = Number(session.encodeRunStartedAt);
     if (!Number.isFinite(runStartedAt) || Date.now() - runStartedAt < DECODE_LEARNING_SETTLE_MS) {
@@ -4788,6 +4868,28 @@ export class HlsSessionManager {
    * @param {{ heights: number[], ownHeight: number, sourceWidth: number, sourceHeight: number, fps: number, source: { megapixelsPerSecond: number, megabitsPerSecond: number } | null, transcodeVideo: boolean }} params
    * @returns {number[]}
    */
+  /**
+   * Seconds of work per second of video this family is ALREADY committed to,
+   * beside any rung being considered.
+   *
+   * Today that is the copy of the picture, where the video is copied and its
+   * cost has been observed. An encoded picture is not added: a viewer changing
+   * quality leaves the rung they are on, so the two do not overlap for long,
+   * and the warm-up that does overlap is bounded by the switch. An audio
+   * rendition is not added either, until its cost is measured the same way —
+   * counting it at a guess would refuse rungs on arithmetic nobody took.
+   *
+   * @param {HlsSession} session
+   * @returns {number}
+   */
+  #committedCostOf(session) {
+    if (session.transcodeVideo === true) {
+      return 0;
+    }
+    const observed = this.#observedCopyCost.get(`${session.sourceKey}:${session.fileIndex}`);
+    return observed && observed.costSec > 0 ? observed.costSec : 0;
+  }
+
   #sustainableHeights({
     heights,
     ownHeight,
@@ -4797,7 +4899,8 @@ export class HlsSessionManager {
     fps,
     source,
     transcodeVideo,
-    observedDecodeCostSec = null
+    observedDecodeCostSec = null,
+    concurrentCostSec = 0
   }) {
     const benchmark = this.softwarePresetBenchmark;
     if (!Array.isArray(benchmark) || benchmark.length === 0 || sourceHeight <= 0 || sourceWidth <= 0) {
@@ -4835,7 +4938,8 @@ export class HlsSessionManager {
         decodeModel: this.decodeCostModel,
         source,
         outputPixelsPerSec: width * height * fps,
-        observedDecodeCostSec
+        observedDecodeCostSec,
+        concurrentCostSec
       });
       if (sustainable) {
         kept.push(height);

package/services/hwaccel.js

@@ -1054,7 +1054,8 @@ export function canSustainOutput({
   decodeModel = null,
   source = null,
   outputPixelsPerSec,
-  observedDecodeCostSec = null
+  observedDecodeCostSec = null,
+  concurrentCostSec = 0
 }) {
   if (!Array.isArray(benchmark) || benchmark.length === 0) {
     // Nothing measured on this host: the budget cannot refuse what it cannot
@@ -1070,13 +1071,28 @@ export function canSustainOutput({
     // term the ladder is offered whole, exactly as it was before.
     return { speed: null, sustainable: true };
   }
-  const speed = predictedRealtimeSpeed({
+  const alone = predictedRealtimeSpeed({
     decodeModel,
     encodePixelsPerSec: cheapestPresetPixelsPerSec(benchmark),
     outputPixelsPerSec,
     source,
     observedDecodeCostSec: observed
   });
+  // What ELSE will be running while this rung is. A rung is never the only
+  // thing on the machine: the picture it accompanies is being copied or
+  // encoded, an audio track may have its own encoder, and a warm-up is two
+  // encoders by design. Measured on the addon host, a copy alone takes about an
+  // eighth of the machine per second of video, and the field case of
+  // 2026-08-15 adds up exactly: 0.125 for the copy plus ~1.05 for the rung is
+  // more than the one second per second the machine has, which is what was
+  // observed.
+  //
+  // Zero when nothing else is known to be running, or when nothing has been
+  // measured yet — then this is a LOWER bound on the cost and the check is as
+  // permissive as it was before.
+  const speed = alone === null || !(concurrentCostSec > 0)
+    ? alone
+    : 1 / (1 / alone + concurrentCostSec);
   if (speed === null) {
     return { speed: null, sustainable: true };
   }

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