@torrent-tv/proxy 2.87.13 → 2.87.14

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.87.14
+
+- **Fix**: Evaluate source-stall coverage against the continuous timeline already prepared on the proxy, while independently checking client-buffer continuity and delivery capacity.
+
 ## 2.87.13
 
 - **Fix**: Include distinct active piece reads in memory demand and preserve their slots immediately, so reads without priority-map ranges cannot deadlock the torrent piece store.

package/package.json

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

package/services/server/playback-readiness.js

@@ -81,7 +81,7 @@ export class RateTrend {
  * @param {number} input.durationSeconds
  * @param {number} input.bufferedAheadSeconds
  * @param {number} input.bufferLimitSeconds
- * @param {number} input.reserveSeconds
+ * @param {number} input.reserveSeconds - Measured source-stall coverage, in media seconds.
  * @param {number} input.lookaheadSeconds
  * @param {number} input.now
  * @param {boolean} [input.requiredAudio]
@@ -110,12 +110,9 @@ export function predictPlaybackReadiness(input = {}) {
   if (remaining <= buffered) {
     return result(true, 0, buffered, reserve, 0, "client-buffer-covers-end", 0);
   }
-  if (!(duration > 0) || !(capacity > 0) || !(reserve > 0) || tracks.length === 0) {
+  if (!(duration > 0) || !(capacity > 0) || tracks.length === 0) {
     return result(false, null, buffered, reserve, null, "incomplete-state", 0);
   }
-  if (reserve > capacity) {
-    return result(false, null, buffered, reserve, null, "reserve-exceeds-client-capacity", 0);
-  }
   const requiredTracks = input.requiredAudio === true ? 2 : 1;
   if (tracks.length < requiredTracks) {
     return result(false, null, buffered, reserve, null, "separate-audio-not-observed", 0);
@@ -166,7 +163,7 @@ export function predictPlaybackReadiness(input = {}) {
 
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
-    const { track, ready, segments } = state;
+    const { track, segments } = state;
     const measuredBitsPerMediaSecond = state.bitsPerMediaSecond;
     for (const segment of segments) {
       if (segment.endSeconds <= position + buffered) {
@@ -277,6 +274,7 @@ export function predictPlaybackReadiness(input = {}) {
     const trackFinish = trackState.map(() => 0);
     let transferFinish = 0;
     const completions = [];
+    const productions = [];
     for (const job of jobs) {
       const { track, trackIndex, segment, ahead, sizeBits, encodeWork, sourceIntervals } = job;
       if (prefillOnly && (ahead > prefillReach || segment.endSeconds - position > capacity)) {
@@ -322,7 +320,14 @@ export function predictPlaybackReadiness(input = {}) {
       if (!job.produced) {
         trackFinish[trackIndex] = encodedAt;
       }
-      const producedAt = Math.max(sourceReadyAtLatest, encodedAt);
+      const producedAt = job.produced ? 0 : Math.max(sourceReadyAtLatest, encodedAt);
+      productions.push({
+        at: producedAt,
+        sourceReadyAt: sourceReadyAtLatest,
+        trackIndex,
+        segment,
+        requiresSource: sourceIntervals.size > 0
+      });
       const roomAt = segment.endSeconds - position <= capacity
         ? 0
         : startDelaySeconds + segment.endSeconds - position - capacity;
@@ -339,12 +344,16 @@ export function predictPlaybackReadiness(input = {}) {
       ? completions.filter(({ segment }) => segment.startSeconds - position <= prefillReach &&
         segment.endSeconds - position <= capacity)
       : completions;
-    const safety = isSafeSchedule(usefulCompletions, trackState, position, duration,
+    const usefulProductions = prefillOnly
+      ? productions.filter(({ segment }) => segment.startSeconds - position <= prefillReach &&
+        segment.endSeconds - position <= capacity)
+      : productions;
+    const safety = isSafeSchedule(usefulCompletions, usefulProductions, trackState, position, duration,
       buffered, capacity, reserve, startDelaySeconds);
     return { safe: safety.safe,
       bufferedAtStart: safety.bufferedAtStart,
-      finishAt: usefulCompletions.reduce((latest, item) => Math.max(latest, item.at), 0),
-      completions: usefulCompletions };
+      neededSeconds: safety.neededSeconds,
+      finishAt: usefulCompletions.reduce((latest, item) => Math.max(latest, item.at), 0) };
   };
 
   const prefillReach = Math.min(capacity, lookahead, remaining);
@@ -353,7 +362,8 @@ export function predictPlaybackReadiness(input = {}) {
   if (!Number.isFinite(maximumUsefulDelay)) {
     return result(false, null, buffered, reserve, null, "prefill-cannot-complete", preparedSegments);
   }
-  if (schedule(0).safe) {
+  const immediate = schedule(0);
+  if (immediate.safe) {
     return result(true, 0, buffered, reserve, 0, "trajectory-safe-now", preparedSegments);
   }
   const searchLimit = Math.max(maximumUsefulDelay, rateRecoveryDelay);
@@ -396,7 +406,7 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
   const readiness = schedule(high);
-  return result(false, high, buffered, reserve, Math.max(0, reserve - buffered),
+  return result(false, high, buffered, reserve, immediate.neededSeconds,
     "minimum-safe-delay", preparedSegments, readiness.bufferedAtStart);
 }
 
@@ -508,53 +518,104 @@ function averageBitsPerMediaSecond(track, segments, ready) {
   return finiteNonNegative(track.bitsPerMediaSecond);
 }
 
-function isSafeSchedule(completions, trackState, position, duration, buffered, capacity, reserve, startDelay) {
-  const ranges = trackState.map(() => [{ start: position, end: position + buffered }]);
-  const ordered = [...completions]
+function isSafeSchedule(completions, productions, trackState, position, duration, buffered, capacity, reserve,
+  startDelay) {
+  // Client continuity is constrained by its buffer limit; source-stall reserve
+  // is covered by the larger union of client data and output already prepared here.
+  const clientRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
+  const preparedRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
+  const orderedCompletions = [...completions]
     .filter(({ at }) => Number.isFinite(at))
     .sort((left, right) => left.at - right.at || left.trackIndex - right.trackIndex);
+  const orderedProductions = [...productions]
+    .filter(({ at }) => Number.isFinite(at))
+    .sort((left, right) => left.at - right.at || left.trackIndex - right.trackIndex);
+  const reserveUntil = trackState.map(() => Number.NEGATIVE_INFINITY);
+  // The measured reserve applies only until this track's last required source
+  // interval has arrived; encoding and client delivery stay in the schedule.
+  for (const production of productions) {
+    if (production.requiresSource) {
+      reserveUntil[production.trackIndex] = Math.max(reserveUntil[production.trackIndex],
+        production.sourceReadyAt);
+    }
+  }
   let completionIndex = 0;
+  let productionIndex = 0;
 
   const addThrough = (time) => {
-    while (completionIndex < ordered.length && ordered[completionIndex].at <= time) {
-      const { trackIndex, segment } = ordered[completionIndex];
-      addRange(ranges[trackIndex], segment.startSeconds, segment.endSeconds);
+    while (productionIndex < orderedProductions.length && orderedProductions[productionIndex].at <= time) {
+      const { trackIndex, segment } = orderedProductions[productionIndex];
+      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      productionIndex += 1;
+    }
+    while (completionIndex < orderedCompletions.length && orderedCompletions[completionIndex].at <= time) {
+      const { trackIndex, segment } = orderedCompletions[completionIndex];
+      addRange(clientRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
       completionIndex += 1;
     }
   };
-  const safeAt = (time) => {
+  const safeAt = (time, checkClient = true) => {
     const playerPosition = position + Math.max(0, time - startDelay);
-    const available = Math.min(capacity, ...ranges.map((trackRanges) =>
+    if (playerPosition >= duration) {
+      return { safe: true, stockSafe: true, available: 0, neededSeconds: 0 };
+    }
+    const available = Math.min(capacity, ...clientRanges.map((trackRanges) =>
       Math.max(0, contiguousEnd(trackRanges, playerPosition) - playerPosition)));
-    const required = Math.min(reserve, Math.max(0, duration - playerPosition));
-    return { safe: available >= required, available };
+    let neededSeconds = 0;
+    let stockSafe = true;
+    for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
+      const required = time <= reserveUntil[trackIndex]
+        ? Math.min(reserve, Math.max(0, duration - playerPosition))
+        : 0;
+      const preparedAhead = Math.max(0,
+        contiguousEnd(preparedRanges[trackIndex], playerPosition) - playerPosition);
+      const deficit = Math.max(0, required - preparedAhead);
+      neededSeconds = Math.max(neededSeconds, deficit);
+      stockSafe &&= deficit === 0;
+    }
+    return {
+      safe: (!checkClient || available > 0) && stockSafe,
+      stockSafe,
+      available,
+      neededSeconds
+    };
   };
 
   addThrough(startDelay);
   const atStart = safeAt(startDelay);
   if (!atStart.safe) {
-    return { safe: false, bufferedAtStart: atStart.available };
-  }
-
-  while (completionIndex < ordered.length) {
-    const time = ordered[completionIndex].at;
-    if (time > startDelay) {
-      const beforeArrival = safeAt(time);
-      if (!beforeArrival.safe) {
-        return { safe: false, bufferedAtStart: atStart.available };
-      }
+    return { safe: false, bufferedAtStart: atStart.available, neededSeconds: atStart.neededSeconds };
+  }
+
+  const playbackEnd = startDelay + Math.max(0, duration - position);
+  const playbackBoundaries = [position + buffered,
+    ...trackState.flatMap(({ segments }) => segments.map(({ endSeconds }) => endSeconds))]
+    .filter((boundary) => boundary > position && boundary < duration)
+    .map((boundary) => startDelay + boundary - position);
+  const sourceReadyTimes = productions
+    .filter(({ requiresSource }) => requiresSource)
+    .map(({ sourceReadyAt }) => sourceReadyAt);
+  const eventTimes = [...orderedCompletions.map(({ at }) => at),
+    ...orderedProductions.map(({ at }) => at), ...playbackBoundaries, ...sourceReadyTimes]
+    .filter((time) => Number.isFinite(time) && time > startDelay && time < playbackEnd)
+    .sort((left, right) => left - right)
+    .filter((time, index, all) => index === 0 || time !== all[index - 1]);
+
+  for (const time of eventTimes) {
+    const beforeArrival = safeAt(time, false);
+    if (!beforeArrival.stockSafe) {
+      return { safe: false, bufferedAtStart: atStart.available, neededSeconds: beforeArrival.neededSeconds };
     }
     addThrough(time);
-    if (time > startDelay) {
-      const afterArrival = safeAt(time);
-      if (!afterArrival.safe) {
-        return { safe: false, bufferedAtStart: atStart.available };
-      }
+    const afterArrival = safeAt(time);
+    if (!afterArrival.safe) {
+      return { safe: false, bufferedAtStart: atStart.available, neededSeconds: afterArrival.neededSeconds };
     }
   }
 
-  const atEnd = safeAt(startDelay + Math.max(0, duration - position));
-  return { safe: atEnd.safe, bufferedAtStart: atStart.available };
+  const atEnd = safeAt(playbackEnd);
+  return { safe: atEnd.safe, bufferedAtStart: atStart.available, neededSeconds: atStart.neededSeconds };
 }
 
 function addRange(ranges, start, end) {

package/test/playback-readiness.test.js

@@ -36,7 +36,50 @@ test("finds the first safe start from segments delivered before playback", () =>
 
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 1) < 1e-8);
+});
+
+test("keeps source-stall reserve in the proxy's prepared timeline, not the capped browser buffer", () => {
+  const now = 10_000;
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 12,
+    bufferedAheadSeconds: 2,
+    bufferLimitSeconds: 4,
+    reserveSeconds: 6,
+    lookaheadSeconds: 12,
+    sources: [{
+      id: "source",
+      complete: false,
+      bytesPerMediaSecond: 1,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }]
+    }],
+    tracks: [{
+      id: "video",
+      sourceIds: ["source"],
+      processedSeconds: 8,
+      bitsPerMediaSecond: 80,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }],
+      segments: [
+        { index: 0, startSeconds: 0, endSeconds: 2 },
+        { index: 1, startSeconds: 2, endSeconds: 4 },
+        { index: 2, startSeconds: 4, endSeconds: 6 },
+        { index: 3, startSeconds: 6, endSeconds: 8 },
+        { index: 4, startSeconds: 8, endSeconds: 10 },
+        { index: 5, startSeconds: 10, endSeconds: 12 }
+      ],
+      readySegmentIndices: [0, 1, 2, 3],
+      segmentSizesBytes: new Map([[0, 20], [1, 20], [2, 20], [3, 20], [4, 20], [5, 20]])
+    }],
+    linkReadings: [{ at: now - 1_000, value: 80_000 }, { at: now, value: 80_000 }]
+  });
+
+  assert.equal(forecast.ready, true);
+  assert.equal(forecast.reason, "trajectory-safe-now");
+  assert.equal(forecast.reserveSeconds, 6);
+  assert.equal(forecast.bufferedSeconds, 2);
+  assert.equal(forecast.preparedSegments, 4);
 });
 
 test("overlaps source reads and encoding, then waits for the slower stage and delivery", () => {
@@ -53,7 +96,7 @@ test("overlaps source reads and encoding, then waits for the slower stage and de
   const forecast = predictPlaybackReadiness(input({ sources: [source], tracks: [track] }));
 
   assert.equal(forecast.ready, false);
-  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 2) < 1e-8);
 });
 
 test("does not produce an ETA without a client-link measurement", () => {
@@ -177,7 +220,7 @@ test("downloads an overlapping source interval once when two tracks use the same
 
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Math.abs(forecast.delaySeconds - 2.048) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 2.032) < 1e-8);
 });
 
 test("downloads sources on separate torrents concurrently", () => {
@@ -319,5 +362,5 @@ test("finds a safe interval when rising encode speed and falling link speed make
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
   assert.ok(Number.isFinite(forecast.delaySeconds));
-  assert.ok(forecast.delaySeconds > 7 && forecast.delaySeconds < 10);
+  assert.ok(forecast.delaySeconds > 4 && forecast.delaySeconds < 5);
 });