@torrent-tv/proxy 2.101.19 → 2.101.21

package/package.json

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

package/routes/stream/get.js

@@ -7,6 +7,7 @@
  */
 
 import { open } from "node:fs/promises";
+import { Readable } from "node:stream";
 import { parseRange } from "../../utils/parse-range.js";
 import { logger } from "../../utils/logger.js";
 
@@ -109,49 +110,66 @@ function wholeFileFor(torrentPool, sourceKey, fileIndex) {
 }
 
 /**
- * Open the whole file a response under way can continue from, if there is one.
+ * Acquire the whole file a response can continue from, if there is one.
  *
- * Any failure to open it leaves the response on the torrent, which can still
+ * Any failure to acquire it leaves the response on the torrent, which can still
  * answer; a file the disk owner removed is also forgotten here, as the route
  * does before headers.
  *
- * @param {{ wholeFiles?: Map<string, { path: string, length: number, name: string }> }} torrentPool
+ * @param {{ wholeFiles?: Map<string, { path: string, length: number, name: string }>, acquireWholeFile: (source: { sourceKey: string, fileIndex: number }) => Promise<{ length: number, stream: (start: number, end: number, onRead: (length: number) => void) => import("node:stream").Readable | null, release: () => Promise<unknown> } | null> }} torrentPool
  * @param {string} sourceKey
  * @param {number} fileIndex
  * @param {number} length - The length the response was promised for.
- * @returns {Promise<import("node:fs/promises").FileHandle | null>}
+ * @returns {Promise<{ length: number, stream: (start: number, end: number, onRead: (length: number) => void) => import("node:stream").Readable | null, release: () => Promise<unknown> } | null>}
  */
