@apocaliss92/nodelink-js 0.6.4 → 0.6.6

package/dist/index.d.ts

@@ -233,6 +233,59 @@ export declare function alawToPcm16(bytes: Uint8Array | Buffer): Int16Array;
  */
 export declare const ALL_UDP_DISCOVERY_METHODS: readonly UdpDiscoveryMethod[];
 
+export declare const ALWAYS_ON_DEFAULTS: {
+    triggers: AlwaysOnTrigger[];
+    windowMs: number;
+    idleFps: number;
+    primeOnStart: boolean;
+    placeholder: Required<PlaceholderOptions>;
+};
+
+export declare class AlwaysOnController {
+    private readonly o;
+    private readonly triggers;
+    private readonly windowMs;
+    private readonly primeOnStart;
+    private readonly logger;
+    private windowTimer;
+    private live;
+    private started;
+    private readonly handler;
+    constructor(o: AlwaysOnControllerOptions);
+    private get windowSeconds();
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private onEvent;
+    private openWindow;
+    private closeWindow;
+}
+
+export declare interface AlwaysOnControllerOptions {
+    api: ReolinkBaichuanApi;
+    channel: number;
+    options: AlwaysOnOptions;
+    goLive: () => Promise<void>;
+    goIdle: () => Promise<void>;
+    logger?: Logger_3;
+}
+
+export declare interface AlwaysOnOptions {
+    enabled: boolean;
+    /** Event types that open a live window. Default ["motion", "doorbell"]. */
+    triggers?: AlwaysOnTrigger[];
+    /** Live window duration after a trigger (ms), extended by new events. Default 15000. */
+    windowMs?: number;
+    /** Placeholder repeat rate while idle (fps). Default 1. */
+    idleFps?: number;
+    /** Wake once on start to capture an initial keyframe. Default true. */
+    primeOnStart?: boolean;
+    /** Placeholder appearance. */
+    placeholder?: PlaceholderOptions;
+}
+
+/** Event types (from ReolinkSimpleEventType) that may open a live window. */
+export declare type AlwaysOnTrigger = "motion" | "doorbell" | "people" | "vehicle" | "animal" | "face" | "package";
+
 export declare type AnyBuffer = Buffer<ArrayBufferLike>;
 
 /**
@@ -1688,6 +1741,9 @@ export declare class BaichuanRtspServer extends EventEmitter<{
     private deviceId;
     private dedicatedSessionRelease;
     private externalListener;
+    private readonly alwaysOnOptions;
+    private continuousStream;
+    private alwaysOnController;
     private authCredentials;
     private requireAuth;
     private authNonces;
@@ -1696,6 +1752,7 @@ export declare class BaichuanRtspServer extends EventEmitter<{
     private readonly lazyMetadata;
     private connectedClients;
     private nativeStreamActive;
+    private tearingDown;
     private clientConnectionServer;
     private streamMetadata;
     private clientResources;
@@ -1804,6 +1861,24 @@ export declare class BaichuanRtspServer extends EventEmitter<{
      * Start ffmpeg for a specific client.
      */
     private startClientFfmpeg;
+    /**
+     * Always-on source: bridge a {@link ContinuousVideoStream} into the existing
+     * fanout. Yields the same frame shape that `createNativeStream` produces, so
+     * the rest of the pipeline (prebuffer, param-set extraction, per-client
+     * subscribe, ffmpeg/direct-RTP) is unchanged.
+     *
+     * The CVS itself is long-lived (created once, reused across native-stream
+     * restarts) and is driven by the {@link AlwaysOnController}, which opens/closes
+     * live windows from camera events. Each fanout source generator only forwards
+     * CVS events to the fanout pump for as long as `signal` is not aborted.
+     */
+    private createContinuousSource;
+    /**
+     * Lazily build the long-lived {@link ContinuousVideoStream} +
+     * {@link AlwaysOnController} for always-on mode. Both are created once and
+     * reused for the lifetime of the server (across native-stream restarts).
+     */
+    private ensureContinuousStream;
     /**
      * Start native stream (mark as active).
      * Each client will create its own generator, so we just track that the stream is active.
@@ -1967,6 +2042,15 @@ export declare interface BaichuanRtspServerOptions {
      * Default: false (keep existing behaviour).
      */
     lazyMetadata?: boolean;
