@torrent-tv/proxy 2.87.14 → 2.87.16

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

@@ -0,0 +1,72 @@
+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";
+
+function box(type, body) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(body.length + 8);
+  header.write(type, 4);
+  return Buffer.concat([header, body]);
+}
+
+function init(emptyMs, mediaTime) {
+  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 elst = Buffer.alloc(32);
+  elst.writeUInt32BE(2, 4);
+  elst.writeUInt32BE(emptyMs, 8);
+  elst.writeInt32BE(-1, 12);
+  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))
+  ]))]));
+}
+
+function fragment(decodeTime, composition) {
+  const tfhd = Buffer.alloc(12);
+  tfhd.writeUIntBE(8, 1, 3);
+  tfhd.writeUInt32BE(1, 4);
+  tfhd.writeUInt32BE(1000, 8);
+  const tfdt = Buffer.alloc(12);
+  tfdt[0] = 1;
+  tfdt.writeBigUInt64BE(BigInt(decodeTime), 4);
+  const trun = Buffer.alloc(12);
+  trun.writeUIntBE(0x800, 1, 3);
+  trun.writeUInt32BE(1, 4);
+  trun.writeUInt32BE(composition, 8);
+  return box("moof", box("traf", Buffer.concat([
+    box("tfhd", tfhd), box("tfdt", tfdt), box("trun", trun)
+  ])));
+}
+
+test("a shared init preserves presentation times without adding composition delay twice", () => {
+  const shared = fmp4Format.prepareSharedInit(init(83, 2000));
+  const own = init(4125, 3000);
+  const media = Buffer.concat([fragment(0, 3000), fragment(48000, 3000)]);
+  const raw = Buffer.concat([own, media]);
+  const prepared = fmp4Format.prepareSegmentBytes(media, {
+    startSeconds: 4.125, initBytes: shared, rawBytes: raw
+  });
+  assert.deepEqual(readPresentationRanges(Buffer.concat([shared, prepared])), readPresentationRanges(raw));
+  const times = [];
+  walkBoxes(prepared, (type, start) => {
+    if (type === "tfdt") times.push(Number(prepared.readBigUInt64BE(start + 4)));
+  });
+  assert.deepEqual(times, [98000, 146000]);
+});
+
+test("a shared init first read after a seek also supports returning to the beginning", () => {
+  const shared = fmp4Format.prepareSharedInit(init(304083, 2000));
+  const media = fragment(0, 2000);
+  const raw = Buffer.concat([init(83, 2000), media]);
+  const prepared = fmp4Format.prepareSegmentBytes(media, {
+    startSeconds: 0.083, initBytes: shared, rawBytes: raw
+  });
+  assert.deepEqual(readPresentationRanges(Buffer.concat([shared, prepared])), readPresentationRanges(raw));
+});

package/test/piece-disk-store.test.js

@@ -18,6 +18,26 @@ import { PieceDiskStore } from "../services/storage/piece-store/piece-disk-store
 
 const PIECE = 4096;
 
