node-red-contrib-homekit-bridged 2.0.0-dev.4 → 2.0.0-dev.7

package/build/lib/camera/CameraControl.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CameraControl_exports = {};
+__export(CameraControl_exports, {
+  configureCamera: () => configureCamera
+});
+module.exports = __toCommonJS(CameraControl_exports);
+var import_hap_nodejs = require("@homebridge/hap-nodejs");
+var import_CameraDelegate = require("./CameraDelegate");
+const configureCamera = (accessory, config) => {
+  const streamDelegate = new import_CameraDelegate.CameraDelegate(accessory, config);
+  const cameraController = new import_hap_nodejs.CameraController({
+    cameraStreamCount: Math.max(1, config?.cameraConfigMaxStreams || 2),
+    // default 2
+    delegate: streamDelegate,
+    streamingOptions: {
+      // srtp: true, // legacy option which will just enable AES_CM_128_HMAC_SHA1_80 (can still be used though)
+      // iOS does not support NONE just there for testing with Wireshark, for example
+      supportedCryptoSuites: [
+        import_hap_nodejs.SRTPCryptoSuites.NONE,
+        import_hap_nodejs.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80
+      ],
+      video: {
+        codec: {
+          profiles: [
+            import_hap_nodejs.H264Profile.BASELINE,
+            import_hap_nodejs.H264Profile.MAIN,
+            import_hap_nodejs.H264Profile.HIGH
+          ],
+          levels: [
+            import_hap_nodejs.H264Level.LEVEL3_1,
+            import_hap_nodejs.H264Level.LEVEL3_2,
+            import_hap_nodejs.H264Level.LEVEL4_0
+          ]
+        },
+        resolutions: (() => {
+          const maxW = config?.cameraConfigMaxWidth;
+          const maxH = config?.cameraConfigMaxHeight;
+          const maxFps = config?.cameraConfigMaxFPS;
+          const defaults = [
+            [1920, 1080, 30],
+            [1280, 960, 30],
+            [1280, 720, 30],
+            [1024, 768, 30],
+            [640, 480, 30],
+            [640, 360, 30],
+            [480, 360, 30],
+            [480, 270, 30],
+            [320, 240, 30],
+            [320, 240, 15],
+            [320, 180, 30]
+          ];
+          return defaults.filter(
+            ([w, h]) => (!maxW || w <= maxW) && (!maxH || h <= maxH)
+          ).map(([w, h, f]) => [w, h, Math.min(f, maxFps || f)]);
+        })()
+      }
+      // audio options intentionally omitted here; delegate will honor config for RTP audio path
+    },
+    recording: {
+      options: {
+        prebufferLength: 4e3,
+        mediaContainerConfiguration: {
+          type: import_hap_nodejs.MediaContainerType.FRAGMENTED_MP4,
+          fragmentLength: 4e3
+        },
+        video: {
+          type: import_hap_nodejs.VideoCodecType.H264,
+          parameters: {
+            profiles: [import_hap_nodejs.H264Profile.HIGH],
+            levels: [import_hap_nodejs.H264Level.LEVEL4_0]
+          },
+          resolutions: [
+            [320, 180, 30],
+            [320, 240, 15],
+            [320, 240, 30],
+            [480, 270, 30],
+            [480, 360, 30],
+            [640, 360, 30],
+            [640, 480, 30],
+            [1280, 720, 30],
+            [1280, 960, 30],
+            [1920, 1080, 30],
+            [1600, 1200, 30]
+          ]
+        },
+        audio: {
+          codecs: {
+            type: import_hap_nodejs.AudioRecordingCodecType.AAC_ELD,
+            audioChannels: 1,
+            samplerate: import_hap_nodejs.AudioRecordingSamplerate.KHZ_48,
+            bitrateMode: import_hap_nodejs.AudioBitrate.VARIABLE
+          }
+        }
+      },
+      delegate: streamDelegate
+    },
+    sensors: {
+      motion: true,
+      occupancy: true
+    }
+  });
+  streamDelegate.controller = cameraController;
+  accessory.configureController(cameraController);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configureCamera
+});

package/build/lib/camera/CameraDelegate.js

