Core Analysis¶

Core Issue: Achieving near-real-time multi-camera detection on resource-constrained hosts requires optimizing inference, decoding, and network connection bottlenecks.

Technical Analysis¶

• Add AI accelerators first: Coral/Hailo or a GPU offload inference from the CPU and are critical for concurrency.
• Use RTSP re-streaming: Re-streaming reduces camera connection counts and decoding pressure.
• Lower input quality: Reduce detection stream resolution and FPS (e.g., 720p or lower, 10–15 FPS) to cut decoding and inference cost.
• Use mask/zone editor: Limit detection to key areas to reduce per-frame work.
• Scale test incrementally: Measure per-stream CPU/inference latency on a single camera before scaling up.

Practical Steps (ordered)¶

1. Verify Coral/Hailo drivers and Docker compatibility on the target host.
2. Configure two camera streams per device: low-res for detection, high-res for recording/playback if needed.
3. Enable RTSP re-streaming to minimize direct camera connections.
4. Use motion detection as a filter and trigger full model inference on motion events.
5. Monitor CPU, memory, IO, and disk; tune resolution/FPS and retention accordingly.

Important Notes¶

Important: Accelerator drivers/firmware are tightly coupled with kernel and container versions—validate compatibility in the target environment.

Summary: Combining hardware acceleration, stream re-streaming, and resolution/zone optimization enables multi-camera near-real-time detection on constrained hosts, but requires staged testing and resource monitoring.

Core Analysis¶

Core Issue: Deployment issues typically stem from external components (camera streams, accelerator drivers, container/kernel) and user configuration errors (masks, thresholds, storage).

Common Failures & Diagnostic Steps¶

• Stream/decoding failures: Use ffprobe/ffmpeg on the host to test RTSP URL, codecs, and resolutions; check network and camera connection limits.
• Accelerator not visible or underperforming: Check lsusb, dmesg for device visibility and verify container access with docker run --device; confirm driver/firmware compatibility with the kernel.
• Dropped frames/high latency: Check Frigate logs for FPS and inference latency; reduce detection resolution/FPS or add an accelerator; enable RTSP re-streaming.
• False positives/negatives: Review mask/zone settings in the UI and adjust motion/model confidence thresholds.
• Disk filling up: Inspect recording/retain settings, confirm retention/rotation behavior and configure disk usage monitoring/alerts.

Practical Fixes¶

1. Triage layer by layer: network/RTSP → decoding → inference device → Frigate config → storage.
2. Validate stream stability and encoding with ffmpeg/ffprobe locally.
3. Ensure correct device mounts and matching drivers inside the container.
4. Test mask/threshold changes with short evaluation windows and watch logs.

Important: Many issues are due to driver/firmware vs. container/kernel mismatches—validate in a test environment before kernel/Docker upgrades.

Summary: Structured troubleshooting using standard tools (ffmpeg, container logs, device checks) will identify most issues; fixes typically involve configuration tuning or driver/compatibility resolution.

Core Analysis¶

Core Issue: To preserve critical events while maximizing storage efficiency, recording, detection, and retention policies should be layered and use multi-stream and event-tiering approaches.

Technical Analysis¶

• Detection stream vs. recording stream: Use a low-res/low-FPS detection stream for real-time detection; when important objects are detected, trigger high-quality recording to save the critical segment.
• Event-driven retention: Configure different retention periods for object types (e.g., person, vehicle, pet)—longer for high-priority events.
• Pre/post buffering: Configure appropriate pre/post buffers (e.g., 5–10s pre, 15–30s post) to preserve event context.
• Tiered storage: Keep metadata/thumbnails for non-event segments or shorter retention to save space.

Practical Recommendations (steps)¶

1. Configure two streams per camera: a low-res detection stream and a high-res record-on-trigger stream.
2. Set longer retain values for critical object types (person/vehicle) and shorter for others.
3. Use motion filtering and masks to reduce false triggers.
4. Enable disk usage alerts and set minimum retention thresholds to avoid accidental deletion of important clips.
5. Periodically export or back up key events to external storage (e.g., NAS) for secondary retention.

Important Notes¶

Important: Setting all cameras to high-res 24/7 recording will quickly consume disk—even with event-driven logic—so configure retention carefully.

Summary: Detection stream + event-triggered recording + tiered retention (by object type/priority), together with monitoring and backups, provides a practical path to save storage while preserving important events.

Core Analysis¶

Core Issue: Achieving low-latency alerts and live video requires optimizing both the event pipeline (MQTT → Home Assistant) and the video path (WebRTC/MSE/RTSP).

Technical Analysis¶

• Event pipeline (low latency): Enable Frigate’s MQTT output to publish detection events (e.g., person/vehicle). Home Assistant consumes them via the Frigate custom component or direct MQTT subscriptions to trigger automations.
• Video playback (low latency):
• Prefer WebRTC: Lowest end-to-end latency for browsers and supported clients.
• Use MSE: Lower latency and broad compatibility where supported.
• Use RTSP re-streaming when camera limitations exist or to reduce camera connection counts—Frigate re-streams and forwards to clients.

Practical Steps¶

1. Enable and configure the mqtt section in Frigate, aligning topics/payloads with Home Assistant subscriptions.
2. Install/configure the Frigate integration in Home Assistant or create MQTT triggers for entities and automations.
3. Use WebRTC for low-latency viewing; fallback to MSE or RTSP as needed.
4. Place Frigate and Home Assistant on the same LAN/subnet when possible to minimize hops.

Important Notes¶

Important: WebRTC may require TURN/STUN for NAT traversal in cross-network scenarios; MQTT event rate limiting or improper handling can introduce delays on the Home Assistant side.

Summary: By optimizing both MQTT event delivery and selecting appropriate low-latency video transports (WebRTC > MSE > RTSP re-streaming), you can achieve fast alerts and real-time video in a LAN setup—assuming correct configuration and network support.