Logitech Brio → Apple HomeKit Secure Video on Proxmox

Turn a Logitech Brio 4K USB webcam into a fully local HomeKit Secure Video camera — live view, iCloud-recorded motion clips, audio, and prebuffered recordings. Runs on a Proxmox node with Intel iGPU hardware acceleration.

Architecture

Proxmox host
│
├── /dev/video0        ← Logitech Brio 4K (V4L2, MJPEG)
├── /dev/snd/pcmC0D0c  ← Brio built-in microphone (ALSA)
├── /dev/dri/renderD128 ← Intel iGPU (VAAPI)
│
└── LXC CT200  (Ubuntu 22.04, privileged, your VLAN, your IP)
    │  Devices bind-mounted from host into container
    │
    ├── systemd: brio-stream.service
    │   ffmpeg captures MJPEG from /dev/video0, uploads frames to
    │   Intel GPU via VAAPI, encodes H264 (Constrained Baseline),
    │   captures audio from ALSA hw:0,0, encodes AAC 128k/16kHz,
    │   pushes combined RTSP stream to mediamtx on port 8554
    │
    ├── Docker: mediamtx  (bluenviron/mediamtx:latest-ffmpeg)
    │   Pure RTSP server. Accepts the stream published by
    │   brio-stream and re-serves it to Scrypted at
    │   rtsp://127.0.0.1:8554/brio
    │
    └── Docker: scrypted  (ghcr.io/koush/scrypted)
        Rebroadcast plugin prebuffers 10s of H264/AAC
        HomeKit plugin publishes camera in Accessory Mode (required for HSV)
        OpenCV plugin provides motion detection → triggers HSV recording
        Apple Home app ← HAP over local network → Scrypted

Components

Component	Role
LXC (privileged)	Isolation layer for Docker with direct device passthrough
Same VLAN as HomePods	HomeKit uses mDNS for discovery; camera must be on the same L2 segment as your HomePods and iPhones
brio-stream systemd service	Captures video + audio from the Brio and encodes to H264/AAC using VAAPI
mediamtx	RTSP server that accepts the stream from brio-stream and serves it to Scrypted
Scrypted	HomeKit bridge; handles prebuffering, motion detection, and HSV recording pipeline
OpenCV mixin	Software motion sensor; required for HSV — HomeKit only records clips when a motion event fires

Prerequisites

• Proxmox VE 7.x or 8.x
• Logitech Brio (USB ID 046d:085e) plugged into the Proxmox host
• Intel iGPU on the Proxmox host (Intel UHD 630 confirmed; any Gen 8+ iHD-compatible GPU works)
• The LXC's VLAN must be the same L2 segment as your HomePods and iPhones
• iCloud+ subscription (50 GB or higher) for HomeKit Secure Video recording
• Ubuntu 22.04 LXC template available on local storage

Deployment

Step 1 — configure and run on the Proxmox host

Edit the variables at the top of setup-host.sh to match your environment:

CT_ID=200                    # LXC container ID
CT_VLAN=1                    # VLAN tag (set to 0 or remove tag= if not using VLANs)
CT_IP="192.168.1.100/24"    # Static IP for the container
CT_GW="192.168.1.1"         # Gateway — must be on the same L2 as your HomePods
CT_DNS="192.168.1.1"         # DNS server
CT_DISK="local-lvm:16"      # Storage pool and disk size

Then run:

bash setup-host.sh

This script:

1. Detects the Brio on the USB bus and resolves its /dev/video* major numbers
2. Installs a udev rule so the device stays mode 0666 after replug
3. Downloads the Ubuntu 22.04 LXC template if not present
4. Creates the LXC container with the configured resources, IP, and onboot=1
5. Appends cgroup2 device rules and bind-mount entries to /etc/pve/lxc/<CT_ID>.conf for /dev/video*, /dev/bus/usb/…, /dev/dri, and /dev/snd
6. Starts the container

Step 2 — run inside the container

for f in setup-container.sh docker-compose.yml mediamtx.yml; do
  pct push 200 $f /root/$f
done
pct exec 200 -- bash /root/setup-container.sh

This installs Docker, copies docker-compose.yml and mediamtx.yml to /opt/scrypted/, and starts the mediamtx and scrypted containers.

Step 3 — install Intel VAAPI driver and brio-stream service

