@torrent-tv/proxy 2.7.0 → 2.8.0

package/package.json

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

package/services/hls-session-manager.js

@@ -24,12 +24,6 @@ const DEFAULT_SEGMENT_DURATION_SEC = 4;
 // is allowed to be before we restart ffmpeg at that position (server-side seek).
 // Requests within the window are served by waiting for the running encode.
 const MAX_LOOKAHEAD_SEGMENTS = 8;
-// Just-in-time pacing: pause the encoder once it is this many segments ahead of
-// the player's current position, and resume once the lead shrinks to the resume
-// threshold.  This keeps a comfortable buffer for smooth playback while capping
-// CPU near real-time instead of racing through the whole file at once.
-const PACING_PAUSE_AHEAD_SEGMENTS = 8;
-const PACING_RESUME_AHEAD_SEGMENTS = 4;
 // Idle TTL: a session is disposed this long after the last segment/playlist
 // access. Kept short so an ffmpeg process does not keep burning CPU after the
 // viewer stops or navigates away. Active playback refreshes the timer on every
@@ -498,11 +492,6 @@ export class HlsSessionManager {
       encodeStartIndex: 0,
       // Guards against repeatedly restarting to the same seek position.
       pendingRestartIndex: -1,
-      // Just-in-time pacing: highest segment index the player has requested
-      // (≈ playhead) and whether the encoder is currently paused for running
-      // far enough ahead.
-      playheadIndex: 0,
-      paused: false,
       progress: {
         state: "starting",
         processedSeconds: 0,
@@ -590,19 +579,14 @@ export class HlsSessionManager {
 
     // Terminate any existing encode process before starting a new one.  The
     // old process's exit handler no-ops because session.ffmpeg is reassigned
-    // below (it checks identity).  Resume first in case it was paused, so the
-    // termination signal is actually delivered.
+    // below (it checks identity).
     if (session.ffmpeg && !session.ffmpeg.killed) {
       try {
-        if (session.paused) {
-          session.ffmpeg.kill("SIGCONT");
-        }
         session.ffmpeg.kill("SIGTERM");
       } catch (_error) {
         // Best effort.
       }
     }
-    session.paused = false;
 
     const videoCodecArgs = session.transcodeVideo
       ? [
@@ -669,7 +653,6 @@ export class HlsSessionManager {
     session.ffmpeg = ffmpeg;
     session.encodeStartIndex = safeIndex;
     session.pendingRestartIndex = -1;
-    session.playheadIndex = safeIndex;
     session.state = session.state === "disposed" ? "disposed" : "starting";
     session.progress.state = "running";
     session.progress.processedSeconds = startSeconds;
@@ -742,8 +725,6 @@ export class HlsSessionManager {
               ` speed=${session.progress.speed || "n/a"}`
           );
         }
-        // Just-in-time pacing: pause once we are far enough ahead of the player.
-        this.#maybePauseEncoder(session);
       }
     });
 
@@ -819,79 +800,6 @@ export class HlsSessionManager {
     this.#startEncodeRun(session, index);
   }
 
-  /**
-   * Segment index ffmpeg has encoded up to so far, derived from the output
-   * timestamp reported via -progress.
-   *
-   * @param {HlsSession} session
-   * @returns {number}
-   */
-  #producedSegmentIndex(session) {
-    const processed = Number(session.progress?.processedSeconds);
-    if (!Number.isFinite(processed) || processed <= 0) {
-      return session.encodeStartIndex;
-    }
-    return Math.floor(processed / this.segmentDurationSec);
-  }
-
-  /**
-   * Pause the encoder once it has produced enough segments ahead of the
-   * player's current position (just-in-time pacing).  No-op on platforms
-   * without POSIX job-control signals (fail-open: the encoder keeps running).
-   *
-   * @param {HlsSession} session
-   * @returns {void}
-   */
-  #maybePauseEncoder(session) {
-    if (session.paused || !session.ffmpeg || session.ffmpeg.killed) {
-      return;
-    }
-    if (process.platform === "win32") {
-      return;
-    }
-    const ahead = this.#producedSegmentIndex(session) - session.playheadIndex;
-    if (ahead < PACING_PAUSE_AHEAD_SEGMENTS) {
-      return;
-    }
-    try {
-      session.ffmpeg.kill("SIGSTOP");
-      session.paused = true;
-      logger.info(
-        `transcode ${session.id} paused (buffered ${ahead} segments ahead) "${session.fileName}"`
-      );
-    } catch (_error) {
-      // Fail-open: if we cannot pause, let the encoder keep running.
-    }
-  }
-
-  /**
-   * Resume a paused encoder when the player has caught up enough that the
-   * buffered lead has shrunk to the resume threshold.
-   *
-   * @param {HlsSession} session
-   * @returns {void}
-   */
-  #maybeResumeEncoder(session) {
-    if (!session.paused || !session.ffmpeg || session.ffmpeg.killed) {
-      return;
-    }
-    const ahead = this.#producedSegmentIndex(session) - session.playheadIndex;
-    if (ahead > PACING_RESUME_AHEAD_SEGMENTS) {
-      return;
-    }
-    try {
-      session.ffmpeg.kill("SIGCONT");
-      session.paused = false;
-      session.progress.updatedAt = Date.now();
-      logger.info(`transcode ${session.id} resumed (lead ${ahead} segments) "${session.fileName}"`);
-    } catch (_error) {
-      // If resume fails, force a restart from the player's position so it does
-      // not stall (fail-safe toward smooth playback).
-      session.paused = false;
-      this.#startEncodeRun(session, session.playheadIndex);
-    }
-  }
-
   #buildVideoFilter(targetWidth, targetHeight) {
     const safeWidth = Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 1280;
     const safeHeight = Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 720;
@@ -970,16 +878,6 @@ export class HlsSessionManager {
     }
     session.lastAccessedAt = Date.now();
 
-    // Track the player position (≈ playhead) from segment requests and resume
-    // a paused encoder as the player approaches the buffered edge.
-    if (fileName !== PLAYLIST_FILE_NAME) {
-      const requestedIndex = segmentIndexFromName(fileName);
-      if (requestedIndex >= 0) {
-        session.playheadIndex = Math.max(session.playheadIndex, requestedIndex);
-        this.#maybeResumeEncoder(session);
-      }
-    }
-
     // Serve the synthetic VOD playlist (full duration, terminated with
     // #EXT-X-ENDLIST) so the player gets the correct total length and a fully
     // seekable timeline up-front, independent of how far ffmpeg has encoded.
@@ -1127,16 +1025,6 @@ export class HlsSessionManager {
     this.sessionIdBySource.delete(session.sourceMapKey);
 
     if (session.ffmpeg && !session.ffmpeg.killed) {
-      // Resume first if paused, otherwise SIGTERM is not delivered to a
-      // stopped process.
-      if (session.paused) {
-        try {
-          session.ffmpeg.kill("SIGCONT");
-        } catch (_error) {
-          // Best effort.
-        }
-        session.paused = false;
-      }
       session.ffmpeg.kill("SIGTERM");
       await waitForChildExit(session.ffmpeg);
     }