@apocaliss92/scrypted-reolink-native 0.5.42 → 0.5.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apocaliss92/scrypted-reolink-native",
-  "version": "0.5.42",
+  "version": "0.5.44",
   "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
   "author": "@apocaliss92",
   "license": "Apache",
@@ -44,7 +44,7 @@
     ]
   },
   "dependencies": {
-    "@apocaliss92/nodelink-js": "^0.5.2",
+    "@apocaliss92/nodelink-js": "^0.6.0",
     "@scrypted/common": "file:../../scrypted/common",
     "@scrypted/rtsp": "file:../../scrypted/plugins/rtsp",
     "@scrypted/sdk": "^0.3.118"

package/src/camera.ts

@@ -43,7 +43,43 @@ import sdk, {
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import crypto from "crypto";
 import fs from "fs";
+import os from "os";
 import path from "path";
+
+/**
+ * Per-platform list of ffmpeg H.264 encoders we offer in the composite
+ * settings dropdown. Mirrors `@scrypted/common/src/ffmpeg-hardware-
+ * acceleration.ts`'s `getH264EncoderArgs()` but replicated here so we
+ * don't take a build dependency on Scrypted's internal common package
+ * (the subpath import doesn't resolve cleanly through the file-symlink
+ * Scrypted plugins use). The shape mirrors the upstream helper exactly
+ * so we can swap to the real one as soon as the resolution issue is
+ * addressed upstream.
+ *
+ * Each value is the full `-c:v <encoder> [extra-args...]` arg list. The
+ * code below pulls element [1] for the `-c:v` identifier and propagates
+ * the rest through `extraOutputArgs`.
+ */
+function getCompositeH264EncoderArgs(): { [label: string]: string[] } {
+  const args: { [label: string]: string[] } = {};
+  const platform = os.platform();
+  if (platform === "darwin") {
+    args["VideoToolbox"] = ["-c:v", "h264_videotoolbox"];
+  } else if (platform === "win32") {
+    args["Intel QuickSync"] = ["-c:v", "h264_qsv"];
+    args["AMD"] = ["-c:v", "h264_amf"];
+    args["Nvidia"] = ["-c:v", "h264_nvenc"];
+  } else if (platform === "linux") {
+    args["V4L2 (Raspberry Pi)"] = [
+      "-pix_fmt", "yuv420p",
+      "-c:v", "h264_v4l2m2m",
+    ];
+    args["VAAPI"] = ["-c:v", "h264_vaapi"];
+    args["Nvidia"] = ["-c:v", "h264_nvenc"];
+  }
+  args["libx264 (Software)"] = ["-c:v", "libx264"];
+  return args;
+}
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import {
   ReolinkCameraAutotracking,
@@ -683,6 +719,109 @@ export class ReolinkCamera
         this.scheduleStreamManagerRestart("compositeDisableTranscode changed");
       },
     },
+    // ─── Composite ffmpeg tuning ─────────────────────────────────
+    // Encoder + quality knobs. Defaults preserve the previous behavior
+    // (libx264 / ultrafast / crf 23 / 1s GOP). Switching the encoder
+    // away from libx264 is the single biggest perf win — try the HW
+    // encoder for your host: h264_videotoolbox (macOS), h264_qsv or
+    // h264_vaapi (Intel/AMD), h264_nvenc (NVIDIA), h264_v4l2m2m
+    // (Raspberry Pi). When you change the encoder the libx264-specific
+    // preset/CRF knobs are silently dropped — use "Composite: extra
+    // output args" to pass the encoder's own options.
+    // Encoder choices come straight from Scrypted's per-platform
+    // hardware-acceleration helper, so the dropdown only ever offers
+    // encoders that ffmpeg on this host actually supports — Mac sees
+    // VideoToolbox, Windows sees QuickSync/AMD/Nvidia, Linux sees
+    // V4L2/VAAPI/Nvidia, Raspberry Pi sees its dedicated V4L2 path.
+    // The displayed label is human-readable ("VideoToolbox",
+    // "Intel QuickSync", "libx264 (Software)") and the actual ffmpeg
+    // `-c:v` identifier is resolved at use time via
+    // `resolveCompositeVideoEncoder()` below.
+    compositeVideoEncoder: {
+      title: "Composite: ffmpeg encoder",
+      description:
+        "Output video encoder. Choices are limited to what ffmpeg supports on this host. Hardware encoders typically reduce CPU 5-10× vs libx264.",
+      type: "string",
+      defaultValue: "libx264 (Software)",
+      group: "Composite stream",
+      hide: true,
+      choices: Object.keys(getCompositeH264EncoderArgs()),
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeVideoEncoder changed");
+      },
+    },
+    compositeEncoderPreset: {
+      title: "Composite: libx264 preset",
+      description:
+        "Only used when encoder is libx264. ultrafast = least CPU / worst compression; placebo = the opposite. Default ultrafast.",
+      type: "string",
+      defaultValue: "ultrafast",
+      group: "Composite stream",
+      hide: true,
+      choices: [
+        "ultrafast",
+        "superfast",
+        "veryfast",
+        "faster",
+        "fast",
+        "medium",
+        "slow",
+        "slower",
+        "veryslow",
+        "placebo",
+      ],
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeEncoderPreset changed");
+      },
+    },
+    compositeCrf: {
+      title: "Composite: libx264 CRF (quality)",
+      description:
+        "Only used when encoder is libx264. 0 = lossless (huge), 23 = visually lossless, 51 = worst. Drop by 2 to roughly halve bitrate at the same quality.",
+      type: "number",
+      defaultValue: 23,
+      group: "Composite stream",
+      hide: true,
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeCrf changed");
+      },
+    },
+    compositeGopSeconds: {
+      title: "Composite: keyframe interval (seconds)",
+      description:
+        "Lower = faster mid-stream join + larger stream; higher = better compression + slower join. Default 1s.",
+      type: "number",
+      defaultValue: 1,
+      group: "Composite stream",
+      hide: true,
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeGopSeconds changed");
+      },
+    },
+    compositeExtraGlobalArgs: {
+      title: "Composite: extra global args",
+      description:
+        "Free-form ffmpeg args inserted BEFORE the inputs. Use for hardware decode hints, e.g. \"-hwaccel videotoolbox\" or \"-hwaccel qsv -qsv_device /dev/dri/renderD128\". Whitespace-separated. Invalid args WILL crash ffmpeg.",
+      type: "string",
+      defaultValue: "",
+      group: "Composite stream",
+      hide: true,
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeExtraGlobalArgs changed");
+      },
+    },
+    compositeExtraOutputArgs: {
+      title: "Composite: extra output args",
+      description:
+        "Free-form ffmpeg args inserted JUST BEFORE the output. Use for encoder-specific options when encoder ≠ libx264, e.g. \"-q:v 23\" (qsv) or \"-preset fast -rc cbr\" (nvenc). Whitespace-separated. Invalid args WILL crash ffmpeg.",
+      type: "string",
+      defaultValue: "",
+      group: "Composite stream",
+      hide: true,
+      onPut: async () => {
+        this.scheduleStreamManagerRestart("compositeExtraOutputArgs changed");
+      },
+    },
     // ─── E-mail Push ─────────────────────────────────────────────
     // Per-camera knobs that pair with the singleton
     // `Reolink E-mail Push Server` device. Hidden by default and