pct exec 200 -- apt-get install -y ffmpeg intel-media-va-driver
pct push 200 brio-stream.service /etc/systemd/system/brio-stream.service
pct exec 200 -- systemctl daemon-reload
pct exec 200 -- systemctl enable --now brio-stream.service
pct exec 200 -- docker restart mediamtx

Verify the stream is publishing:

pct exec 200 -- docker logs mediamtx --tail 5
# Expected: is publishing to path 'brio' ... 2 tracks (H264, MPEG-4 Audio)

Step 4 — configure Scrypted

Open http://<container-ip>:11080 and complete the one-time setup:

1. Create admin account
2. Install plugins from the Plugin Store:
   • @scrypted/homekit
   • @scrypted/prebuffer-mixin (Rebroadcast)
   • @scrypted/opencv
   • @scrypted/snapshot
3. Add the camera — Plugins → RTSP Camera Plugin → Add Device
   • Name: anything you like (e.g. Front Door)
   • RTSP URL: rtsp://127.0.0.1:8554/brio
4. Set RTSP Parser to FFmpeg TCP — open the camera device → Rebroadcast settings → RTSP Parser → FFmpeg (TCP)
5. Enable OpenCV — on the camera device, enable the OpenCV Motion Detection mixin
6. Enable HomeKit — on the camera device, enable the HomeKit mixin → set mode to Accessory (not Bridge)
7. Enable HomeKit Secure Video — toggle on in the HomeKit mixin settings for the camera

Step 5 — pair with Apple Home

1. Open the Home app → tap + → Add Accessory → More Options
2. The camera appears as a new unpaired accessory
3. Enter the 8-digit pairing code shown in Scrypted's HomeKit plugin page
4. In Home app camera settings, enable Record Video

Verify: wave in front of the camera — a clip should appear in the Home app Activity tab within ~30 seconds, including ~10 seconds of footage before the motion started (prebuffer).

Files

File	Purpose
setup-host.sh	Run on Proxmox host: creates LXC, configures device passthrough, sets udev rule
setup-container.sh	Run inside the LXC: installs Docker, copies and starts docker-compose
docker-compose.yml	Defines mediamtx and scrypted Docker services
mediamtx.yml	mediamtx config — listens on :8554, accepts RTSP publish on path brio
brio-stream.service	systemd unit — runs ffmpeg with VAAPI on the LXC, pushes to mediamtx
lxc-conf-additions.txt	Reference: the cgroup2 + mount entries added to /etc/pve/lxc/<CT_ID>.conf

Stream pipeline

Brio camera
  │  USB (UVC)
  ▼
/dev/video0   MJPEG frames at 1920×1080 30fps
  │  v4l2 input (ffmpeg, brio-stream.service)
  ▼
Intel iGPU
  │  VAAPI: format=nv12,hwupload → h264_vaapi
  │  Constrained Baseline, GOP=15 (keyframe every 0.5s)
  ▼
/dev/snd/pcmC0D0c   stereo PCM 48kHz  ──┐
  │  ALSA hw:0,0 (ffmpeg)               │ muxed
  │  AAC-LC 128kbps 16kHz stereo  ───────┘
  ▼
mediamtx  rtsp://127.0.0.1:8554/brio
  │  RTSP/TCP
  ▼
Scrypted — Rebroadcast plugin (FFmpeg TCP parser)
  │  10-second H264/AAC prebuffer in memory
  ▼
Scrypted — OpenCV Motion Detection mixin
  │  Fires MotionDetected event on pixel change
  ▼
Scrypted — HomeKit plugin (Accessory Mode)
  │  HAP over TCP/UDP, mDNS advertisement on local network
  ▼
Apple Home / iCloud
  Live view + HomeKit Secure Video clips

Reboot behaviour

Boot stage	What happens
Proxmox boots	LXC starts automatically (onboot: 1, startup order=2)
LXC init	Docker daemon starts (systemd docker.service)
Docker ready	mediamtx and scrypted containers start (restart: unless-stopped)
+10s	brio-stream.service exits ExecStartPre sleep, ffmpeg starts and connects to mediamtx
Scrypted ready	Rebroadcast plugin connects to rtsp://127.0.0.1:8554/brio, prebuffer fills
~60s after boot	Camera is live in HomeKit