@torrent-tv/proxy 2.107.24 → 2.107.26

package/package.json

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

package/services/server/ViewerRequests.js

@@ -1282,8 +1282,12 @@ export class ViewerRequests {
       const ranges = inventory.has(index) ? this.#host.encodeRuns.finishedMediaRangesOf(output, index) : undefined;
       const mediaRanges = ranges && output.segmentFormat?.servedMediaRanges ?
         output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined;
+      // The player can request a fragment whose media timestamps extend a few
+      // frames past its nominal playlist end while seeking to the next piece.
       if (index !== 0 && mediaRanges === undefined && !inventory.has(index) &&
-        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) && endSeconds <= positionSeconds) {
+        Number.isFinite(endSeconds) && Number.isFinite(positionSeconds) &&
+        !this.#host.playbackReadiness.endsWithinPlayerSeekTolerance(endSeconds, positionSeconds) &&
+        endSeconds < positionSeconds) {
         continue;
       }
       const startSeconds = timeline.publishedStartOf(index);

package/services/server/wire-outputs.js

@@ -72,7 +72,7 @@ import { ViewerRequests } from "./ViewerRequests.js";
 import { OutputLifecycle } from "./OutputLifecycle.js";
 import { SegmentServing } from "./SegmentServing.js";
 import { audioStartSecondsFor } from "../viewer/audio-start.js";
-import { forecastRate, rateSummaryOf, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
+import { endsWithinPlayerSeekTolerance, forecastRate, rateSummaryOf, predictPlaybackReadiness, RateTrend } from "../viewer/playback-readiness.js";
 import { audioRenditionName } from "../media/audio-inventory.js";
 import { Renditions } from "../encode/Renditions.js";
 import { CushionReport, LOOKAHEAD_PAUSE_SECONDS } from "../encode/CushionReport.js";
@@ -640,7 +640,8 @@ export function wireOutputs({
     get encodeRuns() { return parts.encodeRuns; },
     // When this viewer's playback can start and run to the end: the viewer
     // component's forecast, which models the viewer's browser.
-    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend },
+    playbackReadiness: { predict: predictPlaybackReadiness, forecastRate, rateSummaryOf, RateTrend,
+      endsWithinPlayerSeekTolerance },
     // Whether the subtitle a viewer chose has been read where they stand — the
     // source preparation's answer, set on these parts by the assembly.
     subtitleReadyFor: (viewer) => parts.subtitleReadyFor?.(viewer) ?? true,

package/services/viewer/playback-readiness.js

@@ -38,9 +38,20 @@ 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;
+// Match the media element's allowance around a seek target. A fragment's
+// timestamps can extend slightly beyond its nominal playlist boundary.
+export const PLAYER_SEEK_TOLERANCE_SECONDS = 0.25;
+
+/**
+ * @param {number} segmentEndSeconds
+ * @param {number} positionSeconds
+ * @returns {boolean}
+ */
+export function endsWithinPlayerSeekTolerance(segmentEndSeconds, positionSeconds) {
+  return Number.isFinite(segmentEndSeconds) && Number.isFinite(positionSeconds) &&
+    segmentEndSeconds <= positionSeconds &&
+    positionSeconds - segmentEndSeconds <= PLAYER_SEEK_TOLERANCE_SECONDS;
+}
 
 /**
  * The mean rate predicted over a horizon by the integral of the measured rate.
@@ -223,7 +234,8 @@ export function predictPlaybackReadiness(input = {}) {
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
     segments: segmentsOf[trackIndex]
-      .filter((segment) => isPiece(segment) && segment.endSeconds > position && segment.startSeconds < horizonEnd)
+      .filter((segment) => isPiece(segment) &&
+        segment.endSeconds >= position - PLAYER_SEEK_TOLERANCE_SECONDS && segment.startSeconds < horizonEnd)
       .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
     // The pieces after the near window, as the playlist cuts them, and the
     // offset the page's player placed them by.
@@ -290,9 +302,12 @@ export function predictPlaybackReadiness(input = {}) {
     for (const segment of segments) {
       // Media the page already holds is not transferred again: every range of
       // the piece still ahead of the viewer lies inside what the page holds.
+      const boundaryPrerequisite = endsWithinPlayerSeekTolerance(segment.endSeconds, position);
       let held = segment.ranges.length > 0;
       for (const range of segment.ranges) {
-        if (compare(range.end, at) > 0 && !contains(state.clientRanges, latest(range.start, at), range.end)) {
+        const requiredStart = boundaryPrerequisite ? range.start : latest(range.start, at);
+        if ((boundaryPrerequisite || compare(range.end, at) > 0) &&
+          !contains(state.clientRanges, requiredStart, range.end)) {
           held = false;
           break;
         }
@@ -840,7 +855,7 @@ 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 startTolerance = add(position, rescale(fromSeconds(PLAYER_SEEK_TOLERANCE_SECONDS), unit));
   const held = [];
   for (const range of ranges) {
     const reportedStart = rescale(range.start, unit);
@@ -867,7 +882,7 @@ function heldRanges(ranges, segments, unit, position) {
 function withSeekStartTolerance(ranges, position, unit) {
   const first = ranges.reduce((earliestRange, range) =>
     !earliestRange || compare(range.start, earliestRange.start) < 0 ? range : earliestRange, null);
-  const toleranceEnd = add(position, rescale(fromSeconds(CLIENT_RANGE_START_TOLERANCE_SECONDS), unit));
+  const toleranceEnd = add(position, rescale(fromSeconds(PLAYER_SEEK_TOLERANCE_SECONDS), unit));
   if (!first || compare(first.start, position) <= 0 || compare(first.start, toleranceEnd) > 0) {
     return ranges;
   }
@@ -876,8 +891,11 @@ function withSeekStartTolerance(ranges, position, unit) {
 
 /**
  * The pieces of a track this forecast places in exact time: those still to
- * play (ending after `position`) that start before `horizonEnd`, the first
- * piece, every piece that has been read and every piece that is made. A piece
+ * play (ending within the player's seek tolerance of `position`) that start
+ * before `horizonEnd`, the first piece, every piece that has been read and
+ * every piece that is made. A piece ending just before a seek target is kept
+ * as a prerequisite because its media timestamps can extend past its nominal
+ * playlist boundary. A piece
  * that is none of these changes no exact answer: after the near window it is
  * scheduled in seconds, it is not where the track starts, no unread piece is
  * placed by it (only read pieces are), it lends no frame to what the page
@@ -891,7 +909,8 @@ function withSeekStartTolerance(ranges, position, unit) {
 function piecesThatMatter(track, position, horizonEnd = Number.POSITIVE_INFINITY) {
   const made = new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []);
   const kept = track.segments.filter((segment) => segment?.index === 0 || segment?.mediaRanges !== undefined ||
-    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) && segment.endSeconds <= position) &&
+    made.has(segment?.index) || (!(Number.isFinite(segment?.endSeconds) &&
+      segment.endSeconds < position - PLAYER_SEEK_TOLERANCE_SECONDS) &&
       !(Number.isFinite(segment?.startSeconds) && segment.startSeconds >= horizonEnd)));
   return kept.length === track.segments.length ? track.segments : kept;
 }