hap-nodejs 0.12.3-beta.27 → 0.12.3-beta.28

package/dist/accessories/Camera_accessory.js

@@ -1,64 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const child_process_1 = require("child_process");
-const events_1 = require("events");
-const net_1 = require("net");
-const __1 = require("..");
-const cameraUUID = __1.uuid.generate("hap-nodejs:accessories:ip-camera");
-const camera = exports.accessory = new __1.Accessory("IPCamera", cameraUUID);
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var child_process_1 = require("child_process");
+var events_1 = require("events");
+var net_1 = require("net");
+var __1 = require("..");
+var cameraUUID = __1.uuid.generate("hap-nodejs:accessories:ip-camera");
+var camera = exports.accessory = new __1.Accessory("IPCamera", cameraUUID);
 // @ts-expect-error: Core/BridgeCore API
 camera.username = "9F:B2:46:0C:40:DB";
 // @ts-expect-error: Core/BridgeCore API
 camera.pincode = "948-23-459";
 camera.category = 17 /* Categories.IP_CAMERA */;
-const FFMPEGH264ProfileNames = [
+var FFMPEGH264ProfileNames = [
     "baseline",
     "main",
     "high",
 ];
-const FFMPEGH264LevelNames = [
+var FFMPEGH264LevelNames = [
     "3.1",
     "3.2",
     "4.0",
 ];
-const ports = new Set();
+var ports = new Set();
 function getPort() {
-    for (let i = 5011;; i++) {
+    for (var i = 5011;; i++) {
         if (!ports.has(i)) {
             ports.add(i);
             return i;
         }
     }
 }
-class ExampleCamera {
-    ffmpegDebugOutput = false;
-    controller;
-    // keep track of sessions
-    pendingSessions = {};
-    ongoingSessions = {};
-    // minimal secure video properties.
-    configuration;
-    handlingStreamingRequest = false;
-    server;
-    handleSnapshotRequest(request, callback) {
-        const ffmpegCommand = `-f lavfi -i testsrc=s=${request.width}x${request.height} -vframes 1 -f mjpeg -`;
-        const ffmpeg = (0, child_process_1.spawn)("ffmpeg", ffmpegCommand.split(" "), { env: process.env });
-        const snapshotBuffers = [];
-        ffmpeg.stdout.on("data", data => snapshotBuffers.push(data));
-        ffmpeg.stderr.on("data", data => {
-            if (this.ffmpegDebugOutput) {
+var ExampleCamera = /** @class */ (function () {
+    function ExampleCamera() {
+        this.ffmpegDebugOutput = false;
+        // keep track of sessions
+        this.pendingSessions = {};
+        this.ongoingSessions = {};
+        this.handlingStreamingRequest = false;
+    }
+    ExampleCamera.prototype.handleSnapshotRequest = function (request, callback) {
+        var _this = this;
+        var ffmpegCommand = "-f lavfi -i testsrc=s=".concat(request.width, "x").concat(request.height, " -vframes 1 -f mjpeg -");
+        var ffmpeg = (0, child_process_1.spawn)("ffmpeg", ffmpegCommand.split(" "), { env: process.env });
+        var snapshotBuffers = [];
+        ffmpeg.stdout.on("data", function (data) { return snapshotBuffers.push(data); });
+        ffmpeg.stderr.on("data", function (data) {
+            if (_this.ffmpegDebugOutput) {
                 console.log("SNAPSHOT: " + String(data));
             }
         });
-        ffmpeg.on("exit", (code, signal) => {
+        ffmpeg.on("exit", function (code, signal) {
             if (signal) {
                 console.log("Snapshot process was killed with signal: " + signal);
                 callback(new Error("killed with signal " + signal));
             }
             else if (code === 0) {
-                console.log(`Successfully captured snapshot at ${request.width}x${request.height}`);
+                console.log("Successfully captured snapshot at ".concat(request.width, "x").concat(request.height));
                 callback(undefined, Buffer.concat(snapshotBuffers));
             }
             else {
@@ -66,18 +65,18 @@ class ExampleCamera {
                 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; // could be used to support multiple crypto suite (or support no suite for debugging)
-        const videoSrtpKey = video.srtp_key;
-        const videoSrtpSalt = video.srtp_salt;
-        const videoSSRC = __1.CameraController.generateSynchronisationSource();
-        const localPort = getPort();
-        const sessionInfo = {
+    ExampleCamera.prototype.prepareStream = function (request, callback) {
+        var sessionId = request.sessionID;
+        var targetAddress = request.targetAddress;
+        var video = request.video;
+        var videoCryptoSuite = video.srtpCryptoSuite; // could be used to support multiple crypto suite (or support no suite for debugging)
+        var videoSrtpKey = video.srtp_key;
+        var videoSrtpSalt = video.srtp_salt;
+        var videoSSRC = __1.CameraController.generateSynchronisationSource();
+        var localPort = getPort();
+        var sessionInfo = {
             address: targetAddress,
             videoPort: video.port,
             localVideoPort: localPort,
@@ -85,7 +84,7 @@ class ExampleCamera {
             videoSRTP: Buffer.concat([videoSrtpKey, videoSrtpSalt]),
             videoSSRC: videoSSRC,
         };
-        const response = {
+        var response = {
             video: {
                 port: localPort,
                 ssrc: videoSSRC,
@@ -96,37 +95,38 @@ class ExampleCamera {
         };
         this.pendingSessions[sessionId] = sessionInfo;
         callback(undefined, response);
-    }
+    };
     // called when iOS device asks stream to start/stop/reconfigure
-    handleStreamRequest(request, callback) {
-        const sessionId = request.sessionID;
+    ExampleCamera.prototype.handleStreamRequest = function (request, callback) {
+        var _this = this;
+        var sessionId = request.sessionID;
         switch (request.type) {
             case "start" /* StreamRequestTypes.START */: {
-                const sessionInfo = this.pendingSessions[sessionId];
-                const video = request.video;
-                const profile = FFMPEGH264ProfileNames[video.profile];
-                const level = FFMPEGH264LevelNames[video.level];
-                const width = video.width;
-                const height = video.height;
-                const fps = video.fps;
-                const payloadType = video.pt;
-                const maxBitrate = video.max_bit_rate;
+                var sessionInfo = this.pendingSessions[sessionId];
+                var video = request.video;
+                var profile = FFMPEGH264ProfileNames[video.profile];
+                var level = FFMPEGH264LevelNames[video.level];
+                var width = video.width;
+                var height = video.height;
+                var fps = video.fps;
+                var payloadType = video.pt;
+                var maxBitrate = video.max_bit_rate;
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const rtcpInterval = video.rtcp_interval; // usually 0.5
-                const mtu = video.mtu; // maximum transmission unit
-                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");
-                console.log(`Starting video stream (${width}x${height}, ${fps} fps, ${maxBitrate} kbps, ${mtu} mtu)...`);
-                let videoffmpegCommand = `-re -f lavfi -i testsrc=s=${width}x${height}:r=${fps} -map 0:0 ` +
-                    `-c:v h264 -pix_fmt yuv420p -r ${fps} -an -sn -dn -b:v ${maxBitrate}k ` +
-                    `-profile:v ${profile} -level:v ${level} ` +
-                    `-payload_type ${payloadType} -ssrc ${ssrc} -f rtp `;
+                var rtcpInterval = video.rtcp_interval; // usually 0.5
+                var mtu = video.mtu; // maximum transmission unit
+                var address = sessionInfo.address;
+                var videoPort = sessionInfo.videoPort;
+                var localVideoPort = sessionInfo.localVideoPort;
+                var ssrc = sessionInfo.videoSSRC;
+                var cryptoSuite = sessionInfo.videoCryptoSuite;
+                var videoSRTP = sessionInfo.videoSRTP.toString("base64");
+                console.log("Starting video stream (".concat(width, "x").concat(height, ", ").concat(fps, " fps, ").concat(maxBitrate, " kbps, ").concat(mtu, " mtu)..."));
+                var videoffmpegCommand = "-re -f lavfi -i testsrc=s=".concat(width, "x").concat(height, ":r=").concat(fps, " -map 0:0 ") +
+                    "-c:v h264 -pix_fmt yuv420p -r ".concat(fps, " -an -sn -dn -b:v ").concat(maxBitrate, "k ") +
+                    "-profile:v ".concat(profile, " -level:v ").concat(level, " ") +
+                    "-payload_type ".concat(payloadType, " -ssrc ").concat(ssrc, " -f rtp ");
                 if (cryptoSuite !== 2 /* SRTPCryptoSuites.NONE */) {
-                    let suite;
+                    var suite = void 0;
                     switch (cryptoSuite) {
                         case 0 /* SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80 */: // actually ffmpeg just supports AES_CM_128_HMAC_SHA1_80
                             suite = "AES_CM_128_HMAC_SHA1_80";
@@ -135,41 +135,41 @@ class ExampleCamera {
                             suite = "AES_CM_256_HMAC_SHA1_80";
                             break;
                     }
-                    videoffmpegCommand += `-srtp_out_suite ${suite} -srtp_out_params ${videoSRTP} s`;
+                    videoffmpegCommand += "-srtp_out_suite ".concat(suite, " -srtp_out_params ").concat(videoSRTP, " s");
                 }
-                videoffmpegCommand += `rtp://${address}:${videoPort}?rtcpport=${videoPort}&localrtcpport=${localVideoPort}&pkt_size=${mtu}`;
+                videoffmpegCommand += "rtp://".concat(address, ":").concat(videoPort, "?rtcpport=").concat(videoPort, "&localrtcpport=").concat(localVideoPort, "&pkt_size=").concat(mtu);
                 if (this.ffmpegDebugOutput) {
                     console.log("FFMPEG command: ffmpeg " + videoffmpegCommand);
                 }
-                const ffmpegVideo = (0, child_process_1.spawn)("ffmpeg", videoffmpegCommand.split(" "), { env: process.env });
-                let started = false;
-                ffmpegVideo.stderr.on("data", (data) => {
+                var ffmpegVideo = (0, child_process_1.spawn)("ffmpeg", videoffmpegCommand.split(" "), { env: process.env });
+                var started_1 = false;
+                ffmpegVideo.stderr.on("data", function (data) {
                     console.log(data.toString("utf8"));
-                    if (!started) {
-                        started = true;
+                    if (!started_1) {
+                        started_1 = true;
                         console.log("FFMPEG: received first frame");
                         callback(); // do not forget to execute callback once set up
                     }
-                    if (this.ffmpegDebugOutput) {
+                    if (_this.ffmpegDebugOutput) {
                         console.log("VIDEO: " + String(data));
                     }
                 });
-                ffmpegVideo.on("error", error => {
+                ffmpegVideo.on("error", function (error) {
                     console.log("[Video] Failed to start video stream: " + error.message);
                     callback(new Error("ffmpeg process creation failed!"));
                 });
-                ffmpegVideo.on("exit", (code, signal) => {
-                    const message = "[Video] ffmpeg exited with code: " + code + " and signal: " + signal;
+                ffmpegVideo.on("exit", function (code, signal) {
+                    var message = "[Video] ffmpeg exited with code: " + code + " and signal: " + signal;
                     if (code == null || code === 255) {
                         console.log(message + " (Video stream stopped!)");
                     }
                     else {
                         console.log(message + " (error)");
-                        if (!started) {
+                        if (!started_1) {
                             callback(new Error(message));
                         }
                         else {
-                            this.controller.forceStopStreamingSession(sessionId);
+                            _this.controller.forceStopStreamingSession(sessionId);
                         }
                     }
                 });
@@ -186,7 +186,7 @@ class ExampleCamera {
                 callback();
                 break;
             case "stop" /* StreamRequestTypes.STOP */: {
-                const ongoingSession = this.ongoingSessions[sessionId];
+                var ongoingSession = this.ongoingSessions[sessionId];
                 if (!ongoingSession) {
                     callback();
                     break;
@@ -205,15 +205,15 @@ class ExampleCamera {
                 break;
             }
         }
-    }
-    updateRecordingActive(active) {
+    };
+    ExampleCamera.prototype.updateRecordingActive = function (active) {
         // we haven't implemented a prebuffer
         console.log("Recording active set to " + active);
-    }
-    updateRecordingConfiguration(configuration) {
+    };
+    ExampleCamera.prototype.updateRecordingConfiguration = function (configuration) {
         this.configuration = configuration;
         console.log(configuration);
-    }
+    };
     /**
      * This is a very minimal, very experimental example on how to implement fmp4 streaming with a
      * CameraController supporting HomeKit Secure Video.
@@ -224,234 +224,315 @@ class ExampleCamera {
      *   when the HomeKit Controller requests it (see the documentation of `CameraRecordingDelegate`).
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async *handleRecordingStreamRequest(streamId) {
-        (0, assert_1.default)(!!this.configuration);
-        /**
-         * With this flag you can control how the generator reacts to a reset to the motion trigger.
-         * If set to true, the generator will send a proper endOfStream if the motion stops.
-         * If set to false, the generator will run till the HomeKit Controller closes the stream.
-         *
-         * Note: In a real implementation you would most likely introduce a bit of a delay.
-         */
-        const STOP_AFTER_MOTION_STOP = false;
-        this.handlingStreamingRequest = true;
-        (0, assert_1.default)(this.configuration.videoCodec.type === 0 /* VideoCodecType.H264 */);
-        const profile = this.configuration.videoCodec.parameters.profile === 2 /* H264Profile.HIGH */ ? "high"
-            : this.configuration.videoCodec.parameters.profile === 1 /* H264Profile.MAIN */ ? "main" : "baseline";
-        const level = this.configuration.videoCodec.parameters.level === 2 /* H264Level.LEVEL4_0 */ ? "4.0"
-            : this.configuration.videoCodec.parameters.level === 1 /* 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 / 1000})`,
-            "-r", this.configuration.videoCodec.resolution[2].toString(),
-        ];
-        let samplerate;
-        switch (this.configuration.audioCodec.samplerate) {
-            case 0 /* AudioRecordingSamplerate.KHZ_8 */:
-                samplerate = "8";
-                break;
-            case 1 /* AudioRecordingSamplerate.KHZ_16 */:
-                samplerate = "16";
-                break;
-            case 2 /* AudioRecordingSamplerate.KHZ_24 */:
-                samplerate = "24";
-                break;
-            case 3 /* AudioRecordingSamplerate.KHZ_32 */:
-                samplerate = "32";
-                break;
-            case 4 /* AudioRecordingSamplerate.KHZ_44_1 */:
-                samplerate = "44.1";
-                break;
-            case 5 /* AudioRecordingSamplerate.KHZ_48 */:
-                samplerate = "48";
-                break;
-            default:
-                throw new Error("Unsupported audio samplerate: " + this.configuration.audioCodec.samplerate);
-        }
-        const audioArgs = this.controller?.recordingManagement?.recordingManagementService.getCharacteristic(__1.Characteristic.RecordingAudioActive)
-            ? [
-                "-acodec", "libfdk_aac",
-                ...(this.configuration.audioCodec.type === 0 /* 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 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; // early exit
-        }
-        const pending = [];
-        try {
-            for await (const box of this.server.generator()) {
-                pending.push(box.header, box.data);
-                const motionDetected = camera.getService(__1.Service.MotionSensor)?.getCharacteristic(__1.Characteristic.MotionDetected).value;
-                console.log("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: isLast,
-                    };
-                    if (isLast) {
-                        console.log("Ending session due to motion stopped!");
-                        break;
-                    }
+    ExampleCamera.prototype.handleRecordingStreamRequest = function (streamId) {
+        return tslib_1.__asyncGenerator(this, arguments, function handleRecordingStreamRequest_1() {
+            var STOP_AFTER_MOTION_STOP, profile, level, videoArgs, samplerate, audioArgs, pending, _a, _b, _c, box, motionDetected, fragment, isLast, e_1_1, error_1;
+            var _d, e_1, _e, _f;
+            var _g, _h, _j;
+            return tslib_1.__generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0:
+                        (0, assert_1.default)(!!this.configuration);
+                        STOP_AFTER_MOTION_STOP = false;
+                        this.handlingStreamingRequest = true;
+                        (0, assert_1.default)(this.configuration.videoCodec.type === 0 /* VideoCodecType.H264 */);
+                        profile = this.configuration.videoCodec.parameters.profile === 2 /* H264Profile.HIGH */ ? "high"
+                            : this.configuration.videoCodec.parameters.profile === 1 /* H264Profile.MAIN */ ? "main" : "baseline";
+                        level = this.configuration.videoCodec.parameters.level === 2 /* H264Level.LEVEL4_0 */ ? "4.0"
+                            : this.configuration.videoCodec.parameters.level === 1 /* H264Level.LEVEL3_2 */ ? "3.2" : "3.1";
+                        videoArgs = [
+                            "-an",
+                            "-sn",
+                            "-dn",
+                            "-codec:v",
+                            "libx264",
+                            "-pix_fmt",
+                            "yuv420p",
+                            "-profile:v", profile,
+                            "-level:v", level,
+                            "-b:v",
+                            "".concat(this.configuration.videoCodec.parameters.bitRate, "k"),
+                            "-force_key_frames",
+                            "expr:eq(t,n_forced*".concat(this.configuration.videoCodec.parameters.iFrameInterval / 1000, ")"),
+                            "-r", this.configuration.videoCodec.resolution[2].toString(),
+                        ];
+                        switch (this.configuration.audioCodec.samplerate) {
+                            case 0 /* AudioRecordingSamplerate.KHZ_8 */:
+                                samplerate = "8";
+                                break;
+                            case 1 /* AudioRecordingSamplerate.KHZ_16 */:
+                                samplerate = "16";
+                                break;
+                            case 2 /* AudioRecordingSamplerate.KHZ_24 */:
+                                samplerate = "24";
+                                break;
+                            case 3 /* AudioRecordingSamplerate.KHZ_32 */:
+                                samplerate = "32";
+                                break;
+                            case 4 /* AudioRecordingSamplerate.KHZ_44_1 */:
+                                samplerate = "44.1";
+                                break;
+                            case 5 /* AudioRecordingSamplerate.KHZ_48 */:
+                                samplerate = "48";
+                                break;
+                            default:
+                                throw new Error("Unsupported audio samplerate: " + this.configuration.audioCodec.samplerate);
+                        }
+                        audioArgs = ((_h = (_g = this.controller) === null || _g === void 0 ? void 0 : _g.recordingManagement) === null || _h === void 0 ? void 0 : _h.recordingManagementService.getCharacteristic(__1.Characteristic.RecordingAudioActive))
+                            ? tslib_1.__spreadArray(tslib_1.__spreadArray([
+                                "-acodec", "libfdk_aac"
+                            ], tslib_1.__read((this.configuration.audioCodec.type === 0 /* AudioRecordingCodecType.AAC_LC */ ?
+                                ["-profile:a", "aac_low"] :
+                                ["-profile:a", "aac_eld"])), false), [
+                                "-ar",
+                                "".concat(samplerate, "k"),
+                                "-b:a",
+                                "".concat(this.configuration.audioCodec.bitrate, "k"),
+                                "-ac",
+                                "".concat(this.configuration.audioCodec.audioChannels),
+                            ], false) : [];
+                        this.server = new MP4StreamingServer("ffmpeg", "-f lavfi -i       testsrc=s=".concat(this.configuration.videoCodec.resolution[0], "x").concat(this.configuration.videoCodec.resolution[1], ":r=").concat(this.configuration.videoCodec.resolution[2])
+                            .split(/ /g), audioArgs, videoArgs);
+                        return [4 /*yield*/, tslib_1.__await(this.server.start())];
+                    case 1:
+                        _k.sent();
+                        if (!(!this.server || this.server.destroyed)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, tslib_1.__await(void 0)];
+                    case 2: return [2 /*return*/, _k.sent()]; // early exit
+                    case 3:
+                        pending = [];
+                        _k.label = 4;
+                    case 4:
+                        _k.trys.push([4, 19, , 20]);
+                        _k.label = 5;
+                    case 5:
+                        _k.trys.push([5, 12, 13, 18]);
+                        _a = true, _b = tslib_1.__asyncValues(this.server.generator());
+                        _k.label = 6;
+                    case 6: return [4 /*yield*/, tslib_1.__await(_b.next())];
+                    case 7:
+                        if (!(_c = _k.sent(), _d = _c.done, !_d)) return [3 /*break*/, 11];
+                        _f = _c.value;
+                        _a = false;
+                        box = _f;
+                        pending.push(box.header, box.data);
+                        motionDetected = (_j = camera.getService(__1.Service.MotionSensor)) === null || _j === void 0 ? void 0 : _j.getCharacteristic(__1.Characteristic.MotionDetected).value;
+                        console.log("mp4 box type " + box.type + " and length " + box.length);
+                        if (!(box.type === "moov" || box.type === "mdat")) return [3 /*break*/, 10];
+                        fragment = Buffer.concat(pending);
+                        pending.splice(0, pending.length);
+                        isLast = STOP_AFTER_MOTION_STOP && !motionDetected;
+                        return [4 /*yield*/, tslib_1.__await({
+                                data: fragment,
+                                isLast: isLast,
+                            })];
+                    case 8: return [4 /*yield*/, _k.sent()];
+                    case 9:
+                        _k.sent();
+                        if (isLast) {
+                            console.log("Ending session due to motion stopped!");
+                            return [3 /*break*/, 11];
+                        }
+                        _k.label = 10;
+                    case 10:
+                        _a = true;
+                        return [3 /*break*/, 6];
+                    case 11: return [3 /*break*/, 18];
+                    case 12:
+                        e_1_1 = _k.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 18];
+                    case 13:
+                        _k.trys.push([13, , 16, 17]);
+                        if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 15];
+                        return [4 /*yield*/, tslib_1.__await(_e.call(_b))];
+                    case 14:
+                        _k.sent();
+                        _k.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 17: return [7 /*endfinally*/];
+                    case 18: return [3 /*break*/, 20];
+                    case 19:
+                        error_1 = _k.sent();
+                        if (!error_1.message.startsWith("FFMPEG")) { // cheap way of identifying our own emitted errors
+                            console.error("Encountered unexpected error on generator " + error_1.stack);
+                        }
+                        return [3 /*break*/, 20];
+                    case 20: return [2 /*return*/];
                 }
-            }
-        }
-        catch (error) {
-            if (!error.message.startsWith("FFMPEG")) { // cheap way of identifying our own emitted errors
-                console.error("Encountered unexpected error on generator " + error.stack);
-            }
-        }
-    }
+            });
+        });
+    };
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    closeRecordingStream(streamId, reason) {
+    ExampleCamera.prototype.closeRecordingStream = function (streamId, reason) {
         if (this.server) {
             this.server.destroy();
             this.server = undefined;
         }
         this.handlingStreamingRequest = false;
-    }
-    acknowledgeStream(streamId) {
+    };
+    ExampleCamera.prototype.acknowledgeStream = function (streamId) {
         this.closeRecordingStream(streamId);
-    }
-}
-class MP4StreamingServer {
-    server;
-    /**
-     * This can be configured to output ffmpeg debug output!
-     */
-    debugMode = false;
-    ffmpegPath;
-    args;
-    socket;
-    childProcess;
-    destroyed = false;
-    connectPromise;
-    connectResolve;
-    constructor(ffmpegPath, ffmpegInput, audioOutputArgs, videoOutputArgs) {
-        this.connectPromise = new Promise(resolve => this.connectResolve = resolve);
+    };
+    return ExampleCamera;
+}());
+var MP4StreamingServer = /** @class */ (function () {
+    function MP4StreamingServer(ffmpegPath, ffmpegInput, audioOutputArgs, videoOutputArgs) {
+        var _a, _b, _c;
+        var _this = this;
+        /**
+         * This can be configured to output ffmpeg debug output!
+         */
+        this.debugMode = false;
+        this.destroyed = false;
+        this.connectPromise = new Promise(function (resolve) { return _this.connectResolve = resolve; });
         this.server = (0, net_1.createServer)(this.handleConnection.bind(this));
         this.ffmpegPath = ffmpegPath;
         this.args = [];
-        this.args.push(...ffmpegInput);
-        this.args.push(...audioOutputArgs);
+        (_a = this.args).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(ffmpegInput), false));
+        (_b = this.args).push.apply(_b, tslib_1.__spreadArray([], tslib_1.__read(audioOutputArgs), false));
         this.args.push("-f", "mp4");
-        this.args.push(...videoOutputArgs);
+        (_c = this.args).push.apply(_c, tslib_1.__spreadArray([], tslib_1.__read(videoOutputArgs), false));
         this.args.push("-fflags", "+genpts", "-reset_timestamps", "1");
         this.args.push("-movflags", "frag_keyframe+empty_moov+default_base_moof");
     }
-    async start() {
-        const promise = (0, events_1.once)(this.server, "listening");
-        this.server.listen(); // listen on random port
-        await promise;
-        if (this.destroyed) {
-            return;
-        }
-        const port = this.server.address().port;
-        this.args.push("tcp://127.0.0.1:" + port);
-        console.log(this.ffmpegPath + " " + this.args.join(" "));
-        this.childProcess = (0, child_process_1.spawn)(this.ffmpegPath, this.args, { env: process.env, stdio: this.debugMode ? "pipe" : "ignore" });
-        if (!this.childProcess) {
-            console.error("ChildProcess is undefined directly after the init!");
-        }
-        if (this.debugMode) {
-            this.childProcess.stdout?.on("data", data => console.log(data.toString()));
-            this.childProcess.stderr?.on("data", data => console.log(data.toString()));
-        }
-    }
-    destroy() {
-        this.socket?.destroy();
-        this.childProcess?.kill();
+    MP4StreamingServer.prototype.start = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var promise, port;
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        promise = (0, events_1.once)(this.server, "listening");
+                        this.server.listen(); // listen on random port
+                        return [4 /*yield*/, promise];
+                    case 1:
+                        _c.sent();
+                        if (this.destroyed) {
+                            return [2 /*return*/];
+                        }
+                        port = this.server.address().port;
+                        this.args.push("tcp://127.0.0.1:" + port);
+                        console.log(this.ffmpegPath + " " + this.args.join(" "));
+                        this.childProcess = (0, child_process_1.spawn)(this.ffmpegPath, this.args, { env: process.env, stdio: this.debugMode ? "pipe" : "ignore" });
+                        if (!this.childProcess) {
+                            console.error("ChildProcess is undefined directly after the init!");
+                        }
+                        if (this.debugMode) {
+                            (_a = this.childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", function (data) { return console.log(data.toString()); });
+                            (_b = this.childProcess.stderr) === null || _b === void 0 ? void 0 : _b.on("data", function (data) { return console.log(data.toString()); });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MP4StreamingServer.prototype.destroy = function () {
+        var _a, _b;
+        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.childProcess) === null || _b === void 0 ? void 0 : _b.kill();
         this.socket = undefined;
         this.childProcess = undefined;
         this.destroyed = true;
-    }
-    handleConnection(socket) {
+    };
+    MP4StreamingServer.prototype.handleConnection = function (socket) {
+        var _a;
         this.server.close(); // don't accept any further clients
         this.socket = socket;
-        this.connectResolve?.();
-    }
+        (_a = this.connectResolve) === null || _a === void 0 ? void 0 : _a.call(this);
+    };
     /**
      * Generator for `MP4Atom`s.
      * Throws error to signal EOF when socket is closed.
      */
-    async *generator() {
-        await this.connectPromise;
-        if (!this.socket || !this.childProcess) {
-            console.log("Socket undefined " + !!this.socket + " childProcess undefined " + !!this.childProcess);
-            throw new Error("Unexpected state!");
-        }
-        while (true) {
-            const header = await this.read(8);
-            const length = header.readInt32BE(0) - 8;
-            const type = header.slice(4).toString();
-            const data = await this.read(length);
-            yield {
-                header: header,
-                length: length,
-                type: type,
-                data: data,
-            };
-        }
-    }
-    async read(length) {
-        if (!this.socket) {
-            throw Error("FFMPEG tried reading from closed socket!");
-        }
-        if (!length) {
-            return Buffer.alloc(0);
-        }
-        const value = this.socket.read(length);
-        if (value) {
-            return value;
-        }
-        return new Promise((resolve, reject) => {
-            const readHandler = () => {
-                const value = this.socket.read(length);
+    MP4StreamingServer.prototype.generator = function () {
+        return tslib_1.__asyncGenerator(this, arguments, function generator_1() {
+            var header, length, type, data;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, tslib_1.__await(this.connectPromise)];
+                    case 1:
+                        _a.sent();
+                        if (!this.socket || !this.childProcess) {
+                            console.log("Socket undefined " + !!this.socket + " childProcess undefined " + !!this.childProcess);
+                            throw new Error("Unexpected state!");
+                        }
+                        _a.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 7];
+                        return [4 /*yield*/, tslib_1.__await(this.read(8))];
+                    case 3:
+                        header = _a.sent();
+                        length = header.readInt32BE(0) - 8;
+                        type = header.slice(4).toString();
+                        return [4 /*yield*/, tslib_1.__await(this.read(length))];
+                    case 4:
+                        data = _a.sent();
+                        return [4 /*yield*/, tslib_1.__await({
+                                header: header,
+                                length: length,
+                                type: type,
+                                data: data,
+                            })];
+                    case 5: return [4 /*yield*/, _a.sent()];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 2];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MP4StreamingServer.prototype.read = function (length) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var value;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                if (!this.socket) {
+                    throw Error("FFMPEG tried reading from closed socket!");
+                }
+                if (!length) {
+                    return [2 /*return*/, Buffer.alloc(0)];
+                }
+                value = this.socket.read(length);
                 if (value) {
-                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                    cleanup();
-                    resolve(value);
+                    return [2 /*return*/, value];
                 }
-            };
-            const endHandler = () => {
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                cleanup();
-                reject(new Error(`FFMPEG socket closed during read for ${length} bytes!`));
-            };
-            const cleanup = () => {
-                this.socket?.removeListener("readable", readHandler);
-                this.socket?.removeListener("close", endHandler);
-            };
-            if (!this.socket) {
-                throw new Error("FFMPEG socket is closed now!");
-            }
-            this.socket.on("readable", readHandler);
-            this.socket.on("close", endHandler);
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var readHandler = function () {
+                            var value = _this.socket.read(length);
+                            if (value) {
+                                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                                cleanup();
+                                resolve(value);
+                            }
+                        };
+                        var endHandler = function () {
+                            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                            cleanup();
+                            reject(new Error("FFMPEG socket closed during read for ".concat(length, " bytes!")));
+                        };
+                        var cleanup = function () {
+                            var _a, _b;
+                            (_a = _this.socket) === null || _a === void 0 ? void 0 : _a.removeListener("readable", readHandler);
+                            (_b = _this.socket) === null || _b === void 0 ? void 0 : _b.removeListener("close", endHandler);
+                        };
+                        if (!_this.socket) {
+                            throw new Error("FFMPEG socket is closed now!");
+                        }
+                        _this.socket.on("readable", readHandler);
+                        _this.socket.on("close", endHandler);
+                    })];
+            });
         });
-    }
-}
-const streamDelegate = new ExampleCamera();
-const cameraController = new __1.CameraController({
+    };
+    return MP4StreamingServer;
+}());
+var streamDelegate = new ExampleCamera();
+var cameraController = new __1.CameraController({
     cameraStreamCount: 2, // HomeKit requires at least 2 streams, but 1 is also just fine
     delegate: streamDelegate,
     streamingOptions: {
@@ -538,8 +619,8 @@ camera.configureController(cameraController);
 // a service to trigger the motion sensor!
 camera.addService(__1.Service.Switch, "MOTION TRIGGER")
     .getCharacteristic(__1.Characteristic.On)
-    .onSet(value => {
-    camera.getService(__1.Service.MotionSensor)
-        ?.updateCharacteristic(__1.Characteristic.MotionDetected, value);
+    .onSet(function (value) {
+    var _a;
+    (_a = camera.getService(__1.Service.MotionSensor)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(__1.Characteristic.MotionDetected, value);
 });
 //# sourceMappingURL=Camera_accessory.js.map