@torrent-tv/proxy 2.95.10 → 2.95.12

package/package.json

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

package/services/encode/EncodeRuns.js

@@ -986,7 +986,7 @@ export class EncodeRuns {
         if (Number.isInteger(index) && (index < safeIndex || index > run.to)) return null;
         let bytes = null;
         if (admittedInput && session.segmentFormat.id === "fmp4" && session.spec.carries !== "audio-only" &&
-          session.spec.audio && !this.#host.servesAudioSeparately(session)) {
+          (admittedInput.original || session.spec.audio && !this.#host.servesAudioSeparately(session))) {
           try {
             const address = session.outputKey ?? "";
             const grid = session.timeline.published ?? session.timeline.boundaries;

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

@@ -9,7 +9,7 @@ export function presentationSegment(current, following, { from, to }) {
     const edit = own.edits.get(id);
     if (!edit) throw new Error("A segment track has no declared clock.");
     const samples = [...track.samples];
-    if (track.kind === "soun" && next?.tracks.has(id)) {
+    if (next?.tracks.has(id)) {
       const nextEdit = next.edits.get(id);
       if (!nextEdit || nextEdit.timescale !== edit.timescale) throw new Error("Adjacent segment clocks differ.");
       for (const sample of next.tracks.get(id).samples) {
@@ -18,18 +18,33 @@ export function presentationSegment(current, following, { from, to }) {
     }
     const start = BigInt(Math.round(from * Number(edit.timescale)));
     const end = BigInt(Math.round(to * Number(edit.timescale)));
-    const selected = samples.filter(sample => {
+    const wanted = samples.filter(sample => {
       const pts = sample.dts + sample.composition + edit.offset;
-      return pts < end && pts + sample.duration > start;
+      return pts < end && (track.kind === "vide" ? pts >= start : pts + sample.duration > start);
     });
+    if (!wanted.length) throw new Error("A presentation segment lacks required media.");
+    // An open-GOP picture before the cut can follow the next CRA in decode
+    // order. Retain the reference pictures through its last required DTS;
+    // dropping the CRA would make the recovered leading pictures undecodable.
+    const lastDecode = wanted.reduce((last, sample) => sample.dts > last ? sample.dts : last, -1n);
+    const firstDecode = wanted.reduce((first, sample) => first === null || sample.dts < first ? sample.dts : first, null);
+    const selected = track.kind === "vide" ? samples.filter(sample =>
+      sample.dts >= firstDecode && sample.dts <= lastDecode && sample.dts + sample.composition + edit.offset >= start) : wanted;
     selected.sort((left, right) => left.dts < right.dts ? -1 : left.dts > right.dts ? 1 : 0);
-    if (!selected.length) throw new Error("A presentation segment lacks required media.");
     tracks.push({ id, samples: selected });
   }
   const makeMoof = offset => box("moof", full("mfhd", 0, 0, u32(1)), ...tracks.map(track => {
-    const entries = track.samples.map(sample => Buffer.concat([
-      u32(Number(sample.duration)), u32(sample.bytes.length), u32(sample.flags), i32(Number(sample.composition))
-    ]));
+    let decodeTime = track.samples[0].dts;
+    const entries = track.samples.map(sample => {
+      // Removing leading pictures can leave a gap in decode timestamps.
+      // trun advances by durations only; retain each original presentation
+      // timestamp relative to the decode clock actually written here.
+      const composition = sample.dts + sample.composition - decodeTime;
+      decodeTime += sample.duration;
+      return Buffer.concat([
+        u32(Number(sample.duration)), u32(sample.bytes.length), u32(sample.flags), i32(Number(composition))
+      ]);
+    });
     const payload = Buffer.concat([u32(track.samples.length), i32(offset), ...entries]);
     offset += track.samples.reduce((bytes, sample) => bytes + sample.bytes.length, 0);
     const clock = Buffer.alloc(8);

package/services/storage/machine-memory.js

@@ -58,17 +58,26 @@ import os from "node:os";
  * Version 1 states the file lists of the cgroup alone as `active_file` and of
  * it with its descendants as `total_active_file`; its usage includes the
  * descendants, so the hierarchical figures are the ones that subtract from it.
+ *
+ * Version 2 has two limits. `memory.max` is where the kernel kills;
+ * `memory.high` is where it throttles the cgroup and pushes its memory out —
+ * on the Home Assistant kernel a 300 MB allocation took 2123 ms instead of
+ * 527 ms past a 128 MiB `memory.high`, with 186 MiB of it sent to swap
+ * (torrent-tv/meta#155). systemd's `MemoryHigh=` sets it without
+ * `MemoryMax=`, so it is a limit of its own, and a level's limit is the
+ * smaller of the two. Version 1's soft limit is not a counterpart: it only
+ * orders reclaim when the whole machine is short.
  */
 const HIERARCHIES = {
   1: {
     mount: "/sys/fs/cgroup/memory",
-    limit: "memory.limit_in_bytes",
+    limits: ["memory.limit_in_bytes"],
     usage: "memory.usage_in_bytes",
     reclaimable: ["total_active_file", "total_inactive_file"]
   },
   2: {
     mount: "/sys/fs/cgroup",
-    limit: "memory.max",
+    limits: ["memory.max", "memory.high"],
     usage: "memory.current",
     reclaimable: ["active_file", "inactive_file", "slab_reclaimable"]
   }
@@ -230,18 +239,24 @@ function levelsOf(mount, path) {
  * @param {string} directory
  * @param {number} hostTotal
  * @returns {{ roomBytes: number, limitBytes: number } | null} Null where this
- *   level states no limit — `max`, the version 1 sentinel — or is not there.
+ *   level states no limit — `max` in every limit file, the version 1
+ *   sentinel — or is not there.
  */
 function roomAt(readFile, hierarchy, directory, hostTotal) {
-  let limitBytes;
   let usageBytes;
   try {
-    limitBytes = bytesOf(readFile(`${directory}/${hierarchy.limit}`));
     usageBytes = bytesOf(readFile(`${directory}/${hierarchy.usage}`));
   } catch {
     return null; // silent-ok: no such level, or no memory controller on it.
   }
-  if (!Number.isFinite(limitBytes) || limitBytes >= hostTotal || !Number.isFinite(usageBytes)) {
+  const limitBytes = Math.min(...hierarchy.limits.map((name) => {
+    try {
+      return bytesOf(readFile(`${directory}/${name}`));
+    } catch {
+      return Number.NaN; // silent-ok: a limit file this kernel does not have states no limit.
+    }
+  }).filter(Number.isFinite));
+  if (limitBytes >= hostTotal || !Number.isFinite(usageBytes)) {
     return null;
   }
   let reclaimableBytes = 0;