hap-nodejs 0.12.3-beta.11 → 0.12.3-beta.13

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;
-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"));
+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"));
 // noinspection JSDeprecatedSymbols
-var Camera_1 = require("./Camera");
-var RTPProxy_1 = tslib_1.__importDefault(require("./RTPProxy"));
-var debug = (0, debug_1.default)("HAP-NodeJS:Camera:RTPStreamManagement");
+const Camera_1 = require("./Camera");
+const RTPProxy_1 = tslib_1.__importDefault(require("./RTPProxy"));
+const debug = (0, debug_1.default)("HAP-NodeJS:Camera:RTPStreamManagement");
 // ---------------------------------- TLV DEFINITIONS START ----------------------------------
 var StreamingStatusTypes;
 (function (StreamingStatusTypes) {
@@ -283,16 +283,61 @@ var StreamRequestTypes;
 /**
  * @group Camera
  */
-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
+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) {
         this.id = id;
         this.delegate = delegate;
         this.requireProxy = options.proxy || false;
@@ -319,48 +364,47 @@ var RTPStreamManagement = /** @class */ (function () {
         this.resetSelectedStreamConfiguration();
         this.disabledThroughOperatingMode = disabledThroughOperatingMode;
     }
-    RTPStreamManagement.prototype.forceStop = function () {
+    forceStop() {
         this.handleSessionClosed();
-    };
-    RTPStreamManagement.prototype.getService = function () {
+    }
+    getService() {
         return this.service;
-    };
+    }
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
     /**
      * @deprecated
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    RTPStreamManagement.prototype.handleCloseConnection = function (connectionID) {
+    handleCloseConnection(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.
-    };
-    RTPStreamManagement.prototype.handleFactoryReset = function () {
+    }
+    handleFactoryReset() {
         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
-    };
-    RTPStreamManagement.prototype.destroy = function () {
+    }
+    destroy() {
         if (this.activeConnection) {
             this._handleStopStream();
         }
-    };
-    RTPStreamManagement.prototype.constructService = function (id) {
-        var managementService = new Service_1.Service.CameraRTPStreamManagement("", id.toString());
+    }
+    constructService(id) {
+        const 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;
-    };
-    RTPStreamManagement.prototype.setupServiceHandlers = function () {
-        var _this = this;
+    }
+    setupServiceHandlers() {
         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 */, function () { var _a; return (_a = _this.stateChangeDelegate) === null || _a === void 0 ? void 0 : _a.call(_this); })
+            .on("change" /* CharacteristicEventTypes.CHANGE */, () => this.stateChangeDelegate?.())
             .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);
@@ -369,32 +413,32 @@ var RTPStreamManagement = /** @class */ (function () {
         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 */, function (callback) {
-            if (_this.streamingIsDisabled()) {
+            .on("get" /* CharacteristicEventTypes.GET */, 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 */, function (callback) {
-            if (_this.streamingIsDisabled()) {
+            .on("get" /* CharacteristicEventTypes.GET */, 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 */, function (value, callback, context, connection) {
+            .on("set" /* CharacteristicEventTypes.SET */, (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);
         });
-    };
-    RTPStreamManagement.prototype.handleSessionClosed = function () {
+    }
+    handleSessionClosed() {
         this.resetSelectedStreamConfiguration();
         this.resetSetupEndpointsResponse();
         if (this.activeConnection) {
@@ -415,51 +459,49 @@ var RTPStreamManagement = /** @class */ (function () {
             this.audioProxy.destroy();
             this.audioProxy = undefined;
         }
-    };
-    RTPStreamManagement.prototype.streamingIsDisabled = function (callback) {
-        var _a;
+    }
+    streamingIsDisabled(callback) {
         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 ((_a = this.disabledThroughOperatingMode) === null || _a === void 0 ? void 0 : _a.call(this)) {
+        if (this.disabledThroughOperatingMode?.()) {
             callback && callback(new hapStatusError_1.HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
             return true;
         }
         return false;
-    };
-    RTPStreamManagement.prototype._handleSelectedStreamConfigurationWrite = function (value, callback) {
-        var _this = this;
+    }
+    _handleSelectedStreamConfigurationWrite(value, callback) {
         if (this.streamingIsDisabled(callback)) {
             return;
         }
-        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];
+        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];
         if (sessionIdentifier !== this.sessionIdentifier) {
-            debug("Received unknown session Identifier with request to ".concat(SessionControlCommand[requestType]));
+            debug(`Received unknown session Identifier with request to ${SessionControlCommand[requestType]}`);
             callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
             return;
         }
         this.selectedConfiguration = value;
         // intercept the callback chain to check if an error occurred.
-        var streamCallback = function (error, writeResponse) {
+        const streamCallback = (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: {
-                var selectedVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
-                var selectedAudioParameters = tlv.decode(objects[3 /* SelectedRTPStreamConfigurationTypes.SELECTED_AUDIO_PARAMETERS */]);
+                const selectedVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
+                const selectedAudioParameters = tlv.decode(objects[3 /* SelectedRTPStreamConfigurationTypes.SELECTED_AUDIO_PARAMETERS */]);
                 this._handleStartStream(selectedVideoParameters, selectedAudioParameters, streamCallback);
                 break;
             }
             case SessionControlCommand.RECONFIGURE_SESSION: {
-                var reconfiguredVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
+                const reconfiguredVideoParameters = tlv.decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
                 this.handleReconfigureStream(reconfiguredVideoParameters, streamCallback);
                 break;
             }
@@ -469,68 +511,68 @@ var RTPStreamManagement = /** @class */ (function () {
             case SessionControlCommand.RESUME_SESSION:
             case SessionControlCommand.SUSPEND_SESSION:
             default:
-                debug("Unhandled request type ".concat(SessionControlCommand[requestType]));
+                debug(`Unhandled request type ${SessionControlCommand[requestType]}`);
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                 return;
         }
-    };
-    RTPStreamManagement.prototype._handleStartStream = function (videoConfiguration, audioConfiguration, callback) {
+    }
+    _handleStartStream(videoConfiguration, audioConfiguration, callback) {
         // selected video configuration
         // noinspection JSUnusedLocalSymbols
-        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 */];
+        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 */];
         // video parameters
-        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;
+        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;
         if (cvoEnabled && cvoEnabled[0] === 1 /* VideoCodecCVO.SUPPORTED */) {
             cvoId = videoParameters[5 /* VideoCodecParametersTypes.CVO_ID */].readUInt8(0);
         }
         // video attributes
-        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);
+        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);
         // video rtp parameters
-        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
+        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
         if (videoRTPParameters[5 /* VideoRTPParametersTypes.MAX_MTU */]) {
             maxMTU = videoRTPParameters[5 /* VideoRTPParametersTypes.MAX_MTU */].readUInt16LE(0);
         }
         // selected audio configuration
-        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);
+        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);
         // audio parameters
-        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);
+        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);
         // audio rtp parameters
-        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
+        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
         if (this.requireProxy) {
             this.videoProxy.setOutgoingPayloadType(videoPayloadType);
             if (!this.disableAudioProxy) {
                 this.audioProxy.setOutgoingPayloadType(audioPayloadType);
             }
         }
-        var videoInfo = {
+        const videoInfo = {
             codec: videoCodec.readUInt8(0),
             profile: h264Profile,
             level: h264Level,
@@ -545,8 +587,8 @@ var RTPStreamManagement = /** @class */ (function () {
             rtcp_interval: videoRTCPInterval,
             mtu: maxMTU,
         };
-        var audioCodecName;
-        var samplerateNum;
+        let audioCodecName;
+        let samplerateNum;
         switch (audioCodec) {
             case 0 /* AudioCodecTypes.PCMU */:
                 audioCodecName = "PCMU" /* AudioStreamingCodecType.PCMU */;
@@ -570,7 +612,7 @@ var RTPStreamManagement = /** @class */ (function () {
                 audioCodecName = "AMR-WB" /* AudioStreamingCodecType.AMR_WB */;
                 break;
             default:
-                throw new Error("Encountered unknown selected audio codec ".concat(audioCodec));
+                throw new Error(`Encountered unknown selected audio codec ${audioCodec}`);
         }
         switch (samplerate) {
             case 0 /* AudioSamplerate.KHZ_8 */:
@@ -583,9 +625,9 @@ var RTPStreamManagement = /** @class */ (function () {
                 samplerateNum = 24;
                 break;
             default:
-                throw new Error("Encountered unknown selected audio samplerate ".concat(samplerate));
+                throw new Error(`Encountered unknown selected audio samplerate ${samplerate}`);
         }
-        var audioInfo = {
+        const audioInfo = {
             codec: audioCodecName,
             channel: channels,
             bit_rate: audioBitrate,
@@ -598,58 +640,57 @@ var RTPStreamManagement = /** @class */ (function () {
             comfort_pt: comfortNoisePayloadType,
             comfortNoiseEnabled: comfortNoise,
         };
-        var request = {
+        const request = {
             sessionID: this.sessionIdentifier,
             type: "start" /* StreamRequestTypes.START */,
             video: videoInfo,
             audio: audioInfo,
         };
-        this.delegate.handleStreamRequest(request, function (error) { return callback(error); });
-    };
-    RTPStreamManagement.prototype.handleReconfigureStream = function (videoConfiguration, callback) {
+        this.delegate.handleStreamRequest(request, error => callback(error));
+    }
+    handleReconfigureStream(videoConfiguration, callback) {
         // selected video configuration
-        var videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
-        var videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
+        const videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
+        const videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
         // video attributes
-        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);
+        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);
         // video rtp parameters
-        var videoRTPParameters = tlv.decode(videoRTPParametersTLV);
-        var videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
+        const videoRTPParameters = tlv.decode(videoRTPParametersTLV);
+        const videoMaximumBitrate = videoRTPParameters[3 /* VideoRTPParametersTypes.MAX_BIT_RATE */].readUInt16LE(0);
         // seems to be always zero, use default of 0.5
-        var videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0) || 0.5;
-        var reconfiguredVideoInfo = {
+        const videoRTCPInterval = videoRTPParameters[4 /* VideoRTPParametersTypes.MIN_RTCP_INTERVAL */].readFloatLE(0) || 0.5;
+        const reconfiguredVideoInfo = {
             width: width,
             height: height,
             fps: frameRate,
             max_bit_rate: videoMaximumBitrate,
             rtcp_interval: videoRTCPInterval,
         };
-        var request = {
+        const request = {
             sessionID: this.sessionIdentifier,
             type: "reconfigure" /* StreamRequestTypes.RECONFIGURE */,
             video: reconfiguredVideoInfo,
         };
-        this.delegate.handleStreamRequest(request, function (error) { return callback(error); });
-    };
-    RTPStreamManagement.prototype._handleStopStream = function (callback) {
-        var request = {
+        this.delegate.handleStreamRequest(request, error => callback(error));
+    }
+    _handleStopStream(callback) {
+        const request = {
             sessionID: this.sessionIdentifier, // save sessionIdentifier before handleSessionClosed is called
             type: "stop" /* StreamRequestTypes.STOP */,
         };
         this.handleSessionClosed();
-        this.delegate.handleStreamRequest(request, function (error) { return callback ? callback(error) : undefined; });
-    };
-    RTPStreamManagement.prototype.handleSetupEndpoints = function (value, callback, connection) {
-        var _this = this;
+        this.delegate.handleStreamRequest(request, error => callback ? callback(error) : undefined);
+    }
+    handleSetupEndpoints(value, callback, connection) {
         if (this.streamingIsDisabled(callback)) {
             return;
         }
-        var data = Buffer.from(value, "base64");
-        var objects = tlv.decode(data);
-        var sessionIdentifier = uuid.unparse(objects[1 /* SetupEndpointsTypes.SESSION_ID */]);
+        const data = Buffer.from(value, "base64");
+        const objects = tlv.decode(data);
+        const 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();
@@ -664,26 +705,26 @@ var RTPStreamManagement = /** @class */ (function () {
         this.sessionIdentifier = sessionIdentifier;
         this._updateStreamStatus(1 /* StreamingStatus.IN_USE */);
         // Address
-        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);
+        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);
         // Video SRTP Params
-        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 */];
+        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 */];
         // Audio SRTP Params
-        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 */];
+        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 */];
         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);
-        var prepareRequest = {
+        const prepareRequest = {
             sessionID: sessionIdentifier,
             sourceAddress: connection.localAddress,
             targetAddress: controllerAddress,
@@ -701,7 +742,7 @@ var RTPStreamManagement = /** @class */ (function () {
                 srtp_salt: audioMasterSalt,
             },
         };
-        var promises = [];
+        const 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({
@@ -710,9 +751,9 @@ var RTPStreamManagement = /** @class */ (function () {
                 outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // videoSSRC
                 disabled: false,
             });
-            promises.push(this.videoProxy.setup().then(function () {
-                prepareRequest.video.proxy_rtp = _this.videoProxy.incomingRTPPort();
-                prepareRequest.video.proxy_rtcp = _this.videoProxy.incomingRTCPPort();
+            promises.push(this.videoProxy.setup().then(() => {
+                prepareRequest.video.proxy_rtp = this.videoProxy.incomingRTPPort();
+                prepareRequest.video.proxy_rtcp = this.videoProxy.incomingRTCPPort();
             }));
             if (!this.disableAudioProxy) {
                 this.audioProxy = new RTPProxy_1.default({
@@ -721,52 +762,52 @@ var RTPStreamManagement = /** @class */ (function () {
                     outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // audioSSRC
                     disabled: this.videoOnly,
                 });
-                promises.push(this.audioProxy.setup().then(function () {
-                    prepareRequest.audio.proxy_rtp = _this.audioProxy.incomingRTPPort();
-                    prepareRequest.audio.proxy_rtcp = _this.audioProxy.incomingRTCPPort();
+                promises.push(this.audioProxy.setup().then(() => {
+                    prepareRequest.audio.proxy_rtp = this.audioProxy.incomingRTPPort();
+                    prepareRequest.audio.proxy_rtcp = this.audioProxy.incomingRTCPPort();
                 }));
             }
         }
-        Promise.all(promises).then(function () {
-            _this.delegate.prepareStream(prepareRequest, (0, once_1.once)(function (error, response) {
+        Promise.all(promises).then(() => {
+            this.delegate.prepareStream(prepareRequest, (0, once_1.once)((error, response) => {
                 if (error || !response) {
-                    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();
+                    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();
                     callback(error);
                 }
                 else {
-                    _this.generateSetupEndpointResponse(connection, sessionIdentifier, prepareRequest, response, callback);
+                    this.generateSetupEndpointResponse(connection, sessionIdentifier, prepareRequest, response, callback);
                 }
             }));
         });
-    };
-    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;
+    }
+    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;
         if (!this.videoOnly && !response.audio) {
             throw new Error("Audio was enabled but not supplied in PrepareStreamResponse!");
         }
         // Provide default values if audio was not supplied
-        var audio = response.audio || {
+        const 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) {
-            var videoInfo = response.video;
-            var audioInfo = audio;
+            const videoInfo = response.video;
+            const audioInfo = audio;
             if (response.addressOverride) {
                 addressVersion = net_1.default.isIPv4(response.addressOverride) ? "ipv4" : "ipv6";
                 address = response.addressOverride;
@@ -775,7 +816,7 @@ var RTPStreamManagement = /** @class */ (function () {
                 address = connection.getLocalAddress(addressVersion);
             }
             if (request.addressVersion !== addressVersion) {
-                throw new Error("Incoming and outgoing ip address versions must match! Expected ".concat(request.addressVersion, " but got ").concat(addressVersion));
+                throw new Error(`Incoming and outgoing ip address versions must match! Expected ${request.addressVersion} but got ${addressVersion}`);
             }
             videoPort = videoInfo.port;
             audioPort = audioInfo.port;
@@ -797,7 +838,7 @@ var RTPStreamManagement = /** @class */ (function () {
             audioSSRC = audioInfo.ssrc;
         }
         else {
-            var videoInfo = response.video;
+            const videoInfo = response.video;
             address = connection.getLocalAddress(request.addressVersion);
             videoCryptoSuite = 2 /* SRTPCryptoSuites.NONE */;
             videoSRTPKey = Buffer.alloc(0);
@@ -812,7 +853,7 @@ var RTPStreamManagement = /** @class */ (function () {
             videoPort = this.videoProxy.outgoingLocalPort();
             videoSSRC = this.videoProxy.outgoingSSRC;
             if (!this.disableAudioProxy) {
-                var audioInfo = response.audio;
+                const audioInfo = response.audio;
                 this.audioProxy.setIncomingPayloadType(audioInfo.proxy_pt);
                 this.audioProxy.setServerAddress(audioInfo.proxy_server_address);
                 this.audioProxy.setServerRTPPort(audioInfo.proxy_server_rtp);
@@ -821,66 +862,66 @@ var RTPStreamManagement = /** @class */ (function () {
                 audioSSRC = this.audioProxy.outgoingSSRC;
             }
             else {
-                var audioInfo = response.audio;
+                const 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
-        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);
+        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);
         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();
-    };
-    RTPStreamManagement.prototype._updateStreamStatus = function (status) {
+    }
+    _updateStreamStatus(status) {
         this.streamStatus = status;
         this.service.updateCharacteristic(Characteristic_1.Characteristic.StreamingStatus, tlv.encode(1 /* StreamingStatusTypes.STATUS */, this.streamStatus).toString("base64"));
-    };
-    RTPStreamManagement._supportedRTPConfiguration = function (supportedCryptoSuites) {
+    }
+    static _supportedRTPConfiguration(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");
-    };
-    RTPStreamManagement._supportedVideoStreamConfiguration = function (videoOptions) {
+    }
+    static _supportedVideoStreamConfiguration(videoOptions) {
         if (!videoOptions.codec) {
             throw new Error("Video codec cannot be undefined");
         }
         if (!videoOptions.resolutions) {
             throw new Error("Video resolutions cannot be undefined");
         }
-        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 */);
+        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 */);
         if (videoOptions.cvoId != null) {
             codecParameters = Buffer.concat([
                 codecParameters,
                 tlv.encode(4 /* VideoCodecParametersTypes.CVO_ENABLED */, 1 /* VideoCodecCVO.SUPPORTED */, 5 /* VideoCodecParametersTypes.CVO_ID */, videoOptions.cvoId),
             ]);
         }
-        var videoStreamConfiguration = tlv.encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, 0 /* VideoCodecType.H264 */, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map(function (resolution) {
+        const videoStreamConfiguration = tlv.encode(1 /* VideoCodecConfigurationTypes.CODEC_TYPE */, 0 /* VideoCodecType.H264 */, 2 /* VideoCodecConfigurationTypes.CODEC_PARAMETERS */, codecParameters, 3 /* VideoCodecConfigurationTypes.ATTRIBUTES */, videoOptions.resolutions.map(resolution => {
             if (resolution.length !== 3) {
                 throw new Error("Unexpected video resolution");
             }
-            var width = Buffer.alloc(2);
-            var height = Buffer.alloc(2);
-            var frameRate = Buffer.alloc(1);
+            const width = Buffer.alloc(2);
+            const height = Buffer.alloc(2);
+            const 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");
-    };
-    RTPStreamManagement.prototype.checkForLegacyAudioCodecRepresentation = function (codecs) {
-        var codecMap = {};
-        codecs.slice().forEach(function (codec) {
-            var previous = codecMap[codec.type];
+    }
+    checkForLegacyAudioCodecRepresentation(codecs) {
+        const codecMap = {};
+        codecs.slice().forEach(codec => {
+            const previous = codecMap[codec.type];
             if (previous) {
                 if (typeof previous.samplerate === "number") {
                     previous.samplerate = [previous.samplerate];
                 }
                 previous.samplerate = previous.samplerate.concat(codec.samplerate);
-                var index = codecs.indexOf(codec);
+                const index = codecs.indexOf(codec);
                 if (index >= 0) {
                     codecs.splice(index, 1);
                 }
@@ -889,12 +930,12 @@ var RTPStreamManagement = /** @class */ (function () {
                 codecMap[codec.type] = codec;
             }
         });
-    };
-    RTPStreamManagement.prototype._supportedAudioStreamConfiguration = function (audioOptions) {
+    }
+    _supportedAudioStreamConfiguration(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.
-        var comfortNoise = audioOptions && !!audioOptions.comfort_noise;
-        var supportedCodecs = (audioOptions && audioOptions.codecs) || [];
+        const comfortNoise = audioOptions && !!audioOptions.comfort_noise;
+        const 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.");
@@ -904,8 +945,8 @@ var RTPStreamManagement = /** @class */ (function () {
                 samplerate: [16 /* AudioStreamingSamplerate.KHZ_16 */, 24 /* AudioStreamingSamplerate.KHZ_24 */], // 16 and 24 must be supported
             });
         }
-        var codecConfigurations = supportedCodecs.map(function (codec) {
-            var type;
+        const codecConfigurations = supportedCodecs.map(codec => {
+            let type;
             switch (codec.type) {
                 case "OPUS" /* AudioStreamingCodecType.OPUS */:
                     type = 3 /* AudioCodecTypes.OPUS */;
@@ -931,8 +972,8 @@ var RTPStreamManagement = /** @class */ (function () {
                 default:
                     throw new Error("Unsupported codec: " + codec.type);
             }
-            var providedSamplerates = (typeof codec.samplerate === "number" ? [codec.samplerate] : codec.samplerate).map(function (rate) {
-                var samplerate;
+            const providedSamplerates = (typeof codec.samplerate === "number" ? [codec.samplerate] : codec.samplerate).map(rate => {
+                let samplerate;
                 switch (rate) {
                     case 8 /* AudioStreamingSamplerate.KHZ_8 */:
                         samplerate = 0 /* AudioSamplerate.KHZ_8 */;
@@ -948,28 +989,28 @@ var RTPStreamManagement = /** @class */ (function () {
                         samplerate = -1;
                 }
                 return samplerate;
-            }).filter(function (rate) { return rate !== -1; });
+            }).filter(rate => rate !== -1);
             if (providedSamplerates.length === 0) {
                 throw new Error("Audio samplerate cannot be empty!");
             }
-            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);
+            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);
             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");
-    };
-    RTPStreamManagement.prototype.resetSetupEndpointsResponse = function () {
+    }
+    resetSetupEndpointsResponse() {
         this.setupEndpointsResponse = tlv.encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64");
         this.service.updateCharacteristic(Characteristic_1.Characteristic.SetupEndpoints, this.setupEndpointsResponse);
-    };
-    RTPStreamManagement.prototype.resetSelectedStreamConfiguration = function () {
+    }
+    resetSelectedStreamConfiguration() {
         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
      */
-    RTPStreamManagement.prototype.serialize = function () {
-        var characteristicValue = this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value;
+    serialize() {
+        const characteristicValue = this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value;
         if (characteristicValue === true) {
             return undefined;
         }
@@ -977,50 +1018,36 @@ var RTPStreamManagement = /** @class */ (function () {
             id: this.id,
             active: !!characteristicValue,
         };
-    };
+    }
     /**
      * @private
      */
-    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, "!"));
+    deserialize(serialized) {
+        (0, assert_1.default)(serialized.id === this.id, `Tried to initialize RTPStreamManagement ${this.id} with data from management with id ${serialized.id}!`);
         this.service.updateCharacteristic(Characteristic_1.Characteristic.Active, serialized.active);
-    };
+    }
     /**
      * @private
      */
-    RTPStreamManagement.prototype.setupStateChangeDelegate = function (delegate) {
+    setupStateChangeDelegate(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
  */
-var StreamController = /** @class */ (function (_super) {
-    tslib_1.__extends(StreamController, _super);
+class StreamController extends RTPStreamManagement {
+    /**
+     *  options get saved so we can still support {@link Accessory.configureCameraSource}
+     */
+    options;
     // noinspection JSDeprecatedSymbols
-    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;
+    constructor(id, options, delegate, service) {
+        super(id, options, new Camera_1.LegacyCameraSourceAdapter(delegate), service);
+        this.options = options;
     }
-    return StreamController;
-}(RTPStreamManagement));
+}
 exports.StreamController = StreamController;
 //# sourceMappingURL=RTPStreamManagement.js.map