homebridge-unifi-protect 5.5.4 → 6.0.1

package/dist/protect-stream.js

@@ -1,45 +1,37 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProtectStreamingDelegate = void 0;
-const unifi_protect_1 = require("unifi-protect");
-const settings_1 = require("./settings");
-const protect_ffmpeg_stream_1 = require("./protect-ffmpeg-stream");
-const protect_record_1 = require("./protect-record");
-const protect_rtp_1 = require("./protect-rtp");
-const ws_1 = __importDefault(require("ws"));
-const events_1 = __importDefault(require("events"));
-const ffmpeg_for_homebridge_1 = __importDefault(require("ffmpeg-for-homebridge"));
-const camera_utils_1 = require("@homebridge/camera-utils");
-// Increase the listener limits to support Protect installations with more than 10 cameras. 100 seems like a reasonable default.
-// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-member-access
-require("events").EventEmitter.defaultMaxListeners = 100;
+import { PROTECT_FFMPEG_AUDIO_FILTER_FFTNR, PROTECT_FFMPEG_AUDIO_FILTER_HIGHPASS, PROTECT_FFMPEG_AUDIO_FILTER_LOWPASS, PROTECT_HKSV_SEGMENT_LENGTH, PROTECT_HKSV_TIMESHIFT_BUFFER_MAXLENGTH, PROTECT_SNAPSHOT_CACHE_MAXAGE } from "./settings.js";
+import { FetchError } from "unifi-protect";
+import { FfmpegStreamingProcess } from "./protect-ffmpeg-stream.js";
+import { ProtectRecordingDelegate } from "./protect-record.js";
+import { RtpDemuxer } from "./protect-rtp.js";
+import WebSocket from "ws";
+import events from "node:events";
+import ffmpegPath from "ffmpeg-for-homebridge";
+import { platform } from "node:process";
 // Camera streaming delegate implementation for Protect.
