Skip to content

Hardware-Beschleunigung ​

camera.ui beschleunigt zwei Dinge: die Video-Pipeline (Dekodieren der Kamera-Streams für Erkennung, Live-Ansicht und Snapshots sowie Enkodieren fürs Streaming) und die KI-Inferenz (Objekterkennung und alles, was darauf aufbaut).

Video-Beschleunigung ist auf jeder Plattform automatisch. camera.ui prüft die Hardware zur Laufzeit, wählt das beste verfügbare Backend und fällt auf Software zurück, wenn keins da ist. Auch KI-Beschleuniger arbeiten automatisch, sobald die Hardware erreichbar ist; unter Docker heißt das: das Device durchreichen (siehe unten).

Was läuft wo ​

PlattformVideo-Pipeline (automatisch)KI-Backends
macOS (Desktop-App, Intel & Apple Silicon)VideoToolbox (Apple GPU + Media Engine)CoreML (Apple GPU + Neural Engine), ONNX
Windows (Desktop-App, x64)NVIDIA (CUDA/NVENC), Intel (QSV) und jede GPU via Direct3D 11/12OpenVINO (Intel GPU/NPU), ONNX (NVIDIA CUDA)
Linux x64 (Docker, bare-metal, Proxmox)NVIDIA (CUDA/NVENC), Intel (VA-API/QSV), AMD (VA-API), dazu Vulkan/OpenCLOpenVINO (Intel GPU/NPU), ONNX (CUDA/TensorRT), NCNN (Vulkan), Coral, Hailo
Linux arm64 (Docker, bare-metal)Rockchip (RKMPP)Coral, Hailo, NCNN (CPU, Vulkan)

Die Tabelle zeigt, was camera.ui nutzen kann. Der passende GPU-Treiber muss trotzdem auf dem Host installiert sein. Ein Backend, dessen Treiber fehlt, wird still übersprungen und erzeugt nie einen Fehler. Auf einem Raspberry Pi lässt NCNN die GPU aus und rechnet auf der CPU, die dort um ein Vielfaches schneller ist.

Die Desktop-App braucht keine Einrichtung: macOS bringt die Video-Beschleunigung mit dem Betriebssystem mit, Windows nutzt den System-Grafiktreiber. Jedes Erkennungs-Plugin loggt, worauf jedes Modell läuft (Loaded model: …), und zeigt es unter Active Hardware in seinen Plugin-Einstellungen.

Der Rest dieser Seite ist für Linux und Docker, wo Hardware in drei Schritten die Container-Grenze überwinden muss:

  1. Host-Treiber. Der kernelseitige Treiber muss auf dem Host installiert sein (der einzige Teil, den ein Docker-Image nie mitliefern kann).
  2. Device-Passthrough. Der Device-Node kommt in den devices:-Abschnitt deiner Compose-Datei.
  3. Verifizieren. Der Container sagt dir, was tatsächlich angekommen ist.

GPUs wählst du über den passenden Image-Flavor. KI-Beschleuniger funktionieren mit jedem Flavor: Die Coral-Runtime steckt in jedem Image, und die Hailo-Runtime bringt ihr Plugin selbst mit. Die einzige Ausnahme ist die Intel NPU, deren Userspace-Treiber nur im intel-Flavor enthalten ist.

Host prüfen ​

Das cameraui/docker-Repository enthält einen Host-Helfer, der deine Maschine diagnostiziert und die Treiber installiert, die mehr als einen Paketmanager brauchen:

bash
curl -fsSLO https://raw.githubusercontent.com/cameraui/docker/main/scripts/host/cameraui-host.sh
sudo bash cameraui-host.sh check     # read-only: Treiber, Docker-Runtime, Device-Nodes
sudo bash cameraui-host.sh nvidia    # NVIDIA Container Toolkit installieren
sudo bash cameraui-host.sh hailo     # Hailo-PCIe-Kernel-Treiber bauen + installieren
sudo bash cameraui-host.sh coral     # gasket/apex-Treiber installieren (PCIe/M.2-Coral)

check gibt für jede Beschleuniger-Klasse eine ✓/✗-Zeile mit dem passenden Fix aus. Führe es zuerst aus.

Aus dem Container verifizieren ​

Bei jedem Start loggt der Container, welche Device-Nodes er tatsächlich sieht:

[setup] accelerator devices: /dev/dri ✓ · /dev/kfd ✗ · /dev/accel ✗ · /dev/apex_0 ✓ · /dev/hailo0 ✗ · /dev/bus/usb ✗ · nvidia ✗

Zeigt ein Device hier ✗, existiert aber auf dem Host, fehlt es in deiner Compose-devices:-Liste. blocked heißt, der Container sieht das Device, darf es aber nicht öffnen: Es wurde als Volume eingebunden statt unter devices: eingetragen, oder der Container läuft als Docker-Swarm-Dienst. Die Erkennungs-Plugins loggen zusätzlich, was sie gefunden haben (Available devices: …) und worauf jedes Modell wirklich läuft (Loaded model: … (AUTO -> CPU)), und zeigen es unter Active Hardware in ihren Plugin-Einstellungen.

Schnellreferenz ​

HardwareBeschleunigtHost-TreiberAn den Container durchreichen
Intel / AMD GPUVideo (VA-API/QSV) + OpenCL/Vulkan-Inferenzim Kernel (i915/amdgpu)/dev/dri
NVIDIA GPUVideo (NVENC/NVDEC) + CUDANVIDIA-Treiber + Container Toolkitüber die Toolkit-Runtime
Coral Edge TPU (PCIe/M.2)Objekterkennunggasket/apex (coral-Befehl)/dev/apex_0
Coral Edge TPU (USB)Objekterkennungkeiner/dev/bus/usb
Hailo-8 / Hailo-8LObjekterkennunghailo_pci + Firmware (hailo-Befehl)/dev/hailo0
Intel NPU (Core Ultra)OpenVINO-Inferenzintel_vpu-Kernelmodul + Firmware/dev/accel (intel-Flavor)
AMD ROCmComputeROCm-Stack/dev/kfd + /dev/dri

