@camstack/addon-pipeline 0.1.18 → 0.1.19

package/dist/motion-wasm/index.js

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("../index-DLHaHm6u.js");
+const index = require("../index-BbPPvoCx.js");
 const fs = require("node:fs");
 const path = require("node:path");
 const DEFAULT_CONFIG$1 = {

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { i as evaluateZoneRules, B as BaseAddon, t as motionDetectionCapability, m as hydrateSchema, D as DeviceType } from "../index-asZs8U_s.mjs";
+import { i as evaluateZoneRules, B as BaseAddon, t as motionDetectionCapability, m as hydrateSchema, D as DeviceType } from "../index-Bmlkm0Fd.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 const DEFAULT_CONFIG$1 = {

package/dist/pipeline-runner/index.js

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("../index-DLHaHm6u.js");
+const index = require("../index-BbPPvoCx.js");
 const shmRing = require("@camstack/shm-ring");
 class FrameQueue {
   /**
@@ -137,9 +137,9 @@ class PipelineTimingSampler {
     if (!this.detSamples.has(deviceId)) this.detSamples.set(deviceId, []);
     this.detSamples.get(deviceId).push(s);
   }
-  addMotionSample(deviceId, ms) {
+  addMotionSample(deviceId, ms, frameAge = -1) {
     if (!this.motSamples.has(deviceId)) this.motSamples.set(deviceId, []);
-    this.motSamples.get(deviceId).push(ms);
+    this.motSamples.get(deviceId).push({ ms, frameAge });
   }
   addAudioSample(deviceId, s) {
     if (!this.audioSamples.has(deviceId)) this.audioSamples.set(deviceId, []);
@@ -164,6 +164,7 @@ class PipelineTimingSampler {
       if (det.length === 0) continue;
       const e2e = det.map((s) => s.endToEnd);
       const inf = det.map((s) => s.inference);
+      const frameAge = det.map((s) => s.frameAge).filter((v) => v >= 0);
       const totalDet = det.reduce((s, d) => s + d.detections, 0);
       this.log.info(
         "pipeline stats",
@@ -172,7 +173,20 @@ class PipelineTimingSampler {
           meta: {
             frames: det.length,
             intervalSec: REPORT_INTERVAL_MS / 1e3,
+            // enqueue → emit, in ms. Stage breakdown (avg) exposes WHERE the
+            // latency sits: queue backlog vs semaphore contention vs inference
+            // vs result-emit. inference is usually the floor (model chain).
             e2e: { avg: avg(e2e), p95: p95(e2e), max: max(e2e) },
+            // Frame age (capture→inference-pick): if large, the analyzed frame is
+            // already stale (decoder/ring behind), which delays the overlay
+            // regardless of how fast the result is delivered.
+            frameAge: { avg: avg(frameAge), p95: p95(frameAge), max: max(frameAge) },
+            stagesMs: {
+              queueWait: avg(det.map((s) => s.queueWait)),
+              semaphoreWait: avg(det.map((s) => s.semaphoreWait)),
+              inference: avg(inf),
+              resultToEmit: avg(det.map((s) => s.resultToEmit))
+            },
             inference: { avg: avg(inf), p95: p95(inf) },
             detections: totalDet,
             dropped,
@@ -185,6 +199,8 @@ class PipelineTimingSampler {
     this.detSamples.clear();
     for (const [deviceId, mot] of this.motSamples) {
       if (mot.length === 0) continue;
+      const ms = mot.map((s) => s.ms);
+      const frameAge = mot.map((s) => s.frameAge).filter((v) => v >= 0);
       this.log.info(
         "motion stats",
         {
@@ -192,10 +208,12 @@ class PipelineTimingSampler {
           meta: {
             frames: mot.length,
             intervalSec: REPORT_INTERVAL_MS / 1e3,
-            avg: avg(mot),
-            p95: p95(mot),
-            max: max(mot)
-            // motionAddon: rt.motionAddon ?? null,
+            avg: avg(ms),
+            p95: p95(ms),
+            max: max(ms),
+            // Frame age at motion analysis (capture→analysis). Large = stale
+            // input frame (decoder/ring behind) → motion box lags real movement.
+            frameAge: { avg: avg(frameAge), p95: p95(frameAge), max: max(frameAge) }
           }
         }
       );
@@ -541,8 +559,7 @@ class PipelineRunner {
   async processWithSemaphore(deviceId, entry, frameInput, state, streamType) {
     const pickedAt = Date.now();
     const { frame, handle } = entry;
-    const captureTs = frame.timestamp;
-    const enqueuedAt = frame._enqueuedAt ?? captureTs;
+    const enqueuedAt = frame._enqueuedAt ?? pickedAt;
     const release = await this.semaphore.acquire();
     const semAcquiredAt = Date.now();
     try {
@@ -557,13 +574,19 @@ class PipelineRunner {
       if (result) {
         await this.notifyCallbacks(deviceId, frame, result, streamType, handle);
         const emittedAt = Date.now();
+        const capturedAt = frame.capturedAt;
         this.timingSampler.addSample(deviceId, {
-          captureToEnqueue: enqueuedAt - captureTs,
           queueWait: pickedAt - enqueuedAt,
           semaphoreWait: semAcquiredAt - pickedAt,
           inference: inferenceMs,
           resultToEmit: emittedAt - inferDoneAt,
-          endToEnd: emittedAt - captureTs,
+          // capturedAt is the shm-ring commit wall-clock; pickedAt − capturedAt
+          // is how stale the frame was when inference started. <0/absent → unknown.
+          frameAge: typeof capturedAt === "number" && capturedAt > 0 ? pickedAt - capturedAt : -1,
+          // Wall-clock pipeline latency: enqueue → result emitted. (Capture →
+          // enqueue, i.e. RTSP decode + shm-ring write, is not measured here —
+          // the shm frame carries only a PTS, no wall-clock capture stamp.)
+          endToEnd: emittedAt - enqueuedAt,
           detections: result.detections?.length ?? 0
         });
       }
@@ -754,6 +777,11 @@ const DEFAULT_CONFIG = {
   targetLoadPercent: 80,
   minThrottledFps: 1
 };
+function shouldStartOnboardAnalyzer(config) {
+  if (!config.onboardMotionDrivesAnalyzer) return false;
+  if (config.motionSources.includes("analyzer")) return false;
+  return true;
+}
 function toFrameInput(frame) {
   return {
     data: frame.data,
@@ -784,6 +812,20 @@ class PipelineRunnerAddon extends index.BaseAddon {
    * detach.
    */
   lastMotionAt = /* @__PURE__ */ new Map();
+  /**
+   * Dynamic analyzer subscriptions opened on `MotionOnMotionChanged
+   * source:'onboard'` when `onboardMotionDrivesAnalyzer === true`. Each
+   * entry is the unsubscribe handle returned by `subscribeMotionFrames`.
+   * Cleared on teardown timer fire, detach, and shutdown.
+   */
+  onboardAnalyzerSubs = /* @__PURE__ */ new Map();
+  /**
+   * Teardown timers that close the dynamic analyzer subscription after
+   * `motionCooldownMs` without a new motion event. Re-armed on every
+   * `MotionOnMotionChanged source:'onboard'` call so the sub stays open
+   * while motion persists.
+   */
+  onboardAnalyzerTeardownTimers = /* @__PURE__ */ new Map();
   /**
    * Snapshot-equality cache for metrics-snapshot defer. The runner
    * fires per-camera metrics every `METRICS_SNAPSHOT_INTERVAL_MS`;
@@ -848,6 +890,9 @@ class PipelineRunnerAddon extends index.BaseAddon {
           const attachment = this.attached.get(deviceId);
           if (!attachment) return;
           const source = data.source;
+          if (source === "onboard") {
+            void this.handleOnboardMotionAnalyzer(deviceId, data.detected);
+          }
           if (!attachment.config.motionSources.includes(source)) return;
           this.runner?.reportMotion(
             deviceId,
@@ -892,6 +937,9 @@ class PipelineRunnerAddon extends index.BaseAddon {
       this.unsubMotionEvents = null;
     }
     this.lastAnalyzerDetected.clear();
+    for (const deviceId of [...this.onboardAnalyzerTeardownTimers.keys(), ...this.onboardAnalyzerSubs.keys()]) {
+      this.clearOnboardAnalyzer(deviceId);
+    }
     if (this.runner) {
       this.runner.stop();
       this.runner = null;
@@ -1326,6 +1374,7 @@ class PipelineRunnerAddon extends index.BaseAddon {
   detachInternal(deviceId) {
     const attachment = this.attached.get(deviceId);
     if (!attachment) return;
+    this.clearOnboardAnalyzer(deviceId);
     attachment.motionUnsubscribe?.();
     attachment.detectionUnsubscribe?.();
     this.attached.delete(deviceId);
@@ -1334,6 +1383,70 @@ class PipelineRunnerAddon extends index.BaseAddon {
     this.runner?.unregisterCamera(deviceId);
     this.ctx?.logger.info("detachCamera", { tags: { deviceId } });
   }
+  /**
+   * Synchronously cancel the teardown timer and call the unsubscribe
+   * handle for the dynamic onboard analyzer, if one is open. Safe to
+   * call when no subscription exists.
+   */
+  clearOnboardAnalyzer(deviceId) {
+    const timer = this.onboardAnalyzerTeardownTimers.get(deviceId);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      this.onboardAnalyzerTeardownTimers.delete(deviceId);
+    }
+    const unsub = this.onboardAnalyzerSubs.get(deviceId);
+    if (unsub !== void 0) {
+      try {
+        unsub();
+      } catch {
+      }
+      this.onboardAnalyzerSubs.delete(deviceId);
+    }
+  }
+  /**
+   * Dynamic analyzer gate for onboard-motion cameras.
+   *
+   * Called from the `MotionOnMotionChanged` subscriber whenever
+   * `source === 'onboard'`. Opens a `subscribeMotionFrames` subscription
+   * the first time motion is detected (idempotent — a second `detected:true`
+   * while the sub is already open is a no-op). Always re-arms the teardown
+   * timer so the subscription stays open as long as motion events keep
+   * arriving and tears down `motionCooldownMs` after the last event.
+   *
+   * No-op when:
+   * - The camera is not currently attached.
+   * - `shouldStartOnboardAnalyzer(config)` returns false (flag off or
+   *   `motionSources` already includes `'analyzer'`).
+   */
+  async handleOnboardMotionAnalyzer(deviceId, detected) {
+    const attachment = this.attached.get(deviceId);
+    if (!attachment) return;
+    const config = attachment.config;
+    if (!shouldStartOnboardAnalyzer(config)) return;
+    const log = this.ctx.logger.withTags({ deviceId });
+    if (detected && !this.onboardAnalyzerSubs.has(deviceId)) {
+      const unsub = await this.subscribeMotionFrames(config);
+      if (unsub) {
+        this.onboardAnalyzerSubs.set(deviceId, unsub);
+        log.debug("onboard-analyzer: opened motion-frame subscription");
+      }
+    }
+    const existing = this.onboardAnalyzerTeardownTimers.get(deviceId);
+    if (existing !== void 0) clearTimeout(existing);
+    const cooldownMs = config.motionCooldownMs;
+    const timer = setTimeout(() => {
+      this.onboardAnalyzerTeardownTimers.delete(deviceId);
+      const unsub = this.onboardAnalyzerSubs.get(deviceId);
+      if (!unsub) return;
+      try {
+        unsub();
+      } catch {
+      }
+      this.onboardAnalyzerSubs.delete(deviceId);
+      log.debug("onboard-analyzer: closed after motion cooldown", { meta: { cooldownMs } });
+    }, cooldownMs);
+    this.onboardAnalyzerTeardownTimers.set(deviceId, timer);
+  }
   async getLocalLoad() {
     const metrics = this.runner?.getMetrics() ?? { avgInferenceTimeMs: 0, queueDepth: 0 };
     const allCameraMetrics = this.runner?.getAllCameraMetrics() ?? [];
@@ -1590,20 +1703,24 @@ class PipelineRunnerAddon extends index.BaseAddon {
           zonesPayload
         ));
       }