-async function openWholeFileToContinue(torrentPool, sourceKey, fileIndex, length) {
+async function acquireWholeFileRead(torrentPool, sourceKey, fileIndex, length) {
   const whole = wholeFileFor(torrentPool, sourceKey, fileIndex);
   if (!whole || whole.length !== length) {
     return null;
   }
   try {
-    return await open(whole.path, "r");
+    const read = await torrentPool.acquireWholeFile({ sourceKey, fileIndex });
+    if (!read) {
+      forgetWholeFile(torrentPool, sourceKey, fileIndex, whole);
+      return null;
+    }
+    if (read.length !== length) {
+      await read.release();
+      forgetWholeFile(torrentPool, sourceKey, fileIndex, whole);
+      return null;
+    }
+    return read;
   } catch (error) {
     if (error.code === "ENOENT") {
-      const key = `${sourceKey.slice("torrent:".length).toLowerCase()}/${fileIndex}`;
-      if (torrentPool.wholeFiles.get(key) === whole) torrentPool.wholeFiles.delete(key);
+      forgetWholeFile(torrentPool, sourceKey, fileIndex, whole);
     }
     return null;
   }
 }
 
+function forgetWholeFile(torrentPool, sourceKey, fileIndex, whole) {
+  const key = `${sourceKey.slice("torrent:".length).toLowerCase()}/${fileIndex}`;
+  if (torrentPool.wholeFiles?.get(key) === whole) torrentPool.wholeFiles.delete(key);
+}
+
 /**
  * Write bytes `from`..`end` of an open file to a response, each write waited
  * for, and close the file.
  *
  * @param {import("node:http").ServerResponse} raw
- * @param {import("node:fs/promises").FileHandle} handle
+ * @param {{ stream: (start: number, end: number, onRead: (length: number) => void) => import("node:stream").Readable | null, release: () => Promise<unknown> }} read
  * @param {number} from - Inclusive.
  * @param {number} end - Inclusive.
  * @param {(length: number) => void} onWritten
  * @returns {Promise<number>} Bytes written.
  */
-async function writeFromWholeFile(raw, handle, from, end, onWritten) {
+async function writeFromWholeFile(raw, read, from, end, onWritten) {
   let written = 0;
+  let stream = null;
   try {
-    for await (const chunk of handle.createReadStream({ start: from, end, autoClose: false })) {
+    stream = read.stream(from, end, () => {});
+    if (!stream) throw new Error("Completed file did not provide the admitted range.");
+    for await (const chunk of stream) {
       if (raw.writableEnded || raw.destroyed) {
         break;
       }
@@ -162,7 +180,8 @@ async function writeFromWholeFile(raw, handle, from, end, onWritten) {
       onWritten(chunk.length);
     }
   } finally {
-    await handle.close().catch(() => undefined);
+    stream?.destroy();
+    await read.release();
   }
   return written;
 }
@@ -173,35 +192,41 @@ async function writeFromWholeFile(raw, handle, from, end, onWritten) {
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
  * @param {{ path: string, length: number, name: string }} file
- * @param {import("node:fs/promises").FileHandle} handle - Already open; closed for HEAD.
+ * @param {{ stream: (start: number, end: number, onRead: (length: number) => void) => import("node:stream").Readable | null, release: () => Promise<unknown> }} read
  * @returns {Promise<void> | void}
  */
-function serveWholeFile(req, reply, file, handle) {
+function serveWholeFile(req, reply, file, read) {
   const disposition = `inline; filename*=UTF-8''${encodeURIComponent(file.name)}`;
-  if (req.method === "HEAD") {
-    reply.hijack();
-    reply.raw.writeHead(200, {
-      "Accept-Ranges": "bytes",
-      "Content-Type": "application/octet-stream",
-      "Content-Length": String(file.length),
-      "Content-Disposition": disposition
-    });
-    reply.raw.end();
-    return;
-  }
   reply.header("Accept-Ranges", "bytes");
   reply.header("Content-Type", "application/octet-stream");
   reply.header("Content-Disposition", disposition);
   const range = parseRange(req.headers.range, file.length);
+  if (file.length === 0) {
+    reply.header("Content-Length", "0");
+    void read.release().catch(() => undefined);
+    return reply.send(Readable.from([]));
+  }
+  const start = range?.start ?? 0;
+  const end = range?.end ?? file.length - 1;
+  const stream = read.stream(start, end, () => {});
+  if (!stream) {
+    void read.release().catch(() => undefined);
+    return null;
+  }
   if (!range) {
     reply.header("Content-Length", String(file.length));
-    return reply.send(handle.createReadStream());
+  } else {
+    reply.code(206);
+    reply.header("Content-Length", String(end - start + 1));
+    reply.header("Content-Range", `bytes ${start}-${end}/${file.length}`);
+  }
+  void read.release().catch(() => undefined);
+  try {
+    return reply.send(stream);
+  } catch (error) {
+    stream.destroy();
+    throw error;
   }
-  const { start, end } = range;
-  reply.code(206);
-  reply.header("Content-Length", String(end - start + 1));
-  reply.header("Content-Range", `bytes ${start}-${end}/${file.length}`);
-  return reply.send(handle.createReadStream({ start, end }));
 }
 
 export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool, noteInputBytes = null, noteInputWaiting = null }) {
@@ -224,23 +249,36 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
   // nothing the torrent would have told us.
   const whole = wholeFileFor(torrentPool, sourceKey, fileIndex);
   if (whole) {
-    let handle;
-    try {
-      // Open before committing headers: the disk owner may have removed an
-      // announced file. An open descriptor also preserves a live POSIX read.
-      handle = await open(whole.path, "r");
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      const key = `${sourceKey.slice("torrent:".length).toLowerCase()}/${fileIndex}`;
-      if (torrentPool.wholeFiles.get(key) === whole) torrentPool.wholeFiles.delete(key);
-    }
-    if (handle) {
-      if (req.method === "HEAD") await handle.close();
+    if (req.method === "HEAD") {
+      let handle;
       try {
-        return serveWholeFile(req, reply, whole, handle);
+        handle = await open(whole.path, "r");
       } catch (error) {
-        await handle.close().catch(() => undefined);
-        throw error;
+        if (error.code !== "ENOENT") throw error;
+        forgetWholeFile(torrentPool, sourceKey, fileIndex, whole);
+      }
+      if (handle) {
+        await handle.close();
+        reply.hijack();
+        reply.raw.writeHead(200, {
+          "Accept-Ranges": "bytes",
+          "Content-Type": "application/octet-stream",
+          "Content-Length": String(whole.length),
+          "Content-Disposition": `inline; filename*=UTF-8''${encodeURIComponent(whole.name)}`
+        });
+        reply.raw.end();
+        return;
+      }
+    } else {
+      const read = await acquireWholeFileRead(torrentPool, sourceKey, fileIndex, whole.length);
+      if (read) {
+        try {
+          const sent = serveWholeFile(req, reply, whole, read);
+          if (sent) return sent;
+        } catch (error) {
+          await read.release().catch(() => undefined);
+          throw error;
+        }
       }
     }
   }
@@ -338,7 +376,7 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
             fragment.release();
             break;
           }
-          continueFrom = await openWholeFileToContinue(torrentPool, sourceKey, fileIndex, file.length);
+          continueFrom = await acquireWholeFileRead(torrentPool, sourceKey, fileIndex, file.length);
           if (continueFrom) {
             fragment.release();
             break;
@@ -368,7 +406,7 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
         }
       } catch (error) {
         if (sent >= contentLength || req.raw.aborted || reply.raw.destroyed) throw error;
-        continueFrom = await openWholeFileToContinue(torrentPool, sourceKey, fileIndex, file.length);
+        continueFrom = await acquireWholeFileRead(torrentPool, sourceKey, fileIndex, file.length);
         if (!continueFrom) throw error;
       }
       if (continueFrom) {

package/services/encode/Renditions.js

@@ -43,8 +43,11 @@ export class Renditions {
    */
   #moveWaitsSaid = new Map();
 
+  /** Viewers waiting for a preset's measured speed before a quality step up. @type {Set<string>} */
+  #presetSpeedWaitSaid = new Set();
+
   /**
-   * @param {object} host - `viewerSecondsOn`, `audioStartSecondsFor`, `activeOutputFor`, `viewersOf`, `audioRenditionName`, `logger`, `placeViewer`, `viewerLeaves`, `createOrGetSession`, `planEncodersSoon`, `disposeSession`, `viewerPositionOf`, `encodeRuns`, `fileStartTimeReads`, `getCachedAudioTracks`, `getCachedMediaInfo`, `getContainerMediaInfo`, `localBaseUrl`, `outputTimes`, `outputs`, `quality`, `qualityOffer`, `segmentDurationSec`, `sourceFiles`, `viewers`, `generationOfRequest`, `givenOutputOf`, `noteGivenOutput`, `chosenOutputOf`, `chooseOutput`, `storedPieceReady`, `headersCompatible`, `audioChoiceOf`, `linkMbpsOf`, `qualityModeOf`, `noteServingVerdict`, `limitsFor`, `heightsChosenAs`, `highestGivenSegmentOf`, `sameHeightSwitchOf`, `noteSameHeightSwitch`, `switchingOnto`, `switchingFrom`, `segmentClosed`, `secondsUntilClosed`, `invalidateWaits`, `bufferedSecondsOf`, `minimumBufferSecondsFor`
+   * @param {object} host - `viewerSecondsOn`, `audioStartSecondsFor`, `activeOutputFor`, `viewersOf`, `audioRenditionName`, `logger`, `placeViewer`, `viewerLeaves`, `createOrGetSession`, `planEncodersSoon`, `disposeSession`, `viewerPositionOf`, `encodeRuns`, `fileStartTimeReads`, `getCachedAudioTracks`, `getCachedMediaInfo`, `getContainerMediaInfo`, `localBaseUrl`, `outputTimes`, `outputs`, `quality`, `qualityOffer`, `segmentDurationSec`, `sourceFiles`, `viewers`, `generationOfRequest`, `givenOutputOf`, `noteGivenOutput`, `chosenOutputOf`, `chooseOutput`, `storedPieceReady`, `headersCompatible`, `audioChoiceOf`, `linkMbpsOf`, `qualityModeOf`, `noteServingVerdict`, `limitsFor`, `heightsChosenAs`, `highestGivenSegmentOf`, `sameHeightSwitchOf`, `noteSameHeightSwitch`, `switchingOnto`, `switchingFrom`, `segmentClosed`, `secondsUntilClosed`, `invalidateWaits`, `bufferedSecondsOf`, `minimumBufferSecondsFor`, `processingSpeedOf`, `requiredSpeedOf`
    */
   constructor(host) {
     this.#host = host;
@@ -1052,6 +1055,25 @@ export class Renditions {
         return;
       }
     }
+    // A quality step up may choose a slower encoding preset. The benchmark is
+    // only a forecast; keep the current output until this candidate has closed
+    // pieces at the source's required speed. A step down is urgent and must
+    // not wait on a measurement from the output meant to rescue playback.
+    if (move.direction === "up" && move.changes === "preset" && prepared.spec?.transcodesVideo) {
+      const speed = this.#host.processingSpeedOf?.(prepared) ?? null;
+      const required = this.#host.requiredSpeedOf?.(prepared) ?? 1;
+      if (!Number.isFinite(speed) || speed < required) {
+        if (!this.#presetSpeedWaitSaid.has(consumerId)) {
+          this.#presetSpeedWaitSaid.add(consumerId);
+          this.#host.logger.info(
+            `transcode ${base.id} keeps ${consumerId} on ${current.outputKey} while ${prepared.outputKey} ` +
+            `proves its preset at ${Number.isFinite(speed) ? `${speed.toFixed(2)}x` : "an unmeasured speed"}; ` +
+            `requires ${required.toFixed(2)}x`
+          );
+        }
+        return;
+      }
+    }
     // The player fetches the fMP4 init once and decodes every later fragment
     // against it. Changing bitrate outputs is safe only when the prepared
     // output's init says the same thing to that decoder. The new segment is
@@ -1151,6 +1173,7 @@ export class Renditions {
    */
   #completeSameHeightSwitch(base, consumerId, move, prepared, current, next) {
     this.#moveWaitsSaid.delete(consumerId);
+    this.#presetSpeedWaitSaid.delete(consumerId);
     for (const height of move.askedHeights) {
       this.#choose(consumerId, height, prepared, base);
     }
@@ -1189,6 +1212,7 @@ export class Renditions {
    */
   #cancelSameHeightSwitch(base, consumerId, reason) {
     this.#moveWaitsSaid.delete(consumerId);
+    this.#presetSpeedWaitSaid.delete(consumerId);
     const move = this.#host.sameHeightSwitchOf(consumerId);
     if (!move) {
       return;

package/services/server/wire-outputs.js

@@ -457,6 +457,7 @@ export function wireOutputs({
     presetLadder: () => (parts.encoders.current?.kind === "software" && Array.isArray(parts.softwarePresetBenchmark)
       ? parts.softwarePresetBenchmark.map((entry) => entry.preset) : []),
     presetSpeedOf: (output, preset) => parts.encodeCost.presetSpeedOf(output, preset, { segmentSeconds: parts.segmentDurationSec }),
+    processingSpeedOf: (output) => parts.encodeCost.latestSpeedReadingOf(output)?.speed ?? null,
     // The price a move was decided at, given to an output with no measured
     // piece: one already measured stands on its readings, and an output that
     // runs was priced with its own cost counted beside the one on screen.