npm - @camstack/addon-pipeline - Versions diffs - 1.1.26 → 1.1.28 - Mend

@camstack/addon-pipeline 1.1.26 → 1.1.28

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/embed-dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>CamStack Embed</title>
-    <script type="module" crossorigin src="./assets/index-C-pL8ETk.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-DrJ0ee3f.css">
+    <script type="module" crossorigin src="./assets/index-CeZV1B-2.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-C5UpuPr8.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.1.26",
+  "version": "1.1.28",
   "description": "CamStack Pipeline bundle — runner, detection, motion, decoders, audio + stream broker. Multi-entry npm package shipping 7 addons under a single bundle.",
   "keywords": [
     "camstack",
@@ -36,6 +36,10 @@
       "import": "./dist/decoder-ffmpeg/index.mjs",
       "require": "./dist/decoder-ffmpeg/index.js"
     },
+    "./decoder-nodeav": {
+      "import": "./dist/decoder-nodeav/index.mjs",
+      "require": "./dist/decoder-nodeav/index.js"
+    },
     "./audio-codec-ffmpeg": {
       "import": "./dist/audio-codec-ffmpeg/index.mjs",
       "require": "./dist/audio-codec-ffmpeg/index.js"
@@ -149,7 +153,7 @@
         "category": "pipeline",
         "name": "Decoder (ffmpeg)",
         "version": "0.1.0",
-        "description": "Out-of-process video decoder spawning an ffmpeg subprocess — VA-API safe on Intel (a decode crash is isolated to the child, never taking down the runner). The sole decoder; ffmpeg is provisioned per node via ctx.deps.ensureFfmpeg().",
+        "description": "Out-of-process video decoder spawning an ffmpeg subprocess — a decode crash is isolated to the child, never taking down the runner. The DEFAULT decoder backend: it registers the decoder cap only when the node's `decoder` settings section selects `ffmpeg` (the default). ffmpeg is provisioned per node via ctx.deps.ensureFfmpeg().",
         "entry": "./dist/decoder-ffmpeg/index.js",
         "execution": {
           "placement": "any-node",
@@ -157,7 +161,30 @@
         },
         "capabilities": [
           {
-            "name": "decoder"
+            "name": "decoder",
+            "optional": true
+          }
+        ],
+        "passive": true,
+        "protected": true,
+        "icon": "assets/icon.svg",
+        "color": "#0ea5e9"
+      },
+      {
+        "id": "decoder-nodeav",
+        "category": "pipeline",
+        "name": "Decoder (node-av)",
+        "version": "0.1.0",
+        "description": "In-process video decoder using FFmpeg native bindings (node-av) — no subprocess lifecycle (nothing to spawn, supervise, or leak). Registers the decoder cap only when the node's `decoder` settings section selects `nodeav`; decoder-ffmpeg is the default backend.",
+        "entry": "./dist/decoder-nodeav/index.js",
+        "execution": {
+          "placement": "any-node",
+          "heapProfile": "heavy"
+        },
+        "capabilities": [
+          {
+            "name": "decoder",
+            "optional": true
           }
         ],
         "passive": true,
@@ -299,6 +326,7 @@
     "@camstack/system": "*",
     "lucide-react": "^0.511.0",
     "mp4box": "0.5.4",
+    "node-av": "^6.0.0",
     "sharp": "^0.35.2",
     "zod": "^4.3.6"
   },

package/python/inference_pool.py CHANGED Viewed

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Async inference pool — request_id multiplexed, per-runtime concurrency.
-Architecture mirrors Scrypted's ML plugins (coreml / openvino / onnx):
+Per-runtime ML backends (coreml / openvino / onnx):
   - asyncio main loop reads requests from stdin; inference is dispatched
     onto a runtime-specific executor so the reader never blocks.
   - Each request carries a 32-bit id; responses are tagged with the same
@@ -10,9 +10,10 @@ Architecture mirrors Scrypted's ML plugins (coreml / openvino / onnx):
       CoreML   → ThreadPoolExecutor(1) — ANE is single-context; one
                  Python thread is enough, and avoids GIL thrashing.
       OpenVINO → ThreadPoolExecutor(OPTIMAL_NUMBER_OF_INFER_REQUESTS),