Intel / AMD GPU ​

Der Treiber ist Teil des Kernels, auf dem Host ist nichts zu installieren. Nutze den intel- oder amd-Flavor und reiche /dev/dri durch:

yaml
    devices:
      - /dev/dri:/dev/dri

Ältere Intel-iGPUs (Gen8 bis Gen11, z. B. UHD 630)

Intels aktuelle OpenCL-Runtime deckt nur noch Gen12 und neuer ab. Der intel-Flavor bündelt deshalb zusätzlich Intels Legacy-Runtime, sodass OpenVINO- und OpenCL-Inferenz auch auf Gen8- bis Gen11-iGPUs funktioniert (Broadwell bis Comet Lake). Nur Chips vor Gen8 (Haswell und älter) haben gar keine OpenCL-Runtime: Dort fällt die Inferenz auf die CPU zurück, und ein Coral oder Hailo ist der Weg zu schneller Erkennung. Die Video-Dekodierung ist auf allen ohnehin voll beschleunigt.

NVIDIA GPU ​

Zwei host-seitige Bausteine: der NVIDIA-Treiber (z. B. sudo ubuntu-drivers install) und das Container Toolkit, das die Treiber-Bibliotheken in Container injiziert. sudo bash cameraui-host.sh nvidia installiert das Toolkit und registriert es bei Docker. Nutze dann das nvidia-Flavor-Override von der Docker-Seite. NVIDIA_DRIVER_CAPABILITIES=all aktiviert auch die OpenCL- und Vulkan-Pfade, die die Erkennungs-Plugins nutzen können.

Außerhalb von Docker (Bare-Metal-Linux, Windows) braucht CUDA-Erkennung mit dem ONNX-Plugin zusätzlich die CUDA-13-Bibliotheken und cuDNN 9 systemweit von NVIDIA. In Docker bringt das nvidia-Image beides mit und braucht einen NVIDIA-Treiber ab 580; das nvidia-cuda12-Image bleibt für ältere Treiber bei CUDA 12 und gehört zum ONNX-Legacy-Plugin. Das nvidia-tensorrt-Image bringt zusätzlich die TensorRT-Runtime für den tensorrt-Provider des ONNX-Plugins mit, das verdoppelt grob den Erkennungsdurchsatz, kostet aber etwa doppelt so viel VRAM; außerhalb von Docker installierst du TensorRT 10 bei Bedarf selbst. Die Grenze zwischen den beiden Schienen liegt bei Turing: GTX 16xx / RTX 20xx und neuer nutzen das ONNX-Plugin auf den CUDA-13-Images, GTX 900 und 10xx (Maxwell, Pascal, Volta) laufen nur mit dem ONNX-Legacy-Plugin auf nvidia-cuda12, und RTX 50xx läuft ausschließlich auf der CUDA-13-Seite. Karten vor der GTX 900 werden nicht unterstützt.

Coral Edge TPU ​

Die Laufzeit-Bibliothek (libedgetpu) ist bereits in jedem Image-Flavor enthalten. Nur die Host-Seite unterscheidet sich je nach Bauform:

  • PCIe / M.2. Braucht den gasket/apex-Kernel-Treiber. sudo bash cameraui-host.sh coral installiert ihn (ein gepflegter Community-Build, da Googles Original-Paket auf Kerneln ≥ 6.13 nicht mehr kompiliert). Danach das Device durchreichen:

    yaml
        devices:
          - /dev/apex_0:/dev/apex_0
  • USB. Kein Treiber nötig, nur den USB-Bus durchreichen:

    yaml
        devices:
          - /dev/bus/usb:/dev/bus/usb

Ohne erreichbaren TPU läuft das Coral-Plugin auf der CPU und sagt das in seinem Log. Prüfe seine Available devices:-Zeile, falls die Erkennung langsam wirkt.

Um zu sehen, auf welchem Gerät die Erkennung tatsächlich läuft, starte den Benchmark unter Metrics → Kameras: Seine Seite je Kamera nennt Runtime, Modell und Gerät. Siehe Was Erkennung kostet.

Hailo-8 / Hailo-8L ​

Der Kernel-Treiber wird auf dem Host aus dem Quellcode gebaut: sudo bash cameraui-host.sh hailo installiert die Build-Abhängigkeiten, kompiliert den Treiber und installiert Firmware und udev-Regeln. Danach neu starten, damit die Firmware lädt, dann das Device durchreichen:

yaml
    devices:
      - /dev/hailo0:/dev/hailo0

Die Userspace-Runtime liefert das Hailo-Plugin selbst mit.

Intel NPU (Core Ultra) ​

Der intel-Flavor bündelt den Userspace-Treiber der NPU (Level Zero + Intel NPU UMD und Compiler); andere Flavors nicht. Auf dem Host brauchst du das intel_vpu-Kernelmodul (upstream seit Linux 6.8) und dessen Firmware; falls /dev/accel fehlt, siehe intel/linux-npu-driver. Dann das Device durchreichen:

yaml
    devices:
      - /dev/accel:/dev/accel

Das OpenVINO-Plugin listet dann NPU in seiner Available devices:-Log-Zeile und in seiner Device-Einstellung.

Alle Produktnamen, Logos und Marken gehören ihren jeweiligen Inhabern. Ihre Nennung bedeutet keine Verbindung oder Empfehlung.