@torrent-tv/proxy 2.9.86 → 2.9.87

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.87
+
+- **Fix**: fMP4 playback no longer stops after the first segment. A segment's position was being written into **every** fragment it contains, and the explicit-cut muxer puts several in one segment — `frag_keyframe` opens a fragment at each keyframe while a cut point comes only every few keyframes. Measured: a 6 s piece carries three fragments per track, at 0, 2 and 4 s of its own clock; all three were stamped with the segment's start, so they claimed the same decode time and the player rejected the segment. In the field (2.9.86, this session) that showed as segments 1 and 2 requested in an endless alternation, each served in tens of milliseconds with the transcode healthy at 12x, while the picture froze a few seconds in. The position is now applied as a shift: each track's first fragment sets the base and the rest keep their distance from it. With one fragment per track — what the `hls` muxer produces — a shift and a write are the same thing, so the other path is unchanged. Verified end to end on the addon host: four pieces cut, split, stamped and reassembled the way a player does, then probed — 600 frames over 24 s, decode timestamps rising by exactly 0.04 s across every segment join, no duplicates, clean decode.
+
 ## 2.9.86
 
 - **Fix**: fMP4 playback starts again. The real reason ffmpeg exited before writing anything was the audio, not the file names: the MP4 muxer derives a copied AC-3 track's `dac3` box from the bitstream, so it cannot write `moov` until the first audio packet arrives, while our `empty_moov` demands it at header time — `Cannot write moov atom before AC3 packets. Set the delay_moov flag to fix this.`, captured in the field on a copied AC-3 source. `delay_moov` is now passed alongside it. The `hls` muxer sets that flag itself, which is why the fault appeared only once the muxing moved to the `segment` muxer in 2.9.84; MPEG-TS has no `moov` and was never affected. Verified in the addon container on an AC-3 source: without the flag the exact command the proxy runs fails, with it the segments are written, and the piece layout is unchanged (`ftyp moov moof mdat … mfra`), so the init split added in 2.9.84 still cuts in the same places — headers of consecutive pieces differ in four bytes, all inside `elst`, which the `tfdt` rewriting already overrides.

package/package.json

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

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

