@torrent-tv/proxy 2.87.17 → 2.87.18

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.87.17",
+  "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";
 
@@ -285,6 +286,9 @@ export const fmp4Format = {
     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

@@ -52,6 +52,10 @@ import { mpegtsFormat } from "./mpegts.js";
  * @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,14 +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/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

@@ -6,6 +6,7 @@ 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);
@@ -14,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);
@@ -28,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)]))
   ]))]));
 }
 
@@ -95,3 +99,38 @@ test("HLS fragments use the separate init and the same timeline translation as s
     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, {});
+});