@apocaliss92/nodelink-js 0.1.7 → 0.1.8

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   normalizeUid,
   parseSupportXml,
   setGlobalLogger
-} from "./chunk-JMT75JNG.js";
+} from "./chunk-AFUYHWWQ.js";
 import {
   AesStreamDecryptor,
   BC_AES_IV,
@@ -495,6 +495,79 @@ var AutodiscoveryClient = class {
   }
 };
 
+// src/reolink/baichuan/types.ts
+function getVideoclipClientInfo(headers) {
+  const getHeader = (key) => {
+    const val = headers[key] ?? headers[key.toLowerCase()] ?? headers[key.toUpperCase()];
+    return Array.isArray(val) ? val[0] : val;
+  };
+  return {
+    userAgent: getHeader("user-agent") ?? getHeader("User-Agent"),
+    accept: getHeader("accept") ?? getHeader("Accept"),
+    range: getHeader("range") ?? getHeader("Range"),
+    secChUa: getHeader("sec-ch-ua") ?? getHeader("Sec-CH-UA"),
+    secChUaMobile: getHeader("sec-ch-ua-mobile") ?? getHeader("Sec-CH-UA-Mobile"),
+    secChUaPlatform: getHeader("sec-ch-ua-platform") ?? getHeader("Sec-CH-UA-Platform")
+  };
+}
+function decideVideoclipTranscodeMode(headers, forceMode) {
+  const clientInfo = getVideoclipClientInfo(headers);
+  if (forceMode) {
+    return {
+      mode: forceMode,
+      reason: `forced: ${forceMode}`,
+      clientInfo
+    };
+  }
+  const ua = (clientInfo.userAgent ?? "").toLowerCase();
+  const platform = (clientInfo.secChUaPlatform ?? "").toLowerCase().replace(/"/g, "");
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  if (isIos) {
+    return {
+      mode: "transcode-h264",
+      reason: "iOS device detected - no native H.265 support in <video>",
+      clientInfo
+    };
+  }
+  const isFirefox = ua.includes("firefox");
+  if (isFirefox) {
+    return {
+      mode: "transcode-h264",
+      reason: "Firefox detected - no H.265 support",
+      clientInfo
+    };
+  }
+  const isAndroid = ua.includes("android") || platform === "android";
+  if (isAndroid) {
+    return {
+      mode: "transcode-h264",
+      reason: "Android device detected - variable H.265 support",
+      clientInfo
+    };
+  }
+  const isChromium = ua.includes("chrome") || ua.includes("edg");
+  const isMac = ua.includes("mac os") || platform === "macos";
+  if (isChromium && !isMac) {
+    return {
+      mode: "transcode-h264",
+      reason: "Chrome/Edge on non-Mac detected - limited H.265 support",
+      clientInfo
+    };
+  }
+  if (isMac) {
+    return {
+      mode: "passthrough",
+      reason: "macOS detected - native H.265 hardware decoding available",
+      clientInfo
+    };
+  }
+  return {
+    mode: "transcode-h264",
+    reason: "Unknown client - transcoding for compatibility",
+    clientInfo
+  };
+}
+
 // src/reolink/baichuan/endpoints-server.ts
 import http from "http";
 import { spawn } from "child_process";
@@ -4308,11 +4381,1114 @@ var BaichuanHttpStreamServer = class extends EventEmitter2 {
   }
 };
 
-// src/multifocal/compositeRtspServer.ts
+// src/baichuan/stream/BaichuanMjpegServer.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import * as http5 from "http";
+
+// src/baichuan/stream/MjpegTransformer.ts
 import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn6 } from "child_process";
