@torrent-tv/proxy 2.87.16 → 2.87.17

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 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.17",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

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

@@ -279,7 +279,12 @@ 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]));
+  },
 
   /**
    * Whether a segment carries every track the init promises.

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

@@ -49,6 +49,9 @@ 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.
  */
 
 /** @type {Readonly<Record<string, SegmentFormat>>} */

package/services/server/ViewerRequests.js

@@ -569,7 +569,9 @@ export class ViewerRequests {
         index,
         startSeconds: timeline.publishedStartOf(index),
         endSeconds: timeline.publishedStartOf(index + 1),
-        mediaRanges: this.#host.segmentStore.mediaRangesOf(output.outputKey, index)
+        mediaRanges: this.#host.segmentStore.mediaRangesOf(output.outputKey, index, {
+          startSeconds: timeline.publishedStartOf(index)
+        })
       }));
       const sourceIndexes = [output.spec.video?.fileIndex, output.spec.audio?.fileIndex]
         .filter((fileIndex) => Number.isInteger(fileIndex) && fileIndex >= 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/test/fmp4-presentation-clock.test.js

@@ -2,6 +2,10 @@ 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";
 
 function box(type, body) {
   const header = Buffer.alloc(8);
@@ -70,3 +74,24 @@ 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);
+});