@torrent-tv/proxy 2.95.32 → 2.95.34

package/package.json

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

package/services/server/ViewerRequests.js

@@ -612,12 +612,13 @@ export class ViewerRequests {
           })).filter(range => range.end > range.start) } : sharedForecast;
         sourceMeasurements.set(sourceId, {
           id: sourceId,
+          serviceKey: output.file.sourceKey,
           complete: stats?.fileAvailable === true,
           residence: stats?.residence,
           fileOffset: stats?.fileOffset,
           fileLength: stats?.fileLength,
           pieceLength: stats?.pieceLength,
-          downloadRateReadings: this.#sourceRateReadings(measurement, sourceId, stats, now),
+          downloadRateReadings: this.#sourceRateReadings(measurement, output.file.sourceKey, stats, now),
           downloadForecast,
         });
       }

package/services/viewer/playback-readiness.js

@@ -37,6 +37,10 @@ import {
   ZERO
 } from "./media-time.js";
 
+// Match the media element's allowance for a range that starts a few frames
+// after its current position (see server/public/domain/buffer-metrics.js).
+const CLIENT_RANGE_START_TOLERANCE_SECONDS = 0.25;
+
 /**
  * The mean rate predicted over a horizon by the integral of the measured rate.
  * Polling does not change the last measured service rate.
@@ -99,7 +103,8 @@ export class RateTrend {
  * @param {number} input.lookaheadSeconds
  * @param {number} input.now
  * @param {boolean} [input.requiredAudio]
- * @param {Array<{ id: string, complete: boolean,
+ * @param {Array<{ id: string, serviceKey?: string, complete: boolean, fileOffset?: number,
+ *   fileLength?: number, pieceLength?: number, downloadRateReadings?: object,
  *   downloadForecast?: { ranges: Array<{ start: number, end: number, availableAt: number | null }> } }>} input.sources
  * @param {Array<{ id: string, sourceIds: string[], processedSeconds: number,
  *   bitsPerMediaSecond: number, readings: Array<{ at: number, value: number }>,
@@ -147,7 +152,7 @@ export function predictPlaybackReadiness(input = {}) {
   const position = toSeconds(at);
   const remaining = Math.max(0, duration - position);
   const measuredRanges = reported.map((ranges, trackIndex) => ranges ?
-    heldRanges(ranges, segmentsOf[trackIndex], unit) : null);
+    heldRanges(ranges, segmentsOf[trackIndex], unit, at) : null);
   const measured = measuredRanges.length > 0 && measuredRanges.every(Boolean);
   const heldEnd = measured ? earliest(...measuredRanges.map((ranges) => contiguousEnd(ranges, at))) : null;
   // The figure reported back is what the page said it holds; the widening by
@@ -192,8 +197,16 @@ export function predictPlaybackReadiness(input = {}) {
     return result(false, null, buffered, reserve, null, "timeline-unavailable", 0);
   }
   const sourceState = new Map();
+  // A torrent has one download service, even when required media lives in separate files.
+  const sourceServices = new Map();
   for (const [id, source] of sources) {
-    sourceState.set(id, { source, rate: rateCurve(source.downloadRateReadings, now), serviceFinish: 0 });
+    const serviceKey = typeof source.serviceKey === "string" ? source.serviceKey : id;
+    let service = sourceServices.get(serviceKey);
+    if (!service) {
+      service = { rate: rateCurve(source.downloadRateReadings, now), finish: 0 };
+      sourceServices.set(serviceKey, service);
+    }
+    sourceState.set(id, { source, service });
   }
   const link = rateCurve(input.linkReadings, now);
   let unknownReason = null;
@@ -333,7 +346,8 @@ export function predictPlaybackReadiness(input = {}) {
         // pieces, project only the media-order demand from the torrent's latest
         // measured download service; no supplier or positive rate means no
         // estimated arrival.
-        const { source: facts, rate } = source;
+        const { source: facts, service: sourceService } = source;
+        const { rate } = sourceService;
         if (!rate || !(rate.rateAt(0) > 0) || !Number.isSafeInteger(facts.pieceLength) ||
             facts.pieceLength <= 0 || !Number.isSafeInteger(facts.fileOffset) ||
             !Number.isSafeInteger(facts.fileLength) || facts.fileLength <= 0) {
@@ -342,7 +356,7 @@ export function predictPlaybackReadiness(input = {}) {
           unavailableSource: { sourceId, segmentIndex: segment.index, range: interval, missing } };
         }
         const estimatedPieces = sourcePiecesFor(missing, facts);
-        let finish = Math.max(source.serviceFinish, sourceArrivalAt);
+        let finish = Math.max(sourceService.finish, sourceArrivalAt);
         const service = sourceByteService.get(sourceId) ?? [];
         for (const pieceRange of estimatedPieces) {
           const stillMissing = uncoveredIntervals(pieceRange, sourceByteCoverage.get(sourceId) ?? []);
@@ -354,7 +368,7 @@ export function predictPlaybackReadiness(input = {}) {
           sourceByteCoverage.set(sourceId, numericCoverage(service));
           sourceArrivals.set(sourceId, indexedArrivals(service));
         }
-        source.serviceFinish = finish;
+        sourceService.finish = finish;
       }
     }
     // Production accepts a complete held segment input. It cannot overlap its
@@ -501,13 +515,18 @@ function joinedPiece(served) {
  * @param {bigint} unit
  * @returns {import("./media-time.js").MediaRange[]}
  */
-function heldRanges(ranges, segments, unit) {
+function heldRanges(ranges, segments, unit, position) {
   const pieces = segments.flatMap((segment) => segment.ranges ?? []);
   const zero = mediaTime(0n, unit);
   const error = rescale(REPORTED_TIME_ERROR, unit);
+  const startTolerance = add(position, rescale(fromSeconds(CLIENT_RANGE_START_TOLERANCE_SECONDS), unit));
   const held = [];
   for (const range of ranges) {
-    const start = latest(zero, subtract(rescale(range.start, unit), error));
+    const reportedStart = rescale(range.start, unit);
+    let start = latest(zero, subtract(reportedStart, error));
+    if (compare(reportedStart, position) > 0 && compare(reportedStart, startTolerance) <= 0) {
+      start = position;
+    }
     const end = add(rescale(range.end, unit), error);
     const inside = pieces.filter((piece) => contains([{ start, end }], piece.start, piece.end));
     addMediaRange(held, { start, end, frame: latest(zero, ...inside.map(({ frame }) => frame)) });