@torrent-tv/proxy 2.75.0 → 2.76.1

package/services/torrent-worker/container-tracks.js

@@ -205,22 +205,6 @@ async function readTracks(torrent, fileIndex, sourceKey, options) {
   }
 }
 
-/**
- * The audio tracks of one file, in the order ffmpeg numbers them `0:a:N`.
- *
- * @param {object} torrent
- * @param {number} fileIndex
- * @param {string} sourceKey
- * @param {{ prefetchEdges?: () => Promise<unknown> }} [options]
- * @returns {Promise<object[]>}
- */
-export async function containerAudioTracksOf(torrent, fileIndex, sourceKey, options = {}) {
-  const tracks = await containerTracksOf(torrent, fileIndex, sourceKey, options);
-  return tracks
-    .filter((track) => track.type === "audio")
-    .sort((left, right) => left.declaredIndex - right.declaredIndex);
-}
-
 /** Bytes of a file's head worth fetching before its track table is read. */
 export const CONTAINER_HEAD_BYTES = HEAD_BYTES;
 
@@ -300,16 +284,78 @@ export async function warmResumePosition(torrent, fileIndex, sourceKey, position
 }
 
 /**
- * What one file declares about itself: format, duration, and where its own
- * timeline begins.
+ * Where one file's keyframes are, from the container's own table.
+ *
+ * A property of immutable bytes, like the duration and the track list, and read
+ * here for the same reason they are: the container is cached per file, so the
+ * table is read ONCE however many sessions ask for it, and two sessions created
+ * in the same moment join one read instead of making two. That is the two-viewer
+ * case exactly — measured 2026-09-03, two pictures of one file were created 13 ms
+ * apart, and each read the table for itself over the proxy's own HTTP.
  *
- * The same header the track table is read from, and the container instance is
- * cached per file, so asking for this after the tracks costs no read at all.
- * It exists because the alternative was a second reader: the session manager
- * used to spawn an ffmpeg over the proxy's own HTTP to learn where a sidecar
- * soundtrack's timeline begins, and that read cost 8121 ms in the field on
- * 2026-09-03 while this layer had read the same header in 8 ms in the same
- * second.
+ * It decides which branch a copy takes: a picture can only be cut where the
+ * source already has a keyframe, so a file with no readable index is re-encoded
+ * instead. That decision belongs to the FILE, and it is the same for everybody
+ * watching it.
+ *
+ * @param {object} torrent
+ * @param {number} fileIndex
+ * @param {string} sourceKey
+ * @param {{ prefetchEdges?: () => Promise<unknown> }} [options]
+ * @returns {Promise<{ times: number[], tolerance: number } | null>}
+ */
+export async function containerKeyframesOf(torrent, fileIndex, sourceKey, options = {}) {
+  const file = torrent?.files?.[fileIndex];
+  if (!file || !Number.isFinite(file.length) || file.length <= 0) {
+    return null;
+  }
+  if (typeof options.prefetchEdges === "function") {
+    try {
+      await options.prefetchEdges();
+    } catch {
+      // A prefetch that failed is not a reason to skip the read: the read
+      // fetches what it needs itself, only more slowly.
+    }
+  }
+  const readRange = async (start, end) =>
+    readFetching(file, start, Math.min(end, file.length - 1));
+  const startedAt = Date.now();
+  const params = {
+    sourceKey,
+    fileIndex,
+    readRange,
+    fileSize: file.length,
+    label: String(file.name ?? "")
+  };
+  try {
+    const index = await containerOrchestrator.getKeyframeIndex(params);
+    // Which container answered, reported whether or not it produced anything:
+    // how often an index disagrees with its own file is a question about the
+    // CONTAINER, and a measurement that does not say which one cannot answer
+    // it. Free — the container is the cached one that has just read the table.
+    const format = (await containerOrchestrator.getContainer(params))?.formatName ?? "unrecognised";
+    const times = Array.isArray(index?.times) && index.times.length > 0 ? index.times : null;
+    logger.info(
+      `container-keyframes: "${String(file.name).slice(0, 40)}" ` +
+      (times
+        ? `${times.length} keyframes from the ${format} index in ${Date.now() - startedAt}ms`
+        : `has no readable index (${format}, ${Date.now() - startedAt}ms)`)
+    );
+    return {
+      times,
+      format,
+      tolerance: Number.isFinite(index?.tolerance) ? index.tolerance : 0
+    };
+  } catch (error) {
+    logger.warn(
+      `container-keyframes: "${String(file.name).slice(0, 40)}" could not be read: ${error?.message ?? error}`
+    );
+    return null;
+  }
+}
+
+/**
+ * What one file declares about itself as a whole.
  *
  * @param {object} torrent
  * @param {number} fileIndex
@@ -357,21 +403,3 @@ export async function containerMediaInfoOf(torrent, fileIndex, sourceKey, option
     return null;
   }
 }
-
-/**
- * Forget one file's tracks, or every file of a source.
- *
- * @param {string} sourceKey
- * @param {number} [fileIndex]
- */
-export function forgetContainerTracks(sourceKey, fileIndex) {
-  if (fileIndex === undefined) {
-    for (const key of [...byFile.keys()]) {
-      if (key.startsWith(`${sourceKey}:`)) {
-        byFile.delete(key);
-      }
-    }
-    return;
-  }
-  byFile.delete(`${sourceKey}:${fileIndex}`);
-}

package/services/torrent-worker/pool-adapter.js

@@ -239,6 +239,24 @@ export class WorkerTorrentPool {
     return answer?.info ?? null;
   }
 
+  /**
+   * Where one file's keyframes are, from the container's own table. Null when
+   * this file has no readable index — which is a final answer about the file,
+   * and the reason a copy of it has to be re-encoded instead.
+   *
+   * @param {object} torrent
+   * @param {number} fileIndex
+   * @returns {Promise<{ times: number[], tolerance: number } | null>}
+   */
+  async getContainerKeyframes(torrent, fileIndex) {
+    const sourceKey = torrent?.sourceKey;
+    if (!sourceKey) {
+      return null;
+    }
+    const answer = await this.#client.getContainerKeyframes({ sourceKey, fileIndex });
+    return answer?.index ?? null;
+  }
+
   /**
    * The audio tracks one file declares, in the order ffmpeg numbers them
    * `0:a:N`.

package/services/torrent-worker/protocol.js

@@ -88,6 +88,13 @@ export const Command = {
    * own HTTP reading the same bytes again.
    */
   CONTAINER_MEDIA_INFO: "container-media-info",
+  /**
+   * Where a file's keyframes are, from the container's own table. A property of
+   * immutable bytes, read once per file by the same container that answers the
+   * two above — and the answer decides whether a picture can be copied at all,
+   * which must be the same answer for every viewer of that file.
+   */
+  CONTAINER_KEYFRAMES: "container-keyframes",
   /**
    * Start fetching the region a viewer is about to resume at, named in seconds
    * and turned into bytes here, where the file's own duration can be read.