@torrent-tv/proxy 2.95.28 → 2.95.30

package/package.json

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

package/services/media/container/AviContainer.js

@@ -232,13 +232,8 @@ export class AviContainer extends Container {
       } else if (type === "audio") {
         if (strf.length < 16) throw new Error("AVI wave format is truncated.");
         const tag = strf.readUInt16LE(0);
-        // WAVEFORMATEX states the average bytes per second the stream carries
-        // (`nAvgBytesPerSec`); zero states nothing. Without it a soundtrack the
-        // browser plays is re-encoded only because its copy has no figure to
-        // ask the link about (torrent-tv/meta#159).
         track = new AudioTrack({ ...params, codecId: waveCodec(tag),
           channels: strf.readUInt16LE(2), samplingFrequency: strf.readUInt32LE(4),
-          bitrateKbps: strf.readUInt32LE(8) * 8 / 1000,
           codecPrivateB64: strf.subarray(18).toString("base64") });
         track.blockAlign = strf.readUInt16LE(12);
         track.matroskaCodecId = "A_MS/ACM";

package/services/media/tracks/AudioTrack.js

@@ -78,8 +78,6 @@ export class AudioTrack extends ContainerTrack {
    * @param {boolean} params.isVisualImpaired - FlagVisualImpaired / descriptive audio
    * @param {number | null} params.channels
    * @param {number | null} params.samplingFrequency
-   * @param {number | null} [params.bitrateKbps] - The rate the file states for
-   *   this track, in kbit/s: an average, not a bound.
    */
   constructor(params) {
     super({ ...params, type: "audio" });
@@ -88,7 +86,6 @@ export class AudioTrack extends ContainerTrack {
     this.isVisualImpaired = params.isVisualImpaired === true;
     this.channels = Number.isFinite(params.channels) ? params.channels : null;
     this.samplingFrequency = Number.isFinite(params.samplingFrequency) ? params.samplingFrequency : null;
-    this.bitrateKbps = Number.isFinite(params.bitrateKbps) && params.bitrateKbps > 0 ? params.bitrateKbps : null;
     this.bitDepth = Number.isSafeInteger(params.bitDepth) && params.bitDepth > 0 ? params.bitDepth : null;
     this.codecDelaySeconds = Number.isFinite(params.codecDelaySeconds) && params.codecDelaySeconds >= 0 ? params.codecDelaySeconds : 0;
     // What the codec is configured as, and the most that configuration allows

package/services/server/ViewerRequests.js

@@ -614,6 +614,10 @@ export class ViewerRequests {
           id: sourceId,
           complete: stats?.fileAvailable === true,
           residence: stats?.residence,
+          fileOffset: stats?.fileOffset,
+          fileLength: stats?.fileLength,
+          pieceLength: stats?.pieceLength,
+          downloadRateReadings: this.#sourceRateReadings(measurement, sourceId, stats, now),
           downloadForecast,
         });
       }
@@ -718,10 +722,11 @@ export class ViewerRequests {
         bufferLimitSeconds: input.bufferLimitSeconds,
         lookaheadSeconds: input.lookaheadSeconds,
         link: input.linkReadings,
-        sources: input.sources.map(({ id, complete, residence, downloadForecast }) => ({
+        sources: input.sources.map(({ id, complete, residence, downloadForecast, downloadRateReadings }) => ({
           id, complete, residenceRanges: residence?.length ?? 0,
           forecastAt: downloadForecast?.measuredAt ?? null, plannedPieces: downloadForecast?.ranges.length ?? 0,
-          unknownPieces: downloadForecast?.ranges.filter(range => range.availableAt === null).length ?? 0
+          unknownPieces: downloadForecast?.ranges.filter(range => range.availableAt === null).length ?? 0,
+          downloadRateBytesPerSecond: downloadRateReadings?.lastValue ?? null
         })),
         tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices }) => ({
           id, processedSeconds, readings, segments: segments.length, prepared: readySegmentIndices.length
@@ -740,7 +745,7 @@ export class ViewerRequests {
     const id = typeof consumerId === "string" ? consumerId : "";
     let state = byViewer.get(id);
     if (!state) {
-      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), tracks: new Map() };
+      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), tracks: new Map(), sources: new Map() };
       byViewer.set(id, state);
     }
     return state;
@@ -764,4 +769,16 @@ export class ViewerRequests {
     }
     return trend.snapshot();
   }
+
+  #sourceRateReadings(state, id, stats, now) {
+    let trend = state.sources.get(id);
+    if (!trend) {
+      trend = new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds);
+      state.sources.set(id, trend);
+    }
+    if (Number.isFinite(stats?.downloadSpeed) && stats.downloadSpeed >= 0) {
+      trend.add(now, stats.downloadSpeed);
+    }
+    return trend.snapshot();
+  }
 }

