Update Double Take link to point to the maintained fork by skrashevich with improved features and fixed errors (#6746)

Signed-off-by: William Lam <wlam@vmware.com>
Co-authored-by: William Lam <wlam@vmware.com>

.github/ISSUE_TEMPLATE/detector_support_request.yml

@@ -1,6 +1,6 @@
-name: EdgeTpu Support Request
-description: Support for setting up EdgeTPU in Frigate
-title: "[EdgeTPU Support]: "
+name: Detector Support Request
+description: Support for setting up object detector in Frigate (Coral, OpenVINO, TensorRT, etc.)
+title: "[Detector Support]: "
 labels: ["support", "triage"]
 assignees: []
 body:

.github/workflows/ci.yml

@@ -6,6 +6,11 @@ on:
       - dev
       - master
 
+# only run the latest commit to avoid cache overwrites
+concurrency:
+  group: ${{ github.ref }}
+  cancel-in-progress: true
+
 env:
   PYTHON_VERSION: 3.9
 
@@ -14,6 +19,15 @@ jobs:
     runs-on: ubuntu-latest
     name: Image Build
     steps:
+      - name: Remove unnecessary files
+        run: |
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /opt/ghc
+      - id: lowercaseRepo
+        uses: ASzc/change-string-case-action@v5
+        with:
+          string: ${{ github.repository }}
       - name: Check out code
         uses: actions/checkout@v3
       - name: Set up QEMU
@@ -38,7 +52,7 @@ jobs:
           platforms: linux/amd64,linux/arm64,linux/arm/v7
           target: frigate
           tags: |
-            ghcr.io/blakeblackshear/frigate:${{ github.ref_name }}-${{ env.SHORT_SHA }}
+            ghcr.io/${{ steps.lowercaseRepo.outputs.lowercase }}:${{ github.ref_name }}-${{ env.SHORT_SHA }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
       - name: Build and push TensorRT
@@ -49,6 +63,5 @@ jobs:
           platforms: linux/amd64
           target: frigate-tensorrt
           tags: |
-            ghcr.io/blakeblackshear/frigate:${{ github.ref_name }}-${{ env.SHORT_SHA }}-tensorrt
+            ghcr.io/${{ steps.lowercaseRepo.outputs.lowercase }}:${{ github.ref_name }}-${{ env.SHORT_SHA }}-tensorrt
           cache-from: type=gha
-          cache-to: type=gha,mode=max

.github/workflows/dependabot-auto-merge.yaml

@@ -0,0 +1,22 @@
+name: dependabot-auto-merge
+on: pull_request
+
+permissions:
+  contents: write
+
+jobs:
+  dependabot-auto-merge:
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]'
+    steps:
+      - name: Get Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Enable auto-merge for Dependabot PRs
+        if: steps.metadata.outputs.dependency-type == 'direct:development' && (steps.metadata.outputs.update-type == 'version-update:semver-minor' || steps.metadata.outputs.update-type == 'version-update:semver-patch')
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pull_request.yml

@@ -65,7 +65,7 @@ jobs:
       - name: Check out the repository
         uses: actions/checkout@v3
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@v4.4.0
+        uses: actions/setup-python@v4.5.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
       - name: Install requirements

Dockerfile

@@ -18,57 +18,16 @@ WORKDIR /rootfs
 
 FROM base AS nginx
 ARG DEBIAN_FRONTEND
-ARG NGINX_VERSION=1.22.1
-ARG VOD_MODULE_VERSION=1.30
-ARG SECURE_TOKEN_MODULE_VERSION=1.4
-ARG RTMP_MODULE_VERSION=1.2.1
 
-RUN cp /etc/apt/sources.list /etc/apt/sources.list.d/sources-src.list \
-    && sed -i 's|deb http|deb-src http|g' /etc/apt/sources.list.d/sources-src.list \
-    && apt-get update
-
-RUN apt-get -yqq build-dep nginx
-
-RUN apt-get -yqq install --no-install-recommends ca-certificates wget \
-    && update-ca-certificates -f \
-    && mkdir /tmp/nginx \
-    && wget https://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz \
-    && tar -zxf nginx-${NGINX_VERSION}.tar.gz -C /tmp/nginx --strip-components=1 \
-    && rm nginx-${NGINX_VERSION}.tar.gz \
-    && mkdir /tmp/nginx-vod-module \
-    && wget https://github.com/kaltura/nginx-vod-module/archive/refs/tags/${VOD_MODULE_VERSION}.tar.gz \
-    && tar -zxf ${VOD_MODULE_VERSION}.tar.gz -C /tmp/nginx-vod-module --strip-components=1 \
-    && rm ${VOD_MODULE_VERSION}.tar.gz \
-    # Patch MAX_CLIPS to allow more clips to be added than the default 128
-    && sed -i 's/MAX_CLIPS (128)/MAX_CLIPS (1080)/g' /tmp/nginx-vod-module/vod/media_set.h \
-    && mkdir /tmp/nginx-secure-token-module \
-    && wget https://github.com/kaltura/nginx-secure-token-module/archive/refs/tags/${SECURE_TOKEN_MODULE_VERSION}.tar.gz \
-    && tar -zxf ${SECURE_TOKEN_MODULE_VERSION}.tar.gz -C /tmp/nginx-secure-token-module --strip-components=1 \
-    && rm ${SECURE_TOKEN_MODULE_VERSION}.tar.gz \
-    && mkdir /tmp/nginx-rtmp-module \
-    && wget https://github.com/arut/nginx-rtmp-module/archive/refs/tags/v${RTMP_MODULE_VERSION}.tar.gz \
-    && tar -zxf v${RTMP_MODULE_VERSION}.tar.gz -C /tmp/nginx-rtmp-module --strip-components=1 \
-    && rm v${RTMP_MODULE_VERSION}.tar.gz
-
-WORKDIR /tmp/nginx
-
-RUN ./configure --prefix=/usr/local/nginx \
-    --with-file-aio \
-    --with-http_sub_module \
-    --with-http_ssl_module \
-    --with-threads \
-    --add-module=../nginx-vod-module \
-    --add-module=../nginx-secure-token-module \
-    --add-module=../nginx-rtmp-module \
-    --with-cc-opt="-O3 -Wno-error=implicit-fallthrough"
-
-RUN make && make install
-RUN rm -rf /usr/local/nginx/html /usr/local/nginx/conf/*.default
+# bind /var/cache/apt to tmpfs to speed up nginx build
+RUN --mount=type=tmpfs,target=/tmp --mount=type=tmpfs,target=/var/cache/apt \
+    --mount=type=bind,source=docker/build_nginx.sh,target=/deps/build_nginx.sh \
+    /deps/build_nginx.sh
 
 FROM wget AS go2rtc
 ARG TARGETARCH
 WORKDIR /rootfs/usr/local/go2rtc/bin
-RUN wget -qO go2rtc "https://github.com/AlexxIT/go2rtc/releases/download/v0.1-rc.5/go2rtc_linux_${TARGETARCH}" \
+RUN wget -qO go2rtc "https://github.com/AlexxIT/go2rtc/releases/download/v1.2.0/go2rtc_linux_${TARGETARCH}" \
     && chmod +x go2rtc
 
 
@@ -132,7 +91,8 @@ RUN wget -qO cpu_model.tflite https://github.com/google-coral/test_data/raw/rele
 COPY labelmap.txt .
 # Copy OpenVino model
 COPY --from=ov-converter /models/public/ssdlite_mobilenet_v2/FP16 openvino-model
-RUN wget -q https://github.com/openvinotoolkit/open_model_zoo/raw/master/data/dataset_classes/coco_91cl_bkgr.txt -O openvino-model/coco_91cl_bkgr.txt
+RUN wget -q https://github.com/openvinotoolkit/open_model_zoo/raw/master/data/dataset_classes/coco_91cl_bkgr.txt -O openvino-model/coco_91cl_bkgr.txt && \
+    sed -i 's/truck/car/g' openvino-model/coco_91cl_bkgr.txt
 
 
 
@@ -184,6 +144,11 @@ RUN pip3 install -r requirements.txt
 COPY requirements-wheels.txt /requirements-wheels.txt
 RUN pip3 wheel --wheel-dir=/wheels -r requirements-wheels.txt
 
+# Make this a separate target so it can be built/cached optionally
+FROM wheels as trt-wheels
+ARG DEBIAN_FRONTEND
+ARG TARGETARCH
+
 # Add TensorRT wheels to another folder
 COPY requirements-tensorrt.txt /requirements-tensorrt.txt
 RUN mkdir -p /trt-wheels && pip3 wheel --wheel-dir=/trt-wheels -r requirements-tensorrt.txt
@@ -227,22 +192,10 @@ RUN ldconfig
 EXPOSE 5000
 EXPOSE 1935
 EXPOSE 8554
-EXPOSE 8555
+EXPOSE 8555/tcp 8555/udp
 
-# Fails if cont-init.d fails
-ENV S6_BEHAVIOUR_IF_STAGE2_FAILS=2
-# Wait indefinitely for cont-init.d to finish before starting services
-ENV S6_CMD_WAIT_FOR_SERVICES=1
-ENV S6_CMD_WAIT_FOR_SERVICES_MAXTIME=0
-# Give services (including Frigate) 30 seconds to stop before killing them
-# But this is not working currently because of:
-# https://github.com/just-containers/s6-overlay/issues/503
-ENV S6_SERVICES_GRACETIME=30000
 # Configure logging to prepend timestamps, log to stdout, keep 0 archives and rotate on 10MB
 ENV S6_LOGGING_SCRIPT="T 1 n0 s10000000 T"
-# TODO: remove after a new version of s6-overlay is released. See:
-# https://github.com/just-containers/s6-overlay/issues/460#issuecomment-1327127006
-ENV S6_SERVICES_READYTIME=50
 
 ENTRYPOINT ["/init"]
 CMD []
@@ -252,7 +205,11 @@ FROM deps AS devcontainer
 
 # Do not start the actual Frigate service on devcontainer as it will be started by VSCode
 # But start a fake service for simulating the logs
-COPY docker/fake_frigate_run /etc/services.d/frigate/run
+COPY docker/fake_frigate_run /etc/s6-overlay/s6-rc.d/frigate/run
+
+# Create symbolic link to the frigate source code, as go2rtc's create_config.sh uses it
+RUN mkdir -p /opt/frigate \
+    && ln -svf /workspace/frigate/frigate /opt/frigate/frigate
 
 # Install Node 16
 RUN apt-get update \
@@ -303,11 +260,13 @@ COPY --from=rootfs / /
 
 # Frigate w/ TensorRT Support as separate image
 FROM frigate AS frigate-tensorrt
-RUN --mount=type=bind,from=wheels,source=/trt-wheels,target=/deps/trt-wheels \
-    pip3 install -U /deps/trt-wheels/*.whl
+RUN --mount=type=bind,from=trt-wheels,source=/trt-wheels,target=/deps/trt-wheels \
+    pip3 install -U /deps/trt-wheels/*.whl && \
+    ln -s libnvrtc.so.11.2 /usr/local/lib/python3.9/dist-packages/nvidia/cuda_nvrtc/lib/libnvrtc.so && \
+    ldconfig
 
 # Dev Container w/ TRT
 FROM devcontainer AS devcontainer-trt
 
-RUN --mount=type=bind,from=wheels,source=/trt-wheels,target=/deps/trt-wheels \
+RUN --mount=type=bind,from=trt-wheels,source=/trt-wheels,target=/deps/trt-wheels \
     pip3 install -U /deps/trt-wheels/*.whl

Makefile

@@ -1,7 +1,7 @@
 default_target: local
 
 COMMIT_HASH := $(shell git log -1 --pretty=format:"%h"|tail -1)
-VERSION = 0.12.0
+VERSION = 0.12.1
 IMAGE_REPO ?= ghcr.io/blakeblackshear/frigate
 CURRENT_UID := $(shell id -u)
 CURRENT_GID := $(shell id -g)

README.md

@@ -16,7 +16,8 @@ Use of a [Google Coral Accelerator](https://coral.ai/products/) is optional, but
 - Communicates over MQTT for easy integration into other systems
 - Records video with retention settings based on detected objects
 - 24/7 recording
-- Re-streaming via RTMP to reduce the number of connections to your camera
+- Re-streaming via RTSP to reduce the number of connections to your camera
+- WebRTC & MSE support for low-latency live view
 
 ## Documentation
 

docker/build_nginx.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+
+set -euxo pipefail
+
+NGINX_VERSION="1.22.1"
+VOD_MODULE_VERSION="1.30"
+SECURE_TOKEN_MODULE_VERSION="1.4"
+RTMP_MODULE_VERSION="1.2.1"
+
+cp /etc/apt/sources.list /etc/apt/sources.list.d/sources-src.list
+sed -i 's|deb http|deb-src http|g' /etc/apt/sources.list.d/sources-src.list
+apt-get update
+
+apt-get -yqq build-dep nginx
+
+apt-get -yqq install --no-install-recommends ca-certificates wget
+update-ca-certificates -f
+mkdir /tmp/nginx
+wget -nv https://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz
+tar -zxf nginx-${NGINX_VERSION}.tar.gz -C /tmp/nginx --strip-components=1
+rm nginx-${NGINX_VERSION}.tar.gz
+mkdir /tmp/nginx-vod-module
+wget -nv https://github.com/kaltura/nginx-vod-module/archive/refs/tags/${VOD_MODULE_VERSION}.tar.gz
+tar -zxf ${VOD_MODULE_VERSION}.tar.gz -C /tmp/nginx-vod-module --strip-components=1
+rm ${VOD_MODULE_VERSION}.tar.gz
+    # Patch MAX_CLIPS to allow more clips to be added than the default 128
+sed -i 's/MAX_CLIPS (128)/MAX_CLIPS (1080)/g' /tmp/nginx-vod-module/vod/media_set.h
+patch -d /tmp/nginx-vod-module/ -p1 << 'EOF'
+--- a/vod/avc_hevc_parser.c       2022-06-27 11:38:10.000000000 +0000
++++ b/vod/avc_hevc_parser.c       2023-01-16 11:25:10.900521298 +0000
+@@ -3,6 +3,9 @@
+ bool_t
+ avc_hevc_parser_rbsp_trailing_bits(bit_reader_state_t* reader)
+ {
++	// https://github.com/blakeblackshear/frigate/issues/4572
++	return TRUE;
++
+ 	uint32_t one_bit;
+
+ 	if (reader->stream.eof_reached)
+EOF
+
+
+mkdir /tmp/nginx-secure-token-module
+wget https://github.com/kaltura/nginx-secure-token-module/archive/refs/tags/${SECURE_TOKEN_MODULE_VERSION}.tar.gz
+tar -zxf ${SECURE_TOKEN_MODULE_VERSION}.tar.gz -C /tmp/nginx-secure-token-module --strip-components=1
+rm ${SECURE_TOKEN_MODULE_VERSION}.tar.gz
+mkdir /tmp/nginx-rtmp-module
+wget -nv https://github.com/arut/nginx-rtmp-module/archive/refs/tags/v${RTMP_MODULE_VERSION}.tar.gz
+tar -zxf v${RTMP_MODULE_VERSION}.tar.gz -C /tmp/nginx-rtmp-module --strip-components=1
+rm v${RTMP_MODULE_VERSION}.tar.gz
+
+cd /tmp/nginx
+
+./configure --prefix=/usr/local/nginx \
+    --with-file-aio \
+    --with-http_sub_module \
+    --with-http_ssl_module \
+    --with-threads \
+    --add-module=../nginx-vod-module \
+    --add-module=../nginx-secure-token-module \
+    --add-module=../nginx-rtmp-module \
+    --with-cc-opt="-O3 -Wno-error=implicit-fallthrough"
+
+make -j$(nproc) && make install
+rm -rf /usr/local/nginx/html /usr/local/nginx/conf/*.default

docker/fake_frigate_run

@@ -2,7 +2,12 @@
 # shellcheck shell=bash
 # Start the fake Frigate service
 
+set -o errexit -o nounset -o pipefail
+
+# Tell S6-Overlay not to restart this service
+s6-svc -O .
+
 while true; do
-  echo "The fake Frigate service is running..."
+  echo "[INFO] The fake Frigate service is running..."
   sleep 5s
 done

docker/install_deps.sh

@@ -10,16 +10,16 @@ apt-get -qq install --no-install-recommends -y \
     wget \
     procps vainfo \
     unzip locales tzdata libxml2 xz-utils \
-    python3-pip
+    python3-pip \
+    curl \
+    jq
 
-# add raspberry pi repo
 mkdir -p -m 600 /root/.gnupg
-gpg --no-default-keyring --keyring /usr/share/keyrings/raspbian.gpg --keyserver keyserver.ubuntu.com --recv-keys 9165938D90FDDD2E
-echo "deb [signed-by=/usr/share/keyrings/raspbian.gpg] http://raspbian.raspberrypi.org/raspbian/ bullseye main contrib non-free rpi" | tee /etc/apt/sources.list.d/raspi.list
 
 # add coral repo
-wget --quiet -O /usr/share/keyrings/google-edgetpu.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
-echo "deb [signed-by=/usr/share/keyrings/google-edgetpu.gpg] https://packages.cloud.google.com/apt coral-edgetpu-stable main" | tee /etc/apt/sources.list.d/coral-edgetpu.list
+curl -fsSLo - https://packages.cloud.google.com/apt/doc/apt-key.gpg | \
+    gpg --dearmor -o /etc/apt/trusted.gpg.d/google-cloud-packages-archive-keyring.gpg
+echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | tee /etc/apt/sources.list.d/coral-edgetpu.list
 echo "libedgetpu1-max libedgetpu/accepted-eula select true" | debconf-set-selections
 
 # enable non-free repo
@@ -30,21 +30,29 @@ apt-get -qq update
 apt-get -qq install --no-install-recommends --no-install-suggests -y \
     libedgetpu1-max python3-tflite-runtime python3-pycoral
 
-# btbn-ffmpeg -> amd64 / arm64
-if [[ "${TARGETARCH}" == "amd64" || "${TARGETARCH}" == "arm64" ]]; then
-    if [[ "${TARGETARCH}" == "amd64" ]]; then
-        btbn_arch="64"
-    else
-        btbn_arch="arm64"
-    fi
+# btbn-ffmpeg -> amd64
+if [[ "${TARGETARCH}" == "amd64" ]]; then
     mkdir -p /usr/lib/btbn-ffmpeg
-    wget -qO btbn-ffmpeg.tar.xz "https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2022-07-31-12-37/ffmpeg-n5.1-2-g915ef932a3-linux${btbn_arch}-gpl-5.1.tar.xz"
+    wget -qO btbn-ffmpeg.tar.xz "https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2022-07-31-12-37/ffmpeg-n5.1-2-g915ef932a3-linux64-gpl-5.1.tar.xz"
     tar -xf btbn-ffmpeg.tar.xz -C /usr/lib/btbn-ffmpeg --strip-components 1
     rm -rf btbn-ffmpeg.tar.xz /usr/lib/btbn-ffmpeg/doc /usr/lib/btbn-ffmpeg/bin/ffplay
 fi
 
 # ffmpeg -> arm32
 if [[ "${TARGETARCH}" == "arm" ]]; then
+    # add raspberry pi repo
+    gpg --no-default-keyring --keyring /usr/share/keyrings/raspbian.gpg --keyserver keyserver.ubuntu.com --recv-keys 9165938D90FDDD2E
+    echo "deb [signed-by=/usr/share/keyrings/raspbian.gpg] http://raspbian.raspberrypi.org/raspbian/ bullseye main contrib non-free rpi" | tee /etc/apt/sources.list.d/raspi.list
+    apt-get -qq update
+    apt-get -qq install --no-install-recommends --no-install-suggests -y ffmpeg
+fi
+
+# ffmpeg -> arm64
+if [[ "${TARGETARCH}" == "arm64" ]]; then
+    # add raspberry pi repo
+    gpg --no-default-keyring --keyring /usr/share/keyrings/raspbian.gpg --keyserver keyserver.ubuntu.com --recv-keys 82B129927FA3303E
+    echo "deb [signed-by=/usr/share/keyrings/raspbian.gpg] https://archive.raspberrypi.org/debian/ bullseye main" | tee /etc/apt/sources.list.d/raspi.list
+    apt-get -qq update
     apt-get -qq install --no-install-recommends --no-install-suggests -y ffmpeg
 fi
 
@@ -57,6 +65,9 @@ if [[ "${TARGETARCH}" == "amd64" ]]; then
     apt-get -qq install --no-install-recommends --no-install-suggests -y \
         intel-opencl-icd \
         mesa-va-drivers libva-drm2 intel-media-va-driver-non-free i965-va-driver libmfx1 radeontop intel-gpu-tools
+    # something about this dependency requires it to be installed in a separate call rather than in the line above
+    apt-get -qq install --no-install-recommends --no-install-suggests -y \
+        i965-va-driver-shaders
     rm -f /etc/apt/sources.list.d/debian-testing.list
 fi
 

docker/install_s6_overlay.sh

@@ -2,7 +2,7 @@
 
 set -euxo pipefail
 
-s6_version="3.1.2.1"
+s6_version="3.1.4.1"
 
 if [[ "${TARGETARCH}" == "amd64" ]]; then
     s6_arch="x86_64"

docker/rootfs/etc/ld.so.conf.d/cuda_tensorrt.conf

@@ -0,0 +1,5 @@
+/usr/local/lib/python3.9/dist-packages/nvidia/cudnn/lib
+/usr/local/lib/python3.9/dist-packages/nvidia/cuda_runtime/lib
+/usr/local/lib/python3.9/dist-packages/nvidia/cublas/lib
+/usr/local/lib/python3.9/dist-packages/nvidia/cuda_nvrtc/lib
+/usr/local/lib/python3.9/dist-packages/tensorrt

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate-log/consumer-for

@@ -0,0 +1 @@
+frigate

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate-log/pipeline-name

@@ -0,0 +1 @@
+frigate-pipeline

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate-log/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate/finish

@@ -0,0 +1,28 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+# Take down the S6 supervision tree when the service exits
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+declare exit_code_container
+exit_code_container=$(cat /run/s6-linux-init-container-results/exitcode)
+readonly exit_code_container
+readonly exit_code_service="${1}"
+readonly exit_code_signal="${2}"
+readonly service="Frigate"
+
+echo "[INFO] Service ${service} exited with code ${exit_code_service} (by signal ${exit_code_signal})"
+
+if [[ "${exit_code_service}" -eq 256 ]]; then
+  if [[ "${exit_code_container}" -eq 0 ]]; then
+    echo $((128 + exit_code_signal)) >/run/s6-linux-init-container-results/exitcode
+  fi
+elif [[ "${exit_code_service}" -ne 0 ]]; then
+  if [[ "${exit_code_container}" -eq 0 ]]; then
+    echo "${exit_code_service}" >/run/s6-linux-init-container-results/exitcode
+  fi
+fi
+
+exec /run/s6/basedir/bin/halt

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate/producer-for

@@ -0,0 +1 @@
+frigate-log

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate/run

@@ -4,7 +4,14 @@
 
 set -o errexit -o nounset -o pipefail
 
-cd /opt/frigate
+# Logs should be sent to stdout so that s6 can collect them
+
+# Tell S6-Overlay not to restart this service
+s6-svc -O .
+
+echo "[INFO] Starting Frigate..."
+
+cd /opt/frigate || echo "[ERROR] Failed to change working directory to /opt/frigate"
 
 # Replace the bash process with the Frigate process, redirecting stderr to stdout
 exec 2>&1

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate/timeout-kill

@@ -0,0 +1 @@
+120000

docker/rootfs/etc/s6-overlay/s6-rc.d/frigate/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-healthcheck/finish

@@ -0,0 +1,12 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+readonly exit_code_service="${1}"
+readonly exit_code_signal="${2}"
+readonly service="go2rtc-healthcheck"
+
+echo "[INFO] The ${service} service exited with code ${exit_code_service} (by signal ${exit_code_signal})"

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-healthcheck/producer-for

@@ -0,0 +1 @@
+go2rtc-log

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-healthcheck/run

@@ -0,0 +1,22 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+# Start the go2rtc-healthcheck service
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+# Give some additional time for go2rtc to start before start pinging
+sleep 10s
+echo "[INFO] Starting go2rtc healthcheck service..."
+
+while sleep 30s; do
+    # Check if the service is running
+    if ! curl --connect-timeout 10 --fail --silent --show-error --output /dev/null http://127.0.0.1:1984/api/streams 2>&1; then
+        echo "[ERROR] The go2rtc service is not responding to ping, restarting..."
+        # We can also use -r instead of -t to send kill signal rather than term
+        s6-svc -t /var/run/service/go2rtc 2>&1
+        # Give some additional time to go2rtc to restart before start pinging again
+        sleep 10s
+    fi
+done

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-healthcheck/timeout-kill

@@ -0,0 +1 @@
+5000

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-healthcheck/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-log/consumer-for

@@ -0,0 +1,2 @@
+go2rtc
+go2rtc-healthcheck

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-log/pipeline-name

@@ -0,0 +1 @@
+go2rtc-pipeline

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc-log/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc/finish

@@ -0,0 +1,12 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+readonly exit_code_service="${1}"
+readonly exit_code_signal="${2}"
+readonly service="go2rtc"
+
+echo "[INFO] The ${service} service exited with code ${exit_code_service} (by signal ${exit_code_signal})"

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc/producer-for

@@ -0,0 +1 @@
+go2rtc-log

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc/run

@@ -0,0 +1,70 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+# Start the go2rtc service
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+function get_ip_and_port_from_supervisor() {
+    local ip_address
+    # Example: 192.168.1.10/24
+    local ip_regex='^([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})/[0-9]{1,2}$'
+    if ip_address=$(
+        curl -fsSL \
+            -H "Authorization: Bearer ${SUPERVISOR_TOKEN}" \
+            -H "Content-Type: application/json" \
+            http://supervisor/network/interface/default/info |
+            jq --exit-status --raw-output '.data.ipv4.address[0]'
+    ) && [[ "${ip_address}" =~ ${ip_regex} ]]; then
+        ip_address="${BASH_REMATCH[1]}"
+        echo "[INFO] Got IP address from supervisor: ${ip_address}"
+    else
+        echo "[WARN] Failed to get IP address from supervisor"
+        return 0
+    fi
+
+    local webrtc_port
+    local port_regex='^([0-9]{1,5})$'
+    if webrtc_port=$(
+        curl -fsSL \
+            -H "Authorization: Bearer ${SUPERVISOR_TOKEN}" \
+            -H "Content-Type: application/json" \
+            http://supervisor/addons/self/info |
+            jq --exit-status --raw-output '.data.network["8555/tcp"]'
+    ) && [[ "${webrtc_port}" =~ ${port_regex} ]]; then
+        webrtc_port="${BASH_REMATCH[1]}"
+        echo "[INFO] Got WebRTC port from supervisor: ${webrtc_port}"
+    else
+        echo "[WARN] Failed to get WebRTC port from supervisor"
+        return 0
+    fi
+
+    export FRIGATE_GO2RTC_WEBRTC_CANDIDATE_INTERNAL="${ip_address}:${webrtc_port}"
+}
+
+if [[ ! -f "/dev/shm/go2rtc.yaml" ]]; then
+    echo "[INFO] Preparing go2rtc config..."
+
+    if [[ -n "${SUPERVISOR_TOKEN:-}" ]]; then
+        # Running as a Home Assistant add-on, infer the IP address and port
+        get_ip_and_port_from_supervisor
+    fi
+
+    python3 /usr/local/go2rtc/create_config.py
+fi
+
+readonly config_path="/config"
+
+if [[ -x "${config_path}/go2rtc" ]]; then
+  readonly binary_path="${config_path}/go2rtc"
+  echo "[WARN] Using go2rtc binary from '${binary_path}' instead of the embedded one"
+else
+  readonly binary_path="/usr/local/go2rtc/bin/go2rtc"
+fi
+
+echo "[INFO] Starting go2rtc..."
+
+# Replace the bash process with the go2rtc process, redirecting stderr to stdout
+exec 2>&1
+exec "${binary_path}" -config=/dev/shm/go2rtc.yaml

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc/timeout-kill

@@ -0,0 +1 @@
+30000

docker/rootfs/etc/s6-overlay/s6-rc.d/go2rtc/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/log-prepare/type

@@ -0,0 +1 @@
+oneshot

docker/rootfs/etc/s6-overlay/s6-rc.d/log-prepare/up

@@ -0,0 +1 @@
+/etc/s6-overlay/s6-rc.d/log-prepare/run

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx-log/consumer-for

@@ -0,0 +1 @@
+nginx

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx-log/pipeline-name

@@ -0,0 +1 @@
+nginx-pipeline

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx-log/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx/finish

@@ -0,0 +1,30 @@
+#!/command/with-contenv bash
+# shellcheck shell=bash
+# Take down the S6 supervision tree when the service fails
+
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+declare exit_code_container
+exit_code_container=$(cat /run/s6-linux-init-container-results/exitcode)
+readonly exit_code_container
+readonly exit_code_service="${1}"
+readonly exit_code_signal="${2}"
+readonly service="NGINX"
+
+echo "[INFO] Service ${service} exited with code ${exit_code_service} (by signal ${exit_code_signal})"
+
+if [[ "${exit_code_service}" -eq 256 ]]; then
+  if [[ "${exit_code_container}" -eq 0 ]]; then
+    echo $((128 + exit_code_signal)) >/run/s6-linux-init-container-results/exitcode
+  fi
+  if [[ "${exit_code_signal}" -eq 15 ]]; then
+    exec /run/s6/basedir/bin/halt
+  fi
+elif [[ "${exit_code_service}" -ne 0 ]]; then
+  if [[ "${exit_code_container}" -eq 0 ]]; then
+    echo "${exit_code_service}" >/run/s6-linux-init-container-results/exitcode
+  fi
+  exec /run/s6/basedir/bin/halt
+fi

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx/producer-for

@@ -0,0 +1 @@
+nginx-log

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx/run

@@ -2,6 +2,12 @@
 # shellcheck shell=bash
 # Start the NGINX service
 
+set -o errexit -o nounset -o pipefail
+
+# Logs should be sent to stdout so that s6 can collect them
+
+echo "[INFO] Starting NGINX..."
+
 # Replace the bash process with the NGINX process, redirecting stderr to stdout
 exec 2>&1
 exec nginx

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx/timeout-kill

@@ -0,0 +1 @@
+30000

docker/rootfs/etc/s6-overlay/s6-rc.d/nginx/type

@@ -0,0 +1 @@
+longrun

docker/rootfs/etc/services.d/frigate/finish

@@ -1,16 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-# Take down the S6 supervision tree when the service exits
-
-set -o errexit -o nounset -o pipefail
-
-# Prepare exit code
-if [[ "${1}" -eq 256 ]]; then
-  exit_code="$((128 + ${2}))"
-else
-  exit_code="${1}"
-fi
-
-# Make the container exit with the same exit code as the service
-echo "${exit_code}" > /run/s6-linux-init-container-results/exitcode
-exec /run/s6/basedir/bin/halt

docker/rootfs/etc/services.d/go2rtc/finish

@@ -1,8 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-# Take down the S6 supervision tree when the service fails, or restart it
-# otherwise
-
-if [[ "${1}" -ne 0 && "${1}" -ne 256 ]]; then
-  exec /run/s6/basedir/bin/halt
-fi

docker/rootfs/etc/services.d/go2rtc/run

@@ -1,15 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-# Start the go2rtc service
-
-set -o errexit -o nounset -o pipefail
-
-if [[ -f "/config/frigate-go2rtc.yaml" ]]; then
-    config_path="/config/frigate-go2rtc.yaml"
-else
-    config_path="/usr/local/go2rtc/go2rtc.yaml"
-fi
-
-# Replace the bash process with the go2rtc process, redirecting stderr to stdout
-exec 2>&1
-exec go2rtc -config="${config_path}"

docker/rootfs/etc/services.d/nginx/finish

@@ -1,8 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-# Take down the S6 supervision tree when the service fails, or restart it
-# otherwise
-
-if [[ "${1}" -ne 0 && "${1}" -ne 256 ]]; then
-  exec /run/s6/basedir/bin/halt
-fi

docker/rootfs/usr/local/bin/frigate

@@ -1,5 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-
-exec 2>&1
-exec python3 -u -m frigate "${@}"

docker/rootfs/usr/local/go2rtc/create_config.py

@@ -0,0 +1,106 @@
+"""Creates a go2rtc config file."""
+
+import json
+import os
+import sys
+import yaml
+
+sys.path.insert(0, "/opt/frigate")
+from frigate.const import BIRDSEYE_PIPE, BTBN_PATH
+from frigate.ffmpeg_presets import parse_preset_hardware_acceleration_encode
+
+sys.path.remove("/opt/frigate")
+
+
+FRIGATE_ENV_VARS = {k: v for k, v in os.environ.items() if k.startswith("FRIGATE_")}
+config_file = os.environ.get("CONFIG_FILE", "/config/config.yml")
+
+# Check if we can use .yaml instead of .yml
+config_file_yaml = config_file.replace(".yml", ".yaml")
+if os.path.isfile(config_file_yaml):
+    config_file = config_file_yaml
+
+with open(config_file) as f:
+    raw_config = f.read()
+
+if config_file.endswith((".yaml", ".yml")):
+    config: dict[str, any] = yaml.safe_load(raw_config)
+elif config_file.endswith(".json"):
+    config: dict[str, any] = json.loads(raw_config)
+
+go2rtc_config: dict[str, any] = config.get("go2rtc", {})
+
+# Need to enable CORS for go2rtc so the frigate integration / card work automatically
+if go2rtc_config.get("api") is None:
+    go2rtc_config["api"] = {"origin": "*"}
+elif go2rtc_config["api"].get("origin") is None:
+    go2rtc_config["api"]["origin"] = "*"
+
+# we want to ensure that logs are easy to read
+if go2rtc_config.get("log") is None:
+    go2rtc_config["log"] = {"format": "text"}
+elif go2rtc_config["log"].get("format") is None:
+    go2rtc_config["log"]["format"] = "text"
+
+if not go2rtc_config.get("webrtc", {}).get("candidates", []):
+    default_candidates = []
+    # use internal candidate if it was discovered when running through the add-on
+    internal_candidate = os.environ.get(
+        "FRIGATE_GO2RTC_WEBRTC_CANDIDATE_INTERNAL", None
+    )
+    if internal_candidate is not None:
+        default_candidates.append(internal_candidate)
+    # should set default stun server so webrtc can work
+    default_candidates.append("stun:8555")
+
+    go2rtc_config["webrtc"] = {"candidates": default_candidates}
+else:
+    print(
+        "[INFO] Not injecting WebRTC candidates into go2rtc config as it has been set manually",
+    )
+
+# sets default RTSP response to be equivalent to ?video=h264,h265&audio=aac
+# this means user does not need to specify audio codec when using restream
+# as source for frigate and the integration supports HLS playback
+if go2rtc_config.get("rtsp") is None:
+    go2rtc_config["rtsp"] = {"default_query": "mp4"}
+elif go2rtc_config["rtsp"].get("default_query") is None:
+    go2rtc_config["rtsp"]["default_query"] = "mp4"
+
+# need to replace ffmpeg command when using ffmpeg4
+if not os.path.exists(BTBN_PATH):
+    if go2rtc_config.get("ffmpeg") is None:
+        go2rtc_config["ffmpeg"] = {
+            "rtsp": "-fflags nobuffer -flags low_delay -stimeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}"
+        }
+    elif go2rtc_config["ffmpeg"].get("rtsp") is None:
+        go2rtc_config["ffmpeg"][
+            "rtsp"
+        ] = "-fflags nobuffer -flags low_delay -stimeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}"
+
+for name in go2rtc_config.get("streams", {}):
+    stream = go2rtc_config["streams"][name]
+
+    if isinstance(stream, str):
+        go2rtc_config["streams"][name] = go2rtc_config["streams"][name].format(
+            **FRIGATE_ENV_VARS
+        )
+    elif isinstance(stream, list):
+        for i, stream in enumerate(stream):
+            go2rtc_config["streams"][name][i] = stream.format(**FRIGATE_ENV_VARS)
+
+# add birdseye restream stream if enabled
+if config.get("birdseye", {}).get("restream", False):
+    birdseye: dict[str, any] = config.get("birdseye")
+
+    input = f"-f rawvideo -pix_fmt yuv420p -video_size {birdseye.get('width', 1280)}x{birdseye.get('height', 720)} -r 10 -i {BIRDSEYE_PIPE}"
+    ffmpeg_cmd = f"exec:{parse_preset_hardware_acceleration_encode(config.get('ffmpeg', {}).get('hwaccel_args'), input, '-rtsp_transport tcp -f rtsp {output}')}"
+
+    if go2rtc_config.get("streams"):
+        go2rtc_config["streams"]["birdseye"] = ffmpeg_cmd
+    else:
+        go2rtc_config["streams"] = {"birdseye": ffmpeg_cmd}
+
+# Write go2rtc_config to /dev/shm/go2rtc.yaml
+with open("/dev/shm/go2rtc.yaml", "w") as f:
+    yaml.dump(go2rtc_config, f)

docker/rootfs/usr/local/go2rtc/go2rtc.yaml

@@ -1,4 +0,0 @@
-webrtc:
-  listen: ":8555"
-  candidates:
-    - stun:8555

docker/tensorrt_models.sh

@@ -32,6 +32,3 @@ do
     python3 onnx_to_tensorrt.py -m ${model}
     cp /tensorrt_demos/yolo/${model}.trt ${OUTPUT_FOLDER}/${model}.trt;
 done
-
-# Download Labelmap
-wget -q https://github.com/openvinotoolkit/open_model_zoo/raw/master/data/dataset_classes/coco_91cl.txt -O ${OUTPUT_FOLDER}/coco_91cl.txt

docs/docs/configuration/advanced.md

@@ -105,6 +105,17 @@ To do this:
 
 1. Download your ffmpeg build and uncompress to a folder on the host (let's use `/home/appdata/frigate/custom-ffmpeg` for this example).
 2. Update your docker-compose or docker CLI to include `'/home/appdata/frigate/custom-ffmpeg':'/usr/lib/btbn-ffmpeg':'ro'` in the volume mappings.
-3. Restart frigate and the custom version will be used if the mapping was done correctly.
+3. Restart Frigate and the custom version will be used if the mapping was done correctly.
 
 NOTE: The folder that is mapped from the host needs to be the folder that contains `/bin`. So if the full structure is `/home/appdata/frigate/custom-ffmpeg/bin/ffmpeg` then `/home/appdata/frigate/custom-ffmpeg` needs to be mapped to `/usr/lib/btbn-ffmpeg`.
+
+## Custom go2rtc version
+
+Frigate currently includes go2rtc v1.2.0, there may be certain cases where you want to run a different version of go2rtc.
+
+To do this:
+
+1. Download the go2rtc build to the /config folder.
+2. Rename the build to `go2rtc`.
+3. Give `go2rtc` execute permission.
+4. Restart Frigate and the custom version will be used, you can verify by checking go2rtc logs.

docs/docs/configuration/camera_specific.md

@@ -11,18 +11,22 @@ This page makes use of presets of FFmpeg args. For more information on presets,
 
 ## MJPEG Cameras
 
-The input and output parameters need to be adjusted for MJPEG cameras
+Note that mjpeg cameras require encoding the video into h264 for recording, and restream roles. This will use significantly more CPU than if the cameras supported h264 feeds directly. It is recommended to use the restream role to create an h264 restream and then use that as the source for ffmpeg.
 
 ```yaml
-input_args: preset-http-mjpeg-generic
-```
+go2rtc:
+  streams:
+    mjpeg_cam: "ffmpeg:{your_mjpeg_stream_url}#video=h264#hardware" # <- use hardware acceleration to create an h264 stream usable for other components.
 
-Note that mjpeg cameras require encoding the video into h264 for recording, and rtmp roles. This will use significantly more CPU than if the cameras supported h264 feeds directly.
-
-```yaml
-output_args:
-  record: preset-record-mjpeg
-  rtmp: preset-rtmp-mjpeg
+cameras:
+  ...
+  mjpeg_cam:
+    ffmpeg:
+      inputs:
+        - path: rtsp://127.0.0.1:8554/mjpeg_cam
+          roles:
+            - detect
+            - record
 ```
 
 ## JPEG Stream Cameras
@@ -102,31 +106,48 @@ If available, recommended settings are:
 According to [this discussion](https://github.com/blakeblackshear/frigate/issues/3235#issuecomment-1135876973), the http video streams seem to be the most reliable for Reolink.
 
 ```yaml
+go2rtc:
+  streams:
+    reolink: 
+      - http://reolink_ip/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password
+      - "ffmpeg:reolink#audio=opus"
+    reolink_sub: 
+      - http://reolink_ip/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=username&password=password
+
 cameras:
   reolink:
     ffmpeg:
-      input_args: preset-http-reolink
       inputs:
-        - path: http://reolink_ip/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password
+        - path: rtsp://127.0.0.1:8554/reolink?video=copy&audio=aac
+          input_args: preset-rtsp-restream
           roles:
             - record
-            - rtmp
-        - path: http://reolink_ip/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=username&password=password
+        - path: rtsp://127.0.0.1:8554/reolink_sub?video=copy
+          input_args: preset-rtsp-restream
           roles:
             - detect
-    detect:
-      width: 896
-      height: 672
-      fps: 7
 ```
 
 ### Unifi Protect Cameras
 
-In the Unifi 2.0 update Unifi Protect Cameras had a change in audio sample rate which causes issues for ffmpeg. The input rate needs to be set for record and rtmp.
+Unifi protect cameras require the rtspx stream to be used with go2rtc.
+To utilize a Unifi protect camera, modify the rtsps link to begin with rtspx.
+Additionally, remove the "?enableSrtp" from the end of the Unifi link.
+
+```yaml
+go2rtc:
+  streams:
+    front:
+      - rtspx://192.168.1.1:7441/abcdefghijk
+```
+
+[See the go2rtc docs for more information](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#source-rtsp)
+
+In the Unifi 2.0 update Unifi Protect Cameras had a change in audio sample rate which causes issues for ffmpeg. The input rate needs to be set for record and rtmp if used directly with unifi protect.
 
 ```yaml
 ffmpeg:
   output_args:
     record: preset-record-ubiquiti
-    rtmp: preset-rtmp-ubiquiti
+    rtmp: preset-rtmp-ubiquiti # recommend using go2rtc instead
 ```

docs/docs/configuration/cameras.md

@@ -15,7 +15,6 @@ Each role can only be assigned to one input per camera. The options for roles ar
 | ---------- | ---------------------------------------------------------------------------------------- |
 | `detect`   | Main feed for object detection                                                           |
 | `record`   | Saves segments of the video feed based on configuration settings. [docs](record.md)      |
-| `restream` | Broadcast as RTSP feed and use the full res stream for live view. [docs](restream.md)    |
 | `rtmp`     | Deprecated: Broadcast as an RTMP feed for other services to consume. [docs](restream.md) |
 
 ```yaml
@@ -29,7 +28,7 @@ cameras:
         - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
           roles:
             - detect
-            - rtmp
+            - rtmp # <- deprecated, recommend using restream instead
         - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:554/live
           roles:
             - record

docs/docs/configuration/detectors.md

@@ -101,7 +101,7 @@ The OpenVINO device to be used is specified using the `"device"` attribute accor
 
 OpenVINO is supported on 6th Gen Intel platforms (Skylake) and newer. A supported Intel platform is required to use the `GPU` device with OpenVINO. The `MYRIAD` device may be run on any platform, including Arm devices. For detailed system requirements, see [OpenVINO System Requirements](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/system-requirements.html)
 
-An OpenVINO model is provided in the container at `/openvino-model/ssdlite_mobilenet_v2.xml` and is used by this detector type by default. The model comes from Intel's Open Model Zoo [SSDLite MobileNet V2](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/ssdlite_mobilenet_v2) and is converted to an FP16 precision IR model. Use the model configuration shown below when using the OpenVINO detector.
+An OpenVINO model is provided in the container at `/openvino-model/ssdlite_mobilenet_v2.xml` and is used by this detector type by default. The model comes from Intel's Open Model Zoo [SSDLite MobileNet V2](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/ssdlite_mobilenet_v2) and is converted to an FP16 precision IR model. Use the model configuration shown below when using the OpenVINO detector with the default model.
 
 ```yaml
 detectors:
@@ -119,6 +119,25 @@ model:
   labelmap_path: /openvino-model/coco_91cl_bkgr.txt
 ```
 
+This detector also supports some YOLO variants: YOLOX, YOLOv5, and YOLOv8 specifically. Other YOLO variants are not officially supported/tested. Frigate does not come with any yolo models preloaded, so you will need to supply your own models. This detector has been verified to work with the [yolox_tiny](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/yolox-tiny) model from Intel's Open Model Zoo. You can follow [these instructions](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/yolox-tiny#download-a-model-and-convert-it-into-openvino-ir-format) to retrieve the OpenVINO-compatible `yolox_tiny` model. Make sure that the model input dimensions match the `width` and `height` parameters, and `model_type` is set accordingly. See [Full Configuration Reference](/configuration/index.md#full-configuration-reference) for a list of possible `model_type` options. Below is an example of how `yolox_tiny` can be used in Frigate:
+
+```yaml
+detectors:
+  ov:
+    type: openvino
+    device: AUTO
+    model:
+      path: /path/to/yolox_tiny.xml
+
+model:
+  width: 416
+  height: 416
+  input_tensor: nchw
+  input_pixel_format: bgr
+  model_type: yolox
+  labelmap_path: /path/to/coco_80cl.txt
+```
+
 ### Intel NCS2 VPU and Myriad X Setup
 
 Intel produces a neural net inference accelleration chip called Myriad X. This chip was sold in their Neural Compute Stick 2 (NCS2) which has been discontinued. If intending to use the MYRIAD device for accelleration, additional setup is required to pass through the USB device. The host needs a udev rule installed to handle the NCS2 device.
@@ -159,6 +178,8 @@ The TensorRT detector uses the 11.x series of CUDA libraries which have minor ve
 
 > **TODO:** NVidia claims support on compute 3.5 and 3.7, but marks it as deprecated. This would have some, but not all, Kepler GPUs as possibly working. This needs testing before making any claims of support.
 
+To use the TensorRT detector, make sure your host system has the [nvidia-container-runtime](https://docs.docker.com/config/containers/resource_constraints/#access-an-nvidia-gpu) installed to pass through the GPU to the container and the host system has a compatible driver installed for your GPU.
+
 There are improved capabilities in newer GPU architectures that TensorRT can benefit from, such as INT8 operations and Tensor cores. The features compatible with your hardware will be optimized when the model is converted to a trt file. Currently the script provided for generating the model provides a switch to enable/disable FP16 operations. If you wish to use newer features such as INT8 optimization, more work is required.
 
 #### Compatibility References:
@@ -171,18 +192,18 @@ There are improved capabilities in newer GPU architectures that TensorRT can ben
 
 ### Generate Models
 
-The models used for TensorRT must be preprocessed on the same hardware platform that they will run on. This means that each user must run additional setup to generate these model files for the TensorRT library. A script is provided that will build several common models.
+The model used for TensorRT must be preprocessed on the same hardware platform that they will run on. This means that each user must run additional setup to generate a model file for the TensorRT library. A script is provided that will build several common models.
 
-To generate the model files, create a new folder to save the models, download the script, and launch a docker container that will run the script.
+To generate model files, create a new folder to save the models, download the script, and launch a docker container that will run the script.
 
 ```bash
 mkdir trt-models
-wget https://raw.githubusercontent.com/blakeblackshear/frigate/nvidia-detector/docker/tensorrt_models.sh
+wget https://github.com/blakeblackshear/frigate/raw/master/docker/tensorrt_models.sh
 chmod +x tensorrt_models.sh
 docker run --gpus=all --rm -it -v `pwd`/trt-models:/tensorrt_models -v `pwd`/tensorrt_models.sh:/tensorrt_models.sh nvcr.io/nvidia/tensorrt:22.07-py3 /tensorrt_models.sh
 ```
 
-The `trt-models` folder can then be mapped into your frigate container as `trt-models` and the models referenced from the config.
+The `trt-models` folder can then be mapped into your Frigate container as `trt-models` and the models referenced from the config.
 
 If your GPU does not support FP16 operations, you can pass the environment variable `-e USE_FP16=False` to the `docker run` command to disable it.
 
@@ -210,6 +231,10 @@ yolov4x-mish-320
 yolov4x-mish-640
 yolov7-tiny-288
 yolov7-tiny-416
+yolov7-640
+yolov7-320
+yolov7x-640
+yolov7x-320
 ```
 
 ### Configuration Parameters
@@ -226,7 +251,6 @@ detectors:
 
 model:
   path: /trt-models/yolov7-tiny-416.trt
-  labelmap_path: /trt-models/coco_91cl.txt
   input_tensor: nchw
   input_pixel_format: rgb
   width: 416

docs/docs/configuration/ffmpeg_presets.md

@@ -5,6 +5,75 @@ title: FFmpeg presets
 
 Some presets of FFmpeg args are provided by default to make the configuration easier. All presets can be seen in [this file](https://github.com/blakeblackshear/frigate/blob/master/frigate/ffmpeg_presets.py).
 
-<!--
-TODO: Use [markdown-magic](https://github.com/DavidWells/markdown-magic) to generate this list from the source code.
--->
+### Hwaccel Presets
+
+It is highly recommended to use hwaccel presets in the config. These presets not only replace the longer args, but they also give Frigate hints of what hardware is available and allows Frigate to make other optimizations using the GPU such as when encoding the birdseye restream or when scaling a stream that has a size different than the native stream size.
+
+See [the hwaccel docs](/configuration/hardware_acceleration.md) for more info on how to setup hwaccel for your GPU / iGPU.
+
+| Preset                | Usage                        | Other Notes                                           |
+| --------------------- | ---------------------------- | ----------------------------------------------------- |
+| preset-rpi-32-h264    | 32 bit Rpi with h264 stream  |                                                       |
+| preset-rpi-64-h264    | 64 bit Rpi with h264 stream  |                                                       |
+| preset-vaapi          | Intel & AMD VAAPI            | Check hwaccel docs to ensure correct driver is chosen |
+| preset-intel-qsv-h264 | Intel QSV with h264 stream   | If issues occur recommend using vaapi preset instead  |
+| preset-intel-qsv-h265 | Intel QSV with h265 stream   | If issues occur recommend using vaapi preset instead  |
+| preset-nvidia-h264    | Nvidia GPU with h264 stream  |                                                       |
+| preset-nvidia-h265    | Nvidia GPU with h265 stream  |                                                       |
+| preset-nvidia-mjpeg   | Nvidia GPU with mjpeg stream | Recommend restreaming mjpeg and using nvidia-h264     |
+
+### Input Args Presets
+
+Input args presets help make the config more readable and handle use cases for different types of streams to ensure maximum compatibility.
+
+See [the camera specific docs](/configuration/camera_specific.md) for more info on non-standard cameras and recommendations for using them in Frigate.
+
+| Preset                           | Usage                     | Other Notes                                                                                      |
+| -------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------ |
+| preset-http-jpeg-generic         | HTTP Live Jpeg            | Recommend restreaming live jpeg instead                                                          |
+| preset-http-mjpeg-generic        | HTTP Mjpeg Stream         | Recommend restreaming mjpeg stream instead                                                       |
+| preset-http-reolink              | Reolink HTTP-FLV Stream   | Only for reolink http, not when restreaming as rtsp                                              |
+| preset-rtmp-generic              | RTMP Stream               |                                                                                                  |
+| preset-rtsp-generic              | RTSP Stream               | This is the default when nothing is specified                                                    |
+| preset-rtsp-restream             | RTSP Stream from restream | Use for rtsp restream as source for frigate                                                      |
+| preset-rtsp-restream-low-latency | RTSP Stream from restream | Use for rtsp restream as source for frigate to lower latency, may cause issues with some cameras |
+| preset-rtsp-udp                  | RTSP Stream via UDP       | Use when camera is UDP only                                                                      |
+| preset-rtsp-blue-iris            | Blue Iris RTSP Stream     | Use when consuming a stream from Blue Iris                                                       |
+
+:::caution
+
+It is important to be mindful of input args when using restream because you can have a mix of protocols. `http` and `rtmp` presets cannot be used with `rtsp` streams. For example, when using a reolink cam with the rtsp restream as a source for record the preset-http-reolink will cause a crash. In this case presets will need to be set at the stream level. See the example below.
+
+:::
+
+```yaml
+go2rtc:
+  streams:
+    reolink_cam: http://192.168.0.139/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=password
+
+cameras:
+  reolink_cam:
+    ffmpeg:
+      inputs:
+        - path: http://192.168.0.139/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=password
+          input_args: preset-http-reolink
+          roles:
+            - detect
+        - path: rtsp://127.0.0.1:8554/reolink_cam
+          input_args: preset-rtsp-generic
+          roles:
+            - record
+```
+
+### Output Args Presets
+
+Output args presets help make the config more readable and handle use cases for different types of streams to ensure consistent recordings.
+
+| Preset                           | Usage                             | Other Notes                                   |
+| -------------------------------- | --------------------------------- | --------------------------------------------- |
+| preset-record-generic            | Record WITHOUT audio              | This is the default when nothing is specified |
+| preset-record-generic-audio-aac  | Record WITH aac audio             | Use this to enable audio in recordings        |
+| preset-record-generic-audio-copy | Record WITH original audio        | Use this to enable audio in recordings        |
+| preset-record-mjpeg              | Record an mjpeg stream            | Recommend restreaming mjpeg stream instead    |
+| preset-record-jpeg               | Record live jpeg                  | Recommend restreaming live jpeg instead       |
+| preset-record-ubiquiti           | Record ubiquiti stream with audio | Recordings with ubiquiti non-standard audio   |

docs/docs/configuration/hardware_acceleration.md

@@ -7,12 +7,6 @@ It is recommended to update your configuration to enable hardware accelerated de
 
 ### Raspberry Pi 3/4
 
-:::caution
-
-There is currently a bug in ffmpeg that causes hwaccel to not work for the RPi kernel 5.15.61 and above. For more information see https://github.com/blakeblackshear/frigate/issues/3780
-
-:::
-
 Ensure you increase the allocated RAM for your GPU to at least 128 (raspi-config > Performance Options > GPU Memory).
 **NOTICE**: If you are using the addon, you may need to turn off `Protection mode` for hardware acceleration.
 
@@ -21,43 +15,146 @@ ffmpeg:
   hwaccel_args: preset-rpi-64-h264
 ```
 
-### Intel-based CPUs (<10th Generation) via Quicksync
+:::note
+
+If running Frigate in docker, you either need to run in priviliged mode or be sure to map the /dev/video1x devices to Frigate
+
+```yaml
+docker run -d \
+  --name frigate \
+  ...
+  --device /dev/video10 \
+  ghcr.io/blakeblackshear/frigate:stable
+```
+
+:::
+
+### Intel-based CPUs
+
+#### Via VAAPI
+
+VAAPI supports automatic profile selection so it will work automatically with both H.264 and H.265 streams. VAAPI is recommended for all generations of Intel-based CPUs if QSV does not work.
 
 ```yaml
 ffmpeg:
-  hwaccel_args: preset-intel-vaapi
+  hwaccel_args: preset-vaapi
 ```
+
 **NOTICE**: With some of the processors, like the J4125, the default driver `iHD` doesn't seem to work correctly for hardware acceleration. You may need to change the driver to `i965` by adding the following environment variable `LIBVA_DRIVER_NAME=i965` to your docker-compose file or [in the frigate.yml for HA OS users](advanced.md#environment_vars).
 
-### Intel-based CPUs (>=10th Generation) via Quicksync
+#### Via Quicksync (>=10th Generation only)
+
+QSV must be set specifically based on the video encoding of the stream.
+
+##### H.264 streams
 
 ```yaml
 ffmpeg:
   hwaccel_args: preset-intel-qsv-h264
 ```
 
+##### H.265 streams
+
+```yaml
+ffmpeg:
+  hwaccel_args: preset-intel-qsv-h265
+```
+
+#### Configuring Intel GPU Stats in Docker
+
+Additional configuration is needed for the Docker container to be able to access the `intel_gpu_top` command for GPU stats. Three possible changes can be made:
+
+1. Run the container as privileged.
+2. Adding the `CAP_PERFMON` capability.
+3. Setting the `perf_event_paranoid` low enough to allow access to the performance event system.
+
+##### Run as privileged
+
+This method works, but it gives more permissions to the container than are actually needed.
+
+###### Docker Compose - Privileged
+
+```yaml
+services:
+  frigate:
+    ...
+    image: ghcr.io/blakeblackshear/frigate:stable
+    privileged: true
+```
+
+###### Docker Run CLI - Privileged
+
+```bash
+docker run -d \
+  --name frigate \
+  ...
+  --privileged \
+  ghcr.io/blakeblackshear/frigate:stable
+```
+
+##### CAP_PERFMON
+
+Only recent versions of Docker support the `CAP_PERFMON` capability. You can test to see if yours supports it by running: `docker run --cap-add=CAP_PERFMON hello-world`
+
+###### Docker Compose - CAP_PERFMON
+
+```yaml
+services:
+  frigate:
+    ...
+    image: ghcr.io/blakeblackshear/frigate:stable
+    cap_add:
+      - CAP_PERFMON
+```
+
+###### Docker Run CLI - CAP_PERFMON
+
+```bash
+docker run -d \
+  --name frigate \
+  ...
+  --cap-add=CAP_PERFMON \
+  ghcr.io/blakeblackshear/frigate:stable
+```
+
+##### perf_event_paranoid
+
+_Note: This setting must be changed for the entire system._
+
+For more information on the various values across different distributions, see https://askubuntu.com/questions/1400874/what-does-perf-paranoia-level-four-do.
+
+Depending on your OS and kernel configuration, you may need to change the `/proc/sys/kernel/perf_event_paranoid` kernel tunable. You can test the change by running `sudo sh -c 'echo 2 >/proc/sys/kernel/perf_event_paranoid'` which will persist until a reboot. Make it permanent by running `sudo sh -c 'echo kernel.perf_event_paranoid=1 >> /etc/sysctl.d/local.conf'`
+
 ### AMD/ATI GPUs (Radeon HD 2000 and newer GPUs) via libva-mesa-driver
 
+VAAPI supports automatic profile selection so it will work automatically with both H.264 and H.265 streams.
+
 **Note:** You also need to set `LIBVA_DRIVER_NAME=radeonsi` as an environment variable on the container.
 
 ```yaml
 ffmpeg:
-  hwaccel_args: preset-amd-vaapi
+  hwaccel_args: preset-vaapi
 ```
 
-### NVIDIA GPU
+### NVIDIA GPUs
 
-[Supported Nvidia GPUs for Decoding](https://developer.nvidia.com/video-encode-and-decode-gpu-support-matrix-new)
+While older GPUs may work, it is recommended to use modern, supported GPUs. NVIDIA provides a [matrix of supported GPUs and features](https://developer.nvidia.com/video-encode-and-decode-gpu-support-matrix-new). If your card is on the list and supports CUVID/NVDEC, it will most likely work with Frigate for decoding. However, you must also use [a driver version that will work with FFmpeg](https://github.com/FFmpeg/nv-codec-headers/blob/master/README). Older driver versions may be missing symbols and fail to work, and older cards are not supported by newer driver versions. The only way around this is to [provide your own FFmpeg](/configuration/advanced#custom-ffmpeg-build) that will work with your driver version, but this is unsupported and may not work well if at all.
 
-These instructions are based on the [jellyfin documentation](https://jellyfin.org/docs/general/administration/hardware-acceleration.html#nvidia-hardware-acceleration-on-docker-linux)
+A more complete list of cards and their compatible drivers is available in the [driver release readme](https://download.nvidia.com/XFree86/Linux-x86_64/525.85.05/README/supportedchips.html).
+
+If your distribution does not offer NVIDIA driver packages, you can [download them here](https://www.nvidia.com/en-us/drivers/unix/).
+
+#### Configuring Nvidia GPUs in Docker
+
+Additional configuration is needed for the Docker container to be able to access the NVIDIA GPU. The supported method for this is to install the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker) and specify the GPU to Docker. How you do this depends on how Docker is being run:
+
+##### Docker Compose - Nvidia GPU
 
-Add `--gpus all` to your docker run command or update your compose file.
-If you have multiple Nvidia graphic card, you can add them with their ids obtained via `nvidia-smi` command
 ```yaml
 services:
   frigate:
     ...
-    image: blakeblackshear/frigate:stable
+    image: ghcr.io/blakeblackshear/frigate:stable
     deploy:    # <------------- Add this section
       resources:
         reservations:
@@ -68,11 +165,23 @@ services:
               capabilities: [gpu]
 ```
 
+##### Docker Run CLI - Nvidia GPU
+
+```bash
+docker run -d \
+  --name frigate \
+  ...
+  --gpus=all \
+  ghcr.io/blakeblackshear/frigate:stable
+```
+
+#### Setup Decoder
+
 The decoder you need to pass in the `hwaccel_args` will depend on the input video.
 
-A list of supported codecs (you can use `ffmpeg -decoders | grep cuvid` in the container to get a list)
+A list of supported codecs (you can use `ffmpeg -decoders | grep cuvid` in the container to get the ones your card supports)
 
-```shell
+```
  V..... h263_cuvid           Nvidia CUVID H263 decoder (codec h263)
  V..... h264_cuvid           Nvidia CUVID H264 decoder (codec h264)
  V..... hevc_cuvid           Nvidia CUVID HEVC decoder (codec hevc)
@@ -93,9 +202,15 @@ ffmpeg:
 ```
 
 If everything is working correctly, you should see a significant improvement in performance.
-Verify that hardware decoding is working by running `docker exec -it frigate nvidia-smi`, which should show the ffmpeg
+Verify that hardware decoding is working by running `nvidia-smi`, which should show `ffmpeg`
 processes:
 
+:::note
+
+`nvidia-smi` may not show `ffmpeg` processes when run inside the container [due to docker limitations](https://github.com/NVIDIA/nvidia-docker/issues/179#issuecomment-645579458).
+
+:::
+
 ```
 +-----------------------------------------------------------------------------+
 | NVIDIA-SMI 455.38       Driver Version: 455.38       CUDA Version: 11.1     |
@@ -123,3 +238,7 @@ processes:
 |    0   N/A  N/A     12827      C   ffmpeg                            417MiB |
 +-----------------------------------------------------------------------------+
 ```
+
+If you do not see these processes, check the `docker logs` for the container and look for decoding errors.
+
+These instructions were originally based on the [Jellyfin documentation](https://jellyfin.org/docs/general/administration/hardware-acceleration.html#nvidia-hardware-acceleration-on-docker-linux).

docs/docs/configuration/index.md

@@ -3,7 +3,7 @@ id: index
 title: Configuration File
 ---
 
-For Home Assistant Addon installations, the config file needs to be in the root of your Home Assistant config directory (same location as `configuration.yaml`) and named `frigate.yml`.
+For Home Assistant Addon installations, the config file needs to be in the root of your Home Assistant config directory (same location as `configuration.yaml`). It can be named `frigate.yml` or `frigate.yaml`, but if both files exist `frigate.yaml` will be preferred and `frigate.yml` will be ignored.
 
 For all other installation types, the config file should be mapped to `/config/config.yml` inside the container.
 
@@ -19,7 +19,6 @@ cameras:
         - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
           roles:
             - detect
-            - restream
     detect:
       width: 1280
       height: 720
@@ -27,7 +26,7 @@ cameras:
 
 ### VSCode Configuration Schema
 
-VSCode (and VSCode addon) supports the JSON schemas which will automatically validate the config. This can be added by adding `# yaml-language-server: $schema=http://frigate_host:5000/api/config/schema.json` to the top of the config file. `frigate_host` being the IP address of frigate or `ccab4aaf-frigate` if running in the addon.
+VSCode (and VSCode addon) supports the JSON schemas which will automatically validate the config. This can be added by adding `# yaml-language-server: $schema=http://frigate_host:5000/api/config/schema.json` to the top of the config file. `frigate_host` being the IP address of Frigate or `ccab4aaf-frigate` if running in the addon.
 
 ### Full configuration reference:
 
@@ -37,6 +36,25 @@ It is not recommended to copy this full configuration file. Only specify values
 
 :::
 
+**Note:** The following values will be replaced at runtime by using environment variables
+
+- `{FRIGATE_MQTT_USER}`
+- `{FRIGATE_MQTT_PASSWORD}`
+- `{FRIGATE_RTSP_USER}`
+- `{FRIGATE_RTSP_PASSWORD}`
+
+for example:
+
+```yaml
+mqtt:
+  user: "{FRIGATE_MQTT_USER}"
+  password: "{FRIGATE_MQTT_PASSWORD}"
+```
+
+```yaml
+- path: rtsp://{FRIGATE_RTSP_USER}:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:8554/unicast
+```
+
 ```yaml
 mqtt:
   # Optional: Enable mqtt server (default: shown below)
@@ -52,6 +70,8 @@ mqtt:
   # NOTE: must be unique if you are running multiple instances
   client_id: frigate
   # Optional: user
+  # NOTE: MQTT user can be specified with an environment variables that must begin with 'FRIGATE_'.
+  #       e.g. user: '{FRIGATE_MQTT_USER}'
   user: mqtt_user
   # Optional: password
   # NOTE: MQTT password can be specified with an environment variables that must begin with 'FRIGATE_'.
@@ -103,6 +123,9 @@ model:
   # Optional: Object detection model input tensor format
   # Valid values are nhwc or nchw (default: shown below)
   input_tensor: nhwc
+  # Optional: Object detection model type, currently only used with the OpenVINO detector
+  # Valid values are ssd, yolox, yolov5, or yolov8 (default: shown below)
+  model_type: ssd
   # Optional: Label name modifications. These are merged into the standard labelmap.
   labelmap:
     2: vehicle
@@ -124,6 +147,9 @@ environment_vars:
 birdseye:
   # Optional: Enable birdseye view (default: shown below)
   enabled: True
+  # Optional: Restream birdseye via RTSP (default: shown below)
+  # NOTE: Enabling this will set birdseye to run 24/7 which may increase CPU usage somewhat.
+  restream: False
   # Optional: Width of the output resolution (default: shown below)
   width: 1280
   # Optional: Height of the output resolution (default: shown below)
@@ -141,7 +167,7 @@ birdseye:
 # More information about presets at https://docs.frigate.video/configuration/ffmpeg_presets
 ffmpeg:
   # Optional: global ffmpeg args (default: shown below)
-  global_args: -hide_banner -loglevel warning
+  global_args: -hide_banner -loglevel warning -threads 2
   # Optional: global hwaccel args (default: shown below)
   # NOTE: See hardware acceleration docs for your specific device
   hwaccel_args: []
@@ -150,7 +176,7 @@ ffmpeg:
   # Optional: global output args
   output_args:
     # Optional: output args for detect streams (default: shown below)
-    detect: -f rawvideo -pix_fmt yuv420p
+    detect: -threads 2 -f rawvideo -pix_fmt yuv420p
     # Optional: output args for record streams (default: shown below)
     record: preset-record-generic
     # Optional: output args for rtmp streams (default: shown below)
@@ -167,9 +193,8 @@ detect:
   # NOTE: Recommended value of 5. Ideally, try and reduce your FPS on the camera.
   fps: 5
   # Optional: enables detection for the camera (default: True)
-  # This value can be set via MQTT and will be updated in startup based on retained value
   enabled: True
-  # Optional: Number of frames without a detection before frigate considers an object to be gone. (default: 5x the frame rate)
+  # Optional: Number of frames without a detection before Frigate considers an object to be gone. (default: 5x the frame rate)
   max_disappeared: 25
   # Optional: Configuration for stationary object tracking
   stationary:
@@ -266,11 +291,6 @@ record:
   # Optional: Enable recording (default: shown below)
   # WARNING: If recording is disabled in the config, turning it on via
   #          the UI or MQTT later will have no effect.
-  # WARNING: Frigate does not currently support limiting recordings based
-  #          on available disk space automatically. If using recordings,
-  #          you must specify retention settings for a number of days that
-  #          will fit within the available disk space of your drive or Frigate
-  #          will crash.
   enabled: False
   # Optional: Number of minutes to wait between cleanup runs (default: shown below)
   # This can be used to reduce the frequency of deleting recording segments from disk if you want to minimize i/o
@@ -320,7 +340,6 @@ record:
 # NOTE: Can be overridden at the camera level
 snapshots:
   # Optional: Enable writing jpg snapshot to /media/frigate/clips (default: shown below)
-  # This value can be set via MQTT and will be updated in startup based on retained value
   enabled: False
   # Optional: save a clean PNG copy of the snapshot image (default: shown below)
   clean_copy: True
@@ -350,24 +369,21 @@ rtmp:
   enabled: False
 
 # Optional: Restream configuration
-# NOTE: Can be overridden at the camera level
-restream:
-  # Optional: Enable the restream (default: True)
-  enabled: True
-  # Optional: Force audio compatibility with browsers (default: shown below)
-  force_audio: True
-  # Optional: Restream birdseye via RTSP (default: shown below)
-  # NOTE: Enabling this will set birdseye to run 24/7 which may increase CPU usage somewhat.
-  birdseye: False
-  # Optional: jsmpeg stream configuration for WebUI
-  jsmpeg:
-    # Optional: Set the height of the jsmpeg stream. (default: 720)
-    # This must be less than or equal to the height of the detect stream. Lower resolutions
-    # reduce bandwidth required for viewing the jsmpeg stream. Width is computed to match known aspect ratio.
-    height: 720
-    # Optional: Set the encode quality of the jsmpeg stream (default: shown below)
-    # 1 is the highest quality, and 31 is the lowest. Lower quality feeds utilize less CPU resources.
-    quality: 8
+# Uses https://github.com/AlexxIT/go2rtc (v1.2.0)
+go2rtc:
+
+# Optional: jsmpeg stream configuration for WebUI
+live:
+  # Optional: Set the name of the stream that should be used for live view
+  # in frigate WebUI. (default: name of camera)
+  stream_name: camera_name
+  # Optional: Set the height of the jsmpeg stream. (default: 720)
+  # This must be less than or equal to the height of the detect stream. Lower resolutions
+  # reduce bandwidth required for viewing the jsmpeg stream. Width is computed to match known aspect ratio.
+  height: 720
+  # Optional: Set the encode quality of the jsmpeg stream (default: shown below)
+  # 1 is the highest quality, and 31 is the lowest. Lower quality feeds utilize less CPU resources.
+  quality: 8
 
 # Optional: in-feed timestamp style configuration
 # NOTE: Can be overridden at the camera level
@@ -408,12 +424,12 @@ cameras:
         # Required: the path to the stream
         # NOTE: path may include environment variables, which must begin with 'FRIGATE_' and be referenced in {}
         - path: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
-          # Required: list of roles for this stream. valid values are: detect,record,restream,rtmp
-          # NOTICE: In addition to assigning the record, restream, and rtmp roles,
+          # Required: list of roles for this stream. valid values are: detect,record,rtmp
+          # NOTICE: In addition to assigning the record and rtmp roles,
           # they must also be enabled in the camera config.
           roles:
             - detect
-            - restream
+            - record
             - rtmp
           # Optional: stream specific global args (default: inherit)
           # global_args:
@@ -480,4 +496,42 @@ cameras:
       order: 0
       # Optional: Whether or not to show the camera in the Frigate UI (default: shown below)
       dashboard: True
+
+# Optional
+ui:
+  # Optional: Set the default live mode for cameras in the UI (default: shown below)
+  live_mode: mse
+  # Optional: Set a timezone to use in the UI (default: use browser local time)
+  # timezone: America/Denver
+  # Optional: Use an experimental recordings / camera view UI (default: shown below)
+  use_experimental: False
+  # Optional: Set the time format used.
+  # Options are browser, 12hour, or 24hour (default: shown below)
+  time_format: browser
+  # Optional: Set the date style for a specified length.
+  # Options are: full, long, medium, short
+  # Examples:
+  #    short: 2/11/23
+  #    medium: Feb 11, 2023
+  #    full: Saturday, February 11, 2023
+  # (default: shown below).
+  date_style: short
+  # Optional: Set the time style for a specified length.
+  # Options are: full, long, medium, short
+  # Examples:
+  #    short: 8:14 PM
+  #    medium: 8:15:22 PM
+  #    full: 8:15:22 PM Mountain Standard Time
+  # (default: shown below).
+  time_style: medium
+  # Optional: Ability to manually override the date / time styling to use strftime format
+  # https://www.gnu.org/software/libc/manual/html_node/Formatting-Calendar-Time.html
+  # possible values are shown above (default: not set)
+  strftime_fmt: "%Y/%m/%d %H:%M"
+
+# Optional: Telemetry configuration
+telemetry:
+  # Optional: Enable the latest version outbound check (default: shown below)
+  # NOTE: If you use the HomeAssistant integration, disabling this will prevent it from reporting new versions
+  version_check: True
 ```

docs/docs/configuration/live.md

@@ -3,39 +3,116 @@ id: live
 title: Live View
 ---
 
-Frigate has different live view options, some of which require [restream](restream.md) to be enabled.
+Frigate has different live view options, some of which require the bundled `go2rtc` to be configured as shown in the [step by step guide](/guides/configuring_go2rtc).
 
 ## Live View Options
 
 Live view options can be selected while viewing the live stream. The options are:
 
-| Source | Latency | Frame Rate                             | Resolution     | Audio                        | Requires Restream | Other Limitations     |
-| ------ | ------- | -------------------------------------- | -------------- | ---------------------------- | ----------------- | --------------------- |
-| jsmpeg | low     | same as `detect -> fps`, capped at 10  | same as detect | no                           | no                | none                  |
-| mse    | low     | native                                 | native         | yes (depends on audio codec) | yes               | not supported on iOS  |
-| webrtc | lowest  | native                                 | native         | yes (depends on audio codec) | yes               | requires extra config |
+| Source | Latency | Frame Rate                            | Resolution     | Audio                        | Requires go2rtc | Other Limitations                            |
+| ------ | ------- | ------------------------------------- | -------------- | ---------------------------- | --------------- | -------------------------------------------- |
+| jsmpeg | low     | same as `detect -> fps`, capped at 10 | same as detect | no                           | no              | none                                         |
+| mse    | low     | native                                | native         | yes (depends on audio codec) | yes             | not supported on iOS, Firefox is h.264 only  |
+| webrtc | lowest  | native                                | native         | yes (depends on audio codec) | yes             | requires extra config, doesn't support h.265 |
+
+### Audio Support
+
+MSE Requires AAC audio, WebRTC requires PCMU/PCMA, or opus audio. If you want to support both MSE and WebRTC then your restream config needs to make sure both are enabled.
+
+```yaml
+go2rtc:
+  streams:
+    rtsp_cam: # <- for RTSP streams
+      - rtsp://192.168.1.5:554/live0 # <- stream which supports video & aac audio
+      - "ffmpeg:rtsp_cam#audio=opus" # <- copy of the stream which transcodes audio to the missing codec (usually will be opus)
+    http_cam: # <- for http streams
+      - http://192.168.50.155/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=user&password=password # <- stream which supports video & aac audio
+      - "ffmpeg:http_cam#audio=opus" # <- copy of the stream which transcodes audio to the missing codec (usually will be opus)
+```
+
+### Setting Stream For Live UI
+
+There may be some cameras that you would prefer to use the sub stream for live view, but the main stream for recording. This can be done via `live -> stream_name`.
+
+```yaml
+go2rtc:
+  streams:
+    rtsp_cam:
+      - rtsp://192.168.1.5:554/live0 # <- stream which supports video & aac audio.
+      - "ffmpeg:rtsp_cam#audio=opus" # <- copy of the stream which transcodes audio to opus
+    rtsp_cam_sub:
+      - rtsp://192.168.1.5:554/substream # <- stream which supports video & aac audio.
+      - "ffmpeg:rtsp_cam_sub#audio=opus" # <- copy of the stream which transcodes audio to opus
+
+cameras:
+  test_cam:
+    ffmpeg:
+      output_args:
+        record: preset-record-generic-audio-copy
+      inputs:
+        - path: rtsp://127.0.0.1:8554/test_cam # <--- the name here must match the name of the camera in restream
+          input_args: preset-rtsp-restream
+          roles:
+            - record
+        - path: rtsp://127.0.0.1:8554/test_cam_sub # <--- the name here must match the name of the camera_sub in restream
+          input_args: preset-rtsp-restream
+          roles:
+            - detect
+    live:
+      stream_name: rtsp_cam_sub
+```
 
 ### WebRTC extra configuration:
 
-webRTC works by creating a websocket connection on extra ports. One of the following is required for webRTC to work:
-* Frigate is run with `network_mode: host` to support automatic UDP port pass through locally and remotely. See https://github.com/AlexxIT/go2rtc#module-webrtc for more details
-* Frigate is run with `network_mode: bridge` and has:
-    * Router setup to forward port `8555` to port `8555` on the frigate device.
-    * For local webRTC, you will need to create your own go2rtc config:
+WebRTC works by creating a TCP or UDP connection on port `8555`. However, it requires additional configuration:
 
-```yaml
-webrtc:
-  listen: ":8555"
-  candidates:
-    - <frigate host ip address>:8555 # <--- enter frigate host IP here
-    - stun:8555
+- For external access, over the internet, setup your router to forward port `8555` to port `8555` on the Frigate device, for both TCP and UDP.
+- For internal/local access, unless you are running through the add-on, you will also need to set the WebRTC candidates list in the go2rtc config. For example, if `192.168.1.10` is the local IP of the device running Frigate:
+
+  ```yaml title="/config/frigate.yaml"
+  go2rtc:
+    streams:
+      test_cam: ...
+    webrtc:
+      candidates:
+        - 192.168.1.10:8555
+        - stun:8555
+  ```
+  
+- For access through Tailscale, the Frigate system's Tailscale IP must be added as a WebRTC candidate. Tailscale IPs all start with `100.`, and are reserved within the `100.0.0.0/8` CIDR block.
+
+:::tip
+
+This extra configuration may not be required if Frigate has been installed as a Home Assistant add-on, as Frigate uses the Supervisor's API to generate a WebRTC candidate.
+
+However, it is recommended if issues occur to define the candidates manually. You should do this if the Frigate add-on fails to generate a valid candidate. If an error occurs you will see some warnings like the below in the add-on logs page during the initialization:
+
+```log
+[WARN] Failed to get IP address from supervisor
+[WARN] Failed to get WebRTC port from supervisor
 ```
 
-and pass that config to frigate via docker or `frigate-go2rtc.yaml` for addon users:
+:::
 
-See https://github.com/AlexxIT/go2rtc#module-webrtc for more details
+:::note
 
+If you are having difficulties getting WebRTC to work and you are running Frigate with docker, you may want to try changing the container network mode:
+
+- `network: host`, in this mode you don't need to forward any ports. The services inside of the Frigate container will have full access to the network interfaces of your host machine as if they were running natively and not in a container. Any port conflicts will need to be resolved. This network mode is recommended by go2rtc, but we recommend you only use it if necessary.
+- `network: bridge` is the default network driver, a bridge network is a Link Layer device which forwards traffic between network segments. You need to forward any ports that you want to be accessible from the host IP.
+
+If not running in host mode, port 8555 will need to be mapped for the container:
+
+docker-compose.yml
 ```yaml
-volumes:
-  - /path/to/your/go2rtc.yaml:/config/frigate-go2rtc.yaml:ro
-```
+services:
+  frigate:
+    ...
+    ports:
+      - "8555:8555/tcp" # WebRTC over tcp
+      - "8555:8555/udp" # WebRTC over udp
+```
+
+:::
+
+See [go2rtc WebRTC docs](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#module-webrtc) for more information about this.

docs/docs/configuration/masks.md

@@ -7,7 +7,7 @@ There are two types of masks available:
 
 **Motion masks**: Motion masks are used to prevent unwanted types of motion from triggering detection. Try watching the debug feed with `Motion Boxes` enabled to see what may be regularly detected as motion. For example, you want to mask out your timestamp, the sky, rooftops, etc. Keep in mind that this mask only prevents motion from being detected and does not prevent objects from being detected if object detection was started due to motion in unmasked areas. Motion is also used during object tracking to refine the object detection area in the next frame. Over masking will make it more difficult for objects to be tracked. To see this effect, create a mask, and then watch the video feed with `Motion Boxes` enabled again.
 
-**Object filter masks**: Object filter masks are used to filter out false positives for a given object type based on location. These should be used to filter any areas where it is not possible for an object of that type to be. The bottom center of the detected object's bounding box is evaluated against the mask. If it is in a masked area, it is assumed to be a false positive. For example, you may want to mask out rooftops, walls, the sky, treetops for people. For cars, masking locations other than the street or your driveway will tell frigate that anything in your yard is a false positive.
+**Object filter masks**: Object filter masks are used to filter out false positives for a given object type based on location. These should be used to filter any areas where it is not possible for an object of that type to be. The bottom center of the detected object's bounding box is evaluated against the mask. If it is in a masked area, it is assumed to be a false positive. For example, you may want to mask out rooftops, walls, the sky, treetops for people. For cars, masking locations other than the street or your driveway will tell Frigate that anything in your yard is a false positive.
 
 To create a poly mask:
 

docs/docs/configuration/record.md

@@ -3,9 +3,11 @@ id: record
 title: Recording
 ---
 
-Recordings can be enabled and are stored at `/media/frigate/recordings`. The folder structure for the recordings is `YYYY-MM/DD/HH/<camera_name>/MM.SS.mp4`. These recordings are written directly from your camera stream without re-encoding. Each camera supports a configurable retention policy in the config. Frigate chooses the largest matching retention value between the recording retention and the event retention when determining if a recording should be removed.
+Recordings can be enabled and are stored at `/media/frigate/recordings`. The folder structure for the recordings is `YYYY-MM-DD/HH/<camera_name>/MM.SS.mp4`. These recordings are written directly from your camera stream without re-encoding. Each camera supports a configurable retention policy in the config. Frigate chooses the largest matching retention value between the recording retention and the event retention when determining if a recording should be removed.
 
-H265 recordings can be viewed in Edge and Safari only. All other browsers require recordings to be encoded with H264.
+New recording segments are written from the camera stream to cache, they are only moved to disk if they match the setup recording retention policy.
+
+H265 recordings can be viewed in Chrome 108+, Edge and Safari only. All other browsers require recordings to be encoded with H264.
 
 ## Will Frigate delete old recordings if my storage runs out?
 
@@ -37,9 +39,9 @@ Using Frigate UI, HomeAssistant, or MQTT, cameras can be automated to only recor
 
 Frigate saves from the stream with the `record` role in 10 second segments. These options determine which recording segments are kept for 24/7 recording (but can also affect events).
 
-Let's say you have frigate configured so that your doorbell camera would retain the last **2** days of 24/7 recording.
+Let's say you have Frigate configured so that your doorbell camera would retain the last **2** days of 24/7 recording.
 - With the `all` option all 48 hours of those two days would be kept and viewable.
-- With the `motion` option the only parts of those 48 hours would be segments that frigate detected motion. This is the middle ground option that won't keep all 48 hours, but will likely keep all segments of interest along with the potential for some extra segments.
+- With the `motion` option the only parts of those 48 hours would be segments that Frigate detected motion. This is the middle ground option that won't keep all 48 hours, but will likely keep all segments of interest along with the potential for some extra segments.
 - With the `active_objects` option the only segments that would be kept are those where there was a true positive object that was not considered stationary.
 
 The same options are available with events. Let's consider a scenario where you drive up and park in your driveway, go inside, then come back out 4 hours later.

docs/docs/configuration/restream.md

@@ -3,19 +3,38 @@ id: restream
 title: Restream
 ---
 
-### RTSP
+## RTSP
 
-Frigate can restream your video feed as an RTSP feed for other applications such as Home Assistant to utilize it at `rtsp://<frigate_host>:8554/<camera_name>`. Port 8554 must be open. [This allows you to use a video feed for detection in frigate and Home Assistant live view at the same time without having to make two separate connections to the camera](#reduce-connections-to-camera). The video feed is copied from the original video feed directly to avoid re-encoding. This feed does not include any annotation by Frigate.
+Frigate can restream your video feed as an RTSP feed for other applications such as Home Assistant to utilize it at `rtsp://<frigate_host>:8554/<camera_name>`. Port 8554 must be open. [This allows you to use a video feed for detection in Frigate and Home Assistant live view at the same time without having to make two separate connections to the camera](#reduce-connections-to-camera). The video feed is copied from the original video feed directly to avoid re-encoding. This feed does not include any annotation by Frigate.
 
-#### Force Audio
+Frigate uses [go2rtc](https://github.com/AlexxIT/go2rtc/tree/v1.2.0) to provide its restream and MSE/WebRTC capabilities. The go2rtc config is hosted at the `go2rtc` in the config, see [go2rtc docs](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#configuration) for more advanced configurations and features.
 
-Different live view technologies (ex: MSE, WebRTC) support different audio codecs. The `restream -> force_audio` flag tells the restream to make multiple streams available so that all live view technologies are supported. Some camera streams don't work well with this, in which case `restream -> force_audio` should be disabled.
+:::note
 
-#### Birdseye Restream
+You can access the go2rtc webUI at `http://frigate_ip:5000/live/webrtc` which can be helpful to debug as well as provide useful information about your camera streams.
 
-Birdseye RTSP restream can be enabled at `restream -> birdseye` and accessed at `rtsp://<frigate_host>:8554/birdseye`. Enabling the restream will cause birdseye to run 24/7 which may increase CPU usage somewhat.
+:::
 
-### RTMP (Deprecated)
+### Birdseye Restream
+
+Birdseye RTSP restream can be enabled at `birdseye -> restream` and accessed at `rtsp://<frigate_host>:8554/birdseye`. Enabling the restream will cause birdseye to run 24/7 which may increase CPU usage somewhat.
+
+### Securing Restream With Authentication
+
+The go2rtc restream can be secured with RTSP based username / password authentication. Ex:
+
+```yaml
+go2rtc:
+  rtsp:
+    username: "admin"
+    password: "pass"
+  streams:
+    ...
+```
+
+**NOTE:** This does not apply to localhost requests, there is no need to provide credentials when using the restream as a source for frigate cameras.
+
+## RTMP (Deprecated)
 
 In previous Frigate versions RTMP was used for re-streaming. RTMP has disadvantages however including being incompatible with H.265, high bitrates, and certain audio codecs. RTMP is deprecated and it is recommended to move to the new restream role.
 
@@ -28,17 +47,36 @@ Some cameras only support one active connection or you may just want to have a s
 One connection is made to the camera. One for the restream, `detect` and `record` connect to the restream.
 
 ```yaml
+go2rtc:
+  streams:
+    rtsp_cam: # <- for RTSP streams
+      - rtsp://192.168.1.5:554/live0 # <- stream which supports video & aac audio
+      - "ffmpeg:rtsp_cam#audio=opus" # <- copy of the stream which transcodes audio to the missing codec (usually will be opus)
+    http_cam: # <- for other streams
+      - http://192.168.50.155/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=user&password=password # <- stream which supports video & aac audio
+      - "ffmpeg:http_cam#audio=opus" # <- copy of the stream which transcodes audio to the missing codec (usually will be opus)
+
 cameras:
-  test_cam:
+  rtsp_cam:
     ffmpeg:
+      output_args:
+        record: preset-record-generic-audio-copy
       inputs:
-        - path: rtsp://localhost:8554/test_cam # <--- the name here must match the name of the camera
+        - path: rtsp://127.0.0.1:8554/rtsp_cam # <--- the name here must match the name of the camera in restream
+          input_args: preset-rtsp-restream
           roles:
             - record
             - detect
-        - path: rtsp://192.168.1.5:554/live0 # <--- 1 connection to camera stream
+  http_cam:
+    ffmpeg:
+      output_args:
+        record: preset-record-generic-audio-copy
+      inputs:
+        - path: rtsp://127.0.0.1:8554/http_cam # <--- the name here must match the name of the camera in restream
+          input_args: preset-rtsp-restream
           roles:
-            - restream
+            - record
+            - detect
 ```
 
 ### With Sub Stream
@@ -46,17 +84,58 @@ cameras:
 Two connections are made to the camera. One for the sub stream, one for the restream, `record` connects to the restream.
 
 ```yaml
+go2rtc:
+  streams:
+    rtsp_cam: 
+      - rtsp://192.168.1.5:554/live0 # <- stream which supports video & aac audio. This is only supported for rtsp streams, http must use ffmpeg
+      - "ffmpeg:rtsp_cam#audio=opus" # <- copy of the stream which transcodes audio to opus
+    rtsp_cam_sub:
+      - rtsp://192.168.1.5:554/substream # <- stream which supports video & aac audio. This is only supported for rtsp streams, http must use ffmpeg
+      - "ffmpeg:rtsp_cam_sub#audio=opus" # <- copy of the stream which transcodes audio to opus
+    http_cam:
+      - http://192.168.50.155/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=user&password=password # <- stream which supports video & aac audio. This is only supported for rtsp streams, http must use ffmpeg
+      - "ffmpeg:http_cam#audio=opus" # <- copy of the stream which transcodes audio to opus
+    http_cam_sub:
+      - http://192.168.50.155/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=user&password=password # <- stream which supports video & aac audio. This is only supported for rtsp streams, http must use ffmpeg
+      - "ffmpeg:http_cam_sub#audio=opus" # <- copy of the stream which transcodes audio to opus
+
 cameras:
-  test_cam:
+  rtsp_cam:
     ffmpeg:
+      output_args:
+        record: preset-record-generic-audio-copy
       inputs:
-        - path: rtsp://localhost:8554/test_cam # <--- the name here must match the name of the camera
+        - path: rtsp://127.0.0.1:8554/rtsp_cam # <--- the name here must match the name of the camera in restream
+          input_args: preset-rtsp-restream
           roles:
             - record
-        - path: rtsp://192.168.1.5:554/stream # <--- camera high res stream
+        - path: rtsp://127.0.0.1:8554/rtsp_cam_sub # <--- the name here must match the name of the camera_sub in restream
+          input_args: preset-rtsp-restream
           roles:
-            - restream
-        - path: rtsp://192.168.1.5:554/substream # <--- camera sub stream
+            - detect
+  http_cam:
+    ffmpeg:
+      output_args:
+        record: preset-record-generic-audio-copy
+      inputs:
+        - path: rtsp://127.0.0.1:8554/http_cam # <--- the name here must match the name of the camera in restream
+          input_args: preset-rtsp-restream
+          roles:
+            - record
+        - path: rtsp://127.0.0.1:8554/http_cam_sub # <--- the name here must match the name of the camera_sub in restream
+          input_args: preset-rtsp-restream
           roles:
             - detect
 ```
+
+## Advanced Restream Configurations
+
+The [exec](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#source-exec) source in go2rtc can be used for custom ffmpeg commands. An example is below:
+
+NOTE: The output will need to be passed with two curly braces `{{output}}`
+
+```yaml
+go2rtc:
+  streams:
+    stream1: exec:ffmpeg -hide_banner -re -stream_loop -1 -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {{output}}
+```

docs/docs/configuration/snapshots.md

@@ -4,3 +4,5 @@ title: Snapshots
 ---
 
 Frigate can save a snapshot image to `/media/frigate/clips` for each event named as `<camera>-<id>.jpg`.
+
+Snapshots sent via MQTT are configured in the [config file](https://docs.frigate.video/configuration/) under  `cameras -> your_camera -> mqtt`

docs/docs/configuration/zones.md

@@ -11,6 +11,24 @@ During testing, enable the Zones option for the debug feed so you can adjust as
 
 To create a zone, follow [the steps for a "Motion mask"](masks.md), but use the section of the web UI for creating a zone instead.
 
+### Restricting events to specific zones
+
+Often you will only want events to be created when an object enters areas of interest. This is done using zones along with setting required_zones. Let's say you only want to be notified when an object enters your entire_yard zone, the config would be:
+
+```yaml
+camera:
+  record:
+    events:
+      required_zones:
+        - entire_yard
+  snapshots:
+    required_zones:
+      - entire_yard
+  zones:
+    entire_yard:
+      coordinates: ...
+```
+
 ### Restricting zones to specific objects
 
 Sometimes you want to limit a zone to specific object types to have more granular control of when events/snapshots are saved. The following example will limit one zone to person objects and the other to cars.

docs/docs/development/contributing.md

@@ -36,13 +36,19 @@ Fork [blakeblackshear/frigate-hass-integration](https://github.com/blakeblackshe
 - [Frigate source code](#frigate-core-web-and-docs)
 - GNU make
 - Docker
-- Extra Coral device (optional, but very helpful to simulate real world performance)
+- An extra detector (Coral, OpenVINO, etc.) is optional but recommended to simulate real world performance.
+
+:::note
+
+A Coral device can only be used by a single process at a time, so an extra Coral device is recommended if using a coral for development purposes.
+
+:::
 
 ### Setup
 
 #### 1. Open the repo with Visual Studio Code
 
-Upon opening, you should be prompted to open the project in a remote container. This will build a container on top of the base frigate container with all the development dependencies installed. This ensures everyone uses a consistent development environment without the need to install any dependencies on your host machine.
+Upon opening, you should be prompted to open the project in a remote container. This will build a container on top of the base Frigate container with all the development dependencies installed. This ensures everyone uses a consistent development environment without the need to install any dependencies on your host machine.
 
 #### 2. Modify your local config file for testing
 
@@ -62,7 +68,6 @@ cameras:
           input_args: -re -stream_loop -1 -fflags +genpts
           roles:
             - detect
-            - rtmp
     detect:
       height: 1080
       width: 1920
@@ -75,12 +80,12 @@ These input args tell ffmpeg to read the mp4 file in an infinite loop. You can u
 
 Create and place these files in a `debug` folder in the root of the repo. This is also where recordings will be created if you enable them in your test config. Update your config from step 2 above to point at the right file. You can check the `docker-compose.yml` file in the repo to see how the volumes are mapped.
 
-#### 4. Run frigate from the command line
+#### 4. Run Frigate from the command line
 
 VSCode will start the docker compose file for you and open a terminal window connected to `frigate-dev`.
 
 - Run `python3 -m frigate` to start the backend.
-- In a separate terminal window inside VS Code, change into the `web` directory and run `npm install && npm start` to start the frontend.
+- In a separate terminal window inside VS Code, change into the `web` directory and run `npm install && npm run dev` to start the frontend.
 
 #### 5. Teardown
 

docs/docs/frigate/camera_setup.md

@@ -3,7 +3,7 @@ id: camera_setup
 title: Camera setup
 ---
 
-Cameras configured to output H.264 video and AAC audio will offer the most compatibility with all features of Frigate and Home Assistant. H.265 has better compression, but far less compatibility. Safari and Edge are the only browsers able to play H.265. Ideally, cameras should be configured directly for the desired resolutions and frame rates you want to use in Frigate. Reducing frame rates within Frigate will waste CPU resources decoding extra frames that are discarded. There are three different goals that you want to tune your stream configurations around.
+Cameras configured to output H.264 video and AAC audio will offer the most compatibility with all features of Frigate and Home Assistant. H.265 has better compression, but less compatibility. Chrome 108+, Safari and Edge are the only browsers able to play H.265 and only support a limited number of H.265 profiles. Ideally, cameras should be configured directly for the desired resolutions and frame rates you want to use in Frigate. Reducing frame rates within Frigate will waste CPU resources decoding extra frames that are discarded. There are three different goals that you want to tune your stream configurations around.
 
 - **Detection**: This is the only stream that Frigate will decode for processing. Also, this is the stream where snapshots will be generated from. The resolution for detection should be tuned for the size of the objects you want to detect. See [Choosing a detect resolution](#choosing-a-detect-resolution) for more details. The recommended frame rate is 5fps, but may need to be higher for very fast moving objects. Higher resolutions and frame rates will drive higher CPU usage on your server.
 
@@ -23,22 +23,14 @@ Larger resolutions **do** improve performance if the objects are very small in t
 
 For the Dahua/Loryta 5442 camera, I use the following settings:
 
-**Main Stream (Recording)**
+**Main Stream (Recording & RTSP)**
 
 - Encode Mode: H.264
 - Resolution: 2688\*1520
 - Frame Rate(FPS): 15
 - I Frame Interval: 30
 
-**Sub Stream 1 (RTMP)**
-
-- Enable: Sub Stream 1
-- Encode Mode: H.264
-- Resolution: 720\*576
-- Frame Rate: 10
-- I Frame Interval: 10
-
-**Sub Stream 2 (Detection)**
+**Sub Stream (Detection)**
 
 - Enable: Sub Stream 2
 - Encode Mode: H.264

docs/docs/frigate/hardware.md

@@ -23,15 +23,11 @@ I may earn a small commission for my endorsement, recommendation, testimonial, o
 
 My current favorite is the Minisforum GK41 because of the dual NICs that allow you to setup a dedicated private network for your cameras where they can be blocked from accessing the internet. There are many used workstation options on eBay that work very well. Anything with an Intel CPU and capable of running Debian should work fine. As a bonus, you may want to look for devices with a M.2 or PCIe express slot that is compatible with the Google Coral. I may earn a small commission for my endorsement, recommendation, testimonial, or link to any products or services from this website.
 
-| Name                                                                                                                                                                                                                                                                                                              | Coral Inference Speed | Coral Compatibility | Notes                                                                                                                             |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| Odyssey X86 Blue J4125 (<a href="https://amzn.to/3oH4BKi" target="_blank" rel="nofollow noopener sponsored">Amazon</a>) (<a href="https://www.seeedstudio.com/Frigate-NVR-with-Odyssey-Blue-and-Coral-USB-Accelerator.html?utm_source=Frigate" target="_blank" rel="nofollow noopener sponsored">SeeedStudio</a>) | 9-10ms          | M.2 B+M, USB        | Dual gigabit NICs for easy isolated camera network. Easily handles several 1080p cameras.                                               |
-| Minisforum GK41 (<a href="https://amzn.to/3ptnb8D" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                  | 9-10ms          | USB                 | Dual gigabit NICs for easy isolated camera network. Easily handles several 1080p cameras.                                               |
-| Beelink GK55 (<a href="https://amzn.to/35E79BC" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                     | 9-10ms          | USB                 | Dual gigabit NICs for easy isolated camera network. Easily handles several 1080p cameras.                                               |
-| Intel NUC (<a href="https://amzn.to/3psFlHi" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                        | 8-10ms          | USB                 | Overkill for most, but great performance. Can handle many cameras at 5fps depending on typical amounts of motion. Requires extra parts. |
-| BMAX B2 Plus (<a href="https://amzn.to/3a6TBh8" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                     | 10-12ms         | USB                 | Good balance of performance and cost. Also capable of running many other services at the same time as frigate.                          |
-| Atomic Pi (<a href="https://amzn.to/2YjpY9m" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                        | 16ms            | USB                 | Good option for a dedicated low power board with a small number of cameras. Can leverage Intel QuickSync for stream decoding.           |
-| Raspberry Pi 4 (64bit) (<a href="https://amzn.to/2YhSGHH" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                           | 10-15ms         | USB                 | Can handle a small number of cameras.                                                                                                   |
+| Name                                                                                                                                                                                                                                                                                                              | Coral Inference Speed | Coral Compatibility | Notes                                                                                                                                   |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| Odyssey X86 Blue J4125 (<a href="https://amzn.to/3oH4BKi" target="_blank" rel="nofollow noopener sponsored">Amazon</a>) (<a href="https://www.seeedstudio.com/Frigate-NVR-with-Odyssey-Blue-and-Coral-USB-Accelerator.html?utm_source=Frigate" target="_blank" rel="nofollow noopener sponsored">SeeedStudio</a>) | 9-10ms                | M.2 B+M, USB        | Dual gigabit NICs for easy isolated camera network. Easily handles several 1080p cameras.                                               |
+| Minisforum GK41 (<a href="https://amzn.to/3ptnb8D" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                  | 9-10ms                | USB                 | Dual gigabit NICs for easy isolated camera network. Easily handles several 1080p cameras.                                               |
+| Intel NUC (<a href="https://amzn.to/3psFlHi" target="_blank" rel="nofollow noopener sponsored">Amazon</a>)                                                                                                                                                                                                        | 8-10ms                | USB                 | Overkill for most, but great performance. Can handle many cameras at 5fps depending on typical amounts of motion. Requires extra parts. |
 
 ## Detectors
 
@@ -50,6 +46,7 @@ A single Coral can handle many cameras and will be sufficient for the majority o
 ### OpenVino
 
 The OpenVINO detector type is able to run on:
+
 - 6th Gen Intel Platforms and newer that have an iGPU
 - x86 & Arm32/64 hosts with VPU Hardware (ex: Intel NCS2)
 
@@ -57,12 +54,21 @@ More information is available [in the detector docs](/configuration/detectors#op
 
 Inference speeds vary greatly depending on the CPU, GPU, or VPU used, some known examples are below:
 
-| Name                | Inference Speed | Notes                                                                 |
-| ------------------- | --------------- | --------------------------------------------------------------------- |
-| Intel Celeron J4105 | ~ 25 ms         | Inference speeds on CPU were ~ 150 ms                                 |
-| Intel Celeron N4020 | 50 - 200 ms     | Inference speeds on CPU were ~ 800 ms, greatly depends on other loads |
-| Intel NCS2 VPU      | 60 - 65 ms      | May vary based on host device                                         |
-| Intel i5 1135G7     | 10 - 15 ms      |                                                                       |
+| Name                 | Inference Speed | Notes                                                                 |
+| -------------------- | --------------- | --------------------------------------------------------------------- |
+| Intel NCS2 VPU       | 60 - 65 ms      | May vary based on host device                                         |
+| Intel Celeron J4105  | ~ 25 ms         | Inference speeds on CPU were 150 - 200 ms                             |
+| Intel Celeron N3060  | 130 - 150 ms    | Inference speeds on CPU were ~ 550 ms                                 |
+| Intel Celeron N3205U | ~ 120 ms        | Inference speeds on CPU were ~ 380 ms                                 |
+| Intel Celeron N4020  | 50 - 200 ms     | Inference speeds on CPU were ~ 800 ms, greatly depends on other loads |
+| Intel i3 6100T       | 15 - 35 ms      | Inference speeds on CPU were 60 - 120 ms                              |
+| Intel i3 8100        | ~ 15 ms         | Inference speeds on CPU were ~ 65 ms                                  |
+| Intel i5 4590        | ~ 20 ms         | Inference speeds on CPU were ~ 230 ms                                 |
+| Intel i5 6500        | ~ 15 ms         | Inference speeds on CPU were ~ 150 ms                                 |
+| Intel i5 7200u       | 15 - 25 ms      | Inference speeds on CPU were ~ 150 ms                                 |
+| Intel i5 7500        | ~ 15 ms         | Inference speeds on CPU were ~ 260 ms                                 |
+| Intel i5 1135G7      | 10 - 15 ms      |                                                                       |
+| Intel i5 12600K      | ~ 15 ms         | Inference speeds on CPU were ~ 35 ms                                  |
 
 ### TensorRT
 
@@ -71,10 +77,15 @@ The TensortRT detector is able to run on x86 hosts that have an Nvidia GPU which
 Inference speeds will vary greatly depending on the GPU and the model used.
 `tiny` variants are faster than the equivalent non-tiny model, some known examples are below:
 
-| Name     | Model           | Inference Speed |
-| -------- | --------------- | --------------- |
-| RTX 3050 | yolov4-tiny-416 | ~ 5 ms          |
-| RTX 3050 | yolov7-tiny-416 | ~ 6 ms          |
+| Name            | Inference Speed |
+| --------------- | --------------- |
+| GTX 1060 6GB    | ~ 7 ms          |
+| GTX 1070        | ~ 6 ms          |
+| GTX 1660 SUPER  | ~ 4 ms          |
+| RTX 3050        | 5 - 7 ms        |
+| RTX 3070 Mobile | ~ 5 ms          |
+| Quadro P400 2GB | 20 - 25 ms      |
+| Quadro P2000    | ~ 12 ms         |
 
 ## What does Frigate use the CPU for and what does it use a detector for? (ELI5 Version)
 

docs/docs/frigate/index.md

@@ -15,7 +15,7 @@ Use of a [Google Coral Accelerator](https://coral.ai/products/) is optional, but
 - Object detection with TensorFlow runs in separate processes for maximum FPS
 - Communicates over MQTT for easy integration into other systems
 - Recording with retention based on detected objects
-- Re-streaming via RTMP to reduce the number of connections to your camera
+- Re-streaming via RTSP to reduce the number of connections to your camera
 - A dynamic combined camera view of all tracked cameras.
 
 ## Screenshots

docs/docs/frigate/installation.md

@@ -3,7 +3,7 @@ id: installation
 title: Installation
 ---
 
-Frigate is a Docker container that can be run on any Docker host including as a [HassOS Addon](https://www.home-assistant.io/addons/). Note that a Home Assistant Addon is **not** the same thing as the integration. The [integration](integrations/home-assistant) is required to integrate Frigate into Home Assistant.
+Frigate is a Docker container that can be run on any Docker host including as a [HassOS Addon](https://www.home-assistant.io/addons/). Note that a Home Assistant Addon is **not** the same thing as the integration. The [integration](/integrations/home-assistant) is required to integrate Frigate into Home Assistant.
 
 ## Dependencies
 
@@ -23,7 +23,7 @@ Frigate uses the following locations for read/write operations in the container.
 
 - `/media/frigate/clips`: Used for snapshot storage. In the future, it will likely be renamed from `clips` to `snapshots`. The file structure here cannot be modified and isn't intended to be browsed or managed manually.
 - `/media/frigate/recordings`: Internal system storage for recording segments. The file structure here cannot be modified and isn't intended to be browsed or managed manually.
-- `/media/frigate/frigate.db`: Default location for the sqlite database. You will also see several files alongside this file while frigate is running. If moving the database location (often needed when using a network drive at `/media/frigate`), it is recommended to mount a volume with docker at `/db` and change the storage location of the database to `/db/frigate.db` in the config file.
+- `/media/frigate/frigate.db`: Default location for the sqlite database. You will also see several files alongside this file while Frigate is running. If moving the database location (often needed when using a network drive at `/media/frigate`), it is recommended to mount a volume with docker at `/db` and change the storage location of the database to `/db/frigate.db` in the config file.
 - `/tmp/cache`: Cache location for recording segments. Initial recordings are written here before being checked and converted to mp4 and moved to the recordings folder.
 - `/dev/shm`: It is not recommended to modify this directory or map it with docker. This is the location for raw decoded frames in shared memory and it's size is impacted by the `shm-size` calculations below.
 - `/config/config.yml`: Default location of the config file.
@@ -38,7 +38,7 @@ services:
   frigate:
     ...
     volumes:
-      - /path/to/your/config.yml:/config/config.yml:ro
+      - /path/to/your/config.yml:/config/config.yml
       - /path/to/your/storage:/media/frigate
       - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
         target: /tmp/cache
@@ -55,7 +55,7 @@ services:
   frigate:
     ...
     volumes:
-      - /path/to/your/config.yml:/config/config.yml:ro
+      - /path/to/your/config.yml:/config/config.yml
       - /path/to/network/storage:/media/frigate
       - /path/to/local/disk:/db
       - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
@@ -74,17 +74,29 @@ database:
 
 ### Calculating required shm-size
 
-Frigate utilizes shared memory to store frames during processing. The default `shm-size` provided by Docker is 64m.
+Frigate utilizes shared memory to store frames during processing. The default `shm-size` provided by Docker is **64MB**.
 
-The default shm-size of 64m is fine for setups with 2 or less 1080p cameras. If frigate is exiting with "Bus error" messages, it is likely because you have too many high resolution cameras and you need to specify a higher shm size.
+The default shm size of **64MB** is fine for setups with **2 cameras** detecting at **720p**. If Frigate is exiting with "Bus error" messages, it is likely because you have too many high resolution cameras and you need to specify a higher shm size.
 
-You can calculate the necessary shm-size for each camera with the following formula using the resolution specified for detect:
+The Frigate container also stores logs in shm, which can take up to **30MB**, so make sure to take this into account in your math as well.
 
-```
-(width * height * 1.5 * 9 + 270480)/1048576 = <shm size in mb>
+You can calculate the necessary shm size for each camera with the following formula using the resolution specified for detect:
+
+```console
+# Replace <width> and <height>
+$ python -c 'print("{:.2f}MB".format((<width> * <height> * 1.5 * 9 + 270480) / 1048576))'
+
+# Example for 1280x720
+$ python -c 'print("{:.2f}MB".format((1280 * 720 * 1.5 * 9 + 270480) / 1048576))'
+12.12MB
+
+# Example for eight cameras detecting at 1280x720, including logs
+$ python -c 'print("{:.2f}MB".format(((1280 * 720 * 1.5 * 9 + 270480) / 1048576) * 8 + 30))'
+126.99MB
 ```
 
-The shm size cannot be set per container for Home Assistant Addons. You must set `default-shm-size` in `/etc/docker/daemon.json` to increase the default shm size. This will increase the shm size for all of your docker containers. This may or may not cause issues with your setup. https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-configuration-file
+The shm size cannot be set per container for Home Assistant add-ons. However, this is probably not required since by default Home Assistant Supervisor allocates `/dev/shm` with half the size of your total memory. If your machine has 8GB of memory, chances are that Frigate will have access to up to 4GB without any additional configuration.
+
 
 ### Raspberry Pi 3/4
 
@@ -103,7 +115,7 @@ services:
     container_name: frigate
     privileged: true # this may not be necessary for all setups
     restart: unless-stopped
-    image: blakeblackshear/frigate:stable
+    image: ghcr.io/blakeblackshear/frigate:stable
     shm_size: "64mb" # update for your cameras based on calculation above
     devices:
       - /dev/bus/usb:/dev/bus/usb # passes the USB Coral, needs to be modified for other versions
@@ -111,7 +123,7 @@ services:
       - /dev/dri/renderD128 # for intel hwaccel, needs to be updated for your hardware
     volumes:
       - /etc/localtime:/etc/localtime:ro
-      - /path/to/your/config.yml:/config/config.yml:ro
+      - /path/to/your/config.yml:/config/config.yml
       - /path/to/your/storage:/media/frigate
       - type: tmpfs # Optional: 1GB of memory, reduces SSD/SD Card wear
         target: /tmp/cache
@@ -119,7 +131,9 @@ services:
           size: 1000000000
     ports:
       - "5000:5000"
-      - "1935:1935" # RTMP feeds
+      - "8554:8554" # RTSP feeds
+      - "8555:8555/tcp" # WebRTC over tcp
+      - "8555:8555/udp" # WebRTC over udp
     environment:
       FRIGATE_RTSP_PASSWORD: "password"
 ```
@@ -135,19 +149,24 @@ docker run -d \
   --device /dev/dri/renderD128 \
   --shm-size=64m \
   -v /path/to/your/storage:/media/frigate \
-  -v /path/to/your/config.yml:/config/config.yml:ro \
+  -v /path/to/your/config.yml:/config/config.yml \
   -v /etc/localtime:/etc/localtime:ro \
   -e FRIGATE_RTSP_PASSWORD='password' \
   -p 5000:5000 \
-  -p 1935:1935 \
-  blakeblackshear/frigate:stable
+  -p 8554:8554 \
+  -p 8555:8555/tcp \
+  -p 8555:8555/udp \
+  ghcr.io/blakeblackshear/frigate:stable
 ```
 
 ## Home Assistant Operating System (HassOS)
 
 :::caution
 
-Due to limitations in Home Assistant Operating System, utilizing external storage for recordings or snapshots requires [modifying udev rules manually](https://community.home-assistant.io/t/solved-mount-usb-drive-in-hassio-to-be-used-on-the-media-folder-with-udev-customization/258406/46).
+There are important limitations in Home Assistant Operating System to be aware of:
+- Utilizing external storage for recordings or snapshots requires [modifying udev rules manually](https://community.home-assistant.io/t/solved-mount-usb-drive-in-hassio-to-be-used-on-the-media-folder-with-udev-customization/258406/46).
+- AMD GPUs are not supported because HA OS does not include the mesa driver.
+- Nvidia GPUs are not supported because addons do not support the nvidia runtime.
 
 :::
 
@@ -178,6 +197,13 @@ There are several versions of the addon available:
 
 ## Home Assistant Supervised
 
+:::caution
+
+There are important limitations in Home Assistant Supervised to be aware of:
+- Nvidia GPUs are not supported because addons do not support the nvidia runtime.
+
+:::
+
 :::tip
 
 If possible, it is recommended to run Frigate standalone in Docker and use [Frigate's Proxy Addon](https://github.com/blakeblackshear/frigate-hass-addons/blob/main/frigate_proxy/README.md).
@@ -208,6 +234,112 @@ To install make sure you have the [community app plugin here](https://forums.unr
 
 It is recommended to run Frigate in LXC for maximum performance. See [this discussion](https://github.com/blakeblackshear/frigate/discussions/1111) for more information.
 
-## ESX
+## ESXi
+
+For details on running Frigate using ESXi, please see the instructions [here](https://williamlam.com/2023/05/frigate-nvr-with-coral-tpu-igpu-passthrough-using-esxi-on-intel-nuc.html).
+
+## Synology NAS on DSM 7
+
+These settings were tested on DSM 7.1.1-42962 Update 4
+
+
+**General:**
+
+The `Execute container using high privilege` option needs to be enabled in order to give the frigate container the elevated privileges it may need.
+
+The `Enable auto-restart` option can be enabled if you want the container to automatically restart whenever it improperly shuts down due to an error.	
+
+![image](https://user-images.githubusercontent.com/4516296/232586790-0b659a82-561d-4bc5-899b-0f5b39c6b11d.png)
+
+
+**Advanced Settings:**
+
+If you want to use the password template feature, you should add the "FRIGATE_RTSP_PASSWORD" environment variable and set it to your preferred password under advanced settings. The rest of the environment variables should be left as default for now.
+
+![image](https://user-images.githubusercontent.com/4516296/232587163-0eb662d4-5e28-4914-852f-9db1ec4b9c3d.png)
+
+
+**Port Settings:**
+
+The network mode should be set to `bridge`. You need to map the default frigate container ports to your local Synology NAS ports that you want to use to access Frigate.
+
+There may be other services running on your NAS that are using the same ports that frigate uses. In that instance you can set the ports to auto or a specific port.
+
+![image](https://user-images.githubusercontent.com/4516296/232582642-773c0e37-7ef5-4373-8ce3-41401b1626e6.png)
+
+
+**Volume Settings:**
+
+You need to configure 2 paths:
+
+- The location of your config file in yaml format, this needs to be file and you need to go to the location of where your config.yml is located, this will be different depending on your NAS folder structure e.g. `/docker/frigate/config/config.yml` will mount to `/config/config.yml` within the container.
+- The location on your NAS where the recordings will be saved this needs to be a folder e.g. `/docker/volumes/frigate-0-media`
+
+![image](https://user-images.githubusercontent.com/4516296/232585872-44431d15-55e0-4004-b78b-1e512702b911.png)
+
+## QNAP NAS
+
+These instructions were tested on a QNAP with an Intel J3455 CPU and 16G RAM, running QTS 4.5.4.2117.
+
+QNAP has a graphic tool named Container Station to intall and manage docker containers.  However, there are two limitations with Container Station that make it unsuitable to install Frigate:
+
+1. Container Station does not incorporate GitHub Container Registry (ghcr), which hosts Frigate docker image version 0.12.0 and above.
+2. Container Station uses default 64 Mb shared memory size (shm-size), and does not have a mechanism to adjust it.  Frigate requires a larger shm-size to be able to work properly with more than two high resolution cameras.
+
+Because of above limitations, the installation has to be done from command line.  Here are the steps:
+
+**Preparation**
+1. Install Container Station from QNAP App Center if it is not installed.
+2. Enable ssh on your QNAP (please do an Internet search on how to do this).
+3. Prepare Frigate config file, name it `config.yml`.
+4. Calculate shared memory size according to [documentation](https://docs.frigate.video/frigate/installation).
+5. Find your time zone value from https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+6. ssh to QNAP.
+
+**Installation**
+
+Run the following commands to install Frigate (using `stable` version as example):
+```bash
+# Download Frigate image
+docker pull ghcr.io/blakeblackshear/frigate:stable
+# Create directory to host Frigate config file on QNAP file system.
+# E.g., you can choose to create it under /share/Container.
+mkdir -p /share/Container/frigate/config
+# Copy the config file prepared in step 2 into the newly created config directory.
+cp path/to/your/config/file /share/Container/frigate/config
+# Create directory to host Frigate media files on QNAP file system.
+# (if you have a surveilliance disk, create media directory on the surveilliance disk.
+# Example command assumes share_vol2 is the surveilliance drive
+mkdir -p /share/share_vol2/frigate/media
+# Create Frigate docker container.  Replace shm-size value with the value from preparation step 3.
+# Also replace the time zone value for 'TZ' in the sample command.
+# Example command will create a docker container that uses at most 2 CPUs and 4G RAM.
+# You may need to add "--env=LIBVA_DRIVER_NAME=i965 \" to the following docker run command if you
+# have certain CPU (e.g., J4125). See https://docs.frigate.video/configuration/hardware_acceleration.
+docker run \
+  --name=frigate \
+  --shm-size=256m \
+  --restart=unless-stopped \
+  --env=TZ=America/New_York \
+  --volume=/share/Container/frigate/config:/config:rw \
+  --volume=/share/share_vol2/frigate/media:/media/frigate:rw \
+  --network=bridge \
+  --privileged \
+  --workdir=/opt/frigate \
+  -p 1935:1935 \
+  -p 5000:5000 \
+  -p 8554:8554 \
+  -p 8555:8555 \
+  -p 8555:8555/udp \
+  --label='com.qnap.qcs.network.mode=nat' \
+  --label='com.qnap.qcs.gpu=False' \
+  --memory="4g" \
+  --cpus="2" \
+  --detach=true \
+  -t \
+  ghcr.io/blakeblackshear/frigate:stable
+```
+
+Log into QNAP, open Container Station.  Frigate docker container should be listed under 'Overview' and running.  Visit Frigate Web UI by clicking Frigate docker, and then clicking the URL shown at the top of the detail page.
+
 
-For details on running Frigate under ESX, see details [here](https://github.com/blakeblackshear/frigate/issues/305).

docs/docs/guides/configuring_go2rtc.md

@@ -0,0 +1,83 @@
+---
+id: configuring_go2rtc
+title: Configuring go2rtc
+---
+
+Use of the bundled go2rtc is optional. You can still configure FFmpeg to connect directly to your cameras. However, adding go2rtc to your configuration is required for the following features:
+
+- WebRTC or MSE for live viewing with higher resolutions and frame rates than the jsmpeg stream which is limited to the detect stream
+- RTSP (instead of RTMP) relay for use with Home Assistant or other consumers to reduce the number of connections to your camera streams
+
+# Setup a go2rtc stream
+
+First, you will want to configure go2rtc to connect to your camera stream by adding the stream you want to use for live view in your Frigate config file. If you set the stream name under go2rtc to match the name of your camera, it will automatically be mapped and you will get additional live view options for the camera. Avoid changing any other parts of your config at this step. Note that go2rtc supports [many different stream types](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#module-streams), not just rtsp.
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+```
+
+The easiest live view to get working is MSE. After adding this to the config, restart Frigate and try to watch the live stream by selecting MSE in the dropdown after clicking on the camera.
+
+### What if my video doesn't play?
+
+If you are unable to see your video feed, first check the go2rtc logs in the Frigate UI under Logs in the sidebar. If go2rtc is having difficulty connecting to your camera, you should see some error messages in the log. If you do not see any errors, then the video codec of the stream may not be supported in your browser. If your camera stream is set to H265, try switching to H264. You can see more information about [video codec compatibility](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#codecs-madness) in the go2rtc documentation. If you are not able to switch your camera settings from H265 to H264 or your stream is a different format such as MJPEG, you can use go2rtc to re-encode the video using the [FFmpeg parameters](https://github.com/AlexxIT/go2rtc/tree/v1.2.0#source-ffmpeg). It supports rotating and resizing video feeds and hardware acceleration. Keep in mind that transcoding video from one format to another is a resource intensive task and you may be better off using the built-in jsmpeg view. Here is an example of a config that will re-encode the stream to H264 without hardware acceleration:
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+      - "ffmpeg:back#video=h264"
+```
+
+Some camera streams may need to use the ffmpeg module in go2rtc. This has the downside of slower startup times, but has compatibility with more stream types.
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - ffmpeg:rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+```
+
+If you can see the video but do not have audio, this is most likely because your camera's audio stream is not AAC. If possible, update your camera's audio settings to AAC. If your cameras do not support AAC audio, you will need to tell go2rtc to re-encode the audio to AAC on demand if you want audio. This will use additional CPU and add some latency. To add AAC audio on demand, you can update your go2rtc config as follows:
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+      - "ffmpeg:back#audio=aac"
+```
+
+If you need to convert **both** the audio and video streams, you can use the following:
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+      - "ffmpeg:back#video=h264#audio=aac"
+```
+
+When using the ffmpeg module, you would add AAC audio like this:
+
+```yaml
+go2rtc:
+  streams:
+    back:
+      - "ffmpeg:rtsp://user:password@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2#video=copy#audio=copy#audio=aac"
+```
+
+:::caution
+
+To access the go2rtc stream externally when utilizing the Frigate Add-On (for instance through VLC), you must first enable the RTSP Restream port. You can do this by visiting the Frigate Add-On configuration page within Home Assistant and revealing the hidden options under the "Show disabled ports" section.
+
+:::
+
+## Next steps
+
+1. If the stream you added to go2rtc is also used by Frigate for the `record` or `detect` role, you can migrate your config to pull from the RTSP restream to reduce the number of connections to your camera as shown [here](/configuration/restream#reduce-connections-to-camera).
+1. You may also prefer to [setup WebRTC](/configuration/live#webrtc-extra-configuration) for slightly lower latency than MSE. Note that WebRTC only supports h264 and specific audio formats.

docs/docs/guides/events_setup.md

@@ -1,10 +0,0 @@
----
-id: events_setup
-title: Setting Up Events
----
-
-[Snapshots](../configuration/snapshots.md) and/or [Recordings](../configuration/record.md) must be enabled for events to be created for detected objects.
-
-## Limiting Events to Areas of Interest
-
-The best way to limit events to areas of interest is to use [zones](../configuration/zones.md) along with `required_zones` for events and snapshots to only have events created in areas of interest.

docs/docs/guides/false_positives.md

@@ -20,4 +20,4 @@ For object filters in your configuration, any single detection below `min_score`
 | 5     | 0.88          | 0.7, 0.85, 0.95, 0.90, 0.88       | 0.88           | Yes             |
 | 6     | 0.95          | 0.7, 0.85, 0.95, 0.90, 0.88, 0.95 | 0.89           | Yes             |
 
-In frame 2, the score is below the `min_score` value, so frigate ignores it and it becomes a 0.0. The computed score is the median of the score history (padding to at least 3 values), and only when that computed score crosses the `threshold` is the object marked as a true positive. That happens in frame 4 in the example.
+In frame 2, the score is below the `min_score` value, so Frigate ignores it and it becomes a 0.0. The computed score is the median of the score history (padding to at least 3 values), and only when that computed score crosses the `threshold` is the object marked as a true positive. That happens in frame 4 in the example.

docs/docs/guides/getting_started.md

@@ -1,124 +1,81 @@
 ---
 id: getting_started
-title: Creating a config file
+title: Getting started
 ---
 
-This guide walks through the steps to build a configuration file for Frigate. It assumes that you already have an environment setup as described in [Installation](../frigate/installation.md). You should also configure your cameras according to the [camera setup guide](/guides/camera_setup)
+This guide walks through the steps to build a configuration file for Frigate. It assumes that you already have an environment setup as described in [Installation](../frigate/installation.md). You should also configure your cameras according to the [camera setup guide](/frigate/camera_setup). Pay particular attention to the section on choosing a detect resolution.
 
-### Step 1: Configure the MQTT server (Optional)
+### Step 1: Add a detect stream
 
-Use of a functioning MQTT server is optional for frigate, but required for the home assistant integration. Start by adding the mqtt section at the top level in your config:
+First we will add the detect stream for the camera:
 
-If using mqtt:
-```yaml
-mqtt:
-  host: <ip of your mqtt server>
-```
-
-If not using mqtt:
 ```yaml
 mqtt:
   enabled: False
-```
-
-If using the Mosquitto Addon in Home Assistant, a username and password is required. For example:
-
-```yaml
-mqtt:
-  host: <ip of your mqtt server>
-  user: <username>
-  password: <password>
-```
-
-Frigate supports many configuration options for mqtt. See the [configuration reference](../configuration/index.md#full-configuration-reference) for more info.
-
-### Step 2: Configure detectors
-
-By default, Frigate will use a single CPU detector. If you have a USB Coral, you will need to add a detectors section to your config.
-
-```yaml
-mqtt:
-  host: <ip of your mqtt server>
-
-detectors:
-  coral:
-    type: edgetpu
-    device: usb
-```
-
-More details on available detectors can be found [here](../configuration/detectors.md).
-
-### Step 3: Add a minimal camera configuration
-
-Now let's add the first camera:
-
-```yaml
-mqtt:
-  host: <ip of your mqtt server>
-
-detectors:
-  coral:
-    type: edgetpu
-    device: usb
 
 cameras:
-  camera_1: # <------ Name the camera
+  name_of_your_camera: # <------ Name the camera
     ffmpeg:
       inputs:
-        - path: rtsp://10.0.10.10:554/rtsp # <----- Update for your camera
+        - path: rtsp://10.0.10.10:554/rtsp # <----- The stream you want to use for detection
           roles:
             - detect
-            - rtmp
-    rtmp:
-      enabled: False # <-- RTMP should be disabled if your stream is not H264
     detect:
+      enabled: False # <---- disable detection until you have a working camera feed
       width: 1280 # <---- update for your camera's resolution
       height: 720 # <---- update for your camera's resolution
 ```
 
-### Step 4: Start Frigate
+### Step 2: Start Frigate
 
 At this point you should be able to start Frigate and see the the video feed in the UI.
 
-If you get a green image from the camera, this means ffmpeg was not able to get the video feed from your camera. Check the logs for error messages from ffmpeg. The default ffmpeg arguments are designed to work with H264 RTSP cameras that support TCP connections. If you do not have H264 cameras, make sure you have disabled RTMP. It is possible to enable it, but you must tell ffmpeg to re-encode the video with customized output args.
+If you get an error image from the camera, this means ffmpeg was not able to get the video feed from your camera. Check the logs for error messages from ffmpeg. The default ffmpeg arguments are designed to work with H264 RTSP cameras that support TCP connections.
 
 FFmpeg arguments for other types of cameras can be found [here](../configuration/camera_specific.md).
 
-### Step 5: Configure hardware acceleration (optional)
+### Step 3: Configure hardware acceleration (recommended)
 
 Now that you have a working camera configuration, you want to setup hardware acceleration to minimize the CPU required to decode your video streams. See the [hardware acceleration](../configuration/hardware_acceleration.md) config reference for examples applicable to your hardware.
 
-In order to best evaluate the performance impact of hardware acceleration, it is recommended to temporarily disable detection.
+Here is an example configuration with hardware acceleration configured for Intel processors with an integrated GPU using the [preset](../configuration/ffmpeg_presets.md):
 
 ```yaml
 mqtt: ...
 
-detectors: ...
-
 cameras:
-  camera_1:
-    ffmpeg: ...
-    detect:
-      enabled: False
-      ...
-```
-
-Here is an example configuration with hardware acceleration configured:
-
-```yaml
-mqtt: ...
-
-detectors: ...
-
-cameras:
-  camera_1:
+  name_of_your_camera:
     ffmpeg:
       inputs: ...
-      hwaccel_args: -c:v h264_v4l2m2m
+      hwaccel_args: preset-vaapi
     detect: ...
 ```
 
-### Step 6: Setup motion masks
+### Step 4: Configure detectors
+
+By default, Frigate will use a single CPU detector. If you have a USB Coral, you will need to add a detectors section to your config.
+
+```yaml
+mqtt: ...
+
+detectors: # <---- add detectors
+  coral:
+    type: edgetpu
+    device: usb
+
+cameras:
+  name_of_your_camera:
+    ffmpeg: ...
+    detect:
+      enabled: True # <---- turn on detection
+      ...
+```
+
+More details on available detectors can be found [here](../configuration/detectors.md).
+
+Restart Frigate and you should start seeing detections for `person`. If you want to track other objects, they will need to be added according to the [configuration file reference](../configuration/index.md#full-configuration-reference).
+
+### Step 5: Setup motion masks
 
 Now that you have optimized your configuration for decoding the video stream, you will want to check to see where to implement motion masks. To do this, navigate to the camera in the UI, select "Debug" at the top, and enable "Motion boxes" in the options below the video feed. Watch for areas that continuously trigger unwanted motion to be detected. Common areas to mask include camera timestamps and trees that frequently blow in the wind. The goal is to avoid wasting object detection cycles looking at these areas.
 
@@ -134,7 +91,7 @@ Your configuration should look similar to this now.
 
 ```yaml
 mqtt:
-  host: mqtt.local
+  enabled: False
 
 detectors:
   coral:
@@ -142,13 +99,12 @@ detectors:
     device: usb
 
 cameras:
-  camera_1:
+  name_of_your_camera:
     ffmpeg:
       inputs:
         - path: rtsp://10.0.10.10:554/rtsp
           roles:
             - detect
-            - rtmp
     detect:
       width: 1280
       height: 720
@@ -157,9 +113,13 @@ cameras:
         - 0,461,3,0,1919,0,1919,843,1699,492,1344,458,1346,336,973,317,869,375,866,432
 ```
 
-### Step 7: Enable recording (optional)
+### Step 6: Enable recording and/or snapshots
 
-To enable recording video, add the `record` role to a stream and enable it in the config.
+In order to see Events in the Frigate UI, either snapshots or record will need to be enabled.
+
+#### Record
+
+To enable recording video, add the `record` role to a stream and enable it in the config. If record is disabled in the config, turning it on via the UI will not have any effect.
 
 ```yaml
 mqtt: ...
@@ -167,14 +127,13 @@ mqtt: ...
 detectors: ...
 
 cameras:
-  camera_1:
+  name_of_your_camera:
     ffmpeg:
       inputs:
         - path: rtsp://10.0.10.10:554/rtsp
           roles:
             - detect
-            - rtmp
-        - path: rtsp://10.0.10.10:554/high_res_stream # <----- Add high res stream
+        - path: rtsp://10.0.10.10:554/high_res_stream # <----- Add stream you want to record from
           roles:
             - record
     detect: ...
@@ -187,9 +146,9 @@ If you don't have separate streams for detect and record, you would just add the
 
 By default, Frigate will retain video of all events for 10 days. The full set of options for recording can be found [here](../configuration/index.md#full-configuration-reference).
 
-### Step 8: Enable snapshots (optional)
+#### Snapshots
 
-To enable snapshots of your events, just enable it in the config.
+To enable snapshots of your events, just enable it in the config. Snapshots are taken from the detect stream because it is the only stream decoded.
 
 ```yaml
 mqtt: ...
@@ -197,7 +156,7 @@ mqtt: ...
 detectors: ...
 
 cameras:
-  camera_1: ...
+  name_of_your_camera: ...
     detect: ...
     record: ...
     snapshots: # <----- Enable snapshots
@@ -206,3 +165,10 @@ cameras:
 ```
 
 By default, Frigate will retain snapshots of all events for 10 days. The full set of options for snapshots can be found [here](../configuration/index.md#full-configuration-reference).
+
+### Step 7: Follow up guides
+
+Now that you have a working install, you can use the following guides for additional features:
+
+1. [Configuring go2rtc](configuring_go2rtc) - Additional live view options and RTSP relay
+2. [Home Assistant Integration](../integrations/home-assistant.md) - Integrate with Home Assistant

docs/docs/guides/ha_notifications.md

@@ -3,11 +3,11 @@ id: ha_notifications
 title: Home Assistant notifications
 ---
 
-The best way to get started with notifications for Frigate is to use the [Blueprint](https://community.home-assistant.io/t/frigate-mobile-app-notifications/311091). You can use the yaml generated from the Blueprint as a starting point and customize from there.
+The best way to get started with notifications for Frigate is to use the [Blueprint](https://community.home-assistant.io/t/frigate-mobile-app-notifications-2-0/559732). You can use the yaml generated from the Blueprint as a starting point and customize from there.
 
 It is generally recommended to trigger notifications based on the `frigate/events` mqtt topic. This provides the event_id needed to fetch [thumbnails/snapshots/clips](../integrations/home-assistant.md#notification-api) and other useful information to customize when and where you want to receive alerts. The data is published in the form of a change feed, which means you can reference the "previous state" of the object in the `before` section and the "current state" of the object in the `after` section. You can see an example [here](../integrations/mqtt.md#frigateevents).
 
-Here is a simple example of a notification automation of events which will update the existing notification for each change. This means the image you see in the notification will update as frigate finds a "better" image.
+Here is a simple example of a notification automation of events which will update the existing notification for each change. This means the image you see in the notification will update as Frigate finds a "better" image.
 
 ```yaml
 automation:
@@ -45,7 +45,7 @@ automation:
               https://your.public.hass.address.com/api/frigate/notifications/{{trigger.payload_json["after"]["id"]}}/thumbnail.jpg
             tag: '{{trigger.payload_json["after"]["id"]}}'
             when: '{{trigger.payload_json["after"]["start_time"]|int}}'
-            entity_id: camera.{{trigger.payload_json["after"]["camera"]}}
+            entity_id: camera.{{trigger.payload_json["after"]["camera"] | replace("-","_") | lower}}
     mode: single
 ```
 

docs/docs/guides/reverse_proxy.md

@@ -1,6 +1,6 @@
 ---
 id: reverse_proxy
-title: Setting up a Reverse Proxy
+title: Setting up a reverse proxy
 ---
 
 This guide outlines the basic configuration steps needed to expose your Frigate UI to the internet.
@@ -8,6 +8,7 @@ A common way of accomplishing this is to use a reverse proxy webserver between y
 A reverse proxy accepts HTTP requests from the public internet and redirects them transparently to internal webserver(s) on your network.
 
 The suggested steps are:
+
 - **Configure** a 'proxy' HTTP webserver (such as [Apache2](https://httpd.apache.org/docs/current/) or [NPM](https://github.com/NginxProxyManager/nginx-proxy-manager)) and only expose ports 80/443 from this webserver to the internet
 - **Encrypt** content from the proxy webserver by installing SSL (such as with [Let's Encrypt](https://letsencrypt.org/)). Note that SSL is then not required on your Frigate webserver as the proxy encrypts all requests for you
 - **Restrict** access to your Frigate instance at the proxy using, for example, password authentication
@@ -31,6 +32,7 @@ On Debian Apache2 the configuration file will be named along the lines of `/etc/
 
 Make life easier for yourself by presenting your Frigate interface as a DNS sub-domain rather than as a sub-folder of your main domain.
 Here we access Frigate via https://cctv.mydomain.co.uk
+
 ```xml
 <VirtualHost *:443>
     ServerName cctv.mydomain.co.uk
@@ -38,7 +40,7 @@ Here we access Frigate via https://cctv.mydomain.co.uk
     ProxyPreserveHost On
     ProxyPass "/"  "http://frigatepi.local:5000/"
     ProxyPassReverse "/"  "http://frigatepi.local:5000/"
-    
+
     ProxyPass /ws ws://frigatepi.local:5000/ws
     ProxyPassReverse /ws ws://frigatepi.local:5000/ws
 
@@ -82,3 +84,61 @@ There are many ways to authenticate a website but a straightforward approach is
     </Location>
 </VirtualHost>
 ```
+
+## Nginx Reverse Proxy
+
+This method shows a working example for subdomain type reverse proxy with SSL enabled. 
+
+### Setup server and port to reverse proxy
+
+This is set in `$server` and `$port` this should match your ports you have exposed to your docker container.  Optionally you listen on port `443` and enable `SSL`
+
+```
+# ------------------------------------------------------------
+# frigate.domain.com
+# ------------------------------------------------------------
+
+server {
+  set $forward_scheme http;
+  set $server         "192.168.100.2"; # FRIGATE SERVER LOCATION
+  set $port           5000;
+
+  listen 80;
+  listen 443 ssl http2;
+
+  server_name frigate.domain.com;
+}
+```
+
+### Setup SSL (optional)
+
+This section points to your SSL files, the example below shows locations to a default Lets Encrypt SSL certificate. 
+
+```
+  # Let's Encrypt SSL
+  include conf.d/include/letsencrypt-acme-challenge.conf;
+  include conf.d/include/ssl-ciphers.conf;
+  ssl_certificate /etc/letsencrypt/live/npm-1/fullchain.pem;
+  ssl_certificate_key /etc/letsencrypt/live/npm-1/privkey.pem;
+```
+
+
+### Setup reverse proxy settings 
+
+Thhe settings below enabled connection upgrade, sets up logging (optional) and proxies everything from the `/` context to the docker host and port specified earlier in the configuration
+
+```
+  proxy_set_header Upgrade $http_upgrade;
+  proxy_set_header Connection $http_connection;
+  proxy_http_version 1.1;
+
+  access_log /data/logs/proxy-host-40_access.log proxy;
+  error_log /data/logs/proxy-host-40_error.log warn;
+
+  location / {
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection $http_connection;
+    proxy_http_version 1.1;
+  }
+
+```

docs/docs/guides/stationary_objects.md

@@ -3,7 +3,7 @@ id: stationary_objects
 title: Avoiding stationary objects
 ---
 
-Many people use Frigate to detect cars entering their driveway, and they often run into an issue with repeated events of a parked car being repeatedly detected over the course of multiple days (for example if the car is lost at night and detected again the following morning.
+Many people use Frigate to detect cars entering their driveway, and they often run into an issue with repeated notifications or events of a parked car being repeatedly detected over the course of multiple days (for example if the car is lost at night and detected again the following morning).
 
 You can use zones to restrict events and notifications to objects that have entered specific areas.
 
@@ -15,6 +15,12 @@ Frigate is designed to track objects as they move and over-masking can prevent i
 
 :::
 
+:::info
+
+Once a vehicle crosses the entrance into the parking area, that event will stay `In Progress` until it is no longer seen in the frame. Frigate is designed to have an event last as long as an object is visible in the frame, an event being `In Progress` does not mean the event is being constantly recorded. You can define the recording behavior by adjusting the [recording retention settings](../configuration/record.md).
+
+:::
+
 To only be notified of cars that enter your driveway from the street, you could create multiple zones that cover your driveway. For cars, you would only notify if `entered_zones` from the events MQTT topic has more than 1 zone.
 
 See [this example](../configuration/zones.md#restricting-zones-to-specific-objects) from the Zones documentation to see how to restrict zones to certain object types.

docs/docs/integrations/api.md

@@ -26,7 +26,7 @@ You can access a higher resolution mjpeg stream by appending `h=height-in-pixels
 
 ### `GET /api/<camera_name>/latest.jpg[?h=300]`
 
-The most recent frame that frigate has finished processing. It is a full resolution image by default.
+The most recent frame that Frigate has finished processing. It is a full resolution image by default.
 
 Accepts the following query string parameters:
 
@@ -63,7 +63,7 @@ Sample response:
     "camera_fps": 5.0,
     /***************
      * Number of times detection is run per second. This can be higher than
-     * your camera FPS because frigate often looks at the same frame multiple times
+     * your camera FPS because Frigate often looks at the same frame multiple times
      * or in multiple locations
      ***************/
     "detection_fps": 1.5,
@@ -76,11 +76,11 @@ Sample response:
      ***************/
     "pid": 34,
     /***************
-     * Frames per second being processed by frigate.
+     * Frames per second being processed by Frigate.
      ***************/
     "process_fps": 5.1,
     /***************
-     * Frames per second skip for processing by frigate.
+     * Frames per second skip for processing by Frigate.
      ***************/
     "skipped_fps": 0.0
   },
