homebridge-unifi-protect 6.5.1 → 6.7.0

package/dist/protect-ffmpeg-codecs.js

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process";
+import os from "node:os";
+import util from "node:util";
+export class FfmpegCodecs {
+    constructor(platform) {
+        this._gpuMem = 0;
+        this.log = platform.log;
+        this.platform = platform;
+        this.videoProcessor = platform.config.videoProcessor;
+        this.videoProcessorCodecs = {};
+        this.videoProcessorHwAccels = {};
+    }
+    // Launch our configured controllers once all accessories have been loaded. Once we do, they will sustain themselves.
+    async probe() {
+        // Let's conduct our system-specific capability probes.
+        switch (this.platform.hostSystem) {
+            case "raspbian":
+                // If we're on a Raspberry Pi, let's verify that we have enough GPU memory for hardware-based decoding and encoding.
+                await this.probeRpiGpuMem();
+                break;
+            default:
+                break;
+        }
+        // First things first - ensure we've got a working video processor before we do anything else.
+        if (!(await this.probeVideoProcessorCodecs()) || !(await this.probeVideoProcessorHwAccel())) {
+            return false;
+        }
+        return true;
+    }
+    // Utility to determine whether or not a specific decoder is available to the video processor for a given format.
+    hasDecoder(codec, decoder) {
+        // Normalize our lookups.
+        codec = codec.toLowerCase();
+        decoder = decoder.toLowerCase();
+        return this.videoProcessorCodecs[codec]?.decoders.some(x => x === decoder);
+    }
+    // Utility to determine whether or not a specific encoder is available to the video processor for a given format.
+    hasEncoder(codec, encoder) {
+        // Normalize our lookups.
+        codec = codec.toLowerCase();
+        encoder = encoder.toLowerCase();
+        return this.videoProcessorCodecs[codec]?.encoders.some(x => x === encoder);
+    }
+    // Utility to determine whether or not a specific decoder is available to the video processor for a given format.
+    hasHwAccel(accel) {
+        return this.videoProcessorHwAccels[accel.toLowerCase()] ? true : false;
+    }
+    get gpuMem() {
+        return this._gpuMem;
+    }
+    // Probe our video processor's hardware acceleration capabilities.
+    async probeVideoProcessorHwAccel() {
+        return this.probeCmd(this.videoProcessor, ["-hide_banner", "-hwaccels"], (stdout) => {
+            // Iterate through each line, and a build a list of encoders.
+            for (const accel of stdout.split(os.EOL)) {
+                // Skip blank lines.
+                if (!accel.length) {
+                    continue;
+                }
+                // Skip the first line.
+                if (accel === "Hardware acceleration methods:") {
+                    continue;
+                }
+                // We've found a hardware acceleration method, let's add it.
+                this.videoProcessorHwAccels[accel.toLowerCase()] = true;
+            }
+        });
+    }
+    // Probe our video processor's encoding and decoding capabilities.
+    async probeVideoProcessorCodecs() {
+        return this.probeCmd(this.videoProcessor, ["-hide_banner", "-codecs"], (stdout) => {
+            // A regular expression to parse out the codec and it's supported decoders.
+            const decodersRegex = /\S+\s+(\S+).+\(decoders: (.*?)\s*\)/;
+            // A regular expression to parse out the codec and it's supported encoders.
+            const encodersRegex = /\S+\s+(\S+).+\(encoders: (.*?)\s*\)/;
+            // Iterate through each line, and a build a list of encoders.
+            for (const codecLine of stdout.split(os.EOL)) {
+                // Let's see if we have decoders.
+                const decodersMatch = decodersRegex.exec(codecLine);
+                // Let's see if we have encoders.
+                const encodersMatch = encodersRegex.exec(codecLine);
+                // If we found decoders, add them to our list of supported decoders for this format.
+                if (decodersMatch) {
+                    this.videoProcessorCodecs[decodersMatch[1]] = { decoders: [], encoders: [] };
+                    this.videoProcessorCodecs[decodersMatch[1]].decoders = decodersMatch[2].split(" ").map(x => x.toLowerCase());
+                }
+                // If we found decoders, add them to our list of supported decoders for this format.
+                if (encodersMatch) {
+                    if (!this.videoProcessorCodecs[encodersMatch[1]]) {
+                        this.videoProcessorCodecs[encodersMatch[1]] = { decoders: [], encoders: [] };
+                    }
+                    this.videoProcessorCodecs[encodersMatch[1]].encoders = encodersMatch[2].split(" ").map(x => x.toLowerCase());
+                }
+            }
+        });
+    }
+    // Probe Raspberry Pi GPU.
+    async probeRpiGpuMem() {
+        return this.probeCmd("/usr/bin/vcgencmd", ["get_mem", "gpu"], (stdout) => {
+            // A regular expression to parse out the configured GPU memory on the Raspberry Pi.
+            const gpuRegex = /^gpu=(.*)M\n$/;
+            // Let's see what we've got.
+            const gpuMatch = gpuRegex.exec(stdout);
+            // We matched what we're looking for.
+            if (gpuMatch) {
+                // Parse the result and retrieve our allocated GPU memory.
+                this._gpuMem = parseInt(gpuMatch[1]);
+                // Something went wrong.
+                if (isNaN(this._gpuMem)) {
+                    this._gpuMem = 0;
+                }
+            }
+        });
+    }
+    // Utility to probe the capabilities of FFmpeg and the host platform.
+    async probeCmd(command, commandLineArgs, processOutput) {
+        try {
+            // Promisify exec to allow us to wait for it asynchronously.
+            const execAsync = util.promisify(execFile);
+            // Check for the codecs in our video processor.
+            const { stdout } = await execAsync(command, commandLineArgs);
+            processOutput(stdout);
+            return true;
+        }
+        catch (error) {
+            // It's really a SystemError, but Node hides that type from us for esoteric reasons.
+            if (error instanceof Error) {
+                const execError = error;
+                if (execError.code === "ENOENT") {
+                    this.log.error("Unable to find FFmpeg at: '%s'. Please make sure that you have a working version of FFmpeg installed in order to use this plugin.", execError.path);
+                }
+                else {
+                    this.log.error("Error running FFmpeg: %s", error.message);
+                }
+            }
+            this.log.error("Unable to complete plugin startup without a working version of FFmpeg.");
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=protect-ffmpeg-codecs.js.map

package/dist/protect-ffmpeg-codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protect-ffmpeg-codecs.js","sourceRoot":"","sources":["../src/protect-ffmpeg-codecs.ts"],"names":[],"mappings":"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"}

package/dist/protect-ffmpeg-options.d.ts

@@ -0,0 +1,20 @@
+import { H264Level, H264Profile } from "homebridge";
+import { ProtectCamera } from "./protect-camera.js";
+export declare class FfmpegOptions {
+    private readonly hwPixelFormat;
+    private readonly log;
+    private readonly platform;
+    private readonly protectCamera;
+    constructor(protectCamera: ProtectCamera);
+    private configureHwAccel;
+    get audioEncoder(): string[];
+    get audioDecoder(): string;
+    get videoDecoder(): string[];
+    private defaultVideoEncoderOptions;
+    recordEncoder(width: number, height: number, fps: number, bitrate: number, profile: H264Profile, level: H264Level, idrInterval: number): string[];
+    streamEncoder(width: number, height: number, fps: number, bitrate: number, profile: H264Profile, level: H264Level, idrInterval: number, useSmartQuality?: boolean): string[];
+    get recordingDefaultChannel(): string | undefined;
+    get hostSystemMaxPixels(): number;
+    private getH264Level;
+    private getH264Profile;
+}

package/dist/protect-ffmpeg-options.js

@@ -0,0 +1,468 @@
+import { PROTECT_HOMEKIT_STREAMING_HEADROOM, PROTECT_RPI_GPU_MINIMUM } from "./settings.js";
+export class FfmpegOptions {
+    // Create an instance of a HomeKit streaming delegate.
+    constructor(protectCamera) {
+        this.hwPixelFormat = [];
+        this.log = protectCamera.log;
+        this.platform = protectCamera.platform;
+        this.protectCamera = protectCamera;
+        // Configure our hardware acceleration support.
+        this.configureHwAccel();
+    }
+    // Determine the video encoder to use when transcoding.
+    configureHwAccel() {
+        let logMessage = "";
+        const accelCategories = this.protectCamera.hints.hardwareTranscoding ? "decoding and transcoding" : "decoding";
+        // Hardware-accelerated decoding is enabled by default, where supported. Let's select the decoder options accordingly where supported.
+        if (this.protectCamera.hints.hardwareDecoding) {
+            // Utility function to check that we have a specific decoder codec available to us.
+            const validateDecoder = (codec, pixelFormat) => {
+                if (!this.platform.codecSupport.hasDecoder("h264", codec)) {
+                    this.log.error("Unable to enable hardware accelerated decoding. Your video processor does not have support for the " + codec + " decoder. " +
+                        "Using software decoding instead.");
+                    this.protectCamera.hints.hardwareDecoding = false;
+                    return false;
+                }
+                this.hwPixelFormat.push(...pixelFormat);
+                return true;
+            };
+            // Utility function to check that we have a specific decoder codec available to us.
+            const validateHwAccel = (accel, pixelFormat) => {
+                if (!this.platform.codecSupport.hasHwAccel(accel)) {
+                    this.log.error("Unable to enable hardware accelerated decoding. Your video processor does not have support for the " + accel + " hardware accelerator. " +
+                        "Using software decoding instead.");
+                    this.protectCamera.hints.hardwareDecoding = false;
+                    return false;
+                }
+                this.hwPixelFormat.push(...pixelFormat);
+                return true;
+            };
+            switch (this.platform.hostSystem) {
+                case "macOS.Apple":
+                case "macOS.Intel":
+                    // Verify that we have hardware-accelerated decoding available to us.
+                    validateHwAccel("videotoolbox", ["videotoolbox_vld", "nv12", "yuv420p"]);
+                    break;
+                case "raspbian":
+                    // If it's less than the minimum hardware GPU memory we need on an Raspberry Pi, we revert back to our default decoder.
+                    if (this.platform.codecSupport.gpuMem < PROTECT_RPI_GPU_MINIMUM) {
+                        this.log.info("Disabling hardware accelerated %s. Adjust the GPU memory configuration on your Raspberry Pi to at least %s MB to enable it.", accelCategories, PROTECT_RPI_GPU_MINIMUM);
+                        this.protectCamera.hints.hardwareDecoding = false;
+                        this.protectCamera.hints.hardwareTranscoding = false;
+                        return false;
+                    }
+                    // Verify that we have the hardware decoder available to us.
+                    validateDecoder("h264_mmal", ["mmal", "yuv420p"]);
+                    break;
+                default:
+                    // Back to software decoding unless we're on a known system that always supports hardware decoding.
+                    this.protectCamera.hints.hardwareDecoding = false;
+                    break;
+            }
+        }
+        // If we've enabled hardware-accelerated transcoding, let's select the encoder options accordingly where supported.
+        if (this.protectCamera.hints.hardwareTranscoding) {
+            // Utility function to check that we have a specific encoder codec available to us.
+            const validateEncoder = (codec) => {
+                if (!this.platform.codecSupport.hasEncoder("h264", codec)) {
+                    this.log.error("Unable to enable hardware accelerated transcoding. Your video processor does not have support for the " + codec + " encoder. " +
+                        "Using software transcoding instead.");
+                    this.protectCamera.hints.hardwareTranscoding = false;
+                    return false;
+                }
+                return true;
+            };
+            switch (this.platform.hostSystem) {
+                case "macOS.Apple":
+                case "macOS.Intel":
+                    // Verify that we have the hardware encoder available to us.
+                    validateEncoder("h264_videotoolbox");
+                    // Validate that we have access to the AudioToolbox AAC encoder.
+                    if (!this.platform.codecSupport.hasEncoder("aac", "aac_at")) {
+                        this.log.error("Your video processor does not have support for the native macOS AAC encoder, aac_at. Will attempt to use libfdk_aac instead.");
+                    }
+                    break;
+                case "raspbian":
+                    // Verify that we have the hardware encoder available to us.
+                    validateEncoder("h264_v4l2m2m");
+                    logMessage = "Raspberry Pi hardware acceleration will be used for livestreaming. " +
+                        "HomeKit Secure Video recordings are not supported by the hardware encoder and will use software transcoding instead";
+                    break;
+                default:
+                    // Let's see if we have Intel QuickSync hardware decoding available to us.
+                    if (this.platform.codecSupport.hasHwAccel("qsv") &&
+                        this.platform.codecSupport.hasDecoder("h264", "h264_qsv") && this.platform.codecSupport.hasEncoder("h264", "h264_qsv")) {
+                        this.protectCamera.hints.hardwareDecoding = true;
+                        this.hwPixelFormat.push("qsv", "yuv420p");
+                        logMessage = "Intel Quick Sync Video";
+                    }
+                    else {
+                        // Back to software encoding.
+                        this.protectCamera.hints.hardwareTranscoding = false;
+                    }
+                    break;
+            }
+        }
+        // Inform the user.
+        if (this.protectCamera.hints.hardwareDecoding || this.protectCamera.hints.hardwareTranscoding) {
+            this.log.info("Hardware accelerated %s enabled%s.", accelCategories, logMessage.length ? ": " + logMessage : "");
+        }
+        return this.protectCamera.hints.hardwareTranscoding;
+    }
+    // Return the audio encoder options to use when transcoding.
+    get audioEncoder() {
+        // If we don't have libfdk_aac available to us, we're essentially dead in the water.
+        let encoderOptions = [];
+        // Utility function to return a default audio encoder codec.
+        const defaultAudioEncoderOptions = () => {
+            if (this.platform.codecSupport.hasEncoder("aac", "libfdk_aac")) {
+                // Default to libfdk_aac since FFmpeg doesn't natively support AAC-ELD. We use the following options by default:
+                //
+                // -acodec libfdk_aac          Use the libfdk_aac encoder.
+                // -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.
+                return [
+                    "-acodec", "libfdk_aac",
+                    "-afterburner", "1",
+                    "-eld_sbr", "1",
+                    "-eld_v2", "1"
+                ];
+            }
+            else {
+                return [];
+            }
+        };
+        switch (this.platform.hostSystem) {
+            case "macOS.Apple":
+            case "macOS.Intel":
+                // If we don't have audiotoolbox available, let's default back to libfdk_aac.
+                if (!this.platform.codecSupport.hasEncoder("aac", "aac_at")) {
+                    encoderOptions = defaultAudioEncoderOptions();
+                    break;
+                }
+                // aac_at is the macOS audio encoder API. We use the following options:
+                //
+                // -acodec aac_at            Use the aac_at encoder on macOS.
+                // -aac_at_mode cvbr         Use the constrained variable bitrate setting to allow the encoder to optimize audio, while remaining within the requested bitrates.
+                encoderOptions = [
+                    "-acodec", "aac_at",
+                    "-aac_at_mode", "cvbr"
+                ];
+                break;
+            default:
+                encoderOptions = defaultAudioEncoderOptions();
+                break;
+        }
+        return encoderOptions;
+    }
+    // Return the audio encoder to use when decoding.
+    get audioDecoder() {
+        return "libfdk_aac";
+    }
+    // Return the video decoder options to use when decoding video.
+    get videoDecoder() {
+        // Default to no special decoder options for inbound streams.
+        let decoderOptions = [];
+        // If we've enabled hardware-accelerated transcoding, let's select decoder options accordingly where supported.
+        if (this.protectCamera.hints.hardwareDecoding) {
+            switch (this.platform.hostSystem) {
+                case "macOS.Apple":
+                case "macOS.Intel":
+                    // h264_videotoolbox is the macOS hardware decoder and encoder API. We use the following options for decoding video:
+                    //
+                    // -hwaccel videotoolbox   Select Video Toolbox for hardware accelerated H.264 decoding.
+                    decoderOptions = [
+                        "-hwaccel", "videotoolbox"
+                    ];
+                    break;
+                case "raspbian":
+                    // h264_mmal is the preferred Raspberry Pi hardware decoder codec. We use the following options for decoding video:
+                    //
+                    // -c:v h264_mmal          Select the Multimedia Abstraction Layer codec for hardware accelerated H.264 processing.
+                    decoderOptions = [
+                        "-c:v", "h264_mmal"
+                    ];
+                    break;
+                default:
+                    // h264_qsv is the Intel Quick Sync Video hardware encoder and decoder.
+                    //
+                    // -hwaccel qsv            Select Quick Sync Video to enable hardware accelerated H.264 decoding.
+                    // -c:v h264_qsv           Select the Quick Sync Video codec for hardware accelerated H.264 processing.
+                    decoderOptions = [
+                        "-hwaccel", "qsv",
+                        "-hwaccel_output_format", "qsv",
+                        "-c:v", "h264_qsv"
+                    ];
+                    break;
+            }
+        }
+        return decoderOptions;
+    }
+    // Utility function to provide our default encoder options.
+    defaultVideoEncoderOptions(width, height, fps, bitrate, profile, level, idrInterval, useSmartQuality = true) {
+        // Default to the tried-and-true libx264. We use the following options by default:
+        //
+        // -c:v libx264                  Use the excellent libx264 H.264 encoder by default, unless the user explicitly overrides it.
+        // -preset veryfast              Use the veryfast encoding preset in libx264, which provides a good balance of encoding speed and quality.
+        // -profile:v                    Use the H.264 profile that HomeKit is requesting when encoding.
+        // -level:v                      Use the H.264 profile level that HomeKit is requesting when encoding.
+        // -noautoscale                  Don't attempt to scale the video stream automatically.
+        // -bf 0                         Disable B-frames when encoding to increase compatibility against occasionally finicky HomeKit clients.
+        // -filter:v                     Set the pixel format and scale the video to the size we want while respecting aspect ratios and ensuring our final
+        //                               dimensions are a power of two.
+        // -g:v                          Set the group of pictures to the number of frames per second * the interval in between keyframes to ensure a solid
+        //                               livestreamng exerience.
+        // -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. This provides an upper bound on bitrate, with a little bit extra to
+        //                               allow encoders some variation in order to maximize quality while honoring bandwidth constraints.
+        const encoderOptions = [
+            // If the user has specified a video encoder, let's use it instead.
+            "-c:v", this.platform.config.videoEncoder ?? "libx264",
+            "-preset", "veryfast",
+            "-profile:v", this.getH264Profile(profile),
+            "-level:v", this.getH264Level(level),
+            "-noautoscale",
+            "-bf", "0",
+            "-filter:v", "format=" + [...this.hwPixelFormat, "yuvj420p"].join("|") + ", scale=-2:min(ih\\," + height.toString() + ")",
+            "-g:v", (fps * idrInterval).toString(),
+            "-bufsize", (2 * bitrate).toString() + "k",
+            "-maxrate", (bitrate + (useSmartQuality ? PROTECT_HOMEKIT_STREAMING_HEADROOM : 0)).toString() + "k"
+        ];
+        // Using libx264's constant rate factor mode produces generally better results across the board. We use a capped CRF approach, allowing libx264 to
+        // make intelligent choices about how to adjust bitrate to achieve a certain quality level depending on the complexity of the scene being encoded, but
+        // constraining it to a maximum bitrate to stay within the bandwidth constraints HomeKit is requesting.
+        if (useSmartQuality) {
+            // -crf 20                     Use a constant rate factor of 20, to allow libx264 the ability to vary bitrates to achieve the visual quality we
+            //                             want, constrained by our maximum bitrate.
+            encoderOptions.push("-crf", "20");
+        }
+        else {
+            // For recording HKSV, we really want to maintain a tight rein on bitrate and don't want to freelance with perceived quality for two reasons - HKSV
+            // is very latency sensitive and it's also very particular about bitrates and the specific format of the stream it receives. The second reason is that
+            // HKSV typically requests bitrates of around 2000kbps, which results in a reasonably high quality recording, as opposed to the typical 2-300kbps
+            // that livestreaming from the Home app itself generates. Those lower bitrates in livestreaming really benefit from the magic that using a good CRF value
+            // can produce in libx264.
+            encoderOptions.push("-b:v", bitrate.toString() + "k");
+        }
+        return encoderOptions;
+    }
+    // Return the video encoder options to use for HKSV.
+    recordEncoder(width, height, fps, bitrate, profile, level, idrInterval) {
+        // Generaly, we default to using the same encoding options we use to transcode livestreams, unless we have platform-specific quirks we need to address,
+        // such as where we can have hardware accelerated transcoded livestreaming, but not hardware-accelerated HKSV event recording. The other noteworthy
+        // aspect here is that HKSV is quite specific in what it wants, and isn't vary tolerant of creative license in how you may choose to alter bitrate to
+        // address quality. When we call our encoders, we also let them know we don't want any additional quality optimizations when transcoding HKSV events.
+        switch (this.platform.hostSystem) {
+            case "raspbian":
+                // Raspberry Pi struggles with hardware accelerated HKSV event recording due to issues in the FFmpeg codec driver, currently. We hope this improves
+                // over time and can offer it to Pi users, or develop a workaround. For now, we default to libx264.
+                return this.defaultVideoEncoderOptions(width, height, fps, bitrate, profile, level, idrInterval, false);
+                break;
+            default:
+                // By default, we use the same options for HKSV and streaming.
+                return this.streamEncoder(width, height, fps, bitrate, profile, level, idrInterval, false);
+        }
+    }
+    // Return the video encoder options to use when transcoding.
+    streamEncoder(width, height, fps, bitrate, profile, level, idrInterval, useSmartQuality = true) {
+        const encoderOptions = [];
+        // Adjust the maximum bitrate tolerance used with -bufsize. This provides an upper bound on bitrate, with a little bit extra to allow encoders some
+        // variation in order to maximize quality while honoring bandwidth constraints.
+        const adjustedMaxBitrate = bitrate + (useSmartQuality ? PROTECT_HOMEKIT_STREAMING_HEADROOM : 0);
+        // If we've enabled hardware-accelerated transcoding, let's select encoder options accordingly where supported.
+        if (this.protectCamera.hints.hardwareTranscoding) {
+            switch (this.platform.hostSystem) {
+                case "macOS.Apple":
+                    // h264_videotoolbox is the macOS hardware encoder API. We use the following options on Apple Silicon:
+                    //
+                    // -c:v                    Specify the macOS hardware encoder, h264_videotoolbox.
+                    // -allow_sw 1             Allow the use of the software encoder if the hardware encoder is occupied or unavailable.
+                    //                         This allows us to scale when we get multiple streaming requests simultaneously that might consume all the available encode engines.
+                    // -realtime 1             We prefer speed over quality - if the encoder has to make a choice, sacrifice one for the other.
+                    // -coder cabac            Use the cabac encoder for better video quality with the encoding profiles we use in HBUP.
+                    // -profile:v              Use the H.264 profile that HomeKit is requesting when encoding.
+                    // -level:v 0              We override what HomeKit requests for the H.264 profile level on macOS when we're using hardware accelerated transcoding because
+                    //                         the hardware encoder is particular about how to use levels. Setting it to 0 allows the encoder to decide for itself.
+                    // -bf 0                   Disable B-frames when encoding to increase compatibility against occasionally finicky HomeKit clients.
+                    // -noautoscale            Don't attempt to scale the video stream automatically.
+                    // -filter:v               Set the pixel format and scale the video to the size we want while respecting aspect ratios and ensuring our final dimensions are a
+                    //                         power of two.
+                    // -g:v                    Set the group of pictures to the number of frames per second * the interval in between keyframes to ensure a solid
+                    //                         livestreamng exerience.
+                    // -bufsize size           This is the decoder buffer size, which drives the variability / quality of the output bitrate.
+                    // -maxrate bitrate        The maximum bitrate tolerance used in concert with -bufsize to constrain the maximum bitrate permitted.
+                    encoderOptions.push("-c:v", "h264_videotoolbox", "-allow_sw", "1", "-realtime", "1", "-coder", "cabac", "-profile:v", this.getH264Profile(profile), "-level:v", "0", "-bf", "0", "-noautoscale", "-filter:v", "format=" + this.hwPixelFormat.join("|") + ", scale=-2:min(ih\\," + height.toString() + ")", "-g:v", (fps * idrInterval).toString(), "-bufsize", (2 * bitrate).toString() + "k", "-maxrate", adjustedMaxBitrate.toString() + "k");
+                    if (useSmartQuality) {
+                        // -q:v 90               Use a fixed quality scale of 90, to allow videotoolbox the ability to vary bitrates to achieve the visual quality we want,
+                        //                       constrained by our maximum bitrate. This is an Apple Silicon-specific feature.
+                        encoderOptions.push("-q:v", "90");
+                    }
+                    else {
+                        // -b:v                  Average bitrate that's being requested by HomeKit.
+                        encoderOptions.push("-b:v", bitrate.toString() + "k");
+                    }
+                    return encoderOptions;
+                    break;
+                case "macOS.Intel":
+                    // h264_videotoolbox is the macOS hardware encoder API. We use the following options on Intel-based Macs:
+                    //
+                    // -c:v                    Specify the macOS hardware encoder, h264_videotoolbox.
+                    // -allow_sw 1             Allow the use of the software encoder if the hardware encoder is occupied or unavailable.
+                    //                         This allows us to scale when we get multiple streaming requests simultaneously that might consume all the available encode engines.
+                    // -realtime 1             We prefer speed over quality - if the encoder has to make a choice, sacrifice one for the other.
+                    // -coder cabac            Use the cabac encoder for better video quality with the encoding profiles we use in HBUP.
+                    // -profile:v              Use the H.264 profile that HomeKit is requesting when encoding.
+                    // -level:v 0              We override what HomeKit requests for the H.264 profile level on macOS when we're using hardware accelerated transcoding because
+                    //                         the hardware encoder is particular about how to use levels. Setting it to 0 allows the encoder to decide for itself.
+                    // -bf 0                   Disable B-frames when encoding to increase compatibility against occasionally finicky HomeKit clients.
+                    // -noautoscale            Don't attempt to scale the video stream automatically.
+                    // -filter:v               Set the pixel format and scale the video to the size we want while respecting aspect ratios and ensuring our final dimensions are a
+                    //                         power of two.
+                    // -b:v                    Average bitrate that's being requested by HomeKit. We can't use a quality constraint and allow for more optimization of the bitrate
+                    //                         on Intel-based Macs due to hardware / API limitations.
+                    // -g:v                    Set the group of pictures to the number of frames per second * the interval in between keyframes to ensure a solid
+                    //                         livestreamng exerience.
+                    // -bufsize size           This is the decoder buffer size, which drives the variability / quality of the output bitrate.
+                    // -maxrate bitrate        The maximum bitrate tolerance used in concert with -bufsize to constrain the maximum bitrate permitted.
+                    return [
+                        "-c:v", "h264_videotoolbox",
+                        "-allow_sw", "1",
+                        "-realtime", "1",
+                        "-coder", "cabac",
+                        "-profile:v", this.getH264Profile(profile),
+                        "-level:v", "0",
+                        "-bf", "0",
+                        "-noautoscale",
+                        "-filter:v", "format=" + this.hwPixelFormat.join("|") + ", scale=-2:min(ih\\," + height.toString() + ")",
+                        "-b:v", bitrate.toString() + "k",
+                        "-g:v", (fps * idrInterval).toString(),
+                        "-bufsize", (2 * bitrate).toString() + "k",
+                        "-maxrate", adjustedMaxBitrate.toString() + "k"
+                    ];
+                    break;
+                case "raspbian":
+                    // h264_v4l2m2m is the preferred interface to the Raspberry Pi hardware encoder API. We use the following options:
+                    //
+                    // -c:v                    Specify the Raspberry Pi hardware encoder, h264_v4l2m2m.
+                    // -noautoscale            Don't attempt to scale the video stream automatically.
+                    // -filter:v               Set the pixel format and scale the video to the size we want while respecting aspect ratios and ensuring our final dimensions are a
+                    //                         power of two.
+                    // -b:v                    Average bitrate that's being requested by HomeKit. We can't use a quality constraint and allow for more optimization of the bitrate
+                    //                         due to v4l2m2m limitations.
+                    // -g:v                    Set the group of pictures to the number of frames per second * the interval in between keyframes to ensure a solid
+                    //                         livestreamng exerience.
+                    // -bufsize size           This is the decoder buffer size, which drives the variability / quality of the output bitrate.
+                    // -maxrate bitrate        The maximum bitrate tolerance used in concert with -bufsize to constrain the maximum bitrate permitted.
+                    return [
+                        "-c:v", "h264_v4l2m2m",
+                        "-profile:v", this.getH264Profile(profile, true),
+                        "-bf", "0",
+                        "-noautoscale",
+                        "-reset_timestamps", "1",
+                        "-filter:v", "format=" + this.hwPixelFormat.join("|") + ", scale=-2:min(ih\\," + height.toString() + ")",
+                        "-b:v", bitrate.toString() + "k",
+                        "-g:v", (fps * idrInterval).toString(),
+                        "-bufsize", (2 * bitrate).toString() + "k",
+                        "-maxrate", adjustedMaxBitrate.toString() + "k"
+                    ];
+                    break;
+                default:
+                    // h264_qsv is the Intel Quick Sync Video hardware encoder API. We use the following options:
+                    //
+                    // -c:v                    Specify the macOS hardware encoder, h264_videotoolbox.
+                    // -profile:v              Use the H.264 profile that HomeKit is requesting when encoding.
+                    // -level:v 0              We override what HomeKit requests for the H.264 profile level when we're using hardware accelerated transcoding because
+                    //                         the hardware encoder will determine which levels to use. Setting it to 0 allows the encoder to decide for itself.
+                    // -bf 0                   Disable B-frames when encoding to increase compatibility against occasionally finicky HomeKit clients.
+                    // -noautoscale            Don't attempt to scale the video stream automatically.
+                    // -init_hw_device         Initialize our hardware accelerator and assign it a name to be used in the FFmpeg command line.
+                    // -filter_hw_device       Specify the hardware accelerator to be used with our video filter pipeline.
+                    // -filter:v               Set the pixel format and scale the video to the size we want while respecting aspect ratios and ensuring our final dimensions are a
+                    //                         power of two.
+                    // -g:v                    Set the group of pictures to the number of frames per second * the interval in between keyframes to ensure a solid
+                    //                         livestreamng exerience.
+                    // -bufsize size           This is the decoder buffer size, which drives the variability / quality of the output bitrate.
+                    // -maxrate bitrate        The maximum bitrate tolerance used in concert with -bufsize to constrain the maximum bitrate permitted.
+                    encoderOptions.push("-c:v", "h264_qsv", "-profile:v", this.getH264Profile(profile), "-level:v", "0", "-bf", "0", "-noautoscale", "-init_hw_device", "qsv=hw", "-filter_hw_device", "hw", "-filter:v", "vpp_qsv=format=same:w=min(iw\\, (iw / ih) * " + height.toString() + "):h=min(ih\\, " + height.toString() + ")", "-g:v", (fps * idrInterval).toString(), "-bufsize", (2 * bitrate).toString() + "k", "-maxrate", adjustedMaxBitrate.toString() + "k");
+                    if (useSmartQuality) {
+                        // -global_quality 20    Use a global quality setting of 20, to allow QSV the ability to vary bitrates to achieve the visual quality we want,
+                        //                       constrained by our maximum bitrate. This leverages a QSV-specific feature known as intelligent constant quality.
+                        encoderOptions.push("-global_quality", "20");
+                    }
+                    else {
+                        // -b:v                  Average bitrate that's being requested by HomeKit.
+                        encoderOptions.push("-b:v", bitrate.toString() + "k");
+                    }
+                    return encoderOptions;
+                    break;
+            }
+        }
+        // If we aren't hardware accelerated, we default to libx264.
+        return this.defaultVideoEncoderOptions(width, height, fps, bitrate, profile, level, idrInterval, useSmartQuality);
+    }
+    // Use the host system information to determine which recording channel to use by default for HKSV.
+    get recordingDefaultChannel() {
+        switch (this.platform.hostSystem) {
+            case "raspbian":
+                // For constrained CPU environments like Raspberry Pi, we default to recording from the highest quality channel we can, that's at or below 1080p.
+                // That provides a reasonable default, while still allowing users who really want to, to be able to specify something else.
+                return this.protectCamera.findRtsp(1920, 1080, undefined, undefined, this.hostSystemMaxPixels)?.channel.name ?? undefined;
+                break;
+            default:
+                // We default to no preference for the default Protect camera channel.
+                return undefined;
+        }
+    }
+    // Return the maximum pixel count supported by a specific hardware encoder on the host system.
+    get hostSystemMaxPixels() {
+        if (this.protectCamera.hints.hardwareTranscoding) {
+            switch (this.platform.hostSystem) {
+                case "raspbian":
+                    // For constrained environments like Raspberry Pi, when hardware transcoding has been selected for a camera, we limit the available source
+                    // streams to no more than 1080p. In practice, that means that devices like the G4 Pro can't use their highest quality stream for
+                    // transcoding due to the limitations of the Raspberry Pi GPU that cannot support higher pixel counts.
+                    return 1920 * 1080;
+                    break;
+                default:
+                    break;
+            }
+        }
+        return 0;
+    }
+    // Translate HomeKit H.264 level information for FFmpeg.
+    getH264Level(level, numeric = false) {
+        switch (level) {
+            case 0 /* H264Level.LEVEL3_1 */:
+                return numeric ? "31" : "3.1";
+                break;
+            case 1 /* H264Level.LEVEL3_2 */:
+                return numeric ? "32" : "3.2";
+                break;
+            case 2 /* H264Level.LEVEL4_0 */:
+                return numeric ? "40" : "4.0";
+                break;
+            default:
+                return numeric ? "31" : "3.1";
+                break;
+        }
+    }
+    // Translate HomeKit H.264 profile information for FFmpeg.
+    getH264Profile(profile, numeric = false) {
+        switch (profile) {
+            case 0 /* H264Profile.BASELINE */:
+                return numeric ? "66" : "baseline";
+                break;
+            case 2 /* H264Profile.HIGH */:
+                return numeric ? "100" : "high";
+                break;
+            case 1 /* H264Profile.MAIN */:
+                return numeric ? "77" : "main";
+                break;
+            default:
+                return numeric ? "77" : "main";
+                break;
+        }
+    }
+}
+//# sourceMappingURL=protect-ffmpeg-options.js.map