@torrent-tv/proxy 2.88.3 → 2.88.4

package/test/audio-buffer-continuity.test.js

@@ -1,70 +1,70 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import test from "node:test";
-import { readPresentationRanges, translatePresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
-import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
-
-const evidence = JSON.parse(readFileSync(new URL("./fixtures/audio-frame-boundary.json", import.meta.url), "utf8"));
-const header = Buffer.from(evidence.files["init.mp4"], "base64");
-
-function ranges(name, shiftedFrames = 0) {
-  const bytes = Buffer.from(evidence.files[name], "base64");
-  let frameTicks;
-  walkBoxes(bytes, (type, start) => {
-    if (type === "tfhd") {
-      const flags = bytes.readUIntBE(start + 1, 3);
-      const at = start + 8 + ((flags & 1) ? 8 : 0) + ((flags & 2) ? 4 : 0);
-      if (flags & 8) frameTicks = bytes.readUInt32BE(at);
-    }
-    if (type === "tfdt" && shiftedFrames) {
-      assert.ok(frameTicks > 0);
-      bytes.writeBigUInt64BE(bytes.readBigUInt64BE(start + 4) + BigInt(frameTicks * shiftedFrames), start + 4);
-    }
-  });
-  return translatePresentationRanges(readPresentationRanges(Buffer.concat([header, bytes])), header, 0);
-}
-
-function state(second = ranges("segment-00172.mp4")) {
-  const first = ranges("segment-00171.mp4");
-  const now = 1000;
-  return {
-    now,
-    positionSeconds: first[0].start,
-    durationSeconds: second.at(-1).end,
-    bufferLimitSeconds: second.at(-1).end - first[0].start,
-    reserveSeconds: 0,
-    lookaheadSeconds: second.at(-1).end - first[0].start,
-    sources: [{ id: "source", complete: true }],
-    linkReadings: [{ at: now, value: 1_000_000 }],
-    tracks: [{
-      id: "audio", sourceIds: ["source"], clientRanges: [
-        { start: evidence.browserBufferedRanges[0][0], end: evidence.browserBufferedRanges[0][1] }
-      ],
-      readings: [{ at: now, value: 1 }],
-      readySegmentIndices: [0, 1], segmentSizesBytes: { 0: 170000, 1: 170000 },
-      segments: [
-        { index: 0, startSeconds: first[0].start, endSeconds: second[0].start, mediaRanges: first },
-        { index: 1, startSeconds: second[0].start, endSeconds: second.at(-1).end, mediaRanges: second }
-      ]
-    }]
-  };
-}
-
-test("captured AAC boundary agrees with Chrome's continuous buffered range", () => {
-  const input = state();
-  assert.equal(predictPlaybackReadiness(input).ready, true);
-  for (const segment of input.tracks[0].segments) {
-    segment.mediaRanges = segment.mediaRanges.map(({ start, end }) => ({ start, end }));
-  }
-  assert.equal(predictPlaybackReadiness(input).reason, "no-safe-start-found");
-});
-
-test("four missing AAC frames preserve the discontinuity observed in Chrome", () => {
-  assert.equal(predictPlaybackReadiness(state(ranges("segment-00172.mp4", 4))).reason, "no-safe-start-found");
-});
-
-test("a join boundary never supplies audio before the adjacent segment arrives", () => {
-  const input = state();
-  input.linkReadings[0].value = 1;
-  assert.notEqual(predictPlaybackReadiness(input).ready, true);
-});
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { readPresentationRanges, translatePresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
+import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
+
+const evidence = JSON.parse(readFileSync(new URL("./fixtures/audio-frame-boundary.json", import.meta.url), "utf8"));
+const header = Buffer.from(evidence.files["init.mp4"], "base64");
+
+function ranges(name, shiftedFrames = 0) {
+  const bytes = Buffer.from(evidence.files[name], "base64");
+  let frameTicks;
+  walkBoxes(bytes, (type, start) => {
+    if (type === "tfhd") {
+      const flags = bytes.readUIntBE(start + 1, 3);
+      const at = start + 8 + ((flags & 1) ? 8 : 0) + ((flags & 2) ? 4 : 0);
+      if (flags & 8) frameTicks = bytes.readUInt32BE(at);
+    }
+    if (type === "tfdt" && shiftedFrames) {
+      assert.ok(frameTicks > 0);
+      bytes.writeBigUInt64BE(bytes.readBigUInt64BE(start + 4) + BigInt(frameTicks * shiftedFrames), start + 4);
+    }
+  });
+  return translatePresentationRanges(readPresentationRanges(Buffer.concat([header, bytes])), header, 0);
+}
+
+function state(second = ranges("segment-00172.mp4")) {
+  const first = ranges("segment-00171.mp4");
+  const now = 1000;
+  return {
+    now,
+    positionSeconds: first[0].start,
+    durationSeconds: second.at(-1).end,
+    bufferLimitSeconds: second.at(-1).end - first[0].start,
+    reserveSeconds: 0,
+    lookaheadSeconds: second.at(-1).end - first[0].start,
+    sources: [{ id: "source", complete: true }],
+    linkReadings: [{ at: now, value: 1_000_000 }],
+    tracks: [{
+      id: "audio", sourceIds: ["source"], clientRanges: [
+        { start: evidence.browserBufferedRanges[0][0], end: evidence.browserBufferedRanges[0][1] }
+      ],
+      readings: [{ at: now, value: 1 }],
+      readySegmentIndices: [0, 1], segmentSizesBytes: { 0: 170000, 1: 170000 },
+      segments: [
+        { index: 0, startSeconds: first[0].start, endSeconds: second[0].start, mediaRanges: first },
+        { index: 1, startSeconds: second[0].start, endSeconds: second.at(-1).end, mediaRanges: second }
+      ]
+    }]
+  };
+}
+
+test("captured AAC boundary agrees with Chrome's continuous buffered range", () => {
+  const input = state();
+  assert.equal(predictPlaybackReadiness(input).ready, true);
+  for (const segment of input.tracks[0].segments) {
+    segment.mediaRanges = segment.mediaRanges.map(({ start, end }) => ({ start, end }));
+  }
+  assert.equal(predictPlaybackReadiness(input).reason, "no-safe-start-found");
+});
+
+test("four missing AAC frames preserve the discontinuity observed in Chrome", () => {
+  assert.equal(predictPlaybackReadiness(state(ranges("segment-00172.mp4", 4))).reason, "no-safe-start-found");
+});
+
+test("a join boundary never supplies audio before the adjacent segment arrives", () => {
+  const input = state();
+  input.linkReadings[0].value = 1;
+  assert.notEqual(predictPlaybackReadiness(input).ready, true);
+});

package/test/audio-inventory.test.js

@@ -1,212 +1,212 @@
-/**
- * @file One numbered list of soundtracks, from two readings of the same file.
- *
- * Two things are being pinned here, and each has cost a real failure elsewhere
- * in this project:
- *
- * 1. **The alignment guard.** The container reading is used ONLY when it can be
- *    lined up with ffmpeg's own numbering, because `0:a:N` is what the encoder
- *    is handed — a flag attributed to the wrong track is worse than a missing
- *    one. Same discipline as `subtitle-defaults.js`, for the same reason.
- * 2. **The flat numbering.** The browser's menu, the `audioTrackIndex` on a
- *    session request and the `a/<n>/` address of a rendition are one number.
- *    Embedded tracks must keep the numbers they have always had, so that a
- *    session created against an older cached plan means the same thing.
- */
-
-import test from "node:test";
-import { Container } from "../services/media/container/Container.js";
-import { AudioTrack } from "../services/media/tracks/AudioTrack.js";
-import assert from "node:assert/strict";
-import {
-  audioRenditionName,
-  buildAudioInventory,
-  enrichAudioInventoryFromSidecar,
-  resolveAudioIndex
-} from "../services/media/audio-inventory.js";
-
-test("a pair agreeing on language is accepted", () => {
-  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "jpn" }), true);
-});
-
-test("a pair disagreeing on language is refused", () => {
-  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "rus" }), false);
-});
-
-test("two tracks that say nothing about themselves do not break the alignment", () => {
-  assert.equal(Container.pairingHolds({ language: "und", title: "" }, { language: "", name: "" }), true);
-});
-
-test("the container's own flags reach the merged track", () => {
-  const merged = Container.mergeAudioFlags(
-    [
-      { index: 0, language: "eng", title: "", isDefault: true, codec: "aac" },
-      { index: 1, language: "eng", title: "Director", isDefault: true, codec: "ac3" }
-    ],
-    [
-      { language: "eng", name: "", isOriginal: true, isDefault: true, declaresDefault: true, channels: 6 },
-      { language: "eng", name: "Director", isCommentary: true, isDefault: false, declaresDefault: true, channels: 2 }
-    ]
-  );
-  assert.equal(merged.aligned, true);
-  assert.equal(merged.tracks[0].isOriginal, true);
-  assert.equal(merged.tracks[0].channels, 6);
-  assert.equal(merged.tracks[1].isCommentary, true);
-  // Matroska defaults FlagDefault to 1 and ffmpeg prints the applied default, so
-  // the banner said both tracks were default. The container says otherwise.
-  assert.equal(merged.tracks[1].isDefault, false);
-});
-
-test("a count that differs drops the container reading whole", () => {
-  const merged = Container.mergeAudioFlags(
-    [{ index: 0, language: "eng", isDefault: true }],
-    [{ language: "eng" }, { language: "rus" }]
-  );
-  assert.equal(merged.aligned, false);
-  assert.match(merged.reason, /declares 2 audio tracks and the probe found 1/);
-  // Nothing of it is used — not even the flags that happened to line up.
-  assert.equal(merged.tracks[0].isCommentary, false);
-  assert.equal(merged.tracks[0].declaresDefault, false);
-});
-
-test("one pair that agrees on neither language nor title drops it too", () => {
-  const merged = Container.mergeAudioFlags(
-    [{ index: 0, language: "jpn", title: "" }, { index: 1, language: "rus", title: "" }],
-    [{ language: "jpn", name: "" }, { language: "eng", name: "" }]
-  );
-  assert.equal(merged.aligned, false);
-  assert.match(merged.reason, /audio 1 is/);
-});
-
-test("embedded tracks keep the numbers they have always had, sidecars follow", () => {
-  const inventory = buildAudioInventory({
-    embedded: [
-      { language: "jpn", codec: "aac", isDefault: true },
-      { language: "eng", codec: "ac3", title: "Commentary", isCommentary: true }
-    ],
-    videoFileIndex: 24,
-    sidecars: [
-      {
-        file: { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" },
-        tracks: [{ language: "rus", codecId: "A_AC3", channels: 6 }]
-      }
-    ]
-  });
-
-  assert.deepEqual(inventory.map((entry) => entry.index), [0, 1, 2]);
-  assert.deepEqual(inventory.map((entry) => entry.fileIndex), [24, 24, 12]);
-  assert.deepEqual(inventory.map((entry) => entry.sourceTrackIndex), [0, 1, 0]);
-  assert.deepEqual(inventory.map((entry) => entry.kind), ["embedded", "embedded", "sidecar"]);
-  assert.equal(inventory[2].codec, "ac3");
-  assert.deepEqual(inventory[2].folders, ["Rus Sound"]);
-  assert.equal(inventory[2].fileName, "ep.mka");
-});
-
-test("late sidecar metadata enriches the existing entry without changing its address", () => {
-  const file = { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" };
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "jpn", codec: "aac" }],
-    videoFileIndex: 24,
-    sidecars: [{ file, tracks: [] }]
-  });
-  const addresses = inventory.map(({ index, fileIndex, sourceTrackIndex, kind }) => ({
-    index,
-    fileIndex,
-    sourceTrackIndex,
-    kind
-  }));
-
-  assert.equal(enrichAudioInventoryFromSidecar(inventory, file, {
-    language: "rus",
-    languageBcp47: "ru",
-    codecId: "A_AC3",
-    channels: 6,
-    isOriginal: true
-  }), true);
-
-  assert.deepEqual(inventory.map(({ index, fileIndex, sourceTrackIndex, kind }) => ({
-    index,
-    fileIndex,
-    sourceTrackIndex,
-    kind
-  })), addresses);
-  assert.equal(inventory.length, 2);
-  assert.equal(inventory[1].codec, "ac3");
-  assert.equal(inventory[1].languageBcp47, "ru");
-  assert.equal(inventory[1].channels, 6);
-  assert.equal(inventory[1].isOriginal, true);
-});
-
-test("a sidecar whose table could not be read is still offered, as one track", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "eng", codec: "aac" }],
-    videoFileIndex: 0,
-    sidecars: [{ file: { fileIndex: 1, name: "dub.ac3", folders: [], extension: ".ac3" }, tracks: [] }]
-  });
-  assert.equal(inventory.length, 2);
-  assert.equal(inventory[1].sourceTrackIndex, 0);
-  // The extension of a bare elementary stream IS its codec.
-  assert.equal(inventory[1].codec, "ac3");
-});
-
-test("a sidecar carrying two tracks contributes both", () => {
-  const inventory = buildAudioInventory({
-    embedded: [],
-    videoFileIndex: 0,
-    sidecars: [
-      {
-        file: { fileIndex: 3, name: "dubs.mka", folders: [], extension: ".mka" },
-        tracks: [{ language: "rus" }, { language: "ukr" }]
-      }
-    ]
-  });
-  assert.deepEqual(inventory.map((entry) => [entry.index, entry.sourceTrackIndex]), [[0, 0], [1, 1]]);
-});
-
-test("the flat number resolves back to a file and a track inside it", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "jpn" }],
-    videoFileIndex: 24,
-    sidecars: [{ file: { fileIndex: 12, name: "ep.mka", folders: [], extension: ".mka" }, tracks: [{}] }]
-  });
-  assert.equal(resolveAudioIndex(inventory, 1).fileIndex, 12);
-  assert.equal(resolveAudioIndex(inventory, 1).sourceTrackIndex, 0);
-  assert.equal(resolveAudioIndex(inventory, 9), null);
-});
-
-test("codec identifiers are translated to the names the browser judges by", () => {
-  assert.equal(AudioTrack.codecNameOf({ codec: "AAC" }), "aac");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AC3" }), "ac3");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AAC/MPEG4/LC" }), "aac");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "A_PCM/INT/LIT" }), "pcm");
-  assert.equal(AudioTrack.codecNameOf({ codecId: "ec-3" }), "eac3");
-  assert.equal(AudioTrack.codecNameOf({}, ".dts"), "dts");
-  assert.equal(AudioTrack.codecNameOf({}, ".unknown"), "");
-});
-
-test("a rendition is named by what the file says, and two never share a name", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "jpn" }],
-    videoFileIndex: 0,
-    sidecars: [
-      { file: { fileIndex: 1, name: "a.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] },
-      { file: { fileIndex: 2, name: "b.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] }
-    ]
-  });
-  assert.equal(audioRenditionName(inventory[0], inventory), "jpn");
-  // Both sidecars sit in the same folder and neither names itself, so the names
-  // would collide — and hls.js groups renditions by name.
-  assert.notEqual(
-    audioRenditionName(inventory[1], inventory),
-    audioRenditionName(inventory[2], inventory)
-  );
-});
-
-test("a commentary says so in its rendition name", () => {
-  const inventory = buildAudioInventory({
-    embedded: [{ language: "eng" }, { language: "eng", title: "Director", isCommentary: true }],
-    videoFileIndex: 0,
-    sidecars: []
-  });
-  assert.match(audioRenditionName(inventory[1], inventory), /commentary/);
-});
+/**
+ * @file One numbered list of soundtracks, from two readings of the same file.
+ *
+ * Two things are being pinned here, and each has cost a real failure elsewhere
+ * in this project:
+ *
+ * 1. **The alignment guard.** The container reading is used ONLY when it can be
+ *    lined up with ffmpeg's own numbering, because `0:a:N` is what the encoder
+ *    is handed — a flag attributed to the wrong track is worse than a missing
+ *    one. Same discipline as `subtitle-defaults.js`, for the same reason.
+ * 2. **The flat numbering.** The browser's menu, the `audioTrackIndex` on a
+ *    session request and the `a/<n>/` address of a rendition are one number.
+ *    Embedded tracks must keep the numbers they have always had, so that a
+ *    session created against an older cached plan means the same thing.
+ */
+
+import test from "node:test";
+import { Container } from "../services/media/container/Container.js";
+import { AudioTrack } from "../services/media/tracks/AudioTrack.js";
+import assert from "node:assert/strict";
+import {
+  audioRenditionName,
+  buildAudioInventory,
+  enrichAudioInventoryFromSidecar,
+  resolveAudioIndex
+} from "../services/media/audio-inventory.js";
+
+test("a pair agreeing on language is accepted", () => {
+  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "jpn" }), true);
+});
+
+test("a pair disagreeing on language is refused", () => {
+  assert.equal(Container.pairingHolds({ language: "jpn" }, { language: "rus" }), false);
+});
+
+test("two tracks that say nothing about themselves do not break the alignment", () => {
+  assert.equal(Container.pairingHolds({ language: "und", title: "" }, { language: "", name: "" }), true);
+});
+
+test("the container's own flags reach the merged track", () => {
+  const merged = Container.mergeAudioFlags(
+    [
+      { index: 0, language: "eng", title: "", isDefault: true, codec: "aac" },
+      { index: 1, language: "eng", title: "Director", isDefault: true, codec: "ac3" }
+    ],
+    [
+      { language: "eng", name: "", isOriginal: true, isDefault: true, declaresDefault: true, channels: 6 },
+      { language: "eng", name: "Director", isCommentary: true, isDefault: false, declaresDefault: true, channels: 2 }
+    ]
+  );
+  assert.equal(merged.aligned, true);
+  assert.equal(merged.tracks[0].isOriginal, true);
+  assert.equal(merged.tracks[0].channels, 6);
+  assert.equal(merged.tracks[1].isCommentary, true);
+  // Matroska defaults FlagDefault to 1 and ffmpeg prints the applied default, so
+  // the banner said both tracks were default. The container says otherwise.
+  assert.equal(merged.tracks[1].isDefault, false);
+});
+
+test("a count that differs drops the container reading whole", () => {
+  const merged = Container.mergeAudioFlags(
+    [{ index: 0, language: "eng", isDefault: true }],
+    [{ language: "eng" }, { language: "rus" }]
+  );
+  assert.equal(merged.aligned, false);
+  assert.match(merged.reason, /declares 2 audio tracks and the probe found 1/);
+  // Nothing of it is used — not even the flags that happened to line up.
+  assert.equal(merged.tracks[0].isCommentary, false);
+  assert.equal(merged.tracks[0].declaresDefault, false);
+});
+
+test("one pair that agrees on neither language nor title drops it too", () => {
+  const merged = Container.mergeAudioFlags(
+    [{ index: 0, language: "jpn", title: "" }, { index: 1, language: "rus", title: "" }],
+    [{ language: "jpn", name: "" }, { language: "eng", name: "" }]
+  );
+  assert.equal(merged.aligned, false);
+  assert.match(merged.reason, /audio 1 is/);
+});
+
+test("embedded tracks keep the numbers they have always had, sidecars follow", () => {
+  const inventory = buildAudioInventory({
+    embedded: [
+      { language: "jpn", codec: "aac", isDefault: true },
+      { language: "eng", codec: "ac3", title: "Commentary", isCommentary: true }
+    ],
+    videoFileIndex: 24,
+    sidecars: [
+      {
+        file: { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" },
+        tracks: [{ language: "rus", codecId: "A_AC3", channels: 6 }]
+      }
+    ]
+  });
+
+  assert.deepEqual(inventory.map((entry) => entry.index), [0, 1, 2]);
+  assert.deepEqual(inventory.map((entry) => entry.fileIndex), [24, 24, 12]);
+  assert.deepEqual(inventory.map((entry) => entry.sourceTrackIndex), [0, 1, 0]);
+  assert.deepEqual(inventory.map((entry) => entry.kind), ["embedded", "embedded", "sidecar"]);
+  assert.equal(inventory[2].codec, "ac3");
+  assert.deepEqual(inventory[2].folders, ["Rus Sound"]);
+  assert.equal(inventory[2].fileName, "ep.mka");
+});
+
+test("late sidecar metadata enriches the existing entry without changing its address", () => {
+  const file = { fileIndex: 12, name: "ep.mka", folders: ["Rus Sound"], extension: ".mka" };
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "jpn", codec: "aac" }],
+    videoFileIndex: 24,
+    sidecars: [{ file, tracks: [] }]
+  });
+  const addresses = inventory.map(({ index, fileIndex, sourceTrackIndex, kind }) => ({
+    index,
+    fileIndex,
+    sourceTrackIndex,
+    kind
+  }));
+
+  assert.equal(enrichAudioInventoryFromSidecar(inventory, file, {
+    language: "rus",
+    languageBcp47: "ru",
+    codecId: "A_AC3",
+    channels: 6,
+    isOriginal: true
+  }), true);
+
+  assert.deepEqual(inventory.map(({ index, fileIndex, sourceTrackIndex, kind }) => ({
+    index,
+    fileIndex,
+    sourceTrackIndex,
+    kind
+  })), addresses);
+  assert.equal(inventory.length, 2);
+  assert.equal(inventory[1].codec, "ac3");
+  assert.equal(inventory[1].languageBcp47, "ru");
+  assert.equal(inventory[1].channels, 6);
+  assert.equal(inventory[1].isOriginal, true);
+});
+
+test("a sidecar whose table could not be read is still offered, as one track", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "eng", codec: "aac" }],
+    videoFileIndex: 0,
+    sidecars: [{ file: { fileIndex: 1, name: "dub.ac3", folders: [], extension: ".ac3" }, tracks: [] }]
+  });
+  assert.equal(inventory.length, 2);
+  assert.equal(inventory[1].sourceTrackIndex, 0);
+  // The extension of a bare elementary stream IS its codec.
+  assert.equal(inventory[1].codec, "ac3");
+});
+
+test("a sidecar carrying two tracks contributes both", () => {
+  const inventory = buildAudioInventory({
+    embedded: [],
+    videoFileIndex: 0,
+    sidecars: [
+      {
+        file: { fileIndex: 3, name: "dubs.mka", folders: [], extension: ".mka" },
+        tracks: [{ language: "rus" }, { language: "ukr" }]
+      }
+    ]
+  });
+  assert.deepEqual(inventory.map((entry) => [entry.index, entry.sourceTrackIndex]), [[0, 0], [1, 1]]);
+});
+
+test("the flat number resolves back to a file and a track inside it", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "jpn" }],
+    videoFileIndex: 24,
+    sidecars: [{ file: { fileIndex: 12, name: "ep.mka", folders: [], extension: ".mka" }, tracks: [{}] }]
+  });
+  assert.equal(resolveAudioIndex(inventory, 1).fileIndex, 12);
+  assert.equal(resolveAudioIndex(inventory, 1).sourceTrackIndex, 0);
+  assert.equal(resolveAudioIndex(inventory, 9), null);
+});
+
+test("codec identifiers are translated to the names the browser judges by", () => {
+  assert.equal(AudioTrack.codecNameOf({ codec: "AAC" }), "aac");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AC3" }), "ac3");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_AAC/MPEG4/LC" }), "aac");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "A_PCM/INT/LIT" }), "pcm");
+  assert.equal(AudioTrack.codecNameOf({ codecId: "ec-3" }), "eac3");
+  assert.equal(AudioTrack.codecNameOf({}, ".dts"), "dts");
+  assert.equal(AudioTrack.codecNameOf({}, ".unknown"), "");
+});
+
+test("a rendition is named by what the file says, and two never share a name", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "jpn" }],
+    videoFileIndex: 0,
+    sidecars: [
+      { file: { fileIndex: 1, name: "a.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] },
+      { file: { fileIndex: 2, name: "b.mka", folders: ["Rus Sound"], extension: ".mka" }, tracks: [{}] }
+    ]
+  });
+  assert.equal(audioRenditionName(inventory[0], inventory), "jpn");
+  // Both sidecars sit in the same folder and neither names itself, so the names
+  // would collide — and hls.js groups renditions by name.
+  assert.notEqual(
+    audioRenditionName(inventory[1], inventory),
+    audioRenditionName(inventory[2], inventory)
+  );
+});
+
+test("a commentary says so in its rendition name", () => {
+  const inventory = buildAudioInventory({
+    embedded: [{ language: "eng" }, { language: "eng", title: "Director", isCommentary: true }],
+    videoFileIndex: 0,
+    sidecars: []
+  });
+  assert.match(audioRenditionName(inventory[1], inventory), /commentary/);
+});