@@ -166,6 +166,7 @@ Events from the database. Accepts the following query string parameters:
 | `has_snapshot`       | int  | Filter to events that have snapshots (0 or 1) |
 | `has_clip`           | int  | Filter to events that have clips (0 or 1)     |
 | `include_thumbnails` | int  | Include thumbnails in the response (0 or 1)   |
+| `in_progress`        | int  | Limit to events in progress (0 or 1)          |
 
 ### `GET /api/events/summary`
 

docs/docs/integrations/home-assistant.md

@@ -16,6 +16,8 @@ See the [MQTT integration
 documentation](https://www.home-assistant.io/integrations/mqtt/) for more
 details.
 
+In addition, MQTT must be enabled in your Frigate configuration file and Frigate must be connected to the same MQTT server as Home Assistant for many of the entities created by the integration to function.
+
 ### Integration installation
 
 Available via HACS as a default repository. To install:
@@ -30,7 +32,7 @@ Home Assistant > HACS > Integrations > "Explore & Add Integrations" > Frigate
 - Then add/configure the integration:
 
 ```
-Home Assistant > Configuration > Integrations > Add Integration > Frigate
+Home Assistant > Settings > Devices & Services > Add Integration > Frigate
 ```
 
 Note: You will also need
@@ -45,7 +47,7 @@ that card.
 
 ## Configuration
 
-When configuring the integration, you will be asked for the `URL` of your frigate instance which is the URL you use to access Frigate in the browser. This may look like `http://<host>:5000/`. If you are using HassOS with the addon, the URL should be one of the following depending on which addon version you are using. Note that if you are using the Proxy Addon, you do NOT point the integration at the proxy URL. Just enter the URL used to access frigate directly from your network.
+When configuring the integration, you will be asked for the `URL` of your Frigate instance which is the URL you use to access Frigate in the browser. This may look like `http://<host>:5000/`. If you are using HassOS with the addon, the URL should be one of the following depending on which addon version you are using. Note that if you are using the Proxy Addon, you do NOT point the integration at the proxy URL. Just enter the URL used to access Frigate directly from your network.
 
 | Addon Version                  | URL                                    |
 | ------------------------------ | -------------------------------------- |
@@ -64,13 +66,13 @@ Home Assistant > Configuration > Integrations > Frigate > Options
 
 | Option            | Description                                                                                                                                                                                                                                                                                                                          |
 | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| RTMP URL Template | A [jinja2](https://jinja.palletsprojects.com/) template that is used to override the standard RTMP stream URL (e.g. for use with reverse proxies). This option is only shown to users who have [advanced mode](https://www.home-assistant.io/blog/2019/07/17/release-96/#advanced-mode) enabled. See [RTMP streams](#streams) below. |
+| RTSP URL Template | A [jinja2](https://jinja.palletsprojects.com/) template that is used to override the standard RTSP stream URL (e.g. for use with reverse proxies). This option is only shown to users who have [advanced mode](https://www.home-assistant.io/blog/2019/07/17/release-96/#advanced-mode) enabled. See [RTSP streams](#streams) below. |
 
 ## Entities Provided
 
 | Platform        | Description                                                                       |
 | --------------- | --------------------------------------------------------------------------------- |
-| `camera`        | Live camera stream (requires RTMP), camera for image of the last detected object. |
+| `camera`        | Live camera stream (requires RTSP), camera for image of the last detected object. |
 | `sensor`        | States to monitor Frigate performance, object counts for all zones and cameras.   |
 | `switch`        | Switch entities to toggle detection, recordings and snapshots.                    |
 | `binary_sensor` | A "motion" binary sensor entity per camera/zone/object.                           |
@@ -124,13 +126,17 @@ https://HA_URL/api/frigate/notifications/<event-id>/clip.mp4
 
 ## RTMP stream
 
-In order for the live streams to function they need to be accessible on the RTMP
-port (default: `1935`) at `<frigatehost>:1935`. Home Assistant will directly
+RTMP is deprecated and it is recommended to switch to use RTSP restreams.
+
+## RTSP stream
+
+In order for the live streams to function they need to be accessible on the RTSP
+port (default: `8554`) at `<frigatehost>:8554`. Home Assistant will directly
 connect to that streaming port when the live camera is viewed.
 
-#### RTMP URL Template
+#### RTSP URL Template
 
-For advanced usecases, this behavior can be changed with the [RTMP URL
+For advanced usecases, this behavior can be changed with the [RTSP URL
 template](#options) option. When set, this string will override the default stream
 address that is derived from the default behavior described above. This option supports
 [jinja2 templates](https://jinja.palletsprojects.com/) and has the `camera` dict
@@ -142,24 +148,24 @@ This is potentially useful when Frigate is behind a reverse proxy, and/or when
 the default stream port is otherwise not accessible to Home Assistant (e.g.
 firewall rules).
 
-###### RTMP URL Template Examples
+###### RTSP URL Template Examples
 
 Use a different port number:
 
 ```
-rtmp://<frigate_host>:2000/live/front_door
+rtsp://<frigate_host>:2000/front_door
 ```
 
 Use the camera name in the stream URL:
 
 ```
-rtmp://<frigate_host>:2000/live/{{ name }}
+rtsp://<frigate_host>:2000/{{ name }}
 ```
 
 Use the camera name in the stream URL, converting it to lowercase first:
 
 ```
-rtmp://<frigate_host>:2000/live/{{ name|lower }}
+rtsp://<frigate_host>:2000/{{ name|lower }}
 ```
 
 ## Multiple Instance Support

docs/docs/integrations/mqtt.md

@@ -8,12 +8,12 @@ These are the MQTT messages generated by Frigate. The default topic_prefix is `f
 ### `frigate/available`
 
 Designed to be used as an availability topic with Home Assistant. Possible message are:
-"online": published when frigate is running (on startup)
-"offline": published right before frigate stops
+"online": published when Frigate is running (on startup)
+"offline": published right before Frigate stops
 
 ### `frigate/restart`
 
-Causes frigate to exit. Docker should be configured to automatically restart the container on exit.
+Causes Frigate to exit. Docker should be configured to automatically restart the container on exit.
 
 ### `frigate/<camera_name>/<object_name>`
 
@@ -34,7 +34,7 @@ The height and crop of snapshots can be configured in the config.
 
 ### `frigate/events`
 
-Message published for each changed event. The first message is published when the tracked object is no longer marked as a false_positive. When frigate finds a better snapshot of the tracked object or when a zone change occurs, it will publish a message with the same id. When the event ends, a final message is published with `end_time` set.
+Message published for each changed event. The first message is published when the tracked object is no longer marked as a false_positive. When Frigate finds a better snapshot of the tracked object or when a zone change occurs, it will publish a message with the same id. When the event ends, a final message is published with `end_time` set.
 
 ```json
 {

docs/docs/integrations/plus.md

@@ -0,0 +1,54 @@
+---
+id: plus
+title: Frigate+
+---
+
+:::info
+
+Frigate+ is under active development and currently only offers the ability to submit your examples with annotations. Models will be available after enough examples are submitted to train a robust model. It is free to create an account and upload your examples.
+
+:::
+
+Frigate+ offers models trained from scratch and specifically designed for the way Frigate NVR analyzes video footage. They offer higher accuracy with less resources. By uploading your own labeled examples, your model can be uniquely tuned for accuracy in your specific conditions. After tuning, performance is evaluated against a broad dataset and real world examples submitted by other Frigate+ users to prevent overfitting.
+
+Custom models also include a more relevant set of objects for security cameras such as person, face, car, license plate, delivery truck, package, dog, cat, deer, and more. Interested in detecting an object unique to you? Upload examples to incorporate your own objects without worrying that you are reducing the accuracy of other object types in the model.
+
+## Setup
+
+### Create an account
+
+Free accounts can be created at [https://plus.frigate.video](https://plus.frigate.video).
+
+### Generate an API key
+
+Once logged in, you can generate an API key for Frigate in Settings.
+
+![API key](/img/plus-api-key-min.png)
+
+### Set your API key
+
+In Frigate, you can set the `PLUS_API_KEY` environment variable to enable the `SEND TO FRIGATE+` buttons on the events page. You can set it in your Docker Compose file or in your Docker run command. Home Assistant Addon users can set it under Settings > Addons > Frigate NVR > Configuration > Options (be sure to toggle the "Show unused optional configuration options" switch).
+
+:::caution
+
+You cannot use the `environment_vars` section of your configuration file to set this environment variable.
+
+:::
+
+### Submit examples
+
+Once your API key is configured, you can submit examples directly from the events page in Frigate using the `SEND TO FRIGATE+` button.
+
+:::note
+
+Snapshots must be enabled to be able to submit examples to Frigate+
+
+:::
+
+![Send To Plus](/img/send-to-plus.png)
+
+### Annotate and verify
+
+You can view all of your submitted images at [https://plus.frigate.video](https://plus.frigate.video). Annotations can be added by clicking an image.
+
+![Annotate](/img/annotate.png)

docs/docs/integrations/third_party_extensions.md

@@ -0,0 +1,20 @@
+---
+id: third_party_extensions
+title: Third Party Extensions
+---
+
+Being open source, others have the possibility to modify and extend the rich functionality Frigate already offers.
+This page is meant to be an overview over additions one can make to the home NVR setup. The list is not exhaustive and can be extended via PR to the Frigate docs.
+
+:::caution
+
+This page does not recommend or rate the presented projects.
+Please use your own knowledge to assess and vet them before you install anything on your system.
+
+:::
+
+## [Double Take](https://github.com/skrashevich/double-take)
+
+[Double Take](https://github.com/skrashevich/double-take) provides an unified UI and API for processing and training images for facial recognition.
+It supports automatically setting the sub labels in Frigate for person objects that are detected and recognized.
+This is a fork (with fixed errors and new features) of [original Double Take](https://github.com/jakowenko/double-take) project which, unfortunately, isn't being maintained by author.

docs/docs/troubleshooting/faqs.md

@@ -7,38 +7,27 @@ title: Frequently Asked Questions
 
 This error message is due to a shm-size that is too small. Try updating your shm-size according to [this guide](../frigate/installation.md#calculating-required-shm-size).
 
-### I am seeing a solid green image for my camera.
-
-A solid green image means that frigate has not received any frames from ffmpeg. Check the logs to see why ffmpeg is exiting and adjust your ffmpeg args accordingly.
-
 ### How can I get sound or audio in my recordings? {#audio-in-recordings}
 
-By default, Frigate removes audio from recordings to reduce the likelihood of failing for invalid data. If you would like to include audio, you need to override the output args to remove `-an` for where you want to include audio. The recommended audio codec is `aac`. Not all audio codecs are supported by RTMP, so you may need to re-encode your audio with `-c:a aac`. The default ffmpeg args are shown [here](../configuration/index.md/#full-configuration-reference).
+By default, Frigate removes audio from recordings to reduce the likelihood of failing for invalid data. If you would like to include audio, you need to set a [FFmpeg preset](/configuration/ffmpeg_presets) that supports audio:
 
-:::tip
-
-When using `-c:a aac`, do not forget to replace `-c copy` with `-c:v copy`. Example:
-
-```diff title="frigate.yml"
+```yaml title="frigate.yml"
 ffmpeg:
   output_args:
--    record: -f segment -segment_time 10 -segment_format mp4 -reset_timestamps 1 -strftime 1 -c copy -an
-+    record: -f segment -segment_time 10 -segment_format mp4 -reset_timestamps 1 -strftime 1 -c:v copy -c:a aac
+    record: preset-record-generic-audio-aac
 ```
 
-This is needed because the `-c` flag (without `:a` or `:v`) applies for both audio and video, thus making it conflicting with `-c:a aac`.
-
-:::
-
-### My mjpeg stream or snapshots look green and crazy
-
-This almost always means that the width/height defined for your camera are not correct. Double check the resolution with vlc or another player. Also make sure you don't have the width and height values backwards.
-
-![mismatched-resolution](/img/mismatched-resolution-min.jpg)
-
 ### I can't view events or recordings in the Web UI.
 
-Ensure your cameras send h264 encoded video
+Ensure your cameras send h264 encoded video, or [transcode them](/configuration/restream.md).
+
+You can open `chrome://media-internals/` in another tab and then try to playback, the media internals page will give information about why playback is failing.
+
+### My mjpeg stream or snapshots look green and crazy
+
+This almost always means that the width/height defined for your camera are not correct. Double check the resolution with VLC or another player. Also make sure you don't have the width and height values backwards.
+
+![mismatched-resolution](/img/mismatched-resolution-min.jpg)
 
 ### "[mov,mp4,m4a,3gp,3g2,mj2 @ 0x5639eeb6e140] moov atom not found"
 
@@ -46,8 +35,8 @@ These messages in the logs are expected in certain situations. Frigate checks th
 
 ### "On connect called"
 
-If you see repeated "On connect called" messages in your config, check for another instance of frigate. This happens when multiple frigate containers are trying to connect to mqtt with the same client_id.
+If you see repeated "On connect called" messages in your logs, check for another instance of Frigate. This happens when multiple Frigate containers are trying to connect to MQTT with the same `client_id`.
 
 ### Error: Database Is Locked
 
-sqlite does not work well on a network share, if the `/media` folder is mapped to a network share then [this guide](../configuration/advanced.md#database) should be used to move the database to a location on the internal drive.
+SQLite does not work well on a network share, if the `/media` folder is mapped to a network share then [this guide](../configuration/advanced.md#database) should be used to move the database to a location on the internal drive.

docs/docusaurus.config.js

@@ -13,7 +13,7 @@ module.exports = {
   themeConfig: {
     algolia: {
       appId: 'WIURGBNBPY',
-      apiKey: '81ec882db78f7fed05c51daf973f0362',
+      apiKey: 'd02cc0a6a61178b25da550212925226b',
       indexName: 'frigate',
     },
     docs: {

docs/sidebars.js

@@ -4,11 +4,11 @@ module.exports = {
       "frigate/index",
       "frigate/hardware",
       "frigate/installation",
+      "frigate/camera_setup",
     ],
     Guides: [
-      "guides/camera_setup",
       "guides/getting_started",
-      "guides/events_setup",
+      "guides/configuring_go2rtc",
       "guides/false_positives",
       "guides/ha_notifications",
       "guides/stationary_objects",
@@ -33,9 +33,11 @@ module.exports = {
       "configuration/ffmpeg_presets",
     ],
     Integrations: [
+      "integrations/plus",
       "integrations/home-assistant",
       "integrations/api",
       "integrations/mqtt",
+      "integrations/third_party_extensions",
     ],
     Troubleshooting: [
       "troubleshooting/faqs",