@apocaliss92/nodelink-js 0.4.6 → 0.4.8

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   DUAL_LENS_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
   Intercom,
+  MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -20,6 +21,7 @@ import {
   createNativeStream,
   createNullLogger,
   createTaggedLogger,
+  decideSleepInferenceTransition,
   decodeHeader,
   discoverReolinkDevices,
   discoverViaArpTable,
@@ -43,7 +45,7 @@ import {
   parseSupportXml,
   setGlobalLogger,
   xmlIndicatesFloodlight
-} from "./chunk-F2Y5U3YP.js";
+} from "./chunk-VBYF3BQX.js";
 import {
   AesStreamDecryptor,
   BC_AES_IV,
@@ -223,7 +225,7 @@ import {
   testChannelStreams,
   xmlEscape,
   zipDirectory
-} from "./chunk-TR3V5FTO.js";
+} from "./chunk-YKKQDUKU.js";
 
 // src/reolink/baichuan/HlsSessionManager.ts
 var withTimeout = async (p, ms, label) => {
@@ -4725,6 +4727,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
   gracePeriodMs;
   prebufferMaxMs;
   maxBufferBytes;
+  streamTimeoutMs;
   prestartStream;
   active = false;
   server;
@@ -4738,8 +4741,16 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
   connectedClients = /* @__PURE__ */ new Set();
   clientSockets = /* @__PURE__ */ new Map();
   stopGraceTimer;
+  // Stream health monitoring
+  lastFrameAt = 0;
+  streamHealthTimer;
+  totalFramesReceived = 0;
+  totalVideoFramesWritten = 0;
   // Prebuffer
   prebuffer = [];
+  // Audio metadata — populated on first valid ADTS AAC frame.
+  // Exposed via getAudioInfo() for the stream-diagnostics feature.
+  audioInfo = null;
   constructor(options) {
     super();
     this.api = options.api;
@@ -4753,6 +4764,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     this.gracePeriodMs = options.gracePeriodMs ?? 3e4;
     this.prebufferMaxMs = options.prebufferMs ?? 3e3;
     this.maxBufferBytes = options.maxBufferBytes ?? 1e8;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 15e3;
     this.prestartStream = options.prestartStream ?? true;
   }
   // -----------------------------------------------------------------------
@@ -4791,6 +4803,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     if (!this.active) return;
     this.active = false;
     clearTimeout(this.stopGraceTimer);
+    this.stopStreamHealthMonitor();
     for (const [id, sock] of this.clientSockets) {
       sock.destroy();
       this.connectedClients.delete(id);
@@ -4821,6 +4834,45 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     return this.connectedClients.size;
   }
   // -----------------------------------------------------------------------
+  // Diagnostic subscription API (implements DiagnosticStreamServer)
+  //
+  // Matches the shape of BaichuanRtspServer's diagnostic API so the
+  // stream-diagnostic feature in the Manager app can drive either backend
+  // with identical code.
+  // -----------------------------------------------------------------------
+  /**
+   * Subscribe to the raw native stream for diagnostic purposes.
+   * The subscriber receives the same frames the MPEG-TS muxer consumes
+   * (pre-muxing). Counts as a "consumer" so the native stream is kept alive
+   * for the lifetime of the subscription. If the stream is not already
+   * running (battery camera, prestart=false), this starts it.
+   */
+  async subscribeDiagnostic(id) {
+    this.connectedClients.add(`diag:${id}`);
+    if (!this.nativeStreamActive) {
+      await this.startNativeStream();
+    }
+    if (!this.nativeFanout) {
+      this.connectedClients.delete(`diag:${id}`);
+      throw new Error(
+        "Go2rtcTcpServer: native stream failed to start \u2014 cannot subscribe diagnostic"
+      );
+    }
+    return this.nativeFanout.subscribe(`diag:${id}`);
+  }
+  /** Unsubscribe a diagnostic session and release its consumer slot. */
+  unsubscribeDiagnostic(id) {
+    this.removeClient(`diag:${id}`, "diagnostic unsubscribe");
+  }
+  /**
+   * Returns ADTS AAC audio metadata detected from the native stream, or
+   * null if no audio frame has been observed yet (e.g. video-only cameras
+   * or before the first audio packet arrives).
+   */
+  getAudioInfo() {
+    return this.audioInfo;
+  }
+  // -----------------------------------------------------------------------
   // Client handling
   // -----------------------------------------------------------------------
   handleClient(socket) {
@@ -4844,12 +4896,12 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
         `[Go2rtcTcpServer] feedClient error  id=${clientId}: ${err}`
       );
     });