package/test/audio-track-bitrate.test.js

@@ -1,40 +1,40 @@
-/**
- * @file The rate a copied soundtrack puts on a viewer's link is the rate the
- * file states for THAT track — roadmap item 97, step 11.
- *
- * Not the first rate the banner prints and not the file's total: two tracks of
- * one film can differ fivefold (a stereo AAC and a 5.1 AC3), and the viewer
- * receives only the one they chose. Parsed text, no process.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { parseStreamCodecs } from "../services/media/playback-planner.js";
-import { buildAudioInventory } from "../services/media/audio-inventory.js";
-
-const BANNER = [
-  "Input #0, matroska,webm, from 'http://127.0.0.1/stream':",
-  "  Duration: 01:30:00.00, start: 0.000000, bitrate: 9000 kb/s",
-  "  Stream #0:0: Video: h264 (High), yuv420p, 1920x1080, 24 fps (default)",
-  "  Stream #0:1(eng): Audio: aac (LC), 48000 Hz, stereo, fltp, 128 kb/s (default)",
-  "  Stream #0:2(rus): Audio: ac3, 48000 Hz, 5.1(side), fltp",
-  "    Metadata:",
-  "      title           : Dub",
-  "      BPS             : 640000",
-  "  Stream #0:3(fre): Audio: ac3, 48000 Hz, 5.1(side), fltp",
-  "At least one output file must be specified"
-].join("\n");
-
-test("each soundtrack carries its own stated rate, from its own line or its own statistics tag", () => {
-  const { audioTracks } = parseStreamCodecs(BANNER);
-
-  assert.deepEqual(audioTracks.map((track) => track.bitrateKbps), [128, 640, null]);
-  assert.notEqual(audioTracks[1].bitrateKbps, 9000, "never the file's total");
-});
-
-test("the inventory keeps each track's rate, so the chosen one can be priced", () => {
-  const { audioTracks } = parseStreamCodecs(BANNER);
-  const inventory = buildAudioInventory({ embedded: audioTracks, videoFileIndex: 0, sidecars: [] });
-
-  assert.deepEqual(inventory.map((entry) => entry.bitrateKbps), [128, 640, null]);
-});
+/**
+ * @file The rate a copied soundtrack puts on a viewer's link is the rate the
+ * file states for THAT track — roadmap item 97, step 11.
+ *
+ * Not the first rate the banner prints and not the file's total: two tracks of
+ * one film can differ fivefold (a stereo AAC and a 5.1 AC3), and the viewer
+ * receives only the one they chose. Parsed text, no process.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseStreamCodecs } from "../services/media/playback-planner.js";
+import { buildAudioInventory } from "../services/media/audio-inventory.js";
+
+const BANNER = [
+  "Input #0, matroska,webm, from 'http://127.0.0.1/stream':",
+  "  Duration: 01:30:00.00, start: 0.000000, bitrate: 9000 kb/s",
+  "  Stream #0:0: Video: h264 (High), yuv420p, 1920x1080, 24 fps (default)",
+  "  Stream #0:1(eng): Audio: aac (LC), 48000 Hz, stereo, fltp, 128 kb/s (default)",
+  "  Stream #0:2(rus): Audio: ac3, 48000 Hz, 5.1(side), fltp",
+  "    Metadata:",
+  "      title           : Dub",
+  "      BPS             : 640000",
+  "  Stream #0:3(fre): Audio: ac3, 48000 Hz, 5.1(side), fltp",
+  "At least one output file must be specified"
+].join("\n");
+
+test("each soundtrack carries its own stated rate, from its own line or its own statistics tag", () => {
+  const { audioTracks } = parseStreamCodecs(BANNER);
+
+  assert.deepEqual(audioTracks.map((track) => track.bitrateKbps), [128, 640, null]);
+  assert.notEqual(audioTracks[1].bitrateKbps, 9000, "never the file's total");
+});
+
+test("the inventory keeps each track's rate, so the chosen one can be priced", () => {
+  const { audioTracks } = parseStreamCodecs(BANNER);
+  const inventory = buildAudioInventory({ embedded: audioTracks, videoFileIndex: 0, sidecars: [] });
+
+  assert.deepEqual(inventory.map((entry) => entry.bitrateKbps), [128, 640, null]);
+});