@@ -0,0 +1,507 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CameraDelegate_exports = {};
+__export(CameraDelegate_exports, {
+  CameraDelegate: () => CameraDelegate
+});
+module.exports = __toCommonJS(CameraDelegate_exports);
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_child_process = require("node:child_process");
+var import_hap_nodejs = require("@homebridge/hap-nodejs");
+var import_logger = require("@nrchkb/logger");
+var import_MP4StreamingServer = require("./MP4StreamingServer");
+const FFMPEGH264ProfileNames = ["baseline", "main", "high"];
+const FFMPEGH264LevelNames = ["3.1", "3.2", "4.0"];
+const ports = /* @__PURE__ */ new Set();
+const PENDING_SESSION_TIMEOUT_MS = 3e4;
+function getPort() {
+  for (let i = 5011; ; i++) {
+    if (!ports.has(i)) {
+      ports.add(i);
+      return i;
+    }
+  }
+}
+function splitCommandLine(command) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (const char of command.trim()) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === " ") {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) {
+    args.push(current);
+  }
+  return args;
+}
+class CameraDelegate {
+  constructor(accessory, config) {
+    this.accessory = accessory;
+    this.config = config;
+    this.ffmpegDebugOutput = false;
+    this.log = (0, import_logger.logger)("NRCHKB", "CameraDelegate");
+    // keep track of sessions
+    this.pendingSessions = {};
+    this.ongoingSessions = {};
+    this.handlingStreamingRequest = false;
+    try {
+      const name = accessory?.displayName || accessory?.UUID || "UnknownAccessory";
+      this.log = (0, import_logger.logger)("NRCHKB", "CameraDelegate", name);
+    } catch (_) {
+    }
+  }
+  handleSnapshotRequest(request, callback) {
+    const ffmpegPath = this.config?.cameraConfigVideoProcessor || "ffmpeg";
+    const stillSource = this.config?.cameraConfigStillImageSource?.trim();
+    const mainSource = this.config?.cameraConfigSource?.trim();
+    let imageSource;
+    if (stillSource) {
+      imageSource = stillSource;
+    } else if (mainSource) {
+      imageSource = mainSource;
+    } else {
+      imageSource = `-f lavfi -i testsrc=s=${request.width}x${request.height}`;
+    }
+    const ffmpegCommand = `${imageSource} -t 1 -s ${request.width}x${request.height} -f image2 -`;
+    const ffmpeg = (0, import_node_child_process.spawn)(ffmpegPath, splitCommandLine(ffmpegCommand), {
+      env: process.env
+    });
+    const snapshotBuffers = [];
+    ffmpeg.stdout.on("data", (data) => snapshotBuffers.push(data));
+    ffmpeg.stderr.on("data", (data) => {
+      if (this.ffmpegDebugOutput || this.config?.cameraConfigDebug) {
+        this.log.debug(`SNAPSHOT: ${String(data)}`);
+      }
+    });
+    ffmpeg.on("exit", (code, signal) => {
+      if (signal) {
+        this.log.error(
+          `Snapshot process was killed with signal: ${signal}`
+        );
+        callback(new Error(`killed with signal ${signal}`));
+      } else if (code === 0) {
+        this.log.debug(
+          `Successfully captured snapshot at ${request.width}x${request.height}`
+        );
+        callback(void 0, Buffer.concat(snapshotBuffers));
+      } else {
+        this.log.error(`Snapshot process exited with code ${code}`);
+        callback(new Error(`Snapshot process exited with code ${code}`));
+      }
+    });
+  }
+  // called when iOS request rtp setup
+  prepareStream(request, callback) {
+    const sessionId = request.sessionID;
+    const targetAddress = request.targetAddress;
+    const video = request.video;
+    const videoCryptoSuite = video.srtpCryptoSuite;
+    const videoSrtpKey = video.srtp_key;
+    const videoSrtpSalt = video.srtp_salt;
+    const videoSSRC = import_hap_nodejs.CameraController.generateSynchronisationSource();
+    const localPort = getPort();
+    const timeout = setTimeout(() => {
+      const pendingSession = this.pendingSessions[sessionId];
+      if (!pendingSession) {
+        return;
+      }
+      ports.delete(pendingSession.localVideoPort);
+      delete this.pendingSessions[sessionId];
+      this.log.error(`Stream session ${sessionId} timed out before start`);
+    }, PENDING_SESSION_TIMEOUT_MS);
+    const sessionInfo = {
+      address: targetAddress,
+      videoPort: video.port,
+      localVideoPort: localPort,
+      videoCryptoSuite,
+      videoSRTP: Buffer.concat([videoSrtpKey, videoSrtpSalt]),
+      videoSSRC,
+      timeout
+    };
+    const response = {
+      video: {
+        port: localPort,
+        ssrc: videoSSRC,
+        srtp_key: videoSrtpKey,
+        srtp_salt: videoSrtpSalt
+      }
+      // audio is omitted as we do not support audio in this example
+    };
+    this.pendingSessions[sessionId] = sessionInfo;
+    callback(void 0, response);
+  }
+  // called when the iOS device asks stream to start/stop/reconfigure
+  handleStreamRequest(request, callback) {
+    const sessionId = request.sessionID;
+    switch (request.type) {
+      case import_hap_nodejs.StreamRequestTypes.START: {
+        const sessionInfo = this.pendingSessions[sessionId];
+        if (!sessionInfo) {
+          callback(
+            new Error(`No pending stream session ${sessionId}`)
+          );
+          break;
+        }
+        clearTimeout(sessionInfo.timeout);
+        const video = request.video;
+        const profile = FFMPEGH264ProfileNames[video.profile];
+        const level = FFMPEGH264LevelNames[video.level];
+        const width = video.width;
+        const height = video.height;
+        let fps = video.fps;
+        const payloadType = video.pt;
+        let maxBitrate = video.max_bit_rate;
+        const mtu = video.mtu;
+        const address = sessionInfo.address;
+        const videoPort = sessionInfo.videoPort;
+        const localVideoPort = sessionInfo.localVideoPort;
+        const ssrc = sessionInfo.videoSSRC;
+        const cryptoSuite = sessionInfo.videoCryptoSuite;
+        const videoSRTP = sessionInfo.videoSRTP.toString("base64");
+        const cfg = this.config;
+        const ffmpegPath = cfg?.cameraConfigVideoProcessor || "ffmpeg";
+        const source = cfg?.cameraConfigSource || `-f lavfi -i testsrc=s=${width}x${height}:r=${fps}`;
+        const vcodec = cfg?.cameraConfigVideoCodec || "libx264";
+        const additional = cfg?.cameraConfigAdditionalCommandLine?.trim();
+        const mapvideo = cfg?.cameraConfigMapVideo || "0:0";
+        const mapaudio = cfg?.cameraConfigMapAudio || "0:1";
+        const maxConfigBitrate = cfg?.cameraConfigMaxBitrate;
+        if (maxConfigBitrate && maxConfigBitrate > 0 && maxConfigBitrate < maxBitrate) {
+          maxBitrate = maxConfigBitrate;
+        }
+        const maxConfigFps = cfg?.cameraConfigMaxFPS;
+        if (maxConfigFps && maxConfigFps > 0 && maxConfigFps < fps) {
+          fps = maxConfigFps;
+        }
+        const vf = [];
+        if (cfg?.cameraConfigVideoFilter !== null && cfg?.cameraConfigVideoFilter !== void 0 && cfg?.cameraConfigVideoFilter !== "") {
+          vf.push(cfg.cameraConfigVideoFilter);
+        }
+        if (cfg?.cameraConfigHorizontalFlip) vf.push("hflip");
+        if (cfg?.cameraConfigVerticalFlip) vf.push("vflip");
+        this.log.debug(
+          `Starting video stream (${width}x${height}, ${fps} fps, ${maxBitrate} kbps, ${mtu} mtu)...`
+        );
+        let videoffmpegCommand = `${source} -map ${mapvideo} -vcodec ${vcodec} -pix_fmt yuv420p -r ${fps} -f rawvideo ${additional ? `${additional} ` : ""}${vf.length > 0 ? `-vf ${vf.join(",")} ` : ""}-b:v ${maxBitrate}k -bufsize ${maxBitrate}k -maxrate ${maxBitrate}k -profile:v ${profile} -level:v ${level} -payload_type ${payloadType} -ssrc ${ssrc} -f rtp `;
+        if (cryptoSuite !== import_hap_nodejs.SRTPCryptoSuites.NONE) {
+          let suite;
+          switch (cryptoSuite) {
+            case import_hap_nodejs.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80:
+              suite = "AES_CM_128_HMAC_SHA1_80";
+              break;
+            case import_hap_nodejs.SRTPCryptoSuites.AES_CM_256_HMAC_SHA1_80:
+              suite = "AES_CM_256_HMAC_SHA1_80";
+              break;
+          }
+          videoffmpegCommand += `-srtp_out_suite ${suite} -srtp_out_params ${videoSRTP} s`;
+        }
+        videoffmpegCommand += `rtp://${address}:${videoPort}?rtcpport=${videoPort}&localrtcpport=${localVideoPort}&pkt_size=${cfg?.cameraConfigPacketSize || mtu}`;
+        const audioEnabled = this.config?.cameraConfigAudio === true || this.config?.cameraConfigAudio === "true";
+        let audioffmpegCommand = "";
+        if (audioEnabled) {
+          const acodec = cfg?.cameraConfigAudioCodec || "libfdk_aac";
+          const abitrate = 32;
+          const asamplerate = 16;
+          const apayloadType = 110;
+          audioffmpegCommand = ` -map ${mapaudio} -acodec ${acodec} -profile:a aac_eld -flags +global_header -f null -ar ${asamplerate}k -b:a ${abitrate}k -bufsize ${abitrate}k -ac 1 -payload_type ${apayloadType} `;
+        }
+        if (this.ffmpegDebugOutput || this.config?.cameraConfigDebug) {
+          this.log.debug(
+            `FFMPEG command: ${ffmpegPath} ${videoffmpegCommand}${audioffmpegCommand}`
+          );
+        }
+        const cleanupOngoingSession = () => {
+          const ongoingSession = this.ongoingSessions[sessionId];
+          if (ongoingSession) {
+            ports.delete(ongoingSession.localVideoPort);
+            delete this.ongoingSessions[sessionId];
+          }
+        };
+        let callbackSettled = false;
+        const settleCallback = (error) => {
+          if (callbackSettled) {
+            return;
+          }
+          callbackSettled = true;
+          callback(error);
+        };
+        const ffmpegVideo = (0, import_node_child_process.spawn)(
+          ffmpegPath,
+          splitCommandLine(videoffmpegCommand + audioffmpegCommand),
+          {
+            env: process.env
+          }
+        );
+        let started = false;
+        ffmpegVideo.stderr.on("data", (data) => {
+          this.log.debug(data.toString("utf8"));
+          if (!started) {
+            started = true;
+            this.log.debug("FFMPEG: received first frame");
+            settleCallback();
+          }
+          if (this.ffmpegDebugOutput || this.config?.cameraConfigDebug) {
+            this.log.debug(`VIDEO: ${String(data)}`);
+          }
+        });
+        ffmpegVideo.on("error", (error) => {
+          this.log.error(
+            `[Video] Failed to start video stream: ${error.message}`
+          );
+          cleanupOngoingSession();
+          settleCallback(new Error("ffmpeg process creation failed!"));
+        });
+        ffmpegVideo.on("exit", (code, signal) => {
+          const message = "[Video] ffmpeg exited with code: " + code + " and signal: " + signal;
+          if (code == null || code === 255) {
+            this.log.debug(`${message} (Video stream stopped!)`);
+          } else {
+            this.log.error(`${message} (error)`);
+            if (!started) {
+              settleCallback(new Error(message));
+            } else {
+              this.controller?.forceStopStreamingSession(
+                sessionId
+              );
+            }
+          }
+          cleanupOngoingSession();
+        });
+        this.ongoingSessions[sessionId] = {
+          localVideoPort,
+          process: ffmpegVideo
+        };
+        delete this.pendingSessions[sessionId];
+        break;
+      }
+      case import_hap_nodejs.StreamRequestTypes.RECONFIGURE:
+        this.log.debug(
+          "Received (unsupported) request to reconfigure to: " + JSON.stringify(request.video)
+        );
+        callback();
+        break;
+      case import_hap_nodejs.StreamRequestTypes.STOP: {
+        const ongoingSession = this.ongoingSessions[sessionId];
+        const pendingSession = this.pendingSessions[sessionId];
+        if (pendingSession) {
+          clearTimeout(pendingSession.timeout);
+          ports.delete(pendingSession.localVideoPort);
+          delete this.pendingSessions[sessionId];
+        }
+        if (!ongoingSession) {
+          callback();
+          break;
+        }
+        ports.delete(ongoingSession.localVideoPort);
+        try {
+          ongoingSession.process.kill("SIGKILL");
+        } catch (e) {
+          this.log.error(
+            "Error occurred terminating the video process!"
+          );
+          this.log.error(String(e));
+        }
+        delete this.ongoingSessions[sessionId];
+        this.log.debug("Stopped streaming session!");
+        callback();
+        break;
+      }
+    }
+  }
+  updateRecordingActive(active) {
+    this.log.debug(`Recording active set to ${active}`);
+  }
+  updateRecordingConfiguration(configuration) {
+    this.configuration = configuration;
+    this.log.debug(JSON.stringify(configuration));
+  }
+  /**
+   * This is a very minimal, very experimental example of how to implement fmp4 streaming with a
+   * CameraController supporting HomeKit Secure Video.
+   *
+   * An ideal implementation would diverge from this in the following ways:
+   * * It would implement a prebuffer and respect the recording `active` characteristic for that.
+   * * It would start to immediately record after a trigger event occurred and not just
+   *   when the HomeKit Controller requests it (see the documentation of `CameraRecordingDelegate`).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async *handleRecordingStreamRequest(_streamId) {
+    (0, import_node_assert.default)(!!this.configuration);
+    const STOP_AFTER_MOTION_STOP = false;
+    this.handlingStreamingRequest = true;
+    (0, import_node_assert.default)(this.configuration.videoCodec.type === import_hap_nodejs.VideoCodecType.H264);
+    const profile = this.configuration.videoCodec.parameters.profile === import_hap_nodejs.H264Profile.HIGH ? "high" : this.configuration.videoCodec.parameters.profile === import_hap_nodejs.H264Profile.MAIN ? "main" : "baseline";
+    const level = this.configuration.videoCodec.parameters.level === import_hap_nodejs.H264Level.LEVEL4_0 ? "4.0" : this.configuration.videoCodec.parameters.level === import_hap_nodejs.H264Level.LEVEL3_2 ? "3.2" : "3.1";
+    const videoArgs = [
+      "-an",
+      "-sn",
+      "-dn",
+      "-codec:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-profile:v",
+      profile,
+      "-level:v",
+      level,
+      "-b:v",
+      `${this.configuration.videoCodec.parameters.bitRate}k`,
+      "-force_key_frames",
+      `expr:eq(t,n_forced*${this.configuration.videoCodec.parameters.iFrameInterval / 1e3})`,
+      "-r",
+      this.configuration.videoCodec.resolution[2].toString()
+    ];
+    let samplerate;
+    switch (this.configuration.audioCodec.samplerate) {
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_8:
+        samplerate = "8";
+        break;
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_16:
+        samplerate = "16";
+        break;
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_24:
+        samplerate = "24";
+        break;
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_32:
+        samplerate = "32";
+        break;
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_44_1:
+        samplerate = "44.1";
+        break;
+      case import_hap_nodejs.AudioRecordingSamplerate.KHZ_48:
+        samplerate = "48";
+        break;
+      default:
+        throw new Error(
+          "Unsupported audio samplerate: " + this.configuration.audioCodec.samplerate
+        );
+    }
+    const audioArgs = this.controller?.recordingManagement?.recordingManagementService.getCharacteristic(
+      import_hap_nodejs.Characteristic.RecordingAudioActive
+    ) ? [
+      "-acodec",
+      "libfdk_aac",
+      ...this.configuration.audioCodec.type === import_hap_nodejs.AudioRecordingCodecType.AAC_LC ? ["-profile:a", "aac_low"] : ["-profile:a", "aac_eld"],
+      "-ar",
+      `${samplerate}k`,
+      "-b:a",
+      `${this.configuration.audioCodec.bitrate}k`,
+      "-ac",
+      `${this.configuration.audioCodec.audioChannels}`
+    ] : [];
+    this.server = new import_MP4StreamingServer.MP4StreamingServer(
+      "ffmpeg",
+      `-f lavfi -i       testsrc=s=${this.configuration.videoCodec.resolution[0]}x${this.configuration.videoCodec.resolution[1]}:r=${this.configuration.videoCodec.resolution[2]}`.split(
+        / /g
+      ),
+      audioArgs,
+      videoArgs
+    );
+    await this.server.start();
+    if (!this.server || this.server.destroyed) {
+      return;
+    }
+    const pending = [];
+    try {
+      for await (const box of this.server.generator()) {
+        pending.push(box.header, box.data);
+        const motionDetected = this.accessory.getService(import_hap_nodejs.Service.MotionSensor)?.getCharacteristic(import_hap_nodejs.Characteristic.MotionDetected).value;
+        this.log.debug(
+          `mp4 box type ${box.type} and length ${box.length}`
+        );
+        if (box.type === "moov" || box.type === "mdat") {
+          const fragment = Buffer.concat(pending);
+          pending.splice(0, pending.length);
+          const isLast = STOP_AFTER_MOTION_STOP && !motionDetected;
+          yield {
+            data: fragment,
+            isLast
+          };
+          if (isLast) {
+            this.log.debug("Ending session due to motion stopped!");
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      if (!error.message.startsWith("FFMPEG")) {
+        this.log.error(
+          `Encountered unexpected error on generator ${error.stack}`
+        );
+      }
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  closeRecordingStream(streamId, reason) {
+    if (reason) {
+      this.log.error(`Closing stream ${streamId} due to error: ${reason}`);
+    }
+    if (this.server) {
+      this.server.destroy();
+      this.server = void 0;
+    }
+    this.handlingStreamingRequest = false;
+  }
+  acknowledgeStream(streamId) {
+    this.closeRecordingStream(streamId);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CameraDelegate
+});