-                 each thread driving its own InferRequest, with the model
-                 compiled under the THROUGHPUT hint so the streams run
-                 concurrently (a single shared request serialises cameras).
+                 each worker checking out an InferRequest from a fixed
+                 per-model pool (created once, post-compile), with the model
+                 compiled on ONE explicit device under the LATENCY hint (no
+                 AUTO — its CPU->GPU handover invalidated in-flight requests).
       ONNX     → ThreadPoolExecutor(N) — N independent InferenceSessions
                  where N = concurrency setting; each session pinned to
                  its own worker thread.
@@ -48,7 +49,6 @@ import platform
 import shutil
 import struct
 import sys
-import threading
 import time
 from collections import deque
 from dataclasses import dataclass, field
@@ -76,7 +76,7 @@ MSG_INFER_RAW = 0x02
 # Each item is dispatched concurrently via asyncio.gather so the
 # predict pool's existing parallelism applies; the saving over N
 # separate calls is one IPC round-trip per item collapsed to one,
-# matching Scrypted's batch=4 semantics for fair benchmarking.
+# with batch=4 semantics for fair benchmarking.
 MSG_INFER_BATCH = 0x03
 MSG_CACHE_FRAME = 0x04
 MSG_INFER_CACHED = 0x05
@@ -166,62 +166,47 @@ class ModelSlot:
 _runtime: str = ""
 _runtime_lib: Any = None
 # Max OPTIMAL_NUMBER_OF_INFER_REQUESTS across loaded OpenVINO models — used
-# to size the predict pool so the THROUGHPUT streams are actually fed.
+# to size the predict pool so the per-model InferRequest pool is actually fed.
 _ov_optimal_reqs: int = 0
 # Default OpenVINO predict-pool size when models load lazily (so we can't yet
 # query the device's optimal request count). ≈ measured optimal on Intel
 # CPU/iGPU/NPU (4-5). Threads idle-block on infer, so over-provisioning is cheap.
 OV_DEFAULT_CONCURRENCY: int = 4
