@apocaliss92/nodelink-js 0.1.7 → 0.1.8

package/dist/index.d.ts

@@ -980,6 +980,106 @@ export declare type BaichuanLedState = {
     lightState?: string;
 };
 
+/**
+ * BaichuanMjpegServer - MJPEG HTTP server for Baichuan video streams
+ *
+ * Events:
+ * - 'started': Server started
+ * - 'stopped': Server stopped
+ * - 'client-connected': Client connected
+ * - 'client-disconnected': Client disconnected
+ * - 'error': Error occurred
+ */
+export declare class BaichuanMjpegServer extends EventEmitter {
+    private readonly options;
+    private readonly clients;
+    private httpServer;
+    private transformer;
+    private nativeStream;
+    private streamPump;
+    private detectedCodec;
+    private started;
+    private clientIdCounter;
+    constructor(options: BaichuanMjpegServerOptions);
+    /**
+     * Start the MJPEG server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the MJPEG server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle HTTP request
+     */
+    private handleRequest;
+    /**
+     * Handle new MJPEG client
+     */
+    private handleMjpegClient;
+    /**
+     * Start the native video stream and MJPEG transformer
+     */
+    private startStream;
+    /**
+     * Pump native stream and feed to transformer
+     */
+    private pumpStream;
+    /**
+     * Initialize MJPEG transformer once codec is detected
+     */
+    private initTransformer;
+    /**
+     * Broadcast JPEG frame to all connected clients
+     */
+    private broadcastFrame;
+    /**
+     * Stop the stream and transformer
+     */
+    private stopStream;
+    /**
+     * Get current number of connected clients
+     */
+    getClientCount(): number;
+    /**
+     * Get server status
+     */
+    getStatus(): {
+        running: boolean;
+        clients: number;
+        codec: string | null;
+        frames: number;
+    };
+    private log;
+}
+
+export declare interface BaichuanMjpegServerOptions {
+    /** API instance (required) */
+    api: ReolinkBaichuanApi;
+    /** Channel number (required) */
+    channel: number;
+    /** Stream profile (required) */
+    profile: StreamProfile;
+    /** Native-only: TrackMix tele/autotrack variants */
+    variant?: NativeVideoStreamVariant;
+    /** HTTP server port (default: 8080) */
+    port?: number;
+    /** HTTP server host (default: "0.0.0.0") */
+    host?: string;
+    /** URL path for MJPEG stream (default: "/mjpeg") */
+    path?: string;
+    /** JPEG quality (1-31, lower is better, default: 5) */
+    quality?: number;
+    /** Output width (optional) */
+    width?: number;
+    /** Output height (optional) */
+    height?: number;
+    /** Max FPS (optional) */
+    maxFps?: number;
+    /** Logger callback */
+    logger?: (level: "debug" | "info" | "warn" | "error", message: string) => void;
+}
+
 export declare type BaichuanNetInfoPush = {
     netType?: string;
     signal?: number;
@@ -1376,6 +1476,125 @@ export declare interface BaichuanVideoStreamOptions {
     acceptAnyStreamType?: boolean;
 }
 
+/**
+ * BaichuanWebRTCServer - WebRTC server for Baichuan video streams
+ *
+ * Events:
+ * - 'session-created': New session created
+ * - 'session-connected': Session connected (ICE complete)
+ * - 'session-closed': Session closed
+ * - 'intercom-started': Intercom started for session
+ * - 'intercom-stopped': Intercom stopped for session
+ * - 'error': Error occurred
+ */
+export declare class BaichuanWebRTCServer extends EventEmitter {
+    private readonly options;
+    private readonly sessions;
+    private sessionIdCounter;
+    private weriftModule;
+    constructor(options: BaichuanWebRTCServerOptions);
+    /**
+     * Initialize werift module (lazy load to avoid requiring it if not used)
+     */
+    private loadWerift;
+    /**
+     * Create a new WebRTC session
+     * Returns a session ID and SDP offer to send to the browser
+     */
+    createSession(): Promise<{
+        sessionId: string;
+        offer: WebRTCOffer;
+    }>;
+    /**
+     * Handle WebRTC answer from browser and start streaming
+     */
+    handleAnswer(sessionId: string, answer: WebRTCAnswer): Promise<void>;
+    /**
+     * Add ICE candidate from browser
+     */
+    addIceCandidate(sessionId: string, candidate: WebRTCIceCandidate): Promise<void>;
+    /**
+     * Close a WebRTC session
+     */
+    closeSession(sessionId: string): Promise<void>;
+    /**
+     * Get information about all active sessions
+     */
+    getSessions(): WebRTCSessionInfo[];
+    /**
+     * Get information about a specific session
+     */
+    getSession(sessionId: string): WebRTCSessionInfo | null;
+    /**
+     * Close all sessions and stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the number of active sessions
+     */
+    get sessionCount(): number;
+    /**
+     * Wait for ICE gathering to complete
+     */
+    private waitForIceGathering;
+    /**
+     * Start native Baichuan stream and pump frames to WebRTC
+     */
+    private startNativeStream;
+    /**
+     * Pump frames from native stream to WebRTC tracks
+     * H.264 → RTP media track (standard WebRTC)
+     * H.265 → DataChannel with raw Annex-B frames (decoded by WebCodecs in browser)
+     */
+    private pumpFramesToWebRTC;
+    /**
+     * Send H.264 frame via RTP media track
+     */
+    private sendH264Frame;
+    /**
+     * Send H.265 frame via DataChannel
+     * Format: 12-byte header + Annex-B data
+     * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+     */
+    private sendH265Frame;
+    /**
+     * Create RTP packets for H.264 NAL unit
+     * Handles single NAL, STAP-A aggregation, and FU-A fragmentation
+     */
+    private createH264RtpPackets;
+    /**
+     * Start intercom (two-way audio)
+     */
+    private startIntercom;
+    /**
+     * Log helper
+     */
+    private log;
+}
+
+export declare interface BaichuanWebRTCServerOptions {
+    /** API instance (required) */
+    api: ReolinkBaichuanApi;
+    /** Channel number (required) */
+    channel: number;
+    /** Stream profile (required) */
+    profile: StreamProfile;
+    /** Native-only: TrackMix tele/autotrack variants */
+    variant?: NativeVideoStreamVariant;
+    /** Enable two-way audio intercom (default: false) */
+    enableIntercom?: boolean;
+    /** STUN servers for ICE (default: Google STUN) */
+    stunServers?: string[];
+    /** TURN servers for NAT traversal (optional) */
+    turnServers?: Array<{
+        urls: string;
+        username?: string;
+        credential?: string;
+    }>;
+    /** Logger callback */
+    logger?: (level: "debug" | "info" | "warn" | "error", message: string) => void;
+}
+
 export declare type BaichuanWifi = {
     protocol?: number;
     mode?: string;
@@ -2791,6 +3010,25 @@ export declare function createLogger(options?: {
     tag?: string;
 }): Logger_2;
 
+/**
+ * Create an MJPEG HTTP response handler
+ *
+ * Usage:
+ * ```ts
+ * const transformer = new MjpegTransformer({ codec: "h264" });
+ * transformer.start();
+ *
+ * // In your stream handler:
+ * stream.on("accessUnit", (au) => transformer.push(au.data, au.timestamp));
+ *
+ * // HTTP handler:
+ * app.get("/mjpeg", (req, res) => {
+ *   serveMjpeg(res, transformer);
+ * });
+ * ```
+ */
+export declare function createMjpegBoundary(): string;
+
 /**
  * Stream frame data for rebroadcast.
  * Similar to Wyze forkAndStream() implementation.
@@ -2923,6 +3161,22 @@ export declare type DebugOptions = {
     };
 };
 
+/**
+ * Determine if H.265 should be transcoded to H.264 based on client capabilities.
+ *
+ * Decision logic:
+ * - iOS devices (Safari): Need transcoding (no native H.265 in <video> without HLS)
+ * - macOS Safari: Supports H.265 natively
+ * - Chrome/Edge: Limited H.265 support, safer to transcode
+ * - Firefox: No H.265 support, needs transcoding
+ * - Android: Variable support, transcode for safety
+ *
+ * @param headers HTTP request headers
+ * @param forceMode Optional override: "passthrough" or "transcode-h264"
+ * @returns Decision with mode, reason, and client info
+ */
+export declare function decideVideoclipTranscodeMode(headers: Record<string, string | string[] | undefined>, forceMode?: VideoclipTranscodeMode): VideoclipModeDecision;
+
 export declare function decodeHeader(buf: AnyBuffer): {
     header: BaichuanHeader;
     headerLen: number;
@@ -3350,6 +3604,8 @@ declare interface FloodlightTaskState {
     detectType?: string;
 }
 
+export declare function formatMjpegFrame(frame: Buffer, boundary: string): Buffer;
+
 /**
  * FTP task configuration.
  */
@@ -3378,6 +3634,8 @@ export declare function getGlobalLogger(): Logger_2;
  */
 export declare function getH265NalType(nalPayload: Buffer): number | null;
 
+export declare function getMjpegContentType(boundary: string): string;
+
 /**
  * Result of getRecordingVideo() - a fully muxed MP4 with stats.
  */
@@ -3416,6 +3674,11 @@ export declare interface GetRecordingVideoStats {
     hasAudio: boolean;
 }
 
+/**
+ * Extract client info from HTTP request headers.
+ */
+export declare function getVideoclipClientInfo(headers: Record<string, string | string[] | undefined>): VideoclipClientInfo;
+
 /**
  * Parameters for getVideoclips() recording search.
  */
@@ -3651,6 +3914,9 @@ declare interface Logger_2 {
     child?(tag: string): Logger_2;
 }
 
+/** Logger callback type for MjpegTransformer */
+export declare type LoggerCallback = (level: "debug" | "info" | "warn" | "error", message: string) => void;
+
 declare type LoggerLike = Partial<Logger_2> | Console;
 
 export declare type LoginResponseValue = {
@@ -3696,6 +3962,74 @@ export declare interface MediaStream {
     };
 }
 
+export declare interface MjpegFrame {
+    /** JPEG data */
+    data: Buffer;
+    /** Timestamp in microseconds */
+    timestamp: number;
+}
+
+/**
+ * MjpegTransformer - Transforms H.264/H.265 access units to JPEG frames
+ *
+ * Events:
+ * - 'frame': Emitted when a JPEG frame is ready (MjpegFrame)
+ * - 'error': Emitted on error
+ * - 'close': Emitted when transformer is closed
+ */
+export declare class MjpegTransformer extends EventEmitter {
+    private readonly options;
+    private ffmpeg;
+    private started;
+    private closed;
+    private jpegBuffer;
+    private frameCount;
+    private lastTimestamp;
+    constructor(options: MjpegTransformerOptions);
+    /**
+     * Start the transformer (spawns FFmpeg process)
+     */
+    start(): void;
+    /**
+     * Push an H.264/H.265 access unit (Annex-B format with start codes)
+     */
+    push(accessUnit: Buffer, timestamp?: number): void;
+    /**
+     * Handle JPEG data from FFmpeg stdout
+     * FFmpeg outputs complete JPEG images, each starting with SOI (0xFFD8)
+     * and ending with EOI (0xFFD9)
+     */
+    private handleJpegData;
+    /**
+     * Stop the transformer
+     */
+    stop(): Promise<void>;
+    /**
+     * Get frame count
+     */
+    getFrameCount(): number;
+    /**
+     * Check if running
+     */
+    isRunning(): boolean;
+    private log;
+}
+
+export declare interface MjpegTransformerOptions {
+    /** Video codec (required) */
+    codec: "h264" | "h265";
+    /** JPEG quality (1-31, lower is better, default: 5) */
+    quality?: number | undefined;
+    /** Output width (optional, maintains aspect ratio if only one dimension set) */
+    width?: number | undefined;
+    /** Output height (optional, maintains aspect ratio if only one dimension set) */
+    height?: number | undefined;
+    /** Frame rate limit (optional, e.g., 10 for max 10 fps) */
+    maxFps?: number | undefined;
+    /** Logger callback */
+    logger?: LoggerCallback | undefined;
+}
+
 /**
  * Motion alarm configuration (getMotionAlarm response).
  * cmdId=46 (GetMdAlarm)
@@ -6024,6 +6358,13 @@ export declare class ReolinkBaichuanApi {
          * Recommended: pass a unique identifier per logical device/player instance.
          */
         deviceId?: string;
+        /**
+         * Transcode H.265/HEVC to H.264/AVC for compatibility with clients that don't support H.265.
+         * When true and the source is H.265, ffmpeg will transcode to H.264 using libx264.
+         * This increases CPU usage but ensures playback on iOS Safari, older browsers, etc.
+         * Default: false (passthrough/copy).
+         */
+        transcodeH265ToH264?: boolean;
     }): Promise<{
         mp4: Readable;
         stop: () => Promise<void>;
@@ -7547,6 +7888,28 @@ export declare interface TwoWayAudioConfig {
     mode?: "mixAudioStream" | string;
 }
 
+/**
+ * Client information extracted from HTTP request headers.
+ * Used to determine optimal video delivery format.
+ */
+export declare type VideoclipClientInfo = {
+    userAgent: string | undefined;
+    accept: string | undefined;
+    range: string | undefined;
+    secChUa: string | undefined;
+    secChUaMobile: string | undefined;
+    secChUaPlatform: string | undefined;
+};
+
+/**
+ * Result of videoclip mode decision.
+ */
+export declare type VideoclipModeDecision = {
+    mode: VideoclipTranscodeMode;
+    reason: string;
+    clientInfo: VideoclipClientInfo;
+};
+
 export declare type VideoclipThumbnailResult = {
     /** Raw I-frame data (H.264 or H.265) */
     frame: Buffer;
@@ -7560,6 +7923,13 @@ export declare type VideoclipThumbnailResult = {
     streamInfo: PlaybackSnapshotStreamInfo;
 };
 
+/**
+ * Videoclip delivery mode.
+ * - `passthrough`: Copy codec as-is (H.264 or H.265)
+ * - `transcode-h264`: Transcode H.265 to H.264 for compatibility
+ */
+export declare type VideoclipTranscodeMode = "passthrough" | "transcode-h264";
+
 export declare type VideoCodec = "H.264" | "H.265" | "MJPEG" | "MPEG4" | string;
 
 /**
@@ -7684,6 +8054,34 @@ export declare type WakeUpOptions = {
     reconnect?: boolean;
 };
 
+export declare interface WebRTCAnswer {
+    sdp: string;
+    type: "answer";
+}
+
+export declare interface WebRTCIceCandidate {
+    candidate: string;
+    sdpMid?: string;
+    sdpMLineIndex?: number;
+}
+
+export declare interface WebRTCOffer {
+    sdp: string;
+    type: "offer";
+}
+
+export declare interface WebRTCSessionInfo {
+    id: string;
+    state: "connecting" | "connected" | "disconnected" | "failed";
+    createdAt: Date;
+    stats: {
+        videoFrames: number;
+        audioFrames: number;
+        bytesSent: number;
+        intercomBytesSent: number;
+    };
+}
+
 /**
  * White LED state configuration.
  */