-    const cleanup = () => {
-      this.removeClient(clientId);
+    const cleanup = (reason) => {
+      this.removeClient(clientId, reason);
       socket.destroy();
     };
-    socket.on("error", cleanup);
-    socket.on("close", cleanup);
+    socket.on("error", (err) => cleanup(`error: ${err.message}`));
+    socket.on("close", (hadError) => cleanup(hadError ? "close (with error)" : "close (clean)"));
   }
   async feedClient(clientId, socket) {
     const fanoutDeadline = Date.now() + 3e4;
@@ -4865,6 +4917,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     }
     if (!this.active || !this.nativeFanout) return;
     const subscription = this.nativeFanout.subscribe(clientId);
+    let muxer = null;
     const prebufferSnap = this.prebuffer.slice();
     let lastIdrIdx = -1;
     for (let i = prebufferSnap.length - 1; i >= 0; i--) {
@@ -4878,9 +4931,21 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
       this.logger.info?.(
         `[Go2rtcTcpServer] prebuffer replay  client=${clientId} frames=${replay.length}`
       );
+      if (!muxer) {
+        muxer = new MpegTsMuxer({
+          videoType: this.detectedVideoType ?? "H264",
+          includeAudio: true
+        });
+      }
       for (const entry of replay) {
         if (socket.destroyed) return;
-        socket.write(entry.data);
+        let ts;
+        if (!entry.audio) {
+          ts = muxer.muxVideo(entry.data, entry.pts, entry.isKeyframe);
+        } else {
+          ts = muxer.muxAudio(entry.data, entry.pts);
+        }
+        if (ts.length > 0) socket.write(ts);
       }
     }
     let seenKeyframe = lastIdrIdx >= 0;
@@ -4899,17 +4964,35 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
           break;
         }
         liveFrameCount++;
-        const annexB = this.convertFrame(frame);
+        if (frame.audio) {
+          if (muxer) {
+            const pts2 = frame.microseconds ?? Date.now() * 1e3;
+            const ts2 = muxer.muxAudio(frame.data, pts2);
+            if (ts2.length > 0) socket.write(ts2);
+          }
+          continue;
+        }
+        const annexB = this.convertVideoFrame(frame);
         if (!annexB) continue;
+        const isKf = this.isAnnexBKeyframe(annexB, frame.videoType);
         if (!seenKeyframe) {
-          if (!this.isAnnexBKeyframe(annexB, frame.videoType)) continue;
+          if (!isKf) continue;
           seenKeyframe = true;
           this.logger.info?.(
             `[Go2rtcTcpServer] first live keyframe  client=${clientId} after ${liveFrameCount} frames`
           );
+          if (!muxer) {
+            muxer = new MpegTsMuxer({
+              videoType: frame.videoType ?? this.detectedVideoType ?? "H264",
+              includeAudio: true
+            });
+          }
         }
-        socket.write(annexB);
+        const pts = frame.microseconds ?? Date.now() * 1e3;
+        const ts = muxer.muxVideo(annexB, pts, isKf);
+        socket.write(ts);
         liveVideoWritten++;
