@torrent-tv/proxy 2.95.9 → 2.95.11

package/package.json

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

package/server.js

@@ -494,7 +494,7 @@ export async function startProxyServer({
   });
   const indexMemory = new IndexMemory({
     reviseBudget: () => { void outputParts.machineBudget.revise().catch(error => logger.warn(`packet index budget: ${error.message}`)); },
-    changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); }
+    changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
   const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand }) => {
     const record = sourceRegistry.get(sourceKey);
@@ -531,6 +531,10 @@ export async function startProxyServer({
       onReadResult: async (statement, result, revision) => {
         if (revision.demand !== downloadMaps.epoch(sourceKey, fileIndex)) return;
         if (demand && !downloadMaps.wantsInterval(sourceKey, fileIndex, demand)) return;
+        if (statement === "keyframes" && result.kind === "result") {
+          keyframeTables.learn(params, { times: result.value?.times ?? null, tolerance: result.value?.tolerance ?? 0,
+            format: containerOrchestrator.known(sourceKey, fileIndex)?.formatName ?? "unrecognised" });
+        }
         const finished = mediaReads.record(params, statement, result, revision.storage, revision.memory);
         await downloadMaps.metadata({ sourceKey, fileIndex, statement: requestId ? `${statement}:${requestId}` : statement, result,
           ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}) });

package/services/encode/EncodeInputs.js

@@ -5,6 +5,7 @@ import { admitOriginalInput } from "./OriginalInput.js";
 export class EncodeInputs {
   #requests = new Map();
   #revision = 0;
+  #memoryRevision = 0;
   #held = 0;
   #allowed = 0;
   #wanted = new Map();
@@ -43,7 +44,13 @@ export class EncodeInputs {
   allow(bytes) {
     const changed = this.#allowed !== Math.max(0, bytes);
     this.#allowed = Math.max(0, bytes);
-    if (changed) this.#retryMemory();
+    if (changed) this.memoryChanged();
+  }
+
+  /** Metadata admission and input admission can change independently. */
+  memoryChanged() {
+    this.#memoryRevision++;
+    this.#retryMemory();
   }
 
   #retryMemory() {
@@ -112,6 +119,7 @@ export class EncodeInputs {
   #prepare(request) {
     request.pending = true;
     request.revision = this.#revision;
+    request.memoryRevision = this.#memoryRevision;
     request.promise = (async () => {
       const resolved = await this.#resolve(request.output, request.from, request.to);
       if (this.#requests.get(request.key) !== request) return;
@@ -133,7 +141,7 @@ export class EncodeInputs {
           return () => {
             if (!released) {
               released = true; this.#held -= bytes;
-              queueMicrotask(() => this.#retryMemory());
+              queueMicrotask(() => this.memoryChanged());
             }
           };
         }
@@ -149,7 +157,9 @@ export class EncodeInputs {
     }).finally(() => {
       request.pending = false;
       if (request.result?.kind !== "needs-memory") this.#wanted.delete(request.key);
-      if (this.#requests.get(request.key) === request && request.revision !== this.#revision &&
+      const changed = request.result?.kind === "needs-memory"
+        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision;
+      if (this.#requests.get(request.key) === request && changed &&
         request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
     });
   }

package/services/encode/EncodeRuns.js

@@ -986,7 +986,7 @@ export class EncodeRuns {
         if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         if (admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only" &&
-          session.spec.audio && !this.#host.servesAudioSeparately(session)) {
+          (admittedInput.original || session.spec.audio && !this.#host.servesAudioSeparately(session))) {
           try {
             const address = session.outputKey ?? "";
             const grid = session.timeline.published ?? session.timeline.boundaries;

package/services/encode/segment-formats/presentation-segment.js

@@ -9,7 +9,7 @@ export function presentationSegment(current, following, { from, to }) {
     const edit = own.edits.get(id);
     if (!edit) throw new Error("A segment track has no declared clock.");
     const samples = [...track.samples];
-    if (track.kind === "soun" && next?.tracks.has(id)) {
+    if (next?.tracks.has(id)) {
       const nextEdit = next.edits.get(id);
       if (!nextEdit || nextEdit.timescale !== edit.timescale) throw new Error("Adjacent segment clocks differ.");
       for (const sample of next.tracks.get(id).samples) {
@@ -18,18 +18,33 @@ export function presentationSegment(current, following, { from, to }) {
     }
     const start = BigInt(Math.round(from * Number(edit.timescale)));
     const end = BigInt(Math.round(to * Number(edit.timescale)));
-    const selected = samples.filter(sample => {
+    const wanted = samples.filter(sample => {
       const pts = sample.dts + sample.composition + edit.offset;
-      return pts < end && pts + sample.duration > start;
+      return pts < end && (track.kind === "vide" ? pts >= start : pts + sample.duration > start);
     });
+    if (!wanted.length) throw new Error("A presentation segment lacks required media.");
+    // An open-GOP picture before the cut can follow the next CRA in decode
+    // order. Retain the reference pictures through its last required DTS;
+    // dropping the CRA would make the recovered leading pictures undecodable.
+    const lastDecode = wanted.reduce((last, sample) => sample.dts > last ? sample.dts : last, -1n);
+    const firstDecode = wanted.reduce((first, sample) => first === null || sample.dts < first ? sample.dts : first, null);
+    const selected = track.kind === "vide" ? samples.filter(sample =>
+      sample.dts >= firstDecode && sample.dts <= lastDecode && sample.dts + sample.composition + edit.offset >= start) : wanted;
     selected.sort((left, right) => left.dts < right.dts ? -1 : left.dts > right.dts ? 1 : 0);
-    if (!selected.length) throw new Error("A presentation segment lacks required media.");
     tracks.push({ id, samples: selected });
   }
   const makeMoof = offset => box("moof", full("mfhd", 0, 0, u32(1)), ...tracks.map(track => {
-    const entries = track.samples.map(sample => Buffer.concat([
-      u32(Number(sample.duration)), u32(sample.bytes.length), u32(sample.flags), i32(Number(sample.composition))
-    ]));
+    let decodeTime = track.samples[0].dts;
+    const entries = track.samples.map(sample => {
+      // Removing leading pictures can leave a gap in decode timestamps.
+      // trun advances by durations only; retain each original presentation
+      // timestamp relative to the decode clock actually written here.
+      const composition = sample.dts + sample.composition - decodeTime;
+      decodeTime += sample.duration;
+      return Buffer.concat([
+        u32(Number(sample.duration)), u32(sample.bytes.length), u32(sample.flags), i32(Number(composition))
+      ]);
+    });
     const payload = Buffer.concat([u32(track.samples.length), i32(offset), ...entries]);
     offset += track.samples.reduce((bytes, sample) => bytes + sample.bytes.length, 0);
     const clock = Buffer.alloc(8);

package/services/media/KeyframeTables.js

@@ -2,6 +2,7 @@
 
 import { KeyframeTable } from "./container/KeyframeTable.js";
 import { isUnavailable } from "./container/unavailable.js";
+import { IndexMemoryUnavailable } from "./container/memory-unavailable.js";
 import { logger as defaultLogger } from "../../utils/logger.js";
 
 export class KeyframeTables {
@@ -123,6 +124,8 @@ export class KeyframeTables {
             `keyframe index "${logName}": not downloaded yet after ${Date.now() - startedMs}ms — ` +
               "read again when pieces of the file arrive"
           );
+        } else if (error instanceof IndexMemoryUnavailable) {
+          this.#logger.info(`keyframe index "${logName}": waiting for ${error.bytes} additional allocation bytes`);
         } else {
           this.#logger.warn(
             `keyframe index "${logName}": the read failed after ${Date.now() - startedMs}ms — ` +
@@ -183,7 +186,10 @@ export class KeyframeTables {
       const table = await this.read(params);
       return { table, arrived: table.answered };
     } catch (error) {
-      if (isUnavailable(error)) return { table: this.of(params), arrived: false };
+      if (isUnavailable(error) || error instanceof IndexMemoryUnavailable) {
+        const table = this.of(params);
+        return { table, arrived: table.answered };
+      }
       throw error;
     }
   }

package/services/media/container/AviContainer.js

@@ -11,6 +11,7 @@ import { ContainerTrack } from "../tracks/ContainerTrack.js";
 import { PacketIndex } from "./PacketIndex.js";
 import { openDmlPackets } from "./avi-open-dml.js";
 import { isUnavailable } from "./unavailable.js";
+import { IndexMemoryUnavailable } from "./memory-unavailable.js";
 import { Mpeg4PictureTiming } from "./mpeg4-picture-timing.js";
 import { MpegElementaryIndex } from "./mpeg-elementary-index.js";
 import { RetainedReads } from "./RetainedReads.js";
@@ -25,6 +26,7 @@ export class AviContainer extends Container {
   #tracks = null;
   #packets = null;
   #scan = null;
+  #indexed = null;
   #declarations = null;
   #workTags = null;
 
@@ -108,7 +110,7 @@ export class AviContainer extends Container {
   }
 
 
-  packetIndexBytes() { return (this.#packets ?? this.#scan?.index)?.allocatedBytes() ?? 0; }
+  packetIndexBytes() { return (this.#packets ?? this.#scan?.index ?? this.#indexed?.index)?.allocatedBytes() ?? 0; }
 
   static detect(head) {
     return isAvi(head);
@@ -221,6 +223,7 @@ export class AviContainer extends Container {
   async readPacketIndex(interval) {
     if (this.#packets) return this.#packets;
     if (this.#scan) return this.#readUnindexed(interval);
+    if (this.#indexed) return this.#readIndexed();
     const tracks = await this.readTracks();
     const { streams } = await this.#readHeaders();
     if (streams.some(stream => stream.indexChunks.length)) {
@@ -278,20 +281,30 @@ export class AviContainer extends Container {
     }
     if ((table.end - table.start) % 16 !== 0) throw new Error("AVI packet index entry is truncated.");
     const index = new PacketIndex({ packetMemory: this.packetMemory, deferMemory: true });
-    try {
     const clocks = new Map();
     const timings = new Map();
+    if (tracks.some(track => ["video", "audio", "subtitle"].includes(track.type) && !(track.timeBase > 0))) {
+      throw new Error("AVI stream time base is invalid.");
+    }
     for (const track of tracks) {
       if (!["video", "audio", "subtitle"].includes(track.type)) continue;
-      if (!(track.timeBase > 0)) throw new Error("AVI stream time base is invalid.");
       index.declareTrack(track.trackNumber, { type: track.type, codecId: track.codecId, codecRanges: streams[track.trackNumber].codecRanges });
       clocks.set(track.trackNumber, track.startTimeSeconds);
     }
-    let offsetBase = null;
-    for (let at = table.start; at < table.end; at += 16) {
+    this.#indexed = { index, clocks, timings, tracks, movi, table, offsetBase: null, at: table.start };
+    return this.#readIndexed();
+  }
+
+  async #readIndexed() {
+    const state = this.#indexed;
+    const { index, clocks, timings, tracks, movi, table } = state;
+    try {
+    index.flushPending();
+    for (; state.at < table.end;) {
+      const at = state.at;
       const entry = await this.readRange(at, at + 15);
       const chunkId = entry.toString("ascii", 0, 4);
-      if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId)) continue;
+      if (!/^[0-9]{2}(db|dc|wb)$/.test(chunkId)) { state.at += 16; continue; }
       const id = Number(chunkId.slice(0, 2));
       const track = tracks.find(track => track.trackNumber === id);
       if (!track || !clocks.has(id)) throw new Error("AVI packet refers to an undeclared stream.");
@@ -300,18 +313,19 @@ export class AviContainer extends Container {
       const length = entry.readUInt32LE(12);
       if (length === 0) {
         if (track.type === "video") { index.extendLastPresentation(id, track.timeBase); clocks.set(id, clocks.get(id) + track.timeBase); }
+        state.at += 16;
         continue;
       }
-      if (offsetBase === null) {
+      if (state.offsetBase === null) {
         for (const base of [movi.start, 0, movi.start + 4]) {
           const address = base + offset;
           if (address < movi.start + 4 || address + 8 + length > movi.end) continue;
           const probe = await this.readRange(address, address + 7);
-          if (probe.toString("ascii", 0, 4) === chunkId && probe.readUInt32LE(4) === length) { offsetBase = base; break; }
+          if (probe.toString("ascii", 0, 4) === chunkId && probe.readUInt32LE(4) === length) { state.offsetBase = base; break; }
         }
-        if (offsetBase === null) throw new Error("AVI packet index has no valid offset base.");
+        if (state.offsetBase === null) throw new Error("AVI packet index has no valid offset base.");
       }
-      const address = offsetBase + offset;
+      const address = state.offsetBase + offset;
       if (address < movi.start + 4 || address + 8 + length > movi.end) throw new Error("AVI indexed packet exceeds its media list.");
       const probe = await this.readRange(address, address + 7);
       if (probe.toString("ascii", 0, 4) !== chunkId || probe.readUInt32LE(4) !== length) throw new Error("AVI packet index disagrees with its chunk header.");
@@ -321,15 +335,21 @@ export class AviContainer extends Container {
       await this.#appendPacket(index, timings, track, { pts, duration, keyframe: track.type !== "video" || chunkId.endsWith("db") || !!(flags & 0x10),
         ranges: [[address + 8, address + 8 + length - 1]] });
       clocks.set(id, pts + duration);
+      // The pending facts own this entry even if their allocation must wait.
+      state.at += 16;
       index.flushPending();
     }
     for (const timing of timings.values()) timing.elementary?.complete();
     index.flushPending();
     for (const id of clocks.keys()) index.complete(id);
     this.#packets = index;
+    this.#indexed = null;
     return index;
     } catch (error) {
-      index.dispose();
+      if (!isUnavailable(error) && !(error instanceof IndexMemoryUnavailable)) {
+        index.dispose();
+        this.#indexed = null;
+      }
       throw error;
     }
   }