-      runner.timingSampler.addMotionSample(deviceId, Date.now() - motionStart);
+      const capturedAt = frame.capturedAt;
+      const motionFrameAge = typeof capturedAt === "number" && capturedAt > 0 ? motionStart - capturedAt : -1;
+      runner.timingSampler.addMotionSample(deviceId, Date.now() - motionStart, motionFrameAge);
     } catch (error) {
       const msg = index.errMsg(error);
       log.error("runMotionAnalysis failed", { meta: { error: msg } });
     }
   }
-  emitInferenceResult(deviceId, _frame, result, handle) {
+  emitInferenceResult(deviceId, frame, result, handle) {
     const ctx = this.ctx;
     if (!ctx?.eventBus) return;
+    const capturedAt = frame.capturedAt;
     const payload = {
       deviceId,
       frame: result,
       nodeId: this.nodeId,
-      frameHandle: handle
+      frameHandle: handle,
+      ...typeof capturedAt === "number" && capturedAt > 0 ? { capturedAt } : {}
     };
     this.ctx.eventBus.emit(index.createEvent(
       index.EventCategory.PipelineInferenceResult,
@@ -1744,4 +1861,5 @@ exports.PipelineTimingSampler = PipelineTimingSampler;
 exports.Semaphore = Semaphore;
 exports.customActions = pipelineRunnerBenchActions;
 exports.default = PipelineRunnerAddon;
+exports.shouldStartOnboardAnalyzer = shouldStartOnboardAnalyzer;
 //# sourceMappingURL=index.js.map