package/services/torrent/torrent-pool.js

@@ -2118,6 +2118,7 @@ export class TorrentPool {
       fileDownloaded,
       fileLength,
       fileOffset: file.offset,
+      pieceLength: torrent.pieceLength,
       residence,
       fileAvailable: fileLength > 0 && residence.length > 0 && residence.every(range => range.location !== "missing"),
       // Compatibility fields report the same current urgent map demand.

package/services/viewer/playback-readiness.js

@@ -193,7 +193,7 @@ export function predictPlaybackReadiness(input = {}) {
   }
   const sourceState = new Map();
   for (const [id, source] of sources) {
-    sourceState.set(id, { source });
+    sourceState.set(id, { source, rate: rateCurve(source.downloadRateReadings, now), serviceFinish: 0 });
   }
   const link = rateCurve(input.linkReadings, now);
   let unknownReason = null;
@@ -318,11 +318,43 @@ export function predictPlaybackReadiness(input = {}) {
     const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
     let sourceArrivalAt = 0;
     for (const [sourceId, ranges] of sourceByteIntervals) {
+      const source = sourceState.get(sourceId);
+      if (!source) {
+        return result(false, null, buffered, reserve, null, "source-measurement-unavailable", preparedSegments);
+      }
       for (const interval of ranges) {
         const missing = uncoveredIntervals(interval, sourceByteCoverage.get(sourceId) ?? []);
-        if (missing.length) return { ...result(false, null, buffered, reserve, null, "download-schedule-unavailable", preparedSegments),
+        if (missing.length === 0) {
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId)));
+          continue;
+        }
+
+        // Explicit piece arrivals remain authoritative. For still-unmapped
+        // 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;
+        if (!rate || !(rate.rateAt(0) > 0) || !Number.isSafeInteger(facts.pieceLength) ||
+            facts.pieceLength <= 0 || !Number.isSafeInteger(facts.fileOffset) ||
+            !Number.isSafeInteger(facts.fileLength) || facts.fileLength <= 0) {
+          return { ...result(false, null, buffered, reserve, null,
+            rate ? "service-not-advancing" : "download-rate-unavailable", preparedSegments),
           unavailableSource: { sourceId, segmentIndex: segment.index, range: interval, missing } };
-        sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId)));
+        }
+        const estimatedPieces = sourcePiecesFor(missing, facts);
+        let finish = Math.max(source.serviceFinish, sourceArrivalAt);
+        const service = sourceByteService.get(sourceId) ?? [];
+        for (const pieceRange of estimatedPieces) {
+          const stillMissing = uncoveredIntervals(pieceRange, sourceByteCoverage.get(sourceId) ?? []);
+          for (const part of stillMissing) {
+            finish = rate.finish(part.end - part.start, finish);
+            service.push({ start: part.start, end: part.end, begin: finish, finish });
+            sourceArrivalAt = Math.max(sourceArrivalAt, finish);
+          }
+          sourceByteCoverage.set(sourceId, numericCoverage(service));
+          sourceArrivals.set(sourceId, indexedArrivals(service));
+        }
+        source.serviceFinish = finish;
       }
     }
     // Production accepts a complete held segment input. It cannot overlap its
@@ -536,6 +568,22 @@ function uncoveredIntervals(interval, served) {
   return missing;
 }
 
+/** Expand missing file bytes to the whole torrent pieces the reader must hold. */
+function sourcePiecesFor(ranges, source) {
+  const pieces = [];
+  for (const range of ranges) {
+    if (!(range.end > range.start)) continue;
+    const first = Math.floor((source.fileOffset + range.start) / source.pieceLength);
+    const last = Math.ceil((source.fileOffset + range.end) / source.pieceLength) - 1;
+    for (let index = first; index <= last; index += 1) {
+      const start = Math.max(0, index * source.pieceLength - source.fileOffset);
+      const end = Math.min(source.fileLength, (index + 1) * source.pieceLength - source.fileOffset);
+      if (end > start) pieces.push({ start, end });
+    }
+  }
+  return numericCoverage(pieces);
+}
+
 /**
  * Ranges for pieces not read yet, placed in the clock of the pieces that were.
  * A cut time of the playlist is mapped linearly between the nearest measured