@torrent-tv/proxy 2.105.2 → 2.105.4

package/package.json

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

package/services/media/container/AviContainer.js

@@ -18,6 +18,7 @@ import { readAviIndex } from "./avi-index.js";
 import { isUnavailable } from "./unavailable.js";
 import { Mpeg4PictureTiming } from "./mpeg4-picture-timing.js";
 import { MpegElementaryIndex } from "./mpeg-elementary-index.js";
+import { ac3Frame } from "./ac3-frame.js";
 import { RetainedReads } from "./RetainedReads.js";
 import { OutsideReadableEdges, edgeReader, emptyWorkTags, text, textList, yearOf } from "./work-tags.js";
 
@@ -208,8 +209,14 @@ export class AviContainer extends Container {
    * ones, and the swarm was asked for the picture's next piece only after it
    * (torrent-tv/meta#178).
    */
-  packetTableWouldWait() {
+  packetTableWouldWait(interval = null) {
     if (!this.#index || this.#packets || this.#scan) return false;
+    if (interval?.trackIds?.length) {
+      const tracks = this.#tracks ?? [];
+      const selected = tracks.filter(track => interval.trackIds.includes(track.trackNumber));
+      if (selected.length === interval.trackIds.length && selected.length === 1 && selected[0].type === "audio" &&
+        selected[0].codecId === "ac3") return false;
+    }
     return this.#soundPacketsRefused === null || this.packetMemory?.fits?.(this.#soundPacketsRefused) !== false;
   }
 
@@ -414,7 +421,16 @@ export class AviContainer extends Container {
   }
 
   async readPacketIndex(interval) {
-    if (this.#packets) return this.#packets;
+    if (this.#packets) {
+      if (this.#index && interval?.trackIds?.length) {
+        const tracks = await this.readTracks();
+        const selected = tracks.filter(track => interval.trackIds.includes(track.trackNumber));
+        if (selected.length === 1 && selected[0].type === "audio" && selected[0].codecId === "ac3") {
+          return this.#indexedAc3PacketsOf(this.#index, selected[0], interval);
+        }
+      }
+      return this.#packets;
+    }
     if (this.#scan) return this.#readUnindexed(interval);
     // A picture of a file with an index is read by FFmpeg from the original
     // bytes (torrent-tv/meta#151). Its SOUND is not: the index states every
@@ -424,6 +440,12 @@ export class AviContainer extends Container {
     // copied 2.3 GB for 0.19 GB of its own (torrent-tv/meta#166).
     const indexed = await this.#readIndex();
     if (indexed) {
+      const tracks = await this.readTracks();
+      const selected = interval?.trackIds?.length
+        ? tracks.filter(track => interval.trackIds.includes(track.trackNumber)) : [];
+      if (selected.length === 1 && selected[0].type === "audio" && selected[0].codecId === "ac3") {
+        return this.#indexedAc3PacketsOf(indexed, selected[0], interval);
+      }
       // A refusal of memory for the table is kept for as long as the memory's
       // owner says the same reservation still would not fit. Not kept, the
       // next reader walked the index, counted the packets and was refused
@@ -463,6 +485,68 @@ export class AviContainer extends Container {
     return this.#readUnindexed(interval);
   }
 
+  /** Parse only the indexed AC-3 blocks needed for one audio interval. */
+  async #indexedAc3PacketsOf(index, track, interval) {
+    const stream = index.packets[track.trackNumber];
+    if (!stream?.count) throw new Error("Indexed AVI AC-3 track has no packets.");
+    const read = new Map();
+    const bytesAt = async at => {
+      if (read.has(at)) return read.get(at);
+      const length = stream.lengths[at];
+      const bytes = length ? await this.readRange(stream.starts[at], stream.starts[at] + length - 1) : Buffer.alloc(0);
+      read.set(at, bytes);
+      return bytes;
+    };
+    const chainAt = async start => {
+      let bytes = Buffer.alloc(0), cursor = 0, at = start, frames = 0;
+      while (frames < 3 && at < stream.count && bytes.length < 32 * 1024) {
+        bytes = Buffer.concat([bytes, await bytesAt(at++)]);
+        while (bytes.length - cursor >= 7 && frames < 3) {
+          if (bytes[cursor] !== 0x0b || bytes[cursor + 1] !== 0x77) return false;
+          let frame;
+          try { frame = ac3Frame(bytes.subarray(cursor)); }
+          catch { return false; }
+          if (bytes.length - cursor < frame.size) break;
+          cursor += frame.size;
+          frames++;
+        }
+      }
+      return frames === 3;
+    };
+
+    const anchor = stream.atOrBefore(interval.from);
+    let first = -1, scannedBytes = 0;
+    for (let at = anchor; at >= 0 && scannedBytes < 128 * 1024; at--) {
+      const bytes = await bytesAt(at);
+      scannedBytes += bytes.length;
+      if (bytes.length >= 7 && bytes[0] === 0x0b && bytes[1] === 0x77 && await chainAt(at)) {
+        first = at;
+        break;
+      }
+    }
+    if (first < 0) throw new Error("Indexed AVI AC-3 has no complete frame chain near the requested interval.");
+
+    const elementary = new MpegElementaryIndex([track], { packetMemory: this.packetMemory });
+    try {
+      for (let at = first; at < stream.count; at++) {
+        const bytes = await bytesAt(at);
+        if (bytes.length) elementary.push(track.trackNumber, bytes, stream.starts[at], at === first ? { pts: stream.times[first] } : {});
+        const input = elementary.index.inputFor({ trackId: track.trackNumber, from: interval.from, to: interval.to,
+          mode: interval.modes?.[track.trackNumber] ?? "transcode" });
+        if (input.kind === "result") {
+          elementary.index.disposeAfterUse = true;
+          return elementary.index;
+        }
+      }
+      elementary.complete();
+      elementary.index.disposeAfterUse = true;
+      return elementary.index;
+    } catch (error) {
+      elementary.index.dispose();
+      throw error;
+    }
+  }
+
   /**
    * The sound packets an AVI index states, on FFmpeg's clock: the time the
    * index gives each packet is the one FFmpeg's demuxer gives it, and a packet

package/services/media/direct-segment-input.js

@@ -33,11 +33,15 @@ export async function directSegmentInput(container, { interval, tracks, mode },
   const walked = await container.packetWalkRanges?.(interval);
   if (walked) return walked;
   // The table is begun, or joined, and not waited for.
-  if (container.packetTableWouldWait?.() === true) {
+  if (container.packetTableWouldWait?.(interval) === true) {
     whenBuilt(container.readPacketIndex(interval).then(() => undefined, () => undefined));
     return { kind: "pending" };
   }
   const index = await container.readPacketIndex(interval);
-  await index.prepareAudioDependencies?.(interval, container.readRange);
-  return new SegmentInputs({ index, tracks }).forInterval({ ...interval, mode });
+  try {
+    await index.prepareAudioDependencies?.(interval, container.readRange);
+    return new SegmentInputs({ index, tracks }).forInterval({ ...interval, mode });
+  } finally {
+    if (index.disposeAfterUse === true) index.dispose();
+  }
 }

package/services/server/ViewerRequests.js

@@ -147,7 +147,8 @@ export class ViewerRequests {
     const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical,
-      firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds });
+      firstRequiredSegmentsSeconds: context.activeFirstRequiredSegmentsSeconds,
+      firstRequiredStages: context.activeFirstRequiredStages });
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
   }
 
@@ -192,13 +193,19 @@ export class ViewerRequests {
     const elapsedMs = waitElapsedSince(context, waitElapsedMs);
     const measuredWorkSeconds = processing.firstRequiredSegmentsSeconds;
     const hasActiveEstimate = Number.isFinite(measuredWorkSeconds) && measuredWorkSeconds >= 0;
+    const stagesChanged = Array.isArray(processing.firstRequiredStages) &&
+      JSON.stringify(processing.firstRequiredStages) !== JSON.stringify(context.activeFirstRequiredStages);
     const activeTotalSeconds = hasActiveEstimate
       ? elapsedMs / 1000 + measuredWorkSeconds
       : context.activeTotalSeconds;
-    const activeEstimateChanged = hasActiveEstimate && activeTotalSeconds !== context.activeTotalSeconds;
+    const activeEstimateChanged = hasActiveEstimate &&
+      (activeTotalSeconds !== context.activeTotalSeconds || stagesChanged);
     if (hasActiveEstimate) {
       context.activeTotalSeconds = activeTotalSeconds;
       context.activeFirstRequiredSegmentsSeconds = measuredWorkSeconds;
+      if (Array.isArray(processing.firstRequiredStages)) {
+        context.activeFirstRequiredStages = processing.firstRequiredStages;
+      }
     }
     const changed = featuresChanged || activeEstimateChanged;
     if (sameWait && changed) context.revision += 1;
@@ -213,7 +220,8 @@ export class ViewerRequests {
     const seconds = earlyWaitRemainingSeconds(totalSeconds, elapsedMs);
     if (!Number.isFinite(seconds) || seconds < 0) return null;
     this.#logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical,
-      firstRequiredSegmentsSeconds: hasActiveEstimate ? measuredWorkSeconds : context.activeFirstRequiredSegmentsSeconds });
+      firstRequiredSegmentsSeconds: hasActiveEstimate ? measuredWorkSeconds : context.activeFirstRequiredSegmentsSeconds,
+      firstRequiredStages: context.activeFirstRequiredStages });
     return { version: 1, waitId, revision: context.revision, remainingSeconds: seconds, ageMs: 0 };
   }
 
@@ -222,11 +230,12 @@ export class ViewerRequests {
     return Number.isFinite(estimate) ? { seconds: estimate, stagesMs: null, observations: null } : estimate;
   }
 
-  #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical, firstRequiredSegmentsSeconds }) {
+  #logEarlyForecast(context, { elapsedMs, seconds, totalSeconds, historical, firstRequiredSegmentsSeconds,
+    firstRequiredStages }) {
     if (context.loggedForecastRevision === context.revision) return;
     const basis = Number.isFinite(firstRequiredSegmentsSeconds) ? "first-required" : "historical-stages";
     const estimate = basis === "first-required"
-      ? { firstRequiredSegmentsSeconds }
+      ? { firstRequiredSegmentsSeconds, ...(Array.isArray(firstRequiredStages) ? { firstRequiredStages } : {}) }
       : { stagesMs: historical?.stagesMs ?? null, observations: historical?.observations ?? null };
     logger.info(`early wait forecast ${JSON.stringify({ waitId: context.waitId, consumer: context.consumerId,
       generation: context.generation, features: context.features, elapsedMs, revision: context.revision,
@@ -1062,7 +1071,8 @@ export class ViewerRequests {
           audioOperation: audioOperation?.operation,
           videoSpeedX: videoOperation?.speed,
           audioSpeedX: audioOperation?.speed,
-          firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds
+          firstRequiredSegmentsSeconds: forecast.firstRequiredSegmentsSeconds,
+          firstRequiredStages: forecast.firstRequiredStages
         } });
       if (waitEstimate) forecast.waitEstimate = waitEstimate;
     }
@@ -1105,6 +1115,7 @@ export class ViewerRequests {
     const holding = forecast.holdingBy;
     this.#host.noteViewerWaiting?.(consumerId || session.id,
       holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
+    delete forecast.firstRequiredStages;
     return forecast;
   }
 

package/services/viewer/playback-readiness.js

@@ -463,23 +463,28 @@ export function predictPlaybackReadiness(input = {}) {
     // Production accepts a complete held segment input. It cannot overlap its
     // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    let admittedAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
+    let runAdmissionAt = null;
+    let runOpenSeconds = 0;
+    let productionStartAt = Math.max(trackFinish[trackIndex], sourceArrivalAt);
     if (!job.produced && encodeWork > 0) {
       const run = runStarts[trackIndex];
       const live = run.spans.some(span => segment.startSeconds >= span.start && segment.startSeconds < span.end);
       if (!live && (run.admittedAt === null || sourceArrivalAt > run.admittedAt)) {
-        run.admittedAt = admittedAt;
-        admittedAt += run.openSeconds;
+        runAdmissionAt = productionStartAt;
+        run.admittedAt = runAdmissionAt;
+        runOpenSeconds = run.openSeconds;
+        productionStartAt += runOpenSeconds;
       }
     }
-    const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
+    const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, productionStartAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
     const sourcePlanned = sourceArrivalAt > 0 && plan.finish >= sourceArrivalAt;
     productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0, sourceArrivalAt,
-      sourcePlanned });
+      sourcePlanned, runAdmissionAt, runOpenSeconds, productionStartAt, encodeWork });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));
     transferFinish = deliveryAt;
-    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment, sourceArrivalAt,
+    const appendSeconds = finiteNonNegative(track.appendSeconds);
+    completions.push({ at: deliveryAt + appendSeconds, deliveryAt, appendSeconds, trackIndex, segment, sourceArrivalAt,
       sourcePlanned });
   }
 
@@ -547,13 +552,32 @@ export function predictPlaybackReadiness(input = {}) {
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
     }
   }
-  const firstRequiredTrackSeconds = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
+  const firstRequiredStages = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
     const first = state.segments.find(segment => segment.endSeconds > position);
-    if (!first) return 0;
-    if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) return 0;
+    if (!first) return { track: state.track.id ?? trackIndex, segment: null, alreadyBuffered: true,
+      sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
+      productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+    if (first.ranges.every(range => contains(state.clientRanges, range.start, range.end))) {
+      return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: true,
+        sourceArrivalSeconds: 0, runAdmissionSeconds: null, runOpenSeconds: 0, productionStartSeconds: 0,
+        productionCompleteSeconds: 0, deliveryCompleteSeconds: 0, appendSeconds: 0, completionSeconds: 0 };
+    }
     const completion = completions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
-    return completion?.at ?? null;
+    if (!completion) return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
+      sourceArrivalSeconds: null, runAdmissionSeconds: null, runOpenSeconds: null, productionStartSeconds: null,
+      productionCompleteSeconds: null, deliveryCompleteSeconds: null, appendSeconds: null, completionSeconds: null };
+    const production = productions.find(item => item.trackIndex === trackIndex && item.segment.index === first.index);
+    return { track: state.track.id ?? trackIndex, segment: first.index, alreadyBuffered: false,
+      sourceArrivalSeconds: production?.sourceArrivalAt ?? 0,
+      runAdmissionSeconds: production?.runAdmissionAt ?? null,
+      runOpenSeconds: production?.runOpenSeconds ?? 0,
+      productionStartSeconds: production?.productionStartAt ?? null,
+      productionCompleteSeconds: production?.at ?? null,
+      deliveryCompleteSeconds: completion.deliveryAt,
+      appendSeconds: completion.appendSeconds,
+      completionSeconds: completion.at };
   });
+  const firstRequiredTrackSeconds = firstRequiredStages.map(stage => stage.completionSeconds);
   const firstRequiredSegmentsSeconds = firstRequiredTrackSeconds.every(Number.isFinite)
     ? Math.max(0, ...firstRequiredTrackSeconds) : null;
   const delay = Math.max(0, ...constraints);
@@ -564,6 +588,7 @@ export function predictPlaybackReadiness(input = {}) {
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
     firstRequiredSegmentsSeconds,
+    firstRequiredStages,
     // The piece whose `kind` — its production, or its delivery to the page —
     // comes `atSeconds` from now while the media before it lasts
     // `aheadSeconds`: the difference is the delay.