+var JPEG_SOI = Buffer.from([255, 216]);
+var JPEG_EOI = Buffer.from([255, 217]);
+var MjpegTransformer = class extends EventEmitter3 {
+  options;
+  ffmpeg = null;
+  started = false;
+  closed = false;
+  jpegBuffer = Buffer.alloc(0);
+  frameCount = 0;
+  lastTimestamp = 0;
+  constructor(options) {
+    super();
+    this.options = {
+      codec: options.codec,
+      quality: options.quality ?? 5,
+      width: options.width,
+      height: options.height,
+      maxFps: options.maxFps,
+      logger: options.logger
+    };
+  }
+  /**
+   * Start the transformer (spawns FFmpeg process)
+   */
+  start() {
+    if (this.started || this.closed) return;
+    this.started = true;
+    const { codec, quality, width, height, maxFps } = this.options;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      // Input: raw video from stdin
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    const filters = [];
+    if (width || height) {
+      const w = width ?? -1;
+      const h = height ?? -1;
+      filters.push(`scale=${w}:${h}`);
+    }
+    if (maxFps) {
+      filters.push(`fps=${maxFps}`);
+    }
+    if (filters.length > 0) {
+      args.push("-vf", filters.join(","));
+    }
+    args.push(
+      "-c:v",
+      "mjpeg",
+      "-q:v",
+      String(quality),
+      "-f",
+      "mjpeg",
+      "pipe:1"
+    );
+    this.log("debug", `Starting FFmpeg with args: ${args.join(" ")}`);
+    this.ffmpeg = spawn6("ffmpeg", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpeg.stdout.on("data", (data) => {
+      this.handleJpegData(data);
+    });
+    this.ffmpeg.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        this.log("debug", `FFmpeg: ${msg}`);
+      }
+    });
+    this.ffmpeg.on("close", (code) => {
+      this.log("debug", `FFmpeg closed with code ${code}`);
+      this.ffmpeg = null;
+      if (!this.closed) {
+        this.emit("close", code);
+      }
+    });
+    this.ffmpeg.on("error", (err) => {
+      this.log("error", `FFmpeg error: ${err.message}`);
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Push an H.264/H.265 access unit (Annex-B format with start codes)
+   */
+  push(accessUnit, timestamp) {
+    if (!this.started || this.closed || !this.ffmpeg) {
+      return;
+    }
+    this.lastTimestamp = timestamp ?? Date.now() * 1e3;
+    try {
+      this.ffmpeg.stdin.write(accessUnit);
+    } catch (err) {
+      this.log("error", `Failed to write to FFmpeg: ${err}`);
+    }
+  }
+  /**
+   * Handle JPEG data from FFmpeg stdout
+   * FFmpeg outputs complete JPEG images, each starting with SOI (0xFFD8)
+   * and ending with EOI (0xFFD9)
+   */
+  handleJpegData(data) {
+    this.jpegBuffer = Buffer.concat([this.jpegBuffer, data]);
+    while (true) {
+      const soiIndex = this.jpegBuffer.indexOf(JPEG_SOI);
+      if (soiIndex < 0) {
+        this.jpegBuffer = Buffer.alloc(0);
+        break;
+      }
+      if (soiIndex > 0) {
+        this.jpegBuffer = this.jpegBuffer.subarray(soiIndex);
+      }
+      const eoiIndex = this.jpegBuffer.indexOf(JPEG_EOI, 2);
+      if (eoiIndex < 0) {
+        break;
+      }
+      const frameEnd = eoiIndex + 2;
+      const jpegFrame = this.jpegBuffer.subarray(0, frameEnd);
+      this.jpegBuffer = this.jpegBuffer.subarray(frameEnd);
+      this.frameCount++;
+      const frame = {
+        data: jpegFrame,
+        timestamp: this.lastTimestamp
+      };
+      this.emit("frame", frame);
+    }
+  }
+  /**
+   * Stop the transformer
+   */
+  async stop() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ffmpeg) {
+      try {
+        this.ffmpeg.stdin.end();
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const ff = this.ffmpeg;
+        if (!ff) {
+          resolve();
+          return;
+        }
+        const timeout = setTimeout(() => {
+          ff.kill("SIGKILL");
+          resolve();
+        }, 1e3);
+        ff.once("close", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        try {
+          ff.kill("SIGTERM");
+        } catch {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      this.ffmpeg = null;
+    }
+    this.emit("close", 0);
+  }
+  /**
+   * Get frame count
+   */
+  getFrameCount() {
+    return this.frameCount;
+  }
+  /**
+   * Check if running
+   */
+  isRunning() {
+    return this.started && !this.closed && this.ffmpeg !== null;
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[MjpegTransformer] ${message}`);
+  }
+};
+function createMjpegBoundary() {
+  return `mjpegboundary${Date.now()}`;
+}
+function getMjpegContentType(boundary) {
+  return `multipart/x-mixed-replace; boundary=${boundary}`;
+}
+function formatMjpegFrame(frame, boundary) {
+  const header = Buffer.from(
+    `--${boundary}\r
+Content-Type: image/jpeg\r
+Content-Length: ${frame.length}\r
+\r
+`
+  );
+  return Buffer.concat([header, frame, Buffer.from("\r\n")]);
+}
+
+// src/baichuan/stream/BaichuanMjpegServer.ts
+var BaichuanMjpegServer = class extends EventEmitter4 {
+  options;
+  clients = /* @__PURE__ */ new Map();
+  httpServer = null;
+  transformer = null;
+  nativeStream = null;
+  streamPump = null;
+  detectedCodec = null;
+  started = false;
+  clientIdCounter = 0;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Start the MJPEG server
+   */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    const port = this.options.port ?? 8080;
+    const host = this.options.host ?? "0.0.0.0";
+    const path = this.options.path ?? "/mjpeg";
+    this.httpServer = http5.createServer((req, res) => {
+      this.handleRequest(req, res, path);
+    });
+    return new Promise((resolve, reject) => {
+      this.httpServer.on("error", (err) => {
+        this.log("error", `HTTP server error: ${err.message}`);
+        reject(err);
+      });
+      this.httpServer.listen(port, host, () => {
+        this.log(
+          "info",
+          `MJPEG server started on http://${host}:${port}${path}`
+        );
+        this.emit("started", { host, port, path });
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the MJPEG server
+   */
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    for (const [id, client] of this.clients) {
+      try {
+        client.response.end();
+      } catch {
+      }
+      this.clients.delete(id);
+    }
+    await this.stopStream();
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    this.log("info", "MJPEG server stopped");
+    this.emit("stopped");
+  }
+  /**
+   * Handle HTTP request
+   */
+  handleRequest(req, res, expectedPath) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname !== expectedPath) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    if (req.method !== "GET") {
+      res.statusCode = 405;
+      res.end("Method Not Allowed");
+      return;
+    }
+    this.handleMjpegClient(req, res);
+  }
+  /**
+   * Handle new MJPEG client
+   */
+  handleMjpegClient(req, res) {
+    const clientId = `client-${++this.clientIdCounter}`;
+    const boundary = createMjpegBoundary();
+    const client = {
+      id: clientId,
+      response: res,
+      boundary,
+      connectedAt: Date.now()
+    };
+    this.clients.set(clientId, client);
+    this.log(
+      "info",
+      `MJPEG client connected: ${clientId} (total: ${this.clients.size})`
+    );
+    this.emit("client-connected", { id: clientId, total: this.clients.size });
+    res.writeHead(200, {
+      "Content-Type": getMjpegContentType(boundary),
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      Pragma: "no-cache",
+      Expires: "0",
+      Connection: "close"
+    });
+    const cleanup = () => {
+      this.clients.delete(clientId);
+      this.log(
+        "info",
+        `MJPEG client disconnected: ${clientId} (remaining: ${this.clients.size})`
+      );
+      this.emit("client-disconnected", {
+        id: clientId,
+        total: this.clients.size
+      });
+      if (this.clients.size === 0) {
+        this.stopStream();
+      }
+    };
+    req.on("close", cleanup);
+    res.on("close", cleanup);
+    res.on("error", cleanup);
+    if (!this.transformer) {
+      this.startStream();
+    }
+  }
+  /**
+   * Start the native video stream and MJPEG transformer
+   */
+  async startStream() {
+    if (this.transformer) return;
+    this.log("info", "Starting native video stream...");
+    const { api, channel, profile, variant, quality, width, height, maxFps } = this.options;
+    try {
+      this.nativeStream = createNativeStream(
+        api,
+        channel,
+        profile,
+        variant ? { variant } : void 0
+      );
+      this.streamPump = this.pumpStream();
+    } catch (err) {
+      this.log("error", `Failed to start stream: ${err}`);
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Pump native stream and feed to transformer
+   */
+  async pumpStream() {
+    if (!this.nativeStream) return;
+    let frameBuffer = [];
+    let waitingForKeyframe = true;
+    try {
+      for await (const frame of this.nativeStream) {
+        if (!this.started || this.clients.size === 0) break;
+        const { type, data, microseconds, videoType } = frame;
+        if (type !== "Iframe" && type !== "Pframe") continue;
+        if (!data || data.length === 0) continue;
+        let annexB;
+        if (videoType === "H265") {
+          annexB = convertToAnnexB2(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h265";
+            this.initTransformer();
+          }
+        } else {
+          annexB = convertToAnnexB(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h264";
+            this.initTransformer();
+          }
+        }
+        if (waitingForKeyframe) {
+          if (type === "Iframe") {
+            waitingForKeyframe = false;
+          } else {
+            continue;
+          }
+        }
+        if (this.transformer) {
+          this.transformer.push(annexB, microseconds);
+        }
+      }
+    } catch (err) {
+      if (this.started) {
+        this.log("error", `Stream error: ${err}`);
+        this.emit("error", err);
+      }
+    }
+  }
+  /**
+   * Initialize MJPEG transformer once codec is detected
+   */
+  initTransformer() {
+    if (this.transformer || !this.detectedCodec) return;
+    const { quality, width, height, maxFps } = this.options;
+    this.transformer = new MjpegTransformer({
+      codec: this.detectedCodec,
+      quality,
+      width,
+      height,
+      maxFps,
+      logger: this.options.logger
+    });
+    this.transformer.on("frame", (frame) => {
+      this.broadcastFrame(frame);
+    });
+    this.transformer.on("error", (err) => {
+      this.log("error", `Transformer error: ${err}`);
+    });
+    this.transformer.on("close", () => {
+      this.log("debug", "Transformer closed");
+    });
+    this.transformer.start();
+    this.log(
+      "info",
+      `MJPEG transformer started (codec: ${this.detectedCodec})`
+    );
+  }
+  /**
+   * Broadcast JPEG frame to all connected clients
+   */
+  broadcastFrame(frame) {
+    for (const client of this.clients.values()) {
+      try {
+        const mjpegData = formatMjpegFrame(frame.data, client.boundary);
+        client.response.write(mjpegData);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Stop the stream and transformer
+   */
+  async stopStream() {
+    if (this.transformer) {
+      await this.transformer.stop();
+      this.transformer = null;
+    }
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.streamPump) {
+      try {
+        await this.streamPump;
+      } catch {
+      }
+      this.streamPump = null;
+    }
+    this.detectedCodec = null;
+    this.log("debug", "Stream stopped");
+  }
+  /**
+   * Get current number of connected clients
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Get server status
+   */
+  getStatus() {
+    return {
+      running: this.started,
+      clients: this.clients.size,
+      codec: this.detectedCodec,
+      frames: this.transformer?.getFrameCount() ?? 0
+    };
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[BaichuanMjpegServer] ${message}`);
+  }
+};
+
+// src/baichuan/stream/BaichuanWebRTCServer.ts
+import { EventEmitter as EventEmitter5 } from "events";
+function parseAnnexBNalUnits(annexB) {
+  const nalUnits = [];
+  let offset = 0;
+  while (offset < annexB.length) {
+    let startCodeLen = 0;
+    if (offset + 4 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 0 && annexB[offset + 3] === 1) {
+      startCodeLen = 4;
+    } else if (offset + 3 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 1) {
+      startCodeLen = 3;
+    } else {
+      offset++;
+      continue;
+    }
+    const naluStart = offset + startCodeLen;
+    let naluEnd = annexB.length;
+    for (let i = naluStart; i < annexB.length - 2; i++) {
+      if (annexB[i] === 0 && annexB[i + 1] === 0 && (annexB[i + 2] === 1 || i + 3 < annexB.length && annexB[i + 2] === 0 && annexB[i + 3] === 1)) {
+        naluEnd = i;
+        break;
+      }
+    }
+    if (naluEnd > naluStart) {
+      nalUnits.push(annexB.subarray(naluStart, naluEnd));
+    }
+    offset = naluEnd;
+  }
+  return nalUnits;
+}
+function getH264NalType(nalUnit) {
+  return nalUnit[0] & 31;
+}
+function getH265NalType2(nalUnit) {
+  return nalUnit[0] >> 1 & 63;
+}
+var BaichuanWebRTCServer = class extends EventEmitter5 {
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  sessionIdCounter = 0;
+  weriftModule = null;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Initialize werift module (lazy load to avoid requiring it if not used)
+   */
+  async loadWerift() {
+    if (this.weriftModule) return this.weriftModule;
+    try {
+      this.weriftModule = await import("werift");
+      return this.weriftModule;
+    } catch (err) {
+      throw new Error(
+        `Failed to load werift module. Make sure it's installed: npm install werift
+Error: ${err}`
+      );
+    }
+  }
+  /**
+   * Create a new WebRTC session
+   * Returns a session ID and SDP offer to send to the browser
+   */
+  async createSession() {
+    const werift = await this.loadWerift();
+    const { RTCPeerConnection, MediaStreamTrack, RTCRtpCodecParameters } = werift;
+    const sessionId = `webrtc-${++this.sessionIdCounter}-${Date.now()}`;
+    this.log("info", `Creating WebRTC session ${sessionId}`);
+    const iceServers = [];
+    const stunServers = this.options.stunServers ?? [
+      "stun:stun.l.google.com:19302"
+    ];
+    for (const urls of stunServers) {
+      iceServers.push({ urls });
+    }
+    if (this.options.turnServers) {
+      iceServers.push(...this.options.turnServers);
+    }
+    const peerConnection = new RTCPeerConnection({
+      iceServers,
+      codecs: {
+        video: [
+          new RTCRtpCodecParameters({
+            mimeType: "video/H264",
+            clockRate: 9e4,
+            rtcpFeedback: [
+              { type: "nack" },
+              { type: "nack", parameter: "pli" },
+              { type: "goog-remb" }
+            ],
+            parameters: "packetization-mode=1;profile-level-id=42e01f;level-asymmetry-allowed=1"
+          })
+        ],
+        audio: [
+          new RTCRtpCodecParameters({
+            mimeType: "audio/opus",
+            clockRate: 48e3,
+            channels: 2
+          })
+        ]
+      }
+    });
+    const session = {
+      id: sessionId,
+      peerConnection,
+      videoTrack: null,
+      audioTrack: null,
+      videoDataChannel: null,
+      nativeStream: null,
+      intercom: null,
+      dataChannel: null,
+      videoCodec: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      state: "connecting",
+      stats: {
+        videoFrames: 0,
+        audioFrames: 0,
+        bytesSent: 0,
+        intercomBytesSent: 0
+      }
+    };
+    this.sessions.set(sessionId, session);
+    const videoTrack = new MediaStreamTrack({ kind: "video" });
+    peerConnection.addTrack(videoTrack);
+    session.videoTrack = videoTrack;
+    const audioTrack = new MediaStreamTrack({ kind: "audio" });
+    peerConnection.addTrack(audioTrack);
+    session.audioTrack = audioTrack;
+    const videoDataChannel = peerConnection.createDataChannel("video", {
+      ordered: true,
+      maxRetransmits: 0
+      // Unreliable for real-time video
+    });
+    session.videoDataChannel = videoDataChannel;
+    videoDataChannel.onopen = () => {
+      this.log("info", `Video data channel opened for session ${sessionId}`);
+    };
+    if (this.options.enableIntercom) {
+      const dataChannel = peerConnection.createDataChannel("intercom", {
+        ordered: true
+      });
+      session.dataChannel = dataChannel;
+      dataChannel.onopen = () => {
+        this.log(
+          "info",
+          `Intercom data channel opened for session ${sessionId}`
+        );
+        this.emit("intercom-started", { sessionId });
+      };
+      dataChannel.onmessage = async (event) => {
+        if (session.intercom && event.data instanceof ArrayBuffer) {
+          try {
+            const audioData = Buffer.from(event.data);
+            await session.intercom.sendAudio(audioData);
+            session.stats.intercomBytesSent += audioData.length;
+          } catch (err) {
+            this.log("error", `Failed to send intercom audio: ${err}`);
+          }
+        }
+      };
+      dataChannel.onclose = () => {
+        this.log(
+          "info",
+          `Intercom data channel closed for session ${sessionId}`
+        );
+        this.emit("intercom-stopped", { sessionId });
+      };
+    }
+    peerConnection.iceConnectionStateChange.subscribe((state) => {
+      this.log("debug", `ICE connection state for ${sessionId}: ${state}`);
+      if (state === "connected") {
+        session.state = "connected";
+        this.emit("session-connected", { sessionId });
+      } else if (state === "disconnected" || state === "failed") {
+        session.state = state;
+        this.closeSession(sessionId).catch((err) => {
+          this.log("error", `Error closing session on ICE ${state}: ${err}`);
+        });
+      }
+    });
+    peerConnection.connectionStateChange.subscribe((state) => {
+      this.log("debug", `Connection state for ${sessionId}: ${state}`);
+      if (state === "closed" || state === "failed") {
+        this.closeSession(sessionId).catch((err) => {
+          this.log(
+            "error",
+            `Error closing session on connection ${state}: ${err}`
+          );
+        });
+      }
+    });
+    const offer = await peerConnection.createOffer();
+    await peerConnection.setLocalDescription(offer);
+    await this.waitForIceGathering(peerConnection, 3e3);
+    const localDescription = peerConnection.localDescription;
+    if (!localDescription) {
+      throw new Error("Failed to create local description");
+    }
+    this.emit("session-created", { sessionId });
+    return {
+      sessionId,
+      offer: {
+        sdp: localDescription.sdp,
+        type: "offer"
+      }
+    };
+  }
+  /**
+   * Handle WebRTC answer from browser and start streaming
+   */
+  async handleAnswer(sessionId, answer) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCSessionDescription } = werift;
+    this.log("info", `Handling WebRTC answer for session ${sessionId}`);
+    await session.peerConnection.setRemoteDescription(
+      new RTCSessionDescription(answer.sdp, answer.type)
+    );
+    await this.startNativeStream(session);
+    if (this.options.enableIntercom && session.dataChannel) {
+      await this.startIntercom(session);
+    }
+  }
+  /**
+   * Add ICE candidate from browser
+   */
+  async addIceCandidate(sessionId, candidate) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCIceCandidate } = werift;
+    await session.peerConnection.addIceCandidate(
+      new RTCIceCandidate(candidate.candidate, candidate.sdpMid ?? "0")
+    );
+  }
+  /**
+   * Close a WebRTC session
+   */
+  async closeSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.log("info", `Closing WebRTC session ${sessionId}`);
+    session.state = "disconnected";
+    if (session.intercom) {
+      try {
+        await session.intercom.stop();
+      } catch (err) {
+        this.log("debug", `Error stopping intercom: ${err}`);
+      }
+      session.intercom = null;
+    }
+    if (session.dataChannel) {
+      try {
+        session.dataChannel.close();
+      } catch (err) {
+        this.log("debug", `Error closing data channel: ${err}`);
+      }
+      session.dataChannel = null;
+    }
+    if (session.cleanup) {
+      session.cleanup();
+    }
+    try {
+      await session.peerConnection.close();
+    } catch (err) {
+      this.log("debug", `Error closing peer connection: ${err}`);
+    }
+    this.sessions.delete(sessionId);
+    this.emit("session-closed", { sessionId });
+    this.log(
+      "info",
+      `WebRTC session ${sessionId} closed (active sessions: ${this.sessions.size})`
+    );
+  }
+  /**
+   * Get information about all active sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      state: s.state,
+      createdAt: s.createdAt,
+      stats: { ...s.stats }
+    }));
+  }
+  /**
+   * Get information about a specific session
+   */
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    return {
+      id: session.id,
+      state: session.state,
+      createdAt: session.createdAt,
+      stats: { ...session.stats }
+    };
+  }
+  /**
+   * Close all sessions and stop the server
+   */
+  async stop() {
+    this.log("info", "Stopping WebRTC server");
+    const sessionIds = Array.from(this.sessions.keys());
+    await Promise.all(sessionIds.map((id) => this.closeSession(id)));
+    this.log("info", "WebRTC server stopped");
+  }
+  /**
+   * Get the number of active sessions
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Wait for ICE gathering to complete
+   */
+  async waitForIceGathering(pc, timeoutMs) {
+    if (pc.iceGatheringState === "complete") return;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+      pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Start native Baichuan stream and pump frames to WebRTC
+   */
+  async startNativeStream(session) {
+    this.log(
+      "info",
+      `Starting native stream for session ${session.id} (channel=${this.options.channel}, profile=${this.options.profile})`
+    );
+    session.nativeStream = createNativeStream(
+      this.options.api,
+      this.options.channel,
+      this.options.profile,
+      this.options.variant !== void 0 ? { variant: this.options.variant } : void 0
+    );
+    this.pumpFramesToWebRTC(session).catch((err) => {
+      this.log("error", `Frame pump error for session ${session.id}: ${err}`);
+      this.closeSession(session.id).catch(() => {
+      });
+    });
+  }
+  /**
+   * 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)
+   */
+  async pumpFramesToWebRTC(session) {
+    if (!session.nativeStream) {
+      this.log("warn", `No native stream for session ${session.id}`);
+      return;
+    }
+    this.log("info", `Starting frame pump for session ${session.id}`);
+    const werift = await this.loadWerift();
+    const { RtpPacket, RtpHeader } = werift;
+    let sequenceNumber = Math.floor(Math.random() * 65535);
+    let timestamp = Math.floor(Math.random() * 4294967295);
+    const videoClockRate = 9e4;
+    let lastTimeMicros = 0;
+    let lastLogTime = Date.now();
+    let packetsSentSinceLastLog = 0;
+    let frameNumber = 0;
+    try {
+      this.log("info", `Entering frame loop for session ${session.id}`);
+      for await (const frame of session.nativeStream) {
+        if (session.state === "disconnected" || session.state === "failed") {
+          this.log(
+            "debug",
+            `Session ${session.id} state is ${session.state}, breaking frame loop`
+          );
+          break;
+        }
+        if (frame.audio) {
+          session.stats.audioFrames++;
+        } else {
+          if (frame.data) {
+            if (!session.videoCodec && frame.videoType) {
+              session.videoCodec = frame.videoType;
+              this.log("info", `Detected video codec: ${session.videoCodec}`);
+              if (session.videoDataChannel && session.videoDataChannel.readyState === "open") {
+                const codecInfo = JSON.stringify({
+                  type: "codec",
+                  codec: session.videoCodec,
+                  width: frame.width || 0,
+                  height: frame.height || 0
+                });
+                session.videoDataChannel.send(codecInfo);
+              }
+            }
+            if (frame.microseconds && lastTimeMicros > 0) {
+              const deltaMicros = frame.microseconds - lastTimeMicros;
+              const deltaTicks = Math.floor(
+                deltaMicros / 1e6 * videoClockRate
+              );
+              timestamp = timestamp + deltaTicks >>> 0;
+            } else {
+              timestamp = timestamp + 3e3 >>> 0;
+            }
+            lastTimeMicros = frame.microseconds || 0;
+            if (session.videoCodec === "H264") {
+              await this.sendH264Frame(
+                session,
+                werift,
+                frame.data,
+                sequenceNumber,
+                timestamp
+              );
+              sequenceNumber = sequenceNumber + Math.ceil(frame.data.length / 1200) & 65535;
+              packetsSentSinceLastLog++;
+            } else if (session.videoCodec === "H265") {
+              await this.sendH265Frame(session, frame, frameNumber);
+              packetsSentSinceLastLog++;
+            }
+            frameNumber++;
+            session.stats.videoFrames++;
+            session.stats.bytesSent += frame.data.length;
+            const now = Date.now();
+            if (now - lastLogTime >= 5e3) {
+              this.log(
+                "debug",
+                `WebRTC session ${session.id} [${session.videoCodec}]: sent ${session.stats.videoFrames} frames, ${packetsSentSinceLastLog} packets, ${Math.round(session.stats.bytesSent / 1024)} KB`
+              );
+              lastLogTime = now;
+              packetsSentSinceLastLog = 0;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      this.log(
+        "error",
+        `Error pumping frames for session ${session.id}: ${err}`
+      );
+    }
+    this.log("info", `Native stream ended for session ${session.id}`);
+  }
+  /**
+   * Send H.264 frame via RTP media track
+   */
+  async sendH264Frame(session, werift, frameData, sequenceNumber, timestamp) {
+    const nalUnits = parseAnnexBNalUnits(frameData);
+    for (let i = 0; i < nalUnits.length; i++) {
+      const nalUnit = nalUnits[i];
+      if (nalUnit.length === 0) continue;
+      const isLastNalu = i === nalUnits.length - 1;
+      const nalType = getH264NalType(nalUnit);
+      if (nalType === 9) continue;
+      const rtpPackets = this.createH264RtpPackets(
+        werift,
+        nalUnit,
+        sequenceNumber,
+        timestamp,
+        isLastNalu
+      );
+      for (const rtpPacket of rtpPackets) {
+        session.videoTrack.writeRtp(rtpPacket);
+        sequenceNumber = sequenceNumber + 1 & 65535;
+      }
+    }
+  }
+  /**
+   * Send H.265 frame via DataChannel
+   * Format: 12-byte header + Annex-B data
+   * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+   */
+  async sendH265Frame(session, frame, frameNumber) {
+    if (!session.videoDataChannel) {
+      if (frameNumber === 0) {
+        this.log("warn", `No video data channel for session ${session.id}`);
+      }
+      return;
+    }
+    if (session.videoDataChannel.readyState !== "open") {
+      if (frameNumber === 0) {
+        this.log(
+          "warn",
+          `Video data channel not open for session ${session.id}: ${session.videoDataChannel.readyState}`
+        );
+      }
+      return;
+    }
+    let isKeyframe = frame.isKeyframe === true;
+    if (!isKeyframe && frame.isKeyframe === void 0) {
+      const nalUnits = parseAnnexBNalUnits(frame.data);
+      for (const nalUnit of nalUnits) {
+        if (nalUnit.length === 0) continue;
+        const nalType = getH265NalType2(nalUnit);
+        if (nalType === 32 || nalType === 33 || nalType === 34 || nalType === 19 || nalType === 20) {
+          isKeyframe = true;
+          break;
+        }
+      }
+    }
+    const header = Buffer.alloc(12);
+    header.writeUInt32BE(frameNumber, 0);
+    header.writeUInt32BE(frame.microseconds ? frame.microseconds / 1e3 : 0, 4);
+    header.writeUInt8(1, 8);
+    header.writeUInt8(isKeyframe ? 1 : 0, 9);
+    header.writeUInt16BE(0, 10);
+    const packet = Buffer.concat([header, frame.data]);
+    if (frameNumber < 3) {
+      this.log(
+        "info",
+        `Sending H.265 frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
+      );
+    }
+    const MAX_CHUNK_SIZE = 16e3;
+    try {
+      if (packet.length <= MAX_CHUNK_SIZE) {
+        session.videoDataChannel.send(packet);
+      } else {
+        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * MAX_CHUNK_SIZE;
+          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
+          const chunk = packet.subarray(start, end);
+          const chunkHeader = Buffer.alloc(2);
+          chunkHeader.writeUInt8(i, 0);
+          chunkHeader.writeUInt8(totalChunks, 1);
+          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
+        }
+      }
+    } catch (err) {
+      this.log("error", `Error sending H.265 frame ${frameNumber}: ${err}`);
+    }
+  }
+  /**
+   * Create RTP packets for H.264 NAL unit
+   * Handles single NAL, STAP-A aggregation, and FU-A fragmentation
+   */
+  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker) {
+    const { RtpPacket, RtpHeader } = werift;
+    const MTU = 1200;
+    const packets = [];
+    if (nalUnit.length <= MTU) {
+      const header = new RtpHeader();
+      header.payloadType = 96;
+      header.sequenceNumber = sequenceNumber;
+      header.timestamp = timestamp;
+      header.marker = marker;
+      packets.push(new RtpPacket(header, nalUnit));
+    } else {
+      const nalHeader = nalUnit[0];
+      const nalType = nalHeader & 31;
+      const nri = nalHeader & 96;
+      const fuIndicator = (nri | 28) & 255;
+      let offset = 1;
+      let isFirst = true;
+      while (offset < nalUnit.length) {
+        const remaining = nalUnit.length - offset;
+        const chunkSize = Math.min(remaining, MTU - 2);
+        const isLast = offset + chunkSize >= nalUnit.length;
+        let fuHeader = nalType;
+        if (isFirst) fuHeader |= 128;
+        if (isLast) fuHeader |= 64;
+        const fuPayload = Buffer.alloc(2 + chunkSize);
+        fuPayload[0] = fuIndicator;
+        fuPayload[1] = fuHeader;
+        nalUnit.copy(fuPayload, 2, offset, offset + chunkSize);
+        const header = new RtpHeader();
+        header.payloadType = 96;
+        header.sequenceNumber = sequenceNumber + packets.length & 65535;
+        header.timestamp = timestamp;
+        header.marker = isLast && marker;
+        packets.push(new RtpPacket(header, fuPayload));
+        offset += chunkSize;
+        isFirst = false;
+      }
+    }
+    return packets;
+  }
+  /**
+   * Start intercom (two-way audio)
+   */
+  async startIntercom(session) {
+    try {
+      session.intercom = new Intercom({
+        api: this.options.api,
+        channel: this.options.channel
+      });
+      await session.intercom.start();
+      this.log("info", `Intercom started for session ${session.id}`);
+    } catch (err) {
+      this.log(
+        "error",
+        `Failed to start intercom for session ${session.id}: ${err}`
+      );
+      session.intercom = null;
+    }
+  }
+  /**
+   * Log helper
+   */
+  log(level, message) {
+    if (this.options.logger) {
+      this.options.logger(level, message);
+    }
+  }
+};
+
+// src/multifocal/compositeRtspServer.ts
+import { EventEmitter as EventEmitter6 } from "events";
+import { spawn as spawn7 } from "child_process";
 import * as net from "net";
