@apocaliss92/nodelink-js 0.4.7 → 0.4.8

package/dist/index.d.ts

@@ -1311,6 +1311,7 @@ export declare class BaichuanRtspServer extends EventEmitter<{
     private authNonces;
     private readonly AUTH_REALM;
     private readonly NONCE_TIMEOUT_MS;
+    private readonly lazyMetadata;
     private connectedClients;
     private nativeStreamActive;
     private clientConnectionServer;
@@ -1330,10 +1331,20 @@ export declare class BaichuanRtspServer extends EventEmitter<{
     private tempStreamGenerator;
     private nativeFanout;
     private noClientAutoStopTimer;
+    /** Fires if camera never sends frames after stream start (sleeping), even with clients connected. */
+    private noFrameDeadlineTimer;
     /** After last RTSP client; 0 = never auto-stop native stream. */
     private readonly nativeStreamIdleStopMs;
     /** Primed-but-no-PLAY timeout; 0 = disabled. */
     private readonly nativeStreamPrimeIdleStopMs;
+    /**
+     * Max time to wait for the first camera frame after stream start.
+     * If no frames arrive within this window, the native stream is stopped
+     * (camera is sleeping). Prevents the BaichuanVideoStream watchdog from
+     * firing and waking the camera when no real viewer is watching.
+     * 0 = disabled. Defaults to nativeStreamPrimeIdleStopMs * 2 when > 0.
+     */
+    private readonly nativeStreamNoFrameDeadlineMs;
     private readonly PREBUFFER_MAX_MS;
     private prebuffer;
     private static isAdtsAacFrame;
@@ -1344,6 +1355,8 @@ export declare class BaichuanRtspServer extends EventEmitter<{
     private static splitAnnexBNals;
     private static stripAdtsHeader;
     constructor(options: BaichuanRtspServerOptions);
+    /** Number of currently connected RTSP clients. */
+    get clientCount(): number;
     /**
      * Generate a new nonce for Digest authentication
      */
@@ -1369,6 +1382,7 @@ export declare class BaichuanRtspServer extends EventEmitter<{
      */
     private generateWwwAuthenticateHeader;
     private clearNoClientAutoStopTimer;
+    private clearNoFrameDeadlineTimer;
     private setFlowVideoType;
     /**
      * Start the RTSP server.
@@ -1381,6 +1395,21 @@ export declare class BaichuanRtspServer extends EventEmitter<{
      * @param initialBuffer - Any bytes already read during path parsing/auth
      */
     acceptConnection(socket: net.Socket, initialBuffer?: Buffer): void;
+    /**
+     * Inject an already-accepted client socket from a multiplexer
+     * (e.g. `LocalRtspMux`) that owns the listening port.
+     *
+     * The mux reads the first RTSP request line to determine the target path,
+     * then hands the socket over. Any bytes already consumed during routing
+     * are replayed back onto the socket via `unshift()` so the RTSP parser in
+     * `handleRtspConnection` sees the complete original request.
+     *
+     * @param socket - Client TCP socket, already accepted by the mux.
+     * @param preReadData - Bytes the mux has already pulled off the socket
+     *   while parsing the request line. Replayed via `socket.unshift()`
+     *   before any further reads.
+     */
+    injectSocket(socket: net.Socket, preReadData: Buffer): void;
     /**
      * Handle RTSP connection from a client.
      */
@@ -1481,13 +1510,34 @@ export declare interface BaichuanRtspServerOptions {
      * - "rfc4571": RFC4571 framing: 2-byte length + RTP packet
      */
     tcpRtpFraming?: "rtsp-interleaved" | "rfc4571";
-    /** Credentials for RTSP authentication (optional) */
+    /**
+     * Credentials for RTSP authentication (optional).
+     *
+     * Each entry carries either the plaintext `password` or a pre-computed
+     * Digest `ha1 = MD5(username ":" realm ":" password)`. The HA1 variant is
+     * preferred when the consumer stores only hashed credentials (e.g. the
+     * manager reuses dashboard-user HA1 values without ever holding plaintext).
+     *
+     * When both are supplied, `ha1` wins for Digest validation while `password`
+     * is used for Basic authentication.
+     */
     credentials?: Array<{
         username: string;
         password: string;
+        ha1?: string;
+    } | {
+        username: string;
+        password?: string;
+        ha1: string;
     }>;
     /** Require authentication for RTSP connections (default: false if no credentials set) */
     requireAuth?: boolean;
+    /**
+     * Digest authentication realm advertised to clients. Must match the realm
+     * used when pre-computing HA1 values in `credentials[*].ha1`.
+     * Default: "BaichuanRtspServer" (kept for backward compatibility).
+     */
+    authRealm?: string;
     /**
      * External identifier for dedicated socket session.
      * When provided, a dedicated BaichuanClient is created for the stream,
@@ -1500,6 +1550,18 @@ export declare interface BaichuanRtspServerOptions {
      * start() still performs metadata fetch and codec detection.
      */
     externalListener?: boolean;
+    /**
+     * When true, the server runs in **mux mode**: `start()` skips creating
+     * or listening on any TCP server (a shared multiplexer — e.g.
+     * `LocalRtspMux` — owns the public RTSP port and routes accepted sockets
+     * here via `injectSocket()`). `stop()` likewise skips closing a TCP
+     * server it does not own.
+     *
+     * Semantically equivalent to `externalListener: true`, but expressed from
+     * the point of view of the multiplexer that will drive this instance.
+     * Either flag is sufficient; both may be set together.
+     */
+    muxMode?: boolean;
     /**
      * Ms after the last RTSP client disconnects before stopping the native Baichuan stream.
      * 0 = keep the native stream running (matches rtsp proxy idle timeout 0 / always-mounted sources).
@@ -1511,6 +1573,18 @@ export declare interface BaichuanRtspServerOptions {
      * 0 = disable. Default 15000 when nativeStreamIdleStopMs > 0, else 0.
      */
     nativeStreamPrimeIdleStopMs?: number;
+    /**
+     * When true, `start()` does NOT fetch stream metadata from the camera —
+     * the metadata fetch is deferred to the first DESCRIBE. Useful for
+     * battery / UDP cameras so binding the RTSP port at boot does not wake
+     * them up when no client is listening.
+     *
+     * Trade-off: the very first DESCRIBE pays the metadata round-trip
+     * latency. Subsequent connections hit the cached metadata.
+     *
+     * Default: false (keep existing behaviour).
+     */
+    lazyMetadata?: boolean;
 }
 
 export declare type BaichuanSerialPush = {
@@ -3415,6 +3489,8 @@ export declare function createNativeStream(api: ReolinkBaichuanApi, channel: num
     variant?: NativeVideoStreamVariant;
     /** Optional dedicated BaichuanClient for stream isolation. When omitted, uses api.client (shared). */
     client?: BaichuanClient;
+    /** Cancellation signal — aborting wakes the idle sleep and exits the generator promptly. */
+    signal?: AbortSignal;
 }): AsyncGenerator<{
     audio: boolean;
     data: Buffer;
@@ -3525,6 +3601,22 @@ export declare type DebugOptions = {
     };
 };
 
+/**
+ * Decide whether a new sleep-inference poll should emit an event, given the
+ * previously committed state and any pending hysteresis candidate.
+ *
+ * Rules:
+ *   1. First observation (committed === undefined): always adopt as committed.
+ *      Emit "sleeping" but not "awake" — awake is the implicit default, so
+ *      emitting on startup would be noisy.
+ *   2. Inferred matches committed: stable, clear any pending candidate.
+ *   3. Inferred differs from committed but matches the pending candidate:
+ *      increment count. When count reaches hysteresisPolls, commit and emit.
+ *   4. Inferred differs from committed AND from any pending candidate:
+ *      restart the candidate at count=1 (does not emit).
+ */
+export declare function decideSleepInferenceTransition(input: SleepInferenceInput): SleepInferenceDecision;
+
 /**
  * Determine if H.265 should be transcoded to H.264 based on client capabilities.
  *
@@ -4217,6 +4309,7 @@ export declare class Go2rtcTcpServer extends EventEmitter<{
     private totalFramesReceived;
     private totalVideoFramesWritten;
     private prebuffer;
+    private audioInfo;
     constructor(options: Go2rtcTcpServerOptions);
     /** Start listening. Resolves once the TCP server is bound. */
     start(): Promise<void>;
@@ -4228,18 +4321,45 @@ export declare class Go2rtcTcpServer extends EventEmitter<{
     get go2rtcSourceUrl(): string | undefined;
     /** Number of currently connected clients. */
     get clientCount(): number;
+    /**
+     * 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.
+     */
+    subscribeDiagnostic(id: string): Promise<AsyncGenerator<NativeFrame, void, unknown>>;
+    /** Unsubscribe a diagnostic session and release its consumer slot. */
+    unsubscribeDiagnostic(id: string): void;
+    /**
+     * 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(): {
+        codec: "aac-adts";
+        sampleRate: number;
+        channels: number;
+        configHex: string;
+    } | null;
     private handleClient;
     private feedClient;
     /**
-     * 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).
      */
-    private convertFrame;
+    private convertVideoFrame;
     /** Check if an Annex-B buffer contains a keyframe (IDR for H.264, IRAP for H.265). */
     private isAnnexBKeyframe;
     /** Split Annex-B byte stream into individual NAL units. */
     private static splitAnnexBNals;
+    /** True if `b` starts with an ADTS AAC syncword (0xFFF). */
+    private static isAdtsAacFrame;
+    /**
+     * Parse an ADTS header into {sampleRate, channels, AudioSpecificConfig hex}.
+     * Returns null when the buffer is not a valid ADTS frame.
+     */
+    private static parseAdtsSamplingInfo;
     private startNativeStream;
     private stopNativeStream;
     private startStreamHealthMonitor;
@@ -4780,6 +4900,84 @@ export declare interface MotionEvent {
     source?: "md" | "pir" | "unknown";
 }
 
+/**
+ * Stateful MPEG-TS muxer.  Each instance has its own continuity counters —
+ * create one per output stream (or per client connection for prebuffer replay).
+ */
+export declare class MpegTsMuxer {
+    private readonly videoStreamType;
+    private readonly includeAudio;
+    private patCc;
+    private pmtCc;
+    private videoCc;
+    private audioCc;
+    private framesSinceTableSend;
+    private tablesSent;
+    constructor(options: MpegTsMuxerOptions);
+    /**
+     * Mux a video frame (Annex-B H.264 or H.265) into MPEG-TS packets.
+     * PAT and PMT are emitted before keyframes and periodically.
+     *
+     * @param annexBData - Annex-B video data (with start codes)
+     * @param ptsUs      - Presentation timestamp in microseconds
+     * @param isKeyframe - Whether this is an IDR / IRAP frame
+     */
+    muxVideo(annexBData: Buffer, ptsUs: number, isKeyframe: boolean): Buffer;
+    /**
+     * Mux an audio frame (ADTS AAC) into MPEG-TS packets.
+     * Returns an empty Buffer when includeAudio is false.
+     *
+     * @param adtsData - Raw ADTS AAC frame (starting with 0xFF 0xF1/0xF9 syncword)
+     * @param ptsUs    - Presentation timestamp in microseconds
+     */
+    muxAudio(adtsData: Buffer, ptsUs: number): Buffer;
+    /** Reset all continuity counters and table state (e.g. after stream restart). */
+    reset(): void;
+}
+
+/**
+ * MPEG-TS Muxer for H.264/H.265 video + ADTS AAC audio.
+ *
+ * Produces 188-byte MPEG-TS packets suitable for feeding to go2rtc via a
+ * plain TCP connection (`tcp://127.0.0.1:{port}`).  go2rtc auto-detects the
+ * container format from the 0x47 sync byte and extracts both video and audio.
+ *
+ * Stream layout:
+ *   PID 0x0000 — PAT (Program Association Table)
+ *   PID 0x1000 — PMT (Program Map Table)
+ *   PID 0x0100 — Video elementary stream (H.264 or H.265, Annex-B)
+ *   PID 0x0101 — Audio elementary stream (AAC-ADTS, stream type 0x0F)
+ *
+ * Each `MpegTsMuxer` instance is independent: continuity counters are
+ * per-instance so multiple concurrent streams do not corrupt each other.
+ *
+ * Usage:
+ *   const muxer = new MpegTsMuxer({ videoType: "H265", includeAudio: true });
+ *   const tsBytes = muxer.muxVideo(annexBBuffer, ptsUs, isKeyframe);
+ *   const tsBytes = muxer.muxAudio(adtsBuffer, ptsUs);
+ */
+export declare interface MpegTsMuxerOptions {
+    /** Video codec type. */
+    videoType: "H264" | "H265";
+    /**
+     * Whether to include an audio PID (0x0101) in the PMT.
+     * When true, audio frames muxed via muxAudio() are wrapped in PES packets
+     * on PID 0x0101 (AAC-ADTS, stream type 0x0F).
+     * Default: true.
+     */
+    includeAudio?: boolean;
+}
+
+declare type NativeFrame = {
+    audio: boolean;
+    data: Buffer;
+    codec: string | null;
+    sampleRate: number | null;
+    microseconds: number | null;
+    videoType?: "H264" | "H265";
+    isKeyframe?: boolean;
+};
+
 export declare type NativeVideoStreamVariant = "default" | "autotrack" | "telephoto";
 
 /**
@@ -5218,7 +5416,17 @@ export declare class ReolinkBaichuanApi {
     private statePollingInterval;
     private udpSleepInferenceInterval;
     private readonly udpLastInferredSleepStateByChannel;
+    /**
+     * Per-channel pending sleep-state candidate for hysteresis.
+     * When the inference flips to a new state we require N consecutive polls
+     * of that same state before committing it — this filters out transient
+     * flapping caused by non-waking traffic drifting in/out of the 10 s
+     * getSleepStatus() observation window during stream teardown.
+     */
+    private readonly udpPendingSleepStateByChannel;
     private readonly udpSleepInferenceIntervalMs;
+    /** Consecutive inference polls required to commit a new sleeping/awake state. */
+    private readonly udpSleepInferenceHysteresisPolls;
     private lastMotionState;
     private lastAiState;
     private aiStatePollingDisabled;
@@ -8941,6 +9149,31 @@ export declare interface SirenStatusConfig {
     };
 }
 
+export declare interface SleepInferenceDecision {
+    /** The event to dispatch, or null if no event should fire this poll. */
+    emit: "sleeping" | "awake" | null;
+    /** New committed state to store (never "unknown"). */
+    nextCommitted: SleepState;
+    /** New pending candidate to store, or undefined to clear it. */
+    nextPending: SleepInferencePending | undefined;
+}
+
+export declare interface SleepInferenceInput {
+    /** State returned by the current getSleepStatus() poll — must not be "unknown". */
+    inferred: Exclude<SleepState, "unknown">;
+    /** Previously committed state (undefined = first observation after inference start). */
+    committed: SleepState | undefined;
+    /** Pending candidate state and consecutive match count, if any. */
+    pending: SleepInferencePending | undefined;
+    /** Consecutive polls of the same inferred state required to commit. */
+    hysteresisPolls: number;
+}
+
+export declare interface SleepInferencePending {
+    state: SleepState;
+    count: number;
+}
+
 export declare type SleepState = "awake" | "sleeping" | "unknown";
 
 /**