hap-nodejs 1.1.1-beta.2 → 1.1.1-beta.3

package/dist/lib/camera/RTPStreamManagement.js

@@ -1,25 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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"));
-const RTPProxy_1 = tslib_1.__importDefault(require("./RTPProxy"));
-const debug = (0, debug_1.default)("HAP-NodeJS:Camera:RTPStreamManagement");
+import assert from 'node:assert';
+import { Buffer } from 'node:buffer';
+import { randomBytes } from 'node:crypto';
+import { isIPv4 } from 'node:net';
+import createDebug from 'debug';
+import { Characteristic } from '../Characteristic.js';
+import { CameraController } from '../controller/index.js';
+import { Service } from '../Service.js';
+import { HapStatusError } from '../util/hapStatusError.js';
+import { once } from '../util/once.js';
+import { decode, encode, writeUInt16, writeUInt32 } from '../util/tlv.js';
+import { unparse, write } from '../util/uuid.js';
+import RTPProxy from './RTPProxy.js';
+const debug = createDebug('HAP-NodeJS:Camera:RTPStreamManagement');
 // ---------------------------------- TLV DEFINITIONS START ----------------------------------
+// eslint-disable-next-line no-restricted-syntax
 var StreamingStatusTypes;
 (function (StreamingStatusTypes) {
     StreamingStatusTypes[StreamingStatusTypes["STATUS"] = 1] = "STATUS";
 })(StreamingStatusTypes || (StreamingStatusTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var StreamingStatus;
 (function (StreamingStatus) {
     StreamingStatus[StreamingStatus["AVAILABLE"] = 0] = "AVAILABLE";
@@ -27,16 +26,19 @@ var StreamingStatus;
     StreamingStatus[StreamingStatus["UNAVAILABLE"] = 2] = "UNAVAILABLE";
 })(StreamingStatus || (StreamingStatus = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SupportedVideoStreamConfigurationTypes;
 (function (SupportedVideoStreamConfigurationTypes) {
     SupportedVideoStreamConfigurationTypes[SupportedVideoStreamConfigurationTypes["VIDEO_CODEC_CONFIGURATION"] = 1] = "VIDEO_CODEC_CONFIGURATION";
 })(SupportedVideoStreamConfigurationTypes || (SupportedVideoStreamConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var VideoCodecConfigurationTypes;
 (function (VideoCodecConfigurationTypes) {
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["CODEC_PARAMETERS"] = 2] = "CODEC_PARAMETERS";
     VideoCodecConfigurationTypes[VideoCodecConfigurationTypes["ATTRIBUTES"] = 3] = "ATTRIBUTES";
 })(VideoCodecConfigurationTypes || (VideoCodecConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var VideoCodecParametersTypes;
 (function (VideoCodecParametersTypes) {
     VideoCodecParametersTypes[VideoCodecParametersTypes["PROFILE_ID"] = 1] = "PROFILE_ID";
@@ -45,6 +47,7 @@ var VideoCodecParametersTypes;
     VideoCodecParametersTypes[VideoCodecParametersTypes["CVO_ENABLED"] = 4] = "CVO_ENABLED";
     VideoCodecParametersTypes[VideoCodecParametersTypes["CVO_ID"] = 5] = "CVO_ID";
 })(VideoCodecParametersTypes || (VideoCodecParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var VideoAttributesTypes;
 (function (VideoAttributesTypes) {
     VideoAttributesTypes[VideoAttributesTypes["IMAGE_WIDTH"] = 1] = "IMAGE_WIDTH";
@@ -54,53 +57,61 @@ var VideoAttributesTypes;
 /**
  * @group Camera
  */
-var VideoCodecType;
+// eslint-disable-next-line no-restricted-syntax
+export var VideoCodecType;
 (function (VideoCodecType) {
     VideoCodecType[VideoCodecType["H264"] = 0] = "H264";
     // while the namespace is already reserved for H265 it isn't currently supported.
     // H265 = 0x01,
-})(VideoCodecType || (exports.VideoCodecType = VideoCodecType = {}));
+})(VideoCodecType || (VideoCodecType = {}));
 /**
  * @group Camera
  */
-var H264Profile;
+// eslint-disable-next-line no-restricted-syntax
+export var H264Profile;
 (function (H264Profile) {
     H264Profile[H264Profile["BASELINE"] = 0] = "BASELINE";
     H264Profile[H264Profile["MAIN"] = 1] = "MAIN";
     H264Profile[H264Profile["HIGH"] = 2] = "HIGH";
-})(H264Profile || (exports.H264Profile = H264Profile = {}));
+})(H264Profile || (H264Profile = {}));
 /**
  * @group Camera
  */
-var H264Level;
+// eslint-disable-next-line no-restricted-syntax
+export var H264Level;
 (function (H264Level) {
     H264Level[H264Level["LEVEL3_1"] = 0] = "LEVEL3_1";
     H264Level[H264Level["LEVEL3_2"] = 1] = "LEVEL3_2";
     H264Level[H264Level["LEVEL4_0"] = 2] = "LEVEL4_0";
-})(H264Level || (exports.H264Level = H264Level = {}));
+})(H264Level || (H264Level = {}));
 /**
  * @group Camera
  */
-var VideoCodecPacketizationMode;
+// eslint-disable-next-line no-restricted-syntax
+export var VideoCodecPacketizationMode;
 (function (VideoCodecPacketizationMode) {
     VideoCodecPacketizationMode[VideoCodecPacketizationMode["NON_INTERLEAVED"] = 0] = "NON_INTERLEAVED";
-})(VideoCodecPacketizationMode || (exports.VideoCodecPacketizationMode = VideoCodecPacketizationMode = {}));
+})(VideoCodecPacketizationMode || (VideoCodecPacketizationMode = {}));
+// eslint-disable-next-line no-restricted-syntax
 var VideoCodecCVO;
 (function (VideoCodecCVO) {
     VideoCodecCVO[VideoCodecCVO["UNSUPPORTED"] = 0] = "UNSUPPORTED";
     VideoCodecCVO[VideoCodecCVO["SUPPORTED"] = 1] = "SUPPORTED";
 })(VideoCodecCVO || (VideoCodecCVO = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SupportedAudioStreamConfigurationTypes;
 (function (SupportedAudioStreamConfigurationTypes) {
     SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["AUDIO_CODEC_CONFIGURATION"] = 1] = "AUDIO_CODEC_CONFIGURATION";
     SupportedAudioStreamConfigurationTypes[SupportedAudioStreamConfigurationTypes["COMFORT_NOISE_SUPPORT"] = 2] = "COMFORT_NOISE_SUPPORT";
 })(SupportedAudioStreamConfigurationTypes || (SupportedAudioStreamConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioCodecConfigurationTypes;
 (function (AudioCodecConfigurationTypes) {
     AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
     AudioCodecConfigurationTypes[AudioCodecConfigurationTypes["CODEC_PARAMETERS"] = 2] = "CODEC_PARAMETERS";
 })(AudioCodecConfigurationTypes || (AudioCodecConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioCodecTypes;
 (function (AudioCodecTypes) {
     AudioCodecTypes[AudioCodecTypes["PCMU"] = 0] = "PCMU";
@@ -111,33 +122,37 @@ var AudioCodecTypes;
     AudioCodecTypes[AudioCodecTypes["AMR"] = 5] = "AMR";
     AudioCodecTypes[AudioCodecTypes["AMR_WB"] = 6] = "AMR_WB";
 })(AudioCodecTypes || (AudioCodecTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioCodecParametersTypes;
 (function (AudioCodecParametersTypes) {
     AudioCodecParametersTypes[AudioCodecParametersTypes["CHANNEL"] = 1] = "CHANNEL";
     AudioCodecParametersTypes[AudioCodecParametersTypes["BIT_RATE"] = 2] = "BIT_RATE";
     AudioCodecParametersTypes[AudioCodecParametersTypes["SAMPLE_RATE"] = 3] = "SAMPLE_RATE";
-    AudioCodecParametersTypes[AudioCodecParametersTypes["PACKET_TIME"] = 4] = "PACKET_TIME"; // only present in selected audio codec parameters tlv
+    AudioCodecParametersTypes[AudioCodecParametersTypes["PACKET_TIME"] = 4] = "PACKET_TIME";
 })(AudioCodecParametersTypes || (AudioCodecParametersTypes = {}));
 /**
  * @group Camera
  */
-var AudioBitrate;
+// eslint-disable-next-line no-restricted-syntax
+export var AudioBitrate;
 (function (AudioBitrate) {
     AudioBitrate[AudioBitrate["VARIABLE"] = 0] = "VARIABLE";
     AudioBitrate[AudioBitrate["CONSTANT"] = 1] = "CONSTANT";
-})(AudioBitrate || (exports.AudioBitrate = AudioBitrate = {}));
+})(AudioBitrate || (AudioBitrate = {}));
 /**
  * @group Camera
  */
-var AudioSamplerate;
+// eslint-disable-next-line no-restricted-syntax
+export var AudioSamplerate;
 (function (AudioSamplerate) {
     AudioSamplerate[AudioSamplerate["KHZ_8"] = 0] = "KHZ_8";
     AudioSamplerate[AudioSamplerate["KHZ_16"] = 1] = "KHZ_16";
     AudioSamplerate[AudioSamplerate["KHZ_24"] = 2] = "KHZ_24";
     // 3, 4, 5 are theoretically defined, but no idea to what kHz value they correspond to
     // probably KHZ_32, KHZ_44_1, KHZ_48 (as supported by Secure Video recordings)
-})(AudioSamplerate || (exports.AudioSamplerate = AudioSamplerate = {}));
+})(AudioSamplerate || (AudioSamplerate = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SupportedRTPConfigurationTypes;
 (function (SupportedRTPConfigurationTypes) {
     SupportedRTPConfigurationTypes[SupportedRTPConfigurationTypes["SRTP_CRYPTO_SUITE"] = 2] = "SRTP_CRYPTO_SUITE";
@@ -145,13 +160,15 @@ var SupportedRTPConfigurationTypes;
 /**
  * @group Camera
  */
-var SRTPCryptoSuites;
+// eslint-disable-next-line no-restricted-syntax
+export var SRTPCryptoSuites;
 (function (SRTPCryptoSuites) {
     SRTPCryptoSuites[SRTPCryptoSuites["AES_CM_128_HMAC_SHA1_80"] = 0] = "AES_CM_128_HMAC_SHA1_80";
     SRTPCryptoSuites[SRTPCryptoSuites["AES_CM_256_HMAC_SHA1_80"] = 1] = "AES_CM_256_HMAC_SHA1_80";
     SRTPCryptoSuites[SRTPCryptoSuites["NONE"] = 2] = "NONE";
-})(SRTPCryptoSuites || (exports.SRTPCryptoSuites = SRTPCryptoSuites = {}));
+})(SRTPCryptoSuites || (SRTPCryptoSuites = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SetupEndpointsTypes;
 (function (SetupEndpointsTypes) {
     SetupEndpointsTypes[SetupEndpointsTypes["SESSION_ID"] = 1] = "SESSION_ID";
@@ -159,6 +176,7 @@ var SetupEndpointsTypes;
     SetupEndpointsTypes[SetupEndpointsTypes["VIDEO_SRTP_PARAMETERS"] = 4] = "VIDEO_SRTP_PARAMETERS";
     SetupEndpointsTypes[SetupEndpointsTypes["AUDIO_SRTP_PARAMETERS"] = 5] = "AUDIO_SRTP_PARAMETERS";
 })(SetupEndpointsTypes || (SetupEndpointsTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AddressTypes;
 (function (AddressTypes) {
     AddressTypes[AddressTypes["ADDRESS_VERSION"] = 1] = "ADDRESS_VERSION";
@@ -166,17 +184,20 @@ var AddressTypes;
     AddressTypes[AddressTypes["VIDEO_RTP_PORT"] = 3] = "VIDEO_RTP_PORT";
     AddressTypes[AddressTypes["AUDIO_RTP_PORT"] = 4] = "AUDIO_RTP_PORT";
 })(AddressTypes || (AddressTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var IPAddressVersion;
 (function (IPAddressVersion) {
     IPAddressVersion[IPAddressVersion["IPV4"] = 0] = "IPV4";
     IPAddressVersion[IPAddressVersion["IPV6"] = 1] = "IPV6";
 })(IPAddressVersion || (IPAddressVersion = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SRTPParametersTypes;
 (function (SRTPParametersTypes) {
     SRTPParametersTypes[SRTPParametersTypes["SRTP_CRYPTO_SUITE"] = 1] = "SRTP_CRYPTO_SUITE";
     SRTPParametersTypes[SRTPParametersTypes["MASTER_KEY"] = 2] = "MASTER_KEY";
-    SRTPParametersTypes[SRTPParametersTypes["MASTER_SALT"] = 3] = "MASTER_SALT"; // 14 bytes
+    SRTPParametersTypes[SRTPParametersTypes["MASTER_SALT"] = 3] = "MASTER_SALT";
 })(SRTPParametersTypes || (SRTPParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SetupEndpointsResponseTypes;
 (function (SetupEndpointsResponseTypes) {
     SetupEndpointsResponseTypes[SetupEndpointsResponseTypes["SESSION_ID"] = 1] = "SESSION_ID";
@@ -187,6 +208,7 @@ var SetupEndpointsResponseTypes;
     SetupEndpointsResponseTypes[SetupEndpointsResponseTypes["VIDEO_SSRC"] = 6] = "VIDEO_SSRC";
     SetupEndpointsResponseTypes[SetupEndpointsResponseTypes["AUDIO_SSRC"] = 7] = "AUDIO_SSRC";
 })(SetupEndpointsResponseTypes || (SetupEndpointsResponseTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SetupEndpointsStatus;
 (function (SetupEndpointsStatus) {
     SetupEndpointsStatus[SetupEndpointsStatus["SUCCESS"] = 0] = "SUCCESS";
@@ -194,12 +216,14 @@ var SetupEndpointsStatus;
     SetupEndpointsStatus[SetupEndpointsStatus["ERROR"] = 2] = "ERROR";
 })(SetupEndpointsStatus || (SetupEndpointsStatus = {}));
 // ----------
+// eslint-disable-next-line no-restricted-syntax
 var SelectedRTPStreamConfigurationTypes;
 (function (SelectedRTPStreamConfigurationTypes) {
     SelectedRTPStreamConfigurationTypes[SelectedRTPStreamConfigurationTypes["SESSION_CONTROL"] = 1] = "SESSION_CONTROL";
     SelectedRTPStreamConfigurationTypes[SelectedRTPStreamConfigurationTypes["SELECTED_VIDEO_PARAMETERS"] = 2] = "SELECTED_VIDEO_PARAMETERS";
     SelectedRTPStreamConfigurationTypes[SelectedRTPStreamConfigurationTypes["SELECTED_AUDIO_PARAMETERS"] = 3] = "SELECTED_AUDIO_PARAMETERS";
 })(SelectedRTPStreamConfigurationTypes || (SelectedRTPStreamConfigurationTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SessionControlTypes;
 (function (SessionControlTypes) {
     SessionControlTypes[SessionControlTypes["SESSION_IDENTIFIER"] = 1] = "SESSION_IDENTIFIER";
@@ -213,6 +237,7 @@ var SessionControlCommand;
     SessionControlCommand[SessionControlCommand["RESUME_SESSION"] = 3] = "RESUME_SESSION";
     SessionControlCommand[SessionControlCommand["RECONFIGURE_SESSION"] = 4] = "RECONFIGURE_SESSION";
 })(SessionControlCommand || (SessionControlCommand = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SelectedVideoParametersTypes;
 (function (SelectedVideoParametersTypes) {
     SelectedVideoParametersTypes[SelectedVideoParametersTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
@@ -220,6 +245,7 @@ var SelectedVideoParametersTypes;
     SelectedVideoParametersTypes[SelectedVideoParametersTypes["ATTRIBUTES"] = 3] = "ATTRIBUTES";
     SelectedVideoParametersTypes[SelectedVideoParametersTypes["RTP_PARAMETERS"] = 4] = "RTP_PARAMETERS";
 })(SelectedVideoParametersTypes || (SelectedVideoParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var VideoRTPParametersTypes;
 (function (VideoRTPParametersTypes) {
     VideoRTPParametersTypes[VideoRTPParametersTypes["PAYLOAD_TYPE"] = 1] = "PAYLOAD_TYPE";
@@ -228,6 +254,7 @@ var VideoRTPParametersTypes;
     VideoRTPParametersTypes[VideoRTPParametersTypes["MIN_RTCP_INTERVAL"] = 4] = "MIN_RTCP_INTERVAL";
     VideoRTPParametersTypes[VideoRTPParametersTypes["MAX_MTU"] = 5] = "MAX_MTU";
 })(VideoRTPParametersTypes || (VideoRTPParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var SelectedAudioParametersTypes;
 (function (SelectedAudioParametersTypes) {
     SelectedAudioParametersTypes[SelectedAudioParametersTypes["CODEC_TYPE"] = 1] = "CODEC_TYPE";
@@ -235,6 +262,7 @@ var SelectedAudioParametersTypes;
     SelectedAudioParametersTypes[SelectedAudioParametersTypes["RTP_PARAMETERS"] = 3] = "RTP_PARAMETERS";
     SelectedAudioParametersTypes[SelectedAudioParametersTypes["COMFORT_NOISE"] = 4] = "COMFORT_NOISE";
 })(SelectedAudioParametersTypes || (SelectedAudioParametersTypes = {}));
+// eslint-disable-next-line no-restricted-syntax
 var AudioRTPParametersTypes;
 (function (AudioRTPParametersTypes) {
     AudioRTPParametersTypes[AudioRTPParametersTypes["PAYLOAD_TYPE"] = 1] = "PAYLOAD_TYPE";
@@ -243,14 +271,14 @@ var AudioRTPParametersTypes;
     AudioRTPParametersTypes[AudioRTPParametersTypes["MIN_RTCP_INTERVAL"] = 4] = "MIN_RTCP_INTERVAL";
     AudioRTPParametersTypes[AudioRTPParametersTypes["COMFORT_NOISE_PAYLOAD_TYPE"] = 6] = "COMFORT_NOISE_PAYLOAD_TYPE";
 })(AudioRTPParametersTypes || (AudioRTPParametersTypes = {}));
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isLegacySRTPOptions(options) {
-    return "srtp" in options;
+    return 'srtp' in options;
 }
 /**
  * @group Camera
  */
-var AudioStreamingCodecType;
+// eslint-disable-next-line no-restricted-syntax
+export var AudioStreamingCodecType;
 (function (AudioStreamingCodecType) {
     AudioStreamingCodecType["PCMU"] = "PCMU";
     AudioStreamingCodecType["PCMA"] = "PCMA";
@@ -259,29 +287,31 @@ var AudioStreamingCodecType;
     AudioStreamingCodecType["MSBC"] = "mSBC";
     AudioStreamingCodecType["AMR"] = "AMR";
     AudioStreamingCodecType["AMR_WB"] = "AMR-WB";
-})(AudioStreamingCodecType || (exports.AudioStreamingCodecType = AudioStreamingCodecType = {}));
+})(AudioStreamingCodecType || (AudioStreamingCodecType = {}));
 /**
  * @group Camera
  */
-var AudioStreamingSamplerate;
+// eslint-disable-next-line no-restricted-syntax
+export var AudioStreamingSamplerate;
 (function (AudioStreamingSamplerate) {
     AudioStreamingSamplerate[AudioStreamingSamplerate["KHZ_8"] = 8] = "KHZ_8";
     AudioStreamingSamplerate[AudioStreamingSamplerate["KHZ_16"] = 16] = "KHZ_16";
     AudioStreamingSamplerate[AudioStreamingSamplerate["KHZ_24"] = 24] = "KHZ_24";
-})(AudioStreamingSamplerate || (exports.AudioStreamingSamplerate = AudioStreamingSamplerate = {}));
+})(AudioStreamingSamplerate || (AudioStreamingSamplerate = {}));
 /**
  * @group Camera
  */
-var StreamRequestTypes;
+// eslint-disable-next-line no-restricted-syntax
+export var StreamRequestTypes;
 (function (StreamRequestTypes) {
     StreamRequestTypes["RECONFIGURE"] = "reconfigure";
     StreamRequestTypes["START"] = "start";
     StreamRequestTypes["STOP"] = "stop";
-})(StreamRequestTypes || (exports.StreamRequestTypes = StreamRequestTypes = {}));
+})(StreamRequestTypes || (StreamRequestTypes = {}));
 /**
  * @group Camera
  */
-class RTPStreamManagement {
+export class RTPStreamManagement {
     id;
     delegate;
     service;
@@ -297,18 +327,18 @@ class RTPStreamManagement {
     activeConnectionClosedListener;
     sessionIdentifier = undefined;
     /**
-     * @private private API
+     * @private
      */
     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
+    selectedConfiguration = ''; // base64 representation of the currently selected configuration
+    setupEndpointsResponse = ''; // response of the SetupEndpoints Characteristic
     /**
-     * @private deprecated API
+     * @private
      */
     audioProxy;
     /**
-     * @private deprecated API
+     * @private
      */
     videoProxy;
     /**
@@ -332,7 +362,7 @@ class RTPStreamManagement {
             this.supportedCryptoSuites.push(2 /* SRTPCryptoSuites.NONE */);
         }
         if (!options.video) {
-            throw new Error("Video parameters cannot be undefined in options");
+            throw new Error('Video parameters cannot be undefined in options');
         }
         this.supportedRTPConfiguration = RTPStreamManagement._supportedRTPConfiguration(this.supportedCryptoSuites);
         this.supportedVideoStreamConfiguration = RTPStreamManagement._supportedVideoStreamConfiguration(options.video);
@@ -353,7 +383,7 @@ class RTPStreamManagement {
     handleFactoryReset() {
         this.resetSelectedStreamConfiguration();
         this.resetSetupEndpointsResponse();
-        this.service.updateCharacteristic(Characteristic_1.Characteristic.Active, true);
+        this.service.updateCharacteristic(Characteristic.Active, true);
         // on a factory reset the assumption is that all connections were already terminated and thus "handleStopStream" was already called
     }
     destroy() {
@@ -362,46 +392,46 @@ class RTPStreamManagement {
         }
     }
     constructService(id) {
-        const managementService = new Service_1.Service.CameraRTPStreamManagement("", id.toString());
+        const managementService = new 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);
+        managementService.setCharacteristic(Characteristic.Active, true);
         return managementService;
     }
     setupServiceHandlers() {
-        if (!this.service.testCharacteristic(Characteristic_1.Characteristic.Active)) {
+        if (!this.service.testCharacteristic(Characteristic.Active)) {
             // the active characteristic might not be present on some older configurations.
-            this.service.setCharacteristic(Characteristic_1.Characteristic.Active, true);
+            this.service.setCharacteristic(Characteristic.Active, true);
         }
-        this.service.getCharacteristic(Characteristic_1.Characteristic.Active)
+        this.service.getCharacteristic(Characteristic.Active)
             .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);
-        this.service.setCharacteristic(Characteristic_1.Characteristic.SupportedVideoStreamConfiguration, this.supportedVideoStreamConfiguration);
-        this.service.setCharacteristic(Characteristic_1.Characteristic.SupportedAudioStreamConfiguration, this.supportedAudioStreamConfiguration);
+        this.service.setCharacteristic(Characteristic.SupportedRTPConfiguration, this.supportedRTPConfiguration);
+        this.service.setCharacteristic(Characteristic.SupportedVideoStreamConfiguration, this.supportedVideoStreamConfiguration);
+        this.service.setCharacteristic(Characteristic.SupportedAudioStreamConfiguration, this.supportedAudioStreamConfiguration);
         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 => {
+        this.service.setCharacteristic(Characteristic.SetupEndpoints, this.setupEndpointsResponse); // reset SetupEndpoints to default
+        this.service.getCharacteristic(Characteristic.SelectedRTPStreamConfiguration)
+            .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"));
+                callback(null, encode(1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */, encode(2 /* SessionControlTypes.COMMAND */, SessionControlCommand.SUSPEND_SESSION)).toString('base64'));
                 return;
             }
             callback(null, this.selectedConfiguration);
         })
             .on("set" /* CharacteristicEventTypes.SET */, this._handleSelectedStreamConfigurationWrite.bind(this));
-        this.service.getCharacteristic(Characteristic_1.Characteristic.SetupEndpoints)
-            .on("get" /* CharacteristicEventTypes.GET */, callback => {
+        this.service.getCharacteristic(Characteristic.SetupEndpoints)
+            .on("get" /* CharacteristicEventTypes.GET */, (callback) => {
             if (this.streamingIsDisabled()) {
-                callback(null, tlv.encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64"));
+                callback(null, encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString('base64'));
                 return;
             }
             callback(null, this.setupEndpointsResponse);
         })
             .on("set" /* CharacteristicEventTypes.SET */, (value, callback, context, connection) => {
             if (!connection) {
-                debug("Set event handler for SetupEndpoints cannot be called from plugin. Connection undefined!");
+                debug('Set event handler for SetupEndpoints cannot be called from plugin. Connection undefined!');
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
                 return;
             }
@@ -429,15 +459,15 @@ class RTPStreamManagement {
         }
     }
     streamingIsDisabled(callback) {
-        if (!this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value) {
-            if (typeof callback === "function") {
-                callback(new hapStatusError_1.HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
+        if (!this.service.getCharacteristic(Characteristic.Active).value) {
+            if (typeof callback === 'function') {
+                callback(new HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
             }
             return true;
         }
         if (this.disabledThroughOperatingMode?.()) {
-            if (typeof callback === "function") {
-                callback(new hapStatusError_1.HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
+            if (typeof callback === 'function') {
+                callback(new HapStatusError(-70412 /* HAPStatus.NOT_ALLOWED_IN_CURRENT_STATE */));
             }
             return true;
         }
@@ -447,10 +477,10 @@ class RTPStreamManagement {
         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 data = Buffer.from(value, 'base64');
+        const objects = decode(data);
+        const sessionControl = decode(objects[1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */]);
+        const sessionIdentifier = 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 ${SessionControlCommand[requestType]}`);
@@ -467,13 +497,13 @@ class RTPStreamManagement {
         };
         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 */]);
+                const selectedVideoParameters = decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
+                const selectedAudioParameters = 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 */]);
+                const reconfiguredVideoParameters = decode(objects[2 /* SelectedRTPStreamConfigurationTypes.SELECTED_VIDEO_PARAMETERS */]);
                 this.handleReconfigureStream(reconfiguredVideoParameters, streamCallback);
                 break;
             }
@@ -485,38 +515,36 @@ class RTPStreamManagement {
             default:
                 debug(`Unhandled request type ${SessionControlCommand[requestType]}`);
                 callback(-70410 /* HAPStatus.INVALID_VALUE_IN_REQUEST */);
-                return;
         }
     }
     _handleStartStream(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 */];
         // video parameters
-        const videoParameters = tlv.decode(videoParametersTLV);
+        const videoParameters = 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;
+        let cvoId;
         if (cvoEnabled && cvoEnabled[0] === 1 /* VideoCodecCVO.SUPPORTED */) {
             cvoId = videoParameters[5 /* VideoCodecParametersTypes.CVO_ID */].readUInt8(0);
         }
         // video attributes
-        const videoAttributes = tlv.decode(videoAttributesTLV);
+        const videoAttributes = 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
-        const videoRTPParameters = tlv.decode(videoRTPParametersTLV);
+        const videoRTPParameters = 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
+        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);
         }
@@ -526,13 +554,13 @@ class RTPStreamManagement {
         const audioRTPParametersTLV = audioConfiguration[3 /* SelectedAudioParametersTypes.RTP_PARAMETERS */];
         const comfortNoise = !!audioConfiguration[4 /* SelectedAudioParametersTypes.COMFORT_NOISE */].readUInt8(0);
         // audio parameters
-        const audioParameters = tlv.decode(audioParametersTLV);
+        const audioParameters = 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
-        const audioRTPParameters = tlv.decode(audioRTPParametersTLV);
+        const audioRTPParameters = 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);
@@ -548,10 +576,10 @@ class RTPStreamManagement {
             codec: videoCodec.readUInt8(0),
             profile: h264Profile,
             level: h264Level,
-            packetizationMode: packetizationMode,
-            cvoId: cvoId,
-            width: width,
-            height: height,
+            packetizationMode,
+            cvoId,
+            width,
+            height,
             fps: frameRate,
             pt: videoPayloadType,
             ssrc: videoSSRC,
@@ -625,18 +653,18 @@ class RTPStreamManagement {
         const videoAttributesTLV = videoConfiguration[3 /* SelectedVideoParametersTypes.ATTRIBUTES */];
         const videoRTPParametersTLV = videoConfiguration[4 /* SelectedVideoParametersTypes.RTP_PARAMETERS */];
         // video attributes
-        const videoAttributes = tlv.decode(videoAttributesTLV);
+        const videoAttributes = 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
-        const videoRTPParameters = tlv.decode(videoRTPParametersTLV);
+        const videoRTPParameters = decode(videoRTPParametersTLV);
         const 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 = {
-            width: width,
-            height: height,
+            width,
+            height,
             fps: frameRate,
             max_bit_rate: videoMaximumBitrate,
             rtcp_interval: videoRTCPInterval,
@@ -660,15 +688,15 @@ class RTPStreamManagement {
         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 */]);
+        const data = Buffer.from(value, 'base64');
+        const objects = decode(data);
+        const sessionIdentifier = 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");
+            this.setupEndpointsResponse = encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, write(sessionIdentifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 1 /* SetupEndpointsStatus.BUSY */).toString('base64');
             callback();
             return;
         }
-        (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!");
+        assert(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);
@@ -676,29 +704,29 @@ class RTPStreamManagement {
         this._updateStreamStatus(1 /* StreamingStatus.IN_USE */);
         // Address
         const targetAddressPayload = objects[3 /* SetupEndpointsTypes.CONTROLLER_ADDRESS */];
-        const processedAddressInfo = tlv.decode(targetAddressPayload);
+        const processedAddressInfo = decode(targetAddressPayload);
         const addressVersion = processedAddressInfo[1 /* AddressTypes.ADDRESS_VERSION */][0];
-        const controllerAddress = processedAddressInfo[2 /* AddressTypes.ADDRESS */].toString("utf8");
+        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
         const videoSRTPPayload = objects[4 /* SetupEndpointsTypes.VIDEO_SRTP_PARAMETERS */];
-        const processedVideoInfo = tlv.decode(videoSRTPPayload);
+        const processedVideoInfo = 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
         const audioSRTPPayload = objects[5 /* SetupEndpointsTypes.AUDIO_SRTP_PARAMETERS */];
-        const processedAudioInfo = tlv.decode(audioSRTPPayload);
+        const processedAudioInfo = 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);
+        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 = {
             sessionID: sessionIdentifier,
             sourceAddress: connection.localAddress,
             targetAddress: controllerAddress,
-            addressVersion: addressVersion === 1 /* IPAddressVersion.IPV6 */ ? "ipv6" : "ipv4",
+            addressVersion: addressVersion === 1 /* IPAddressVersion.IPV6 */ ? 'ipv6' : 'ipv4',
             video: {
                 port: targetVideoPort,
                 srtpCryptoSuite: videoCryptoSuite,
@@ -714,11 +742,11 @@ class RTPStreamManagement {
         };
         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({
+            prepareRequest.targetAddress = connection.getLocalAddress(addressVersion === 1 /* IPAddressVersion.IPV6 */ ? 'ipv6' : 'ipv4'); // ip versions must be the same
+            this.videoProxy = new RTPProxy({
                 outgoingAddress: controllerAddress,
                 outgoingPort: targetVideoPort,
-                outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // videoSSRC
+                outgoingSSRC: randomBytes(4).readUInt32LE(0), // videoSSRC
                 disabled: false,
             });
             promises.push(this.videoProxy.setup().then(() => {
@@ -726,10 +754,10 @@ class RTPStreamManagement {
                 prepareRequest.video.proxy_rtcp = this.videoProxy.incomingRTCPPort();
             }));
             if (!this.disableAudioProxy) {
-                this.audioProxy = new RTPProxy_1.default({
+                this.audioProxy = new RTPProxy({
                     outgoingAddress: controllerAddress,
                     outgoingPort: targetAudioPort,
-                    outgoingSSRC: crypto_1.default.randomBytes(4).readUInt32LE(0), // audioSSRC
+                    outgoingSSRC: randomBytes(4).readUInt32LE(0), // audioSSRC
                     disabled: this.videoOnly,
                 });
                 promises.push(this.audioProxy.setup().then(() => {
@@ -739,10 +767,10 @@ class RTPStreamManagement {
             }
         }
         Promise.all(promises).then(() => {
-            this.delegate.prepareStream(prepareRequest, (0, once_1.once)((error, response) => {
+            this.delegate.prepareStream(prepareRequest, once((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.setupEndpointsResponse = encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, write(sessionIdentifier), 2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString('base64');
                     this.handleSessionClosed();
                     callback(error);
                 }
@@ -766,12 +794,12 @@ class RTPStreamManagement {
         let videoSSRC;
         let audioSSRC;
         if (!this.videoOnly && !response.audio) {
-            throw new Error("Audio was enabled but not supplied in PrepareStreamResponse!");
+            throw new Error('Audio was enabled but not supplied in PrepareStreamResponse!');
         }
         // Provide default values if audio was not supplied
         const audio = response.audio || {
             port: request.audio.port,
-            ssrc: controller_1.CameraController.generateSynchronisationSource(),
+            ssrc: CameraController.generateSynchronisationSource(),
             srtp_key: request.audio.srtp_key,
             srtp_salt: request.audio.srtp_salt,
         };
@@ -779,7 +807,7 @@ class RTPStreamManagement {
             const videoInfo = response.video;
             const audioInfo = audio;
             if (response.addressOverride) {
-                addressVersion = net_1.default.isIPv4(response.addressOverride) ? "ipv4" : "ipv6";
+                addressVersion = isIPv4(response.addressOverride) ? 'ipv4' : 'ipv6';
                 address = response.addressOverride;
             }
             else {
@@ -792,11 +820,11 @@ class RTPStreamManagement {
             audioPort = audioInfo.port;
             if (request.video.srtpCryptoSuite !== 2 /* SRTPCryptoSuites.NONE */
                 && (videoInfo.srtp_key === undefined || videoInfo.srtp_salt === undefined)) {
-                throw new Error("SRTP was selected for the prepared video stream, but no 'srtp_key' or 'srtp_salt' was specified!");
+                throw new Error('SRTP was selected for the prepared video stream, but no \'srtp_key\' or \'srtp_salt\' was specified!');
             }
             if (request.audio.srtpCryptoSuite !== 2 /* SRTPCryptoSuites.NONE */
                 && (audioInfo.srtp_key === undefined || audioInfo.srtp_salt === undefined)) {
-                throw new Error("SRTP was selected for the prepared audio stream, but no 'srtp_key' or 'srtp_salt' was specified!");
+                throw new Error('SRTP was selected for the prepared audio stream, but no \'srtp_key\' or \'srtp_salt\' was specified!');
             }
             videoCryptoSuite = request.video.srtpCryptoSuite;
             videoSRTPKey = videoInfo.srtp_key || Buffer.alloc(0); // key and salt are zero-length for cryptoSuite = NONE
@@ -838,39 +866,39 @@ class RTPStreamManagement {
             }
         }
         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);
-        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");
+        const accessoryAddress = encode(1 /* AddressTypes.ADDRESS_VERSION */, addressVersion === 'ipv4' ? 0 /* IPAddressVersion.IPV4 */ : 1 /* IPAddressVersion.IPV6 */, 2 /* AddressTypes.ADDRESS */, address, 3 /* AddressTypes.VIDEO_RTP_PORT */, writeUInt16(videoPort), 4 /* AddressTypes.AUDIO_RTP_PORT */, writeUInt16(audioPort));
+        const videoSRTPParameters = encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, videoCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, videoSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, videoSRTPSalt);
+        const audioSRTPParameters = encode(1 /* SRTPParametersTypes.SRTP_CRYPTO_SUITE */, audioCryptoSuite, 2 /* SRTPParametersTypes.MASTER_KEY */, audioSRTPKey, 3 /* SRTPParametersTypes.MASTER_SALT */, audioSRTPSalt);
+        this.setupEndpointsResponse = encode(1 /* SetupEndpointsResponseTypes.SESSION_ID */, 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 */, writeUInt32(videoSSRC), 7 /* SetupEndpointsResponseTypes.AUDIO_SSRC */, writeUInt32(audioSSRC)).toString('base64');
         callback();
     }
     _updateStreamStatus(status) {
         this.streamStatus = status;
-        this.service.updateCharacteristic(Characteristic_1.Characteristic.StreamingStatus, tlv.encode(1 /* StreamingStatusTypes.STATUS */, this.streamStatus).toString("base64"));
+        this.service.updateCharacteristic(Characteristic.StreamingStatus, encode(1 /* StreamingStatusTypes.STATUS */, this.streamStatus).toString('base64'));
     }
     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.");
+            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");
+        return encode(2 /* SupportedRTPConfigurationTypes.SRTP_CRYPTO_SUITE */, supportedCryptoSuites).toString('base64');
     }
     static _supportedVideoStreamConfiguration(videoOptions) {
         if (!videoOptions.codec) {
-            throw new Error("Video codec cannot be undefined");
+            throw new Error('Video codec cannot be undefined');
         }
         if (!videoOptions.resolutions) {
-            throw new Error("Video resolutions cannot be undefined");
+            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 */);
+        let codecParameters = 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),
+                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 => {
+        const videoStreamConfiguration = 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");
+                throw new Error('Unexpected video resolution');
             }
             const width = Buffer.alloc(2);
             const height = Buffer.alloc(2);
@@ -878,16 +906,16 @@ class RTPStreamManagement {
             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 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");
+        return encode(1 /* SupportedVideoStreamConfigurationTypes.VIDEO_CODEC_CONFIGURATION */, videoStreamConfiguration).toString('base64');
     }
     checkForLegacyAudioCodecRepresentation(codecs) {
         const codecMap = {};
-        codecs.slice().forEach(codec => {
+        codecs.slice().forEach((codec) => {
             const previous = codecMap[codec.type];
             if (previous) {
-                if (typeof previous.samplerate === "number") {
+                if (typeof previous.samplerate === 'number') {
                     previous.samplerate = [previous.samplerate];
                 }
                 previous.samplerate = previous.samplerate.concat(codec.samplerate);
@@ -908,14 +936,14 @@ class RTPStreamManagement {
         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.");
+            debug('Client doesn\'t support any audio codec that HomeKit supports.');
             this.videoOnly = true;
             supportedCodecs.push({
                 type: "OPUS" /* AudioStreamingCodecType.OPUS */, // Opus @16K required by Apple Watch AFAIK
                 samplerate: [16 /* AudioStreamingSamplerate.KHZ_16 */, 24 /* AudioStreamingSamplerate.KHZ_24 */], // 16 and 24 must be supported
             });
         }
-        const codecConfigurations = supportedCodecs.map(codec => {
+        const codecConfigurations = supportedCodecs.map((codec) => {
             let type;
             switch (codec.type) {
                 case "OPUS" /* AudioStreamingCodecType.OPUS */:
@@ -940,9 +968,9 @@ class RTPStreamManagement {
                     type = 6 /* AudioCodecTypes.AMR_WB */;
                     break;
                 default:
-                    throw new Error("Unsupported codec: " + codec.type);
+                    throw new Error(`Unsupported codec: ${codec.type}`);
             }
-            const providedSamplerates = (typeof codec.samplerate === "number" ? [codec.samplerate] : codec.samplerate).map(rate => {
+            const providedSamplerates = (typeof codec.samplerate === 'number' ? [codec.samplerate] : codec.samplerate).map((rate) => {
                 let samplerate;
                 switch (rate) {
                     case 8 /* AudioStreamingSamplerate.KHZ_8 */:
@@ -955,32 +983,33 @@ class RTPStreamManagement {
                         samplerate = 2 /* AudioSamplerate.KHZ_24 */;
                         break;
                     default:
-                        console.log("Unsupported sample rate: ", codec.samplerate);
+                        // eslint-disable-next-line no-console
+                        console.log('Unsupported sample rate: ', codec.samplerate);
                         samplerate = -1;
                 }
                 return samplerate;
             }).filter(rate => rate !== -1);
             if (providedSamplerates.length === 0) {
-                throw new Error("Audio samplerate cannot be empty!");
+                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);
-            return tlv.encode(1 /* AudioCodecConfigurationTypes.CODEC_TYPE */, type, 2 /* AudioCodecConfigurationTypes.CODEC_PARAMETERS */, audioParameters);
+            const audioParameters = 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 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");
+        return encode(1 /* SupportedAudioStreamConfigurationTypes.AUDIO_CODEC_CONFIGURATION */, codecConfigurations, 2 /* SupportedAudioStreamConfigurationTypes.COMFORT_NOISE_SUPPORT */, comfortNoise ? 1 : 0).toString('base64');
     }
     resetSetupEndpointsResponse() {
-        this.setupEndpointsResponse = tlv.encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString("base64");
-        this.service.updateCharacteristic(Characteristic_1.Characteristic.SetupEndpoints, this.setupEndpointsResponse);
+        this.setupEndpointsResponse = encode(2 /* SetupEndpointsResponseTypes.STATUS */, 2 /* SetupEndpointsStatus.ERROR */).toString('base64');
+        this.service.updateCharacteristic(Characteristic.SetupEndpoints, this.setupEndpointsResponse);
     }
     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);
+        this.selectedConfiguration = encode(1 /* SelectedRTPStreamConfigurationTypes.SESSION_CONTROL */, encode(2 /* SessionControlTypes.COMMAND */, SessionControlCommand.SUSPEND_SESSION)).toString('base64');
+        this.service.updateCharacteristic(Characteristic.SelectedRTPStreamConfiguration, this.selectedConfiguration);
     }
     /**
      * @private
      */
     serialize() {
-        const characteristicValue = this.service.getCharacteristic(Characteristic_1.Characteristic.Active).value;
+        const characteristicValue = this.service.getCharacteristic(Characteristic.Active).value;
         if (characteristicValue === true) {
             return undefined;
         }
@@ -993,8 +1022,8 @@ class RTPStreamManagement {
      * @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}!`);
-        this.service.updateCharacteristic(Characteristic_1.Characteristic.Active, serialized.active);
+        assert(serialized.id === this.id, `Tried to initialize RTPStreamManagement ${this.id} with data from management with id ${serialized.id}!`);
+        this.service.updateCharacteristic(Characteristic.Active, serialized.active);
     }
     /**
      * @private
@@ -1003,5 +1032,4 @@ class RTPStreamManagement {
         this.stateChangeDelegate = delegate;
     }
 }
-exports.RTPStreamManagement = RTPStreamManagement;
 //# sourceMappingURL=RTPStreamManagement.js.map