+    /**
+     * Always-on continuous stream (battery cameras). When `enabled`, the server
+     * sources video from a {@link ContinuousVideoStream} (real frames during
+     * event-driven live windows, a low-fps placeholder while the camera sleeps)
+     * driven by an {@link AlwaysOnController}. The controller owns the sleep/wake
+     * decision, so the server's own battery idle-stop timers are suppressed.
+     * When omitted/disabled the server behaves exactly as before.
+     */
+    alwaysOn?: AlwaysOnOptions;
 }
 
 export declare type BaichuanSerialPush = {
@@ -3240,6 +3324,11 @@ export declare function buildStartZoomFocusXml(channelId: number, movePos: numbe
  */
 export declare function buildWhiteLedStateXml(channelId: number, state: number): string;
 
+declare interface CachedKeyframe {
+    data: Buffer;
+    videoType: "H264" | "H265";
+}
+
 declare type CameraResolver = (recipient: string) => string | undefined;
 
 /**
@@ -4391,6 +4480,46 @@ export declare function computeExpectedStreamCompatibility(params: {
     reason: string;
 }>;
 
+export declare class ContinuousVideoStream extends EventEmitter<{
+    videoAccessUnit: [VideoAccessUnit];
+    additionalHeader: [unknown];
+    audioFrame: [Buffer];
+    error: [Error];
+    close: [];
+}> {
+    private readonly opts;
+    private live;
+    private lastKeyframe;
+    private lastMicroseconds;
+    private readonly idleFps;
+    private readonly renderer;
+    private readonly logger;
+    private stopped;
+    private starting;
+    private idleTimer;
+    private idlePlaceholder;
+    constructor(opts: ContinuousVideoStreamOptions);
+    hasCachedKeyframe(): boolean;
+    goLive(): Promise<void>;
+    goIdle(): Promise<void>;
+    stop(): Promise<void>;
+    private startIdleLoop;
+    private stopIdleLoop;
+    private onLiveAccessUnit;
+    private onAdditionalHeader;
+    private onAudioFrame;
+    private onLiveError;
+}
+
+export declare interface ContinuousVideoStreamOptions {
+    /** Returns an un-started live BaichuanVideoStream; ContinuousVideoStream calls start() itself. */
+    createLiveStream: () => Promise<BaichuanVideoStream>;
+    idleFps?: number;
+    placeholder?: PlaceholderOptions;
+    renderer?: PlaceholderRenderer;
+    logger?: Logger_3;
+}
+
 /**
  * Converts H.265 data from length-prefixed (HVCC) to Annex-B (start codes).
  *
@@ -6358,6 +6487,13 @@ declare interface Logger_2 {
     child?(tag: string): Logger_2;
 }
 
+declare interface Logger_3 {
+    info?: (...a: unknown[]) => void;
+    warn?: (...a: unknown[]) => void;
+    error?: (...a: unknown[]) => void;
+    debug?: (...a: unknown[]) => void;
+}
+
 /** Logger callback type for MjpegTransformer */
 export declare type LoggerCallback = (level: "debug" | "info" | "warn" | "error", message: string) => void;
 
@@ -6996,6 +7132,32 @@ export declare interface PirState {
     };
 }
 
