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

package/dist/lib/camera/RTPStreamManagement.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamController = exports.RTPStreamManagement = exports.StreamRequestTypes = exports.AudioStreamingSamplerate = exports.AudioStreamingCodecType = exports.SRTPCryptoSuites = exports.AudioSamplerate = exports.AudioBitrate = exports.VideoCodecPacketizationMode = exports.H264Level = exports.H264Profile = exports.VideoCodecType = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const net_1 = tslib_1.__importDefault(require("net"));
-const Characteristic_1 = require("../Characteristic");
-const controller_1 = require("../controller");
-const Service_1 = require("../Service");
-const hapStatusError_1 = require("../util/hapStatusError");
-const once_1 = require("../util/once");
-const tlv = tslib_1.__importStar(require("../util/tlv"));
-const uuid = tslib_1.__importStar(require("../util/uuid"));
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var crypto_1 = tslib_1.__importDefault(require("crypto"));
+var debug_1 = tslib_1.__importDefault(require("debug"));
+var net_1 = tslib_1.__importDefault(require("net"));
+var Characteristic_1 = require("../Characteristic");
+var controller_1 = require("../controller");
+var Service_1 = require("../Service");
+var hapStatusError_1 = require("../util/hapStatusError");
+var once_1 = require("../util/once");
+var tlv = tslib_1.__importStar(require("../util/tlv"));
+var uuid = tslib_1.__importStar(require("../util/uuid"));
 // noinspection JSDeprecatedSymbols