-class ProtectStreamingDelegate {
+export class ProtectStreamingDelegate {
+    // Create an instance of a HomeKit streaming delegate.
     constructor(protectCamera, resolutions) {
         this.api = protectCamera.api;
         this.config = protectCamera.platform.config;
-        this.debug = protectCamera.platform.debug.bind(protectCamera.platform);
         this.hap = protectCamera.api.hap;
         this.hksv = null;
-        this.log = protectCamera.platform.log;
-        this.name = protectCamera.name.bind(protectCamera);
+        this.log = protectCamera.log;
         this.nvr = protectCamera.nvr;
         this.ongoingSessions = {};
         this.protectCamera = protectCamera;
         this.pendingSessions = {};
         this.platform = protectCamera.platform;
+        this.probesizeOverride = 0;
+        this.probesizeOverrideCount = 0;
         this.rtspEntry = null;
         this.savedBitrate = 0;
         this.snapshotCache = {};
         this.verboseFfmpeg = false;
-        this.videoEncoder = this.config.videoEncoder || "libx264";
-        this.videoProcessor = this.config.videoProcessor || ffmpeg_for_homebridge_1.default || "ffmpeg";
+        this.videoEncoderOptions = this.getVideoEncoderOptions();
+        this.videoProcessor = this.config.videoProcessor || ffmpegPath || "ffmpeg";
         // Setup for HKSV, if enabled.
-        if (this.protectCamera.isHksv) {
-            this.hksv = new protect_record_1.ProtectRecordingDelegate(protectCamera);
+        if (this.protectCamera.hasHksv) {
+            this.hksv = new ProtectRecordingDelegate(protectCamera);
         }
         // Setup for our camera controller.
         const options = {
@@ -48,15 +40,15 @@ class ProtectStreamingDelegate {
             // Our streaming delegate - aka us.
             delegate: this,
             // Our recording capabilities for HomeKit Secure Video.
-            recording: !this.protectCamera.isHksv ? undefined : {
+            recording: !this.protectCamera.hasHksv ? undefined : {
                 delegate: this.hksv,
                 options: {
                     audio: {
                         codecs: [
                             {
                                 // Protect supports a 48 KHz sampling rate, and the low complexity AAC profile.
-                                samplerate: 5 /* this.api.hap.AudioRecordingSamplerate.KHZ_48 */,
-                                type: 0 /* this.api.hap.AudioRecordingCodecType.AAC_LC */
+                                samplerate: 5 /* AudioRecordingSamplerate.KHZ_48 */,
+                                type: 0 /* AudioRecordingCodecType.AAC_LC */
                             }
                         ]
                     },
@@ -64,21 +56,21 @@ class ProtectStreamingDelegate {
                         {
                             // The default HKSV segment length is 4000ms. It turns out that any setting less than that will disable
                             // HomeKit Secure Video.
-                            fragmentLength: settings_1.PROTECT_HKSV_SEGMENT_LENGTH,
-                            type: 0 /* this.api.hap.MediaContainerType.FRAGMENTED_MP4 */
+                            fragmentLength: PROTECT_HKSV_SEGMENT_LENGTH,
+                            type: 0 /* MediaContainerType.FRAGMENTED_MP4 */
                         }
                     ],
                     // Maximum prebuffer length supported. In Protect, this is effectively unlimited, but HomeKit only seems to
                     // request a maximum of a 4000ms prebuffer.
-                    prebufferLength: settings_1.PROTECT_HKSV_BUFFER_LENGTH,
+                    prebufferLength: PROTECT_HKSV_TIMESHIFT_BUFFER_MAXLENGTH,
                     video: {
                         parameters: {
                             // Through admittedly anecdotal testing on various G3 and G4 models, UniFi Protect seems to support
                             // only the H.264 Main profile, though it does support various H.264 levels, ranging from Level 3
                             // through Level 5.1 (G4 Pro at maximum resolution). However, HomeKit only supports Level 3.1, 3.2,
                             // and 4.0 currently.
-                            levels: [0 /* this.hap.H264Level.LEVEL3_1 */, 1 /* this.hap.H264Level.LEVEL3_2 */, 2 /* this.hap.H264Level.LEVEL4_0 */],
-                            profiles: [1 /* this.hap.H264Profile.MAIN */]
+                            levels: [0 /* H264Level.LEVEL3_1 */, 1 /* H264Level.LEVEL3_2 */, 2 /* H264Level.LEVEL4_0 */],
+                            profiles: [1 /* H264Profile.MAIN */]
                         },
                         resolutions: resolutions,
                         type: 0 /* this.api.hap.VideoCodecType.H264 */
@@ -86,18 +78,20 @@ class ProtectStreamingDelegate {
                 }
             },
             // Our motion sensor.
-            sensors: !this.protectCamera.isHksv ? undefined : {
+            sensors: !this.protectCamera.hasHksv ? undefined : {
                 motion: this.protectCamera.accessory.getService(this.hap.Service.MotionSensor)
             },
             streamingOptions: {
                 audio: {
                     codecs: [
                         {
-                            samplerate: 16 /* AudioStreamingSamplerate.KHZ_16 */,
+                            audioChannels: 1,
+                            bitrate: 0,
+                            samplerate: 24 /* AudioStreamingSamplerate.KHZ_24 */,
                             type: "AAC-eld" /* AudioStreamingCodecType.AAC_ELD */
                         }
                     ],
-                    twoWayAudio: this.protectCamera.twoWayAudio
+                    twoWayAudio: this.protectCamera.hints.twoWayAudio
                 },
                 supportedCryptoSuites: [0 /* this.hap.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80 */],
                 video: {
@@ -106,8 +100,8 @@ class ProtectStreamingDelegate {
                         // only the H.264 Main profile, though it does support various H.264 levels, ranging from Level 3
                         // through Level 5.1 (G4 Pro at maximum resolution). However, HomeKit only supports Level 3.1, 3.2,
                         // and 4.0 currently.
-                        levels: [0 /* this.hap.H264Level.LEVEL3_1 */, 1 /* this.hap.H264Level.LEVEL3_2 */, 2 /* this.hap.H264Level.LEVEL4_0 */],
-                        profiles: [1 /* this.hap.H264Profile.MAIN */]
+                        levels: [0 /* H264Level.LEVEL3_1 */, 1 /* H264Level.LEVEL3_2 */, 2 /* H264Level.LEVEL4_0 */],
+                        profiles: [1 /* H264Profile.MAIN */]
                     },
                     // Retrieve the list of supported resolutions from the camera and apply our best guesses for how to
                     // map specific resolutions to the available RTSP streams on a camera. Unfortunately, this creates
@@ -122,12 +116,11 @@ class ProtectStreamingDelegate {
     }
     // HomeKit image snapshot request handler.
     async handleSnapshotRequest(request, callback) {
-        var _a;
         const snapshot = await this.getSnapshot(request);
         // No snapshot was returned - we're done here.
         if (!snapshot) {
             if (callback) {
-                callback(new Error(this.name() + ": Unable to retrieve a snapshot"));
+                callback(new Error(this.protectCamera.name + ": Unable to retrieve a snapshot"));
             }
             return;
         }
@@ -136,39 +129,66 @@ class ProtectStreamingDelegate {
             callback(undefined, snapshot);
         }
         // Publish the snapshot as a data URL to MQTT, if configured.
-        (_a = this.nvr.mqtt) === null || _a === void 0 ? void 0 : _a.publish(this.protectCamera.accessory, "snapshot", "data:image/jpeg;base64," + snapshot.toString("base64"));
+        this.nvr.mqtt?.publish(this.protectCamera.accessory, "snapshot", "data:image/jpeg;base64," + snapshot.toString("base64"));
     }
     // Prepare to launch the video stream.
     async prepareStream(request, callback) {
-        const cameraConfig = this.protectCamera.accessory.context.device;
+        let reservePortFailed = false;
+        const rtpPortReservations = [];
+        // We use this utility to identify errors in reserving UDP ports for our use.
+        const reservePort = async (ipFamily = "ipv4", portCount = 1) => {
+            // If we've already failed, don't keep trying to find more ports.
+            if (reservePortFailed) {
+                return -1;
+            }
+            // Retrieve the ports we're looking for.
+            const assignedPort = await this.platform.rtpPorts.reservePort(ipFamily, portCount);
+            // We didn't get the ports we requested.
+            if (assignedPort === -1) {
+                reservePortFailed = true;
+            }
+            else {
+                // Add this reservation the list of ports we've successfully requested.
+                rtpPortReservations.push(assignedPort);
+                if (portCount === 2) {
+                    rtpPortReservations.push(assignedPort + 1);
+                }
+            }
+            // Return them.
+            return assignedPort;
+        };
         // Check if audio support is enabled.
-        const isAudioEnabled = this.nvr.optionEnabled(cameraConfig, "Audio", true, request.targetAddress);
+        const isAudioEnabled = this.nvr.optionEnabled(this.protectCamera.ufp, "Audio", true, request.targetAddress);
         // We need to check for AAC support because it's going to determine whether we support audio.
-        const hasLibFdk = isAudioEnabled && (await protect_ffmpeg_stream_1.FfmpegStreamingProcess.codecEnabled(this.videoProcessor, "libfdk_aac", this.log));
+        const hasLibFdk = isAudioEnabled && (await FfmpegStreamingProcess.codecEnabled(this.videoProcessor, "libfdk_aac", this.log));
         // Setup our audio plumbing.
-        const audioIncomingRtcpPort = (await (0, camera_utils_1.reservePorts)({ count: 1 }))[0];
-        const audioIncomingPort = (hasLibFdk && this.protectCamera.twoWayAudio) ? (await (0, camera_utils_1.reservePorts)({ count: 1 }))[0] : -1;
-        const audioIncomingRtpPort = (hasLibFdk && this.protectCamera.twoWayAudio) ? (await (0, camera_utils_1.reservePorts)({ count: 2 }))[0] : -1;
+        const audioIncomingRtcpPort = (await reservePort(request.addressVersion));
+        const audioIncomingPort = (hasLibFdk && this.protectCamera.hints.twoWayAudio) ? (await reservePort(request.addressVersion)) : -1;
+        const audioIncomingRtpPort = (hasLibFdk && this.protectCamera.hints.twoWayAudio) ? (await reservePort(request.addressVersion, 2)) : -1;
         const audioSSRC = this.hap.CameraController.generateSynchronisationSource();
         if (!hasLibFdk) {
-            this.log.info("%s: Audio support disabled.%s", this.name(), isAudioEnabled ? " A version of FFmpeg that is compiled with fdk_aac support is required to support audio." : "");
+            this.log.info("Audio support disabled.%s", isAudioEnabled ? " A version of FFmpeg that is compiled with fdk_aac support is required to support audio." : "");
         }
         let rtpDemuxer = null;
         let talkBack = null;
-        if (hasLibFdk && this.protectCamera.twoWayAudio) {
+        if (hasLibFdk && this.protectCamera.hints.twoWayAudio) {
             // Setup the RTP demuxer for two-way audio scenarios.
-            rtpDemuxer = new protect_rtp_1.RtpDemuxer(this, request.addressVersion, audioIncomingPort, audioIncomingRtcpPort, audioIncomingRtpPort);
+            rtpDemuxer = new RtpDemuxer(this, request.addressVersion, audioIncomingPort, audioIncomingRtcpPort, audioIncomingRtpPort);
             // Request the talkback websocket from the controller.
-            const params = new URLSearchParams({ camera: cameraConfig.id });
-            talkBack = await this.nvr.nvrApi.getWsEndpoint(this.nvr.nvrApi.wsUrl() + "/talkback?" + params.toString());
+            const params = new URLSearchParams({ camera: this.protectCamera.ufp.id });
+            talkBack = await this.nvr.ufpApi.getWsEndpoint("talkback", params);
             // Something went wrong and we don't have a talkback websocket.
             if (!talkBack) {
-                this.log.error("%s: Unable to open the return audio channel.", this.name());
+                this.log.error("Unable to open the return audio channel.");
             }
         }
         // Setup our video plumbing.
-        const videoReturnPort = (await (0, camera_utils_1.reservePorts)({ count: 1 }))[0];
+        const videoReturnPort = (await reservePort(request.addressVersion));
         const videoSSRC = this.hap.CameraController.generateSynchronisationSource();
+        // If we've had failures to retrieve the UDP ports we're looking for, inform the user.
+        if (reservePortFailed) {
+            this.log.error("Unable to reserve the UDP ports needed to begin streaming.");
+        }
         const sessionInfo = {
             address: request.targetAddress,
             addressVersion: request.addressVersion,
@@ -180,6 +200,7 @@ class ProtectStreamingDelegate {
             audioSSRC: audioSSRC,
             hasLibFdk: hasLibFdk,
             rtpDemuxer: rtpDemuxer,
+            rtpPortReservations: rtpPortReservations,
             talkBack: talkBack,
             videoCryptoSuite: request.video.srtpCryptoSuite,
             videoPort: request.video.port,
@@ -192,7 +213,7 @@ class ProtectStreamingDelegate {
         // it simple and don't use a demuxer.
         const response = {
             audio: {
-                port: (hasLibFdk && this.protectCamera.twoWayAudio) ? audioIncomingPort : audioIncomingRtcpPort,
+                port: (hasLibFdk && this.protectCamera.hints.twoWayAudio) ? audioIncomingPort : audioIncomingRtcpPort,
                 // eslint-disable-next-line camelcase
                 srtp_key: request.audio.srtp_key,
                 // eslint-disable-next-line camelcase
@@ -214,26 +235,25 @@ class ProtectStreamingDelegate {
     }
     // Launch the Protect video (and audio) stream.
     async startStream(request, callback) {
-        var _a, _b, _c, _d, _e, _f;
-        const cameraConfig = this.protectCamera.accessory.context.device;
         const sessionInfo = this.pendingSessions[request.sessionID];
         const sdpIpVersion = sessionInfo.addressVersion === "ipv6" ? "IP6 " : "IP4";
         // If we aren't connected, we're done.
-        if (cameraConfig.state !== "CONNECTED") {
+        if (this.protectCamera.ufp.state !== "CONNECTED") {
             const errorMessage = "Unable to start video stream: the camera is offline or unavailable.";
-            this.log.error("%s: %s", this.name(), errorMessage);
-            callback(new Error(this.name() + ": " + errorMessage));
+            this.log.error(errorMessage);
+            callback(new Error(this.protectCamera.name + ": " + errorMessage));
             return;
         }
         // Find the best RTSP stream based on what we're looking for.
-        this.rtspEntry = this.protectCamera.findRtsp(request.video.width, request.video.height, cameraConfig, sessionInfo.address);
+        this.rtspEntry = this.protectCamera.findRtsp(request.video.width, request.video.height, this.protectCamera.ufp, sessionInfo.address);
         if (!this.rtspEntry) {
             const errorMessage = "Unable to start video stream: no valid RTSP stream profile was found.";
-            this.log.error("%s: %s %sx%s, %s fps, %s kbps.", this.name(), errorMessage, request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate);
-            callback(new Error(this.name() + ": " + errorMessage));
+            this.log.error("%s %sx%s, %s fps, %s kbps.", errorMessage, request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate);
+            callback(new Error(this.protectCamera.name + ": " + errorMessage));
             return;
         }
-        // Save our current bitrate before we modify it, but only if we're the first stream to catch concurrent streaming clients.
+        // Save our current bitrate before we modify it, but only if we're the first stream - we don't want to do this for
+        // concurrent streaming clients for this camera.
         if (!this.savedBitrate) {
             this.savedBitrate = this.protectCamera.getBitrate(this.rtspEntry.channel.id);
             if (this.savedBitrate < 0) {
@@ -243,8 +263,14 @@ class ProtectStreamingDelegate {
         // Set the desired bitrate in Protect. We don't need to for this to return, because Protect
         // will adapt the stream once it processes the configuration change.
         await this.protectCamera.setBitrate(this.rtspEntry.channel.id, request.video.max_bit_rate * 1000);
-        // Are we transcoding?
-        const isTranscoding = this.nvr.optionEnabled(cameraConfig, "Video.Transcode", false, sessionInfo.address);
+        // Has the user explicitly configured transcoding, or are we a high latency session (e.g. cellular)? If we're high latency, we'll transcode
+        // by default unless the user has asked us not to. Why? It generally results in a speedier experience, at the expense of some stream quality
+        // (HomeKit tends to request far lower bitrates than Protect is capable of producing).
+        //
+        // How do we determine if we're a high latency connection? We look at the RTP packet time of the audio packet time for a hint. HomeKit uses values
+        // of 20, 30, 40, and 60ms. We make an assumption, validated by lots of real-world testing, that when we see 60ms used by HomeKit, it's a
+        // high latency connection and act accordingly.
+        const isTranscoding = this.protectCamera.hints.transcode || ((request.audio.packet_time >= 60) && this.protectCamera.hints.transcodeHighLatency);
         // Set our packet size to be 564. Why? MPEG transport stream (TS) packets are 188 bytes in size each.
         // These packets transmit the video data that you ultimately see on your screen and are transmitted using
         // UDP. Each UDP packet is 1316 bytes in size, before being encapsulated in IP. We want to get as many
@@ -267,9 +293,8 @@ class ProtectStreamingDelegate {
         const videomtu = 188 * 3;
         const audiomtu = 188 * 1;
         // -hide_banner                     Suppress printing the startup banner in FFmpeg.
-        // -probesize 2048                  How many bytes should be analyzed for stream information. We default to to analyze time should be spent analyzing
-        //                                  the input stream, in microseconds.
-        // -max_delay 500000                Set an upper limit on how much time FFmpeg can take in demuxing packets.
+        // -probesize number                How many bytes should be analyzed for stream information.
+        // -max_delay 500000                Set an upper limit on how much time FFmpeg can take in demuxing packets, in microseconds.
         // -r fps                           Set the input frame rate for the video stream.
         // -rtsp_transport tcp              Tell the RTSP stream handler that we're looking for a TCP connection.
         // -i this.rtspEntry.url            RTSPS URL to get our input stream from.
@@ -277,10 +302,11 @@ class ProtectStreamingDelegate {
         //                                  and video tracks in opposite locations from where FFmpeg typically expects them. This
         //                                  setting is a more general solution than naming the track locations directly in case
         //                                  Protect changes this in the future.
-        //                                  Yes, we included these above as well: they need to be included for every I/O stream to maximize effectiveness it seems.
+        //
+        //                                  Yes, we included these above as well: they need to be included for each I/O stream to maximize effectiveness it seems.
         const ffmpegArgs = [
             "-hide_banner",
-            "-probesize", "16384",
+            "-probesize", this.probesizeOverride ? this.probesizeOverride.toString() : this.protectCamera.hints.probesize.toString(),
             "-max_delay", "500000",
             "-r", this.rtspEntry.channel.fps.toString(),
             "-rtsp_transport", "tcp",
@@ -288,23 +314,21 @@ class ProtectStreamingDelegate {
             "-map", "0:v:0"
         ];
         // Inform the user.
-        this.log.info("%s: Streaming request from %s: %sx%s@%sfps, %s kbps. %s %s, %s kbps.", this.name(), sessionInfo.address, request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate, isTranscoding ? "Transcoding" : "Using", this.rtspEntry.name, this.rtspEntry.channel.bitrate / 1000);
+        this.log.info("Streaming request from %s%s: %sx%s@%sfps, %s kbps. %s %s, %s kbps. Audio packet time = %s", sessionInfo.address, (request.audio.packet_time === 60) ? " (high latency connection)" : "", request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate, isTranscoding ? (this.protectCamera.hasHwAccel ? "Hardware accelerated transcoding" : "Transcoding") : "Using", this.rtspEntry.name, this.rtspEntry.channel.bitrate / 1000, request.audio.packet_time);
         // Check to see if we're transcoding. If we are, set the right FFmpeg encoder options. If not, copy the video stream.
         if (isTranscoding) {
             // Configure our video parameters for transcoding:
             //
-            // -vcodec libx264     Copy the stream withour reencoding it.
-            // -pix_fmt yuvj420p   Use the yuvj420p pixel format, which is what Protect uses.
             // -profile:v high     Use the H.264 high profile when encoding, which provides for better stream quality and size efficiency.
-            // -preset veryfast    Use the veryfast encoding preset in libx264, which provides a good balance of encoding speed and quality.
+            // -level:v high       Use the H.264 profile level that HomeKit is requesting when encoding.
             // -bf 0               Disable B-frames when encoding to increase compatibility against occasionally finicky HomeKit clients.
             // -b:v bitrate        The average bitrate to use for this stream. This is specified by HomeKit.
             // -bufsize size       This is the decoder buffer size, which drives the variability / quality of the output bitrate.
-            // -maxrate bitrate    The maximum bitrate tolerance, used with -bufsize. We set this to max_bit_rate to effectively
+            // -maxrate bitrate    The maximum bitrate tolerance, used with -bufsize. We set this with max_bit_rate to effectively
             //                     create a constant bitrate.
             // -filter:v fps=fps=  Use the fps filter to get to the frame rate requested by HomeKit. This has better performance characteristics
             //                     for Protect rather than using "-r".
-            ffmpegArgs.push("-vcodec", this.videoEncoder, "-pix_fmt", "yuvj420p", "-profile:v", "high", "-preset", "veryfast", "-bf", "0", "-b:v", request.video.max_bit_rate.toString() + "k", "-bufsize", (2 * request.video.max_bit_rate).toString() + "k", "-maxrate", request.video.max_bit_rate.toString() + "k", "-filter:v", "fps=fps=" + request.video.fps.toString());
+            ffmpegArgs.push(...this.videoEncoderOptions, "-profile:v", this.getH264Profile(request.video.profile), "-level:v", this.getH264Level(request.video.level), "-bf", "0", "-b:v", request.video.max_bit_rate.toString() + "k", "-bufsize", (2 * request.video.max_bit_rate).toString() + "k", "-maxrate", request.video.max_bit_rate.toString() + "k", "-filter:v", "fps=fps=" + request.video.fps.toString());
         }
         else {
             // Configure our video parameters for just copying the input stream from Protect - it tends to be quite solid in most cases:
@@ -341,15 +365,15 @@ class ProtectStreamingDelegate {
         // -ac 1                            Set the number of audio channels to 1.
         if (sessionInfo.hasLibFdk) {
             // Configure our audio parameters.
-            ffmpegArgs.push("-map", "0:a:0", "-acodec", "libfdk_aac", "-profile:a", "aac_eld", "-flags", "+global_header", "-f", "null", "-ar", request.audio.sample_rate.toString() + "k", "-b:a", request.audio.max_bit_rate.toString() + "k", "-bufsize", (2 * request.audio.max_bit_rate).toString() + "k", "-ac", "1");
+            ffmpegArgs.push("-map", "0:a:0", "-acodec", "libfdk_aac", "-profile:a", "aac_eld", "-flags", "+global_header", "-f", "null", "-ar", request.audio.sample_rate.toString() + "k", "-afterburner", "1", "-eld_sbr", "1", "-eld_v2", "1", "-b:a", request.audio.max_bit_rate.toString() + "k", "-bufsize", (2 * request.audio.max_bit_rate).toString() + "k", "-ac", "1");
             // If we are audio filtering, address it here.
-            if (this.nvr.optionEnabled(cameraConfig, "Audio.Filter.Noise", false, sessionInfo.address)) {
+            if (this.nvr.optionEnabled(this.protectCamera.ufp, "Audio.Filter.Noise", false, sessionInfo.address)) {
                 const afOptions = [];
                 // See what the user has set for the afftdn filter for this camera.
-                let fftNr = parseFloat((_a = this.nvr.optionGet(cameraConfig, "Audio.Filter.Noise.FftNr", sessionInfo.address)) !== null && _a !== void 0 ? _a : "");
+                let fftNr = parseFloat(this.nvr.optionGet(this.protectCamera.ufp, "Audio.Filter.Noise.FftNr", sessionInfo.address) ?? "");
                 // If we have an invalid setting, use the defaults.
                 if ((fftNr !== fftNr) || (fftNr < 0.01) || (fftNr > 97)) {
-                    fftNr = (fftNr > 97) ? 97 : ((fftNr < 0.01) ? 0.01 : settings_1.PROTECT_FFMPEG_AUDIO_FILTER_FFTNR);
+                    fftNr = (fftNr > 97) ? 97 : ((fftNr < 0.01) ? 0.01 : PROTECT_FFMPEG_AUDIO_FILTER_FFTNR);
                 }
                 // nt=w  Focus on eliminating white noise.
                 // om=o  Output the filtered audio.
@@ -357,21 +381,23 @@ class ProtectStreamingDelegate {
                 // tr=1  Enable residual tracking.
                 // nr=X  Noise reduction value in decibels.
                 afOptions.push("afftdn=nt=w:om=o:tn=1:tr=1:nr=" + fftNr.toString());
-                let highpass = (_b = this.nvr.optionGet(cameraConfig, "Audio.Filter.Noise.HighPass", sessionInfo.address)) !== null && _b !== void 0 ? _b : (this.nvr.optionEnabled(cameraConfig, "Audio.Filter.Noise.HighPass", false) ? settings_1.PROTECT_FFMPEG_AUDIO_FILTER_HIGHPASS.toString() : undefined);
-                let lowpass = (_c = this.nvr.optionGet(cameraConfig, "Audio.Filter.Noise.LowPass", sessionInfo.address)) !== null && _c !== void 0 ? _c : (this.nvr.optionEnabled(cameraConfig, "Audio.Filter.Noise.LowPass", false) ? settings_1.PROTECT_FFMPEG_AUDIO_FILTER_LOWPASS.toString() : undefined);
+                let highpass = this.nvr.optionGet(this.protectCamera.ufp, "Audio.Filter.Noise.HighPass", sessionInfo.address) ??
+                    (this.nvr.optionEnabled(this.protectCamera.ufp, "Audio.Filter.Noise.HighPass", false) ? PROTECT_FFMPEG_AUDIO_FILTER_HIGHPASS.toString() : undefined);
+                let lowpass = this.nvr.optionGet(this.protectCamera.ufp, "Audio.Filter.Noise.LowPass", sessionInfo.address) ??
+                    (this.nvr.optionEnabled(this.protectCamera.ufp, "Audio.Filter.Noise.LowPass", false) ? PROTECT_FFMPEG_AUDIO_FILTER_LOWPASS.toString() : undefined);
                 // Only set the highpass and lowpass filters if the user has explicitly enabled them.
                 if ((highpass !== undefined) || (lowpass !== undefined)) {
                     // See what the user has set for the highpass filter for this camera.
-                    highpass = parseInt(highpass !== null && highpass !== void 0 ? highpass : "");
+                    highpass = parseInt(highpass ?? "");
                     // If we have an invalid setting, use the defaults.
                     if ((highpass !== highpass) || (highpass < 0)) {
-                        highpass = settings_1.PROTECT_FFMPEG_AUDIO_FILTER_HIGHPASS;
+                        highpass = PROTECT_FFMPEG_AUDIO_FILTER_HIGHPASS;
                     }
                     // See what the user has set for the highpass filter for this camera.
-                    lowpass = parseInt(lowpass !== null && lowpass !== void 0 ? lowpass : "");
+                    lowpass = parseInt(lowpass ?? "");
                     // If we have an invalid setting, use the defaults.
                     if ((lowpass !== lowpass) || (lowpass < 0)) {
-                        lowpass = settings_1.PROTECT_FFMPEG_AUDIO_FILTER_LOWPASS;
+                        lowpass = PROTECT_FFMPEG_AUDIO_FILTER_LOWPASS;
                     }
                     afOptions.push("highpass=f=" + highpass.toString(), "lowpass=f=" + lowpass.toString());
                 }
@@ -396,12 +422,16 @@ class ProtectStreamingDelegate {
             ffmpegArgs.push("-loglevel", "level+debug");
         }
         // Combine everything and start an instance of FFmpeg.
-        const ffmpegStream = new protect_ffmpeg_stream_1.FfmpegStreamingProcess(this, request.sessionID, ffmpegArgs, (sessionInfo.hasLibFdk && this.protectCamera.twoWayAudio) ? undefined : { addressVersion: sessionInfo.addressVersion, port: sessionInfo.videoReturnPort }, callback);
+        const ffmpegStream = new FfmpegStreamingProcess(this, request.sessionID, ffmpegArgs, (sessionInfo.hasLibFdk && this.protectCamera.hints.twoWayAudio) ? undefined : { addressVersion: sessionInfo.addressVersion, port: sessionInfo.videoReturnPort }, callback);
         // Some housekeeping for our FFmpeg and demuxer sessions.
-        this.ongoingSessions[request.sessionID] = { ffmpeg: [ffmpegStream], rtpDemuxer: sessionInfo.rtpDemuxer };
+        this.ongoingSessions[request.sessionID] = {
+            ffmpeg: [ffmpegStream],
+            rtpDemuxer: sessionInfo.rtpDemuxer,
+            rtpPortReservations: sessionInfo.rtpPortReservations
+        };
         delete this.pendingSessions[request.sessionID];
         // If we aren't doing two-way audio, we're done here. For two-way audio...we have some more plumbing to do.
-        if (!sessionInfo.hasLibFdk || !this.protectCamera.twoWayAudio) {
+        if (!sessionInfo.hasLibFdk || !this.protectCamera.hints.twoWayAudio) {
             return;
         }
         // Session description protocol message that FFmpeg will share with HomeKit.
@@ -416,19 +446,19 @@ class ProtectStreamingDelegate {
         // t             Timestamps for the start and end of the session.
         // m             Media type - audio, adhering to RTP/AVP, payload type 110.
         // b             Bandwidth information - application specific, 24k.
-        // a=rtpmap      Payload type 110 corresponds to an MP4 stream.
+        // a=rtpmap      Payload type 110 corresponds to an MP4 stream. Format is MPEG4-GENERIC/<audio clock rate>/<audio channels>
         // a=fmtp        For payload type 110, use these format parameters.
         // a=crypto      Crypto suite to use for this session.
         const sdpReturnAudio = [
             "v=0",
             "o=- 0 0 IN " + sdpIpVersion + " 127.0.0.1",
-            "s=" + this.name() + " Audio Talkback",
+            "s=" + this.protectCamera.name + " Audio Talkback",
             "c=IN " + sdpIpVersion + " " + sessionInfo.address,
             "t=0 0",
             "m=audio " + sessionInfo.audioIncomingRtpPort.toString() + " RTP/AVP 110",
             "b=AS:24",
-            "a=rtpmap:110 MPEG4-GENERIC/16000/1",
-            "a=fmtp:110 profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3; config=F8F0212C00BC00",
+            "a=rtpmap:110 MPEG4-GENERIC/24000/1",
+            "a=fmtp:110 profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3; config=F8EC212C00BC00",
             "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:" + sessionInfo.audioSRTP.toString("base64")
         ].join("\n");
         // Configure the audio portion of the command line, if we have a version of FFmpeg supports libfdk_aac. Options we use are:
@@ -438,11 +468,13 @@ class ProtectStreamingDelegate {
         // -f sdp                 Specify that our input will be an SDP file.
         // -acodec libfdk_aac     Decode AAC input.
         // -i pipe:0              Read input from standard input.
-        // -acodec aac            Encode to AAC. This is set by Protect.
+        // -acodec libfdk_aac     Encode to AAC. This format is set by Protect.
         // -flags +global_header  Sets the global header in the bitstream.
-        // -ar samplerate         Sample rate to use for this audio. This is specified by Protect.
-        // -b:a bitrate           Bitrate to use for this audio. This is specified by Protect.
-        // -ac 1                  Set the number of audio channels to 1. This is specified by Protect.
+        // -afterburner 1         Increases audio quality at the expense of needing a little bit more computational power in libfdk_aac.
+        // -eld_sbr 1             Use spectral band replication to further enhance audio.
+        // -eld_v2 1              Use the enhanced low delay v2 standard for better audio characteristics.
+        // -af                    Use the aformat audio filter to set the channel layout to mono and use the Protect-provided sample
+        //                        rate to produce the right audio needed for talkback.
         // -f adts                Transmit an ADTS stream.
         // pipe:1                 Output the ADTS stream to standard output.
         const ffmpegReturnAudioCmd = [
@@ -451,11 +483,12 @@ class ProtectStreamingDelegate {
             "-f", "sdp",
             "-acodec", "libfdk_aac",
             "-i", "pipe:0",
+            "-acodec", "libfdk_aac",
             "-flags", "+global_header",
-            "-b:a", cameraConfig.talkbackSettings.bitsPerSample.toString() + "k",
-            "-ac", cameraConfig.talkbackSettings.channels.toString(),
-            "-ar", cameraConfig.talkbackSettings.samplingRate.toString(),
-            "-loglevel", "level+verbose",
+            "-afterburner", "1",
+            "-eld_sbr", "1",
+            "-eld_v2", "1",
+            "-af", "aformat=channel_layouts=mono:sample_rates=" + this.protectCamera.ufp.talkbackSettings.samplingRate.toString(),
             "-f", "adts",
             "pipe:1"
         ];
@@ -474,68 +507,67 @@ class ProtectStreamingDelegate {
             let openListener;
             if (sessionInfo.talkBack) {
                 // Open the talkback connection.
-                ws = new ws_1.default(sessionInfo.talkBack, { rejectUnauthorized: false });
+                ws = new WebSocket(sessionInfo.talkBack, { rejectUnauthorized: false });
                 isTalkbackLive = true;
                 // Catch any errors and inform the user, if needed.
-                ws === null || ws === void 0 ? void 0 : ws.once("error", (error) => {
+                ws?.once("error", (error) => {
                     // Ignore timeout errors, but notify the user about anything else.
                     if (error.code !== "ETIMEDOUT") {
-                        this.log.error("%s: Error in communicating with the return audio channel: %s", this.name(), error);
+                        this.log.error("Error in communicating with the return audio channel: %s", error);
                     }
-                    ws === null || ws === void 0 ? void 0 : ws.terminate();
+                    ws?.terminate();
                 });
                 // Catch any stray open events after we've closed.
-                ws === null || ws === void 0 ? void 0 : ws.on("open", openListener = () => {
+                ws?.on("open", openListener = () => {
                     // If we've somehow opened after we've wrapped up talkback, terminate the connection.
                     if (!isTalkbackLive) {
-                        ws === null || ws === void 0 ? void 0 : ws.terminate();
+                        ws?.terminate();
                     }
                 });
                 // Cleanup after ourselves on close.
-                ws === null || ws === void 0 ? void 0 : ws.once("close", () => {
-                    ws === null || ws === void 0 ? void 0 : ws.removeListener("open", openListener);
+                ws?.once("close", () => {
+                    ws?.removeListener("open", openListener);
                 });
             }
             // Wait for the first RTP packet to be received before trying to launch FFmpeg.
             if (sessionInfo.rtpDemuxer) {
-                await events_1.default.once(sessionInfo.rtpDemuxer, "rtp");
+                await events.once(sessionInfo.rtpDemuxer, "rtp");
                 // If we've already closed the RTP demuxer, we're done here,
                 if (!sessionInfo.rtpDemuxer.isRunning) {
                     // Clean up our talkback websocket.
-                    ws === null || ws === void 0 ? void 0 : ws.terminate();
+                    ws?.terminate();
                     return;
                 }
             }
             // Fire up FFmpeg and start processing the incoming audio.
-            const ffmpegReturnAudio = new protect_ffmpeg_stream_1.FfmpegStreamingProcess(this, request.sessionID, ffmpegReturnAudioCmd);
+            const ffmpegReturnAudio = new FfmpegStreamingProcess(this, request.sessionID, ffmpegReturnAudioCmd);
             // Setup housekeeping for the twoway FFmpeg session.
             this.ongoingSessions[request.sessionID].ffmpeg.push(ffmpegReturnAudio);
             // Feed the SDP session description to FFmpeg on stdin.
-            (_d = ffmpegReturnAudio.stdin) === null || _d === void 0 ? void 0 : _d.end(sdpReturnAudio + "\n");
+            ffmpegReturnAudio.stdin?.end(sdpReturnAudio + "\n");
             // Send the audio.
-            (_e = ffmpegReturnAudio.stdout) === null || _e === void 0 ? void 0 : _e.on("data", dataListener = (data) => {
-                ws === null || ws === void 0 ? void 0 : ws.send(data, (error) => {
+            ffmpegReturnAudio.stdout?.on("data", dataListener = (data) => {
+                ws?.send(data, (error) => {
                     // This happens when an error condition is encountered on sending data to the websocket.
                     // We assume the worst and close our talkback channel.
                     if (error) {
-                        ws === null || ws === void 0 ? void 0 : ws.terminate();
+                        ws?.terminate();
                     }
                 });
             });
             // Make sure we terminate the talkback websocket when we're done.
-            (_f = ffmpegReturnAudio.ffmpegProcess) === null || _f === void 0 ? void 0 : _f.once("exit", () => {
-                var _a;
+            ffmpegReturnAudio.ffmpegProcess?.once("exit", () => {
                 // Make sure we catch any stray connections that may be too slow to open.
                 isTalkbackLive = false;
                 // Close the websocket.
-                if (((ws === null || ws === void 0 ? void 0 : ws.readyState) === ws_1.default.CLOSING) || ((ws === null || ws === void 0 ? void 0 : ws.readyState) === ws_1.default.OPEN)) {
-                    ws === null || ws === void 0 ? void 0 : ws.terminate();
+                if ((ws?.readyState === WebSocket.CLOSING) || (ws?.readyState === WebSocket.OPEN)) {
+                    ws?.terminate();
                 }
-                (_a = ffmpegReturnAudio.stdout) === null || _a === void 0 ? void 0 : _a.removeListener("data", dataListener);
+                ffmpegReturnAudio.stdout?.removeListener("data", dataListener);
             });
         }
         catch (error) {
-            this.log.error("%s: Unable to connect to the return audio channel: %s", this.name(), error);
+            this.log.error("Unable to connect to the return audio channel: %s", error);
         }
     }
     // Process incoming stream requests.
@@ -546,7 +578,7 @@ class ProtectStreamingDelegate {
                 break;
             case "reconfigure" /* StreamRequestTypes.RECONFIGURE */:
                 // Once FFmpeg is updated to support this, we'll enable this one.
-                this.log.info("%s: Streaming parameters adjustment requested by HomeKit: %sx%s, %s fps, %s kbps.", this.name(), request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate);
+                this.log.info("Streaming parameters adjustment requested by HomeKit: %sx%s, %s fps, %s kbps.", request.video.width, request.video.height, request.video.fps, request.video.max_bit_rate);
                 // Set the desired bitrate in Protect.
                 if (this.rtspEntry) {
                     await this.protectCamera.setBitrate(this.rtspEntry.channel.id, request.video.max_bit_rate * 1000);
@@ -563,71 +595,83 @@ class ProtectStreamingDelegate {
     // Retrieve a cached snapshot, if available.
     getCachedSnapshot(cameraMac) {
         // If we have an image from the last few seconds, we can use it. Otherwise, we're done.
-        if (!this.snapshotCache[cameraMac] || ((Date.now() - this.snapshotCache[cameraMac].time) > (60 * 1000))) {
+        if (!this.snapshotCache[cameraMac] || ((Date.now() - this.snapshotCache[cameraMac].time) > (PROTECT_SNAPSHOT_CACHE_MAXAGE * 1000))) {
             delete this.snapshotCache[cameraMac];
             return null;
         }
         return this.snapshotCache[cameraMac].image;
     }
     // Take a snapshot.
-    async getSnapshot(request) {
-        const cameraConfig = this.protectCamera.accessory.context.device;
-        const params = new URLSearchParams({ force: "true" });
+    async getSnapshot(request, isLoggingErrors = true) {
+        const logError = (message, ...parameters) => {
+            // We don't need to log errors for snapshot cache refreshes.
+            if (isLoggingErrors) {
+                this.log.error(message, ...parameters);
+            }
+        };
+        const params = new URLSearchParams({ ts: Date.now().toString() });
         // If we aren't connected, we're done.
-        if (cameraConfig.state !== "CONNECTED") {
-            this.log.error("%s: Unable to retrieve a snapshot: the camera is offline or unavailable.", this.name());
+        if (this.protectCamera.ufp.state !== "CONNECTED") {
+            logError("Unable to retrieve a snapshot: the camera is offline or unavailable.");
             return null;
         }
         // If we have details of the snapshot request, use it to request the right size.
         if (request) {
-            params.append("width", request.width.toString());
-            params.append("height", request.height.toString());
+            params.append("h", request.height.toString());
+            params.append("w", request.width.toString());
+        }
+        // Don't log the inevitable API errors related to response delays from the Protect controller.
+        const savedLogState = this.nvr.logApiErrors;
+        if (!isLoggingErrors) {
+            this.nvr.logApiErrors = false;
         }
         // Request the image from the controller.
-        const response = await this.nvr.nvrApi.fetch(this.protectCamera.snapshotUrl + "?" + params.toString(), { method: "GET" }, true, false);
-        // Occasional snapshot failures will happen. The controller isn't always able to generate them if
-        // it's already generating one, or it's requested too quickly after the last one.
-        if (!(response === null || response === void 0 ? void 0 : response.ok)) {
+        const response = await this.nvr.ufpApi.fetch(this.protectCamera.snapshotUrl + "?" + params.toString(), { method: "GET" }, true, false);
+        if (!isLoggingErrors) {
+            this.nvr.logApiErrors = savedLogState;
+        }
+        // Occasional snapshot failures will happen. The controller isn't always able to generate them if it's already generating one,
+        // or it's requested too quickly after the last one.
+        if (!response?.ok) {
             // See if we have an image cached that we can use instead.
-            const cachedSnapshot = this.getCachedSnapshot(cameraConfig.mac);
+            const cachedSnapshot = this.getCachedSnapshot(this.protectCamera.ufp.mac);
             if (cachedSnapshot) {
-                this.log.error("%s: Unable to retrieve a snapshot. Using the most recent cached snapshot instead.", this.name());
+                logError("Unable to retrieve a snapshot. Using the most recent cached snapshot instead.");
                 return cachedSnapshot;
             }
-            this.log.error("%s: Unable to retrieve a snapshot.%s", this.name(), response ? " " + response.status.toString() + " - " + response.statusText + "." : "");
+            logError("Unable to retrieve a snapshot.%s", response ? " " + response.status.toString() + " - " + response.statusText + "." : "");
             return null;
         }
         try {
             // Retrieve the image.
-            this.snapshotCache[cameraConfig.mac] = { image: Buffer.from(await response.arrayBuffer()), time: Date.now() };
-            return this.snapshotCache[cameraConfig.mac].image;
+            this.snapshotCache[this.protectCamera.ufp.mac] = { image: Buffer.from(await response.arrayBuffer()), time: Date.now() };
+            return this.snapshotCache[this.protectCamera.ufp.mac].image;
         }
         catch (error) {
-            if (error instanceof unifi_protect_1.FetchError) {
+            if (error instanceof FetchError) {
                 let cachedSnapshot;
                 switch (error.code) {
                     case "ERR_STREAM_PREMATURE_CLOSE":
-                        cachedSnapshot = this.getCachedSnapshot(cameraConfig.mac);
+                        cachedSnapshot = this.getCachedSnapshot(this.protectCamera.ufp.mac);
                         if (cachedSnapshot) {
-                            this.log.error("%s: Unable to retrieve a snapshot. Using a cached snapshot instead.", this.name());
+                            logError("Unable to retrieve a snapshot. Using a cached snapshot instead.");
                             return cachedSnapshot;
                         }
-                        this.log.error("%s: Unable to retrieve a snapshot: the Protect controller closed the connection prematurely.", this.name());
+                        logError("Unable to retrieve a snapshot: the Protect controller closed the connection prematurely.");
                         return null;
                         break;
                     default:
-                        this.log.error("%s: Unknown error: %s", this.name(), error.message);
+                        this.log.error("Unknown error: %s", error.message);
                         return null;
                         break;
                 }
             }
-            this.log.error("%s: An error occurred while making a snapshot request: %s.", this.name(), error);
+            this.log.error("An error occurred while making a snapshot request: %s.", error);
             return null;
         }
     }
     // Close a video stream.
     async stopStream(sessionId) {
-        var _a, _b;
         try {
             // Stop any FFmpeg instances we have running.
             if (this.ongoingSessions[sessionId]) {
@@ -635,18 +679,25 @@ class ProtectStreamingDelegate {
                     ffmpegProcess.stop();
                 }
                 // Close the demuxer, if we have one.
-                (_a = this.ongoingSessions[sessionId].rtpDemuxer) === null || _a === void 0 ? void 0 : _a.close();
+                this.ongoingSessions[sessionId].rtpDemuxer?.close();
                 // Inform the user.
-                this.log.info("%s: Stopped video streaming session.", this.name());
+                this.log.info("Stopped video streaming session.");
+                // Release our port reservations.
+                this.ongoingSessions[sessionId].rtpPortReservations.map(x => this.platform.rtpPorts.freePort(x));
+            }
+            // On the off chance we were signaled to prepare to start streaming, but never actually started streaming, cleanup after ourselves.
+            if (this.pendingSessions[sessionId]) {
+                // Release our port reservations.
+                this.pendingSessions[sessionId].rtpPortReservations.map(x => this.platform.rtpPorts.freePort(x));
             }
             // Delete the entries.
             delete this.pendingSessions[sessionId];
             delete this.ongoingSessions[sessionId];
             // If we've completed all streaming sessions, restore any changed settings, such as bitrate, for HomeKit Secure Video.
             if (!this.ongoingSessions.length) {
-                if ((_b = this.hksv) === null || _b === void 0 ? void 0 : _b.isRecording) {
-                    // Restore HKSV settings.
-                    await this.hksv.updateRecordingActive(this.hksv.isRecording);
+                if (this.hksv?.isRecording) {
+                    // Restart the timeshift buffer now that we've stopped streaming.
+                    await this.hksv.restartTimeshifting();
                 }
                 else if (this.savedBitrate) {
                     // Restore our original bitrate.
@@ -658,7 +709,7 @@ class ProtectStreamingDelegate {
             }
         }
         catch (error) {
-            this.log.error("%s: Error occurred while ending the FFmpeg video processes: %s.", this.name(), error);
+            this.log.error("Error occurred while ending the FFmpeg video processes: %s.", error);
         }
     }
     // Shutdown all our video streams.
@@ -668,6 +719,97 @@ class ProtectStreamingDelegate {
             await this.stopStream(session);
         }
     }
+    // Adjust our probe hints.
+    adjustProbeSize() {
+        if (this.probesizeOverrideTimeout) {
+            clearTimeout(this.probesizeOverrideTimeout);
+            this.probesizeOverrideTimeout = undefined;
+        }
+        // Maintain statistics on how often we need to adjust our probesize. If this happens too frequently, we will default to a working value.
+        this.probesizeOverrideCount++;
+        // Increase the probesize by a factor of two each time we need to do something about it. This idea is to balance the latency implications
+        // for the user, but also ensuring we have a functional streaming experience.
+        this.probesizeOverride = (this.probesizeOverride ? this.probesizeOverride : this.protectCamera.hints.probesize) * 2;
+        // Safety check to make sure this never gets too crazy.
+        if (this.probesizeOverride > 5000000) {
+            this.probesizeOverride = 5000000;
+        }
+        this.log.error("The FFmpeg process ended unexpectedly due to issues with the media stream provided by the UniFi Protect livestream API. " +
+            "Adjusting the settings we use for FFmpeg %s to use safer values at the expense of some additional streaming startup latency.", this.probesizeOverrideCount < 10 ? "temporarily" : "permanently");
+        // If this happens often enough, keep the override in place permanently.
+        if (this.probesizeOverrideCount < 10) {
+            this.probesizeOverrideTimeout = setTimeout(() => {
+                this.probesizeOverride = 0;
+                this.probesizeOverrideTimeout = undefined;
+            }, 1000 * 60 * 10);
+        }
+    }
+    // Translate HomeKit H.264 level information for FFmpeg.
+    getH264Level(level) {
+        switch (level) {
+            case 0 /* H264Level.LEVEL3_1 */:
+                return "3.1";
+                break;
+            case 1 /* H264Level.LEVEL3_2 */:
+                return "3.2";
+                break;
+            case 2 /* H264Level.LEVEL4_0 */:
+                return "4.0";
+                break;
+            default:
+                return "3.1";
+                break;
+        }
+    }
+    // Translate HomeKit H.264 profile information for FFmpeg.
+    getH264Profile(profile) {
+        switch (profile) {
+            case 0 /* H264Profile.BASELINE */:
+                return "baseline";
+                break;
+            case 2 /* H264Profile.HIGH */:
+                return "high";
+                break;
+            case 1 /* H264Profile.MAIN */:
+                return "main";
+                break;
+            default:
+                return "main";
+                break;
+        }
+    }
+    // Determine the video encoder to use when transcoding.
+    getVideoEncoderOptions() {
+        // Default to the tried-and-true libx264. We use the following options by default:
+        //
+        // -pix_fmt yuvj420p             Use the yuvj420p pixel format, which is what Protect uses.
+        // -preset veryfast              Use the veryfast encoding preset in libx264, which provides a good balance of encoding
+        //                               speed and quality.
+        let encoder = "libx264";
+        let encoderOptions = "-pix_fmt yuvj420p -preset veryfast";
+        // If the user has specified a video encoder, let's use it.
+        if (this.config.videoEncoder) {
+            encoder = this.config.videoEncoder;
+        }
+        // If we've enabled hardware-accelerated transcoding, Let's deduce what we are running on, and select encoder options accordingly.
+        if (this.protectCamera.hints.hardwareTranscoding) {
+            this.protectCamera.hasHwAccel = true;
+            switch (platform) {
+                case "darwin":
+                    // h264_videotoolbox is the macOS hardware encoder API. We use the following options by default:
+                    //
+                    // -pix_fmt nv12           videotoolbox doesn't support the full yuvj420p pixel format, so we use nv12 to get us close.
+                    // -coder cabac            Use the cabac encoder for better video quality with the encoding profiles we use in HBUP.
+                    encoder = "h264_videotoolbox";
+                    encoderOptions = "-pix_fmt nv12 -coder cabac";
+                    break;
+                default:
+                    // Back to software encoding.
+                    this.protectCamera.hasHwAccel = false;
+                    break;
+            }
+        }
+        return ["-vcodec", encoder, ...encoderOptions.split(" ")];
+    }
 }
-exports.ProtectStreamingDelegate = ProtectStreamingDelegate;
 //# sourceMappingURL=protect-stream.js.map