+        this.totalVideoFramesWritten++;
         if (Date.now() - lastLogAt > 1e4) {
           this.logger.info?.(
             `[Go2rtcTcpServer] live stats  client=${clientId} received=${liveFrameCount} written=${liveVideoWritten} bufLen=${socket.writableLength}`
@@ -4936,14 +5019,11 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
   // Frame conversion
   // -----------------------------------------------------------------------
   /**
-   * Convert a native frame to wire-ready Annex-B.
-   * Audio frames are skipped — raw TCP carries only video (Annex-B).
-   * go2rtc auto-detects the codec from SPS/PPS/VPS NALUs.
+   * Convert a native video frame to Annex-B.
+   * Returns null for audio frames (handled separately by muxAudio).
    */
-  convertFrame(frame) {
-    if (frame.audio) {
-      return null;
-    }
+  convertVideoFrame(frame) {
+    if (frame.audio) return null;
     if (frame.data.length === 0) return null;
     try {
       if (frame.videoType === "H264") {
@@ -5007,10 +5087,71 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     return nals;
   }
   // -----------------------------------------------------------------------
+  // ADTS AAC parsing (used for audio metadata exposed via getAudioInfo)
+  // -----------------------------------------------------------------------
+  /** True if `b` starts with an ADTS AAC syncword (0xFFF). */
+  static isAdtsAacFrame(b) {
+    return b.length >= 2 && b[0] === 255 && (b[1] & 240) === 240;
+  }
+  /**
+   * Parse an ADTS header into {sampleRate, channels, AudioSpecificConfig hex}.
+   * Returns null when the buffer is not a valid ADTS frame.
+   */
+  static parseAdtsSamplingInfo(b) {
+    if (b.length < 7) return null;
+    if (!_Go2rtcTcpServer.isAdtsAacFrame(b)) return null;
+    const samplingIndex = b[2] >> 2 & 15;
+    const sampleRates = [
+      96e3,
+      88200,
+      64e3,
+      48e3,
+      44100,
+      32e3,
+      24e3,
+      22050,
+      16e3,
+      12e3,
+      11025,
+      8e3,
+      7350
+    ];
+    const sampleRate = sampleRates[samplingIndex] ?? null;
+    if (!sampleRate) return null;
+    const channelConfig = (b[2] & 1) << 2 | b[3] >> 6 & 3;
+    const channels = channelConfig === 0 ? 1 : channelConfig;
+    const profile = b[2] >> 6 & 3;
+    const audioObjectType = profile + 1;
+    const asc = audioObjectType << 11 | samplingIndex << 7 | channelConfig << 3;
+    const configHex = Buffer.from([asc >> 8 & 255, asc & 255]).toString(
+      "hex"
+    );
+    return { sampleRate, channels, configHex };
+  }
+  // -----------------------------------------------------------------------
   // Native stream management
   // -----------------------------------------------------------------------
   async startNativeStream() {
     if (this.nativeStreamActive) return;
+    if (!this.api.isReady) {
+      if (this.api.isClosed) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] API has been explicitly closed \u2014 stream cannot start`
+        );
+        return;
+      }
+      try {
+        this.logger.info?.(
+          `[Go2rtcTcpServer] API not ready (idle disconnect?), calling ensureConnected`
+        );
+        await this.api.ensureConnected();
+      } catch (e) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] ensureConnected failed, aborting stream start: ${e}`
+        );
+        return;
+      }
+    }
     this.nativeStreamActive = true;
     let dedicatedClient;
     if (this.deviceId) {
@@ -5029,6 +5170,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     this.logger.info?.(
       `[Go2rtcTcpServer] native stream starting  channel=${this.channel} profile=${this.profile} dedicated=${!!dedicatedClient}`
     );
+    let hadFrames = false;
     this.nativeFanout = new NativeStreamFanout({
       maxQueueItems: 200,
       createSource: () => createNativeStream(this.api, this.channel, this.profile, {
@@ -5036,17 +5178,37 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
         ...dedicatedClient ? { client: dedicatedClient } : {}
       }),
       onFrame: (frame) => {
+        hadFrames = true;
+        this.lastFrameAt = Date.now();
+        this.totalFramesReceived++;
         if (!frame.audio && (frame.videoType === "H264" || frame.videoType === "H265")) {
           this.detectedVideoType = frame.videoType;
         }
-        const wireData = this.convertFrame(frame);
-        if (!wireData || wireData.length === 0) return;
-        const isKeyframe = !frame.audio && this.isAnnexBKeyframe(wireData, frame.videoType);
+        let prebufData;
+        let isKeyframe;
+        if (frame.audio) {
+          if (frame.data.length === 0) return;
+          if (!this.audioInfo) {
+            const parsed = _Go2rtcTcpServer.parseAdtsSamplingInfo(frame.data);
+            if (parsed) {
+              this.audioInfo = { codec: "aac-adts", ...parsed };
+            }
+          }
+          prebufData = frame.data;
+          isKeyframe = false;
+        } else {
+          const annexB = this.convertVideoFrame(frame);
+          if (!annexB || annexB.length === 0) return;
+          prebufData = annexB;
+          isKeyframe = this.isAnnexBKeyframe(annexB, frame.videoType);
+        }
+        const pts = frame.microseconds ?? Date.now() * 1e3;
         this.prebuffer.push({
-          data: Buffer.from(wireData),
+          data: Buffer.from(prebufData),
           time: Date.now(),
           isKeyframe,
-          audio: frame.audio
+          audio: frame.audio,
+          pts
         });
         const cutoff = Date.now() - this.prebufferMaxMs;
         let trimIdx = 0;
@@ -5062,23 +5224,47 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
         this.nativeFanout = null;
+        this.stopStreamHealthMonitor();
+        const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+        const diagnosis = silenceMs > this.streamTimeoutMs ? "camera stopped sending frames" : silenceMs >= 0 ? "stream source closed" : "no frames were ever received";
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] native stream ended  diagnosis="${diagnosis}" lastFrame=${silenceMs >= 0 ? `${(silenceMs / 1e3).toFixed(1)}s ago` : "never"} totalRx=${this.totalFramesReceived} clients=${this.connectedClients.size}`
+        );
         if (this.dedicatedSessionRelease) {
           this.dedicatedSessionRelease().catch(() => {
           });
           this.dedicatedSessionRelease = void 0;
         }
-        if (this.active && (this.connectedClients.size > 0 || this.prestartStream)) {
+        if (!this.prestartStream) {
           this.logger.info?.(
-            `[Go2rtcTcpServer] native stream ended, restarting (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
+            `[Go2rtcTcpServer] battery native stream ended  hadFrames=${hadFrames} channel=${this.channel} profile=${this.profile} \u2014 dropping ${this.connectedClients.size} client(s) to prevent wake loop`
+          );
+          for (const [, sock] of this.clientSockets) {
+            sock.destroy();
+          }
+        } else if (this.active) {
+          if (typeof this.api.isStreamProfileRejected === "function" && this.api.isStreamProfileRejected(this.channel, this.profile)) {
+            this.logger.warn?.(
+              `[Go2rtcTcpServer] profile rejected by device  channel=${this.channel} profile=${this.profile} \u2014 not restarting`
+            );
+            for (const [, sock] of this.clientSockets) {
+              sock.destroy();
+            }
+            return;
+          }
+          this.logger.info?.(
+            `[Go2rtcTcpServer] restarting native stream (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
           );
           this.startNativeStream();
         }
       }
     });
     this.nativeFanout.start();
+    this.startStreamHealthMonitor();
   }
   async stopNativeStream() {
     this.nativeStreamActive = false;
+    this.stopStreamHealthMonitor();
     const fanout = this.nativeFanout;
     this.nativeFanout = null;
     if (fanout) {
@@ -5092,14 +5278,50 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
     }
   }
   // -----------------------------------------------------------------------
+  // Stream health monitoring
+  // -----------------------------------------------------------------------
+  startStreamHealthMonitor() {
+    this.stopStreamHealthMonitor();
+    if (this.streamTimeoutMs <= 0) return;
+    this.lastFrameAt = Date.now();
+    this.streamHealthTimer = setInterval(() => {
+      if (!this.nativeStreamActive || !this.active) {
+        this.stopStreamHealthMonitor();
+        return;
+      }
+      const silenceMs = Date.now() - this.lastFrameAt;
+      if (silenceMs > this.streamTimeoutMs) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] stream inactivity timeout: no frames for ${(silenceMs / 1e3).toFixed(1)}s (threshold=${this.streamTimeoutMs}ms), totalReceived=${this.totalFramesReceived} clients=${this.connectedClients.size} \u2014 forcing stream restart`
+        );
+        this.stopStreamHealthMonitor();
+        const fanout = this.nativeFanout;
+        if (fanout) {
+          this.nativeStreamActive = false;
+          this.nativeFanout = null;
+          fanout.stop().catch(() => {
+          });
+        }
+      }
+    }, Math.min(this.streamTimeoutMs / 2, 5e3));
+  }
+  stopStreamHealthMonitor() {
+    if (this.streamHealthTimer) {
+      clearInterval(this.streamHealthTimer);
+      this.streamHealthTimer = void 0;
+    }
+  }
+  // -----------------------------------------------------------------------
   // Client lifecycle
   // -----------------------------------------------------------------------
-  removeClient(clientId) {
+  removeClient(clientId, reason) {
     if (!this.connectedClients.has(clientId)) return;
     this.connectedClients.delete(clientId);
     this.clientSockets.delete(clientId);
+    const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+    const silenceInfo = silenceMs >= 0 ? ` lastFrame=${(silenceMs / 1e3).toFixed(1)}s ago` : "";
     this.logger.info?.(
-      `[Go2rtcTcpServer] client disconnected  id=${clientId} remaining=${this.connectedClients.size}`
+      `[Go2rtcTcpServer] client disconnected  id=${clientId} reason=${reason ?? "unknown"}  remaining=${this.connectedClients.size}  totalRx=${this.totalFramesReceived} totalTx=${this.totalVideoFramesWritten}${silenceInfo}`
     );
     this.emit("clientDisconnected", clientId);
     if (this.connectedClients.size === 0 && !this.prestartStream) {
@@ -7704,6 +7926,7 @@ export {
   HlsSessionManager,
   Intercom,
   MjpegTransformer,
+  MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -7762,6 +7985,7 @@ export {
   createRfc4571TcpServerForReplay,
   createRtspProxyServer,
   createTaggedLogger,
+  decideSleepInferenceTransition,
   decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,