+test("bytes held before a memory wait cannot be forgotten or evicted", async () => {
+  const { store } = await makeStore(PIECE);
+  try {
+    await store.write(0, Buffer.alloc(PIECE, 7));
+    const release = store.hold(0);
+    store.forget(0);
+    store.forgetBehind([1]);
+    await store.write(1, Buffer.alloc(PIECE, 8));
+    const target = Buffer.alloc(PIECE);
+    assert.equal(await store.read(0, target), PIECE);
+    assert.equal(target[0], 7);
+    release();
+    release();
+    store.forget(0);
+    assert.equal(store.has(0), false);
+  } finally {
+    await store.destroy();
+  }
+});
+
 /**
  * @param {number | null} allowanceBytes
  * @returns {Promise<{ store: PieceDiskStore, directory: string, clock: { at: number } }>}

package/test/piece-store-reservations.test.js

@@ -22,6 +22,7 @@ const CHUNK = 1024;
  */
 function makeDisk({ failWrite = false, failRead = false, holdWrites = false } = {}) {
   const stored = new Map();
+  const reading = new Map();
   /** @type {Array<() => void>} */
   const held = [];
   return {
@@ -61,6 +62,15 @@ function makeDisk({ failWrite = false, failRead = false, holdWrites = false } =
     has(index) {
       return stored.has(index);
     },
+    hold(index) {
+      if (!stored.has(index)) return null;
+      reading.set(index, (reading.get(index) ?? 0) + 1);
+      return () => {
+        const count = reading.get(index) - 1;
+        if (count > 0) reading.set(index, count);
+        else reading.delete(index);
+      };
+    },
     async write(index, bytes) {
       if (holdWrites) {
         await new Promise((resolve) => held.push(resolve));
@@ -82,7 +92,7 @@ function makeDisk({ failWrite = false, failRead = false, holdWrites = false } =
       return bytes.length;
     },
     forget(index) {
-      stored.delete(index);
+      if (!reading.has(index)) stored.delete(index);
     },
     async close() {},
     async destroy() {
@@ -123,6 +133,21 @@ const get = (store, index) =>
     store.get(index, undefined, (error, bytes) => (error ? reject(error) : resolve(bytes)))
   );
 
+test("a revival holds disk bytes across the asynchronous memory reservation", async () => {
+  const { store, disk } = makeStore();
+  disk.stored.set(0, piece(0));
+  try {
+    const revival = store.reside(0);
+    disk.forget(0);
+    const located = await revival;
+    assert.deepEqual(Buffer.from(located.buffer, located.offset, located.length), piece(0));
+    disk.forget(0);
+    assert.equal(disk.has(0), false);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+  }
+});
+
 /**
  * Wait until a condition holds, rather than for a chosen interval — a test that
  * sleeps samples, it does not check (roadmap item 54).

package/test/playback-readiness.test.js

@@ -107,12 +107,14 @@ test("does not produce an ETA without a client-link measurement", () => {
   assert.equal(forecast.reason, "link-rate-unavailable");
 });
 
-test("rate trend projects the measured linear trend without a fitted weight", () => {
+test("rate forecast does not extrapolate acceleration beyond observed service", () => {
   const trend = new RateTrend();
   trend.add(9_000, 2);
   trend.add(10_000, 4);
 
-  assert.equal(forecastRate(trend.snapshot(), 10_000, 2), 6);
+  const predicted = forecastRate(trend.snapshot(), 10_000, 2);
+  assert.ok(predicted > 3 && predicted < 4);
+  assert.ok(forecastRate(trend.snapshot(), 100_000, 2) >= 3);
 });
 
 test("uses each track's own segment boundaries and requires continuous coverage on both tracks", () => {
@@ -331,7 +333,7 @@ test("shares one torrent download rate across distinct video and audio files", (
   assert.ok(Math.abs(forecast.delaySeconds - 4.032) < 1e-8);
 });
 
-test("finds a safe interval when rising encode speed and falling link speed make the forecast non-monotonic", () => {
+test("does not invent future encode acceleration to start an unsustainable output", () => {
   const now = 1_000;
   const forecast = predictPlaybackReadiness({
     now,
@@ -360,7 +362,81 @@ test("finds a safe interval when rising encode speed and falling link speed make
   });
 
   assert.equal(forecast.ready, false);
-  assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Number.isFinite(forecast.delaySeconds));
-  assert.ok(forecast.delaySeconds > 4 && forecast.delaySeconds < 5);
+  assert.equal(forecast.reason, "no-safe-start-found");
+  assert.equal(forecast.delaySeconds, null);
+});
+
+test("a faster old probe cannot turn positive delivery into a permanent zero rate", () => {
+  const trend = new RateTrend(120);
+  trend.add(0, 112_400_000);
+  trend.add(66_757, 37_640_000);
+  assert.equal(forecastRate(trend.snapshot(), 20 * 60_000, 1443.97), 37_640_000);
+  assert.equal(trend.add(66_757, 37_640_000), false);
+});
+
+test("the measurement window retains one boundary sample and discards older history", () => {
+  const trend = new RateTrend(2);
+  trend.add(0, 100);
+  trend.add(1_000, 40);
+  trend.add(4_000, 20);
+  assert.equal(trend.snapshot().count, 2);
+  assert.equal(trend.snapshot().meanValue, 30);
+});
+
+function preparedEpisode(bufferLimitSeconds, linkReadings) {
+  const durationSeconds = 1443.97;
+  const boundaries = [0, 10.01, 18.977, 29.488];
+  for (let index = 4; index <= 197; index += 1) {
+    boundaries.push(29.488 + (durationSeconds - 29.488) * (index - 3) / 194);
+  }
+  const segments = boundaries.slice(0, -1).map((startSeconds, index) => ({
+    index, startSeconds, endSeconds: boundaries[index + 1]
+  }));
+  const tracks = [9_257_176.8, 189_000].map((bitsPerMediaSecond, index) => ({
+    id: String(index),
+    sourceIds: ["source"],
+    processedSeconds: 1437.269,
+    bitsPerMediaSecond,
+    readings: [],
+    segments,
+    readySegmentIndices: segments.map(({ index }) => index),
+    segmentSizesBytes: new Map(segments.map((segment) => [segment.index,
+      (segment.endSeconds - segment.startSeconds) * bitsPerMediaSecond / 8]))
+  }));
+  return {
+    now: 20 * 60_000,
+    positionSeconds: 0,
+    durationSeconds,
+    bufferedAheadSeconds: 19.187,
+    bufferLimitSeconds,
+    reserveSeconds: 5.674,
+    lookaheadSeconds: 120,
+    requiredAudio: true,
+    sources: [{ id: "source", complete: false, bytesPerMediaSecond: 1, readings: [{ at: 0, value: 0 }] }],
+    tracks,
+    linkReadings
+  };
+}
+
+test("starts a prepared episode despite an old declining link measurement", () => {
+  const forecast = predictPlaybackReadiness(preparedEpisode(120, [
+    { at: 0, value: 112_400_000 }, { at: 66_757, value: 37_640_000 }
+  ]));
+  assert.equal(forecast.preparedSegments, 394);
+  assert.equal(forecast.ready, true);
+  assert.equal(forecast.reason, "trajectory-safe-now");
+});
+
+test("the measured buffer proves capacity even when the loader reports a smaller target", () => {
+  const forecast = predictPlaybackReadiness(preparedEpisode(9.092, [{ at: 0, value: 37_640_000 }]));
+  assert.equal(forecast.ready, true);
+});
+
+test("a measured source stop is not replaced by hypothetical future recovery", () => {
+  const forecast = predictPlaybackReadiness(input({ sources: [{
+    id: "source", complete: false, bytesPerMediaSecond: 1,
+    readings: [{ at: 9_000, value: 10 }, { at: 10_000, value: 0 }]
+  }] }));
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.delaySeconds, null);
 });

package/test/playback-start-regressions.test.js

@@ -0,0 +1,99 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
+
+function encode() {
+  const child = new EventEmitter();
+  child.stdio = [null, new EventEmitter(), new EventEmitter(), new EventEmitter()];
+  child.stderr = child.stdio[2];
+  child.kill = () => {};
+  const published = [];
+  const ended = [];
+  const run = new EncodeRun({
+    address: "fake", from: 0, to: 1, encoder: new SoftwareEncoder(),
+    buildArgs: () => [], spawn: () => child, logger: { info() {}, warn() {} },
+    indexOfName: (name) => Number(name),
+    onClosed: (name) => { published.push(name); return name; },
+    onEnded: (value) => ended.push(value)
+  });
+  return { child, run, published, ended };
+}
+
+test("a clean short input never publishes its flushed tail", () => {
+  const { child, published, ended } = encode();
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "0\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, []);
+  assert.equal(ended[0].ending, "short");
+  assert.equal(ended[0].reached, -1);
+});
+
+test("completed cuts survive a failure but its last flushed file does not", () => {
+  const { child, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0"]);
+});
+
+test("normal completion drains the filename pipe before publishing the tail", () => {
+  const { child, published, ended } = encode();
+  child.emit("exit", 0, null);
+  assert.deepEqual(ended, []);
+  child.stdio[3].emit("data", "0\n1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0", "1"]);
+  assert.equal(ended[0].ending, "complete");
+});
+
+test("stopping retains an earlier closed cut and rejects the signal-flushed tail", () => {
+  const { child, run, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  run.stop("a different range is needed");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", null, "SIGTERM");
+  assert.deepEqual(published, ["0"]);
+});
+
+function state(clientRanges) {
+  return {
+    now: 10_000, positionSeconds: 0, durationSeconds: 8,
+    bufferedAheadSeconds: 8, bufferLimitSeconds: 8, reserveSeconds: 0, lookaheadSeconds: 8,
+    sources: [{ id: "source", complete: true }],
+    linkReadings: [{ at: 10_000, value: 80 }],
+    tracks: [{ id: "video", sourceIds: ["source"], processedSeconds: 8,
+      bitsPerMediaSecond: 80, readings: [{ at: 10_000, value: 2 }],
+      readySegmentIndices: [0, 1], segmentSizesBytes: new Map([[0, 40], [1, 40]]),
+      clientRanges, segments: [{ index: 0, startSeconds: 0, endSeconds: 4 },
+        { index: 1, startSeconds: 4, endSeconds: 8 }] }]
+  };
+}
+
+test("future browser ranges are retained rather than transferred again", () => {
+  const forecast = predictPlaybackReadiness(state([{ start: 4, end: 8 }]));
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 4) < 1e-8);
+});
+
+test("a real media hole is not hidden by the scalar buffer or ready file count", () => {
+  const input = state([{ start: 0, end: 3 }, { start: 4, end: 8 }]);
+  input.tracks[0].segments[0].mediaRanges = [{ start: 0, end: 3 }];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.bufferedSeconds, 3);
+  assert.equal(forecast.reason, "no-safe-start-found");
+});
+
+test("missing work before global progress can still be produced", () => {
+  const input = state([]);
+  input.tracks[0].readySegmentIndices = [1];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Number.isFinite(forecast.delaySeconds));
+});

package/test/segment-store.test.js

@@ -113,7 +113,7 @@ test("a piece still being written is not a piece, and its name says so", (t) =>
   assert.equal(store.pathOf(KEY, 1), null);
 
   // And closing it is one rename, after which it is servable.
-  assert.equal(store.publish(KEY, "making-0-00001.mp4", fmp4Format), "segment-00001.mp4");
+  assert.equal(store.publish(KEY, "making-0-00001.mp4", { ...fmp4Format, readMediaRanges: undefined }), "segment-00001.mp4");
   assert.equal(store.isClosed(KEY, 1), true);
 });