@torrent-tv/proxy 2.73.0 → 2.74.0

package/test/mp4-subtitles.test.js

@@ -1,127 +1,173 @@
-/**
- * @file Reading an MP4's text subtitle track out of its sample table.
- *
- * The file is built here, so every answer is known in advance: two cues at
- * stated times, in stated places, with an empty sample between them — the way
- * the format says "nothing on screen just now".
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { decodeSubtitleSample, readMp4SubtitlePlan } from "../services/container-index/mp4-subtitles.js";
-
-function box(type, payload) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(payload.length + 8, 0);
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, payload]);
-}
-
-function fullBox(type, payload) {
-  return box(type, Buffer.concat([Buffer.from([0, 0, 0, 0]), payload]));
-}
-
-function u32(...values) {
-  const buffer = Buffer.alloc(values.length * 4);
-  values.forEach((value, index) => buffer.writeUInt32BE(value, index * 4));
-  return buffer;
-}
-
-/** A `tx3g` sample: a two-byte length, then the text. */
-function textSample(text) {
-  const bytes = Buffer.from(text, "utf8");
-  const length = Buffer.alloc(2);
-  length.writeUInt16BE(bytes.length, 0);
-  return Buffer.concat([length, bytes]);
-}
-
-/**
- * A file with one text track: three samples, the middle one empty.
- *
- * @returns {{ file: Buffer, samples: Buffer[] }}
- */
-function buildFile() {
-  const samples = [textSample("First line"), Buffer.alloc(2), textSample("Second line")];
-  const timescale = 1000;
-
-  const mdhd = fullBox("mdhd", Buffer.concat([
-    u32(0, 0, timescale, 60_000),
-    // Language "eng", five bits a letter offset from 0x60, then a spare word.
-    Buffer.from([0x15, 0xc7, 0, 0])
-  ]));
-  const hdlr = fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("sbtl", "latin1"), u32(0, 0, 0)]));
-  const tkhd = fullBox("tkhd", u32(0, 0, 7, 0, 60_000));
-
-  const stsd = fullBox("stsd", Buffer.concat([u32(1), box("tx3g", Buffer.alloc(24))]));
-  // Two seconds a sample, so the cues sit at 0-2, 2-4 and 4-6 seconds.
-  const stts = fullBox("stts", Buffer.concat([u32(1), u32(3, 2000)]));
-  const stsz = fullBox("stsz", Buffer.concat([u32(0, 3), u32(...samples.map((s) => s.length))]));
-  const stsc = fullBox("stsc", Buffer.concat([u32(1), u32(1, 3, 1)]));
-
-  const stbl = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, fullBox("stco", Buffer.concat([u32(1), u32(0)]))]));
-  const minf = box("minf", stbl);
-  const mdia = box("mdia", Buffer.concat([mdhd, hdlr, minf]));
-  const trak = box("trak", Buffer.concat([tkhd, mdia]));
-  const moovDraft = box("moov", trak);
-
-  // The samples sit after moov, so the chunk offset is known only now. Its
-  // length does not change when the placeholder becomes the real value.
-  const mdatStart = moovDraft.length + 8;
-  const stcoReal = fullBox("stco", Buffer.concat([u32(1), u32(mdatStart)]));
-  const stblReal = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, stcoReal]));
-  const moov = box("moov", box("trak", Buffer.concat([
-    tkhd,
-    box("mdia", Buffer.concat([mdhd, hdlr, box("minf", stblReal)]))
-  ])));
-  const mdat = box("mdat", Buffer.concat(samples));
-  return { file: Buffer.concat([moov, mdat]), samples };
-}
-
-function readerOver(file) {
-  return async (start, end) => {
-    const last = Math.min(end, file.length - 1);
-    return start > last ? null : file.subarray(start, last + 1);
-  };
-}
-
-test("a text track's cues are found with their times and their byte ranges", async () => {
-  const { file, samples } = buildFile();
-
-  const plan = await readMp4SubtitlePlan(readerOver(file), file.length);
-
-  assert.equal(plan.tracks.length, 1);
-  const track = plan.tracks[0];
-  assert.equal(track.format, "tx3g");
-  assert.equal(track.language, "eng");
-  assert.equal(track.samples.length, 2, "the empty sample is a gap, not a cue");
-  assert.deepEqual(
-    track.samples.map((sample) => [sample.startSeconds, sample.endSeconds]),
-    [[0, 2], [4, 6]],
-    "times come from the duration table, and the gap keeps its place in it"
-  );
-  // The bytes the plan points at are the ones that hold the text.
-  const first = file.subarray(track.samples[0].offset, track.samples[0].offset + track.samples[0].size);
-  assert.equal(decodeSubtitleSample(first, "tx3g"), "First line");
-  const second = file.subarray(track.samples[1].offset, track.samples[1].offset + track.samples[1].size);
-  assert.equal(decodeSubtitleSample(second, "tx3g"), "Second line");
-  assert.equal(second.length, samples[2].length);
-});
-
-test("a file with no text track offers nothing", async () => {
-  const moov = box("moov", box("trak", box("mdia", Buffer.concat([
-    fullBox("mdhd", Buffer.concat([u32(0, 0, 1000, 100), Buffer.from([0, 0, 0, 0])])),
-    fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("vide", "latin1"), u32(0, 0, 0)]))
-  ]))));
-  const file = Buffer.concat([moov, box("mdat", Buffer.alloc(4))]);
-
-  const plan = await readMp4SubtitlePlan(readerOver(file), file.length);
-
-  assert.deepEqual(plan.tracks, []);
-});
-
-test("a WebVTT sample gives up the text inside its payload box", () => {
-  const payl = box("payl", Buffer.from("Hello there", "utf8"));
-  const sample = box("vttc", payl);
-
-  assert.equal(decodeSubtitleSample(sample, "wvtt"), "Hello there");
-});
+/**
+ * @file Reading an MP4's text subtitle track out of its sample table.
+ *
+ * The file is built here, so every answer is known in advance: two cues at
+ * stated times, in stated places, with an empty sample between them — the way
+ * the format says "nothing on screen just now".
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Mp4Container } from "../services/container/Mp4Container.js";
+
+function box(type, payload) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(payload.length + 8, 0);
+  header.write(type, 4, "latin1");
+  return Buffer.concat([header, payload]);
+}
+
+function fullBox(type, payload) {
+  return box(type, Buffer.concat([Buffer.from([0, 0, 0, 0]), payload]));
+}
+
+function u32(...values) {
+  const buffer = Buffer.alloc(values.length * 4);
+  values.forEach((value, index) => buffer.writeUInt32BE(value, index * 4));
+  return buffer;
+}
+
+/** A `tx3g` sample: a two-byte length, then the text. */
+function textSample(text) {
+  const bytes = Buffer.from(text, "utf8");
+  const length = Buffer.alloc(2);
+  length.writeUInt16BE(bytes.length, 0);
+  return Buffer.concat([length, bytes]);
+}
+
+/**
+ * A file with one text track: three samples, the middle one empty.
+ *
+ * @param {number} [displayFlags] - The `tx3g` sample entry's display flags.
+ * @param {boolean} [withFtyp] - Open the file with an `ftyp` box, which is what
+ *   the container layer sniffs for before it will read anything.
+ * @returns {{ file: Buffer, samples: Buffer[] }}
+ */
+function buildFile(displayFlags = 0, withFtyp = false) {
+  const samples = [textSample("First line"), Buffer.alloc(2), textSample("Second line")];
+  const timescale = 1000;
+
+  const mdhd = fullBox("mdhd", Buffer.concat([
+    u32(0, 0, timescale, 60_000),
+    // Language "eng", five bits a letter offset from 0x60, then a spare word.
+    Buffer.from([0x15, 0xc7, 0, 0])
+  ]));
+  const hdlr = fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("sbtl", "latin1"), u32(0, 0, 0)]));
+  const tkhd = fullBox("tkhd", u32(0, 0, 7, 0, 60_000));
+
+  // A sample entry opens with 6 reserved bytes and a 2-byte data reference
+  // index, and `displayFlags` is the 32 bits after them.
+  const tx3g = Buffer.alloc(24);
+  tx3g.writeUInt32BE(displayFlags >>> 0, 8);
+  const stsd = fullBox("stsd", Buffer.concat([u32(1), box("tx3g", tx3g)]));
+  // Two seconds a sample, so the cues sit at 0-2, 2-4 and 4-6 seconds.
+  const stts = fullBox("stts", Buffer.concat([u32(1), u32(3, 2000)]));
+  const stsz = fullBox("stsz", Buffer.concat([u32(0, 3), u32(...samples.map((s) => s.length))]));
+  const stsc = fullBox("stsc", Buffer.concat([u32(1), u32(1, 3, 1)]));
+
+  const stbl = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, fullBox("stco", Buffer.concat([u32(1), u32(0)]))]));
+  const minf = box("minf", stbl);
+  const mdia = box("mdia", Buffer.concat([mdhd, hdlr, minf]));
+  const trak = box("trak", Buffer.concat([tkhd, mdia]));
+  const moovDraft = box("moov", trak);
+
+  // The samples sit after moov, so the chunk offset is known only now. Its
+  // length does not change when the placeholder becomes the real value.
+  const ftyp = withFtyp
+    ? box("ftyp", Buffer.concat([Buffer.from("isom", "latin1"), u32(512), Buffer.from("isom", "latin1")]))
+    : Buffer.alloc(0);
+  const mdatStart = ftyp.length + moovDraft.length + 8;
+  const stcoReal = fullBox("stco", Buffer.concat([u32(1), u32(mdatStart)]));
+  const stblReal = box("stbl", Buffer.concat([stsd, stts, stsz, stsc, stcoReal]));
+  const moov = box("moov", box("trak", Buffer.concat([
+    tkhd,
+    box("mdia", Buffer.concat([mdhd, hdlr, box("minf", stblReal)]))
+  ])));
+  const mdat = box("mdat", Buffer.concat(samples));
+  return { file: Buffer.concat([ftyp, moov, mdat]), samples };
+}
+
+function readerOver(file) {
+  return async (start, end) => {
+    const last = Math.min(end, file.length - 1);
+    return start > last ? null : file.subarray(start, last + 1);
+  };
+}
+
+test("a text track's cues are found with their times and their byte ranges", async () => {
+  const { file, samples } = buildFile();
+
+  const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
+
+  assert.equal(plan.tracks.length, 1);
+  const track = plan.tracks[0];
+  assert.equal(track.format, "tx3g");
+  assert.equal(track.language, "eng");
+  assert.equal(track.samples.length, 2, "the empty sample is a gap, not a cue");
+  assert.deepEqual(
+    track.samples.map((sample) => [sample.startSeconds, sample.endSeconds]),
+    [[0, 2], [4, 6]],
+    "times come from the duration table, and the gap keeps its place in it"
+  );
+  // The bytes the plan points at are the ones that hold the text.
+  const first = file.subarray(track.samples[0].offset, track.samples[0].offset + track.samples[0].size);
+  assert.equal(Mp4Container.cueTextOf(first, "tx3g"), "First line");
+  const second = file.subarray(track.samples[1].offset, track.samples[1].offset + track.samples[1].size);
+  assert.equal(Mp4Container.cueTextOf(second, "tx3g"), "Second line");
+  assert.equal(second.length, samples[2].length);
+});
+
+test("a file with no text track offers nothing", async () => {
+  const moov = box("moov", box("trak", box("mdia", Buffer.concat([
+    fullBox("mdhd", Buffer.concat([u32(0, 0, 1000, 100), Buffer.from([0, 0, 0, 0])])),
+    fullBox("hdlr", Buffer.concat([u32(0), Buffer.from("vide", "latin1"), u32(0, 0, 0)]))
+  ]))));
+  const file = Buffer.concat([moov, box("mdat", Buffer.alloc(4))]);
+
+  const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
+
+  assert.deepEqual(plan.tracks, []);
+});
+
+test("a WebVTT sample gives up the text inside its payload box", () => {
+  const payl = box("payl", Buffer.from("Hello there", "utf8"));
+  const sample = box("vttc", payl);
+
+  assert.equal(Mp4Container.cueTextOf(sample, "wvtt"), "Hello there");
+});
+
+test("the sample entry's display flags say whether the track is forced", async () => {
+  // Apple's QuickTime File Format, "Display flags" under Subtitle sample
+  // description: `0x40000000` "Some samples are forced", `0x80000000` "All
+  // samples are forced", and setting the second requires the first — together
+  // `0xC0000000`. `0x20000000` is vertical placement and says nothing about
+  // forcing.
+  const readFlags = async (displayFlags) => {
+    const { file } = buildFile(displayFlags);
+    const plan = await Mp4Container.readSubtitlePlan(readerOver(file), file.length);
+    const track = plan.tracks[0];
+    return [track.someSamplesForced, track.allSamplesForced];
+  };
+
+  assert.deepEqual(await readFlags(0), [false, false]);
+  assert.deepEqual(await readFlags(0x40000000), [true, false]);
+  assert.deepEqual(await readFlags(0xc0000000), [true, true]);
+  // A writer that set only the second bit still means the track is forced.
+  assert.deepEqual(await readFlags(0x80000000), [false, true]);
+  // Vertical placement is a different field's business.
+  assert.deepEqual(await readFlags(0x20000000), [false, false]);
+});
+
+test("a forced sample entry reaches the track the viewer is offered", async () => {
+  const forced = buildFile(0xc0000000, true).file;
+  const plain = buildFile(0, true).file;
+
+  const trackOf = async (file) => {
+    const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
+    const tracks = await container.readTracks();
+    return tracks.find((track) => track.type === "subtitle");
+  };
+
+  assert.equal((await trackOf(forced))?.isForced, true);
+  assert.equal((await trackOf(plain))?.isForced, false);
+});