-const Camera_1 = require("./Camera");
-const RTPProxy_1 = tslib_1.__importDefault(require("./RTPProxy"));
-const debug = (0, debug_1.default)("HAP-NodeJS:Camera:RTPStreamManagement");
+var Camera_1 = require("./Camera");
+var RTPProxy_1 = tslib_1.__importDefault(require("./RTPProxy"));
+var debug = (0, debug_1.default)("HAP-NodeJS:Camera:RTPStreamManagement");
 // ---------------------------------- TLV DEFINITIONS START ----------------------------------
 var StreamingStatusTypes;
 (function (StreamingStatusTypes) {
@@ -283,61 +283,16 @@ var StreamRequestTypes;
 /**
  * @group Camera
  */
-class RTPStreamManagement {
-    /**
-     * @deprecated Please use the SRTPCryptoSuites const enum above.
-     */
-    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
-    static SRTPCryptoSuites = SRTPCryptoSuites;
-    /**
-     * @deprecated Please use the H264Profile const enum above.
-     */
-    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
-    static VideoCodecParamProfileIDTypes = H264Profile;
-    /**
-     * @deprecated won't be updated anymore. Please use the H264Level const enum above.
-     */
-    static VideoCodecParamLevelTypes = Object.freeze({ TYPE3_1: 0, TYPE3_2: 1, TYPE4_0: 2 });
-    id;
-    delegate;
-    service;
-    stateChangeDelegate;
-    requireProxy;
-    disableAudioProxy;
-    supportedCryptoSuites;
-    videoOnly = false;
-    supportedRTPConfiguration;
-    supportedVideoStreamConfiguration;
-    supportedAudioStreamConfiguration;
-    /**
-     * @deprecated
-     */
-    connectionID;
-    activeConnection;
-    activeConnectionClosedListener;
-    sessionIdentifier = undefined;
-    /**
-     * @private private API
-     */
-    streamStatus = 0 /* StreamingStatus.AVAILABLE */; // use _updateStreamStatus to update this property
-    ipVersion; // ip version for the current session
-    selectedConfiguration = ""; // base64 representation of the currently selected configuration
-    setupEndpointsResponse = ""; // response of the SetupEndpoints Characteristic
-    /**
-     * @private deprecated API
-     */
-    audioProxy;
-    /**
-     * @private deprecated API
-     */
-    videoProxy;
-    /**
-     * A RTPStreamManagement is considered disabled if `HomeKitCameraActive` is set to false.
-     * We use a closure based approach to retrieve the value of this characteristic.
-     * The characteristic is managed by the RecordingManagement.
-     */
-    disabledThroughOperatingMode;
-    constructor(id, options, delegate, service, disabledThroughOperatingMode) {
+var RTPStreamManagement = /** @class */ (function () {
+    function RTPStreamManagement(id, options, delegate, service, disabledThroughOperatingMode) {
+        this.videoOnly = false;
+        this.sessionIdentifier = undefined;
+        /**
+         * @private private API
+         */
+        this.streamStatus = 0 /* StreamingStatus.AVAILABLE */; // use _updateStreamStatus to update this property
+        this.selectedConfiguration = ""; // base64 representation of the currently selected configuration
+        this.setupEndpointsResponse = ""; // response of the SetupEndpoints Characteristic
         this.id = id;
         this.delegate = delegate;
         this.requireProxy = options.proxy || false;
@@ -364,47 +319,48 @@ class RTPStreamManagement {
         this.resetSelectedStreamConfiguration();
         this.disabledThroughOperatingMode = disabledThroughOperatingMode;
     }
-    forceStop() {
+    RTPStreamManagement.prototype.forceStop = function () {
         this.handleSessionClosed();
-    }
-    getService() {
+    };
+    RTPStreamManagement.prototype.getService = function () {
         return this.service;
-    }
+    };
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
     /**
      * @deprecated
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    handleCloseConnection(connectionID) {
+    RTPStreamManagement.prototype.handleCloseConnection = function (connectionID) {
         // This method is only here for legacy compatibility. It used to be called by legacy style CameraSource
         // implementations to signal that the associated HAP connection was closed.
         // This is now handled automatically. Thus, we don't need to do anything anymore.
-    }
-    handleFactoryReset() {
+    };
+    RTPStreamManagement.prototype.handleFactoryReset = function () {
         this.resetSelectedStreamConfiguration();
         this.resetSetupEndpointsResponse();
         this.service.updateCharacteristic(Characteristic_1.Characteristic.Active, true);
         // on a factory reset the assumption is that all connections were already terminated and thus "handleStopStream" was already called
-    }
-    destroy() {
+    };
+    RTPStreamManagement.prototype.destroy = function () {
         if (this.activeConnection) {
             this._handleStopStream();
         }
-    }
-    constructService(id) {
-        const managementService = new Service_1.Service.CameraRTPStreamManagement("", id.toString());
+    };
+    RTPStreamManagement.prototype.constructService = function (id) {
+        var managementService = new Service_1.Service.CameraRTPStreamManagement("", id.toString());
         // this service is required only when recording is enabled. We don't really have access to this info here,
         // so we just add the characteristic. Doesn't really hurt.
         managementService.setCharacteristic(Characteristic_1.Characteristic.Active, true);
         return managementService;
-    }
-    setupServiceHandlers() {
+    };
+    RTPStreamManagement.prototype.setupServiceHandlers = function () {
+        var _this = this;
         if (!this.service.testCharacteristic(Characteristic_1.Characteristic.Active)) {
             // the active characteristic might not be present on some older configurations.
             this.service.setCharacteristic(Characteristic_1.Characteristic.Active, true);
         }
         this.service.getCharacteristic(Characteristic_1.Characteristic.Active)
-            .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.())
+            .on("change" /* CharacteristicEventTypes.CHANGE */, function () { var _a; return (_a = _this.stateChangeDelegate) === null || _a === void 0 ? void 0 : _a.call(_this); })
             .setProps({ adminOnlyAccess: [1 /* Access.WRITE */] });
         // ensure that configurations are up-to-date and reflected in the characteristic values
         this.service.setCharacteristic(Characteristic_1.Characteristic.SupportedRTPConfiguration, this.supportedRTPConfiguration);
@@ -413,37 +369,36 @@ class RTPStreamManagement {
         this._updateStreamStatus(0 /* StreamingStatus.AVAILABLE */); // reset streaming status to available
         this.service.setCharacteristic(Characteristic_1.Characteristic.SetupEndpoints, this.setupEndpointsResponse); // reset SetupEndpoints to default
         this.service.getCharacteristic(Characteristic_1.Characteristic.SelectedRTPStreamConfiguration)
-            .on("get" /* CharacteristicEventTypes.GET */, callback => {
-            if (this.streamingIsDisabled()) {
+            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
+            if (_this.streamingIsDisabled()) {
                 callback(null, tlv.encode(1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */, tlv.encode(2 /* SessionControlTypes.COMMAND */, SessionControlCommand.SUSPEND_SESSION)).toString("base64"));
                 return;
             }
-            callback(null, this.selectedConfiguration);
+            callback(null, _this.selectedConfiguration);
         })
             .on("set" /* CharacteristicEventTypes.SET */, this._handleSelectedStreamConfigurationWrite.bind(this));
         this.service.getCharacteristic(Characteristic_1.Characteristic.SetupEndpoints)
-            .on("get" /* CharacteristicEventTypes.GET */, callback => {
-            if (this.streamingIsDisabled()) {
+            .on("get" /* CharacteristicEventTypes.GET */, function (callback) {
+            if (_this.streamingIsDisabled()) {
                 callback(null, tlv.encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64"));
                 return;
             }
-            callback(null, this.setupEndpointsResponse);
+            callback(null, _this.setupEndpointsResponse);
         })
-            .on("set" /* CharacteristicEventTypes.SET */, (value, callback, context, connection) => {
+            .on("set" /* CharacteristicEventTypes.SET */, function (value, callback, context, connection) {
             if (!connection) {
                 debug("Set event handler for SetupEndpoints cannot be called from plugin. Connection undefined!");
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                 return;
             }
-            this.handleSetupEndpoints(value, callback, connection);
+            _this.handleSetupEndpoints(value, callback, connection);
         });
-    }
-    handleSessionClosed() {
+    };
+    RTPStreamManagement.prototype.handleSessionClosed = function () {
         this.resetSelectedStreamConfiguration();
         this.resetSetupEndpointsResponse();
         if (this.activeConnection) {
             this.activeConnection.removeListener("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionClosedListener);
-            this.activeConnection.setMaxListeners(this.activeConnection.getMaxListeners() - 1);
             this.activeConnection = undefined;
         }
         this._updateStreamStatus(0 /* StreamingStatus.AVAILABLE */);
@@ -459,49 +414,51 @@ class RTPStreamManagement {
             this.audioProxy.destroy();
             this.audioProxy = undefined;
         }
-    }
-    streamingIsDisabled(callback) {
+    };
+    RTPStreamManagement.prototype.streamingIsDisabled = function (callback) {
+        var _a;
         if (!this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value) {
             callback && callback(new hapStatusError_1.HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
             return true;
         }
-        if (this.disabledThroughOperatingMode?.()) {
+        if ((_a = this.disabledThroughOperatingMode) === null || _a === void 0 ? void 0 : _a.call(this)) {
             callback && callback(new hapStatusError_1.HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
             return true;
         }
         return false;
-    }
-    _handleSelectedStreamConfigurationWrite(value, callback) {
+    };
+    RTPStreamManagement.prototype._handleSelectedStreamConfigurationWrite = function (value, callback) {
+        var _this = this;
         if (this.streamingIsDisabled(callback)) {
             return;
         }
-        const data = Buffer.from(value, "base64");
-        const objects = tlv.decode(data);
-        const sessionControl = tlv.decode(objects[1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */]);
-        const sessionIdentifier = uuid.unparse(sessionControl[1 /* SessionControlTypes.SESSION_IDENTIFIER */]);
-        const requestType = sessionControl[2 /* SessionControlTypes.COMMAND */][0];
+        var data = Buffer.from(value, "base64");
+        var objects = tlv.decode(data);
+        var sessionControl = tlv.decode(objects[1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */]);
+        var sessionIdentifier = uuid.unparse(sessionControl[1 /* SessionControlTypes.SESSION_IDENTIFIER */]);
+        var requestType = sessionControl[2 /* SessionControlTypes.COMMAND */][0];
         if (sessionIdentifier !== this.sessionIdentifier) {
-            debug(`Received unknown session Identifier with request to ${SessionControlCommand[requestType]}`);
+            debug("Received unknown session Identifier with request to ".concat(SessionControlCommand[requestType]));
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             return;
         }
         this.selectedConfiguration = value;
         // intercept the callback chain to check if an error occurred.
-        const streamCallback = (error, writeResponse) => {
+        var streamCallback = function (error, writeResponse) {
             callback(error, writeResponse); // does not support writeResponse, but how knows what comes in the future.
             if (error) {
-                this.handleSessionClosed();
+                _this.handleSessionClosed();
             }
         };
         switch (requestType) {
             case SessionControlCommand.START_SESSION: {
-                const selectedVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
-                const selectedAudioParameters = tlv.decode(objects[3 /* SelectedRTPStreamConfigurationTypes.SELECTED_AUDIO_PARAMETERS */]);
+                var selectedVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
+                var selectedAudioParameters = tlv.decode(objects[3 /* SelectedRTPStreamConfigurationTypes.SELECTED_AUDIO_PARAMETERS */]);
                 this._handleStartStream(selectedVideoParameters, selectedAudioParameters, streamCallback);
                 break;
             }
             case SessionControlCommand.RECONFIGURE_SESSION: {
-                const reconfiguredVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
+                var reconfiguredVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
                 this.handleReconfigureStream(reconfiguredVideoParameters, streamCallback);
                 break;
             }
@@ -511,68 +468,68 @@ class RTPStreamManagement {
             case SessionControlCommand.RESUME_SESSION:
             case SessionControlCommand.SUSPEND_SESSION:
             default:
-                debug(`Unhandled request type ${SessionControlCommand[requestType]}`);
+                debug("Unhandled request type ".concat(SessionControlCommand[requestType]));
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                 return;
         }
-    }
-    _handleStartStream(videoConfiguration, audioConfiguration, callback) {
+    };
+    RTPStreamManagement.prototype._handleStartStream = function (videoConfiguration, audioConfiguration, callback) {
         // selected video configuration
         // noinspection JSUnusedLocalSymbols
-        const videoCodec = videoConfiguration[1 /* SelectedVideoParametersTypes.CODEC_TYPE */]; // always 0x00 for h264
-        const videoParametersTLV = videoConfiguration[2 /* SelectedVideoParametersTypes.CODEC_PARAMETERS */];
-        const videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
-        const videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
+        var videoCodec = videoConfiguration[1 /* SelectedVideoParametersTypes.CODEC_TYPE */]; // always 0x00 for h264
+        var videoParametersTLV = videoConfiguration[2 /* SelectedVideoParametersTypes.CODEC_PARAMETERS */];
+        var videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
+        var videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
         // video parameters
-        const videoParameters = tlv.decode(videoParametersTLV);
-        const h264Profile = videoParameters[1 /* VideoCodecParametersTypes.PROFILE_ID */][0];
-        const h264Level = videoParameters[2 /* VideoCodecParametersTypes.LEVEL */][0];
-        const packetizationMode = videoParameters[3 /* VideoCodecParametersTypes.PACKETIZATION_MODE */][0];
-        const cvoEnabled = videoParameters[4 /* VideoCodecParametersTypes.CVO_ENABLED */];
-        let cvoId = undefined;
+        var videoParameters = tlv.decode(videoParametersTLV);
+        var h264Profile = videoParameters[1 /* VideoCodecParametersTypes.PROFILE_ID */][0];
+        var h264Level = videoParameters[2 /* VideoCodecParametersTypes.LEVEL */][0];
+        var packetizationMode = videoParameters[3 /* VideoCodecParametersTypes.PACKETIZATION_MODE */][0];
+        var cvoEnabled = videoParameters[4 /* VideoCodecParametersTypes.CVO_ENABLED */];
+        var cvoId = undefined;
         if (cvoEnabled && cvoEnabled[0] === 1 /* VideoCodecCVO.SUPPORTED */) {
             cvoId = videoParameters[5 /* VideoCodecParametersTypes.CVO_ID */].readUInt8(0);
         }
         // video attributes
-        const videoAttributes = tlv.decode(videoAttributesTLV);
-        const width = videoAttributes[1 /* VideoAttributesTypes.IMAGE_WIDTH */].readUInt16LE(0);
-        const height = videoAttributes[2 /* VideoAttributesTypes.IMAGE_HEIGHT */].readUInt16LE(0);
-        const frameRate = videoAttributes[3 /* VideoAttributesTypes.FRAME_RATE */].readUInt8(0);
+        var videoAttributes = tlv.decode(videoAttributesTLV);
+        var width = videoAttributes[1 /* VideoAttributesTypes.IMAGE_WIDTH */].readUInt16LE(0);
+        var height = videoAttributes[2 /* VideoAttributesTypes.IMAGE_HEIGHT */].readUInt16LE(0);
+        var frameRate = videoAttributes[3 /* VideoAttributesTypes.FRAME_RATE */].readUInt8(0);
         // video rtp parameters
-        const videoRTPParameters = tlv.decode(videoRTPParametersTLV);
-        const videoPayloadType = videoRTPParameters[1 /* VideoRTPParametersTypes.PAYLOAD_TYPE */].readUInt8(0); // 99
-        const videoSSRC = videoRTPParameters[2 /* VideoRTPParametersTypes.SYNCHRONIZATION_SOURCE */].readUInt32LE(0);
-        const videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
-        const videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0);
-        let maxMTU = this.ipVersion === "ipv6" ? 1228 : 1378; // default values ipv4: 1378 bytes; ipv6: 1228 bytes
+        var videoRTPParameters = tlv.decode(videoRTPParametersTLV);
+        var videoPayloadType = videoRTPParameters[1 /* VideoRTPParametersTypes.PAYLOAD_TYPE */].readUInt8(0); // 99
+        var videoSSRC = videoRTPParameters[2 /* VideoRTPParametersTypes.SYNCHRONIZATION_SOURCE */].readUInt32LE(0);
+        var videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
+        var videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0);
+        var maxMTU = this.ipVersion === "ipv6" ? 1228 : 1378; // default values ipv4: 1378 bytes; ipv6: 1228 bytes
         if (videoRTPParameters[5 /* VideoRTPParametersTypes.MAX_MTU */]) {
             maxMTU = videoRTPParameters[5 /* VideoRTPParametersTypes.MAX_MTU */].readUInt16LE(0);
         }
         // selected audio configuration
-        const audioCodec = audioConfiguration[1 /* SelectedAudioParametersTypes.CODEC_TYPE */][0];
-        const audioParametersTLV = audioConfiguration[2 /* SelectedAudioParametersTypes.CODEC_PARAMETERS */];
-        const audioRTPParametersTLV = audioConfiguration[3 /* SelectedAudioParametersTypes.RTP_PARAMETERS */];
-        const comfortNoise = !!audioConfiguration[4 /* SelectedAudioParametersTypes.COMFORT_NOISE */].readUInt8(0);
+        var audioCodec = audioConfiguration[1 /* SelectedAudioParametersTypes.CODEC_TYPE */][0];
+        var audioParametersTLV = audioConfiguration[2 /* SelectedAudioParametersTypes.CODEC_PARAMETERS */];
+        var audioRTPParametersTLV = audioConfiguration[3 /* SelectedAudioParametersTypes.RTP_PARAMETERS */];
+        var comfortNoise = !!audioConfiguration[4 /* SelectedAudioParametersTypes.COMFORT_NOISE */].readUInt8(0);
         // audio parameters
-        const audioParameters = tlv.decode(audioParametersTLV);
-        const channels = audioParameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
-        const audioBitrate = audioParameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
-        const samplerate = audioParameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
-        const rtpPacketTime = audioParameters[4 /* AudioCodecParametersTypes.PACKET_TIME */].readUInt8(0);
+        var audioParameters = tlv.decode(audioParametersTLV);
+        var channels = audioParameters[1 /* AudioCodecParametersTypes.CHANNEL */][0];
+        var audioBitrate = audioParameters[2 /* AudioCodecParametersTypes.BIT_RATE */][0];
+        var samplerate = audioParameters[3 /* AudioCodecParametersTypes.SAMPLE_RATE */][0];
+        var rtpPacketTime = audioParameters[4 /* AudioCodecParametersTypes.PACKET_TIME */].readUInt8(0);
         // audio rtp parameters
-        const audioRTPParameters = tlv.decode(audioRTPParametersTLV);
-        const audioPayloadType = audioRTPParameters[1 /* AudioRTPParametersTypes.PAYLOAD_TYPE */].readUInt8(0); // 110
-        const audioSSRC = audioRTPParameters[2 /* AudioRTPParametersTypes.SYNCHRONIZATION_SOURCE */].readUInt32LE(0);
-        const audioMaximumBitrate = audioRTPParameters[3 /* AudioRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
-        const audioRTCPInterval = audioRTPParameters[4 /* AudioRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0);
-        const comfortNoisePayloadType = audioRTPParameters[6 /* AudioRTPParametersTypes.COMFORT_NOISE_PAYLOAD_TYPE */].readUInt8(0); // 13
+        var audioRTPParameters = tlv.decode(audioRTPParametersTLV);
+        var audioPayloadType = audioRTPParameters[1 /* AudioRTPParametersTypes.PAYLOAD_TYPE */].readUInt8(0); // 110
+        var audioSSRC = audioRTPParameters[2 /* AudioRTPParametersTypes.SYNCHRONIZATION_SOURCE */].readUInt32LE(0);
+        var audioMaximumBitrate = audioRTPParameters[3 /* AudioRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
+        var audioRTCPInterval = audioRTPParameters[4 /* AudioRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0);
+        var comfortNoisePayloadType = audioRTPParameters[6 /* AudioRTPParametersTypes.COMFORT_NOISE_PAYLOAD_TYPE */].readUInt8(0); // 13
         if (this.requireProxy) {
             this.videoProxy.setOutgoingPayloadType(videoPayloadType);
             if (!this.disableAudioProxy) {
                 this.audioProxy.setOutgoingPayloadType(audioPayloadType);
             }
         }
-        const videoInfo = {
+        var videoInfo = {
             codec: videoCodec.readUInt8(0),
             profile: h264Profile,
             level: h264Level,
@@ -587,8 +544,8 @@ class RTPStreamManagement {
             rtcp_interval: videoRTCPInterval,
             mtu: maxMTU,
         };
-        let audioCodecName;
-        let samplerateNum;
+        var audioCodecName;
+        var samplerateNum;
         switch (audioCodec) {
             case 0 /* AudioCodecTypes.PCMU */:
                 audioCodecName = "PCMU" /* AudioStreamingCodecType.PCMU */;
@@ -612,7 +569,7 @@ class RTPStreamManagement {
                 audioCodecName = "AMR-WB" /* AudioStreamingCodecType.AMR_WB */;
                 break;
             default:
-                throw new Error(`Encountered unknown selected audio codec ${audioCodec}`);
+                throw new Error("Encountered unknown selected audio codec ".concat(audioCodec));
         }
         switch (samplerate) {
             case 0 /* AudioSamplerate.KHZ_8 */:
@@ -625,9 +582,9 @@ class RTPStreamManagement {
                 samplerateNum = 24;
                 break;
             default:
-                throw new Error(`Encountered unknown selected audio samplerate ${samplerate}`);
+                throw new Error("Encountered unknown selected audio samplerate ".concat(samplerate));
         }
-        const audioInfo = {
+        var audioInfo = {
             codec: audioCodecName,
             channel: channels,
             bit_rate: audioBitrate,
@@ -640,57 +597,58 @@ class RTPStreamManagement {
             comfort_pt: comfortNoisePayloadType,
             comfortNoiseEnabled: comfortNoise,
         };
-        const request = {
+        var request = {
             sessionID: this.sessionIdentifier,
             type: "start" /* StreamRequestTypes.START */,
             video: videoInfo,
             audio: audioInfo,
         };
-        this.delegate.handleStreamRequest(request, error => callback(error));
-    }
-    handleReconfigureStream(videoConfiguration, callback) {
+        this.delegate.handleStreamRequest(request, function (error) { return callback(error); });
+    };
+    RTPStreamManagement.prototype.handleReconfigureStream = function (videoConfiguration, callback) {
         // selected video configuration
-        const videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
-        const videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
+        var videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
+        var videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
         // video attributes
-        const videoAttributes = tlv.decode(videoAttributesTLV);
-        const width = videoAttributes[1 /* VideoAttributesTypes.IMAGE_WIDTH */].readUInt16LE(0);
-        const height = videoAttributes[2 /* VideoAttributesTypes.IMAGE_HEIGHT */].readUInt16LE(0);
-        const frameRate = videoAttributes[3 /* VideoAttributesTypes.FRAME_RATE */].readUInt8(0);
+        var videoAttributes = tlv.decode(videoAttributesTLV);
+        var width = videoAttributes[1 /* VideoAttributesTypes.IMAGE_WIDTH */].readUInt16LE(0);
+        var height = videoAttributes[2 /* VideoAttributesTypes.IMAGE_HEIGHT */].readUInt16LE(0);
+        var frameRate = videoAttributes[3 /* VideoAttributesTypes.FRAME_RATE */].readUInt8(0);
         // video rtp parameters
-        const videoRTPParameters = tlv.decode(videoRTPParametersTLV);
-        const videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
+        var videoRTPParameters = tlv.decode(videoRTPParametersTLV);
+        var videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
         // seems to be always zero, use default of 0.5
-        const videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0) || 0.5;
-        const reconfiguredVideoInfo = {
+        var videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0) || 0.5;
+        var reconfiguredVideoInfo = {
             width: width,
             height: height,
             fps: frameRate,
             max_bit_rate: videoMaximumBitrate,
             rtcp_interval: videoRTCPInterval,
         };
-        const request = {
+        var request = {
             sessionID: this.sessionIdentifier,
             type: "reconfigure" /* StreamRequestTypes.RECONFIGURE */,
             video: reconfiguredVideoInfo,
         };
-        this.delegate.handleStreamRequest(request, error => callback(error));
-    }
-    _handleStopStream(callback) {
-        const request = {
+        this.delegate.handleStreamRequest(request, function (error) { return callback(error); });
+    };
+    RTPStreamManagement.prototype._handleStopStream = function (callback) {
+        var request = {
             sessionID: this.sessionIdentifier, // save sessionIdentifier before handleSessionClosed is called
             type: "stop" /* StreamRequestTypes.STOP */,
         };
         this.handleSessionClosed();
-        this.delegate.handleStreamRequest(request, error => callback ? callback(error) : undefined);
-    }
-    handleSetupEndpoints(value, callback, connection) {
+        this.delegate.handleStreamRequest(request, function (error) { return callback ? callback(error) : undefined; });
+    };
+    RTPStreamManagement.prototype.handleSetupEndpoints = function (value, callback, connection) {
+        var _this = this;
         if (this.streamingIsDisabled(callback)) {
             return;
         }
-        const data = Buffer.from(value, "base64");
-        const objects = tlv.decode(data);
-        const sessionIdentifier = uuid.unparse(objects[1 /* SetupEndpointsTypes.SESSION_ID */]);
+        var data = Buffer.from(value, "base64");
+        var objects = tlv.decode(data);
+        var sessionIdentifier = uuid.unparse(objects[1 /* SetupEndpointsTypes.SESSION_ID */]);
         if (this.streamStatus !== 0 /* StreamingStatus.AVAILABLE */) {
             this.setupEndpointsResponse = tlv.encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, uuid.write(sessionIdentifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 1 /* SetupEndpointsStatus.BUSY */).toString("base64");
             callback();
@@ -698,33 +656,32 @@ class RTPStreamManagement {
         }
         (0, assert_1.default)(this.activeConnection == null, "Found non-nil `activeConnection` when trying to setup streaming endpoints, even though streamStatus is reported to be AVAILABLE!");
         this.activeConnection = connection;
-        this.activeConnection.setMaxListeners(this.activeConnection.getMaxListeners() + 1);
         this.activeConnection.on("closed" /* HAPConnectionEvent.CLOSED */, this.activeConnectionClosedListener);
         // noinspection JSDeprecatedSymbols
         this.connectionID = connection.sessionID;
         this.sessionIdentifier = sessionIdentifier;
         this._updateStreamStatus(1 /* StreamingStatus.IN_USE */);
         // Address
-        const targetAddressPayload = objects[3 /* SetupEndpointsTypes.CONTROLLER_ADDRESS */];
-        const processedAddressInfo = tlv.decode(targetAddressPayload);
-        const addressVersion = processedAddressInfo[1 /* AddressTypes.ADDRESS_VERSION */][0];
-        const controllerAddress = processedAddressInfo[2 /* AddressTypes.ADDRESS */].toString("utf8");
-        const targetVideoPort = processedAddressInfo[3 /* AddressTypes.VIDEO_RTP_PORT */].readUInt16LE(0);
-        const targetAudioPort = processedAddressInfo[4 /* AddressTypes.AUDIO_RTP_PORT */].readUInt16LE(0);
+        var targetAddressPayload = objects[3 /* SetupEndpointsTypes.CONTROLLER_ADDRESS */];
+        var processedAddressInfo = tlv.decode(targetAddressPayload);
+        var addressVersion = processedAddressInfo[1 /* AddressTypes.ADDRESS_VERSION */][0];
+        var controllerAddress = processedAddressInfo[2 /* AddressTypes.ADDRESS */].toString("utf8");
+        var targetVideoPort = processedAddressInfo[3 /* AddressTypes.VIDEO_RTP_PORT */].readUInt16LE(0);
+        var targetAudioPort = processedAddressInfo[4 /* AddressTypes.AUDIO_RTP_PORT */].readUInt16LE(0);
         // Video SRTP Params
-        const videoSRTPPayload = objects[4 /* SetupEndpointsTypes.VIDEO_SRTP_PARAMETERS */];
-        const processedVideoInfo = tlv.decode(videoSRTPPayload);
-        const videoCryptoSuite = processedVideoInfo[1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */][0];
-        const videoMasterKey = processedVideoInfo[2 /* SRTPParametersTypes.MASTER_KEY */];
-        const videoMasterSalt = processedVideoInfo[3 /* SRTPParametersTypes.MASTER_SALT */];
+        var videoSRTPPayload = objects[4 /* SetupEndpointsTypes.VIDEO_SRTP_PARAMETERS */];
+        var processedVideoInfo = tlv.decode(videoSRTPPayload);
+        var videoCryptoSuite = processedVideoInfo[1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */][0];
+        var videoMasterKey = processedVideoInfo[2 /* SRTPParametersTypes.MASTER_KEY */];
+        var videoMasterSalt = processedVideoInfo[3 /* SRTPParametersTypes.MASTER_SALT */];
         // Audio SRTP Params
-        const audioSRTPPayload = objects[5 /* SetupEndpointsTypes.AUDIO_SRTP_PARAMETERS */];
-        const processedAudioInfo = tlv.decode(audioSRTPPayload);
-        const audioCryptoSuite = processedAudioInfo[1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */][0];
-        const audioMasterKey = processedAudioInfo[2 /* SRTPParametersTypes.MASTER_KEY */];
-        const audioMasterSalt = processedAudioInfo[3 /* SRTPParametersTypes.MASTER_SALT */];
+        var audioSRTPPayload = objects[5 /* SetupEndpointsTypes.AUDIO_SRTP_PARAMETERS */];
+        var processedAudioInfo = tlv.decode(audioSRTPPayload);
+        var audioCryptoSuite = processedAudioInfo[1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */][0];
+        var audioMasterKey = processedAudioInfo[2 /* SRTPParametersTypes.MASTER_KEY */];
+        var audioMasterSalt = processedAudioInfo[3 /* SRTPParametersTypes.MASTER_SALT */];
         debug("Session: ", sessionIdentifier, "\nControllerAddress: ", controllerAddress, "\nVideoPort: ", targetVideoPort, "\nAudioPort: ", targetAudioPort, "\nVideo Crypto: ", videoCryptoSuite, "\nVideo Master Key: ", videoMasterKey, "\nVideo Master Salt: ", videoMasterSalt, "\nAudio Crypto: ", audioCryptoSuite, "\nAudio Master Key: ", audioMasterKey, "\nAudio Master Salt: ", audioMasterSalt);
-        const prepareRequest = {
+        var prepareRequest = {
             sessionID: sessionIdentifier,
             sourceAddress: connection.localAddress,
             targetAddress: controllerAddress,
@@ -742,7 +699,7 @@ class RTPStreamManagement {
                 srtp_salt: audioMasterSalt,
             },
         };
-        const promises = [];
+        var promises = [];
         if (this.requireProxy) {
             prepareRequest.targetAddress = connection.getLocalAddress(addressVersion === 1 /* IPAddressVersion.IPV6 */ ? "ipv6" : "ipv4"); // ip versions must be the same
             this.videoProxy = new RTPProxy_1.default({
@@ -751,9 +708,9 @@ class RTPStreamManagement {
                 outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // videoSSRC
                 disabled: false,
             });
-            promises.push(this.videoProxy.setup().then(() => {
-                prepareRequest.video.proxy_rtp = this.videoProxy.incomingRTPPort();
-                prepareRequest.video.proxy_rtcp = this.videoProxy.incomingRTCPPort();
+            promises.push(this.videoProxy.setup().then(function () {
+                prepareRequest.video.proxy_rtp = _this.videoProxy.incomingRTPPort();
+                prepareRequest.video.proxy_rtcp = _this.videoProxy.incomingRTCPPort();
             }));
             if (!this.disableAudioProxy) {
                 this.audioProxy = new RTPProxy_1.default({
@@ -762,52 +719,52 @@ class RTPStreamManagement {
                     outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // audioSSRC
                     disabled: this.videoOnly,
                 });
-                promises.push(this.audioProxy.setup().then(() => {
-                    prepareRequest.audio.proxy_rtp = this.audioProxy.incomingRTPPort();
-                    prepareRequest.audio.proxy_rtcp = this.audioProxy.incomingRTCPPort();
+                promises.push(this.audioProxy.setup().then(function () {
+                    prepareRequest.audio.proxy_rtp = _this.audioProxy.incomingRTPPort();
+                    prepareRequest.audio.proxy_rtcp = _this.audioProxy.incomingRTCPPort();
                 }));
             }
         }
-        Promise.all(promises).then(() => {
-            this.delegate.prepareStream(prepareRequest, (0, once_1.once)((error, response) => {
+        Promise.all(promises).then(function () {
+            _this.delegate.prepareStream(prepareRequest, (0, once_1.once)(function (error, response) {
                 if (error || !response) {
-                    debug(`PrepareStream request encountered an error: ${error ? error.message : undefined}`);
-                    this.setupEndpointsResponse = tlv.encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, uuid.write(sessionIdentifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64");
-                    this.handleSessionClosed();
+                    debug("PrepareStream request encountered an error: ".concat(error ? error.message : undefined));
+                    _this.setupEndpointsResponse = tlv.encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, uuid.write(sessionIdentifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64");
+                    _this.handleSessionClosed();
                     callback(error);
                 }
                 else {
-                    this.generateSetupEndpointResponse(connection, sessionIdentifier, prepareRequest, response, callback);
+                    _this.generateSetupEndpointResponse(connection, sessionIdentifier, prepareRequest, response, callback);
                 }
             }));
         });
-    }
-    generateSetupEndpointResponse(connection, identifier, request, response, callback) {
-        let address;
-        let addressVersion = request.addressVersion;
-        let videoPort;
-        let audioPort;
-        let videoCryptoSuite;
-        let videoSRTPKey;
-        let videoSRTPSalt;
-        let audioCryptoSuite;
-        let audioSRTPKey;
-        let audioSRTPSalt;
-        let videoSSRC;
-        let audioSSRC;
+    };
+    RTPStreamManagement.prototype.generateSetupEndpointResponse = function (connection, identifier, request, response, callback) {
+        var address;
+        var addressVersion = request.addressVersion;
+        var videoPort;
+        var audioPort;
+        var videoCryptoSuite;
+        var videoSRTPKey;
+        var videoSRTPSalt;
+        var audioCryptoSuite;
+        var audioSRTPKey;
+        var audioSRTPSalt;
+        var videoSSRC;
+        var audioSSRC;
         if (!this.videoOnly && !response.audio) {
             throw new Error("Audio was enabled but not supplied in PrepareStreamResponse!");
         }
         // Provide default values if audio was not supplied
-        const audio = response.audio || {
+        var audio = response.audio || {
             port: request.audio.port,
             ssrc: controller_1.CameraController.generateSynchronisationSource(),
             srtp_key: request.audio.srtp_key,
             srtp_salt: request.audio.srtp_salt,
         };
         if (!this.requireProxy) {
-            const videoInfo = response.video;
-            const audioInfo = audio;
+            var videoInfo = response.video;
+            var audioInfo = audio;
             if (response.addressOverride) {
                 addressVersion = net_1.default.isIPv4(response.addressOverride) ? "ipv4" : "ipv6";
                 address = response.addressOverride;
@@ -816,7 +773,7 @@ class RTPStreamManagement {
                 address = connection.getLocalAddress(addressVersion);
             }
             if (request.addressVersion !== addressVersion) {
-                throw new Error(`Incoming and outgoing ip address versions must match! Expected ${request.addressVersion} but got ${addressVersion}`);
+                throw new Error("Incoming and outgoing ip address versions must match! Expected ".concat(request.addressVersion, " but got ").concat(addressVersion));
             }
             videoPort = videoInfo.port;
             audioPort = audioInfo.port;
@@ -838,7 +795,7 @@ class RTPStreamManagement {
             audioSSRC = audioInfo.ssrc;
         }
         else {
-            const videoInfo = response.video;
+            var videoInfo = response.video;
             address = connection.getLocalAddress(request.addressVersion);
             videoCryptoSuite = 2 /* SRTPCryptoSuites.NONE */;
             videoSRTPKey = Buffer.alloc(0);
@@ -853,7 +810,7 @@ class RTPStreamManagement {
             videoPort = this.videoProxy.outgoingLocalPort();
             videoSSRC = this.videoProxy.outgoingSSRC;
             if (!this.disableAudioProxy) {
-                const audioInfo = response.audio;
+                var audioInfo = response.audio;
                 this.audioProxy.setIncomingPayloadType(audioInfo.proxy_pt);
                 this.audioProxy.setServerAddress(audioInfo.proxy_server_address);
                 this.audioProxy.setServerRTPPort(audioInfo.proxy_server_rtp);
@@ -862,66 +819,66 @@ class RTPStreamManagement {
                 audioSSRC = this.audioProxy.outgoingSSRC;
             }
             else {
-                const audioInfo = response.audio;
+                var audioInfo = response.audio;
                 audioPort = audioInfo.port;
                 audioSSRC = audioInfo.ssrc;
             }
         }
         this.ipVersion = addressVersion; // we need to save this in order to calculate some default mtu values later
-        const accessoryAddress = tlv.encode(1 /* AddressTypes.ADDRESS_VERSION */, addressVersion === "ipv4" ? 0 /* IPAddressVersion.IPV4 */ : 1 /* IPAddressVersion.IPV6 */, 2 /* AddressTypes.ADDRESS */, address, 3 /* AddressTypes.VIDEO_RTP_PORT */, tlv.writeUInt16(videoPort), 4 /* AddressTypes.AUDIO_RTP_PORT */, tlv.writeUInt16(audioPort));
-        const videoSRTPParameters = tlv.encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, videoCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, videoSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, videoSRTPSalt);
-        const audioSRTPParameters = tlv.encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, audioCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, audioSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, audioSRTPSalt);
+        var accessoryAddress = tlv.encode(1 /* AddressTypes.ADDRESS_VERSION */, addressVersion === "ipv4" ? 0 /* IPAddressVersion.IPV4 */ : 1 /* IPAddressVersion.IPV6 */, 2 /* AddressTypes.ADDRESS */, address, 3 /* AddressTypes.VIDEO_RTP_PORT */, tlv.writeUInt16(videoPort), 4 /* AddressTypes.AUDIO_RTP_PORT */, tlv.writeUInt16(audioPort));
+        var videoSRTPParameters = tlv.encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, videoCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, videoSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, videoSRTPSalt);
+        var audioSRTPParameters = tlv.encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, audioCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, audioSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, audioSRTPSalt);
         this.setupEndpointsResponse = tlv.encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, uuid.write(identifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 0 /* SetupEndpointsStatus.SUCCESS */, 3 /* SetupEndpointsResponseTypes.ACCESSORY_ADDRESS */, accessoryAddress, 4 /* SetupEndpointsResponseTypes.VIDEO_SRTP_PARAMETERS */, videoSRTPParameters, 5 /* SetupEndpointsResponseTypes.AUDIO_SRTP_PARAMETERS */, audioSRTPParameters, 6 /* SetupEndpointsResponseTypes.VIDEO_SSRC */, tlv.writeUInt32(videoSSRC), 7 /* SetupEndpointsResponseTypes.AUDIO_SSRC */, tlv.writeUInt32(audioSSRC)).toString("base64");
         callback();
-    }
-    _updateStreamStatus(status) {
+    };
+    RTPStreamManagement.prototype._updateStreamStatus = function (status) {
         this.streamStatus = status;
         this.service.updateCharacteristic(Characteristic_1.Characteristic.StreamingStatus, tlv.encode(1 /* StreamingStatusTypes.STATUS */, this.streamStatus).toString("base64"));
-    }
-    static _supportedRTPConfiguration(supportedCryptoSuites) {
+    };
+    RTPStreamManagement._supportedRTPConfiguration = function (supportedCryptoSuites) {
         if (supportedCryptoSuites.length === 1 && supportedCryptoSuites[0] === 2 /* SRTPCryptoSuites.NONE */) {
             debug("Client claims it doesn't support SRTP. The stream may stops working with future iOS releases.");
         }
         return tlv.encode(2 /* SupportedRTPConfigurationTypes.SRTP_CRYPTO_SUITE */, supportedCryptoSuites).toString("base64");
-    }
-    static _supportedVideoStreamConfiguration(videoOptions) {
+    };
+    RTPStreamManagement._supportedVideoStreamConfiguration = function (videoOptions) {
         if (!videoOptions.codec) {
             throw new Error("Video codec cannot be undefined");
         }
         if (!videoOptions.resolutions) {
             throw new Error("Video resolutions cannot be undefined");
         }
-        let codecParameters = tlv.encode(1 /* VideoCodecParametersTypes.PROFILE_ID */, videoOptions.codec.profiles, 2 /* VideoCodecParametersTypes.LEVEL */, videoOptions.codec.levels, 3 /* VideoCodecParametersTypes.PACKETIZATION_MODE */, 0 /* VideoCodecPacketizationMode.NON_INTERLEAVED */);
+        var codecParameters = tlv.encode(1 /* VideoCodecParametersTypes.PROFILE_ID */, videoOptions.codec.profiles, 2 /* VideoCodecParametersTypes.LEVEL */, videoOptions.codec.levels, 3 /* VideoCodecParametersTypes.PACKETIZATION_MODE */, 0 /* VideoCodecPacketizationMode.NON_INTERLEAVED */);
         if (videoOptions.cvoId != null) {
             codecParameters = Buffer.concat([
                 codecParameters,
                 tlv.encode(4 /* VideoCodecParametersTypes.CVO_ENABLED */, 1 /* VideoCodecCVO.SUPPORTED */, 5 /* VideoCodecParametersTypes.CVO_ID */, videoOptions.cvoId),
             ]);
         }
-        const videoStreamConfiguration = tlv.encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, 0 /* VideoCodecType.H264 */, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map(resolution => {
+        var videoStreamConfiguration = tlv.encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, 0 /* VideoCodecType.H264 */, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map(function (resolution) {
             if (resolution.length !== 3) {
                 throw new Error("Unexpected video resolution");
             }
-            const width = Buffer.alloc(2);
-            const height = Buffer.alloc(2);
-            const frameRate = Buffer.alloc(1);
+            var width = Buffer.alloc(2);
+            var height = Buffer.alloc(2);
+            var frameRate = Buffer.alloc(1);
             width.writeUInt16LE(resolution[0], 0);
             height.writeUInt16LE(resolution[1], 0);
             frameRate.writeUInt8(resolution[2], 0);
             return tlv.encode(1 /* VideoAttributesTypes.IMAGE_WIDTH */, width, 2 /* VideoAttributesTypes.IMAGE_HEIGHT */, height, 3 /* VideoAttributesTypes.FRAME_RATE */, frameRate);
         }));
         return tlv.encode(1 /* SupportedVideoStreamConfigurationTypes.VIDEO_CODEC_CONFIGURATION */, videoStreamConfiguration).toString("base64");
-    }
-    checkForLegacyAudioCodecRepresentation(codecs) {
-        const codecMap = {};
-        codecs.slice().forEach(codec => {
-            const previous = codecMap[codec.type];
+    };
+    RTPStreamManagement.prototype.checkForLegacyAudioCodecRepresentation = function (codecs) {
+        var codecMap = {};
+        codecs.slice().forEach(function (codec) {
+            var previous = codecMap[codec.type];
             if (previous) {
                 if (typeof previous.samplerate === "number") {
                     previous.samplerate = [previous.samplerate];
                 }
                 previous.samplerate = previous.samplerate.concat(codec.samplerate);
-                const index = codecs.indexOf(codec);
+                var index = codecs.indexOf(codec);
                 if (index >= 0) {
                     codecs.splice(index, 1);
                 }
@@ -930,12 +887,12 @@ class RTPStreamManagement {
                 codecMap[codec.type] = codec;
             }
         });
-    }
-    _supportedAudioStreamConfiguration(audioOptions) {
+    };
+    RTPStreamManagement.prototype._supportedAudioStreamConfiguration = function (audioOptions) {
         // Only AAC-ELD and OPUS are accepted by iOS currently, and we need to give it something it will accept
         // for it to start the video stream.
-        const comfortNoise = audioOptions && !!audioOptions.comfort_noise;
-        const supportedCodecs = (audioOptions && audioOptions.codecs) || [];
+        var comfortNoise = audioOptions && !!audioOptions.comfort_noise;
+        var supportedCodecs = (audioOptions && audioOptions.codecs) || [];
         this.checkForLegacyAudioCodecRepresentation(supportedCodecs);
         if (supportedCodecs.length === 0) { // Fake a Codec if we haven't got anything
             debug("Client doesn't support any audio codec that HomeKit supports.");
@@ -945,8 +902,8 @@ class RTPStreamManagement {
                 samplerate: [16 /* AudioStreamingSamplerate.KHZ_16 */, 24 /* AudioStreamingSamplerate.KHZ_24 */], // 16 and 24 must be supported
             });
         }
-        const codecConfigurations = supportedCodecs.map(codec => {
-            let type;
+        var codecConfigurations = supportedCodecs.map(function (codec) {
+            var type;
             switch (codec.type) {
                 case "OPUS" /* AudioStreamingCodecType.OPUS */:
                     type = 3 /* AudioCodecTypes.OPUS */;
@@ -972,8 +929,8 @@ class RTPStreamManagement {
                 default:
                     throw new Error("Unsupported codec: " + codec.type);
             }
-            const providedSamplerates = (typeof codec.samplerate === "number" ? [codec.samplerate] : codec.samplerate).map(rate => {
-                let samplerate;
+            var providedSamplerates = (typeof codec.samplerate === "number" ? [codec.samplerate] : codec.samplerate).map(function (rate) {
+                var samplerate;
                 switch (rate) {
                     case 8 /* AudioStreamingSamplerate.KHZ_8 */:
                         samplerate = 0 /* AudioSamplerate.KHZ_8 */;
@@ -989,28 +946,28 @@ class RTPStreamManagement {
                         samplerate = -1;
                 }
                 return samplerate;
-            }).filter(rate => rate !== -1);
+            }).filter(function (rate) { return rate !== -1; });
             if (providedSamplerates.length === 0) {
                 throw new Error("Audio samplerate cannot be empty!");
             }
-            const audioParameters = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, Math.max(1, codec.audioChannels || 1), 2 /* AudioCodecParametersTypes.BIT_RATE */, codec.bitrate || 0 /* AudioBitrate.VARIABLE */, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, providedSamplerates);
+            var audioParameters = tlv.encode(1 /* AudioCodecParametersTypes.CHANNEL */, Math.max(1, codec.audioChannels || 1), 2 /* AudioCodecParametersTypes.BIT_RATE */, codec.bitrate || 0 /* AudioBitrate.VARIABLE */, 3 /* AudioCodecParametersTypes.SAMPLE_RATE */, providedSamplerates);
             return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, type, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, audioParameters);
         });
         return tlv.encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurations, 2 /* SupportedAudioStreamConfigurationTypes.COMFORT_NOISE_SUPPORT */, comfortNoise ? 1 : 0).toString("base64");
-    }
-    resetSetupEndpointsResponse() {
+    };
+    RTPStreamManagement.prototype.resetSetupEndpointsResponse = function () {
         this.setupEndpointsResponse = tlv.encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64");
         this.service.updateCharacteristic(Characteristic_1.Characteristic.SetupEndpoints, this.setupEndpointsResponse);
-    }
-    resetSelectedStreamConfiguration() {
+    };
+    RTPStreamManagement.prototype.resetSelectedStreamConfiguration = function () {
         this.selectedConfiguration = tlv.encode(1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */, tlv.encode(2 /* SessionControlTypes.COMMAND */, SessionControlCommand.SUSPEND_SESSION)).toString("base64");
         this.service.updateCharacteristic(Characteristic_1.Characteristic.SelectedRTPStreamConfiguration, this.selectedConfiguration);
-    }
+    };
     /**
      * @private
      */
-    serialize() {
-        const characteristicValue = this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value;
+    RTPStreamManagement.prototype.serialize = function () {
+        var characteristicValue = this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value;
         if (characteristicValue === true) {
             return undefined;
         }
@@ -1018,36 +975,50 @@ class RTPStreamManagement {
             id: this.id,
             active: !!characteristicValue,
         };
-    }
+    };
     /**
      * @private
      */
-    deserialize(serialized) {
-        (0, assert_1.default)(serialized.id === this.id, `Tried to initialize RTPStreamManagement ${this.id} with data from management with id ${serialized.id}!`);
+    RTPStreamManagement.prototype.deserialize = function (serialized) {
+        (0, assert_1.default)(serialized.id === this.id, "Tried to initialize RTPStreamManagement ".concat(this.id, " with data from management with id ").concat(serialized.id, "!"));
         this.service.updateCharacteristic(Characteristic_1.Characteristic.Active, serialized.active);
-    }
+    };
     /**
      * @private
      */
-    setupStateChangeDelegate(delegate) {
+    RTPStreamManagement.prototype.setupStateChangeDelegate = function (delegate) {
         this.stateChangeDelegate = delegate;
-    }
-}
+    };
+    /**
+     * @deprecated Please use the SRTPCryptoSuites const enum above.
+     */
+    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+    RTPStreamManagement.SRTPCryptoSuites = SRTPCryptoSuites;
+    /**
+     * @deprecated Please use the H264Profile const enum above.
+     */
+    // @ts-expect-error: forceConsistentCasingInFileNames compiler option
+    RTPStreamManagement.VideoCodecParamProfileIDTypes = H264Profile;
+    /**
+     * @deprecated won't be updated anymore. Please use the H264Level const enum above.
+     */
+    RTPStreamManagement.VideoCodecParamLevelTypes = Object.freeze({ TYPE3_1: 0, TYPE3_2: 1, TYPE4_0: 2 });
+    return RTPStreamManagement;
+}());
 exports.RTPStreamManagement = RTPStreamManagement;
 /**
  * @group Camera
  * @deprecated - only there for backwards compatibility, please use {@link RTPStreamManagement} directly
  */
-class StreamController extends RTPStreamManagement {
-    /**
-     *  options get saved so we can still support {@link Accessory.configureCameraSource}
-     */
-    options;
+var StreamController = /** @class */ (function (_super) {
+    tslib_1.__extends(StreamController, _super);
     // noinspection JSDeprecatedSymbols
-    constructor(id, options, delegate, service) {
-        super(id, options, new Camera_1.LegacyCameraSourceAdapter(delegate), service);
-        this.options = options;
+    function StreamController(id, options, delegate, service) {
+        var _this = _super.call(this, id, options, new Camera_1.LegacyCameraSourceAdapter(delegate), service) || this;
+        _this.options = options;
+        return _this;
     }
-}
+    return StreamController;
+}(RTPStreamManagement));
 exports.StreamController = StreamController;
 //# sourceMappingURL=RTPStreamManagement.js.map