@torrent-tv/proxy 2.100.1 → 2.100.2

package/package.json

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

package/server.js

@@ -892,6 +892,7 @@ export async function startProxyServer({
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         if (!params) return { kind: "needs-source" };
         if (timing) {
+          params.walkAccount = timing.walk ??= { lockMs: 0, reads: 0, bytes: 0 };
           params.onTimed = (_statement, waitedMs, readMs) => {
             timing.reads += 1;
             timing.queuedMs += waitedMs;
@@ -974,7 +975,9 @@ export async function startProxyServer({
         const startedAt = Date.now();
         void container.learnPackets({ from: source.input.from, to: source.input.to, trackIds: [...sounds] }, read).then(learned =>
           logger.info(`encode input #${from}..#${to} of ${output.outputKey}: soundtrack packets of track(s) ${[...sounds].join(",")} ` +
-            `over ${source.input.from.toFixed(3)}-${source.input.to.toFixed(3)}s ${learned ? "walked" : "not all walked"} from its copy in ${Date.now() - startedAt}ms`),
+            `over ${source.input.from.toFixed(3)}-${source.input.to.toFixed(3)}s ` +
+            (learned === "walked" ? "walked" : `not all walked (${learned === "memory" ? "memory refused" : "the copy does not hold the rest"})`) +
+            ` from its copy in ${Date.now() - startedAt}ms`),
         error => logger.warn(`encode input #${from}..#${to} of ${output.outputKey}: walking the soundtrack from its copy failed: ${error?.message ?? error}`));
       }
     },

package/services/encode/EncodeInputs.js

@@ -648,6 +648,9 @@ function describeTiming(timing, now) {
     `${timing.resolutions} resolution(s) ${timing.resolveMs}ms ` +
     `(${timing.reads} file read(s): queued ${timing.queuedMs}ms, reading ${timing.readMs}ms), ` +
     `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms` +
+    // Where a packet input's walk spent its read: waiting for the same
+    // track's earlier walks, or reading the file (r62, torrent-tv/meta#178).
+    (timing.walk ? `; packet walk waited ${timing.walk.lockMs}ms for its track and read ${timing.walk.reads} time(s), ${timing.walk.bytes} bytes of the file` : "") +
     (timing.openApproximate ? "; sized by the host's startup open, this output has not opened yet" : "");
 }
 

package/services/media/ContainerOrchestrator.js

@@ -215,7 +215,7 @@ export class ContainerOrchestrator {
         value = await container.readSourceRanges(params.packetInterval);
         if (value.kind !== "result") return { ...value, requestId };
       } else if (statement === "packets") {
-        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent });
+        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent, account: params.walkAccount });
         if (value === null) return { kind: "terminal", reason: "request-obsolete", requestId };
         await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);
       } else {

package/services/media/container/MatroskaContainer.js

@@ -789,8 +789,10 @@ export class MatroskaContainer extends Container {
    *   A walk whose request is no longer current stops between clusters and
    *   answers null. `readRange`, when given, is where this one walk reads
    *   instead of the file's own reader; what it does not hold is unavailable.
+   *   `account`, when given, is told how long each track's walk waited for
+   *   that track's earlier walks and what it read (`lockMs`, `reads`, `bytes`).
    */
-  async readPacketIndex(interval, { isCurrent, readRange } = {}) {
+  async readPacketIndex(interval, { isCurrent, readRange, account } = {}) {
     if (this.#packets) return this.#packets;
     const layout = await this.#segmentLayout();
     if (!layout) throw new Error("Matroska Segment is absent.");
@@ -810,7 +812,7 @@ export class MatroskaContainer extends Container {
     let whole = true;
     for (const track of requested) {
       const chain = await this.#readTrackPackets(layout, tracks, track, start, interval, isCurrent,
-        readRange ? strictReader(readRange, this.fileSize) : this.readRange);
+        readRange ? strictReader(readRange, this.fileSize) : this.readRange, account);
       if (!chain) return null;
       streams.set(track.trackNumber, chain.records);
       if (chain.reachesEnd) complete.add(track.trackNumber);
@@ -835,15 +837,17 @@ export class MatroskaContainer extends Container {
    *
    * @param {{ from: number, to: number, trackIds: number[] }} interval
    * @param {(start: number, end: number) => Buffer | null} readRange - Null where it does not hold the bytes.
-   * @returns {Promise<boolean>} Whether the interval's packets are recorded.
+   * @returns {Promise<"walked" | "missing" | "memory">} Whether the
+   *   interval's packets are recorded, or what stopped the walk: bytes the
+   *   copy does not hold, or memory refused.
    */
   async learnPackets(interval, readRange) {
     try {
-      return await this.readPacketIndex(interval, { readRange }) !== null;
+      return await this.readPacketIndex(interval, { readRange }) !== null ? "walked" : "missing";
     } catch (error) {
-      // What the copy does not hold, or memory refused: the sound's own walk
-      // reads it later, from where this one stopped.
-      if (isUnavailable(error) || error instanceof IndexMemoryUnavailable) return false;
+      // The sound's own walk reads the rest later, from where this one stopped.
+      if (isUnavailable(error)) return "missing";
+      if (error instanceof IndexMemoryUnavailable) return "memory";
       throw error;
     }
   }
@@ -861,13 +865,21 @@ export class MatroskaContainer extends Container {
    *
    * @returns {Promise<{ records: PacketRecordsChain, startAt: number, reachesEnd: boolean }>}
    */
-  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent, read) {
+  async #readTrackPackets(layout, tracks, track, start, interval, isCurrent, reader, account = null) {
     const id = track.trackNumber;
     const previous = this.#packetWalks.get(id) ?? Promise.resolve();
     let finished;
     const walk = previous.then(() => new Promise(resolve => { finished = resolve; }));
     this.#packetWalks.set(id, walk);
+    const waitedFrom = Date.now();
     await previous;
+    const read = account ? async (start, end) => {
+      const bytes = await reader(start, end);
+      account.reads += 1;
+      account.bytes += bytes.length;
+      return bytes;
+    } : reader;
+    if (account) account.lockMs += Date.now() - waitedFrom;
     try {
       const readings = this.#packetReadings.get(id) ?? [];
       this.#packetReadings.set(id, readings);