@apocaliss92/nodelink-js 0.2.3 → 0.2.5

package/dist/cli/rtsp-server.js

@@ -3,10 +3,10 @@ import {
   BaichuanRtspServer,
   ReolinkBaichuanApi,
   autoDetectDeviceType
-} from "../chunk-RWYEGEWG.js";
+} from "../chunk-EG5IY3CM.js";
 import {
   __require
-} from "../chunk-NLTB7GTA.js";
+} from "../chunk-APEEZ4UN.js";
 
 // src/cli/rtsp-server.ts
 function parseArgs() {

package/dist/index.cjs

@@ -3000,14 +3000,6 @@ var init_BaichuanVideoStream = __esm({
               this.profile,
               { variant: this.variant, client: this.client }
             );
-            if (this.client.getTransport?.() === "udp") {
-              await startPromise;
-            } else {
-              await Promise.race([
-                startPromise,
-                new Promise((resolve) => setTimeout(resolve, 400))
-              ]);
-            }
             const updateActiveMsgNum = () => {
               try {
                 const getMsgNum = this.api.getActiveVideoMsgNumWithVariant;
@@ -3017,6 +3009,15 @@ var init_BaichuanVideoStream = __esm({
               }
             };
             updateActiveMsgNum();
+            if (this.client.getTransport?.() === "udp") {
+              await startPromise;
+            } else {
+              await Promise.race([
+                startPromise,
+                new Promise((resolve) => setTimeout(resolve, 400))
+              ]);
+            }
+            updateActiveMsgNum();
             void startPromise.then(() => updateActiveMsgNum()).catch((e) => {
               const err = e instanceof Error ? e : new Error(String(e));
               this.emitSafeError(err);
@@ -12542,8 +12543,24 @@ var BaichuanEventEmitter = class {
   }
 };
 async function* createNativeStream(api, channel, profile, options) {
+  let client = options?.client;
+  let dedicatedRelease;
+  if (!client) {
+    const variantSuffix = options?.variant && options.variant !== "default" ? `:${options.variant}` : "";
+    const sessionKey = `live:native${variantSuffix}:ch${channel}:${profile}`;
+    try {
+      api.logger?.info?.(`[createNativeStream] acquiring dedicated session  key=${sessionKey}`);
+      const session = await api.createDedicatedSession(sessionKey);
+      client = session.client;
+      dedicatedRelease = session.release;
+      api.logger?.info?.(`[createNativeStream] dedicated session acquired  key=${sessionKey}`);
+    } catch (e) {
+      api.logger?.warn?.(`[createNativeStream] dedicated session failed, using shared client: ${e instanceof Error ? e.message : e}`);
+      client = api.client;
+    }
+  }
   const videoStream = new BaichuanVideoStream({
-    client: api.client,
+    client,
     api,
     channel,
     profile,
@@ -12557,9 +12574,15 @@ async function* createNativeStream(api, channel, profile, options) {
   let closed = false;
   const onError = (_error) => {
     closed = true;
+    api.logger?.warn?.(
+      `[createNativeStream] stream error \u2192 closed  channel=${channel} profile=${profile} error=${_error?.message ?? _error}`
+    );
   };
   const onClose = () => {
     closed = true;
+    api.logger?.warn?.(
+      `[createNativeStream] stream close \u2192 closed  channel=${channel} profile=${profile}`
+    );
   };
   try {
     videoStream.on("error", onError);
@@ -12670,6 +12693,10 @@ async function* createNativeStream(api, channel, profile, options) {
     }
     videoStream.removeListener("error", onError);
     videoStream.removeListener("close", onClose);
+    if (dedicatedRelease) {
+      dedicatedRelease().catch(() => {
+      });
+    }
   }
 }
 
@@ -12909,6 +12936,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
   tcpRtpFraming;
   active = false;
   flow;
+  deviceId;
+  dedicatedSessionRelease;
   // Authentication
   authCredentials = [];
   requireAuth;
@@ -13075,6 +13104,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     this.path = options.path ?? `/stream/${this.profile}`;
     this.logger = options.logger ?? console;
     this.tcpRtpFraming = options.tcpRtpFraming ?? "rfc4571";
+    this.deviceId = options.deviceId;
     this.authCredentials = options.credentials ?? [];
     this.requireAuth = options.requireAuth ?? this.authCredentials.length > 0;
     const transport = this.api.client.getTransport();
@@ -14460,14 +14490,31 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     this.firstAudioPromise = new Promise((resolve) => {
       this.firstAudioResolve = resolve;
     });
+    let dedicatedClient;
+    const variantSuffix = this.variant && this.variant !== "default" ? `:${this.variant}` : "";
+    const deviceIdPart = this.deviceId ?? "rtsp-server";
+    const sessionKey = `live:${deviceIdPart}:ch${this.channel}:${this.profile}${variantSuffix}`;
+    try {
+      const session = await this.api.createDedicatedSession(sessionKey, this.logger);
+      dedicatedClient = session.client;
+      this.dedicatedSessionRelease = session.release;
+      this.logger.info(
+        `[rebroadcast] dedicated session acquired  sessionKey=${sessionKey}`
+      );
+    } catch (e) {
+      this.logger.warn(
+        `[rebroadcast] failed to acquire dedicated session, falling back to shared socket: ${e}`
+      );
+    }
     this.logger.info(
-      `[rebroadcast] native stream starting  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size}`
+      `[rebroadcast] native stream starting  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size} dedicated=${!!dedicatedClient}`
     );
     await this.flow.startKeepAlive(this.api);
     this.nativeFanout = new NativeStreamFanout({
       maxQueueItems: 200,
       createSource: () => createNativeStream(this.api, this.channel, this.profile, {
-        variant: this.variant
+        variant: this.variant,
+        ...dedicatedClient ? { client: dedicatedClient } : {}
       }),
       onFrame: (frame) => {
         if (frame.audio) {
@@ -14525,6 +14572,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
         this.firstFrameResolve = null;
         this.nativeFanout = null;
         this.prebuffer = [];
+        if (this.dedicatedSessionRelease) {
+          const release = this.dedicatedSessionRelease;
+          this.dedicatedSessionRelease = void 0;
+          release().catch(() => {
+          });
+        }
         this.logger.info(
           `[rebroadcast] native stream ended (camera sleeping or connection lost)  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size}`
         );
@@ -14594,6 +14647,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
       await fanout.stop();
     }
     this.prebuffer = [];
+    if (this.dedicatedSessionRelease) {
+      const release = this.dedicatedSessionRelease;
+      this.dedicatedSessionRelease = void 0;
+      try {
+        await release();
+      } catch {
+      }
+    }
     if (this.tempStreamGenerator) {
       try {
         await this.tempStreamGenerator.return(void 0);
@@ -14603,14 +14664,22 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     }
   }
   /**
-   * Remove a client and stop native stream if no clients remain.
+   * Remove a client and schedule native stream stop if no clients remain.
+   * Uses a grace period so rapid reconnects (e.g. Frigate polling) reuse the running stream
+   * and benefit from the prebuffer instead of waiting for a fresh keyframe.
    */
   removeClient(clientId) {
     if (this.connectedClients.has(clientId)) {
       this.connectedClients.delete(clientId);
       this.emit("clientDisconnected", clientId);
       if (this.connectedClients.size === 0) {
-        void this.stopNativeStream();
+        this.clearNoClientAutoStopTimer();
+        this.noClientAutoStopTimer = setTimeout(() => {
+          if (this.connectedClients.size === 0) {
+            void this.stopNativeStream();
+          }
+        }, 3e4);
+        this.noClientAutoStopTimer?.unref?.();
       }
     }
   }
@@ -34182,6 +34251,7 @@ var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
   segmentDuration;
   playlistSize;
   ffmpegPath;
+  externalVideoStream;
   log;
   outputDir = null;
   createdTempDir = false;
@@ -34208,6 +34278,7 @@ var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
       this.outputDir = options.outputDir;
       this.createdTempDir = false;
     }
+    this.externalVideoStream = options.externalVideoStream;
     this.log = options.logger ?? (() => {
     });
   }
@@ -34232,12 +34303,16 @@ var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
       this.playlistPath = import_node_path3.default.join(this.outputDir, "playlist.m3u8");
       this.segmentPattern = import_node_path3.default.join(this.outputDir, "segment_%05d.ts");
       this.log("info", `Starting HLS stream to ${this.outputDir}`);
-      this.nativeStream = createNativeStream(
-        this.api,
-        this.channel,
-        this.profile,
-        this.variant ? { variant: this.variant } : void 0
-      );
+      if (this.externalVideoStream) {
+        this.nativeStream = this.wrapVideoStreamAsGenerator(this.externalVideoStream);
+      } else {
+        this.nativeStream = createNativeStream(
+          this.api,
+          this.channel,
+          this.profile,
+          this.variant ? { variant: this.variant } : void 0
+        );
+      }
       this.pumpPromise = this.pumpNativeToFfmpeg();
       this.startedAt = /* @__PURE__ */ new Date();
       this.state = "running";
@@ -34356,6 +34431,56 @@ var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
   // ============================================================================
   // Private Methods
   // ============================================================================
+  /**
+   * Wrap a BaichuanVideoStream's videoAccessUnit events into an async generator
+   * compatible with createNativeStream's output format.
+   */
+  async *wrapVideoStreamAsGenerator(videoStream) {
+    const queue = [];
+    let resolve = null;
+    let done = false;
+    const onFrame = (au) => {
+      queue.push(au);
+      resolve?.();
+      resolve = null;
+    };
+    const onClose = () => {
+      done = true;
+      resolve?.();
+      resolve = null;
+    };
+    const onError = () => {
+      done = true;
+      resolve?.();
+      resolve = null;
+    };
+    videoStream.on("videoAccessUnit", onFrame);
+    videoStream.on("close", onClose);
+    videoStream.on("error", onError);
+    try {
+      while (!done) {
+        if (queue.length === 0) {
+          await new Promise((r) => {
+            resolve = r;
+          });
+        }
+        while (queue.length > 0) {
+          const frame = queue.shift();
+          yield {
+            audio: false,
+            data: frame.data,
+            videoType: frame.videoType,
+            isKeyframe: frame.isKeyframe,
+            microseconds: frame.microseconds
+          };
+        }
+      }
+    } finally {
+      videoStream.removeListener("videoAccessUnit", onFrame);
+      videoStream.removeListener("close", onClose);
+      videoStream.removeListener("error", onError);
+    }
+  }
   async pumpNativeToFfmpeg() {
     if (!this.nativeStream || !this.playlistPath || !this.segmentPattern) {
       return;