@torrent-tv/proxy 2.95.3 → 2.95.4

package/services/encode/source-command.js

@@ -0,0 +1,239 @@
+import { PLAYLIST_FILE_NAME } from "./output/playlists.js";
+import { AUDIO_TRANSCODE_KBPS } from "./args.js";
+import { cutsAtGivenTimes, SEGMENT_CUT_TIME_DELTA_SECONDS } from "./output/index.js";
+import { ffmpegSeconds, onKeyframeGridFor, publishedGridFor, publishedStartTime, segmentCutTimesFrom, nearestKeyframeAtOrBefore } from "./run-command.js";
+
+/** Account for FFmpeg's Matroska B-frame input-seek adjustment (ffmpeg_demux.c). */
+function seekLandingOffsetFor(material, keyframe) {
+  if (material.transcodeVideo || material.audioOnly || !(material.reorderDepth > 0)) return 0;
+  const wanted = 3 / 23 + Math.max(0, material.keyframes?.tolerance ?? 0);
+  const next = material.keyframes?.times?.find(time => time > keyframe + 0.001);
+  return next === undefined ? wanted : Math.min(wanted, (next - keyframe) / 2);
+}
+
+export function buildRunCommand({
+  keyframes,
+  inputFile,
+  audioFile,
+  inputUrl,
+  audioInputUrl: audioInputUrlGiven,
+  timeline,
+  output,
+  segmentFormat,
+  transcodeVideo,
+  transcodeAudio,
+  audioOnly,
+  audioSeparate,
+  audioSourceTrackIndex,
+  videoSourceTrackIndex = 0,
+  rateControl,
+  startIndex,
+  endIndex,
+  positionSecondsOverride,
+  videoEncoder,
+  segmentDurationSec,
+  reorderDepth = 0
+}) {
+  const safeIndex = Number.isInteger(startIndex) && startIndex > 0 ? startIndex : 0;
+  const startSeconds = Number.isFinite(positionSecondsOverride)
+    ? positionSecondsOverride
+    : publishedStartTime(timeline, safeIndex, segmentDurationSec);
+  const keyframeGrid = onKeyframeGridFor({ audioOnly, timeline, transcodeVideo });
+  const servesAudioSeparately = audioOnly !== true && audioSeparate === true;
+  const audioFileStartTime = audioFile.startTime;
+  const sourceStartTime = inputFile.startTime;
+  const explicitTimes = segmentFormat.explicitTimesMuxerArgs?.() ?? null;
+  const inputIndex = !transcodeVideo && !audioOnly && explicitTimes && safeIndex > 0
+    ? safeIndex - 1 : safeIndex;
+  const gridCutTimes = cutsAtGivenTimes({ segmentFormat, timeline })
+    ? segmentCutTimesFrom(publishedGridFor(timeline), inputIndex)
+    : null;
+  const cutTimes = gridCutTimes;
+  const videoCodecArgs = transcodeVideo
+    ? videoEncoder.buildVideoArgs({
+        targetWidth: output.encodeWidth,
+        targetHeight: output.encodeHeight,
+        segmentDurationSec: segmentDurationSec,
+        fps: output.outputFps,
+        preset: output.softwarePreset ?? undefined,
+        tonemap: output.applyTonemap === true,
+        forcedKeyframeTimes: cutTimes,
+        rateControl: rateControl ?? null
+      })
+    : ["-c:v", "copy"];
+  const audioCodecArgs = transcodeAudio
+    ? ["-c:a", "aac", "-ac", "2", "-b:a", `${AUDIO_TRANSCODE_KBPS}k`]
+    : ["-c:a", "copy"];
+
+  const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
+  if (transcodeVideo && Array.isArray(videoEncoder.inputArgs)) {
+    args.push(...videoEncoder.inputArgs);
+  }
+  const inputStartSeconds = inputIndex === safeIndex ? startSeconds :
+    publishedStartTime(timeline, inputIndex, segmentDurationSec);
+  const seekSeconds = timeline.cutGrid === "keyframe"
+    ? inputStartSeconds + sourceStartTime
+    : inputStartSeconds;
+  const carriedKeyframe = timeline.cutGrid === "keyframe" && typeof timeline.sourceStartOf === "function"
+    ? timeline.sourceStartOf(inputIndex)
+    : null;
+  const snappedKeyframe = Number.isFinite(carriedKeyframe)
+    ? carriedKeyframe
+    : (Array.isArray(keyframes?.times) && keyframes.times.length > 0
+      ? nearestKeyframeAtOrBefore(keyframes.times, seekSeconds)
+      : null);
+  const audioInputUrl =
+    typeof audioInputUrlGiven === "string" && audioInputUrlGiven.length > 0
+      ? audioInputUrlGiven
+      : "";
+  const audioTimelineShift = audioInputUrl
+    ? audioFileStartTime - sourceStartTime
+    : 0;
+  /**
+   * Add the second input, if there is one, with its own seek.
+   *
+   * Called between the first `-i` and any OUTPUT option, because ffmpeg reads
+   * these positionally: an option written after the last `-i` applies to the
+   * output, and the residual seek below is exactly such an option. Getting the
+   * order wrong would silently turn the audio file's seek into a trim of the
+   * finished stream.
+   *
+   * @param {number} inputSeekSeconds - Where to start, on the PICTURE's
+   *   timeline. Translated to the soundtrack file's own here.
+   */
+  const pushAudioInput = (inputSeekSeconds) => {
+    if (!audioInputUrl) {
+      return;
+    }
+    if (audioTimelineShift !== 0 && keyframeGrid) {
+      args.push("-itsoffset", ffmpegSeconds(-audioTimelineShift));
+    }
+    const audioSeek = Math.max(0, inputSeekSeconds + audioTimelineShift);
+    if (audioSeek > 0) {
+      args.push("-accurate_seek", "-ss", ffmpegSeconds(audioSeek));
+    }
+    args.push("-i", audioInputUrl);
+  };
+
+  if (snappedKeyframe !== null) {
+    const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
+    if (snappedKeyframe > 0) {
+      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, keyframes, reorderDepth }, snappedKeyframe)));
+    }
+    args.push("-i", inputUrl);
+    pushAudioInput(snappedKeyframe);
+    if (residualSeconds > 0 && !keyframeGrid) {
+      args.push("-ss", ffmpegSeconds(residualSeconds));
+    }
+  } else {
+    if (seekSeconds > 0) {
+      args.push("-accurate_seek", "-ss", ffmpegSeconds(seekSeconds));
+    }
+    args.push("-i", inputUrl);
+    pushAudioInput(seekSeconds);
+  }
+  if (!keyframeGrid) {
+    if (startSeconds > 0) {
+      args.push("-output_ts_offset", ffmpegSeconds(startSeconds));
+    }
+  } else {
+    args.push("-copyts");
+    if (sourceStartTime !== 0) {
+      args.push("-output_ts_offset", ffmpegSeconds(-sourceStartTime));
+    }
+  }
+  const runEnd = Number.isInteger(endIndex) ? endIndex : -1;
+  const publishedGrid = publishedGridFor(timeline);
+  if (runEnd >= safeIndex && Array.isArray(publishedGrid) && publishedGrid[runEnd + 1] > 0) {
+    const endsAt = publishedGrid[runEnd + 1];
+    if (transcodeVideo) {
+      args.push("-t", ffmpegSeconds(Math.max(0.1, endsAt - publishedGrid[safeIndex])));
+    } else {
+      args.push("-to", ffmpegSeconds(endsAt));
+    }
+  }
+  if (audioOnly === true) {
+    args.push("-vn", "-map", `0:a:${audioSourceTrackIndex}?`, ...audioCodecArgs);
+  } else if (servesAudioSeparately) {
+    args.push("-an", "-map", `0:v:${videoSourceTrackIndex}?`, ...videoCodecArgs);
+  } else {
+    args.push(
+      "-map",
+      `0:v:${videoSourceTrackIndex}?`,
+      "-map",
+      `${audioInputUrl ? 1 : 0}:a:${audioSourceTrackIndex}?`,
+      ...videoCodecArgs,
+      ...audioCodecArgs
+    );
+  }
+  if (cutTimes && cutTimes.length > 0) {
+    args.push(
+      "-f",
+      "segment",
+      "-segment_times",
+      cutTimes.join(","),
+      "-segment_time_delta",
+      String(SEGMENT_CUT_TIME_DELTA_SECONDS),
+      "-segment_start_number",
+      String(inputIndex),
+      "-segment_list",
+      "pipe:3",
+      "-segment_list_type",
+      "csv",
+      "-segment_list_flags",
+      "+live",
+      ...explicitTimes,
+      segmentFormat.makingFileNameTemplate(String(safeIndex))
+    );
+  } else {
+    args.push(
+      "-f",
+      "hls",
+      "-hls_time",
+      String(segmentDurationSec),
+      "-hls_list_size",
+      "0",
+      "-hls_flags",
+      "independent_segments+temp_file",
+      ...segmentFormat.muxerArgs(),
+      "-start_number",
+      String(safeIndex),
+      PLAYLIST_FILE_NAME
+    );
+  }
+  return { args, safeIndex, inputIndex, startSeconds, cutTimes };
+
+}
+
+/** One finite original-source run, preserving the published interval and track choice. */
+export function buildOriginalCommand(params) {
+  const { admittedInput, timeline, startIndex, inputToken, baseUrl, audioOnly } = params;
+  const grid = publishedGridFor(timeline);
+  const from = grid[startIndex], to = grid[startIndex + 1];
+  if (!(to > from)) throw new Error("Original-source encoding requires a finite published interval.");
+  const sourceFor = kind => admittedInput.sources.find(source => source.input.selections.some(selection => selection.track.type === kind));
+  const primary = sourceFor(audioOnly ? "audio" : "video");
+  const audio = sourceFor("audio") ?? primary;
+  if (!primary) throw new Error("The selected source track is absent from original input.");
+  const url = source => new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href;
+  const localTimeline = { ...timeline, published: [from, to, to + (to - from)],
+    boundaries: [from, to, to + (to - from)], sourceStartOf: () => timeline.sourceStartOf?.(startIndex) ?? from + primary.timeShiftSeconds };
+  const command = buildRunCommand({ ...params, startIndex: 0, endIndex: 0, timeline: localTimeline,
+    videoSourceTrackIndex: primary.input.selections.find(selection => selection.track.type === "video")?.index ?? 0,
+    reorderDepth: primary.input.selections.find(selection => selection.track.type === "video")?.track.reorderDepth ?? 0,
+    inputFile: { startTime: primary.timeShiftSeconds }, audioFile: { startTime: audio.timeShiftSeconds },
+    inputUrl: url(primary), audioInputUrl: audio !== primary && !audioOnly ? url(audio) : "",
+    audioSourceTrackIndex: audio.input.selections.find(selection => selection.track.type === "audio")?.index ?? 0 });
+  const args = command.args;
+  // The segment muxer otherwise shifts negative initial DTS to zero before
+  // the inner muxer writes its edit list, moving B-picture PTS off the source.
+  args.splice(args.indexOf("-f"), 0, "-avoid_negative_ts", "disabled");
+  const formatOptions = args.indexOf("-segment_format_options");
+  if (formatOptions >= 0) args[formatOptions + 1] += ":avoid_negative_ts=disabled";
+  const numbering = args.indexOf("-segment_start_number");
+  if (numbering < 0) throw new Error("The format cannot produce finite original-source segments.");
+  args[numbering + 1] = String(startIndex);
+  args[args.length - 1] = params.segmentFormat.makingFileNameTemplate(admittedInput.runTag);
+  if (audioOnly) args[args.indexOf("-segment_time_delta") + 1] = "0";
+  return { ...command, safeIndex: startIndex, inputIndex: startIndex };
+}