@@ -113,6 +113,19 @@ export function readTrackTimescales(initSegment) {
  * independently-addressable segment anyway: it carries its own position, so it
  * is valid against any init for the same tracks.
  *
+ * A SEGMENT MAY HOLD SEVERAL FRAGMENTS PER TRACK, so the segment's start is
+ * applied as a SHIFT, not as a value written into every `tfdt`. The muxer that
+ * takes explicit cut times uses `frag_keyframe`, which opens a fragment at each
+ * keyframe, while a cut point is only every few keyframes — measured on the
+ * field host: a 6 s piece carried three fragments per track, at 0, 2 and 4 s of
+ * its own clock. Writing the segment's start into all three made them claim the
+ * same decode time; the player rejected the segment and re-fetched it forever
+ * (field 2026-08-04: segments 1 and 2 alternating for minutes, each served in
+ * tens of milliseconds, transcode healthy at 12x). Each track's first fragment
+ * therefore defines the base and the rest keep their distance from it. With one
+ * fragment per track — what the `hls` muxer produces — a shift and a write are
+ * the same thing, so both paths are served by this.
+ *
  * Mutates a copy; the caller's buffer is untouched.
  *
  * @param {Buffer} segment
@@ -128,6 +141,8 @@ export function stampSegmentStartTime(segment, startSeconds, trackTimescales) {
   // `tfhd` carries the track id and always precedes the `tfdt` inside the same
   // `traf`, so an ordered pass pairs each `tfdt` with its track's timescale.
   let currentTrackId = null;
+  /** @type {Map<number, number>} trackId → decode time of that track's first fragment. */
+  const fragmentBase = new Map();
   walkBoxes(stamped, (type, bodyStart, bodyEnd) => {
     if (type === "tfhd") {
       if (bodyStart + 8 <= bodyEnd) {
@@ -143,17 +158,27 @@ export function stampSegmentStartTime(segment, startSeconds, trackTimescales) {
       return;
     }
     const version = stamped[bodyStart];
-    const value = Math.round(startSeconds * timescale);
+    if (version === 1 ? bodyStart + 12 > bodyEnd : bodyStart + 8 > bodyEnd) {
+      return;
+    }
+    const existing =
+      version === 1
+        ? Number(stamped.readBigUInt64BE(bodyStart + 4))
+        : stamped.readUInt32BE(bodyStart + 4);
+    if (!fragmentBase.has(currentTrackId)) {
+      fragmentBase.set(currentTrackId, existing);
+    }
+    // Distance from the track's first fragment in this segment. Never negative:
+    // decode times only move forward, and a malformed one must not drag a later
+    // fragment behind the segment's start.
+    const withinSegment = Math.max(0, existing - (fragmentBase.get(currentTrackId) ?? 0));
+    const value = Math.round(startSeconds * timescale) + withinSegment;
     if (version === 1) {
-      if (bodyStart + 12 <= bodyEnd) {
-        stamped.writeBigUInt64BE(BigInt(value), bodyStart + 4);
-      }
-    } else if (bodyStart + 8 <= bodyEnd) {
+      stamped.writeBigUInt64BE(BigInt(value), bodyStart + 4);
+    } else if (value <= 0xffffffff) {
       // A 32-bit field cannot express beyond ~2^32 ticks; leave it rather than
       // write a wrapped value (the player would land somewhere arbitrary).
-      if (value <= 0xffffffff) {
-        stamped.writeUInt32BE(value, bodyStart + 4);
-      }
+      stamped.writeUInt32BE(value, bodyStart + 4);
     }
   });
   return stamped;

package/test/fmp4-timestamps.test.js

@@ -0,0 +1,140 @@
+/**
+ * Stamping a segment's position onto its fragments.
+ *
+ * A segment produced by the explicit-cut muxer holds SEVERAL fragments per
+ * track — `frag_keyframe` opens one at every keyframe, while a cut point comes
+ * only every few keyframes. Writing the segment's start into each of them made
+ * them all claim the same decode time, and the player re-fetched the segment
+ * forever. The positions inside a segment must therefore survive.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { stampSegmentStartTime } from "../services/segment-formats/mp4-boxes.js";
+
+/**
+ * @param {string} type
+ * @param {Buffer} body
+ * @returns {Buffer}
+ */
+function box(type, body) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(8 + body.length, 0);
+  header.write(type, 4, "latin1");
+  return Buffer.concat([header, body]);
+}
+
+/**
+ * One fragment: `moof > traf > (tfhd, tfdt)`, plus the payload it describes.
+ *
+ * @param {{ trackId: number, decodeTime: number, version?: 0 | 1 }} fragment
+ * @returns {Buffer}
+ */
+function makeFragment({ trackId, decodeTime, version = 1 }) {
+  const tfhdBody = Buffer.alloc(8);
+  tfhdBody.writeUInt32BE(trackId, 4);
+  const tfdtBody = Buffer.alloc(version === 1 ? 12 : 8);
+  tfdtBody[0] = version;
+  if (version === 1) {
+    tfdtBody.writeBigUInt64BE(BigInt(decodeTime), 4);
+  } else {
+    tfdtBody.writeUInt32BE(decodeTime, 4);
+  }
+  const traf = box("traf", Buffer.concat([box("tfhd", tfhdBody), box("tfdt", tfdtBody)]));
+  return Buffer.concat([box("moof", traf), box("mdat", Buffer.alloc(16, 0x5a))]);
+}
+
+/**
+ * Every `tfdt` in order, as `[trackId, decodeTime]`.
+ *
+ * @param {Buffer} segment
+ * @returns {Array<[number, number]>}
+ */
+function readDecodeTimes(segment) {
+  const found = [];
+  let offset = 0;
+  let trackId = 0;
+  while (offset + 8 <= segment.length) {
+    const size = segment.readUInt32BE(offset);
+    const type = segment.toString("latin1", offset + 4, offset + 8);
+    if (type === "tfhd") {
+      trackId = segment.readUInt32BE(offset + 12);
+    } else if (type === "tfdt") {
+      const version = segment[offset + 8];
+      found.push([
+        trackId,
+        version === 1 ? Number(segment.readBigUInt64BE(offset + 12)) : segment.readUInt32BE(offset + 12)
+      ]);
+    }
+    // Descend into the containers on the way to `tfdt`; skip anything else
+    // whole, so `mdat` is never walked into.
+    offset += type === "moof" || type === "traf" ? 8 : size;
+  }
+  return found;
+}
+
+test("fragments keep their distance from the start of the segment", () => {
+  // A 6 s segment holding three fragments at 0, 2 and 4 s of its own clock —
+  // the shape measured on the field host.
+  const timescale = 16_000;
+  const segment = Buffer.concat([
+    makeFragment({ trackId: 1, decodeTime: 0 }),
+    makeFragment({ trackId: 1, decodeTime: 2 * timescale }),
+    makeFragment({ trackId: 1, decodeTime: 4 * timescale })
+  ]);
+
+  const stamped = stampSegmentStartTime(segment, 6, new Map([[1, timescale]]));
+
+  assert.deepEqual(
+    readDecodeTimes(stamped).map(([, time]) => time / timescale),
+    [6, 8, 10],
+    "each fragment must land at the segment's start plus its own offset"
+  );
+});
+
+test("each track is shifted by its own base", () => {
+  const videoScale = 16_000;
+  const audioScale = 44_100;
+  // Audio does not start at zero: its frames do not align with the video's.
+  const segment = Buffer.concat([
+    makeFragment({ trackId: 1, decodeTime: 0 }),
+    makeFragment({ trackId: 2, decodeTime: 1024 }),
+    makeFragment({ trackId: 1, decodeTime: 2 * videoScale }),
+    makeFragment({ trackId: 2, decodeTime: 1024 + 2 * audioScale })
+  ]);
+
+  const stamped = stampSegmentStartTime(
+    segment,
+    6,
+    new Map([
+      [1, videoScale],
+      [2, audioScale]
+    ])
+  );
+
+  assert.deepEqual(readDecodeTimes(stamped), [
+    [1, 6 * videoScale],
+    [2, 6 * audioScale],
+    [1, 8 * videoScale],
+    [2, 8 * audioScale]
+  ]);
+});
+
+test("a single fragment is written outright, as before", () => {
+  const stamped = stampSegmentStartTime(
+    makeFragment({ trackId: 1, decodeTime: 1280 }),
+    12,
+    new Map([[1, 16_000]])
+  );
+  assert.deepEqual(readDecodeTimes(stamped), [[1, 12 * 16_000]]);
+});
+
+test("a 32-bit field too small for the position is left alone", () => {
+  const segment = makeFragment({ trackId: 1, decodeTime: 0, version: 0 });
+  const stamped = stampSegmentStartTime(segment, 1_000_000, new Map([[1, 90_000]]));
+  assert.deepEqual(
+    readDecodeTimes(stamped),
+    [[1, 0]],
+    "a wrapped value would send the player somewhere arbitrary; leaving it is the lesser harm"
+  );
+});