-# OpenVINO device-mode decision — EXACT port of Scrypted's OpenVINO plugin
-# device switch (scrypted-ov-init.py:109-194). Scrypted's rationale, kept
-# verbatim: "AUTO mode can cause conflicts or hide errors with NPU and GPU
-# so try to be explicit and fall back accordingly." The intel-iGPU-only case
-# (the N100) compiles explicit "GPU" — the exact host where the AUTO plugin's
-# mid-flight CPU-helper -> GPU handover invalidated in-flight InferRequest
-# output ports ("Cannot find tensor for port opset1::Result score_8").
-def _resolve_ov_mode(available: list[str], full_names: dict[str, str]) -> str:
-    """Scrypted's exact mode string for an AUTO/default device request.
-    `available` is `core.available_devices`; `full_names` maps each device to
-    its FULL_DEVICE_NAME property (entries whose property query failed are
-    absent — mirrors Scrypted's per-device `except: pass`, so such a device
-    is not classified). The branch matrix, byte-faithful to Scrypted:
-      npu & gpu          -> "AUTO:NPU,GPU,CPU"
-      npu & !gpu         -> "AUTO:NPU,CPU"
-      NVIDIA dGPU(s)     -> "AUTO:<dgpu[,dgpu...]>,CPU"
-      gpu (intel only)   -> "GPU"          (explicit — the N100 case)
-      else               -> "AUTO"
+# OpenVINO device decision. AUTO is NEVER used: the AUTO plugin runs inference
+# on a CPU "helper" while the GPU JIT-compiles, then hands the model over to the
+# GPU mid-flight. InferRequests created during that window bind to the
+# CPU-helper's Result ports; after handover the served model's ports diverge and
+# req.infer() raises "Cannot find tensor for port opset1::Result score_8" (proven
+# live on the N100 iGPU). Compiling ONE explicit device removes the handover
+# entirely. We resolve an ordered candidate list (NPU > GPU > CPU) and compile the
+# first that succeeds, with CPU as the guaranteed floor.
+def _resolve_ov_devices(available: list[str], full_names: dict[str, str]) -> list[str]:
+    """Ordered EXPLICIT device candidates for compile-time failover (NPU>GPU>CPU).
+    Never returns an AUTO/AUTO:.. mode (see the module comment above). `available`
+    is `core.available_devices`; `full_names` maps each device to its
+    FULL_DEVICE_NAME (missing entries = the probe failed, left unclassified). A
+    GPU is only accepted when its FULL_DEVICE_NAME probed successfully (this is
+    also how an Intel iGPU vs an NVIDIA dGPU is told apart downstream). Ordering:
+    NPU(s) -> GPU(s) -> CPU (always last). The compile loop tries each in order
+    and stops at the first that compiles; CPU is the guaranteed fallback.
     """
-    npu = False
-    gpu = False
-    dgpus: list[str] = []
+    npus: list[str] = []
+    gpus: list[str] = []
     for device in available:
         full_device_name = full_names.get(device)
-        if full_device_name is None:
-            continue
-        if "NVIDIA" in full_device_name and "dGPU" in full_device_name:
-            dgpus.append(device)
         if "NPU" in device:
-            npu = True
-        if "GPU" in device:
-            gpu = True
-    mode = "AUTO"
-    if npu:
-        if gpu:
-            mode = "AUTO:NPU,GPU,CPU"
-        else:
-            mode = "AUTO:NPU,CPU"
-    elif len(dgpus):
-        mode = f"AUTO:{','.join(dgpus)},CPU"
-    # forcing GPU can cause crashes on older GPU. (Scrypted's comment — the
-    # GPU-mode compile failure falls back to AUTO in the compile loop below.)
-    elif gpu:
-        mode = "GPU"
-    return mode
+            npus.append(device)
+        elif "GPU" in device and full_device_name is not None:
+            gpus.append(device)
+    ordered: list[str] = [*npus, *gpus]
+    if "CPU" in available and "CPU" not in ordered:
+        ordered.append("CPU")
+    if not ordered:
+        ordered = ["CPU"]
+    return ordered
 # ONNX Runtime execution-provider names used by _resolve_onnx_providers.
@@ -239,8 +224,7 @@ def _resolve_onnx_providers(
 ) -> list:
     """Ordered ONNX Runtime providers — hardware first, CPU always last.
-    Mirrors Scrypted's ONNX plugin ordering (scrypted-onnx-init.py:95-109)
-    for the AUTO/default case:
+    Ordering for the AUTO/default case:
       darwin                    -> CoreMLExecutionProvider
       linux/win on x86_64/AMD64 -> ("CUDAExecutionProvider", {"device_id": N})
