@torrent-tv/proxy 2.89.6 → 2.89.8

package/services/encode/output/index.js

@@ -1,24 +1,24 @@
-export { OutputSpec, VideoOutput, AudioOutput, CutGrid, isOutputName } from "./OutputSpec.js";
-export { PLAYLIST_FILE_NAME } from "./playlists.js";
-
-// FFmpeg may close a segment this far before its requested cut. Both the
-// command and coverage validation use this existing muxer configuration.
-export const SEGMENT_CUT_TIME_DELTA_SECONDS = 0.05;
-
-/**
- * The code an error carries when no output suits the viewer: nothing this proxy
- * could produce or already holds is admitted by their link. Its `details` say
- * why and with which figures. A definition shared by both sides of the
- * interface — the encoding that decides it and the routes that answer it.
- */
-export const OUTPUT_UNAVAILABLE = "OUTPUT_UNAVAILABLE";
-
-/**
- * The code an error carries when THIS MACHINE cannot take the output: no mode
- * of its encoder was shown at startup to hold the picture at any size this
- * viewer could be given, or the machine has no place for one more encoder
- * beside what already runs (roadmap item 97, step 14). Not the viewer's link —
- * another proxy may well serve it, and the page asks the pool before anything
- * plays. Its `details` say why, with the figures.
- */
-export const OUTPUT_NO_CAPACITY = "OUTPUT_NO_CAPACITY";
+export { OutputSpec, VideoOutput, AudioOutput, CutGrid, isOutputName } from "./OutputSpec.js";
+export { PLAYLIST_FILE_NAME } from "./playlists.js";
+
+// FFmpeg may close a segment this far before its requested cut. Both the
+// command and coverage validation use this existing muxer configuration.
+export const SEGMENT_CUT_TIME_DELTA_SECONDS = 0.05;
+
+/**
+ * The code an error carries when no output suits the viewer: nothing this proxy
+ * could produce or already holds is admitted by their link. Its `details` say
+ * why and with which figures. A definition shared by both sides of the
+ * interface — the encoding that decides it and the routes that answer it.
+ */
+export const OUTPUT_UNAVAILABLE = "OUTPUT_UNAVAILABLE";
+
+/**
+ * The code an error carries when THIS MACHINE cannot take the output: no mode
+ * of its encoder was shown at startup to hold the picture at any size this
+ * viewer could be given, or the machine has no place for one more encoder
+ * beside what already runs (roadmap item 97, step 14). Not the viewer's link —
+ * another proxy may well serve it, and the page asks the pool before anything
+ * plays. Its `details` say why, with the figures.
+ */
+export const OUTPUT_NO_CAPACITY = "OUTPUT_NO_CAPACITY";

package/services/encode/piece-completeness.js

@@ -24,11 +24,17 @@ import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "./output/index.js";
  */
 export function cutOf(timeline, index) {
   return index < timeline.segmentCount - 1
-    ? timeline.publishedStartOf(index + 1) - SEGMENT_CUT_TIME_DELTA_SECONDS
+    ? (Math.round(timeline.publishedStartOf(index + 1) * 1_000_000) -
+      Math.round(SEGMENT_CUT_TIME_DELTA_SECONDS * 1_000_000)) / 1_000_000
     : undefined;
 }
 
 /**
+ * Track positions read from empty edits retain their movie-tick uncertainty.
+ * Fresh closures also carry the muxer's packet end and its actual cut, so a
+ * restarted run is judged on its own reference clock. Neither allowance is a
+ * browser's frame-join rule.
+ *
  * @param {{ producedThroughSeconds?: (ranges: object) => number | null }} format
  * @param {object} ranges - The piece's media intervals, as the format read them.
  * @param {number | undefined} cutSeconds - From {@link cutOf}.
@@ -39,8 +45,60 @@ export function judgePiece(format, ranges, cutSeconds) {
   if (throughSeconds === null) {
     return { whole: false, throughSeconds };
   }
-  if (Number.isFinite(cutSeconds) && throughSeconds < cutSeconds) {
+  const cutMicros = ranges?.production?.cutMicros ??
+    (Number.isFinite(cutSeconds) ? BigInt(Math.round(cutSeconds * 1_000_000)) : null);
+  if (cutMicros !== null && ranges?.tracks?.length) {
+    const tracks = ranges.tracks;
+    const production = ranges.production;
+    const reference = production ? tracks.find(({ kind }) => kind === production.kind) : null;
+    const referenceEnd = reference?.ranges.at(-1)?.end;
+    const whole = tracks.every((track) => {
+      const { timescale, ranges: held, positionErrorTicks = 0n } = track;
+      const end = held.at(-1)?.end;
+      if (end === undefined) return false;
+      if (referenceEnd !== undefined) {
+        if (track === reference) return 2n * production.endMicros + 1n >= 2n * cutMicros;
+        // The segment muxer's CSV reports packet time before movenc truncates
+        // the empty edit. Compare on that clock, including another track's
+        // relative end and the precision of both written track positions.
+        const difference = (end + positionErrorTicks) * reference.timescale -
+          (referenceEnd - (reference.positionErrorTicks ?? 0n)) * timescale;
+        const denominator = timescale * reference.timescale;
+        return 2n * difference * 1_000_000n +
+          (2n * production.endMicros + 1n) * denominator >= 2n * cutMicros * denominator;
+      }
+      return (end + positionErrorTicks) * 1_000_000n >= cutMicros * timescale;
+    });
+    return { whole, throughSeconds };
+  }
+  if (cutMicros !== null && throughSeconds < Number(cutMicros) / 1_000_000) {
     return { whole: false, throughSeconds };
   }
   return { whole: true, throughSeconds };
 }
+
+/** The muxer cuts relative to its first reference packet, not the requested seek. */
+export function productionOf(timing, cutTimes, relativeIndex, kind) {
+  if (!timing || timing.originMicros === null || !Number.isFinite(cutTimes?.[relativeIndex])) return null;
+  return {
+    kind,
+    endMicros: timing.endMicros,
+    cutMicros: timing.originMicros + BigInt(Math.round(cutTimes[relativeIndex] * 1_000_000)) -
+      BigInt(Math.round(SEGMENT_CUT_TIME_DELTA_SECONDS * 1_000_000))
+  };
+}
+
+/**
+ * The first CSV entry has start_time = 0 even after a seek (segment.c).
+ * Recover its reference packet's PTS from the reported end minus the exact
+ * sample span. The edit-list offset cancels, including its lost precision.
+ */
+export function originOf(ranges, endMicros, kind) {
+  const track = ranges?.tracks?.find(track => track.kind === kind);
+  if (track?.firstSampleStart === undefined || !track.ranges.length) return null;
+  const ticks = endMicros * track.timescale -
+    (track.ranges.at(-1).end - track.firstSampleStart) * 1_000_000n;
+  // CSV rounds to microseconds; rescale with the muxer's nearest rounding.
+  return ticks >= 0n ? (2n * ticks + track.timescale) / (2n * track.timescale) :
+    -((-2n * ticks + track.timescale) / (2n * track.timescale));
+}