@@ -1889,10 +2028,10 @@ export class ReolinkCamera
   /**
    * Initialize or recreate the StreamManager, taking into account multifocal composite options.
    */
-  protected initStreamManager(
+  protected async initStreamManager(
     logger?: Console,
     forceRecreate: boolean = false,
-  ): void {
+  ): Promise<void> {
     const { username, password } = this.storageSettings.values;
     // Ensure logger is always valid - use provided logger or get from device, fallback to console
     const validLogger = logger || this.getBaichuanLogger() || console;
@@ -1917,7 +2056,73 @@ export class ReolinkCamera
         rtspChannel,
         compositeAssumeH264,
         compositeDisableTranscode,
+        compositeVideoEncoder,
+        compositeEncoderPreset,
+        compositeCrf,
+        compositeGopSeconds,
+        compositeExtraGlobalArgs,
+        compositeExtraOutputArgs,
       } = this.storageSettings.values;
+      // Get the path to the ffmpeg binary Scrypted ships with. The
+      // composite stream spawns ffmpeg directly; on Windows / Electron
+      // the host has a stripped PATH so a bare `ffmpeg` ENOENTs — we
+      // MUST pass the absolute path the SDK knows about.
+      let ffmpegPath: string | undefined;
+      try {
+        ffmpegPath = await sdk.mediaManager.getFFmpegPath();
+      } catch {
+        // Older Scrypted runtimes / weird environments may not expose
+        // this. Fall through to the library's default ("ffmpeg" via PATH);
+        // worst case the composite fails to spawn and the user sees a
+        // friendly error.
+        ffmpegPath = undefined;
+      }
+      // Whitespace-split the free-form extra args. Empty string -> [].
+      const splitArgs = (s: string | undefined): string[] | undefined => {
+        if (typeof s !== "string") return undefined;
+        const arr = s
+          .trim()
+          .split(/\s+/)
+          .filter((a) => a.length > 0);
+        return arr.length > 0 ? arr : undefined;
+      };
+      const extraGlobalArgs = splitArgs(compositeExtraGlobalArgs);
+      const extraOutputArgs = splitArgs(compositeExtraOutputArgs);
+
+      // Resolve the human-readable encoder label the user picked back
+      // into the actual ffmpeg `-c:v` identifier. The helper returns
+      // arrays shaped like ['-c:v', 'h264_videotoolbox', ...extras] —
+      // we pull element [1] for the encoder name and propagate any
+      // additional pix-fmt / pix-encoder args via extraOutputArgs so
+      // they end up just before the output pipe.
+      let resolvedVideoEncoder: string | undefined;
+      let encoderImpliedOutputArgs: string[] = [];
+      if (compositeVideoEncoder) {
+        try {
+          const encoderArgs = getCompositeH264EncoderArgs()[compositeVideoEncoder];
+          // Some entries (V4L2/Raspberry Pi) carry pre-`-c:v` pixel-format
+          // args. Find where `-c:v` is in the array — everything before
+          // becomes encoderImpliedOutputArgs (pixfmt), the element after
+          // `-c:v` is the encoder identifier, and anything after that is
+          // also part of encoderImpliedOutputArgs.
+          const cvIdx = encoderArgs?.indexOf("-c:v") ?? -1;
+          if (encoderArgs && cvIdx >= 0 && encoderArgs[cvIdx + 1]) {
+            resolvedVideoEncoder = encoderArgs[cvIdx + 1]!;
+            // Everything except the `-c:v <encoder>` pair becomes extra
+            // output args, preserving any pixel-format hints the upstream
+            // helper baked in (e.g. yuv420p for V4L2).
+            encoderImpliedOutputArgs = [
+              ...encoderArgs.slice(0, cvIdx),
+              ...encoderArgs.slice(cvIdx + 2),
+            ];
+          }
+        } catch {
+          // ignore; fall back to library default below
+        }
+      }
+      const finalExtraOutputArgs = encoderImpliedOutputArgs.length || extraOutputArgs
+        ? [...encoderImpliedOutputArgs, ...(extraOutputArgs ?? [])]
+        : undefined;
 
       // On NVR/Hub, TrackMix lenses are selected via stream variant, not via a separate channel.
       // Use rtspChannel for BOTH wide and tele so the library can request tele via streamType/variant.
@@ -1967,6 +2172,20 @@ export class ReolinkCamera
         forceH264: true,
         assumeH264Inputs: compositeAssumeH264 ?? true,
         disableTranscode: compositeDisableTranscode ?? false,
+        // ffmpeg knobs — only include when set so the library defaults stay live.
+        ...(ffmpegPath ? { ffmpegPath } : {}),
+        ...(resolvedVideoEncoder
+          ? { videoEncoder: resolvedVideoEncoder }
+          : {}),
+        ...(compositeEncoderPreset
+          ? { encoderPreset: compositeEncoderPreset }
+          : {}),
+        ...(typeof compositeCrf === "number" ? { crf: compositeCrf } : {}),
+        ...(typeof compositeGopSeconds === "number"
+          ? { gopSeconds: compositeGopSeconds }
+          : {}),
+        ...(extraGlobalArgs ? { extraGlobalArgs } : {}),
+        ...(finalExtraOutputArgs ? { extraOutputArgs: finalExtraOutputArgs } : {}),
       };
     }
 