@@ -253,8 +237,8 @@ def _resolve_onnx_providers(
         (ort.get_available_providers()) are dropped — camstack ships the
         plain `onnxruntime` wheel on most nodes, and requesting an EP the
         build lacks raises at session creation instead of falling back.
-      - platform match uses startswith so "darwin" never matches "win"
-        (Scrypted's `"win" in sys.platform` would).
+      - platform match uses startswith so a substring test on "win" never
+        wrongly matches "darwin".
     """
     dev = (device or "").strip().lower()
     ordered: list = []
@@ -265,7 +249,7 @@ def _resolve_onnx_providers(
     elif dev == "cpu":
         pass  # explicit CPU pin — no hardware EPs
     else:
-        # AUTO/default — Scrypted's platform-driven ordering.
+        # AUTO/default — platform-driven ordering.
         if plat == "darwin":
             ordered.append(ONNX_COREML_EP)
         if plat.startswith(("linux", "win")) and machine in ("x86_64", "AMD64"):
@@ -281,8 +265,8 @@ def _resolve_onnx_providers(
 # ---------------------------------------------------------------------------
 # CoreML persistent compiled-model cache
 # ---------------------------------------------------------------------------
-# macOS bug (documented by Scrypted, coreml-init comment): the OS-level
-# compiled-model cache is NOT reused across process restarts — every
+# Known macOS behavior: the OS-level compiled-model cache is NOT reused across
+# process restarts — every
 # `ct.models.MLModel(.mlpackage)` load RECOMPILES the model, and the stale OS
 # cache is only cleared on reboot. camstack loads the .mlpackage on every pool
 # spawn, so each spawn paid the full recompile. Fix: after the first compile,
@@ -472,9 +456,9 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
             "ane": ct.ComputeUnit.CPU_AND_NE,
             "all": ct.ComputeUnit.ALL,
         }
-        # NOTE (Scrypted caveat, coreml-init comment): a macOS bug can cause
-        # the .mlpackage to be RECOMPILED on every load with the compiled
-        # cache not reused until reboot. camstack loads the .mlpackage on
+        # NOTE: a macOS behavior can cause the .mlpackage to be RECOMPILED on
+        # every load with the compiled cache not reused until reboot. camstack
+        # loads the .mlpackage on
         # every pool spawn, so it was exposed to the same trap.
         # _acquire_coreml_model routes through a persistent `.coreml-cache`
         # of the compiled `.mlmodelc` (CompiledMLModel on hit, plain MLModel
@@ -525,13 +509,13 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
     elif _runtime == "openvino":
         core = _runtime_lib
-        ov_device = str(config.get("device", "AUTO")).upper()
-        # Scrypted's exact device switch (see _resolve_ov_mode above): an
-        # AUTO/default request classifies the enumerated devices by their
-        # FULL_DEVICE_NAME and builds the same mode string Scrypted's
-        # OpenVINO plugin does. An operator-pinned device (config "device" =
-        # gpu/cpu/npu) is honored unchanged — compiled directly.
-        if ov_device in ("AUTO", "DEFAULT", ""):
+        ov_device_req = str(config.get("device", "AUTO")).upper()
+        # Device switch (see _resolve_ov_devices above): an AUTO/default request
+        # classifies the enumerated devices by FULL_DEVICE_NAME and yields an
+        # ORDERED EXPLICIT candidate list (NPU>GPU>CPU) for compile-time
+        # failover. An operator-pinned device (config "device" = gpu/cpu/npu) is
+        # honored unchanged — compiled directly, no failover.
+        if ov_device_req in ("AUTO", "DEFAULT", ""):
             available = list(core.available_devices)
             full_names: dict[str, str] = {}
             for dev in available:
@@ -539,41 +523,38 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
                     full_names[dev] = str(core.get_property(dev, "FULL_DEVICE_NAME"))
                 except Exception:
                     pass
-            ov_device = _resolve_ov_mode(available, full_names)
+            candidates = _resolve_ov_devices(available, full_names)
             sys.stderr.write(
-                f"OpenVINO: AUTO resolved to mode {ov_device} "
+                f"OpenVINO: explicit device candidates {candidates} "
                 f"(available: {available}, names: {full_names})\n"
             )
             sys.stderr.flush()
         else:
-            sys.stderr.write(f"OpenVINO: operator-pinned device {ov_device}\n")
+            candidates = [ov_device_req]  # operator pin — compiled directly
+            sys.stderr.write(f"OpenVINO: operator-pinned device {ov_device_req}\n")
             sys.stderr.flush()
-        # THROUGHPUT hint lets OpenVINO spin up multiple internal execution
-        # streams. Combined with one InferRequest per predict-pool thread
-        # (below), concurrent frames from N cameras run in parallel — the
-        # old `compiled(inp)` path drove a single shared default request, so
-        # every camera serialised through one stream regardless of how many
-        # predict workers existed. Measured ~1.5–2.4x throughput on CPU/GPU/NPU.
-        ov_config = {"PERFORMANCE_HINT": "THROUGHPUT"}
+        # LATENCY (not THROUGHPUT): one deterministic execution stream instead of
+        # N. THROUGHPUT spun up multiple internal streams whose lazy request
+        # creation collided with the AUTO handover AND multiplied memory (a factor
+        # in the N100 OOM-freeze). LATENCY keeps a single stream; camera-level
+        # concurrency comes from the fixed InferRequest pool built below.
+        ov_config = {"PERFORMANCE_HINT": "LATENCY"}
         # Persist compiled GPU/NPU kernels so the multi-second JIT compile is paid
         # once (first boot) instead of on every pool spawn. The cold compile storm
-        # (~25s for the full model set on an N100 iGPU) is the window where the AUTO
-        # CPU->GPU handover races (see the index-fetch note below) and frames pile up.
+        # (~25s for the full model set on an N100 iGPU) is where frames pile up;
+        # caching the kernels shrinks that window on subsequent boots.
         try:
             _cache_dir = os.path.join(os.path.dirname(os.path.abspath(path)), ".ov-cache")
             os.makedirs(_cache_dir, exist_ok=True)
             ov_config["CACHE_DIR"] = _cache_dir
         except OSError:
             pass
-        # Compile the resolved mode. Failure fallback is Scrypted's, exactly:
-        # any mode containing "GPU" reverts to plain "AUTO" and recompiles
-        # once; if THAT also fails (or the mode had no GPU), re-raise —
-        # camstack has no reset-and-restart like Scrypted, so the existing
-        # load/replace error handler reports the failure.
-        candidates = [ov_device]
-        if "GPU" in ov_device:
-            candidates.append("AUTO")
+        # Compile-time failover over the explicit candidate list (NO AUTO): try
+        # each device in order (NPU>GPU>CPU) and stop at the first that compiles.
+        # CPU is the guaranteed floor. If every candidate fails, re-raise — the
+        # existing load/replace error handler reports the failure.
         compiled = None
+        ov_device = None
         last_exc: Optional[BaseException] = None
         for candidate in candidates:
             try:
@@ -582,16 +563,16 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
                 break
             except Exception as exc:
                 last_exc = exc
-                sys.stderr.write(f"OpenVINO: compile with mode {candidate} failed: {exc}\n")
+                sys.stderr.write(f"OpenVINO: compile on {candidate} failed: {exc}\n")
                 if candidate != candidates[-1]:
-                    sys.stderr.write(f"OpenVINO: {candidate} mode failed, reverting to AUTO.\n")
+                    sys.stderr.write("OpenVINO: falling back to next device.\n")
                 sys.stderr.flush()
         if compiled is None:
             if last_exc is not None:
                 raise last_exc
             raise RuntimeError("OpenVINO: no device available to compile the model")
         # Name the resolved mode + what OpenVINO actually placed the model on
-        # (mirrors Scrypted's EXECUTION_DEVICES print) so a silent CPU
+        # (the EXECUTION_DEVICES property) so a silent CPU
         # placement is visible in the pool stderr.
         try:
             _exec_devices = compiled.get_property("EXECUTION_DEVICES")
@@ -614,30 +595,36 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
         except Exception:
             pass
-        # One InferRequest per predict thread (thread-local) — InferRequests
-        # are NOT safe to share across threads, and a per-thread request is
-        # what lets the THROUGHPUT streams run concurrently.
-        _ov_tls = threading.local()
+        # Create ALL InferRequests ONCE, now, post-compile. With AUTO gone there
+        # is no CPU->GPU handover, so no request can be born mid-handover and bind
+        # to stale ports — the score_8 race is structurally removed. Requests are
+        # handed out through a thread-safe queue: an InferRequest is never touched
+        # by two threads at once (checkout/return), so sharing a fixed pool is safe
+        # and avoids the old thread-local lazy creation. Size the pool to the
+        # device's optimal count (>= OV_DEFAULT_CONCURRENCY) so it matches the
+        # predict-pool worker count sized in _run().
+        import queue as _queue
+        try:
+            _n_req = int(compiled.get_property("OPTIMAL_NUMBER_OF_INFER_REQUESTS"))
+        except Exception:
+            _n_req = 0
+        _n_req = max(_n_req, OV_DEFAULT_CONCURRENCY)
+        _req_pool: "_queue.Queue" = _queue.Queue()
+        for _ in range(_n_req):
+            _req_pool.put(compiled.create_infer_request())
+        sys.stderr.write(f"OpenVINO: created {_n_req} InferRequest(s) up-front on {ov_device}\n")
+        sys.stderr.flush()
-        def predict(inp_dict: dict, _c=compiled, _names=output_names, _tls=_ov_tls) -> dict:
-            req = getattr(_tls, "req", None)
-            if req is None:
-                req = _tls.req = _c.create_infer_request()
+        def predict(inp_dict: dict, _names=output_names, _pool=_req_pool) -> dict:
             inp = list(inp_dict.values())[0]
+            req = _pool.get()
             try:
                 result = req.infer(inp)
-            except RuntimeError:
-                # AUTO CPU->GPU handover race: a request created during the
-                # CPU-helper phase (while the GPU JIT-compiles) cannot map the
-                # served model's output ports and raises — from INSIDE infer() —
-                # "Cannot find tensor for port ... score_8". (Reproduced live on
-                # the N100 iGPU under concurrent THROUGHPUT threads; the raise is
-                # in req.infer(), not the output fetch below.) Recreate the
-                # thread-local request post-handover and retry once.
-                req = _tls.req = _c.create_infer_request()
-                result = req.infer(inp)
-            # Fetch outputs by positional index (stable across the handover)
-            # rather than ConstOutput port identity — belt-and-braces.
+            finally:
+                _pool.put(req)
+            # Output fetch by positional index — stable and harmless now that the
+            # ports no longer diverge (single explicit device, no handover).
             return {name: result[i] for i, name in enumerate(_names)}
         slot.model = compiled
@@ -646,7 +633,7 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
     elif _runtime == "onnxruntime":
         ort = _runtime_lib
         ort_device = str(config.get("device", "") or "")
-        # Scrypted-style ordered providers — hardware EP first, CPU LAST as
+        # Ordered providers — hardware EP first, CPU LAST as
         # fallback (see _resolve_onnx_providers): a "cuda"/"coreml" pin puts
         # that EP first, a "cpu" pin compiles CPU only, and the AUTO/default
         # case derives the hardware EP from the platform.
@@ -658,8 +645,8 @@ def _load_model(slot: ModelSlot, config: dict) -> None:
             ort_device, sys.platform, platform.machine(), available_eps,
         )
         session = ort.InferenceSession(path, providers=providers)
-        # Report the EP that ACTUALLY initialized — Scrypted strips CPU and
-        # logs the remainder — so a silent CPU fallback is visible.
+        # Report the EP that ACTUALLY initialized (CPU stripped from the log)
+        # so a silent CPU fallback is visible.
         _active_eps = [p for p in session.get_providers() if p != ONNX_CPU_EP]
         _requested = [p[0] if isinstance(p, tuple) else p for p in providers]
         sys.stderr.write(
@@ -1271,18 +1258,18 @@ async def _run() -> None:
             sys.stderr.flush()
         models.append(slot)
-    # OpenVINO: size the predict pool so the THROUGHPUT execution streams are
-    # actually fed by concurrent infer-requests. The addon passes
-    # concurrency=1 (it predates per-thread infer requests) and models load
+    # OpenVINO: size the predict pool so the fixed InferRequest pool (built per
+    # model in _load_model) is actually fed by concurrent predict workers. The
+    # addon passes concurrency=1 (it predates the request pool) and models load
     # lazily AFTER this point, so we can't read OPTIMAL_NUMBER_OF_INFER_REQUESTS
     # here — default to OV_DEFAULT_CONCURRENCY (≈ the measured optimal of 4-5
     # on Intel CPU/iGPU/NPU). If startup-loaded models report a higher optimal,
-    # use that. One InferRequest is created per predict thread on first use.
+    # use that. The per-model InferRequest pool is sized to the same target.
     if runtime == "openvino":
         target = max(_ov_optimal_reqs, OV_DEFAULT_CONCURRENCY)
         if target > concurrency:
             sys.stderr.write(
-                f"OpenVINO THROUGHPUT: predict concurrency {concurrency} -> {target}\n"
+                f"OpenVINO LATENCY: predict concurrency {concurrency} -> {target}\n"
             )
             sys.stderr.flush()
             concurrency = target