@torrent-tv/proxy 2.87.16 → 2.87.18

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.87.18
+
+- **Fix**: Interpret variable-rate video sample presentation holds and movie-clock resolution as media coverage; project prepared intervals onto the browser's reported HLS timestamp offsets per track.
+
+## 2.87.17
+
+- **Fix**: Measure re-encoded HLS fragment intervals against their separate init and served timestamp position, without caching an absent header as empty media.
+
 ## 2.87.16
 
 - **Fix**: Hold spilled source bytes across memory reservation so concurrent eviction cannot terminate ffmpeg input with a missing disk piece.

package/package.json

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

package/routes/api/transcode-sessions/net-report/post.js

@@ -110,6 +110,7 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
       linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : undefined,
       bufferedAheadSec,
       bufferedRanges: body.bufferedRanges,
+      timestampOffsets: body.bufferedRanges?.timestampOffsets,
       bufferLimitSeconds:
         Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : undefined,
       consumerId,

package/services/encode/segment-formats/fmp4.js

@@ -18,6 +18,7 @@ import {
   readTrackTimescales,
   readVideoSampleSize,
   stampSegmentStartTime,
+  translatePresentationRanges,
   walkBoxes
 } from "./mp4-boxes.js";
 
@@ -279,7 +280,15 @@ export const fmp4Format = {
    * transcode itself; the box walk never descends into `mdat`.
    */
   needsSegmentRewrite: true,
-  readMediaRanges: readPresentationRanges,
+  readMediaRanges(raw, { initBytes = null, startSeconds = 0 } = {}) {
+    if (this.extractInit(raw)) return readPresentationRanges(raw);
+    if (!initBytes?.length) return undefined;
+    const served = this.prepareSegmentBytes(raw, { initBytes, startSeconds, rawBytes: raw });
+    return readPresentationRanges(Buffer.concat([initBytes, served]));
+  },
+  clientMediaRanges(ranges, context) {
+    return translatePresentationRanges(ranges, context.initBytes, context.timestampOffsetSeconds);
+  },
 
   /**
    * Whether a segment carries every track the init promises.

package/services/encode/segment-formats/index.js

@@ -49,6 +49,13 @@ import { mpegtsFormat } from "./mpegts.js";
  * @property {(bytes: Buffer, context: PrepareSegmentContext) => Buffer}
  *   prepareSegmentBytes - Correct a segment before serving. Identity for
  *   formats that need nothing.
+ * @property {(bytes: Buffer, context?: Partial<PrepareSegmentContext>) =>
+ *   { start: number, end: number }[] | undefined} [readMediaRanges] - Actual
+ *   served presentation intervals, or undefined until their header is available.
+ * @property {(ranges: { start: number, end: number }[], context: {
+ *   initBytes: Buffer | null, timestampOffsetSeconds?: number }) =>
+ *   { start: number, end: number }[]} [clientMediaRanges] - Project parsed
+ *   presentation intervals onto the clock reported by this viewer's player.
  */
 
 /** @type {Readonly<Record<string, SegmentFormat>>} */

package/services/encode/segment-formats/mp4-boxes.js

@@ -16,6 +16,7 @@
  * @type {ReadonlySet<string>}
  */
 const CONTAINER_BOXES = new Set(["moov", "mvex", "trak", "mdia", "minf", "stbl", "edts", "moof", "traf"]);
+const presentationTracks = new WeakMap();
 
 /**
  * Walk the box tree, invoking `visit` for every box encountered.
@@ -179,8 +180,19 @@ export function readPresentationRanges(raw) {
   let trackId = null;
   let decodeTime = 0;
   let defaultDuration = 0;
+  let movieScale = 0;
+  let declaredTrack = null;
+  const kinds = new Map();
   walkBoxes(raw, (type, start, end) => {
-    if (type === "trex" && start + 20 <= end) {
+    if (type === "mvhd") {
+      const at = start + (raw[start] === 1 ? 20 : 12);
+      if (at + 4 <= end) movieScale = raw.readUInt32BE(at);
+    } else if (type === "tkhd") {
+      const at = start + (raw[start] === 1 ? 20 : 12);
+      if (at + 4 <= end) declaredTrack = raw.readUInt32BE(at);
+    } else if (type === "hdlr" && start + 12 <= end) {
+      kinds.set(declaredTrack, raw.toString("latin1", start + 8, start + 12));
+    } else if (type === "trex" && start + 20 <= end) {
       defaultDurations.set(raw.readUInt32BE(start + 4), raw.readUInt32BE(start + 12));
     } else if (type === "tfhd" && start + 8 <= end) {
       const flags = raw.readUIntBE(start + 1, 3);
@@ -215,20 +227,48 @@ export function readPresentationRanges(raw) {
     }
   });
   // Merge in presentation order: B frames arrive in decode order.
-  const mergedTracks = [...byTrack.values()].map((samples) => {
+  const mergedTracks = [...byTrack].map(([id, samples]) => {
     const merged = [];
-    for (const sample of samples.sort((left, right) => left.start - right.start)) {
+    // Sample durations are decode durations. A displayed video frame remains
+    // present until the next presentation sample, including variable-rate holds.
+    const ordered = samples.sort((left, right) => left.start - right.start);
+    const precision = 1 / (movieScale || scales.get(id));
+    for (const sample of ordered) {
       const previous = merged.at(-1);
-      if (previous && sample.start - previous.end <= Number.EPSILON * Math.max(1, sample.end) * 8) {
+      if (previous && (kinds.get(id) === "vide" ||
+        sample.start - previous.end <= precision + Number.EPSILON * Math.max(1, sample.end) * 8)) {
         previous.end = Math.max(previous.end, sample.end);
       } else merged.push({ ...sample });
     }
-    return merged;
+    // Movie edits quantize independent pieces to movie ticks. Preserve that
+    // declared resolution at joins; it is not a playback buffer threshold.
+    for (const range of merged) range.end += precision;
+    return { id, ranges: merged };
   });
   // A multiplexed segment is playable only where every declared track exists.
-  return mergedTracks.reduce((common, ranges) => common.flatMap((left) => ranges
+  const result = intersectPresentationTracks(mergedTracks);
+  presentationTracks.set(result, mergedTracks);
+  return result;
+}
+
+function intersectPresentationTracks(tracks) {
+  return tracks.map(({ ranges }) => ranges).reduce((common, ranges) => common.flatMap((left) => ranges
     .map((right) => ({ start: Math.max(left.start, right.start), end: Math.min(left.end, right.end) }))
-    .filter(({ start, end }) => end > start)), mergedTracks[0] ?? []);
+    .filter(({ start, end }) => end > start)), tracks[0]?.ranges ?? []);
+}
+
+/** Project the same parsed samples onto the media player's reported clock. */
+export function translatePresentationRanges(ranges, initBytes, timestampOffsetSeconds) {
+  const tracks = presentationTracks.get(ranges);
+  if (!tracks || !initBytes?.length || !Number.isFinite(timestampOffsetSeconds)) return ranges;
+  const edits = readTrackEditOffsets(initBytes);
+  return intersectPresentationTracks(tracks.map(({ id, ranges: held }) => ({
+    id,
+    ranges: held.map(({ start, end }) => ({
+      start: Math.max(0, start + timestampOffsetSeconds - (edits.get(id) ?? 0)),
+      end: end + timestampOffsetSeconds - (edits.get(id) ?? 0)
+    })).filter(({ start, end }) => end > start)
+  })));
 }
 
 /**

package/services/server/ViewerRequests.js

@@ -565,12 +565,22 @@ export class ViewerRequests {
       const trackProgress = output === session ? progress : this.#host.encodeRuns.progressOf(output);
       const trackRates = this.#trackRateReadings(measurement, output, now);
       const timeline = output.timeline;
-      const segments = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) => ({
-        index,
-        startSeconds: timeline.publishedStartOf(index),
-        endSeconds: timeline.publishedStartOf(index + 1),
-        mediaRanges: this.#host.segmentStore.mediaRangesOf(output.outputKey, index)
-      }));
+      const trackName = output === session ? "video" : "audio";
+      const segments = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) => {
+        const ranges = this.#host.segmentStore.mediaRangesOf(output.outputKey, index, {
+          startSeconds: timeline.publishedStartOf(index)
+        });
+        return {
+          index,
+          startSeconds: timeline.publishedStartOf(index),
+          endSeconds: timeline.publishedStartOf(index + 1),
+          mediaRanges: ranges && output.segmentFormat?.clientMediaRanges ?
+            output.segmentFormat.clientMediaRanges(ranges, {
+              initBytes: this.#host.segmentStore.initOf(output.outputKey),
+              timestampOffsetSeconds: viewerReading?.timestampOffsets?.[trackName]
+            }) : ranges
+        };
+      });
       const sourceIndexes = [output.spec.video?.fileIndex, output.spec.audio?.fileIndex]
         .filter((fileIndex) => Number.isInteger(fileIndex) && fileIndex >= 0);
       if (sourceIndexes.length === 0) {

package/services/storage/segment-store/SegmentStore.js

@@ -471,7 +471,7 @@ export class SegmentStore {
     return served;
   }
 
-  mediaRangesOf(key, index) {
+  mediaRangesOf(key, index, { startSeconds = 0 } = {}) {
     const known = this.#mediaRanges.get(key)?.get(index);
     if (known) return known;
     const format = this.#formats.get(key);
@@ -479,7 +479,16 @@ export class SegmentStore {
     const filePath = this.pathOf(key, index);
     if (!filePath) return undefined;
     try {
-      const ranges = format.readMediaRanges(readFileSync(filePath));
+      let initBytes = this.initOf(key);
+      if (!initBytes && format.initFileName) {
+        try {
+          initBytes = readFileSync(path.join(this.pathFor(key), format.initFileName));
+        } catch {
+          // A header not yet produced is not an empty media interval.
+        }
+      }
+      const ranges = format.readMediaRanges(readFileSync(filePath), { initBytes, startSeconds });
+      if (!ranges) return undefined;
       const byIndex = this.#mediaRanges.get(key) ?? new Map();
       byIndex.set(index, ranges);
       this.#mediaRanges.set(key, byIndex);

package/services/viewer/Viewer.js

@@ -392,6 +392,7 @@ export class Viewer {
       linkSampleAgeMs = null,
       bufferedAheadSec,
       bufferedRanges,
+      timestampOffsets,
       bufferLimitSeconds,
       positionSeconds = null,
       playing,
@@ -435,6 +436,8 @@ export class Viewer {
           : now
         : this.netReport?.linkSampleMeasuredAt ?? null,
       bufferedAheadSec: held,
+      timestampOffsets: Object.fromEntries(["video", "audio"].filter((key) =>
+        Number.isFinite(timestampOffsets?.[key])).map((key) => [key, timestampOffsets[key]])),
       bufferedRanges: bufferedRanges && typeof bufferedRanges === "object" ?
         Object.fromEntries(["video", "audio", "media"].filter((key) => Array.isArray(bufferedRanges[key]))
           .map((key) => [key, bufferedRanges[key].slice(0, 256).filter((range) =>

package/test/fmp4-presentation-clock.test.js

@@ -2,6 +2,11 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { readPresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
+import { Viewer } from "../services/viewer/Viewer.js";
 
 function box(type, body) {
   const header = Buffer.alloc(8);
@@ -10,13 +15,15 @@ function box(type, body) {
   return Buffer.concat([header, body]);
 }
 
-function init(emptyMs, mediaTime) {
+function init(emptyMs, mediaTime, kind = "vide") {
   const mvhd = Buffer.alloc(24);
   mvhd.writeUInt32BE(1000, 12);
   const tkhd = Buffer.alloc(20);
   tkhd.writeUInt32BE(1, 12);
   const mdhd = Buffer.alloc(24);
   mdhd.writeUInt32BE(24000, 12);
+  const hdlr = Buffer.alloc(12);
+  hdlr.write(kind, 8);
   const elst = Buffer.alloc(32);
   elst.writeUInt32BE(2, 4);
   elst.writeUInt32BE(emptyMs, 8);
@@ -24,7 +31,8 @@ function init(emptyMs, mediaTime) {
   elst.writeUInt32BE(1000, 20);
   elst.writeInt32BE(mediaTime, 24);
   return box("moov", Buffer.concat([box("mvhd", mvhd), box("trak", Buffer.concat([
-    box("tkhd", tkhd), box("edts", box("elst", elst)), box("mdia", box("mdhd", mdhd))
+    box("tkhd", tkhd), box("edts", box("elst", elst)),
+    box("mdia", Buffer.concat([box("mdhd", mdhd), box("hdlr", hdlr)]))
   ]))]));
 }
 
@@ -70,3 +78,59 @@ test("a shared init first read after a seek also supports returning to the begin
   });
   assert.deepEqual(readPresentationRanges(Buffer.concat([shared, prepared])), readPresentationRanges(raw));
 });
+
+test("HLS fragments use the separate init and the same timeline translation as serving", (t) => {
+  const root = mkdtempSync(path.join(os.tmpdir(), "presentation-ranges-"));
+  const store = new SegmentStore({ root });
+  t.after(() => {
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
+  const key = "encoded-video";
+  store.useFormat(key, fmp4Format);
+  const dir = store.directoryFor(key);
+  const media = fragment(0, 2000);
+  writeFileSync(path.join(dir, fmp4Format.segmentFileName(1)), media);
+  assert.equal(store.mediaRangesOf(key, 1, { startSeconds: 4 }), undefined);
+  const header = init(0, 0);
+  writeFileSync(path.join(dir, fmp4Format.initFileName), header);
+  const served = fmp4Format.prepareSegmentBytes(media, { initBytes: header, startSeconds: 4 });
+  assert.deepEqual(store.mediaRangesOf(key, 1, { startSeconds: 4 }),
+    readPresentationRanges(Buffer.concat([header, served])));
+  assert.ok(store.mediaRangesOf(key, 1)[0].start > 4);
+});
+
+test("variable-rate video retains its frame until the next presentation sample", () => {
+  const media = Buffer.concat([fragment(0, 0), fragment(72000, 0)]);
+  const video = readPresentationRanges(Buffer.concat([init(0, 0), media]));
+  assert.equal(video.length, 1);
+  assert.equal(video[0].start, 0);
+  assert.ok(video[0].end > 3);
+  const audio = readPresentationRanges(Buffer.concat([init(0, 0, "soun"), media]));
+  assert.equal(audio.length, 2);
+  assert.ok(audio[0].end < 0.05);
+  assert.equal(audio[1].start, 3);
+});
+
+test("client clock projection accounts for shared edits and audio initPTS", () => {
+  const audioHeader = init(0, 0, "soun");
+  const audio = readPresentationRanges(Buffer.concat([audioHeader, fragment(96000, 0)]));
+  const shifted = fmp4Format.clientMediaRanges(audio, {
+    initBytes: audioHeader, timestampOffsetSeconds: -0.083
+  });
+  assert.equal(shifted[0].start, 4 - 0.083);
+  const videoHeader = fmp4Format.prepareSharedInit(init(83, 2000));
+  const video = readPresentationRanges(Buffer.concat([init(83, 2000), fragment(0, 2000)]));
+  const projected = fmp4Format.clientMediaRanges(video, {
+    initBytes: videoHeader, timestampOffsetSeconds: -2000 / 24000
+  });
+  assert.deepEqual(projected, video);
+});
+
+test("a viewer retains only finite per-track player clock offsets", () => {
+  const viewer = new Viewer("clock-reading", 1);
+  viewer.report({ timestampOffsets: { video: -0.083, audio: 0, media: 400 } }, 2);
+  assert.deepEqual(viewer.linkReading().timestampOffsets, { video: -0.083, audio: 0 });
+  viewer.report({ timestampOffsets: { video: Number.POSITIVE_INFINITY } }, 3);
+  assert.deepEqual(viewer.linkReading().timestampOffsets, {});
+});