-var CompositeRtspServer = class extends EventEmitter3 {
+var CompositeRtspServer = class extends EventEmitter6 {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -4417,7 +5593,7 @@ var CompositeRtspServer = class extends EventEmitter3 {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = spawn6("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = spawn7("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -4630,8 +5806,10 @@ export {
   BaichuanEventEmitter,
   BaichuanFrameParser,
   BaichuanHttpStreamServer,
+  BaichuanMjpegServer,
   BaichuanRtspServer,
   BaichuanVideoStream,
+  BaichuanWebRTCServer,
   BcMediaAnnexBDecoder,
   BcMediaCodec,
   BcUdpStream,
@@ -4643,6 +5821,7 @@ export {
   H264RtpDepacketizer,
   H265RtpDepacketizer,
   Intercom,
+  MjpegTransformer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -4689,6 +5868,7 @@ export {
   createDebugGateLogger,
   createDiagnosticsBundle,
   createLogger,
+  createMjpegBoundary,
   createNativeStream,
   createNullLogger,
   createReplayHttpServer,
@@ -4696,6 +5876,7 @@ export {
   createRfc4571TcpServerForReplay,
   createRtspProxyServer,
   createTaggedLogger,
+  decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,
   detectVideoCodecFromNal,
@@ -4710,10 +5891,13 @@ export {
   extractSpsFromAnnexB,
   extractVpsFromAnnexB,
   flattenAbilitiesForChannel,
+  formatMjpegFrame,
   getConstructedVideoStreamOptions,
   getGlobalLogger,
   getH265NalType,
+  getMjpegContentType,
   getVideoStream,
+  getVideoclipClientInfo,
   getXmlText,
   hasStartCodes2 as hasH265StartCodes,
   hasStartCodes,