package/services/media/ContainerOrchestrator.js

@@ -129,7 +129,7 @@ export class ContainerOrchestrator {
 
   /** Read one statement without converting missing bytes into an empty answer. */
   async inspect(params, statement = "tracks") {
-    if (!["container", "tracks", "media-info", "keyframes", "packets", "fingerprint", "work-tags", "cover"].includes(statement)) {
+    if (!["container", "tracks", "media-info", "keyframes", "packets", "source-navigation", "source-ranges", "fingerprint", "work-tags", "cover"].includes(statement)) {
       throw new TypeError(`Unknown media statement: ${statement}`);
     }
     const key = `${params.sourceKey}:${params.fileIndex}`;
@@ -191,6 +191,12 @@ export class ContainerOrchestrator {
       } else if (statement === "work-tags" || statement === "cover") {
         value = await (statement === "cover" ? container.readCover(edgesOf(params)) : container.readWorkTags(edgesOf(params)));
         if (value === null) return { kind: "terminal", reason: statement === "cover" ? "no-cover" : "format-states-nothing", requestId };
+      } else if (statement === "source-navigation") {
+        value = await container.supportsOriginalSourceRanges?.() === true;
+      } else if (statement === "source-ranges") {
+        if (typeof container.readSourceRanges !== "function") return { kind: "terminal", reason: "source-range-index-not-supported", requestId };
+        value = await container.readSourceRanges(params.packetInterval);
+        if (value.kind !== "result") return { ...value, requestId };
       } else if (statement === "packets") {
         value = await container.readPacketIndex(params.packetInterval);
         await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);

package/services/media/container/MatroskaContainer.js

@@ -145,6 +145,8 @@ export class MatroskaContainer extends Container {
 
   /** @type {SegmentLayout | null} */
   #layout = null;
+  #sourceElementEnds = new Map();
+  #sourceSeekPoints = null;
 
   /** @type {Array<import("../tracks/ContainerTrack.js").ContainerTrack> | null} */
   #tracks = null;
@@ -569,6 +571,83 @@ export class MatroskaContainer extends Container {
     return result;
   }
 
+  /** Original-file ranges from Cues alone, without reading media block headers.
+   * FFmpeg needs the declarations and seek table as well as complete clusters.
+   * One preceding cluster retains preroll; one following cluster covers demux
+   * lookahead beyond the presentation cut. No packet payload is parsed here.
+   */
+  async supportsOriginalSourceRanges() {
+    const cues = await this.readCues();
+    if (!cues?.points.length) return false;
+    const video = ContainerTrack.firstUsable(await this.readTracks(), "video");
+    return cues.points.some(point => point.positions.some(position => !video || position.track === video.trackNumber));
+  }
+
+  async readMappedSourceRanges(interval) { return this.readSourceRanges(interval); }
+
+  async readSourceRanges(interval) {
+    if (!Number.isFinite(interval?.from) || !Number.isFinite(interval?.to) || interval.to <= interval.from) {
+      throw new TypeError("Source ranges require a finite increasing interval.");
+    }
+    const layout = await this.#segmentLayout();
+    if (!layout || layout.firstClusterAt === null) return { kind: "terminal", reason: "source-has-no-clusters" };
+    const cues = await this.readCues();
+    if (!await this.supportsOriginalSourceRanges()) return { kind: "needs-index", reason: "source-has-no-cue-map" };
+    const tracks = await this.readTracks();
+    const requested = tracks.filter(track => !interval.trackIds?.length || interval.trackIds.includes(track.trackNumber));
+    const video = ContainerTrack.firstUsable(tracks, "video");
+    const points = this.#sourceSeekPoints ??= cues.points.flatMap(point => point.positions
+      .filter(position => !video || position.track === video.trackNumber)
+      .map(position => ({ at: position.clusterAt, seconds: point.ticks * layout.secondsPerTick })))
+      .sort((left, right) => left.seconds - right.seconds || left.at - right.at);
+    if (!points.length) return super.readSourceRanges(interval);
+    const preroll = Math.max(0, ...requested.map(track => track.seekPrerollSeconds ?? 0));
+    const firstAt = (seconds, strict) => {
+      let low = 0, high = points.length;
+      while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (points[middle].seconds < seconds || strict && points[middle].seconds === seconds) low = middle + 1;
+        else high = middle;
+      }
+      return low;
+    };
+    const first = Math.max(0, firstAt(interval.from - preroll, true) - 2);
+    const beyond = firstAt(interval.to, false);
+    const following = points[beyond + 1];
+    const mediaEnd = following ? following.at - 1 : layout.segmentEnd - 1;
+    const elementEnd = async at => {
+      if (this.#sourceElementEnds.has(at)) return this.#sourceElementEnds.get(at);
+      const reader = new ElementReader({ read: this.readRange, fileSize: this.fileSize, portionBytes: this.portionBytes });
+      const header = await reader.header(at, layout.segmentEnd);
+      if (!header || header.end === null) return null;
+      this.#sourceElementEnds.set(at, header.end);
+      return header.end;
+    };
+    const cuesEnd = await elementEnd(layout.cuesAt);
+    if (cuesEnd === null) return { kind: "terminal", reason: "source-seek-index-is-unbounded" };
+    const requestBytes = 1024 * 1024;
+    const paddedEnd = end => Math.min(this.fileSize - 1, end + requestBytes);
+    const ranges = [[0, paddedEnd(layout.firstClusterAt - 1)],
+      [points[first].at, paddedEnd(mediaEnd)], [layout.cuesAt, paddedEnd(cuesEnd - 1)],
+      [Math.max(0, this.fileSize - requestBytes), this.fileSize - 1]];
+    // SeekHead may name top-level declarations after media clusters. Preserve
+    // their original bytes instead of reconstructing declarations for FFmpeg.
+    for (const at of [layout.infoAt, layout.tracksAt]) {
+      if (at === null || at < layout.firstClusterAt) continue;
+      const end = await elementEnd(at);
+      if (end === null) return { kind: "terminal", reason: "source-declarations-are-unbounded" };
+      ranges.push([at, paddedEnd(end - 1)]);
+    }
+    ranges.sort((left, right) => left[0] - right[0]);
+    const union = [];
+    for (const range of ranges) {
+      const previous = union.at(-1);
+      if (previous && range[0] <= previous[1] + 1) previous[1] = Math.max(previous[1], range[1]);
+      else union.push([...range]);
+    }
+    return { kind: "result", from: interval.from, to: interval.to, ranges: union, fileLength: this.fileSize };
+  }
+
   async readPacketIndex(interval) {
     if (this.#packets) return this.#packets;
     const layout = await this.#segmentLayout();

package/services/media/container/ffprobe-record.js

@@ -15,6 +15,8 @@ export function ffprobeRecord(line) {
   const kind = fields.shift();
   const record = { kind };
   for (const [position, value] of fields.entries()) {
+    // Disabled nested sections may leave a trailing separator in FFprobe 8.
+    if (value === "" && fields.slice(position + 1).every(field => field === "")) break;
     // ffprobe 5 emits an empty nested section even when its entries are disabled.
     if (value === "side_data" && fields.slice(position + 1).every(field => field === "")) break;
     const separator = value.indexOf("=");

package/services/server/SegmentServing.js

@@ -794,7 +794,9 @@ export class SegmentServing {
         }
         const ownInit = session.segmentFormat.extractInit(cached ?? await readFile(found));
         const init = ownInit && session.segmentFormat.prepareSharedInit ?
-          session.segmentFormat.prepareSharedInit(ownInit) : ownInit;
+          session.segmentFormat.prepareSharedInit(ownInit, {
+            audioEncoderDelay: session.spec.transcodesAudio ? 1024 : 0
+          }) : ownInit;
         if (!init || init.length === 0) {
           continue;
         }

package/services/server/wire-outputs.js

@@ -341,6 +341,7 @@ export function wireOutputs({
     get encodeCost() { return parts.encodeCost; },
     get encodeOrchestrator() { return parts.encodeOrchestrator; },
     get ffmpegBin() { return parts.ffmpegBin; },
+    get localBaseUrl() { return parts.localBaseUrl; },
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
     get priority() { return parts.priority; },
@@ -972,7 +973,7 @@ export function wireOutputs({
     reviseBudget: () => parts.machineBudget.revise(),
     capacity: () => parts.machineBudget.capacityOf("memory"),
     urgent: (output, index) => parts.encodeOrchestrator.wantedSegmentsOn(output.outputKey).some(window =>
-      index >= window.from && index <= window.to && window.withinSeconds === 0),
+      index >= window.from && index <= window.to && window.urgent === true),
     changed: (output, result) => {
       if (result.kind === "terminal") {
         logger.warn(`encode input output=${output.outputKey} terminal=${result.reason}: ${result.message ?? ""}` +

package/services/storage/piece-store/shared-piece-store.js

@@ -52,6 +52,7 @@ import { PieceDiskStore } from "./piece-disk-store.js";
  * @type {Set<SharedPieceStore>}
  */
 const liveStores = new Set();
+let assignedMemoryAllowance = null;
 
 export function collectStoreStats() {
   return [...liveStores].map((store) => store.stats());
@@ -107,11 +108,17 @@ export function machineReserveBytes() {
 /** Forget what other processes have needed. For tests, which share a module. */
 export function forgetMachineMemory() {
   otherDemand.forget();
+  assignedMemoryAllowance = null;
 }
 
 export { divideAllowance, machineAllowanceBytes };
 
-export function reviseStoreBudgets(allowanceBytes = null) {
+export function reviseStoreBudgets(allowanceBytes = assignedMemoryAllowance) {
+  // Periodic maintenance must retain the main thread's latest allocation.
+  // Recomputing it from host free memory would overwrite a fixed limit and
+  // the memory reserved for admitted encoder input.
+  assignedMemoryAllowance = Number.isFinite(allowanceBytes) && allowanceBytes !== null
+    ? Math.max(0, allowanceBytes) : null;
   const stores = [...liveStores];
   const held = stores.reduce((sum, store) => sum + store.residentBytes, 0);
   // TOLD, NOT WORKED OUT. Memory has one owner and it is on the main thread,