package/test/produced-index.test.js

@@ -0,0 +1,188 @@
+/**
+ * @file The session's one statement of what it has produced.
+ *
+ * Every check builds real directories and real files, because what is under
+ * test is exactly the reading of them: which run's copy wins, what an empty
+ * file counts as, and whether a directory that has not changed is read again.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import os from "node:os";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, unlinkSync } from "node:fs";
+
+import { ProducedIndex } from "../services/produced-index.js";
+
+/** The naming the fMP4 format uses, reduced to what the index asks of it. */
+const segmentFormat = {
+  isSegmentFileName: (name) => /^segment-\d{5}\.mp4$/.test(name),
+  segmentIndexFromName: (name) => {
+    const match = /^segment-(\d{5})\.mp4$/.exec(name);
+    return match ? Number(match[1]) : -1;
+  }
+};
+
+const nameOf = (index) => `segment-${String(index).padStart(5, "0")}.mp4`;
+
+function session() {
+  const dirPath = mkdtempSync(path.join(os.tmpdir(), "produced-index-"));
+  return {
+    dirPath,
+    run(number) {
+      const dir = path.join(dirPath, `run-${number}`);
+      mkdirSync(dir, { recursive: true });
+      return {
+        dir,
+        write(index, contents) {
+          writeFileSync(path.join(dir, nameOf(index)), contents);
+          return path.join(dir, nameOf(index));
+        },
+        writeNamed(name, contents) {
+          writeFileSync(path.join(dir, name), contents);
+          return path.join(dir, name);
+        }
+      };
+    },
+    index: () => new ProducedIndex({ dirPath, segmentFormat }),
+    remove: () => rmSync(dirPath, { recursive: true, force: true })
+  };
+}
+
+test("a file with bytes in it is produced; one that was only opened is not", () => {
+  const s = session();
+  try {
+    const run = s.run(1);
+    run.write(1, "a piece");
+    run.write(2, "");
+    const index = s.index();
+
+    assert.deepEqual([...index.segmentNumbers()], [1]);
+    assert.equal(index.pathOf(nameOf(1)), path.join(run.dir, nameOf(1)));
+    // The empty file exists and is not an answer — this is the pair of beliefs
+    // that stopped playback for ten minutes on 2026-09-03, now one belief.
+    assert.equal(index.pathOf(nameOf(2)), null);
+  } finally {
+    s.remove();
+  }
+});
+
+test("the newest run's copy wins, whichever run was read last", () => {
+  const s = session();
+  try {
+    const first = s.run(1);
+    first.write(7, "old");
+    const second = s.run(2);
+    second.write(7, "new");
+    const index = s.index();
+
+    assert.equal(index.pathOf(nameOf(7)), path.join(second.dir, nameOf(7)));
+
+    // Touching the OLDER run must not make it the answer: the rule is applied
+    // when the question is asked, not when a directory happens to be read.
+    first.write(8, "older still");
+    assert.equal(index.pathOf(nameOf(7)), path.join(second.dir, nameOf(7)));
+    assert.equal(index.pathOf(nameOf(8)), path.join(first.dir, nameOf(8)));
+  } finally {
+    s.remove();
+  }
+});
+
+test("the union of every run is what the session holds", () => {
+  const s = session();
+  try {
+    s.run(1).write(1, "x");
+    s.run(2).write(2, "y");
+    s.run(3).write(3, "z");
+    const index = s.index();
+    assert.deepEqual([...index.segmentNumbers()].sort((a, b) => a - b), [1, 2, 3]);
+  } finally {
+    s.remove();
+  }
+});
+
+test("a file that is not a segment is found by name", () => {
+  const s = session();
+  try {
+    const run = s.run(1);
+    run.writeNamed("init.mp4", "header");
+    const index = s.index();
+    assert.equal(index.pathOf("init.mp4"), path.join(run.dir, "init.mp4"));
+    assert.ok(index.fileNames().includes("init.mp4"));
+  } finally {
+    s.remove();
+  }
+});
+
+test("a run whose directory is gone stops answering", () => {
+  const s = session();
+  try {
+    const run = s.run(1);
+    run.write(4, "piece");
+    const index = s.index();
+    assert.equal(index.segmentNumbers().size, 1);
+
+    rmSync(run.dir, { recursive: true, force: true });
+    assert.equal(index.segmentNumbers().size, 0);
+    assert.equal(index.pathOf(nameOf(4)), null);
+  } finally {
+    s.remove();
+  }
+});
+
+test("a file removed on purpose is not still an answer", () => {
+  const s = session();
+  try {
+    const run = s.run(1);
+    const written = run.write(9, "piece");
+    const index = s.index();
+    assert.equal(index.pathOf(nameOf(9)), written);
+
+    unlinkSync(written);
+    // The directory's own time has moved, but a caller that deletes and asks in
+    // the same tick must not be told the file is there.
+    index.invalidate();
+    assert.equal(index.pathOf(nameOf(9)), null);
+  } finally {
+    s.remove();
+  }
+});
+
+test("an unchanged run is not listed again", () => {
+  const s = session();
+  try {
+    const run = s.run(1);
+    run.write(1, "piece");
+    const index = s.index();
+
+    index.segmentNumbers();
+    const afterFirst = index.directoryReads;
+    assert.equal(afterFirst, 1, "the first question reads the run");
+
+    for (let asked = 0; asked < 20; asked += 1) {
+      index.segmentNumbers();
+      index.pathOf(nameOf(1));
+    }
+    assert.equal(
+      index.directoryReads,
+      afterFirst,
+      "forty more questions about a run that has not changed must read nothing"
+    );
+
+    run.write(2, "another piece");
+    index.segmentNumbers();
+    assert.equal(index.directoryReads, afterFirst + 1, "a run that gained a file is read once more");
+  } finally {
+    s.remove();
+  }
+});
+
+test("a session directory that does not exist answers with nothing", () => {
+  const index = new ProducedIndex({
+    dirPath: path.join(os.tmpdir(), "produced-index-absent-0000"),
+    segmentFormat
+  });
+  assert.deepEqual(index.runDirs(), []);
+  assert.equal(index.pathOf(nameOf(1)), null);
+  assert.deepEqual([...index.segmentNumbers()], []);
+});