@@ -1995,7 +2214,7 @@ export class ReolinkCamera
         logger.log(
           "Restarting StreamManager due to PIP/composite settings change",
         );
-        this.initStreamManager(logger, true);
+        await this.initStreamManager(logger, true);
 
         // Invalidate snapshot cache for battery/multifocal-battery so that
         // the next snapshot reflects the new PIP/composite configuration.
@@ -3560,7 +3779,7 @@ export class ReolinkCamera
       const logger = this.getBaichuanLogger();
       logger.warn("StreamManager not initialized, initializing now...");
       try {
-        this.initStreamManager(logger);
+        await this.initStreamManager(logger);
       } catch (e) {
         logger.error(
           "Failed to initialize StreamManager in getVideoStream",
@@ -3788,6 +4007,18 @@ export class ReolinkCamera
     this.storageSettings.settings.pipPosition.hide = !this.isMultiFocal;
     this.storageSettings.settings.pipSize.hide = !this.isMultiFocal;
     this.storageSettings.settings.pipMargin.hide = !this.isMultiFocal;
+    this.storageSettings.settings.compositeAssumeH264.hide = !this.isMultiFocal;
+    this.storageSettings.settings.compositeDisableTranscode.hide =
+      !this.isMultiFocal;
+    this.storageSettings.settings.compositeVideoEncoder.hide = !this.isMultiFocal;
+    this.storageSettings.settings.compositeEncoderPreset.hide =
+      !this.isMultiFocal;
+    this.storageSettings.settings.compositeCrf.hide = !this.isMultiFocal;
+    this.storageSettings.settings.compositeGopSeconds.hide = !this.isMultiFocal;
+    this.storageSettings.settings.compositeExtraGlobalArgs.hide =
+      !this.isMultiFocal;
+    this.storageSettings.settings.compositeExtraOutputArgs.hide =
+      !this.isMultiFocal;
 
     const hideUid = !this.isBattery || this.isOnNvr || !!this.multiFocalDevice;
     this.storageSettings.settings.uid.hide = hideUid;
@@ -3844,7 +4075,7 @@ export class ReolinkCamera
     }
 
     try {
-      this.initStreamManager();
+      await this.initStreamManager();
     } catch (e) {
       logger.error(
         "Failed to initialize StreamManager in init",