@torrent-tv/proxy 2.96.9 → 2.96.11

package/package.json

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

package/server.js

@@ -54,6 +54,8 @@ import { wireOutputs } from "./services/server/wire-outputs.js";
 import { createPlaybackPlanner } from "./services/media/playback-planner.js";
 import { KeyframeTables } from "./services/media/KeyframeTables.js";
 import { contentsOf } from "./services/torrent/Contents.js";
+import { joinedWithinPieces } from "./services/torrent/demand/pieces.js";
+import { withoutRepeatedZones } from "./services/torrent/map-zones.js";
 import { SubtitleOrchestrator } from "./services/media/SubtitleOrchestrator.js";
 import { containerOrchestrator, CONTAINER_HEAD_BYTES, describeWorkTags } from "./services/media/ContainerOrchestrator.js";
 import { readPlaybackDeclarations } from "./services/media/read-playback-declarations.js";
@@ -434,6 +436,9 @@ export async function startProxyServer({
       const media = await containerOrchestrator.inspect(params, "media-info");
       if (media.kind !== "result" || !map.isCurrent()) return [];
       const shift = Number(media.value?.startTimeSeconds) || 0;
+      // A zone's ranges are stated to the torrent at the precision it fetches:
+      // ranges closer than a piece hold the same pieces as one.
+      const pieceLength = Number(torrentPool.knownTorrent(map.sourceKey)?.pieceLength);
       const converted = [];
       const demands = [];
       for (const output of outputParts.outputs.values()) {
@@ -483,7 +488,7 @@ export async function startProxyServer({
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
         const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         const convert = ranges => {
-          for (const [byteStart, byteEnd] of ranges) converted.push({ ...demand,
+          for (const [byteStart, byteEnd] of joinedWithinPieces(ranges, pieceLength)) converted.push({ ...demand,
             downloadInterval: { from: zone.owner.from, to: zone.owner.to }, byteStart, byteEnd });
         };
         // The bytes one segment needs are a fact of the file and the output, so
@@ -529,7 +534,9 @@ export async function startProxyServer({
         segmentSourceRanges.set(rangesKey, input.ranges);
         convert(input.ranges);
       }
-      return converted;
+      // The ranges a picture reads at open are named again by every segment;
+      // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
+      return withoutRepeatedZones(converted);
     }
   });
   const mediaReads = new MediaReadRequests({

package/services/torrent/demand/pieces.js

@@ -106,3 +106,29 @@ export function nearestFirst({ byteStart, byteEnd, parts }) {
   }
   return ranges;
 }
+
+/**
+ * Byte ranges joined wherever the gap between two of them is shorter than a
+ * piece: the pieces they hold are the same, and there are fewer of them.
+ *
+ * A gap shorter than a piece cannot hold a whole piece, so every piece it
+ * touches is touched by a range beside it. The soundtrack of an AVI read from
+ * its own packets is one range per packet, interleaved with the picture's
+ * bytes: field 2026-10-10 (torrent-tv/meta#166), a map of 350 191 zones took
+ * 20.8 s to reach the torrent thread and grew its heap to 818 MB, for pieces of
+ * 4 MiB that the whole soundtrack touches anyway.
+ *
+ * @param {Array<[number, number]>} ranges - Inclusive byte ranges in ascending order.
+ * @param {number} pieceLength
+ * @returns {Array<[number, number]>} The same ranges when the piece length is not usable.
+ */
+export function joinedWithinPieces(ranges, pieceLength) {
+  if (!Number.isFinite(pieceLength) || pieceLength <= 0) return ranges;
+  const joined = [];
+  for (const [start, end] of ranges) {
+    const previous = joined.at(-1);
+    if (previous && start >= previous[0] && start - previous[1] - 1 < pieceLength) previous[1] = Math.max(previous[1], end);
+    else joined.push([start, end]);
+  }
+  return joined;
+}

package/services/torrent/map-zones.js

@@ -0,0 +1,91 @@
+/**
+ * @file What one zone of the priority map tells the torrent: the level of
+ * urgency it is stated at, and the band the swarm ranks it by.
+ *
+ * Pure arithmetic over the zone's own fields, so the main thread can ask the
+ * same question before a map is sent and the torrent thread when it is applied.
+ */
+import { isAtAWatchingViewer, isBehindEverybody, isNobodyComingNow } from "../viewer/PriorityMap.js";
+import { Urgency } from "./demand/Urgency.js";
+import { compareBands } from "./download/bands.js";
+
+/**
+ * Which level of urgency one zone is stated at, from the map's own number
+ * and nothing else. The map's numbers are a scale as long as the film needs
+ * — ten bands on a fifty-minute film — while the register has five levels,
+ * and the fit is by meaning:
+ *
+ *  - the top of the scale is where a viewer is standing, so it is the
+ *    cushion being built: {@link Urgency.NEAR}. Never BLOCKED — that level
+ *    means a reader is stopped on those bytes right now, which only a read
+ *    can say;
+ *  - the bottom is what nobody is approaching: behind a viewer moving
+ *    forward, and the whole film of a viewer who has stopped the picture.
+ *    Wanted only if somebody seeks back, which is {@link Urgency.BEHIND};
+ *  - one above the bottom is the far tail — wanted for certain if the
+ *    viewer watches on, and not before: {@link Urgency.TAIL};
+ *  - everything between is the lead being built: {@link Urgency.AHEAD}.
+ *
+ * Read from the scale's own ends rather than from the highest and lowest
+ * number in THIS file's map. The two speculative levels are withheld across
+ * every torrent at once while anything urgent is missing anywhere, so a
+ * paused viewer's film has to compare as wanted-last against another film
+ * somebody is watching — and relative to itself alone it would compare as
+ * the most urgent thing there is.
+ *
+ * @param {{ priority?: number, behind?: boolean, deferred?: boolean, urgent?: boolean }} zone
+ * @returns {number}
+ */
+export function levelOfMapZone(zone) {
+  // Read through the map's own words rather than by comparing its numbers.
+  // The scale is that layer's, and the numbers inside a band mean nothing
+  // but their order.
+  const priority = zone.priority ?? 0;
+  if (zone.behind === true || (zone.behind === undefined && isBehindEverybody(priority))) {
+    return Urgency.BEHIND;
+  }
+  if (zone.deferred === true || (zone.deferred === undefined && isNobodyComingNow(priority))) {
+    // In front of somebody who has stopped the picture, and of nobody who is
+    // watching. Wanted, and wanted after everyone who is on their way.
+    return Urgency.TAIL;
+  }
+  return (zone.urgent === true || (zone.urgent === undefined && isAtAWatchingViewer(priority))) ? Urgency.NEAR : Urgency.AHEAD;
+}
+
+/** The priority a zone is stated at, within the register's scale. */
+export function priorityOfMapZone(zone) {
+  return Number.isFinite(zone.priority) ? Math.max(1, Math.min(100, zone.priority)) : 1;
+}
+
+/** When a zone's bytes are needed, as an instant; `now` reads `withinSeconds`. */
+export function deadlineOfMapZone(zone, now = Date.now()) {
+  return Number.isFinite(zone.deadlineAt) ? zone.deadlineAt :
+    Number.isFinite(zone.withinSeconds) ? now + Math.max(0, zone.withinSeconds) * 1000 : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * The zones with every repeat of the same bytes left out but the one the swarm
+ * would rank first.
+ *
+ * Each piece is fetched in the band of the best zone that holds it
+ * ({@link compareBands}), so a zone naming exactly the bytes of a better one
+ * changes nothing the swarm is told. The ranges an AVI's picture reads at open
+ * — its declarations and its indexes — are named again in the zone of every
+ * segment: field 2026-10-10 (torrent-tv/meta#166), maps of 9700 zones, for a
+ * film of 2035 segments, cost half a second each to deliver.
+ *
+ * @template {{ byteStart: number, byteEnd: number }} Zone
+ * @param {Zone[]} zones
+ * @param {number} [now]
+ * @returns {Zone[]} In their order, without the repeats.
+ */
+export function withoutRepeatedZones(zones, now = Date.now()) {
+  const bandOf = zone => ({ urgency: levelOfMapZone(zone), priority: priorityOfMapZone(zone), deadlineAt: deadlineOfMapZone(zone, now) });
+  const best = new Map();
+  zones.forEach((zone, index) => {
+    const key = `${zone.byteStart}:${zone.byteEnd}`;
+    const kept = best.get(key);
+    if (!kept || compareBands(bandOf(zone), kept.band) < 0) best.set(key, { index, band: bandOf(zone) });
+  });
+  return zones.filter((zone, index) => best.get(`${zone.byteStart}:${zone.byteEnd}`).index === index);
+}

package/services/torrent/torrent-pool.js

@@ -20,7 +20,7 @@ import { demandProgress } from "./demand-progress.js";
 import { Urgency, urgencyName } from "./demand/index.js";
 import { demandFor, firstClassStatement, forgetTorrent, reconcileAll, hasUnmetDemand } from "./download/registry.js";
 import { withdrawClaim } from "./download/withdraw-claim.js";
-import { isAtAWatchingViewer, isBehindEverybody, isNobodyComingNow } from "../viewer/PriorityMap.js";
+import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zones.js";
 import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
 
@@ -1290,48 +1290,9 @@ export class TorrentPool {
       .filter((zone) => Number.isSafeInteger(zone?.byteStart) && Number.isSafeInteger(zone?.byteEnd) &&
         zone.byteStart >= 0 && zone.byteEnd >= zone.byteStart && zone.byteStart < length)
       .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
-    /**
-     * Which level of urgency one zone is stated at, from the map's own number
-     * and nothing else. The map's numbers are a scale as long as the film needs
-     * — ten bands on a fifty-minute film — while the register has five levels,
-     * and the fit is by meaning:
-     *
-     *  - the top of the scale is where a viewer is standing, so it is the
-     *    cushion being built: {@link Urgency.NEAR}. Never BLOCKED — that level
-     *    means a reader is stopped on those bytes right now, which only a read
-     *    can say;
-     *  - the bottom is what nobody is approaching: behind a viewer moving
-     *    forward, and the whole film of a viewer who has stopped the picture.
-     *    Wanted only if somebody seeks back, which is {@link Urgency.BEHIND};
-     *  - one above the bottom is the far tail — wanted for certain if the
-     *    viewer watches on, and not before: {@link Urgency.TAIL};
-     *  - everything between is the lead being built: {@link Urgency.AHEAD}.
-     *
-     * Read from the scale's own ends rather than from the highest and lowest
-     * number in THIS file's map. The two speculative levels are withheld across
-     * every torrent at once while anything urgent is missing anywhere, so a
-     * paused viewer's film has to compare as wanted-last against another film
-     * somebody is watching — and relative to itself alone it would compare as
-     * the most urgent thing there is.
-     *
-     * @param {{ priority?: number }} zone
-     * @returns {number}
-     */
-    const levelOf = (zone) => {
-      // Read through the map's own words rather than by comparing its numbers.
-      // The scale is that layer's, and the numbers inside a band mean nothing
-      // but their order.
-      const priority = zone.priority ?? 0;
-      if (zone.behind === true || (zone.behind === undefined && isBehindEverybody(priority))) {
-        return Urgency.BEHIND;
-      }
-      if (zone.deferred === true || (zone.deferred === undefined && isNobodyComingNow(priority))) {
-        // In front of somebody who has stopped the picture, and of nobody who is
-        // watching. Wanted, and wanted after everyone who is on their way.
-        return Urgency.TAIL;
-      }
-      return (zone.urgent === true || (zone.urgent === undefined && isAtAWatchingViewer(priority))) ? Urgency.NEAR : Urgency.AHEAD;
-    };
+    // Which level each zone is stated at: `map-zones.js`, where the main thread
+    // reads the same rule before it sends a map.
+    const levelOf = levelOfMapZone;
     ordered.forEach((zone, index) => {
       // Only ranges declared by the container index or metadata read are wanted.
       const byteStart = zone.byteStart;
@@ -1345,10 +1306,9 @@ export class TorrentPool {
         byteStart,
         byteEnd,
         urgency: levelOf(zone),
-        priority: Number.isFinite(zone.priority) ? Math.max(1, Math.min(100, zone.priority)) : 1,
+        priority: priorityOfMapZone(zone),
         order: Number.isSafeInteger(zone.order) && zone.order >= 0 ? zone.order : 0,
-        deadlineAt: Number.isFinite(zone.deadlineAt) ? zone.deadlineAt :
-          Number.isFinite(zone.withinSeconds) ? Date.now() + Math.max(0, zone.withinSeconds) * 1000 : Number.POSITIVE_INFINITY,
+        deadlineAt: deadlineOfMapZone(zone),
         requestId: zone.requestId ?? `${torrent.infoHash}:${fileIndex}:map`
       });
     });