+export declare interface PlaceholderOptions {
+    /** Decorate the still (dim + text). Falls back to raw keyframe if ffmpeg is unavailable. Default true. */
+    enabled?: boolean;
+    /** Overlay text. Default "Sleeping". */
+    text?: string;
+    /** Dim factor 0..1 (1 = original brightness). Default 0.5. */
+    opacity?: number;
+}
+
+export declare class PlaceholderRenderer {
+    private readonly opts;
+    private readonly logger;
+    constructor(args: {
+        placeholder?: PlaceholderOptions;
+        logger?: Logger_3;
+    });
+    /** Returns the access unit bytes to emit as placeholder, or null if none available. */
+    render(keyframe: CachedKeyframe | null): Promise<Buffer | null>;
+    /** Decodes the cached keyframe access unit into a single JPEG still via ffmpeg. */
+    private decodeToJpeg;
+    /** Dims the still and prints the overlay text using jimp, returning a JPEG buffer. */
+    private decorate;
+    /** Encodes the decorated JPEG into a single IDR access unit in the target codec. */
+    private encodeIdr;
+}
+
 export declare type PlaybackSnapshotStreamInfo = {
     width?: number;
     height?: number;
@@ -8201,10 +8363,12 @@ export declare class ReolinkBaichuanApi {
      * @param options.source - Data source for the channel list (default: `"cgi"`):
      *   - `"cgi"`: Uses HTTP `GetChannelstatus` — returns the channel list immediately,
      *     no dependency on async push messages. Recommended for first-call discovery.
-     *   - `"baichuan"`: Uses the cmd_id 145 push cache populated when the NVR sends channel
-     *     info after login + event subscription. This push is *asynchronous*: if it has not
-     *     arrived yet, the result will have zero channels. Callers must retry (nvr.ts does this
-     *     with a 1-second loop). Note: explicitly requesting cmd_id 145 is not supported.
+     *   - `"baichuan"`: HTTP-free discovery. Prefers the cmd_id 145 push cache when
+     *     populated; otherwise actively probes the channel slots advertised by Support
+     *     (`items[].chnID`) via `getInfo`. Use this for hubs with HTTP disabled.
+     *
+     * When the api was constructed with `nativeOnly`, the source is forced to
+     * `"baichuan"` regardless of this option (no HTTP/CGI is ever attempted).
      */
     getNvrChannelsSummary(options?: {
         channels?: number[];
@@ -11759,7 +11923,7 @@ export declare interface Rfc4571TcpServer {
     username: string;
     password: string;
     server: net_2.Server;
-    videoStream: BaichuanVideoStream | CompositeStream;
+    videoStream: BaichuanVideoStream | CompositeStream | ContinuousVideoStream;
     close: (reason?: unknown) => Promise<void>;
 }
 
@@ -11838,6 +12002,8 @@ export declare interface Rfc4571TcpServerOptions {
      * The dedicated socket is automatically closed when the stream ends.
      */
     deviceId?: string;
+    /** Battery always-on continuous stream (placeholder while asleep, real frames during motion). */
+    alwaysOn?: AlwaysOnOptions;
 }
 
 export declare interface RtpPacketizationOptions {
@@ -12504,6 +12670,14 @@ export declare function upsamplePcm16(src: Int16Array, factor: number): Int16Arr
  */
 export declare function upsertXmlTag(xml: string, tag: string, value: string | number | boolean | undefined): string;
 
+declare type VideoAccessUnit = {
+    data: Buffer;
+    isKeyframe: boolean;
+    videoType: "H264" | "H265";
+    microseconds: number;
+    time?: number;
+};
+
 /**
  * Client information extracted from HTTP request headers.
  * Used to determine optimal video delivery format.

package/dist/index.js

@@ -1,10 +1,13 @@
 import {
   ALL_UDP_DISCOVERY_METHODS,
+  ALWAYS_ON_DEFAULTS,
+  AlwaysOnController,
   BaichuanClient,
   BaichuanEventEmitter,
   BaichuanFrameParser,
   BaichuanRtspServer,
   BcUdpStream,
+  ContinuousVideoStream,
   DEFAULT_SHELTER_CANVAS,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -13,6 +16,7 @@ import {
   MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
+  PlaceholderRenderer,
   ReolinkBaichuanApi,
   _clearP2pLookupDedupForTests,
   _resetEmailPushBusForTests,
@@ -72,7 +76,7 @@ import {
   setGlobalLogger,
   tcpReachabilityProbe,
   xmlIndicatesFloodlight
-} from "./chunk-UL34MR4L.js";
+} from "./chunk-JQ5NSEVD.js";
 import {
   ReolinkCgiApi,
   ReolinkHttpClient,
@@ -3286,7 +3290,8 @@ async function createRfc4571TcpServerInternal(options) {
     apisToClose.add(resolvedCompositeApis.widerApi);
   if (resolvedCompositeApis?.teleApi)
     apisToClose.add(resolvedCompositeApis.teleApi);
-  const uptimeRestartMs = uptimeRestartMsOpt ?? (isComposite ? 6e4 : 1e4);
+  const alwaysOnEnabled = Boolean(options.alwaysOn?.enabled) && !isComposite;
+  const uptimeRestartMs = alwaysOnEnabled ? 0 : uptimeRestartMsOpt ?? (isComposite ? 6e4 : 1e4);
   const variantSuffix = variant && variant !== "default" ? ` variant=${variant}` : "";
   const logPrefix = isComposite ? `[native-rfc4571 composite profile=${profile}${variantSuffix}${requestedId ? ` id=${requestedId}` : ""}]` : `[native-rfc4571 ch=${channel} profile=${profile}${variantSuffix}]`;
   const log = (message) => {
@@ -3310,6 +3315,7 @@ async function createRfc4571TcpServerInternal(options) {
   );
   let videoStream;
   let isCompositeStream = false;
+  let alwaysOnController;
   if (isComposite) {
     const widerChannel = compositeOptions?.widerChannel ?? 0;
     const teleChannel = compositeOptions?.teleChannel ?? 1;
@@ -3452,7 +3458,7 @@ async function createRfc4571TcpServerInternal(options) {
     } else {
       streamClient = baseApi.client;
     }
-    videoStream = new BaichuanVideoStream({
+    const createLiveStream = async () => new BaichuanVideoStream({
       client: streamClient,
       api: baseApi,
       channel: ch,
@@ -3460,10 +3466,39 @@ async function createRfc4571TcpServerInternal(options) {
       variant,
       logger
     });
-    await videoStream.start();
-    log(
-      `stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
-    );
+    if (options.alwaysOn?.enabled) {
+      const cvsOpts = {
+        // ContinuousVideoStream owns the lifecycle: it calls createLiveStream
+        // (which returns a started stream) and re-starts it internally on goLive.
+        createLiveStream,
+        logger
+      };
+      if (options.alwaysOn.idleFps !== void 0)
+        cvsOpts.idleFps = options.alwaysOn.idleFps;
+      if (options.alwaysOn.placeholder !== void 0)
+        cvsOpts.placeholder = options.alwaysOn.placeholder;
+      const cvs = new ContinuousVideoStream(cvsOpts);
+      alwaysOnController = new AlwaysOnController({
+        api: baseApi,
+        channel: ch,
+        options: options.alwaysOn,
+        goLive: () => cvs.goLive(),
+        goIdle: () => cvs.goIdle(),
+        logger
+      });
+      await alwaysOnController.start();
+      videoStream = cvs;
+      log(
+        `always-on stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
+      );
+    } else {
+      const live = await createLiveStream();
+      await live.start();
+      videoStream = live;
+      log(
+        `stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
+      );
+    }
   }
   const waitForKeyframe = async () => {
     if (isCompositeStream) {
@@ -3591,6 +3626,12 @@ async function createRfc4571TcpServerInternal(options) {
   try {
     keyframe = await waitForKeyframe();
   } catch (e) {
+    if (alwaysOnController) {
+      try {
+        await alwaysOnController.stop();
+      } catch {
+      }
+    }
     try {
       await videoStream.stop();
     } catch {
@@ -3839,12 +3880,13 @@ async function createRfc4571TcpServerInternal(options) {
     } catch {
     }
     muxer = makeMuxer();
+    const restartable = videoStream;
     try {
-      await videoStream.stop();
+      await restartable.stop();
     } catch {
     }
     try {
-      await videoStream.start();
+      await restartable.start();
     } catch (e) {
       restarting = false;
       close(e).catch(() => {
@@ -3865,6 +3907,12 @@ async function createRfc4571TcpServerInternal(options) {
     cancelIdleTeardown();
     const reasonStr = reason?.message || reason?.toString?.() || reason || "requested";
     muxer.close();
+    if (alwaysOnController) {
+      try {
+        await alwaysOnController.stop();
+      } catch {
+      }
+    }
     try {
       await videoStream.stop();
     } catch {
@@ -9854,7 +9902,9 @@ function buildInitialStatus(config) {
 }
 export {
   ALL_UDP_DISCOVERY_METHODS,
+  ALWAYS_ON_DEFAULTS,
   AesStreamDecryptor,
+  AlwaysOnController,
   AutodiscoveryClient,
   BC_AES_IV,
   BC_CLASS_FILE_DOWNLOAD,
@@ -10011,6 +10061,7 @@ export {
   BcUdpStream,
   CompositeRtspServer,
   CompositeStream,
+  ContinuousVideoStream,
   DEFAULT_SHELTER_CANVAS,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -10024,6 +10075,7 @@ export {
   MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
+  PlaceholderRenderer,
   ReolinkBaichuanApi,
   ReolinkCgiApi,
   ReolinkHttpClient,