update sample config

Frigate provides an HTTP server that can be used to detect if frigate is running or not. Using the docker-compose "healthcheck" feature we can set automations to restart the service if it stops working.

.dockerignore

@@ -1,7 +1,6 @@
 README.md
-docs/
+diagram.png
 .gitignore
 debug
 config/
-*.pyc
-.git
+*.pyc

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,6 +1,6 @@
 ---
-name: Bug report or Support request
-about: ''
+name: Bug report
+about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
@@ -8,25 +8,25 @@ assignees: ''
 ---
 
 **Describe the bug**
-A clear and concise description of what your issue is.
+A clear and concise description of what the bug is.
 
 **Version of frigate**
-Output from `/version`
+What version are you using?
 
 **Config file**
-Include your full config file wrapped in triple back ticks.
-```yaml
+Include your full config file wrapped in back ticks.
+```
 config here
 ```
 
-**Frigate container logs**
+**Logs**
 ```
 Include relevant log output here
 ```
 
-**Frigate stats**
-```json
-Output from frigate's /stats endpoint
+**Frigate debug stats**
+```
+Output from frigate's /debug/stats endpoint
 ```
 
 **FFprobe from your camera**
@@ -41,7 +41,6 @@ If applicable, add screenshots to help explain your problem.
 
 **Computer Hardware**
  - OS: [e.g. Ubuntu, Windows]
- - Install method: [e.g. Addon, Docker Compose, Docker Command]
  - Virtualization: [e.g. Proxmox, Virtualbox]
  - Coral Version: [e.g. USB, PCIe, None]
  - Network Setup: [e.g. Wired, WiFi]

.gitignore

@@ -1,8 +1,4 @@
 *.pyc 
 debug
 .vscode
-config/config.yml
-models
-*.mp4
-*.db
-frigate/version.py
+config/config.yml

Makefile

@@ -1,54 +1,37 @@
 default_target: amd64_frigate
 
-COMMIT_HASH := $(shell git log -1 --pretty=format:"%h")
-
-version:
-	echo "VERSION='0.8.0-$(COMMIT_HASH)'" > frigate/version.py
-
 amd64_wheels:
 	docker build --tag blakeblackshear/frigate-wheels:amd64 --file docker/Dockerfile.wheels .
 
 amd64_ffmpeg:
-	docker build --tag blakeblackshear/frigate-ffmpeg:1.1.0-amd64 --file docker/Dockerfile.ffmpeg.amd64 .
+	docker build --tag blakeblackshear/frigate-ffmpeg:amd64 --file docker/Dockerfile.ffmpeg.amd64 .
 
-amd64_frigate: version
-	docker build --tag frigate-base --build-arg ARCH=amd64 --build-arg FFMPEG_VERSION=1.1.0 --file docker/Dockerfile.base .
+amd64_frigate:
+	docker build --tag frigate-base --build-arg ARCH=amd64 --file docker/Dockerfile.base .
 	docker build --tag frigate --file docker/Dockerfile.amd64 .
 
 amd64_all: amd64_wheels amd64_ffmpeg amd64_frigate
 
-amd64nvidia_wheels:
-	docker build --tag blakeblackshear/frigate-wheels:amd64nvidia --file docker/Dockerfile.wheels .
+arm64_wheels:
+	docker build --tag blakeblackshear/frigate-wheels:arm64 --file docker/Dockerfile.wheels.arm64 .
 
-amd64nvidia_ffmpeg:
-	docker build --tag blakeblackshear/frigate-ffmpeg:1.0.0-amd64nvidia --file docker/Dockerfile.ffmpeg.amd64nvidia .
+arm64_ffmpeg:
+	docker build --tag blakeblackshear/frigate-ffmpeg:arm64 --file docker/Dockerfile.ffmpeg.arm64 .
 
-amd64nvidia_frigate: version
-	docker build --tag frigate-base --build-arg ARCH=amd64nvidia --build-arg FFMPEG_VERSION=1.0.0 --file docker/Dockerfile.base .
-	docker build --tag frigate --file docker/Dockerfile.amd64nvidia .
+arm64_frigate:
+	docker build --tag frigate-base --build-arg ARCH=arm64 --file docker/Dockerfile.base .
+	docker build --tag frigate --file docker/Dockerfile.arm64 .
 
-amd64nvidia_all: amd64nvidia_wheels amd64nvidia_ffmpeg amd64nvidia_frigate
+armv7hf_all: arm64_wheels arm64_ffmpeg arm64_frigate
 
-aarch64_wheels:
-	docker build --tag blakeblackshear/frigate-wheels:aarch64 --file docker/Dockerfile.wheels.aarch64 .
+armv7hf_wheels:
+	docker build --tag blakeblackshear/frigate-wheels:armv7hf --file docker/Dockerfile.wheels .
 
-aarch64_ffmpeg:
-	docker build --tag blakeblackshear/frigate-ffmpeg:1.0.0-aarch64 --file docker/Dockerfile.ffmpeg.aarch64 .
+armv7hf_ffmpeg:
+	docker build --tag blakeblackshear/frigate-ffmpeg:armv7hf --file docker/Dockerfile.ffmpeg.armv7hf .
 
-aarch64_frigate: version
-	docker build --tag frigate-base --build-arg ARCH=aarch64 --build-arg FFMPEG_VERSION=1.0.0 --file docker/Dockerfile.base .
-	docker build --tag frigate --file docker/Dockerfile.aarch64 .
+armv7hf_frigate:
+	docker build --tag frigate-base --build-arg ARCH=armv7hf --file docker/Dockerfile.base .
+	docker build --tag frigate --file docker/Dockerfile.armv7hf .
 
-armv7_all: armv7_wheels armv7_ffmpeg armv7_frigate
-
-armv7_wheels:
-	docker build --tag blakeblackshear/frigate-wheels:armv7 --file docker/Dockerfile.wheels .
-
-armv7_ffmpeg:
-	docker build --tag blakeblackshear/frigate-ffmpeg:1.0.0-armv7 --file docker/Dockerfile.ffmpeg.armv7 .
-
-armv7_frigate: version
-	docker build --tag frigate-base --build-arg ARCH=armv7 --build-arg FFMPEG_VERSION=1.0.0 --file docker/Dockerfile.base .
-	docker build --tag frigate --file docker/Dockerfile.armv7 .
-
-armv7_all: armv7_wheels armv7_ffmpeg armv7_frigate
+armv7hf_all: armv7hf_wheels armv7hf_ffmpeg armv7hf_frigate

config/config.example.yml

@@ -0,0 +1,232 @@
+web_port: 5000
+
+################
+## List of detectors.
+## Currently supported types: cpu, edgetpu
+## EdgeTPU requires device as defined here: https://coral.ai/docs/edgetpu/multiple-edgetpu/#using-the-tensorflow-lite-python-api
+################
+detectors:
+  coral:
+    type: edgetpu
+    device: usb
+
+mqtt:
+  host: mqtt.server.com
+  topic_prefix: frigate
+  # client_id: frigate # Optional -- set to override default client id of 'frigate' if running multiple instances
+  # user: username # Optional
+  #################
+  ## Environment variables that begin with 'FRIGATE_' may be referenced in {}.
+  ##   password: '{FRIGATE_MQTT_PASSWORD}'
+  #################
+  # password: password # Optional
+
+################
+# Global configuration for saving clips
+################
+save_clips:
+  ###########
+  # Maximum length of time to retain video during long events.
+  # If an object is being tracked for longer than this amount of time, the cache  
+  # will begin to expire and the resulting clip will be the last x seconds of the event.
+  ###########
+  max_seconds: 300
+
+#################
+# Default ffmpeg args. Optional and can be overwritten per camera.
+# Should work with most RTSP cameras that send h264 video
+# Built from the properties below with:
+# "ffmpeg" + global_args + input_args + "-i" + input + output_args
+#################
+# ffmpeg:
+#   global_args:
+#     - -hide_banner
+#     - -loglevel
+#     - panic
+#   hwaccel_args: []
+#   input_args:
+#     - -avoid_negative_ts
+#     - make_zero
+#     - -fflags
+#     - nobuffer
+#     - -flags
+#     - low_delay
+#     - -strict
+#     - experimental
+#     - -fflags
+#     - +genpts+discardcorrupt
+#     - -vsync
+#     - drop
+#     - -rtsp_transport
+#     - tcp
+#     - -stimeout
+#     - '5000000'
+#     - -use_wallclock_as_timestamps
+#     - '1'
+#   output_args:
+#     - -f
+#     - rawvideo
+#     - -pix_fmt
+#     - yuv420p
+
+####################
+# Global object configuration. Applies to all cameras
+# unless overridden at the camera levels.
+# Keys must be valid labels. By default, the model uses coco (https://dl.google.com/coral/canned_models/coco_labels.txt).
+# All labels from the model are reported over MQTT. These values are used to filter out false positives.
+# min_area (optional): minimum width*height of the bounding box for the detected object
+# max_area (optional): maximum width*height of the bounding box for the detected object
+# min_score (optional): minimum score for the object to initiate tracking
+# threshold (optional): The minimum decimal percentage for tracked object's computed score to considered a true positive
+####################
+objects:
+  track:
+    - person
+  filters:
+    person:
+      min_area: 5000
+      max_area: 100000
+      min_score: 0.5
+      threshold: 0.85
+
+cameras:
+  back:
+    ffmpeg:
+      ################
+      # Source passed to ffmpeg after the -i parameter. Supports anything compatible with OpenCV and FFmpeg.
+      # Environment variables that begin with 'FRIGATE_' may be referenced in {}
+      ################
+      input: rtsp://viewer:{FRIGATE_RTSP_PASSWORD}@10.0.10.10:554/cam/realmonitor?channel=1&subtype=2
+      #################
+      # These values will override default values for just this camera
+      #################
+      # global_args: []
+      # hwaccel_args: []
+      # input_args: []
+      # output_args: []
+    
+    ################
+    ## Optionally specify the resolution of the video feed. Frigate will try to auto detect if not specified
+    ################
+    # height: 1280
+    # width: 720
+
+    ################
+    ## Specify the framerate of your camera
+    ##
+    ## NOTE: This should only be set in the event ffmpeg is unable to determine your camera's framerate
+    ##       on its own and the reported framerate for your camera in frigate is well over what is expected.
+    ################
+    # fps: 5
+
+    ################
+    ## Optional mask. Must be the same aspect ratio as your video feed. Value is any of the following:
+    ##   - name of a file in the config directory
+    ##   - base64 encoded image prefixed with 'base64,' eg. 'base64,asfasdfasdf....'
+    ##   - polygon of x,y coordinates prefixed with 'poly,' eg. 'poly,0,900,1080,900,1080,1920,0,1920'
+    ## 
+    ## The mask works by looking at the bottom center of the bounding box for the detected
+    ## person in the image. If that pixel in the mask is a black pixel, it ignores it as a
+    ## false positive. In my mask, the grass and driveway visible from my backdoor camera 
+    ## are white. The garage doors, sky, and trees (anywhere it would be impossible for a 
+    ## person to stand) are black.
+    ## 
+    ## Masked areas are also ignored for motion detection.
+    ################
+    # mask: back-mask.bmp
+
+    ################
+    # Allows you to limit the framerate within frigate for cameras that do not support
+    # custom framerates. A value of 1 tells frigate to look at every frame, 2 every 2nd frame, 
+    # 3 every 3rd frame, etc.
+    ################
+    take_frame: 1
+
+    ################
+    # The number of seconds to retain the highest scoring image for the best.jpg endpoint before allowing it
+    # to be replaced by a newer image. Defaults to 60 seconds.
+    ################
+    best_image_timeout: 60
+
+    ################
+    # MQTT settings
+    ################
+    # mqtt:
+    #   crop_to_region: True
+    #   snapshot_height: 300
+
+    ################
+    # Zones
+    ################
+    zones:
+      #################
+      # Name of the zone
+      ################
+      front_steps:
+        ####################
+        # A list of x,y coordinates to define the polygon of the zone. The top 
+        # left corner is 0,0. Can also be a comma separated string of all x,y coordinates combined.
+        # The same zone name can exist across multiple cameras if they have overlapping FOVs.
+        # An object is determined to be in the zone based on whether or not the bottom center
+        # of it's bounding box is within the polygon. The polygon must have at least 3 points.
+        # Coordinates can be generated at https://www.image-map.net/
+        ####################
+        coordinates:
+          - 545,1077
+          - 747,939
+          - 788,805
+        ################
+        # Zone level object filters. These are applied in addition to the global and camera filters
+        # and should be more restrictive than the global and camera filters. The global and camera
+        # filters are applied upstream.
+        ################
+        filters:
+          person:
+            min_area: 5000
+            max_area: 100000
+            threshold: 0.8
+
+    ################
+    # This will save a clip for each tracked object by frigate along with a json file that contains
+    # data related to the tracked object. This works by telling ffmpeg to write video segments to /cache
+    # from the video stream without re-encoding. Clips are then created by using ffmpeg to merge segments
+    # without re-encoding. The segments saved are unaltered from what frigate receives to avoid re-encoding.
+    # They do not contain bounding boxes. These are optimized to capture "false_positive" examples for improving frigate.
+    #
+    # NOTE: This feature does not work if you have "-vsync drop" configured in your input params. 
+    #       This will only work for camera feeds that can be copied into the mp4 container format without
+    #       encoding such as h264. It may not work for some types of streams.
+    ################
+    save_clips:
+      enabled: False
+      #########
+      # Number of seconds before the event to include in the clips
+      #########
+      pre_capture: 30
+      #########
+      # Objects to save clips for. Defaults to all tracked object types.
+      #########
+      # objects:
+      #   - person      
+
+    ################
+    # Configuration for the snapshots in the debug view and mqtt
+    ################
+    snapshots:
+      show_timestamp: True
+      draw_zones: False
+      draw_bounding_boxes: True
+
+    ################
+    # Camera level object config. If defined, this is used instead of the global config.
+    ################
+    objects:
+      track:
+        - person
+        - car
+      filters:
+        person:
+          min_area: 5000
+          max_area: 100000
+          min_score: 0.5
+          threshold: 0.85

detect_objects.py

@@ -0,0 +1,465 @@
+import faulthandler; faulthandler.enable()
+import os
+import signal
+import sys
+import traceback
+import signal
+import cv2
+import time
+import datetime
+import queue
+import yaml
+import threading
+import multiprocessing as mp
+import subprocess as sp
+import numpy as np
+import logging
+from flask import Flask, Response, make_response, jsonify, request
+import paho.mqtt.client as mqtt
+
+from frigate.video import track_camera, get_ffmpeg_input, get_frame_shape, CameraCapture, start_or_restart_ffmpeg
+from frigate.object_processing import TrackedObjectProcessor
+from frigate.events import EventProcessor
+from frigate.util import EventsPerSecond
+from frigate.edgetpu import EdgeTPUProcess
+
+FRIGATE_VARS = {k: v for k, v in os.environ.items() if k.startswith('FRIGATE_')}
+
+with open('/config/config.yml') as f:
+    CONFIG = yaml.safe_load(f)
+
+MQTT_HOST = CONFIG['mqtt']['host']
+MQTT_PORT = CONFIG.get('mqtt', {}).get('port', 1883)
+MQTT_TOPIC_PREFIX = CONFIG.get('mqtt', {}).get('topic_prefix', 'frigate')
+MQTT_USER = CONFIG.get('mqtt', {}).get('user')
+MQTT_PASS = CONFIG.get('mqtt', {}).get('password')
+if not MQTT_PASS is None:
+    MQTT_PASS = MQTT_PASS.format(**FRIGATE_VARS)
+MQTT_CLIENT_ID = CONFIG.get('mqtt', {}).get('client_id', 'frigate')
+
+# Set the default FFmpeg config
+FFMPEG_CONFIG = CONFIG.get('ffmpeg', {})
+FFMPEG_DEFAULT_CONFIG = {
+    'global_args': FFMPEG_CONFIG.get('global_args', 
+        ['-hide_banner','-loglevel','panic']),
+    'hwaccel_args': FFMPEG_CONFIG.get('hwaccel_args',
+        []),
+    'input_args': FFMPEG_CONFIG.get('input_args',
+        ['-avoid_negative_ts', 'make_zero',
+         '-fflags', 'nobuffer',
+         '-flags', 'low_delay',
+         '-strict', 'experimental',
+         '-fflags', '+genpts+discardcorrupt',
+         '-rtsp_transport', 'tcp',
+         '-stimeout', '5000000',
+         '-use_wallclock_as_timestamps', '1']),
+    'output_args': FFMPEG_CONFIG.get('output_args',
+        ['-f', 'rawvideo',
+         '-pix_fmt', 'yuv420p'])
+}
+
+GLOBAL_OBJECT_CONFIG = CONFIG.get('objects', {})
+
+WEB_PORT = CONFIG.get('web_port', 5000)
+DETECTORS = CONFIG.get('detectors', {'coral': {'type': 'edgetpu', 'device': 'usb'}})
+
+class CameraWatchdog(threading.Thread):
+    def __init__(self, camera_processes, config, detectors, detection_queue, tracked_objects_queue, stop_event):
+        threading.Thread.__init__(self)
+        self.camera_processes = camera_processes
+        self.config = config
+        self.detectors = detectors
+        self.detection_queue = detection_queue
+        self.tracked_objects_queue = tracked_objects_queue
+        self.stop_event = stop_event
+
+    def run(self):
+        time.sleep(10)
+        while True:
+            # wait a bit before checking
+            time.sleep(10)
+
+            if self.stop_event.is_set():
+                print(f"Exiting watchdog...")
+                break
+
+            now = datetime.datetime.now().timestamp()
+
+            # check the detection processes
+            for detector in self.detectors.values():
+                detection_start = detector.detection_start.value
+                if (detection_start > 0.0 and 
+                    now - detection_start > 10):
+                    print("Detection appears to be stuck. Restarting detection process")
+                    detector.start_or_restart()
+                elif not detector.detect_process.is_alive():
+                    print("Detection appears to have stopped. Restarting detection process")
+                    detector.start_or_restart()
+
+            # check the camera processes
+            for name, camera_process in self.camera_processes.items():
+                process = camera_process['process']
+                if not process.is_alive():
+                    print(f"Track process for {name} is not alive. Starting again...")
+                    camera_process['process_fps'].value = 0.0
+                    camera_process['detection_fps'].value = 0.0
+                    camera_process['read_start'].value = 0.0
+                    process = mp.Process(target=track_camera, args=(name, self.config[name], camera_process['frame_queue'],
+                        camera_process['frame_shape'], self.detection_queue, self.tracked_objects_queue, 
+                        camera_process['process_fps'], camera_process['detection_fps'],
+                        camera_process['read_start'], self.stop_event))
+                    process.daemon = True
+                    camera_process['process'] = process
+                    process.start()
+                    print(f"Track process started for {name}: {process.pid}")
+                
+                if not camera_process['capture_thread'].is_alive():
+                    frame_shape = camera_process['frame_shape']
+                    frame_size = frame_shape[0] * frame_shape[1] * frame_shape[2]
+                    ffmpeg_process = start_or_restart_ffmpeg(camera_process['ffmpeg_cmd'], frame_size)
+                    camera_capture = CameraCapture(name, ffmpeg_process, frame_shape, camera_process['frame_queue'], 
+                        camera_process['take_frame'], camera_process['camera_fps'], self.stop_event)
+                    camera_capture.start()
+                    camera_process['ffmpeg_process'] = ffmpeg_process
+                    camera_process['capture_thread'] = camera_capture
+                elif now - camera_process['capture_thread'].current_frame.value > 5:
+                    print(f"No frames received from {name} in 5 seconds. Exiting ffmpeg...")
+                    ffmpeg_process = camera_process['ffmpeg_process']
+                    ffmpeg_process.terminate()
+                    try:
+                        print("Waiting for ffmpeg to exit gracefully...")
+                        ffmpeg_process.communicate(timeout=30)
+                    except sp.TimeoutExpired:
+                        print("FFmpeg didnt exit. Force killing...")
+                        ffmpeg_process.kill()
+                        ffmpeg_process.communicate()
+
+def main():
+    stop_event = threading.Event()
+    # connect to mqtt and setup last will
+    def on_connect(client, userdata, flags, rc):
+        print("On connect called")
+        if rc != 0:
+            if rc == 3:
+                print ("MQTT Server unavailable")
+            elif rc == 4:
+                print ("MQTT Bad username or password")
+            elif rc == 5:
+                print ("MQTT Not authorized")
+            else:
+                print ("Unable to connect to MQTT: Connection refused. Error code: " + str(rc))
+        # publish a message to signal that the service is running
+        client.publish(MQTT_TOPIC_PREFIX+'/available', 'online', retain=True)
+    client = mqtt.Client(client_id=MQTT_CLIENT_ID)
+    client.on_connect = on_connect
+    client.will_set(MQTT_TOPIC_PREFIX+'/available', payload='offline', qos=1, retain=True)
+    if not MQTT_USER is None:
+        client.username_pw_set(MQTT_USER, password=MQTT_PASS)
+    client.connect(MQTT_HOST, MQTT_PORT, 60)
+    client.loop_start()
+
+    ##
+    # Setup config defaults for cameras
+    ##
+    for name, config in CONFIG['cameras'].items():
+        config['snapshots'] = {
+            'show_timestamp': config.get('snapshots', {}).get('show_timestamp', True),
+            'draw_zones': config.get('snapshots', {}).get('draw_zones', False),
+            'draw_bounding_boxes': config.get('snapshots', {}).get('draw_bounding_boxes', True)
+        }
+        config['zones'] = config.get('zones', {})
+
+    # Queue for cameras to push tracked objects to
+    tracked_objects_queue = mp.Queue()
+
+    # Queue for clip processing
+    event_queue = mp.Queue()
+
+    # create the detection pipes and shms
+    out_events = {}
+    camera_shms = []
+    for name in CONFIG['cameras'].keys():
+        out_events[name] = mp.Event()
+        shm_in = mp.shared_memory.SharedMemory(name=name, create=True, size=300*300*3)
+        shm_out = mp.shared_memory.SharedMemory(name=f"out-{name}", create=True, size=20*6*4)
+        camera_shms.append(shm_in)
+        camera_shms.append(shm_out)
+
+    detection_queue = mp.Queue()
+
+    detectors = {}
+    for name, detector in DETECTORS.items():
+        if detector['type'] == 'cpu':
+            detectors[name] = EdgeTPUProcess(detection_queue, out_events=out_events, tf_device='cpu')
+        if detector['type'] == 'edgetpu':
+            detectors[name] = EdgeTPUProcess(detection_queue, out_events=out_events, tf_device=detector['device'])
+
+    # create the camera processes
+    camera_processes = {}
+    for name, config in CONFIG['cameras'].items():
+        # Merge the ffmpeg config with the global config
+        ffmpeg = config.get('ffmpeg', {})
+        ffmpeg_input = get_ffmpeg_input(ffmpeg['input'])
+        ffmpeg_global_args = ffmpeg.get('global_args', FFMPEG_DEFAULT_CONFIG['global_args'])
+        ffmpeg_hwaccel_args = ffmpeg.get('hwaccel_args', FFMPEG_DEFAULT_CONFIG['hwaccel_args'])
+        ffmpeg_input_args = ffmpeg.get('input_args', FFMPEG_DEFAULT_CONFIG['input_args'])
+        ffmpeg_output_args = ffmpeg.get('output_args', FFMPEG_DEFAULT_CONFIG['output_args'])
+        if not config.get('fps') is None:
+            ffmpeg_output_args = ["-r", str(config.get('fps'))] + ffmpeg_output_args
+        if config.get('save_clips', {}).get('enabled', False):
+            ffmpeg_output_args = [
+                "-f",
+                "segment",
+                "-segment_time",
+                "10",
+                "-segment_format",
+                "mp4",
+                "-reset_timestamps",
+                "1",
+                "-strftime",
+                "1",
+                "-c",
+                "copy",
+                "-an",
+                "-map",
+                "0",
+                f"/cache/{name}-%Y%m%d%H%M%S.mp4"
+            ] + ffmpeg_output_args
+        ffmpeg_cmd = (['ffmpeg'] +
+                ffmpeg_global_args +
+                ffmpeg_hwaccel_args +
+                ffmpeg_input_args +
+                ['-i', ffmpeg_input] +
+                ffmpeg_output_args +
+                ['pipe:'])
+        
+        if 'width' in config and 'height' in config:
+            frame_shape = (config['height'], config['width'], 3)
+        else:
+            frame_shape = get_frame_shape(ffmpeg_input)
+        
+        config['frame_shape'] = frame_shape
+
+        frame_size = frame_shape[0] * frame_shape[1] * frame_shape[2]
+        take_frame = config.get('take_frame', 1)
+
+        detection_frame = mp.Value('d', 0.0)
+
+        ffmpeg_process = start_or_restart_ffmpeg(ffmpeg_cmd, frame_size)
+        frame_queue = mp.Queue(maxsize=2)
+        camera_fps = EventsPerSecond()
+        camera_fps.start()
+        camera_capture = CameraCapture(name, ffmpeg_process, frame_shape, frame_queue, take_frame, camera_fps, stop_event)
+        camera_capture.start()
+
+        camera_processes[name] = {
+            'camera_fps': camera_fps,
+            'take_frame': take_frame,
+            'process_fps': mp.Value('d', 0.0),
+            'detection_fps': mp.Value('d', 0.0),
+            'detection_frame': detection_frame,
+            'read_start': mp.Value('d', 0.0),
+            'ffmpeg_process': ffmpeg_process,
+            'ffmpeg_cmd': ffmpeg_cmd,
+            'frame_queue': frame_queue,
+            'frame_shape': frame_shape,
+            'capture_thread': camera_capture
+        }
+
+        # merge global object config into camera object config
+        camera_objects_config = config.get('objects', {})
+        # get objects to track for camera
+        objects_to_track = camera_objects_config.get('track', GLOBAL_OBJECT_CONFIG.get('track', ['person']))
+        # get object filters
+        object_filters = camera_objects_config.get('filters', GLOBAL_OBJECT_CONFIG.get('filters', {}))
+        config['objects'] = {
+            'track': objects_to_track,
+            'filters': object_filters
+        }
+
+        camera_process = mp.Process(target=track_camera, args=(name, config, frame_queue, frame_shape,
+            detection_queue, out_events[name], tracked_objects_queue, camera_processes[name]['process_fps'], 
+            camera_processes[name]['detection_fps'], 
+            camera_processes[name]['read_start'], camera_processes[name]['detection_frame'], stop_event))
+        camera_process.daemon = True
+        camera_processes[name]['process'] = camera_process
+
+    # start the camera_processes
+    for name, camera_process in camera_processes.items():
+        camera_process['process'].start()
+        print(f"Camera_process started for {name}: {camera_process['process'].pid}")
+
+    event_processor = EventProcessor(CONFIG, camera_processes, '/cache', '/clips', event_queue, stop_event)
+    event_processor.start()
+    
+    object_processor = TrackedObjectProcessor(CONFIG['cameras'], client, MQTT_TOPIC_PREFIX, tracked_objects_queue, event_queue, stop_event)
+    object_processor.start()
+    
+    camera_watchdog = CameraWatchdog(camera_processes, CONFIG['cameras'], detectors, detection_queue, tracked_objects_queue, stop_event)
+    camera_watchdog.start()
+
+    def receiveSignal(signalNumber, frame):
+        print('Received:', signalNumber)
+        stop_event.set()
+        event_processor.join()
+        object_processor.join()
+        camera_watchdog.join()
+        for camera_name, camera_process in camera_processes.items():
+            camera_process['capture_thread'].join()
+            # cleanup the frame queue
+            while not camera_process['frame_queue'].empty():
+                frame_time = camera_process['frame_queue'].get()
+                shm = mp.shared_memory.SharedMemory(name=f"{camera_name}{frame_time}")
+                shm.close()
+                shm.unlink()
+
+        for detector in detectors.values():
+            detector.stop()
+        for shm in camera_shms:
+            shm.close()
+            shm.unlink()
+        sys.exit()
+    
+    signal.signal(signal.SIGTERM, receiveSignal)
+    signal.signal(signal.SIGINT, receiveSignal)
+
+    # create a flask app that encodes frames a mjpeg on demand
+    app = Flask(__name__)
+    log = logging.getLogger('werkzeug')
+    log.setLevel(logging.ERROR)
+
+    @app.route('/')
+    def ishealthy():
+        # return a healh
+        return "Frigate is running. Alive and healthy!"
+
+    @app.route('/debug/stack')
+    def processor_stack():
+        frame = sys._current_frames().get(object_processor.ident, None)
+        if frame:
+            return "<br>".join(traceback.format_stack(frame)), 200
+        else:
+            return "no frame found", 200
+
+    @app.route('/debug/print_stack')
+    def print_stack():
+        pid = int(request.args.get('pid', 0))
+        if pid == 0:
+            return "missing pid", 200
+        else:
+            os.kill(pid, signal.SIGUSR1)
+            return "check logs", 200
+
+    @app.route('/debug/stats')
+    def stats():
+        stats = {}
+
+        total_detection_fps = 0
+
+        for name, camera_stats in camera_processes.items():
+            total_detection_fps += camera_stats['detection_fps'].value
+            capture_thread = camera_stats['capture_thread']
+            stats[name] = {
+                'camera_fps': round(capture_thread.fps.eps(), 2),
+                'process_fps': round(camera_stats['process_fps'].value, 2),
+                'skipped_fps': round(capture_thread.skipped_fps.eps(), 2),
+                'detection_fps': round(camera_stats['detection_fps'].value, 2),
+                'read_start': camera_stats['read_start'].value,
+                'pid': camera_stats['process'].pid,
+                'ffmpeg_pid': camera_stats['ffmpeg_process'].pid,
+                'frame_info': {
+                    'read': capture_thread.current_frame.value,
+                    'detect': camera_stats['detection_frame'].value,
+                    'process': object_processor.camera_data[name]['current_frame_time']
+                }
+            }
+        
+        stats['detectors'] = {}
+        for name, detector in detectors.items():
+            stats['detectors'][name] = {
+                'inference_speed': round(detector.avg_inference_speed.value*1000, 2),
+                'detection_start': detector.detection_start.value,
+                'pid': detector.detect_process.pid
+            }
+        stats['detection_fps'] = round(total_detection_fps, 2)
+
+        return jsonify(stats)
+
+    @app.route('/<camera_name>/<label>/best.jpg')
+    def best(camera_name, label):
+        if camera_name in CONFIG['cameras']:
+            best_object = object_processor.get_best(camera_name, label)
+            best_frame = best_object.get('frame')
+            if best_frame is None:
+                best_frame = np.zeros((720,1280,3), np.uint8)
+            else:
+                best_frame = cv2.cvtColor(best_frame, cv2.COLOR_YUV2BGR_I420)
+            
+            crop = bool(request.args.get('crop', 0, type=int))
+            if crop:
+                region = best_object.get('region', [0,0,300,300])
+                best_frame = best_frame[region[1]:region[3], region[0]:region[2]]
+            
+            height = int(request.args.get('h', str(best_frame.shape[0])))
+            width = int(height*best_frame.shape[1]/best_frame.shape[0])
+
+            best_frame = cv2.resize(best_frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
+            ret, jpg = cv2.imencode('.jpg', best_frame)
+            response = make_response(jpg.tobytes())
+            response.headers['Content-Type'] = 'image/jpg'
+            return response
+        else:
+            return "Camera named {} not found".format(camera_name), 404
+
+    @app.route('/<camera_name>')
+    def mjpeg_feed(camera_name):
+        fps = int(request.args.get('fps', '3'))
+        height = int(request.args.get('h', '360'))
+        if camera_name in CONFIG['cameras']:
+            # return a multipart response
+            return Response(imagestream(camera_name, fps, height),
+                            mimetype='multipart/x-mixed-replace; boundary=frame')
+        else:
+            return "Camera named {} not found".format(camera_name), 404
+    
+    @app.route('/<camera_name>/latest.jpg')
+    def latest_frame(camera_name):
+        if camera_name in CONFIG['cameras']:
+            # max out at specified FPS
+            frame = object_processor.get_current_frame(camera_name)
+            if frame is None:
+                frame = np.zeros((720,1280,3), np.uint8)
+
+            height = int(request.args.get('h', str(frame.shape[0])))
+            width = int(height*frame.shape[1]/frame.shape[0])
+
+            frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
+
+            ret, jpg = cv2.imencode('.jpg', frame)
+            response = make_response(jpg.tobytes())
+            response.headers['Content-Type'] = 'image/jpg'
+            return response
+        else:
+            return "Camera named {} not found".format(camera_name), 404
+            
+    def imagestream(camera_name, fps, height):
+        while True:
+            # max out at specified FPS
+            time.sleep(1/fps)
+            frame = object_processor.get_current_frame(camera_name, draw=True)
+            if frame is None:
+                frame = np.zeros((height,int(height*16/9),3), np.uint8)
+
+            width = int(height*frame.shape[1]/frame.shape[0])
+            frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_LINEAR)
+
+            ret, jpg = cv2.imencode('.jpg', frame)
+            yield (b'--frame\r\n'
+                b'Content-Type: image/jpeg\r\n\r\n' + jpg.tobytes() + b'\r\n\r\n')
+
+    app.run(host='0.0.0.0', port=WEB_PORT, debug=False)
+
+    object_processor.join()
+
+if __name__ == '__main__':
+    main()

docker/Dockerfile.amd64

@@ -1,18 +1,16 @@
 FROM frigate-base
 LABEL maintainer "blakeb@blakeshome.com"
 
-# By default, use the i965 driver
-ENV LIBVA_DRIVER_NAME=i965
 # Install packages for apt repo
 RUN apt-get -qq update \
     && apt-get -qq install --no-install-recommends -y \
         # ffmpeg dependencies
         libgomp1 \
         # VAAPI drivers for Intel hardware accel
-        libva-drm2 libva2 libmfx1 i965-va-driver vainfo intel-media-va-driver mesa-va-drivers \
+        libva-drm2 libva2 i965-va-driver vainfo \
         ## Tensorflow lite
-    && wget -q https://github.com/google-coral/pycoral/releases/download/release-frogfish/tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
-    && python3.8 -m pip install tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
-    && rm tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
+    && wget -q https://dl.google.com/coral/python/tflite_runtime-2.1.0.post1-cp38-cp38-linux_x86_64.whl \
+    && python3.8 -m pip install tflite_runtime-2.1.0.post1-cp38-cp38-linux_x86_64.whl \
+    && rm tflite_runtime-2.1.0.post1-cp38-cp38-linux_x86_64.whl \
     && rm -rf /var/lib/apt/lists/* \
     && (apt-get autoremove -y; apt-get autoclean -y)

docker/Dockerfile.amd64nvidia

@@ -1,47 +0,0 @@
-FROM frigate-base
-LABEL maintainer "blakeb@blakeshome.com"
-
-# Install packages for apt repo
-RUN apt-get -qq update \
-    && apt-get -qq install --no-install-recommends -y \
-        # ffmpeg dependencies
-        libgomp1 \
-        ## Tensorflow lite
-    && wget -q https://github.com/google-coral/pycoral/releases/download/release-frogfish/tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
-    && python3.8 -m pip install tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
-    && rm tflite_runtime-2.5.0-cp38-cp38-linux_x86_64.whl \
-    && rm -rf /var/lib/apt/lists/* \
-    && (apt-get autoremove -y; apt-get autoclean -y)
-
-
-# nvidia layer (see https://gitlab.com/nvidia/container-images/cuda/blob/master/dist/11.1/ubuntu20.04-x86_64/base/Dockerfile)
-ENV	    NVIDIA_DRIVER_CAPABILITIES compute,utility,video
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    gnupg2 curl ca-certificates && \
-    curl -fsSL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/7fa2af80.pub | apt-key add - && \
-    echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/cuda.list && \
-    echo "deb https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu2004/x86_64 /" > /etc/apt/sources.list.d/nvidia-ml.list && \
-    apt-get purge --autoremove -y curl \
-    && rm -rf /var/lib/apt/lists/*
-
-ENV CUDA_VERSION 11.1.1
-
-# For libraries in the cuda-compat-* package: https://docs.nvidia.com/cuda/eula/index.html#attachment-a
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    cuda-cudart-11-1=11.1.74-1 \
-    cuda-compat-11-1 \
-    && ln -s cuda-11.1 /usr/local/cuda && \
-    rm -rf /var/lib/apt/lists/*
-
-# Required for nvidia-docker v1
-RUN echo "/usr/local/nvidia/lib" >> /etc/ld.so.conf.d/nvidia.conf && \
-    echo "/usr/local/nvidia/lib64" >> /etc/ld.so.conf.d/nvidia.conf
-
-ENV PATH /usr/local/nvidia/bin:/usr/local/cuda/bin:${PATH}
-ENV LD_LIBRARY_PATH /usr/local/nvidia/lib:/usr/local/nvidia/lib64
-
-# nvidia-container-runtime
-ENV NVIDIA_VISIBLE_DEVICES all
-ENV NVIDIA_DRIVER_CAPABILITIES compute,utility,video
-ENV NVIDIA_REQUIRE_CUDA "cuda>=11.1 brand=tesla,driver>=418,driver<419 brand=tesla,driver>=440,driver<441 brand=tesla,driver>=450,driver<451"

docker/Dockerfile.arm64

@@ -17,6 +17,6 @@ RUN apt-get -qq update \
         libtiff5 \
         libdc1394-22 \
     ## Tensorflow lite
-    && pip3 install https://github.com/google-coral/pycoral/releases/download/release-frogfish/tflite_runtime-2.5.0-cp38-cp38-linux_aarch64.whl \
+    && pip3 install https://dl.google.com/coral/python/tflite_runtime-2.1.0.post1-cp38-cp38-linux_aarch64.whl \
     && rm -rf /var/lib/apt/lists/* \
     && (apt-get autoremove -y; apt-get autoclean -y)

docker/Dockerfile.armv7hf

@@ -19,6 +19,6 @@ RUN apt-get -qq update \
         libaom0 \
         libx265-179 \
     ## Tensorflow lite
-    && pip3 install https://github.com/google-coral/pycoral/releases/download/release-frogfish/tflite_runtime-2.5.0-cp38-cp38-linux_armv7l.whl \
+    && pip3 install https://dl.google.com/coral/python/tflite_runtime-2.1.0.post1-cp38-cp38-linux_armv7l.whl \
     && rm -rf /var/lib/apt/lists/* \
     && (apt-get autoremove -y; apt-get autoclean -y)

docker/Dockerfile.base

@@ -1,7 +1,6 @@
 ARG ARCH=amd64
-ARG FFMPEG_VERSION
 FROM blakeblackshear/frigate-wheels:${ARCH} as wheels
-FROM blakeblackshear/frigate-ffmpeg:${FFMPEG_VERSION}-${ARCH} as ffmpeg
+FROM blakeblackshear/frigate-ffmpeg:${ARCH} as ffmpeg
 
 FROM ubuntu:20.04
 LABEL maintainer "blakeb@blakeshome.com"
@@ -10,14 +9,10 @@ COPY --from=ffmpeg /usr/local /usr/local/
 
 COPY --from=wheels /wheels/. /wheels/
 
-ENV FLASK_ENV=development
-# ENV FONTCONFIG_PATH=/etc/fonts
 ENV DEBIAN_FRONTEND=noninteractive
 # Install packages for apt repo
-RUN apt-get -qq update \
-    && apt-get upgrade -y \
-    && apt-get -qq install --no-install-recommends -y \
-    gnupg wget unzip tzdata nginx libnginx-mod-rtmp \
+RUN apt-get -qq update && apt-get -qq install --no-install-recommends -y \
+    gnupg wget unzip tzdata \
     && apt-get -qq install --no-install-recommends -y \
         python3-pip \
     && pip3 install -U /wheels/*.whl \
@@ -25,29 +20,22 @@ RUN apt-get -qq update \
     && echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" > /etc/apt/sources.list.d/coral-edgetpu.list \
     && echo "libedgetpu1-max libedgetpu/accepted-eula select true" | debconf-set-selections \
     && apt-get -qq update && apt-get -qq install --no-install-recommends -y \
-        libedgetpu1-max=15.0 \
+        libedgetpu1-max \
     && rm -rf /var/lib/apt/lists/* /wheels \
     && (apt-get autoremove -y; apt-get autoclean -y)
 
-RUN pip3 install \
-    peewee \
-    zeroconf \
-    voluptuous
-
-COPY nginx/nginx.conf /etc/nginx/nginx.conf
-
 # get model and labels
+ARG MODEL_REFS=7064b94dd5b996189242320359dbab8b52c94a84
 COPY labelmap.txt /labelmap.txt
-RUN wget -q https://github.com/google-coral/test_data/raw/master/ssdlite_mobiledet_coco_qat_postprocess_edgetpu.tflite -O /edgetpu_model.tflite
-RUN wget -q https://github.com/google-coral/test_data/raw/master/ssdlite_mobiledet_coco_qat_postprocess.tflite -O /cpu_model.tflite
+RUN wget -q https://github.com/google-coral/edgetpu/raw/$MODEL_REFS/test_data/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite -O /edgetpu_model.tflite
+RUN wget -q https://github.com/google-coral/edgetpu/raw/$MODEL_REFS/test_data/ssd_mobilenet_v2_coco_quant_postprocess.tflite -O /cpu_model.tflite
+
+RUN mkdir /cache /clips
 
 WORKDIR /opt/frigate/
 ADD frigate frigate/
+COPY detect_objects.py .
+COPY benchmark.py .
+COPY process_clip.py .
 
-COPY run.sh /run.sh
-RUN chmod +x /run.sh
-
-EXPOSE 5000
-EXPOSE 1935
-
-CMD ["/run.sh"]
+CMD ["python3", "-u", "detect_objects.py"]

docker/Dockerfile.ffmpeg.amd64

@@ -17,10 +17,12 @@ FROM base as build
 ENV         FFMPEG_VERSION=4.3.1 \
             AOM_VERSION=v1.0.0 \
             FDKAAC_VERSION=0.1.5 \
+            FONTCONFIG_VERSION=2.12.4 \
             FREETYPE_VERSION=2.5.5 \
             FRIBIDI_VERSION=0.19.7 \
             KVAZAAR_VERSION=1.2.0 \
             LAME_VERSION=3.100 \
+            LIBASS_VERSION=0.13.7 \
             LIBPTHREAD_STUBS_VERSION=0.4 \
             LIBVIDSTAB_VERSION=1.1.0 \
             LIBXCB_VERSION=1.13.1 \
@@ -39,17 +41,22 @@ ENV         FFMPEG_VERSION=4.3.1 \
             XORG_MACROS_VERSION=1.19.2 \
             XPROTO_VERSION=7.0.31 \
             XVID_VERSION=1.3.4 \
+            LIBXML2_VERSION=2.9.10 \
+            LIBBLURAY_VERSION=1.1.2 \
             LIBZMQ_VERSION=4.3.2 \
             SRC=/usr/local
 
 ARG         FREETYPE_SHA256SUM="5d03dd76c2171a7601e9ce10551d52d4471cf92cd205948e60289251daddffa8 freetype-2.5.5.tar.gz"
 ARG         FRIBIDI_SHA256SUM="3fc96fa9473bd31dcb5500bdf1aa78b337ba13eb8c301e7c28923fea982453a8 0.19.7.tar.gz"
+ARG         LIBASS_SHA256SUM="8fadf294bf701300d4605e6f1d92929304187fca4b8d8a47889315526adbafd7 0.13.7.tar.gz"
 ARG         LIBVIDSTAB_SHA256SUM="14d2a053e56edad4f397be0cb3ef8eb1ec3150404ce99a426c4eb641861dc0bb v1.1.0.tar.gz"
 ARG         OGG_SHA256SUM="e19ee34711d7af328cb26287f4137e70630e7261b17cbe3cd41011d73a654692 libogg-1.3.2.tar.gz"
 ARG         OPUS_SHA256SUM="77db45a87b51578fbc49555ef1b10926179861d854eb2613207dc79d9ec0a9a9 opus-1.2.tar.gz"
 ARG         THEORA_SHA256SUM="40952956c47811928d1e7922cda3bc1f427eb75680c3c37249c91e949054916b libtheora-1.1.1.tar.gz"
 ARG         VORBIS_SHA256SUM="6efbcecdd3e5dfbf090341b485da9d176eb250d893e3eb378c428a2db38301ce libvorbis-1.3.5.tar.gz"
 ARG         XVID_SHA256SUM="4e9fd62728885855bc5007fe1be58df42e5e274497591fec37249e1052ae316f xvidcore-1.3.4.tar.gz"
+ARG         LIBXML2_SHA256SUM="f07dab13bf42d2b8db80620cce7419b3b87827cc937c8bb20fe13b8571ee9501  libxml2-v2.9.10.tar.gz"
+ARG         LIBBLURAY_SHA256SUM="a3dd452239b100dc9da0d01b30e1692693e2a332a7d29917bf84bb10ea7c0b42 libbluray-1.1.2.tar.bz2"
 ARG         LIBZMQ_SHA256SUM="02ecc88466ae38cf2c8d79f09cfd2675ba299a439680b64ade733e26a349edeb v4.3.2.tar.gz"
 
 
@@ -79,7 +86,6 @@ RUN      buildDeps="autoconf \
                     libssl-dev \
                     yasm \
                     libva-dev \
-                    libmfx-dev \
                     zlib1g-dev" && \
         apt-get -yqq update && \
         apt-get install -yq --no-install-recommends ${buildDeps}
@@ -275,6 +281,30 @@ RUN  \
         make -j1 && \
         make install && \
         rm -rf ${DIR}
+## fontconfig https://www.freedesktop.org/wiki/Software/fontconfig/
+RUN  \
+        DIR=/tmp/fontconfig && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://www.freedesktop.org/software/fontconfig/release/fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        tar -jx --strip-components=1 -f fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make && \
+        make install && \
+        rm -rf ${DIR}
+## libass https://github.com/libass/libass
+RUN  \
+        DIR=/tmp/libass && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://github.com/libass/libass/archive/${LIBASS_VERSION}.tar.gz && \
+        echo ${LIBASS_SHA256SUM} | sha256sum --check && \
+        tar -zx --strip-components=1 -f ${LIBASS_VERSION}.tar.gz && \
+        ./autogen.sh && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make && \
+        make install && \
+        rm -rf ${DIR}
 ## kvazaar https://github.com/ultravideo/kvazaar
 RUN \
         DIR=/tmp/kvazaar && \
@@ -369,6 +399,32 @@ RUN \
         make install && \
         rm -rf ${DIR}
 
+## libxml2 - for libbluray
+RUN \
+        DIR=/tmp/libxml2 && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://gitlab.gnome.org/GNOME/libxml2/-/archive/v${LIBXML2_VERSION}/libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        echo ${LIBXML2_SHA256SUM} | sha256sum --check && \
+        tar -xz --strip-components=1 -f libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        ./autogen.sh --prefix="${PREFIX}" --with-ftp=no --with-http=no --with-python=no && \
+        make && \
+        make install && \
+        rm -rf ${DIR}
+
+## libbluray - Requires libxml, freetype, and fontconfig
+RUN \
+        DIR=/tmp/libbluray && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://download.videolan.org/pub/videolan/libbluray/${LIBBLURAY_VERSION}/libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        echo ${LIBBLURAY_SHA256SUM} | sha256sum --check && \
+        tar -jx --strip-components=1 -f libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-examples --disable-bdjava-jar --disable-static --enable-shared && \
+        make && \
+        make install && \
+        rm -rf ${DIR}
+
 ## libzmq https://github.com/zeromq/libzmq/
 RUN \
         DIR=/tmp/libzmq && \
@@ -403,9 +459,10 @@ RUN \
         --enable-libopencore-amrnb \
         --enable-libopencore-amrwb \
         --enable-gpl \
+        --enable-libass \
+        --enable-fontconfig \
         --enable-libfreetype \
         --enable-libvidstab \
-        --enable-libmfx \
         --enable-libmp3lame \
         --enable-libopus \
         --enable-libtheora \
@@ -422,6 +479,7 @@ RUN \
         --enable-postproc \
         --enable-small \
         --enable-version3 \
+        --enable-libbluray \
         --enable-libzmq \
         --extra-libs=-ldl \
         --prefix="${PREFIX}" \
@@ -464,5 +522,5 @@ COPY --from=build /usr/local /usr/local/
 
 RUN \
 	apt-get update -y && \
-	apt-get install -y --no-install-recommends libva-drm2 libva2 i965-va-driver mesa-va-drivers && \
+	apt-get install -y --no-install-recommends libva-drm2 libva2 i965-va-driver && \
 	rm -rf /var/lib/apt/lists/*

docker/Dockerfile.ffmpeg.amd64nvidia

@@ -1,549 +0,0 @@
-# inspired by https://github.com/jrottenberg/ffmpeg/blob/master/docker-images/4.3/ubuntu1804/Dockerfile
-
-# ffmpeg - http://ffmpeg.org/download.html
-#
-# From https://trac.ffmpeg.org/wiki/CompilationGuide/Ubuntu
-#
-# https://hub.docker.com/r/jrottenberg/ffmpeg/
-#
-#
-
-FROM    nvidia/cuda:11.1-devel-ubuntu20.04 AS devel-base
-
-ENV	    NVIDIA_DRIVER_CAPABILITIES compute,utility,video
-ENV         DEBIAN_FRONTEND=noninteractive
-
-WORKDIR     /tmp/workdir
-
-RUN     apt-get -yqq update && \
-        apt-get install -yq --no-install-recommends ca-certificates expat libgomp1 && \
-        apt-get autoremove -y && \
-        apt-get clean -y
-
-FROM       nvidia/cuda:11.1-runtime-ubuntu20.04 AS runtime-base
-
-ENV	    NVIDIA_DRIVER_CAPABILITIES compute,utility,video
-ENV         DEBIAN_FRONTEND=noninteractive
-
-WORKDIR     /tmp/workdir
-
-RUN     apt-get -yqq update && \
-        apt-get install -yq --no-install-recommends ca-certificates expat libgomp1 libxcb-shape0-dev && \
-        apt-get autoremove -y && \
-        apt-get clean -y
-
-
-FROM  devel-base as build
-
-ENV        NVIDIA_HEADERS_VERSION=9.1.23.1
-
-ENV         FFMPEG_VERSION=4.3.1 \
-            AOM_VERSION=v1.0.0 \
-            FDKAAC_VERSION=0.1.5 \
-            FREETYPE_VERSION=2.5.5 \
-            FRIBIDI_VERSION=0.19.7 \
-            KVAZAAR_VERSION=1.2.0 \
-            LAME_VERSION=3.100 \
-            LIBPTHREAD_STUBS_VERSION=0.4 \
-            LIBVIDSTAB_VERSION=1.1.0 \
-            LIBXCB_VERSION=1.13.1 \
-            XCBPROTO_VERSION=1.13 \
-            OGG_VERSION=1.3.2 \
-            OPENCOREAMR_VERSION=0.1.5 \
-            OPUS_VERSION=1.2 \
-            OPENJPEG_VERSION=2.1.2 \
-            THEORA_VERSION=1.1.1 \
-            VORBIS_VERSION=1.3.5 \
-            VPX_VERSION=1.8.0 \
-            WEBP_VERSION=1.0.2 \
-            X264_VERSION=20170226-2245-stable \
-            X265_VERSION=3.1.1 \
-            XAU_VERSION=1.0.9 \
-            XORG_MACROS_VERSION=1.19.2 \
-            XPROTO_VERSION=7.0.31 \
-            XVID_VERSION=1.3.4 \
-            LIBZMQ_VERSION=4.3.2 \
-            LIBSRT_VERSION=1.4.1 \
-            LIBARIBB24_VERSION=1.0.3 \
-            LIBPNG_VERSION=1.6.9 \
-            SRC=/usr/local
-
-ARG         FREETYPE_SHA256SUM="5d03dd76c2171a7601e9ce10551d52d4471cf92cd205948e60289251daddffa8 freetype-2.5.5.tar.gz"
-ARG         FRIBIDI_SHA256SUM="3fc96fa9473bd31dcb5500bdf1aa78b337ba13eb8c301e7c28923fea982453a8 0.19.7.tar.gz"
-ARG         LIBVIDSTAB_SHA256SUM="14d2a053e56edad4f397be0cb3ef8eb1ec3150404ce99a426c4eb641861dc0bb v1.1.0.tar.gz"
-ARG         OGG_SHA256SUM="e19ee34711d7af328cb26287f4137e70630e7261b17cbe3cd41011d73a654692 libogg-1.3.2.tar.gz"
-ARG         OPUS_SHA256SUM="77db45a87b51578fbc49555ef1b10926179861d854eb2613207dc79d9ec0a9a9 opus-1.2.tar.gz"
-ARG         THEORA_SHA256SUM="40952956c47811928d1e7922cda3bc1f427eb75680c3c37249c91e949054916b libtheora-1.1.1.tar.gz"
-ARG         VORBIS_SHA256SUM="6efbcecdd3e5dfbf090341b485da9d176eb250d893e3eb378c428a2db38301ce libvorbis-1.3.5.tar.gz"
-ARG         XVID_SHA256SUM="4e9fd62728885855bc5007fe1be58df42e5e274497591fec37249e1052ae316f xvidcore-1.3.4.tar.gz"
-ARG         LIBZMQ_SHA256SUM="02ecc88466ae38cf2c8d79f09cfd2675ba299a439680b64ade733e26a349edeb v4.3.2.tar.gz"
-ARG         LIBARIBB24_SHA256SUM="f61560738926e57f9173510389634d8c06cabedfa857db4b28fb7704707ff128 v1.0.3.tar.gz"
-
-
-ARG         LD_LIBRARY_PATH=/opt/ffmpeg/lib
-ARG         MAKEFLAGS="-j2"
-ARG         PKG_CONFIG_PATH="/opt/ffmpeg/share/pkgconfig:/opt/ffmpeg/lib/pkgconfig:/opt/ffmpeg/lib64/pkgconfig"
-ARG         PREFIX=/opt/ffmpeg
-ARG         LD_LIBRARY_PATH="/opt/ffmpeg/lib:/opt/ffmpeg/lib64"
-
-
-RUN      buildDeps="autoconf \
-                    automake \
-                    cmake \
-                    curl \
-                    bzip2 \
-                    libexpat1-dev \
-                    g++ \
-                    gcc \
-                    git \
-                    gperf \
-                    libtool \
-                    make \
-                    nasm \
-                    perl \
-                    pkg-config \
-                    python \
-                    libssl-dev \
-                    yasm \
-                    zlib1g-dev" && \
-        apt-get -yqq update && \
-        apt-get install -yq --no-install-recommends ${buildDeps}
-
-RUN \
-	DIR=/tmp/nv-codec-headers && \
-	git clone https://github.com/FFmpeg/nv-codec-headers ${DIR} && \
-	cd ${DIR} && \
-	git checkout n${NVIDIA_HEADERS_VERSION} && \
-	make PREFIX="${PREFIX}" && \
-	make install PREFIX="${PREFIX}" && \
-        rm -rf ${DIR}
-
-## opencore-amr https://sourceforge.net/projects/opencore-amr/
-RUN \
-        DIR=/tmp/opencore-amr && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://versaweb.dl.sourceforge.net/project/opencore-amr/opencore-amr/opencore-amr-${OPENCOREAMR_VERSION}.tar.gz | \
-        tar -zx --strip-components=1 && \
-        ./configure --prefix="${PREFIX}" --enable-shared  && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-## x264 http://www.videolan.org/developers/x264.html
-RUN \
-        DIR=/tmp/x264 && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://download.videolan.org/pub/videolan/x264/snapshots/x264-snapshot-${X264_VERSION}.tar.bz2 | \
-        tar -jx --strip-components=1 && \
-        ./configure --prefix="${PREFIX}" --enable-shared --enable-pic --disable-cli && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### x265 http://x265.org/
-RUN \
-        DIR=/tmp/x265 && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://download.videolan.org/pub/videolan/x265/x265_${X265_VERSION}.tar.gz  | \
-        tar -zx && \
-        cd x265_${X265_VERSION}/build/linux && \
-        sed -i "/-DEXTRA_LIB/ s/$/ -DCMAKE_INSTALL_PREFIX=\${PREFIX}/" multilib.sh && \
-        sed -i "/^cmake/ s/$/ -DENABLE_CLI=OFF/" multilib.sh && \
-        ./multilib.sh && \
-        make -C 8bit install && \
-        rm -rf ${DIR}
-### libogg https://www.xiph.org/ogg/
-RUN \
-        DIR=/tmp/ogg && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO http://downloads.xiph.org/releases/ogg/libogg-${OGG_VERSION}.tar.gz && \
-        echo ${OGG_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f libogg-${OGG_VERSION}.tar.gz && \
-        ./configure --prefix="${PREFIX}" --enable-shared  && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libopus https://www.opus-codec.org/
-RUN \
-        DIR=/tmp/opus && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://archive.mozilla.org/pub/opus/opus-${OPUS_VERSION}.tar.gz && \
-        echo ${OPUS_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f opus-${OPUS_VERSION}.tar.gz && \
-        autoreconf -fiv && \
-        ./configure --prefix="${PREFIX}" --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libvorbis https://xiph.org/vorbis/
-RUN \
-        DIR=/tmp/vorbis && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO http://downloads.xiph.org/releases/vorbis/libvorbis-${VORBIS_VERSION}.tar.gz && \
-        echo ${VORBIS_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f libvorbis-${VORBIS_VERSION}.tar.gz && \
-        ./configure --prefix="${PREFIX}" --with-ogg="${PREFIX}" --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libtheora http://www.theora.org/
-RUN \
-        DIR=/tmp/theora && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO http://downloads.xiph.org/releases/theora/libtheora-${THEORA_VERSION}.tar.gz && \
-        echo ${THEORA_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f libtheora-${THEORA_VERSION}.tar.gz && \
-        ./configure --prefix="${PREFIX}" --with-ogg="${PREFIX}" --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libvpx https://www.webmproject.org/code/
-RUN \
-        DIR=/tmp/vpx && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://codeload.github.com/webmproject/libvpx/tar.gz/v${VPX_VERSION} | \
-        tar -zx --strip-components=1 && \
-        ./configure --prefix="${PREFIX}" --enable-vp8 --enable-vp9 --enable-vp9-highbitdepth --enable-pic --enable-shared \
-        --disable-debug --disable-examples --disable-docs --disable-install-bins  && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libwebp https://developers.google.com/speed/webp/
-RUN \
-        DIR=/tmp/vebp && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://storage.googleapis.com/downloads.webmproject.org/releases/webp/libwebp-${WEBP_VERSION}.tar.gz | \
-        tar -zx --strip-components=1 && \
-        ./configure --prefix="${PREFIX}" --enable-shared  && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### libmp3lame http://lame.sourceforge.net/
-RUN \
-        DIR=/tmp/lame && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://versaweb.dl.sourceforge.net/project/lame/lame/$(echo ${LAME_VERSION} | sed -e 's/[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z-]*\)/\1.\2/')/lame-${LAME_VERSION}.tar.gz | \
-        tar -zx --strip-components=1 && \
-        ./configure --prefix="${PREFIX}" --bindir="${PREFIX}/bin" --enable-shared --enable-nasm --disable-frontend && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### xvid https://www.xvid.com/
-RUN \
-        DIR=/tmp/xvid && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO http://downloads.xvid.org/downloads/xvidcore-${XVID_VERSION}.tar.gz && \
-        echo ${XVID_SHA256SUM} | sha256sum --check && \
-        tar -zx -f xvidcore-${XVID_VERSION}.tar.gz && \
-        cd xvidcore/build/generic && \
-        ./configure --prefix="${PREFIX}" --bindir="${PREFIX}/bin" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-### fdk-aac https://github.com/mstorsjo/fdk-aac
-RUN \
-        DIR=/tmp/fdk-aac && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://github.com/mstorsjo/fdk-aac/archive/v${FDKAAC_VERSION}.tar.gz | \
-        tar -zx --strip-components=1 && \
-        autoreconf -fiv && \
-        ./configure --prefix="${PREFIX}" --enable-shared --datadir="${DIR}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-## openjpeg https://github.com/uclouvain/openjpeg
-RUN \
-        DIR=/tmp/openjpeg && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sL https://github.com/uclouvain/openjpeg/archive/v${OPENJPEG_VERSION}.tar.gz | \
-        tar -zx --strip-components=1 && \
-        cmake -DBUILD_THIRDPARTY:BOOL=ON -DCMAKE_INSTALL_PREFIX="${PREFIX}" . && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-## freetype https://www.freetype.org/
-RUN  \
-        DIR=/tmp/freetype && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://download.savannah.gnu.org/releases/freetype/freetype-${FREETYPE_VERSION}.tar.gz && \
-        echo ${FREETYPE_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f freetype-${FREETYPE_VERSION}.tar.gz && \
-        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-## libvstab https://github.com/georgmartius/vid.stab
-RUN  \
-        DIR=/tmp/vid.stab && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/georgmartius/vid.stab/archive/v${LIBVIDSTAB_VERSION}.tar.gz && \
-        echo ${LIBVIDSTAB_SHA256SUM} | sha256sum --check &&  \
-        tar -zx --strip-components=1 -f v${LIBVIDSTAB_VERSION}.tar.gz && \
-        cmake -DCMAKE_INSTALL_PREFIX="${PREFIX}" . && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-## fridibi https://www.fribidi.org/
-RUN  \
-        DIR=/tmp/fribidi && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/fribidi/fribidi/archive/${FRIBIDI_VERSION}.tar.gz && \
-        echo ${FRIBIDI_SHA256SUM} | sha256sum --check && \
-        tar -zx --strip-components=1 -f ${FRIBIDI_VERSION}.tar.gz && \
-        sed -i 's/^SUBDIRS =.*/SUBDIRS=gen.tab charset lib bin/' Makefile.am && \
-        ./bootstrap --no-config --auto && \
-        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
-        make -j1 && \
-        make install && \
-        rm -rf ${DIR}
-## kvazaar https://github.com/ultravideo/kvazaar
-RUN \
-        DIR=/tmp/kvazaar && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/ultravideo/kvazaar/archive/v${KVAZAAR_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f v${KVAZAAR_VERSION}.tar.gz && \
-        ./autogen.sh && \
-        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/aom && \
-        git clone --branch ${AOM_VERSION} --depth 1 https://aomedia.googlesource.com/aom ${DIR} ; \
-        cd ${DIR} ; \
-        rm -rf CMakeCache.txt CMakeFiles ; \
-        mkdir -p ./aom_build ; \
-        cd ./aom_build ; \
-        cmake -DCMAKE_INSTALL_PREFIX="${PREFIX}" -DBUILD_SHARED_LIBS=1 ..; \
-        make ; \
-        make install ; \
-        rm -rf ${DIR}
-
-## libxcb (and supporting libraries) for screen capture https://xcb.freedesktop.org/
-RUN \
-        DIR=/tmp/xorg-macros && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://www.x.org/archive//individual/util/util-macros-${XORG_MACROS_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f util-macros-${XORG_MACROS_VERSION}.tar.gz && \
-        ./configure --srcdir=${DIR} --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/xproto && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://www.x.org/archive/individual/proto/xproto-${XPROTO_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f xproto-${XPROTO_VERSION}.tar.gz && \
-        ./configure --srcdir=${DIR} --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/libXau && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://www.x.org/archive/individual/lib/libXau-${XAU_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f libXau-${XAU_VERSION}.tar.gz && \
-        ./configure --srcdir=${DIR} --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/libpthread-stubs && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://xcb.freedesktop.org/dist/libpthread-stubs-${LIBPTHREAD_STUBS_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f libpthread-stubs-${LIBPTHREAD_STUBS_VERSION}.tar.gz && \
-        ./configure --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/libxcb-proto && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://xcb.freedesktop.org/dist/xcb-proto-${XCBPROTO_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f xcb-proto-${XCBPROTO_VERSION}.tar.gz && \
-        ACLOCAL_PATH="${PREFIX}/share/aclocal" ./autogen.sh && \
-        ./configure --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-RUN \
-        DIR=/tmp/libxcb && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://xcb.freedesktop.org/dist/libxcb-${LIBXCB_VERSION}.tar.gz && \
-        tar -zx --strip-components=1 -f libxcb-${LIBXCB_VERSION}.tar.gz && \
-        ACLOCAL_PATH="${PREFIX}/share/aclocal" ./autogen.sh && \
-        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-## libzmq https://github.com/zeromq/libzmq/
-RUN \
-        DIR=/tmp/libzmq && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/zeromq/libzmq/archive/v${LIBZMQ_VERSION}.tar.gz && \
-        echo ${LIBZMQ_SHA256SUM} | sha256sum --check && \
-        tar -xz --strip-components=1 -f v${LIBZMQ_VERSION}.tar.gz && \
-        ./autogen.sh && \
-        ./configure --prefix="${PREFIX}" && \
-        make && \
-        make check && \
-        make install && \
-        rm -rf ${DIR}
-
-## libsrt https://github.com/Haivision/srt
-RUN \
-        DIR=/tmp/srt && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/Haivision/srt/archive/v${LIBSRT_VERSION}.tar.gz && \
-        tar -xz --strip-components=1 -f v${LIBSRT_VERSION}.tar.gz && \
-        cmake -DCMAKE_INSTALL_PREFIX="${PREFIX}" . && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-## libpng
-RUN \
-        DIR=/tmp/png && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        git clone https://git.code.sf.net/p/libpng/code ${DIR} -b v${LIBPNG_VERSION} --depth 1 && \
-        ./autogen.sh && \
-        ./configure --prefix="${PREFIX}" && \
-        make check && \
-        make install && \
-        rm -rf ${DIR}
-
-## libaribb24
-RUN \
-        DIR=/tmp/b24 && \
-        mkdir -p ${DIR} && \
-        cd ${DIR} && \
-        curl -sLO https://github.com/nkoriyama/aribb24/archive/v${LIBARIBB24_VERSION}.tar.gz && \
-        echo ${LIBARIBB24_SHA256SUM} | sha256sum --check && \
-        tar -xz --strip-components=1 -f v${LIBARIBB24_VERSION}.tar.gz && \
-        autoreconf -fiv && \
-        ./configure CFLAGS="-I${PREFIX}/include -fPIC" --prefix="${PREFIX}" && \
-        make && \
-        make install && \
-        rm -rf ${DIR}
-
-## ffmpeg https://ffmpeg.org/
-RUN  \
-        DIR=/tmp/ffmpeg && mkdir -p ${DIR} && cd ${DIR} && \
-        curl -sLO https://ffmpeg.org/releases/ffmpeg-${FFMPEG_VERSION}.tar.bz2 && \
-        tar -jx --strip-components=1 -f ffmpeg-${FFMPEG_VERSION}.tar.bz2
-
-
-
-RUN \
-        DIR=/tmp/ffmpeg && mkdir -p ${DIR} && cd ${DIR} && \
-        ./configure \
-        --disable-debug \
-        --disable-doc \
-        --disable-ffplay \
-        --enable-shared \
-        --enable-avresample \
-        --enable-libopencore-amrnb \
-        --enable-libopencore-amrwb \
-        --enable-gpl \
-        --enable-libfreetype \
-        --enable-libvidstab \
-        --enable-libmp3lame \
-        --enable-libopus \
-        --enable-libtheora \
-        --enable-libvorbis \
-        --enable-libvpx \
-        --enable-libwebp \
-        --enable-libxcb \
-        --enable-libx265 \
-        --enable-libxvid \
-        --enable-libx264 \
-        --enable-nonfree \
-        --enable-openssl \
-        --enable-libfdk_aac \
-        --enable-postproc \
-        --enable-small \
-        --enable-version3 \
-        --enable-libzmq \
-        --extra-libs=-ldl \
-        --prefix="${PREFIX}" \
-        --enable-libopenjpeg \
-        --enable-libkvazaar \
-        --enable-libaom \
-        --extra-libs=-lpthread \
-        --enable-libsrt \
-        --enable-libaribb24 \
-        --enable-nvenc \
-        --enable-cuda \
-        --enable-cuvid \
-        --enable-libnpp \
-        --extra-cflags="-I${PREFIX}/include -I${PREFIX}/include/ffnvcodec -I/usr/local/cuda/include/" \
-        --extra-ldflags="-L${PREFIX}/lib -L/usr/local/cuda/lib64 -L/usr/local/cuda/lib32/" && \
-        make && \
-        make install && \
-        make tools/zmqsend && cp tools/zmqsend ${PREFIX}/bin/ && \
-        make distclean && \
-        hash -r && \
-        cd tools && \
-        make qt-faststart && cp qt-faststart ${PREFIX}/bin/
-
-## cleanup
-RUN \
-        LD_LIBRARY_PATH="${PREFIX}/lib:${PREFIX}/lib64:${LD_LIBRARY_PATH}" ldd ${PREFIX}/bin/ffmpeg | grep opt/ffmpeg | cut -d ' ' -f 3 | xargs -i cp {} /usr/local/lib/ && \
-        for lib in /usr/local/lib/*.so.*; do ln -s "${lib##*/}" "${lib%%.so.*}".so; done && \
-        cp ${PREFIX}/bin/* /usr/local/bin/ && \
-        cp -r ${PREFIX}/share/* /usr/local/share/ && \
-        LD_LIBRARY_PATH=/usr/local/lib ffmpeg -buildconf && \
-        cp -r ${PREFIX}/include/libav* ${PREFIX}/include/libpostproc ${PREFIX}/include/libsw* /usr/local/include && \
-        mkdir -p /usr/local/lib/pkgconfig && \
-        for pc in ${PREFIX}/lib/pkgconfig/libav*.pc ${PREFIX}/lib/pkgconfig/libpostproc.pc ${PREFIX}/lib/pkgconfig/libsw*.pc; do \
-          sed "s:${PREFIX}:/usr/local:g; s:/lib64:/lib:g" <"$pc" >/usr/local/lib/pkgconfig/"${pc##*/}"; \
-        done
-
-
-
-FROM        runtime-base AS release
-
-ENV         LD_LIBRARY_PATH=/usr/local/lib:/usr/local/lib64
-
-CMD         ["--help"]
-ENTRYPOINT  ["ffmpeg"]
-
-# copy only needed files, without copying nvidia dev files 
-COPY --from=build /usr/local/bin /usr/local/bin/
-COPY --from=build /usr/local/share /usr/local/share/
-COPY --from=build /usr/local/lib /usr/local/lib/
-COPY --from=build /usr/local/include /usr/local/include/
-
-# Let's make sure the app built correctly
-# Convenient to verify on https://hub.docker.com/r/jrottenberg/ffmpeg/builds/ console output

docker/Dockerfile.ffmpeg.arm64

@@ -18,10 +18,12 @@ FROM base as build
 ENV         FFMPEG_VERSION=4.3.1 \
             AOM_VERSION=v1.0.0 \
             FDKAAC_VERSION=0.1.5 \
+            FONTCONFIG_VERSION=2.12.4 \
             FREETYPE_VERSION=2.5.5 \
             FRIBIDI_VERSION=0.19.7 \
             KVAZAAR_VERSION=1.2.0 \
             LAME_VERSION=3.100 \
+            LIBASS_VERSION=0.13.7 \
             LIBPTHREAD_STUBS_VERSION=0.4 \
             LIBVIDSTAB_VERSION=1.1.0 \
             LIBXCB_VERSION=1.13.1 \
@@ -40,17 +42,22 @@ ENV         FFMPEG_VERSION=4.3.1 \
             XORG_MACROS_VERSION=1.19.2 \
             XPROTO_VERSION=7.0.31 \
             XVID_VERSION=1.3.4 \
+            LIBXML2_VERSION=2.9.10 \
+            LIBBLURAY_VERSION=1.1.2 \
             LIBZMQ_VERSION=4.3.2 \
             SRC=/usr/local
 
 ARG         FREETYPE_SHA256SUM="5d03dd76c2171a7601e9ce10551d52d4471cf92cd205948e60289251daddffa8 freetype-2.5.5.tar.gz"
 ARG         FRIBIDI_SHA256SUM="3fc96fa9473bd31dcb5500bdf1aa78b337ba13eb8c301e7c28923fea982453a8 0.19.7.tar.gz"
+ARG         LIBASS_SHA256SUM="8fadf294bf701300d4605e6f1d92929304187fca4b8d8a47889315526adbafd7 0.13.7.tar.gz"
 ARG         LIBVIDSTAB_SHA256SUM="14d2a053e56edad4f397be0cb3ef8eb1ec3150404ce99a426c4eb641861dc0bb v1.1.0.tar.gz"
 ARG         OGG_SHA256SUM="e19ee34711d7af328cb26287f4137e70630e7261b17cbe3cd41011d73a654692 libogg-1.3.2.tar.gz"
 ARG         OPUS_SHA256SUM="77db45a87b51578fbc49555ef1b10926179861d854eb2613207dc79d9ec0a9a9 opus-1.2.tar.gz"
 ARG         THEORA_SHA256SUM="40952956c47811928d1e7922cda3bc1f427eb75680c3c37249c91e949054916b libtheora-1.1.1.tar.gz"
 ARG         VORBIS_SHA256SUM="6efbcecdd3e5dfbf090341b485da9d176eb250d893e3eb378c428a2db38301ce libvorbis-1.3.5.tar.gz"
 ARG         XVID_SHA256SUM="4e9fd62728885855bc5007fe1be58df42e5e274497591fec37249e1052ae316f xvidcore-1.3.4.tar.gz"
+ARG         LIBXML2_SHA256SUM="f07dab13bf42d2b8db80620cce7419b3b87827cc937c8bb20fe13b8571ee9501  libxml2-v2.9.10.tar.gz"
+ARG         LIBBLURAY_SHA256SUM="a3dd452239b100dc9da0d01b30e1692693e2a332a7d29917bf84bb10ea7c0b42 libbluray-1.1.2.tar.bz2"
 ARG         LIBZMQ_SHA256SUM="02ecc88466ae38cf2c8d79f09cfd2675ba299a439680b64ade733e26a349edeb v4.3.2.tar.gz"
 
 
@@ -280,7 +287,30 @@ RUN  \
         make -j1 && \
         make -j $(nproc) install && \
         rm -rf ${DIR}
-
+## fontconfig https://www.freedesktop.org/wiki/Software/fontconfig/
+RUN  \
+        DIR=/tmp/fontconfig && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://www.freedesktop.org/software/fontconfig/release/fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        tar -jx --strip-components=1 -f fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+## libass https://github.com/libass/libass
+RUN  \
+        DIR=/tmp/libass && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://github.com/libass/libass/archive/${LIBASS_VERSION}.tar.gz && \
+        echo ${LIBASS_SHA256SUM} | sha256sum --check && \
+        tar -zx --strip-components=1 -f ${LIBASS_VERSION}.tar.gz && \
+        ./autogen.sh && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
 ## kvazaar https://github.com/ultravideo/kvazaar
 RUN \
         DIR=/tmp/kvazaar && \
@@ -377,6 +407,32 @@ RUN \
         make -j $(nproc) install && \
         rm -rf ${DIR}
 
+## libxml2 - for libbluray
+RUN \
+        DIR=/tmp/libxml2 && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://gitlab.gnome.org/GNOME/libxml2/-/archive/v${LIBXML2_VERSION}/libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        echo ${LIBXML2_SHA256SUM} | sha256sum --check && \
+        tar -xz --strip-components=1 -f libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        ./autogen.sh --prefix="${PREFIX}" --with-ftp=no --with-http=no --with-python=no && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+
+## libbluray - Requires libxml, freetype, and fontconfig
+RUN \
+        DIR=/tmp/libbluray && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://download.videolan.org/pub/videolan/libbluray/${LIBBLURAY_VERSION}/libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        echo ${LIBBLURAY_SHA256SUM} | sha256sum --check && \
+        tar -jx --strip-components=1 -f libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-examples --disable-bdjava-jar --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+
 ## libzmq https://github.com/zeromq/libzmq/
 RUN \
         DIR=/tmp/libzmq && \
@@ -409,6 +465,8 @@ RUN \
         --enable-libopencore-amrnb \
         --enable-libopencore-amrwb \
         --enable-gpl \
+        --enable-libass \
+        --enable-fontconfig \
         --enable-libfreetype \
         --enable-libvidstab \
         --enable-libmp3lame \
@@ -427,6 +485,7 @@ RUN \
         --enable-postproc \
         --enable-small \
         --enable-version3 \
+        --enable-libbluray \
         --enable-libzmq \
         --extra-libs=-ldl \
         --prefix="${PREFIX}" \

docker/Dockerfile.ffmpeg.armv7hf

@@ -18,10 +18,12 @@ FROM base as build
 ENV         FFMPEG_VERSION=4.3.1 \
             AOM_VERSION=v1.0.0 \
             FDKAAC_VERSION=0.1.5 \
+            FONTCONFIG_VERSION=2.12.4 \
             FREETYPE_VERSION=2.5.5 \
             FRIBIDI_VERSION=0.19.7 \
             KVAZAAR_VERSION=1.2.0 \
             LAME_VERSION=3.100 \
+            LIBASS_VERSION=0.13.7 \
             LIBPTHREAD_STUBS_VERSION=0.4 \
             LIBVIDSTAB_VERSION=1.1.0 \
             LIBXCB_VERSION=1.13.1 \
@@ -40,17 +42,22 @@ ENV         FFMPEG_VERSION=4.3.1 \
             XORG_MACROS_VERSION=1.19.2 \
             XPROTO_VERSION=7.0.31 \
             XVID_VERSION=1.3.4 \
+            LIBXML2_VERSION=2.9.10 \
+            LIBBLURAY_VERSION=1.1.2 \
             LIBZMQ_VERSION=4.3.3 \
             SRC=/usr/local
 
 ARG         FREETYPE_SHA256SUM="5d03dd76c2171a7601e9ce10551d52d4471cf92cd205948e60289251daddffa8 freetype-2.5.5.tar.gz"
 ARG         FRIBIDI_SHA256SUM="3fc96fa9473bd31dcb5500bdf1aa78b337ba13eb8c301e7c28923fea982453a8 0.19.7.tar.gz"
+ARG         LIBASS_SHA256SUM="8fadf294bf701300d4605e6f1d92929304187fca4b8d8a47889315526adbafd7 0.13.7.tar.gz"
 ARG         LIBVIDSTAB_SHA256SUM="14d2a053e56edad4f397be0cb3ef8eb1ec3150404ce99a426c4eb641861dc0bb v1.1.0.tar.gz"
 ARG         OGG_SHA256SUM="e19ee34711d7af328cb26287f4137e70630e7261b17cbe3cd41011d73a654692 libogg-1.3.2.tar.gz"
 ARG         OPUS_SHA256SUM="77db45a87b51578fbc49555ef1b10926179861d854eb2613207dc79d9ec0a9a9 opus-1.2.tar.gz"
 ARG         THEORA_SHA256SUM="40952956c47811928d1e7922cda3bc1f427eb75680c3c37249c91e949054916b libtheora-1.1.1.tar.gz"
 ARG         VORBIS_SHA256SUM="6efbcecdd3e5dfbf090341b485da9d176eb250d893e3eb378c428a2db38301ce libvorbis-1.3.5.tar.gz"
 ARG         XVID_SHA256SUM="4e9fd62728885855bc5007fe1be58df42e5e274497591fec37249e1052ae316f xvidcore-1.3.4.tar.gz"
+ARG         LIBXML2_SHA256SUM="f07dab13bf42d2b8db80620cce7419b3b87827cc937c8bb20fe13b8571ee9501  libxml2-v2.9.10.tar.gz"
+ARG         LIBBLURAY_SHA256SUM="a3dd452239b100dc9da0d01b30e1692693e2a332a7d29917bf84bb10ea7c0b42 libbluray-1.1.2.tar.bz2"
 
 
 ARG         LD_LIBRARY_PATH=/opt/ffmpeg/lib
@@ -282,7 +289,30 @@ RUN  \
         make -j1 && \
         make -j $(nproc) install && \
         rm -rf ${DIR}
-
+## fontconfig https://www.freedesktop.org/wiki/Software/fontconfig/
+RUN  \
+        DIR=/tmp/fontconfig && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://www.freedesktop.org/software/fontconfig/release/fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        tar -jx --strip-components=1 -f fontconfig-${FONTCONFIG_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+## libass https://github.com/libass/libass
+RUN  \
+        DIR=/tmp/libass && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://github.com/libass/libass/archive/${LIBASS_VERSION}.tar.gz && \
+        echo ${LIBASS_SHA256SUM} | sha256sum --check && \
+        tar -zx --strip-components=1 -f ${LIBASS_VERSION}.tar.gz && \
+        ./autogen.sh && \
+        ./configure --prefix="${PREFIX}" --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
 ## kvazaar https://github.com/ultravideo/kvazaar
 RUN \
         DIR=/tmp/kvazaar && \
@@ -379,6 +409,32 @@ RUN \
         make -j $(nproc) install && \
         rm -rf ${DIR}
 
+## libxml2 - for libbluray
+RUN \
+        DIR=/tmp/libxml2 && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://gitlab.gnome.org/GNOME/libxml2/-/archive/v${LIBXML2_VERSION}/libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        echo ${LIBXML2_SHA256SUM} | sha256sum --check && \
+        tar -xz --strip-components=1 -f libxml2-v${LIBXML2_VERSION}.tar.gz && \
+        ./autogen.sh --prefix="${PREFIX}" --with-ftp=no --with-http=no --with-python=no && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+
+## libbluray - Requires libxml, freetype, and fontconfig
+RUN \
+        DIR=/tmp/libbluray && \
+        mkdir -p ${DIR} && \
+        cd ${DIR} && \
+        curl -sLO https://download.videolan.org/pub/videolan/libbluray/${LIBBLURAY_VERSION}/libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        echo ${LIBBLURAY_SHA256SUM} | sha256sum --check && \
+        tar -jx --strip-components=1 -f libbluray-${LIBBLURAY_VERSION}.tar.bz2 && \
+        ./configure --prefix="${PREFIX}" --disable-examples --disable-bdjava-jar --disable-static --enable-shared && \
+        make -j $(nproc) && \
+        make -j $(nproc) install && \
+        rm -rf ${DIR}
+
 ## libzmq https://github.com/zeromq/libzmq/
 RUN \
         DIR=/tmp/libzmq && \
@@ -419,6 +475,8 @@ RUN \
         --enable-libopencore-amrnb \
         --enable-libopencore-amrwb \
         --enable-gpl \
+        --enable-libass \
+        --enable-fontconfig \
         --enable-libfreetype \
         --enable-libvidstab \
         --enable-libmp3lame \
@@ -437,6 +495,7 @@ RUN \
         --enable-postproc \
         --enable-small \
         --enable-version3 \
+        --enable-libbluray \
         --enable-libzmq \
         --extra-libs=-ldl \
         --prefix="${PREFIX}" \

docs/CAMERAS.md

@@ -16,6 +16,8 @@ input_args:
     - experimental
     - -fflags
     - +genpts+discardcorrupt
+    - -vsync
+    - drop
     - -use_wallclock_as_timestamps
     - '1'
 ```

docs/HWACCEL.md

@@ -0,0 +1,32 @@
+# Hardware Acceleration for Decoding Video
+
+FFmpeg is compiled to support hardware accelerated decoding of video streams.
+
+## Intel-based CPUs via Quicksync (https://trac.ffmpeg.org/wiki/Hardware/QuickSync)
+```yaml
+ffmpeg:
+  hwaccel_args:
+    - -hwaccel
+    - vaapi
+    - -hwaccel_device
+    - /dev/dri/renderD128
+    - -hwaccel_output_format
+    - yuv420p
+```
+
+## Raspberry Pi 3b and 4 (32bit OS)
+Ensure you increase the allocated RAM for your GPU to at least 128 (raspi-config > Advanced Options > Memory Split)
+```yaml
+ffmpeg:
+  hwaccel_args:
+    - -c:v
+    - h264_mmal
+```
+
+## Raspberry Pi 4 (64bit OS)
+```yaml
+ffmpeg:
+  hwaccel_args:
+    - -c:v
+    - h264_v4l2m2m
+```

docs/how-frigate-works.md

@@ -1,10 +0,0 @@
-# How Frigate Works
-Frigate is designed to minimize resource and maximize performance by only looking for objects when and where it is necessary
-
-![Diagram](diagram.png)
-
-## 1. Look for Motion
-
-## 2. Calculate Detection Regions
-
-## 3. Run Object Detection

docs/notification-examples.md

@@ -1,71 +0,0 @@
-# Notification examples
-
-Here are some examples of notifications for the HomeAssistant android companion app:
-```yaml
-automation:
-
-  - alias: When a person enters a zone named yard
-    trigger:
-      platform: mqtt
-      topic: frigate/events
-    conditions: 
-      - "{{ trigger.payload_json['after']['label'] == 'person' }}"
-      - "{{ 'yard' in trigger.payload_json['after']['entered_zones'] }}"
-    action:
-      - service: notify.mobile_app_pixel_3
-        data_template:
-          message: "A {{trigger.payload_json['after']['label']}} has entered the yard."
-          data:
-            image: "https://url.com/api/frigate/notifications/{{trigger.payload_json['after']['id']}}.jpg"
-            tag: "{{trigger.payload_json['after']['id']}}"
-
-  - alias: When a person leaves a zone named yard
-    trigger:
-      platform: mqtt
-      topic: frigate/events
-    conditions: 
-      - "{{ trigger.payload_json['after']['label'] == 'person' }}"
-      - "{{ 'yard' in trigger.payload_json['before']['current_zones'] }}"
-      - "{{ not 'yard' in trigger.payload_json['after']['current_zones'] }}"
-    action:
-      - service: notify.mobile_app_pixel_3
-        data_template:
-          message: "A {{trigger.payload_json['after']['label']}} has left the yard."
-          data:
-            image: "https://url.com/api/frigate/notifications/{{trigger.payload_json['after']['id']}}.jpg"
-            tag: "{{trigger.payload_json['after']['id']}}"
-
-  - alias: Notify for dogs in the front with a high top score
-    trigger:
-      platform: mqtt
-      topic: frigate/events
-    conditions: 
-      - "{{ trigger.payload_json['after']['label'] == 'dog' }}"
-      - "{{ trigger.payload_json['after']['camera'] == 'front' }}"
-      - "{{ trigger.payload_json['after']['top_score'] > 0.98 }}"
-    action:
-      - service: notify.mobile_app_pixel_3
-        data_template:
-          message: 'High confidence dog detection.'
-          data:
-            image: "https://url.com/api/frigate/notifications/{{trigger.payload_json['after']['id']}}.jpg"
-            tag: "{{trigger.payload_json['after']['id']}}"
-```
-
-If you are using telegram, you can fetch the image directly from Frigate:
-```yaml
-automation:
-  - alias: Notify of events
-    trigger:
-      platform: mqtt
-      topic: frigate/events
-    action:
-      - service: notify.telegram_full
-        data_template:
-          message: 'A {{trigger.payload_json["after"]["label"]}} was detected.'
-          data:
-            photo:
-              # this url should work for addon users
-              - url: 'http://ccab4aaf-frigate:5000/events/{{trigger.payload_json["after"]["id"]}}/snapshot.jpg'
-                caption : 'A {{trigger.payload_json["after"]["label"]}} was detected on {{ trigger.payload_json["after"]["camera"] }} camera'
-```

docs/nvdec.md

@@ -1,105 +0,0 @@
-# nVidia hardware decoder (NVDEC)
-
-Certain nvidia cards include a hardware decoder, which can greatly improve the
-performance of video decoding. In order to use NVDEC, a special build of 
-ffmpeg with NVDEC support is required. The special docker architecture 'amd64nvidia'
-includes this support for amd64 platforms. An aarch64 for the Jetson, which 
-also includes NVDEC may be added in the future.
-
-## Docker setup
-
-### Requirements
-[nVidia closed source driver](https://www.nvidia.com/en-us/drivers/unix/) required to access NVDEC.
-[nvidia-docker](https://github.com/NVIDIA/nvidia-docker) required to pass NVDEC to docker.
-
-### Setting up docker-compose
-
-In order to pass NVDEC, the docker engine must be set to `nvidia` and the environment variables
-`NVIDIA_VISIBLE_DEVICES=all` and `NVIDIA_DRIVER_CAPABILITIES=compute,utility,video` must be set.
-
-In a docker compose file, these lines need to be set:
-```
-services:
-  frigate:
-    ...
-    image: blakeblackshear/frigate:stable-amd64nvidia
-    runtime: nvidia
-    environment:
-      - NVIDIA_VISIBLE_DEVICES=all
-      - NVIDIA_DRIVER_CAPABILITIES=compute,utility,video 
-```
-
-### Setting up the configuration file
-
-In your frigate config.yml, you'll need to set ffmpeg to use the hardware decoder. 
-The decoder you choose 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)
-```
- 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)
- V..... mjpeg_cuvid          Nvidia CUVID MJPEG decoder (codec mjpeg)
- V..... mpeg1_cuvid          Nvidia CUVID MPEG1VIDEO decoder (codec mpeg1video)
- V..... mpeg2_cuvid          Nvidia CUVID MPEG2VIDEO decoder (codec mpeg2video)
- V..... mpeg4_cuvid          Nvidia CUVID MPEG4 decoder (codec mpeg4)
- V..... vc1_cuvid            Nvidia CUVID VC1 decoder (codec vc1)
- V..... vp8_cuvid            Nvidia CUVID VP8 decoder (codec vp8)
- V..... vp9_cuvid            Nvidia CUVID VP9 decoder (codec vp9)
- ```
-
-For example, for H265 video (hevc), you'll select `hevc_cuvid`. Add
-`-c:v hevc_covid` to your ffmpeg input arguments:
-
-```
-ffmpeg:
-  input_args:
-    ...
-    - -c:v 
-    - hevc_cuvid
-```
-
-If everything is working correctly, you should see a significant improvement in performance.
-Verify that hardware decoding is working by running `nvidia-smi`, which should show the ffmpeg
-processes:
-
-```
-+-----------------------------------------------------------------------------+
-| NVIDIA-SMI 455.38       Driver Version: 455.38       CUDA Version: 11.1     |
-|-------------------------------+----------------------+----------------------+
-| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
-| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
-|                               |                      |               MIG M. |
-|===============================+======================+======================|
-|   0  GeForce GTX 166...  Off  | 00000000:03:00.0 Off |                  N/A |
-| 38%   41C    P2    36W / 125W |   2082MiB /  5942MiB |      5%      Default |
-|                               |                      |                  N/A |
-+-------------------------------+----------------------+----------------------+
-                                                                               
-+-----------------------------------------------------------------------------+
-| Processes:                                                                  |
-|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
-|        ID   ID                                                   Usage      |
-|=============================================================================|
-|    0   N/A  N/A     12737      C   ffmpeg                            249MiB |
-|    0   N/A  N/A     12751      C   ffmpeg                            249MiB |
-|    0   N/A  N/A     12772      C   ffmpeg                            249MiB |
-|    0   N/A  N/A     12775      C   ffmpeg                            249MiB |
-|    0   N/A  N/A     12800      C   ffmpeg                            249MiB |
-|    0   N/A  N/A     12811      C   ffmpeg                            417MiB |
-|    0   N/A  N/A     12827      C   ffmpeg                            417MiB |
-+-----------------------------------------------------------------------------+
-```
-
-To further improve performance, you can set ffmpeg to skip frames in the output,
-using the fps filter:
-
-```
-  output_args:
-    - -filter:v 
-    - fps=fps=5
-```
-
-This setting, for example, allows Frigate to consume my 10-15fps camera streams on
-my relatively low powered Haswell machine with relatively low cpu usage.
-

frigate/__main__.py

@@ -1,15 +0,0 @@
-import faulthandler; faulthandler.enable()
-import sys
-import threading
-
-threading.current_thread().name = "frigate"
-
-from frigate.app import FrigateApp
-
-cli = sys.modules['flask.cli']
-cli.show_server_banner = lambda *x: None
-
-if __name__ == '__main__':
-    frigate_app = FrigateApp()
-
-    frigate_app.start()

frigate/app.py

@@ -1,235 +0,0 @@
-import json
-import logging
-import multiprocessing as mp
-import os
-from logging.handlers import QueueHandler
-from typing import Dict, List
-import sys
-import signal
-
-import yaml
-from playhouse.sqlite_ext import SqliteExtDatabase
-
-from frigate.config import FrigateConfig
-from frigate.const import RECORD_DIR, CLIPS_DIR, CACHE_DIR
-from frigate.edgetpu import EdgeTPUProcess
-from frigate.events import EventProcessor, EventCleanup
-from frigate.http import create_app
-from frigate.log import log_process, root_configurer
-from frigate.models import Event
-from frigate.mqtt import create_mqtt_client
-from frigate.object_processing import TrackedObjectProcessor
-from frigate.record import RecordingMaintainer
-from frigate.video import capture_camera, track_camera
-from frigate.watchdog import FrigateWatchdog
-from frigate.zeroconf import broadcast_zeroconf
-
-logger = logging.getLogger(__name__)
-
-class FrigateApp():
-    def __init__(self):
-        self.stop_event = mp.Event()
-        self.config: FrigateConfig = None
-        self.detection_queue = mp.Queue()
-        self.detectors: Dict[str, EdgeTPUProcess] = {}
-        self.detection_out_events: Dict[str, mp.Event] = {}
-        self.detection_shms: List[mp.shared_memory.SharedMemory] = []
-        self.log_queue = mp.Queue()
-        self.camera_metrics = {}
-
-    def ensure_dirs(self):
-        tmpfs_size = self.config.save_clips.tmpfs_cache_size
-        if tmpfs_size:
-             logger.info(f"Creating tmpfs of size {tmpfs_size}")
-             rc = os.system(f"mount -t tmpfs -o size={tmpfs_size} tmpfs {CACHE_DIR}")
-             if rc != 0:
-                 logger.error(f"Failed to create tmpfs, error code: {rc}")
-
-        for d in [RECORD_DIR, CLIPS_DIR, CACHE_DIR]:
-            if not os.path.exists(d) and not os.path.islink(d):
-                logger.info(f"Creating directory: {d}")
-                os.makedirs(d)
-            else:
-                logger.debug(f"Skipping directory: {d}")
-    
-    def init_logger(self):
-        self.log_process = mp.Process(target=log_process, args=(self.log_queue,), name='log_process')
-        self.log_process.daemon = True
-        self.log_process.start()
-        root_configurer(self.log_queue)
-    
-    def init_config(self):
-        config_file = os.environ.get('CONFIG_FILE', '/config/config.yml')
-        self.config = FrigateConfig(config_file=config_file)
-
-        for camera_name in self.config.cameras.keys():
-            # create camera_metrics
-            self.camera_metrics[camera_name] = {
-                'camera_fps': mp.Value('d', 0.0),
-                'skipped_fps': mp.Value('d', 0.0),
-                'process_fps': mp.Value('d', 0.0),
-                'detection_fps': mp.Value('d', 0.0),
-                'detection_frame': mp.Value('d', 0.0),
-                'read_start': mp.Value('d', 0.0),
-                'ffmpeg_pid': mp.Value('i', 0),
-                'frame_queue': mp.Queue(maxsize=2)
-            }
-        
-    def check_config(self):
-        for name, camera in self.config.cameras.items():
-            assigned_roles = list(set([r for i in camera.ffmpeg.inputs for r in i.roles]))
-            if not camera.save_clips.enabled and 'clips' in assigned_roles:
-                logger.warning(f"Camera {name} has clips assigned to an input, but save_clips is not enabled.")
-            elif camera.save_clips.enabled and not 'clips' in assigned_roles:
-                logger.warning(f"Camera {name} has save_clips enabled, but clips is not assigned to an input.")
-
-            if not camera.record.enabled and 'record' in assigned_roles:
-                logger.warning(f"Camera {name} has record assigned to an input, but record is not enabled.")
-            elif camera.record.enabled and not 'record' in assigned_roles:
-                logger.warning(f"Camera {name} has record enabled, but record is not assigned to an input.")
-
-            if not camera.rtmp.enabled and 'rtmp' in assigned_roles:
-                logger.warning(f"Camera {name} has rtmp assigned to an input, but rtmp is not enabled.")
-            elif camera.rtmp.enabled and not 'rtmp' in assigned_roles:
-                logger.warning(f"Camera {name} has rtmp enabled, but rtmp is not assigned to an input.")
-    
-    def set_log_levels(self):
-        logging.getLogger().setLevel(self.config.logger.default)
-        for log, level in self.config.logger.logs.items():
-            logging.getLogger(log).setLevel(level)
-        
-        if not 'werkzeug' in self.config.logger.logs:
-            logging.getLogger('werkzeug').setLevel('ERROR')
-
-    def init_queues(self):
-        # Queues for clip processing
-        self.event_queue = mp.Queue()
-        self.event_processed_queue = mp.Queue()
-
-        # Queue for cameras to push tracked objects to
-        self.detected_frames_queue = mp.Queue(maxsize=len(self.config.cameras.keys())*2)
-
-    def init_database(self):
-        self.db = SqliteExtDatabase(self.config.database.path)
-        models = [Event]
-        self.db.bind(models)
-        self.db.create_tables(models, safe=True)
-
-    def init_web_server(self):
-        self.flask_app = create_app(self.config, self.db, self.camera_metrics, self.detectors, self.detected_frames_processor)
-
-    def init_mqtt(self):
-        self.mqtt_client = create_mqtt_client(self.config.mqtt)
-
-    def start_detectors(self):
-        model_shape = (self.config.model.height, self.config.model.width)
-        for name in self.config.cameras.keys():
-            self.detection_out_events[name] = mp.Event()
-            shm_in = mp.shared_memory.SharedMemory(name=name, create=True, size=self.config.model.height*self.config.model.width*3)
-            shm_out = mp.shared_memory.SharedMemory(name=f"out-{name}", create=True, size=20*6*4)
-            self.detection_shms.append(shm_in)
-            self.detection_shms.append(shm_out)
-
-        for name, detector in self.config.detectors.items():
-            if detector.type == 'cpu':
-                self.detectors[name] = EdgeTPUProcess(name, self.detection_queue, self.detection_out_events, model_shape, 'cpu', detector.num_threads)
-            if detector.type == 'edgetpu':
-                self.detectors[name] = EdgeTPUProcess(name, self.detection_queue, self.detection_out_events, model_shape, detector.device, detector.num_threads)
-
-    def start_detected_frames_processor(self):
-        self.detected_frames_processor = TrackedObjectProcessor(self.config, self.mqtt_client, self.config.mqtt.topic_prefix, 
-            self.detected_frames_queue, self.event_queue, self.event_processed_queue, self.stop_event)
-        self.detected_frames_processor.start()
-
-    def start_camera_processors(self):
-        model_shape = (self.config.model.height, self.config.model.width)
-        for name, config in self.config.cameras.items():
-            camera_process = mp.Process(target=track_camera, name=f"camera_processor:{name}", args=(name, config, model_shape,
-                self.detection_queue, self.detection_out_events[name], self.detected_frames_queue, 
-                self.camera_metrics[name]))
-            camera_process.daemon = True
-            self.camera_metrics[name]['process'] = camera_process
-            camera_process.start()
-            logger.info(f"Camera processor started for {name}: {camera_process.pid}")
-
-    def start_camera_capture_processes(self):
-        for name, config in self.config.cameras.items():
-            capture_process = mp.Process(target=capture_camera, name=f"camera_capture:{name}", args=(name, config,
-                self.camera_metrics[name]))
-            capture_process.daemon = True
-            self.camera_metrics[name]['capture_process'] = capture_process
-            capture_process.start()
-            logger.info(f"Capture process started for {name}: {capture_process.pid}")
-    
-    def start_event_processor(self):
-        self.event_processor = EventProcessor(self.config, self.camera_metrics, self.event_queue, self.event_processed_queue, self.stop_event)
-        self.event_processor.start()
-    
-    def start_event_cleanup(self):
-        self.event_cleanup = EventCleanup(self.config, self.stop_event)
-        self.event_cleanup.start()
-    
-    def start_recording_maintainer(self):
-        self.recording_maintainer = RecordingMaintainer(self.config, self.stop_event)
-        self.recording_maintainer.start()
-
-    def start_watchdog(self):
-        self.frigate_watchdog = FrigateWatchdog(self.detectors, self.stop_event)
-        self.frigate_watchdog.start()
-
-    def start(self):
-        self.init_logger()
-        try:
-            try:
-                self.init_config()
-            except Exception as e:
-                logger.error(f"Error parsing config: {e}")
-                self.log_process.terminate()
-                sys.exit(1)
-            self.ensure_dirs()
-            self.check_config()
-            self.set_log_levels()
-            self.init_queues()
-            self.init_database()
-            self.init_mqtt()
-        except Exception as e:
-            print(e)
-            self.log_process.terminate()
-            sys.exit(1)
-        self.start_detectors()
-        self.start_detected_frames_processor()
-        self.start_camera_processors()
-        self.start_camera_capture_processes()
-        self.init_web_server()
-        self.start_event_processor()
-        self.start_event_cleanup()
-        self.start_recording_maintainer()
-        self.start_watchdog()
-        # self.zeroconf = broadcast_zeroconf(self.config.mqtt.client_id)
-
-        def receiveSignal(signalNumber, frame):
-            self.stop()
-            sys.exit()
-        
-        signal.signal(signal.SIGTERM, receiveSignal)
-
-        self.flask_app.run(host='127.0.0.1', port=5001, debug=False)
-        self.stop()
-    
-    def stop(self):
-        logger.info(f"Stopping...")
-        self.stop_event.set()
-
-        self.detected_frames_processor.join()
-        self.event_processor.join()
-        self.event_cleanup.join()
-        self.recording_maintainer.join()
-        self.frigate_watchdog.join()
-
-        for detector in self.detectors.values():
-            detector.stop()
-
-        while len(self.detection_shms) > 0:
-            shm = self.detection_shms.pop()
-            shm.close()
-            shm.unlink()

frigate/config.py

@@ -1,963 +0,0 @@
-import base64
-import json
-import os
-from typing import Dict
-
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-import voluptuous as vol
-import yaml
-
-from frigate.const import RECORD_DIR, CLIPS_DIR, CACHE_DIR
-
-DETECTORS_SCHEMA = vol.Schema(
-    {
-        vol.Required(str): {
-            vol.Required('type', default='edgetpu'): vol.In(['cpu', 'edgetpu']), 
-            vol.Optional('device', default='usb'): str,
-            vol.Optional('num_threads', default=3): int
-        }
-    }
-)
-
-DEFAULT_DETECTORS = {
-    'coral': {
-        'type': 'edgetpu',
-        'device': 'usb'
-    }
-}
-
-MQTT_SCHEMA = vol.Schema(
-    {
-        vol.Required('host'): str,
-        vol.Optional('port', default=1883): int,
-        vol.Optional('topic_prefix', default='frigate'): str,
-        vol.Optional('client_id', default='frigate'): str,
-        'user': str,
-        'password': str
-    }
-)
-
-SAVE_CLIPS_RETAIN_SCHEMA = vol.Schema(
-    {
-        vol.Required('default',default=10): int,
-        'objects': {
-            str: int
-        }
-    }
-)
-
-SAVE_CLIPS_SCHEMA = vol.Schema(
-    {
-        vol.Optional('max_seconds', default=300): int,
-        'tmpfs_cache_size': str,
-        vol.Optional('retain', default={}): SAVE_CLIPS_RETAIN_SCHEMA
-    }
-)
-
-FFMPEG_GLOBAL_ARGS_DEFAULT = ['-hide_banner','-loglevel','fatal']
-FFMPEG_INPUT_ARGS_DEFAULT = ['-avoid_negative_ts', 'make_zero',
-    '-fflags', '+genpts+discardcorrupt',
-    '-rtsp_transport', 'tcp',
-    '-stimeout', '5000000',
-    '-use_wallclock_as_timestamps', '1']
-DETECT_FFMPEG_OUTPUT_ARGS_DEFAULT = ['-f', 'rawvideo',
-    '-pix_fmt', 'yuv420p']
-RTMP_FFMPEG_OUTPUT_ARGS_DEFAULT = ["-c", "copy", "-f", "flv"]
-SAVE_CLIPS_FFMPEG_OUTPUT_ARGS_DEFAULT = ["-f", "segment", "-segment_time",
-    "10", "-segment_format", "mp4", "-reset_timestamps", "1", "-strftime",
-    "1", "-c", "copy", "-an"]
-RECORD_FFMPEG_OUTPUT_ARGS_DEFAULT = ["-f", "segment", "-segment_time",
-    "60", "-segment_format", "mp4", "-reset_timestamps", "1", "-strftime",
-    "1", "-c", "copy", "-an"]
-
-GLOBAL_FFMPEG_SCHEMA = vol.Schema(
-    { 
-        vol.Optional('global_args', default=FFMPEG_GLOBAL_ARGS_DEFAULT):  vol.Any(str, [str]),
-        vol.Optional('hwaccel_args', default=[]): vol.Any(str, [str]),
-        vol.Optional('input_args', default=FFMPEG_INPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-        vol.Optional('output_args', default={}): {
-            vol.Optional('detect', default=DETECT_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('record', default=RECORD_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('clips', default=SAVE_CLIPS_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('rtmp', default=RTMP_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-        }
-    }
-)
-
-MOTION_SCHEMA = vol.Schema(
-    {
-        'threshold': vol.Range(min=1, max=255),
-        'contour_area': int,
-        'delta_alpha': float,
-        'frame_alpha': float,
-        'frame_height': int
-    }
-)
-
-DETECT_SCHEMA = vol.Schema(
-    {
-        'max_disappeared': int
-    }
-)
-
-FILTER_SCHEMA = vol.Schema(
-    { 
-        str: {
-                vol.Optional('min_area', default=0): int,
-                vol.Optional('max_area', default=24000000): int,
-                vol.Optional('threshold', default=0.7): float
-            }
-    }
-)
-
-def filters_for_all_tracked_objects(object_config):
-    for tracked_object in object_config.get('track', ['person']):
-        if not 'filters' in object_config:
-            object_config['filters'] = {}
-        if not tracked_object in object_config['filters']:
-            object_config['filters'][tracked_object] = {}
-    return object_config
-
-OBJECTS_SCHEMA = vol.Schema(vol.All(filters_for_all_tracked_objects,
-    {
-        vol.Optional('track', default=['person']): [str],
-        vol.Optional('filters', default = {}): FILTER_SCHEMA.extend({ str: {vol.Optional('min_score', default=0.5): float}})
-    }
-))
-
-def each_role_used_once(inputs):
-    roles = [role for i in inputs for role in i['roles']]
-    roles_set = set(roles)
-    if len(roles) > len(roles_set):
-        raise ValueError
-    return inputs
-
-CAMERA_FFMPEG_SCHEMA = vol.Schema(
-    { 
-        vol.Required('inputs'): vol.All([{
-            vol.Required('path'): str,
-            vol.Required('roles'): ['detect', 'clips', 'record', 'rtmp'],
-            'global_args':  vol.Any(str, [str]),
-            'hwaccel_args': vol.Any(str, [str]),
-            'input_args': vol.Any(str, [str]),
-        }], vol.Msg(each_role_used_once, msg="Each input role may only be used once")), 
-        'output_args': {
-            vol.Optional('detect', default=DETECT_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('record', default=RECORD_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('clips', default=SAVE_CLIPS_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-            vol.Optional('rtmp', default=RTMP_FFMPEG_OUTPUT_ARGS_DEFAULT): vol.Any(str, [str]),
-        }
-    }
-)
-
-def ensure_zones_and_cameras_have_different_names(cameras):
-    zones = [zone for camera in cameras.values() for zone in camera['zones'].keys()]
-    for zone in zones:
-        if zone in cameras.keys():
-            raise ValueError
-    return cameras
-
-CAMERAS_SCHEMA = vol.Schema(vol.All(
-    {
-        str: {
-            vol.Required('ffmpeg'): CAMERA_FFMPEG_SCHEMA,
-            vol.Required('height'): int,
-            vol.Required('width'): int,
-            'fps': int,
-            'mask': vol.Any(str, [str]),
-            vol.Optional('best_image_timeout', default=60): int,
-            vol.Optional('zones', default={}):  {
-                str: {
-                    vol.Required('coordinates'): vol.Any(str, [str]),
-                    vol.Optional('filters', default={}): FILTER_SCHEMA
-                }
-            },
-            vol.Optional('save_clips', default={}): {
-                vol.Optional('enabled', default=False): bool,
-                vol.Optional('pre_capture', default=5): int,
-                vol.Optional('post_capture', default=5): int,
-                'objects': [str],
-                vol.Optional('retain', default={}): SAVE_CLIPS_RETAIN_SCHEMA,
-            },
-            vol.Optional('record', default={}): {
-                'enabled': bool,
-                'retain_days': int,
-            },
-            vol.Optional('rtmp', default={}): {
-                vol.Required('enabled', default=True): bool,
-            },
-            vol.Optional('snapshots', default={}): {
-                vol.Optional('show_timestamp', default=True): bool,
-                vol.Optional('draw_zones', default=False): bool,
-                vol.Optional('draw_bounding_boxes', default=True): bool,
-                vol.Optional('crop_to_region', default=True): bool,
-                vol.Optional('height', default=175): int
-            },
-            'objects': OBJECTS_SCHEMA,
-            vol.Optional('motion', default={}): MOTION_SCHEMA,
-            vol.Optional('detect', default={}): DETECT_SCHEMA
-        }
-    }, vol.Msg(ensure_zones_and_cameras_have_different_names, msg='Zones cannot share names with cameras'))
-)
-
-FRIGATE_CONFIG_SCHEMA = vol.Schema(
-    {
-        vol.Optional('database', default={}): {
-            vol.Optional('path', default=os.path.join(CLIPS_DIR, 'frigate.db')): str
-        },
-        vol.Optional('model', default={'width': 320, 'height': 320}): {
-            vol.Required('width'): int,
-            vol.Required('height'): int
-        },
-        vol.Optional('detectors', default=DEFAULT_DETECTORS): DETECTORS_SCHEMA,
-        'mqtt': MQTT_SCHEMA,
-        vol.Optional('logger', default={'default': 'info', 'logs': {}}): {
-            vol.Optional('default', default='info'): vol.In(['info', 'debug', 'warning', 'error', 'critical']),
-            vol.Optional('logs', default={}): {str: vol.In(['info', 'debug', 'warning', 'error', 'critical']) }
-        },
-        vol.Optional('save_clips', default={}): SAVE_CLIPS_SCHEMA,
-        vol.Optional('record', default={}): {
-            vol.Optional('enabled', default=False): bool,
-            vol.Optional('retain_days', default=30): int,
-        },
-        vol.Optional('ffmpeg', default={}): GLOBAL_FFMPEG_SCHEMA,
-        vol.Optional('objects', default={}): OBJECTS_SCHEMA,
-        vol.Optional('motion', default={}): MOTION_SCHEMA,
-        vol.Optional('detect', default={}): DETECT_SCHEMA,
-        vol.Required('cameras', default={}): CAMERAS_SCHEMA
-    }
-)
-
-class DatabaseConfig():
-    def __init__(self, config):
-        self._path = config['path']
-
-    @property
-    def path(self):
-        return self._path
-    
-    def to_dict(self):
-        return {
-            'path': self.path
-        }
-
-class ModelConfig():
-    def __init__(self, config):
-        self._width = config['width']
-        self._height = config['height']
-    
-    @property
-    def width(self):
-        return self._width
-    
-    @property
-    def height(self):
-        return self._height
-    
-    def to_dict(self):
-        return {
-            'width': self.width,
-            'height': self.height
-        }
-
-class DetectorConfig():
-    def __init__(self, config):
-        self._type = config['type']
-        self._device = config['device']
-        self._num_threads = config['num_threads']
-    
-    @property
-    def type(self):
-        return self._type
-    
-    @property
-    def device(self):
-        return self._device
-    
-    @property
-    def num_threads(self):
-        return self._num_threads
-    
-    def to_dict(self):
-        return {
-            'type': self.type,
-            'device': self.device,
-            'num_threads': self.num_threads
-        }
-
-class LoggerConfig():
-    def __init__(self, config):
-        self._default = config['default'].upper()
-        self._logs = {k: v.upper() for k, v in config['logs'].items()}
-    
-    @property
-    def default(self):
-        return self._default
-    
-    @property
-    def logs(self):
-        return self._logs
-    
-    def to_dict(self):
-        return {
-            'default': self.default,
-            'logs': self.logs
-        }
-
-class MqttConfig():
-    def __init__(self, config):
-        self._host = config['host']
-        self._port = config['port']
-        self._topic_prefix = config['topic_prefix']
-        self._client_id = config['client_id']
-        self._user = config.get('user')
-        self._password = config.get('password')
-    
-    @property
-    def host(self):
-        return self._host
-    
-    @property
-    def port(self):
-        return self._port
-    
-    @property
-    def topic_prefix(self):
-        return self._topic_prefix
-    
-    @property
-    def client_id(self):
-        return self._client_id
-    
-    @property
-    def user(self):
-        return self._user
-    
-    @property
-    def password(self):
-        return self._password
-
-    def to_dict(self):
-        return {
-            'host': self.host,
-            'port': self.port,
-            'topic_prefix': self.topic_prefix,
-            'client_id': self.client_id,
-            'user': self.user
-        }
-
-class CameraInput():
-    def __init__(self, global_config, ffmpeg_input):
-        self._path = ffmpeg_input['path']
-        self._roles = ffmpeg_input['roles']
-        self._global_args = ffmpeg_input.get('global_args', global_config['global_args'])
-        self._hwaccel_args = ffmpeg_input.get('hwaccel_args', global_config['hwaccel_args'])
-        self._input_args = ffmpeg_input.get('input_args', global_config['input_args'])
-    
-    @property
-    def path(self):
-        return self._path
-    
-    @property
-    def roles(self):
-        return self._roles
-    
-    @property
-    def global_args(self):
-        return self._global_args if isinstance(self._global_args, list) else self._global_args.split(' ')
-    
-    @property
-    def hwaccel_args(self):
-        return self._hwaccel_args if isinstance(self._hwaccel_args, list) else self._hwaccel_args.split(' ')
-
-    @property
-    def input_args(self):
-        return self._input_args if isinstance(self._input_args, list) else self._input_args.split(' ')
-
-class CameraFfmpegConfig():
-    def __init__(self, global_config, config):
-        self._inputs = [CameraInput(global_config, i) for i in config['inputs']]
-        self._output_args = config.get('output_args', global_config['output_args'])
-    
-    @property
-    def inputs(self):
-        return self._inputs
-    
-    @property
-    def output_args(self):
-        return {k: v if isinstance(v, list) else v.split(' ') for k, v in self._output_args.items()}
-
-class SaveClipsRetainConfig():
-    def __init__(self, global_config, config):
-        self._default = config.get('default', global_config.get('default'))
-        self._objects = config.get('objects', global_config.get('objects', {}))
-    
-    @property
-    def default(self):
-        return self._default
-    
-    @property
-    def objects(self):
-        return self._objects
-    
-    def to_dict(self):
-        return {
-            'default': self.default,
-            'objects': self.objects
-        }
-
-class SaveClipsConfig():
-    def __init__(self, config):
-        self._max_seconds = config['max_seconds']
-        self._tmpfs_cache_size = config.get('tmpfs_cache_size', '').strip()
-        self._retain = SaveClipsRetainConfig(config['retain'], config['retain'])
-    
-    @property
-    def max_seconds(self):
-        return self._max_seconds
-    
-    @property
-    def tmpfs_cache_size(self):
-        return self._tmpfs_cache_size
-
-    @property
-    def retain(self):
-        return self._retain
-    
-    def to_dict(self):
-        return {
-            'max_seconds': self.max_seconds,
-            'tmpfs_cache_size': self.tmpfs_cache_size,
-            'retain': self.retain.to_dict()
-        }
-
-class RecordConfig():
-    def __init__(self, global_config, config):
-        self._enabled = config.get('enabled', global_config['enabled'])
-        self._retain_days = config.get('retain_days', global_config['retain_days'])
-
-    @property
-    def enabled(self):
-        return self._enabled
-    
-    @property
-    def retain_days(self):
-        return self._retain_days
-    
-    def to_dict(self):
-        return {
-            'enabled': self.enabled,
-            'retain_days': self.retain_days,
-        }
-
-class FilterConfig():
-    def __init__(self, config):
-        self._min_area = config['min_area']
-        self._max_area = config['max_area']
-        self._threshold = config['threshold']
-        self._min_score = config.get('min_score')
-    
-    @property
-    def min_area(self):
-        return self._min_area
-
-    @property
-    def max_area(self):
-        return self._max_area
-
-    @property
-    def threshold(self):
-        return self._threshold
-    
-    @property
-    def min_score(self):
-        return self._min_score
-    
-    def to_dict(self):
-        return {
-            'min_area': self.min_area,
-            'max_area': self.max_area,
-            'threshold': self.threshold,
-            'min_score': self.min_score
-        }
-
-class ObjectConfig():
-    def __init__(self, global_config, config):
-        self._track = config.get('track', global_config['track'])
-        if 'filters' in config:
-            self._filters = { name: FilterConfig(c) for name, c in config['filters'].items() }
-        else:
-            self._filters = { name: FilterConfig(c) for name, c in global_config['filters'].items() }
-    
-    @property
-    def track(self):
-        return self._track
-    
-    @property
-    def filters(self) -> Dict[str, FilterConfig]:
-        return self._filters
-
-    def to_dict(self):
-        return {
-            'track': self.track,
-            'filters': { k: f.to_dict() for k, f in self.filters.items() }
-        }
-
-class CameraSnapshotsConfig():
-    def __init__(self, config):
-        self._show_timestamp = config['show_timestamp']
-        self._draw_zones = config['draw_zones']
-        self._draw_bounding_boxes = config['draw_bounding_boxes']
-        self._crop_to_region = config['crop_to_region']
-        self._height = config.get('height')
-    
-    @property
-    def show_timestamp(self):
-        return self._show_timestamp
-    
-    @property
-    def draw_zones(self):
-        return self._draw_zones
-
-    @property
-    def draw_bounding_boxes(self):
-        return self._draw_bounding_boxes
-
-    @property
-    def crop_to_region(self):
-        return self._crop_to_region
-
-    @property
-    def height(self):
-        return self._height
-    
-    def to_dict(self):
-        return {
-            'show_timestamp': self.show_timestamp,
-            'draw_zones': self.draw_zones,
-            'draw_bounding_boxes': self.draw_bounding_boxes,
-            'crop_to_region': self.crop_to_region,
-            'height': self.height
-        }
-
-class CameraSaveClipsConfig():
-    def __init__(self, global_config, config):
-        self._enabled = config['enabled']
-        self._pre_capture = config['pre_capture']
-        self._post_capture = config['post_capture']
-        self._objects = config.get('objects', global_config['objects']['track'])
-        self._retain = SaveClipsRetainConfig(global_config['save_clips']['retain'], config['retain'])
-    
-    @property
-    def enabled(self):
-        return self._enabled
-    
-    @property
-    def pre_capture(self):
-        return self._pre_capture
-    
-    @property
-    def post_capture(self):
-        return self._post_capture
-
-    @property
-    def objects(self):
-        return self._objects
-    
-    @property
-    def retain(self):
-        return self._retain
-    
-    def to_dict(self):
-        return {
-            'enabled': self.enabled,
-            'pre_capture': self.pre_capture,
-            'post_capture': self.post_capture,
-            'objects': self.objects,
-            'retain': self.retain.to_dict()
-        }
-
-class CameraRtmpConfig():
-    def __init__(self, global_config, config):
-        self._enabled = config['enabled']
-    
-    @property
-    def enabled(self):
-        return self._enabled
-    
-    def to_dict(self):
-        return {
-            'enabled': self.enabled,
-        }
-
-class MotionConfig():
-    def __init__(self, global_config, config, camera_height: int):
-        self._threshold = config.get('threshold', global_config.get('threshold', 25))
-        self._contour_area = config.get('contour_area', global_config.get('contour_area', 100))
-        self._delta_alpha = config.get('delta_alpha', global_config.get('delta_alpha', 0.2))
-        self._frame_alpha = config.get('frame_alpha', global_config.get('frame_alpha', 0.2))
-        self._frame_height = config.get('frame_height', global_config.get('frame_height', camera_height//6))
-    
-    @property
-    def threshold(self):
-        return self._threshold
-
-    @property
-    def contour_area(self):
-        return self._contour_area
-
-    @property
-    def delta_alpha(self):
-        return self._delta_alpha
-
-    @property
-    def frame_alpha(self):
-        return self._frame_alpha
-
-    @property
-    def frame_height(self):
-        return self._frame_height
-    
-    def to_dict(self):
-        return {
-            'threshold': self.threshold,
-            'contour_area': self.contour_area,
-            'delta_alpha': self.delta_alpha,
-            'frame_alpha': self.frame_alpha,
-            'frame_height': self.frame_height,
-        }
-
-
-
-class DetectConfig():
-    def __init__(self, global_config, config, camera_fps):
-        self._max_disappeared = config.get('max_disappeared', global_config.get('max_disappeared', camera_fps*2))
-    
-    @property
-    def max_disappeared(self):
-        return self._max_disappeared
-    
-    def to_dict(self):
-        return {
-            'max_disappeared': self._max_disappeared,
-        }
-
-class ZoneConfig():
-    def __init__(self, name, config):
-        self._coordinates = config['coordinates']
-        self._filters = { name: FilterConfig(c) for name, c in config['filters'].items() }
-
-        if isinstance(self._coordinates, list):
-            self._contour =  np.array([[int(p.split(',')[0]), int(p.split(',')[1])] for p in self._coordinates])
-        elif isinstance(self._coordinates, str):
-            points = self._coordinates.split(',')
-            self._contour =  np.array([[int(points[i]), int(points[i+1])] for i in range(0, len(points), 2)])
-        else:
-            print(f"Unable to parse zone coordinates for {name}")
-            self._contour = np.array([])
-        
-        self._color = (0,0,0)
-    
-    @property
-    def coordinates(self):
-        return self._coordinates
-    
-    @property
-    def contour(self):
-        return self._contour
-    
-    @contour.setter
-    def contour(self, val):
-        self._contour = val
-    
-    @property
-    def color(self):
-        return self._color
-    
-    @color.setter
-    def color(self, val):
-        self._color = val
-    
-    @property
-    def filters(self):
-        return self._filters
-    
-    def to_dict(self):
-        return {
-            'filters': {k: f.to_dict() for k, f in self.filters.items()}
-        }
-
-class CameraConfig():
-    def __init__(self, name, config, global_config):
-        self._name = name
-        self._ffmpeg = CameraFfmpegConfig(global_config['ffmpeg'], config['ffmpeg'])
-        self._height = config.get('height')
-        self._width = config.get('width')
-        self._frame_shape = (self._height, self._width)
-        self._frame_shape_yuv = (self._frame_shape[0]*3//2, self._frame_shape[1])
-        self._fps = config.get('fps')
-        self._mask = self._create_mask(config.get('mask'))
-        self._best_image_timeout = config['best_image_timeout']
-        self._zones = { name: ZoneConfig(name, z) for name, z in config['zones'].items() }
-        self._save_clips = CameraSaveClipsConfig(global_config, config['save_clips'])
-        self._record = RecordConfig(global_config['record'], config['record'])
-        self._rtmp = CameraRtmpConfig(global_config, config['rtmp'])
-        self._snapshots = CameraSnapshotsConfig(config['snapshots'])
-        self._objects = ObjectConfig(global_config['objects'], config.get('objects', {}))
-        self._motion = MotionConfig(global_config['motion'], config['motion'], self._height)
-        self._detect = DetectConfig(global_config['detect'], config['detect'], config.get('fps', 5))
-
-        self._ffmpeg_cmds = []
-        for ffmpeg_input in self._ffmpeg.inputs:
-            ffmpeg_cmd = self._get_ffmpeg_cmd(ffmpeg_input)
-            if ffmpeg_cmd is None:
-                continue
-
-            self._ffmpeg_cmds.append({
-                'roles': ffmpeg_input.roles,
-                'cmd': ffmpeg_cmd
-            })
-
-
-        self._set_zone_colors(self._zones)
-
-    def _create_mask(self, mask):
-        mask_img = np.zeros(self.frame_shape, np.uint8)
-        mask_img[:] = 255
-
-        if isinstance(mask, list):
-            for m in mask:
-                self._add_mask(m, mask_img)
-
-        elif isinstance(mask, str):
-            self._add_mask(mask, mask_img)
-        
-        return mask_img
-    
-    def _add_mask(self, mask, mask_img):
-        if mask.startswith('poly,'):
-            points = mask.split(',')[1:]
-            contour =  np.array([[int(points[i]), int(points[i+1])] for i in range(0, len(points), 2)])
-            cv2.fillPoly(mask_img, pts=[contour], color=(0))
-        else:
-            mask_file = cv2.imread(f"/config/{mask}", cv2.IMREAD_GRAYSCALE)
-            if not mask_file.size == 0:
-                mask_img[np.where(mask_file==[0])] = [0]
-    
-    def _get_ffmpeg_cmd(self, ffmpeg_input):
-        ffmpeg_output_args = []
-        if 'detect' in ffmpeg_input.roles:
-            ffmpeg_output_args = self.ffmpeg.output_args['detect'] + ffmpeg_output_args + ['pipe:']
-            if self.fps:
-                ffmpeg_output_args = ["-r", str(self.fps)] + ffmpeg_output_args
-        if 'rtmp' in ffmpeg_input.roles and self.rtmp.enabled:
-            ffmpeg_output_args = self.ffmpeg.output_args['rtmp'] + [
-                f"rtmp://127.0.0.1/live/{self.name}"
-            ] + ffmpeg_output_args
-        if 'clips' in ffmpeg_input.roles and self.save_clips.enabled:
-            ffmpeg_output_args = self.ffmpeg.output_args['clips'] + [
-                f"{os.path.join(CACHE_DIR, self.name)}-%Y%m%d%H%M%S.mp4"
-            ] + ffmpeg_output_args
-        if 'record' in ffmpeg_input.roles and self.record.enabled:
-            ffmpeg_output_args = self.ffmpeg.output_args['record'] + [
-                f"{os.path.join(RECORD_DIR, self.name)}-%Y%m%d%H%M%S.mp4"
-            ] + ffmpeg_output_args
-        
-        # if there arent any outputs enabled for this input
-        if len(ffmpeg_output_args) == 0:
-            return None
-
-        cmd = (['ffmpeg'] +
-                ffmpeg_input.global_args +
-                ffmpeg_input.hwaccel_args +
-                ffmpeg_input.input_args +
-                ['-i', ffmpeg_input.path] +
-                ffmpeg_output_args)
-        
-        return [part for part in cmd if part != '']
-    
-    def _set_zone_colors(self, zones: Dict[str, ZoneConfig]):
-        # set colors for zones
-        all_zone_names = zones.keys()
-        zone_colors = {}
-        colors = plt.cm.get_cmap('tab10', len(all_zone_names))
-        for i, zone in enumerate(all_zone_names):
-            zone_colors[zone] = tuple(int(round(255 * c)) for c in colors(i)[:3])
-        
-        for name, zone in zones.items():
-            zone.color = zone_colors[name]
-    
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def ffmpeg(self):
-        return self._ffmpeg
-    
-    @property
-    def height(self):
-        return self._height
-    
-    @property
-    def width(self):
-        return self._width
-    
-    @property
-    def fps(self):
-        return self._fps
-    
-    @property
-    def mask(self):
-        return self._mask
-    
-    @property
-    def best_image_timeout(self):
-        return self._best_image_timeout
-    
-    @property
-    def zones(self)-> Dict[str, ZoneConfig]:
-        return self._zones
-    
-    @property
-    def save_clips(self):
-        return self._save_clips
-    
-    @property
-    def record(self):
-        return self._record
-    
-    @property
-    def rtmp(self):
-        return self._rtmp
-    
-    @property
-    def snapshots(self):
-        return self._snapshots
-    
-    @property
-    def objects(self):
-        return self._objects
-    
-    @property
-    def motion(self):
-        return self._motion
-    
-    @property
-    def detect(self):
-        return self._detect
-
-    @property
-    def frame_shape(self):
-        return self._frame_shape
-
-    @property
-    def frame_shape_yuv(self):
-        return self._frame_shape_yuv
-
-    @property
-    def ffmpeg_cmds(self):
-        return self._ffmpeg_cmds
-
-    def to_dict(self):
-        return {
-            'name': self.name,
-            'height': self.height,
-            'width': self.width,
-            'fps': self.fps,
-            'best_image_timeout': self.best_image_timeout,
-            'zones': {k: z.to_dict() for k, z in self.zones.items()},
-            'save_clips': self.save_clips.to_dict(),
-            'record': self.record.to_dict(),
-            'rtmp': self.rtmp.to_dict(),
-            'snapshots': self.snapshots.to_dict(),
-            'objects': self.objects.to_dict(),
-            'motion': self.motion.to_dict(),
-            'detect': self.detect.to_dict(),
-            'frame_shape': self.frame_shape,
-            'ffmpeg_cmds': [{'roles': c['roles'], 'cmd': ' '.join(c['cmd'])} for c in self.ffmpeg_cmds],
-        }
-
-
-class FrigateConfig():
-    def __init__(self, config_file=None, config=None):
-        if config is None and config_file is None:
-            raise ValueError('config or config_file must be defined')
-        elif not config_file is None:
-            config = self._load_file(config_file)
-        
-        config = FRIGATE_CONFIG_SCHEMA(config)
-
-        config = self._sub_env_vars(config)
-
-        self._database = DatabaseConfig(config['database'])
-        self._model = ModelConfig(config['model'])
-        self._detectors = { name: DetectorConfig(d) for name, d in config['detectors'].items() }
-        self._mqtt = MqttConfig(config['mqtt'])
-        self._save_clips = SaveClipsConfig(config['save_clips'])
-        self._cameras = { name: CameraConfig(name, c, config) for name, c in config['cameras'].items() }
-        self._logger = LoggerConfig(config['logger'])
-
-    def _sub_env_vars(self, config):
-        frigate_env_vars = {k: v for k, v in os.environ.items() if k.startswith('FRIGATE_')}
-
-        if 'password' in config['mqtt']:
-            config['mqtt']['password'] = config['mqtt']['password'].format(**frigate_env_vars) 
-        
-        for camera in config['cameras'].values():
-            for i in camera['ffmpeg']['inputs']:
-                i['path'] = i['path'].format(**frigate_env_vars)
-        
-        return config
-
-    def _load_file(self, config_file):
-        with open(config_file) as f:
-            raw_config = f.read()
-        
-        if config_file.endswith(".yml"):    
-            config = yaml.safe_load(raw_config)
-        elif config_file.endswith(".json"):
-            config = json.loads(raw_config)
-        
-        return config
-    
-    def to_dict(self):
-        return {
-            'database': self.database.to_dict(),
-            'model': self.model.to_dict(),
-            'detectors': {k: d.to_dict() for k, d in self.detectors.items()},
-            'mqtt': self.mqtt.to_dict(),
-            'save_clips': self.save_clips.to_dict(),
-            'cameras': {k: c.to_dict() for k, c in self.cameras.items()},
-            'logger': self.logger.to_dict()
-        }
-    
-    @property
-    def database(self):
-        return self._database
-    
-    @property
-    def model(self):
-        return self._model
-    
-    @property
-    def detectors(self) -> Dict[str, DetectorConfig]:
-        return self._detectors
-    
-    @property
-    def logger(self):
-        return self._logger
-
-    @property
-    def mqtt(self):
-        return self._mqtt
-    
-    @property
-    def save_clips(self):
-        return self._save_clips
-
-    @property
-    def cameras(self) -> Dict[str, CameraConfig]:
-        return self._cameras

frigate/const.py

@@ -1,3 +0,0 @@
-CLIPS_DIR = '/media/frigate/clips'
-RECORD_DIR = '/media/frigate/recordings'
-CACHE_DIR = '/tmp/cache'

frigate/edgetpu.py

@@ -1,22 +1,15 @@
+import os
 import datetime
 import hashlib
-import logging
 import multiprocessing as mp
-import os
 import queue
-import threading
-import signal
-from abc import ABC, abstractmethod
 from multiprocessing.connection import Connection
+from abc import ABC, abstractmethod
 from typing import Dict
-
 import numpy as np
 import tflite_runtime.interpreter as tflite
 from tflite_runtime.interpreter import load_delegate
-
-from frigate.util import EventsPerSecond, SharedMemoryFrameManager, listen
-
-logger = logging.getLogger(__name__)
+from frigate.util import EventsPerSecond, listen, SharedMemoryFrameManager
 
 def load_labels(path, encoding='utf-8'):
   """Loads labels from file (with or without index numbers).
@@ -43,7 +36,7 @@ class ObjectDetector(ABC):
         pass
 
 class LocalObjectDetector(ObjectDetector):
-    def __init__(self, tf_device=None, num_threads=3, labels=None):
+    def __init__(self, tf_device=None, labels=None):
         self.fps = EventsPerSecond()
         if labels is None:
             self.labels = {}
@@ -58,15 +51,15 @@ class LocalObjectDetector(ObjectDetector):
 
         if tf_device != 'cpu':
             try:
-                logger.info(f"Attempting to load TPU as {device_config['device']}")
+                print(f"Attempting to load TPU as {device_config['device']}")
                 edge_tpu_delegate = load_delegate('libedgetpu.so.1.0', device_config)
-                logger.info("TPU found")
+                print("TPU found")
             except ValueError:
-                logger.info("No EdgeTPU detected. Falling back to CPU.")
+                print("No EdgeTPU detected. Falling back to CPU.")
         
         if edge_tpu_delegate is None:
             self.interpreter = tflite.Interpreter(
-                model_path='/cpu_model.tflite', num_threads=num_threads)
+                model_path='/cpu_model.tflite')
         else:
             self.interpreter = tflite.Interpreter(
                 model_path='/edgetpu_model.tflite',
@@ -106,21 +99,11 @@ class LocalObjectDetector(ObjectDetector):
         
         return detections
 
-def run_detector(name: str, detection_queue: mp.Queue, out_events: Dict[str, mp.Event], avg_speed, start, model_shape, tf_device, num_threads):
-    threading.current_thread().name = f"detector:{name}"
-    logger = logging.getLogger(f"detector.{name}")
-    logger.info(f"Starting detection process: {os.getpid()}")
+def run_detector(detection_queue, out_events: Dict[str, mp.Event], avg_speed, start, tf_device):
+    print(f"Starting detection process: {os.getpid()}")
     listen()
-
-    stop_event = mp.Event()
-    def receiveSignal(signalNumber, frame):
-        stop_event.set()
-    
-    signal.signal(signal.SIGTERM, receiveSignal)
-    signal.signal(signal.SIGINT, receiveSignal)
-
     frame_manager = SharedMemoryFrameManager()
-    object_detector = LocalObjectDetector(tf_device=tf_device, num_threads=num_threads)
+    object_detector = LocalObjectDetector(tf_device=tf_device)
 
     outputs = {}
     for name in out_events.keys():
@@ -132,14 +115,8 @@ def run_detector(name: str, detection_queue: mp.Queue, out_events: Dict[str, mp.
         }
     
     while True:
-        if stop_event.is_set():
-            break
-
-        try:
-            connection_id = detection_queue.get(timeout=5)
-        except queue.Empty:
-            continue
-        input_frame = frame_manager.get(connection_id, (1,model_shape[0],model_shape[1],3))
+        connection_id = detection_queue.get()
+        input_frame = frame_manager.get(connection_id, (1,300,300,3))
 
         if input_frame is None:
             continue
@@ -155,24 +132,21 @@ def run_detector(name: str, detection_queue: mp.Queue, out_events: Dict[str, mp.
         avg_speed.value = (avg_speed.value*9 + duration)/10
         
 class EdgeTPUProcess():
-    def __init__(self, name, detection_queue, out_events, model_shape, tf_device=None, num_threads=3):
-        self.name = name
+    def __init__(self, detection_queue, out_events, tf_device=None):
         self.out_events = out_events
         self.detection_queue = detection_queue
         self.avg_inference_speed = mp.Value('d', 0.01)
         self.detection_start = mp.Value('d', 0.0)
         self.detect_process = None
-        self.model_shape = model_shape
         self.tf_device = tf_device
-        self.num_threads = num_threads
         self.start_or_restart()
     
     def stop(self):
         self.detect_process.terminate()
-        logging.info("Waiting for detection process to exit gracefully...")
+        print("Waiting for detection process to exit gracefully...")
         self.detect_process.join(timeout=30)
         if self.detect_process.exitcode is None:
-            logging.info("Detection process didnt exit. Force killing...")
+            print("Detection process didnt exit. Force killing...")
             self.detect_process.kill()
             self.detect_process.join()
 
@@ -180,19 +154,19 @@ class EdgeTPUProcess():
         self.detection_start.value = 0.0
         if (not self.detect_process is None) and self.detect_process.is_alive():
             self.stop()
-        self.detect_process = mp.Process(target=run_detector, name=f"detector:{self.name}", args=(self.name, self.detection_queue, self.out_events, self.avg_inference_speed, self.detection_start, self.model_shape, self.tf_device, self.num_threads))
+        self.detect_process = mp.Process(target=run_detector, args=(self.detection_queue, self.out_events, self.avg_inference_speed, self.detection_start, self.tf_device))
         self.detect_process.daemon = True
         self.detect_process.start()
 
 class RemoteObjectDetector():
-    def __init__(self, name, labels, detection_queue, event, model_shape):
+    def __init__(self, name, labels, detection_queue, event):
         self.labels = load_labels(labels)
         self.name = name
         self.fps = EventsPerSecond()
         self.detection_queue = detection_queue
         self.event = event
         self.shm = mp.shared_memory.SharedMemory(name=self.name, create=False)
-        self.np_shm = np.ndarray((1,model_shape[0],model_shape[1],3), dtype=np.uint8, buffer=self.shm.buf)
+        self.np_shm = np.ndarray((1,300,300,3), dtype=np.uint8, buffer=self.shm.buf)
         self.out_shm = mp.shared_memory.SharedMemory(name=f"out-{self.name}", create=False)
         self.out_np_shm = np.ndarray((20,6), dtype=np.float32, buffer=self.out_shm.buf)
     
@@ -222,4 +196,4 @@ class RemoteObjectDetector():
     
     def cleanup(self):
         self.shm.unlink()
-        self.out_shm.unlink()
+        self.out_shm.unlink()

frigate/events.py

@@ -1,49 +1,36 @@
-import datetime
-import json
-import logging
 import os
-import queue
-import subprocess as sp
-import threading
 import time
-from collections import defaultdict
-from pathlib import Path
-
 import psutil
-
-from frigate.config import FrigateConfig
-from frigate.const import RECORD_DIR, CLIPS_DIR, CACHE_DIR
-from frigate.models import Event
-
-from peewee import fn
-
-logger = logging.getLogger(__name__)
+import threading
+from collections import defaultdict
+import json
+import datetime
+import subprocess as sp
+import queue
 
 class EventProcessor(threading.Thread):
-    def __init__(self, config, camera_processes, event_queue, event_processed_queue, stop_event):
+    def __init__(self, config, camera_processes, cache_dir, clip_dir, event_queue, stop_event):
         threading.Thread.__init__(self)
-        self.name = 'event_processor'
         self.config = config
         self.camera_processes = camera_processes
+        self.cache_dir = cache_dir
+        self.clip_dir = clip_dir
         self.cached_clips = {}
         self.event_queue = event_queue
-        self.event_processed_queue = event_processed_queue
         self.events_in_process = {}
         self.stop_event = stop_event
     
     def refresh_cache(self):
-        cached_files = os.listdir(CACHE_DIR)
+        cached_files = os.listdir(self.cache_dir)
 
         files_in_use = []
-        for process in psutil.process_iter():
+        for process_data in self.camera_processes.values():
             try:
-                if process.name() != 'ffmpeg':
-                    continue
-
-                flist = process.open_files()
+                ffmpeg_process = psutil.Process(pid=process_data['ffmpeg_process'].pid)
+                flist = ffmpeg_process.open_files()
                 if flist:
                     for nt in flist:
-                        if nt.path.startswith(CACHE_DIR):
+                        if nt.path.startswith(self.cache_dir):
                             files_in_use.append(nt.path.split('/')[-1])
             except:
                 continue
@@ -63,7 +50,7 @@ class EventProcessor(threading.Thread):
                 'format=duration',
                 '-of',
                 'default=noprint_wrappers=1:nokey=1',
-                f"{os.path.join(CACHE_DIR,f)}"
+                f"{os.path.join(self.cache_dir,f)}"
             ])
             p = sp.Popen(ffprobe_cmd, stdout=sp.PIPE, shell=True)
             (output, err) = p.communicate()
@@ -71,8 +58,8 @@ class EventProcessor(threading.Thread):
             if p_status == 0:
                 duration = float(output.decode('utf-8').strip())
             else:
-                logger.info(f"bad file: {f}")
-                os.remove(os.path.join(CACHE_DIR,f))
+                print(f"bad file: {f}")
+                os.remove(os.path.join(self.cache_dir,f))
                 continue
 
             self.cached_clips[f] = {
@@ -88,27 +75,27 @@ class EventProcessor(threading.Thread):
             earliest_event = datetime.datetime.now().timestamp()
 
         # if the earliest event exceeds the max seconds, cap it
-        max_seconds = self.config.save_clips.max_seconds
+        max_seconds = self.config.get('save_clips', {}).get('max_seconds', 300)
         if datetime.datetime.now().timestamp()-earliest_event > max_seconds:
             earliest_event = datetime.datetime.now().timestamp()-max_seconds
         
         for f, data in list(self.cached_clips.items()):
             if earliest_event-90 > data['start_time']+data['duration']:
                 del self.cached_clips[f]
-                os.remove(os.path.join(CACHE_DIR,f))
+                os.remove(os.path.join(self.cache_dir,f))
 
-    def create_clip(self, camera, event_data, pre_capture, post_capture):
+    def create_clip(self, camera, event_data, pre_capture):
         # get all clips from the camera with the event sorted
         sorted_clips = sorted([c for c in self.cached_clips.values() if c['camera'] == camera], key = lambda i: i['start_time'])
 
-        while len(sorted_clips) == 0 or sorted_clips[-1]['start_time'] + sorted_clips[-1]['duration'] < event_data['end_time']+post_capture:
+        while sorted_clips[-1]['start_time'] + sorted_clips[-1]['duration'] < event_data['end_time']:
             time.sleep(5)
             self.refresh_cache()
             # get all clips from the camera with the event sorted
             sorted_clips = sorted([c for c in self.cached_clips.values() if c['camera'] == camera], key = lambda i: i['start_time'])
         
         playlist_start = event_data['start_time']-pre_capture
-        playlist_end = event_data['end_time']+post_capture
+        playlist_end = event_data['end_time']+5
         playlist_lines = []
         for clip in sorted_clips:
             # clip ends before playlist start time, skip
@@ -117,7 +104,7 @@ class EventProcessor(threading.Thread):
             # clip starts after playlist ends, finish
             if clip['start_time'] > playlist_end:
                 break
-            playlist_lines.append(f"file '{os.path.join(CACHE_DIR,clip['path'])}'")
+            playlist_lines.append(f"file '{os.path.join(self.cache_dir,clip['path'])}'")
             # if this is the starting clip, add an inpoint
             if clip['start_time'] < playlist_start:
                 playlist_lines.append(f"inpoint {int(playlist_start-clip['start_time'])}")
@@ -139,20 +126,21 @@ class EventProcessor(threading.Thread):
             '-',
             '-c',
             'copy',
-            '-movflags',
-            '+faststart',
-            f"{os.path.join(CLIPS_DIR, clip_name)}.mp4"
+            f"{os.path.join(self.clip_dir, clip_name)}.mp4"
         ]
 
         p = sp.run(ffmpeg_cmd, input="\n".join(playlist_lines), encoding='ascii', capture_output=True)
         if p.returncode != 0:
-            logger.error(p.stderr)
+            print(p.stderr)
             return
+        
+        with open(f"{os.path.join(self.clip_dir, clip_name)}.json", 'w') as outfile:
+            json.dump(event_data, outfile)
 
     def run(self):
         while True:
             if self.stop_event.is_set():
-                logger.info(f"Exiting event processor...")
+                print(f"Exiting event processor...")
                 break
 
             try:
@@ -164,126 +152,23 @@ class EventProcessor(threading.Thread):
 
             self.refresh_cache()
 
-            save_clips_config = self.config.cameras[camera].save_clips
+            save_clips_config = self.config['cameras'][camera].get('save_clips', {})
 
             # if save clips is not enabled for this camera, just continue
-            if not save_clips_config.enabled:
-                if event_type == 'end':
-                    self.event_processed_queue.put((event_data['id'], camera))
+            if not save_clips_config.get('enabled', False):
                 continue
 
             # if specific objects are listed for this camera, only save clips for them
-            if not event_data['label'] in save_clips_config.objects:
-                if event_type == 'end':
-                    self.event_processed_queue.put((event_data['id'], camera))
-                continue
+            if 'objects' in save_clips_config:
+                if not event_data['label'] in save_clips_config['objects']:
+                    continue
 
             if event_type == 'start':
                 self.events_in_process[event_data['id']] = event_data
 
             if event_type == 'end':
                 if len(self.cached_clips) > 0 and not event_data['false_positive']:
-                    self.create_clip(camera, event_data, save_clips_config.pre_capture, save_clips_config.post_capture)
-                    Event.create(
-                        id=event_data['id'],
-                        label=event_data['label'],
-                        camera=camera,
-                        start_time=event_data['start_time'],
-                        end_time=event_data['end_time'],
-                        top_score=event_data['top_score'],
-                        false_positive=event_data['false_positive'],
-                        zones=list(event_data['entered_zones']),
-                        thumbnail=event_data['thumbnail']
-                    )
+                    self.create_clip(camera, event_data, save_clips_config.get('pre_capture', 30))
                 del self.events_in_process[event_data['id']]
-                self.event_processed_queue.put((event_data['id'], camera))
 
-class EventCleanup(threading.Thread):
-    def __init__(self, config: FrigateConfig, stop_event):
-        threading.Thread.__init__(self)
-        self.name = 'event_cleanup'
-        self.config = config
-        self.stop_event = stop_event
-
-    def run(self):
-        counter = 0
-        while(True):
-            if self.stop_event.is_set():
-                logger.info(f"Exiting event cleanup...")
-                break
-
-            # only expire events every 10 minutes, but check for stop events every 10 seconds
-            time.sleep(10)
-            counter = counter + 1
-            if counter < 60:
-                continue
-            counter = 0
-
-            camera_keys = list(self.config.cameras.keys())
-
-            # Expire events from unlisted cameras based on the global config
-            retain_config = self.config.save_clips.retain
-            
-            distinct_labels = (Event.select(Event.label)
-                        .where(Event.camera.not_in(camera_keys))
-                        .distinct())
-            
-            # loop over object types in db
-            for l in distinct_labels:
-                # get expiration time for this label
-                expire_days = retain_config.objects.get(l.label, retain_config.default)
-                expire_after = (datetime.datetime.now() - datetime.timedelta(days=expire_days)).timestamp()
-                # grab all events after specific time
-                expired_events = (
-                    Event.select()
-                        .where(Event.camera.not_in(camera_keys), 
-                            Event.start_time < expire_after, 
-                            Event.label == l.label)
-                )
-                # delete the grabbed clips from disk
-                for event in expired_events:
-                    clip_name = f"{event.camera}-{event.id}"
-                    clip = Path(f"{os.path.join(CLIPS_DIR, clip_name)}.mp4")
-                    clip.unlink(missing_ok=True)
-                # delete the event for this type from the db
-                delete_query = (
-                    Event.delete()
-                        .where(Event.camera.not_in(camera_keys), 
-                            Event.start_time < expire_after, 
-                            Event.label == l.label)
-                )
-                delete_query.execute()
-
-            # Expire events from cameras based on the camera config
-            for name, camera in self.config.cameras.items():
-                retain_config = camera.save_clips.retain
-                # get distinct objects in database for this camera
-                distinct_labels = (Event.select(Event.label)
-                        .where(Event.camera == name)
-                        .distinct())
-
-                # loop over object types in db
-                for l in distinct_labels:
-                    # get expiration time for this label
-                    expire_days = retain_config.objects.get(l.label, retain_config.default)
-                    expire_after = (datetime.datetime.now() - datetime.timedelta(days=expire_days)).timestamp()
-                    # grab all events after specific time
-                    expired_events = (
-                        Event.select()
-                            .where(Event.camera == name, 
-                                Event.start_time < expire_after, 
-                                Event.label == l.label)
-                    )
-                    # delete the grabbed clips from disk
-                    for event in expired_events:
-                        clip_name = f"{event.camera}-{event.id}"
-                        clip = Path(f"{os.path.join(CLIPS_DIR, clip_name)}.mp4")
-                        clip.unlink(missing_ok=True)
-                    # delete the event for this type from the db
-                    delete_query = (
-                        Event.delete()
-                            .where( Event.camera == name, 
-                                Event.start_time < expire_after, 
-                                Event.label == l.label)
-                    )
-                    delete_query.execute()
+                

frigate/http.py

@@ -1,269 +0,0 @@
-import base64
-import datetime
-import logging
-import os
-import time
-from functools import reduce
-
-import cv2
-import numpy as np
-from flask import (Blueprint, Flask, Response, current_app, jsonify,
-                   make_response, request)
-from peewee import SqliteDatabase, operator, fn, DoesNotExist
-from playhouse.shortcuts import model_to_dict
-
-from frigate.models import Event
-from frigate.util import calculate_region
-from frigate.version import VERSION
-
-logger = logging.getLogger(__name__)
-
-bp = Blueprint('frigate', __name__)
-
-def create_app(frigate_config, database: SqliteDatabase, camera_metrics, detectors, detected_frames_processor):
-    app = Flask(__name__)
-
-    @app.before_request
-    def _db_connect():
-        database.connect()
-
-    @app.teardown_request
-    def _db_close(exc):
-        if not database.is_closed():
-            database.close()
-
-    app.frigate_config = frigate_config
-    app.camera_metrics = camera_metrics
-    app.detectors = detectors
-    app.detected_frames_processor = detected_frames_processor
-    
-    app.register_blueprint(bp)
-
-    return app
-
-@bp.route('/')
-def is_healthy():
-    return "Frigate is running. Alive and healthy!"
-
-@bp.route('/events/summary')
-def events_summary():
-    groups = (
-        Event
-            .select(
-                Event.camera, 
-                Event.label, 
-                fn.strftime('%Y-%m-%d', fn.datetime(Event.start_time, 'unixepoch', 'localtime')).alias('day'), 
-                Event.zones,
-                fn.COUNT(Event.id).alias('count')
-            )
-            .group_by(
-                Event.camera, 
-                Event.label, 
-                fn.strftime('%Y-%m-%d', fn.datetime(Event.start_time, 'unixepoch', 'localtime')),
-                Event.zones
-            )
-        )
-
-    return jsonify([e for e in groups.dicts()])
-
-@bp.route('/events/<id>')
-def event(id):
-    try:
-        return model_to_dict(Event.get(Event.id == id))
-    except DoesNotExist:
-        return "Event not found", 404
-
-@bp.route('/events/<id>/snapshot.jpg')
-def event_snapshot(id):
-    format = request.args.get('format', 'ios')
-    thumbnail_bytes = None
-    try:
-        event = Event.get(Event.id == id)
-        thumbnail_bytes = base64.b64decode(event.thumbnail)
-    except DoesNotExist:
-        # see if the object is currently being tracked
-        try:
-            for camera_state in current_app.detected_frames_processor.camera_states.values():
-                if id in camera_state.tracked_objects:
-                    tracked_obj = camera_state.tracked_objects.get(id)
-                    if not tracked_obj is None:
-                        thumbnail_bytes = tracked_obj.get_jpg_bytes()
-        except:
-            return "Event not found", 404
-    
-    if thumbnail_bytes is None:
-        return "Event not found", 404
-    
-    # android notifications prefer a 2:1 ratio
-    if format == 'android':
-        jpg_as_np = np.frombuffer(thumbnail_bytes, dtype=np.uint8)
-        img = cv2.imdecode(jpg_as_np, flags=1)
-        thumbnail = cv2.copyMakeBorder(img, 0, 0, int(img.shape[1]*0.5), int(img.shape[1]*0.5), cv2.BORDER_CONSTANT, (0,0,0))
-        ret, jpg = cv2.imencode('.jpg', thumbnail)    
-        thumbnail_bytes = jpg.tobytes()
-    
-    response = make_response(thumbnail_bytes)
-    response.headers['Content-Type'] = 'image/jpg'
-    return response
-
-@bp.route('/events')
-def events():
-    limit = request.args.get('limit', 100)
-    camera = request.args.get('camera')
-    label = request.args.get('label')
-    zone = request.args.get('zone')
-    after = request.args.get('after', type=int)
-    before = request.args.get('before', type=int)
-
-    clauses = []
-    
-    if camera:
-        clauses.append((Event.camera == camera))
-    
-    if label:
-        clauses.append((Event.label == label))
-    
-    if zone:
-        clauses.append((Event.zones.cast('text') % f"*\"{zone}\"*"))
-    
-    if after:
-        clauses.append((Event.start_time >= after))
-    
-    if before:
-        clauses.append((Event.start_time <= before))
-
-    if len(clauses) == 0:
-        clauses.append((1 == 1))
-
-    events =    (Event.select()
-                .where(reduce(operator.and_, clauses))
-                .order_by(Event.start_time.desc())
-                .limit(limit))
-
-    return jsonify([model_to_dict(e) for e in events])
-
-@bp.route('/config')
-def config():
-    return jsonify(current_app.frigate_config.to_dict())
-
-@bp.route('/version')
-def version():
-    return VERSION
-
-@bp.route('/stats')
-def stats():
-    camera_metrics = current_app.camera_metrics
-    stats = {}
-
-    total_detection_fps = 0
-
-    for name, camera_stats in camera_metrics.items():
-        total_detection_fps += camera_stats['detection_fps'].value
-        stats[name] = {
-            'camera_fps': round(camera_stats['camera_fps'].value, 2),
-            'process_fps': round(camera_stats['process_fps'].value, 2),
-            'skipped_fps': round(camera_stats['skipped_fps'].value, 2),
-            'detection_fps': round(camera_stats['detection_fps'].value, 2),
-            'pid': camera_stats['process'].pid,
-            'capture_pid': camera_stats['capture_process'].pid
-        }
-    
-    stats['detectors'] = {}
-    for name, detector in current_app.detectors.items():
-        stats['detectors'][name] = {
-            'inference_speed': round(detector.avg_inference_speed.value*1000, 2),
-            'detection_start': detector.detection_start.value,
-            'pid': detector.detect_process.pid
-        }
-    stats['detection_fps'] = round(total_detection_fps, 2)
-
-    return jsonify(stats)
-
-@bp.route('/<camera_name>/<label>/best.jpg')
-def best(camera_name, label):
-    if camera_name in current_app.frigate_config.cameras:
-        best_object = current_app.detected_frames_processor.get_best(camera_name, label)
-        best_frame = best_object.get('frame')
-        if best_frame is None:
-            best_frame = np.zeros((720,1280,3), np.uint8)
-        else:
-            best_frame = cv2.cvtColor(best_frame, cv2.COLOR_YUV2BGR_I420)
-        
-        crop = bool(request.args.get('crop', 0, type=int))
-        if crop:
-            box = best_object.get('box', (0,0,300,300))
-            region = calculate_region(best_frame.shape, box[0], box[1], box[2], box[3], 1.1)
-            best_frame = best_frame[region[1]:region[3], region[0]:region[2]]
-        
-        height = int(request.args.get('h', str(best_frame.shape[0])))
-        width = int(height*best_frame.shape[1]/best_frame.shape[0])
-
-        best_frame = cv2.resize(best_frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
-        ret, jpg = cv2.imencode('.jpg', best_frame)
-        response = make_response(jpg.tobytes())
-        response.headers['Content-Type'] = 'image/jpg'
-        return response
-    else:
-        return "Camera named {} not found".format(camera_name), 404
-
-@bp.route('/<camera_name>')
-def mjpeg_feed(camera_name):
-    fps = int(request.args.get('fps', '3'))
-    height = int(request.args.get('h', '360'))
-    draw_options = {
-        'bounding_boxes': request.args.get('bbox', type=int),
-        'timestamp': request.args.get('timestamp', type=int),
-        'zones': request.args.get('zones', type=int),
-        'mask': request.args.get('mask', type=int),
-        'motion_boxes': request.args.get('motion', type=int),
-        'regions': request.args.get('regions', type=int),
-    }
-    if camera_name in current_app.frigate_config.cameras:
-        # return a multipart response
-        return Response(imagestream(current_app.detected_frames_processor, camera_name, fps, height, draw_options),
-                        mimetype='multipart/x-mixed-replace; boundary=frame')
-    else:
-        return "Camera named {} not found".format(camera_name), 404
-
-@bp.route('/<camera_name>/latest.jpg')
-def latest_frame(camera_name):
-    draw_options = {
-        'bounding_boxes': request.args.get('bbox', type=int),
-        'timestamp': request.args.get('timestamp', type=int),
-        'zones': request.args.get('zones', type=int),
-        'mask': request.args.get('mask', type=int),
-        'motion_boxes': request.args.get('motion', type=int),
-        'regions': request.args.get('regions', type=int),
-    }
-    if camera_name in current_app.frigate_config.cameras:
-        # max out at specified FPS
-        frame = current_app.detected_frames_processor.get_current_frame(camera_name, draw_options)
-        if frame is None:
-            frame = np.zeros((720,1280,3), np.uint8)
-
-        height = int(request.args.get('h', str(frame.shape[0])))
-        width = int(height*frame.shape[1]/frame.shape[0])
-
-        frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
-
-        ret, jpg = cv2.imencode('.jpg', frame)
-        response = make_response(jpg.tobytes())
-        response.headers['Content-Type'] = 'image/jpg'
-        return response
-    else:
-        return "Camera named {} not found".format(camera_name), 404
-        
-def imagestream(detected_frames_processor, camera_name, fps, height, draw_options):
-    while True:
-        # max out at specified FPS
-        time.sleep(1/fps)
-        frame = detected_frames_processor.get_current_frame(camera_name, draw_options)
-        if frame is None:
-            frame = np.zeros((height,int(height*16/9),3), np.uint8)
-
-        width = int(height*frame.shape[1]/frame.shape[0])
-        frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_LINEAR)
-
-        ret, jpg = cv2.imencode('.jpg', frame)
-        yield (b'--frame\r\n'
-            b'Content-Type: image/jpeg\r\n\r\n' + jpg.tobytes() + b'\r\n\r\n')

frigate/log.py

@@ -1,75 +0,0 @@
-# adapted from https://medium.com/@jonathonbao/python3-logging-with-multiprocessing-f51f460b8778
-import logging
-import threading
-import os
-import signal
-import queue
-import multiprocessing as mp
-from logging import handlers
-
-
-def listener_configurer():
-    root = logging.getLogger()
-    console_handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(name)-30s %(levelname)-8s: %(message)s')
-    console_handler.setFormatter(formatter)
-    root.addHandler(console_handler)
-    root.setLevel(logging.INFO)
-
-def root_configurer(queue):
-    h = handlers.QueueHandler(queue)
-    root = logging.getLogger()
-    root.addHandler(h)
-    root.setLevel(logging.INFO)
-
-def log_process(log_queue):
-    stop_event = mp.Event()
-    def receiveSignal(signalNumber, frame):
-        stop_event.set()
-    
-    signal.signal(signal.SIGTERM, receiveSignal)
-    signal.signal(signal.SIGINT, receiveSignal)
-
-    threading.current_thread().name = f"logger"
-    listener_configurer()
-    while True:
-        if stop_event.is_set() and log_queue.empty():
-            break
-        try:
-            record = log_queue.get(timeout=5)
-        except queue.Empty:
-            continue
-        logger = logging.getLogger(record.name)
-        logger.handle(record)
-
-# based on https://codereview.stackexchange.com/a/17959
-class LogPipe(threading.Thread):
-    def __init__(self, log_name, level):
-        """Setup the object with a logger and a loglevel
-        and start the thread
-        """
-        threading.Thread.__init__(self)
-        self.daemon = False
-        self.logger = logging.getLogger(log_name)
-        self.level = level
-        self.fdRead, self.fdWrite = os.pipe()
-        self.pipeReader = os.fdopen(self.fdRead)
-        self.start()
-
-    def fileno(self):
-        """Return the write file descriptor of the pipe
-        """
-        return self.fdWrite
-
-    def run(self):
-        """Run the thread, logging everything.
-        """
-        for line in iter(self.pipeReader.readline, ''):
-            self.logger.log(self.level, line.strip('\n'))
-
-        self.pipeReader.close()
-
-    def close(self):
-        """Close the write end of the pipe.
-        """
-        os.close(self.fdWrite)

frigate/models.py

@@ -1,14 +0,0 @@
-from peewee import *
-from playhouse.sqlite_ext import *
-
-
-class Event(Model):
-    id = CharField(null=False, primary_key=True, max_length=30)
-    label = CharField(index=True, max_length=20)
-    camera = CharField(index=True, max_length=20)
-    start_time = DateTimeField()
-    end_time = DateTimeField()
-    top_score = FloatField()
-    false_positive = BooleanField()
-    zones = JSONField()
-    thumbnail = TextField()

frigate/motion.py

@@ -1,15 +1,12 @@
 import cv2
 import imutils
 import numpy as np
-from frigate.config import MotionConfig
-
 
 class MotionDetector():
-    def __init__(self, frame_shape, mask, config: MotionConfig):
-        self.config = config
+    def __init__(self, frame_shape, mask, resize_factor=4):
         self.frame_shape = frame_shape
-        self.resize_factor = frame_shape[0]/config.frame_height
-        self.motion_frame_size = (config.frame_height, config.frame_height*frame_shape[1]//frame_shape[0])
+        self.resize_factor = resize_factor
+        self.motion_frame_size = (int(frame_shape[0]/resize_factor), int(frame_shape[1]/resize_factor))
         self.avg_frame = np.zeros(self.motion_frame_size, np.float)
         self.avg_delta = np.zeros(self.motion_frame_size, np.float)
         self.motion_frame_count = 0
@@ -25,8 +22,6 @@ class MotionDetector():
         # resize frame
         resized_frame = cv2.resize(gray, dsize=(self.motion_frame_size[1], self.motion_frame_size[0]), interpolation=cv2.INTER_LINEAR)
 
-        # TODO: can I improve the contrast of the grayscale image here?
-
         # convert to grayscale
         # resized_frame = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2GRAY)
 
@@ -42,21 +37,22 @@ class MotionDetector():
             frameDelta = cv2.absdiff(resized_frame, cv2.convertScaleAbs(self.avg_frame))
 
             # compute the average delta over the past few frames
+            # the alpha value can be modified to configure how sensitive the motion detection is.
             # higher values mean the current frame impacts the delta a lot, and a single raindrop may
             # register as motion, too low and a fast moving person wont be detected as motion
-            cv2.accumulateWeighted(frameDelta, self.avg_delta, self.config.delta_alpha)
+            # this also assumes that a person is in the same location across more than a single frame
+            cv2.accumulateWeighted(frameDelta, self.avg_delta, 0.2)
 
             # compute the threshold image for the current frame
-            # TODO: threshold
-            current_thresh = cv2.threshold(frameDelta, self.config.threshold, 255, cv2.THRESH_BINARY)[1]
+            current_thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
 
             # black out everything in the avg_delta where there isnt motion in the current frame
             avg_delta_image = cv2.convertScaleAbs(self.avg_delta)
-            avg_delta_image = cv2.bitwise_and(avg_delta_image, current_thresh)
+            avg_delta_image[np.where(current_thresh==[0])] = [0]
 
             # then look for deltas above the threshold, but only in areas where there is a delta
             # in the current frame. this prevents deltas from previous frames from being included
-            thresh = cv2.threshold(avg_delta_image, self.config.threshold, 255, cv2.THRESH_BINARY)[1]
+            thresh = cv2.threshold(avg_delta_image, 25, 255, cv2.THRESH_BINARY)[1]
 
             # dilate the thresholded image to fill in holes, then find contours
             # on thresholded image
@@ -68,18 +64,19 @@ class MotionDetector():
             for c in cnts:
                 # if the contour is big enough, count it as motion
                 contour_area = cv2.contourArea(c)
-                if contour_area > self.config.contour_area:
+                if contour_area > 100:
                     x, y, w, h = cv2.boundingRect(c)
-                    motion_boxes.append((int(x*self.resize_factor), int(y*self.resize_factor), int((x+w)*self.resize_factor), int((y+h)*self.resize_factor)))
+                    motion_boxes.append((x*self.resize_factor, y*self.resize_factor, (x+w)*self.resize_factor, (y+h)*self.resize_factor))
         
         if len(motion_boxes) > 0:
             self.motion_frame_count += 1
+            # TODO: this really depends on FPS
             if self.motion_frame_count >= 10:
-                # only average in the current frame if the difference persists for a bit
-                cv2.accumulateWeighted(resized_frame, self.avg_frame, self.config.frame_alpha)
+                # only average in the current frame if the difference persists for at least 3 frames
+                cv2.accumulateWeighted(resized_frame, self.avg_frame, 0.2)
         else:
             # when no motion, just keep averaging the frames together
-            cv2.accumulateWeighted(resized_frame, self.avg_frame, self.config.frame_alpha)
+            cv2.accumulateWeighted(resized_frame, self.avg_frame, 0.2)
             self.motion_frame_count = 0
 
-        return motion_boxes
+        return motion_boxes

frigate/mqtt.py

@@ -1,36 +0,0 @@
-import logging
-import threading
-
-import paho.mqtt.client as mqtt
-
-from frigate.config import MqttConfig
-
-logger = logging.getLogger(__name__)
-
-def create_mqtt_client(config: MqttConfig):
-    client = mqtt.Client(client_id=config.client_id)
-    def on_connect(client, userdata, flags, rc):
-        threading.current_thread().name = "mqtt"
-        if rc != 0:
-            if rc == 3:
-                logger.error("MQTT Server unavailable")
-            elif rc == 4:
-                logger.error("MQTT Bad username or password")
-            elif rc == 5:
-                logger.error("MQTT Not authorized")
-            else:
-                logger.error("Unable to connect to MQTT: Connection refused. Error code: " + str(rc))
-            
-        logger.info("MQTT connected")
-        client.publish(config.topic_prefix+'/available', 'online', retain=True)       
-    client.on_connect = on_connect
-    client.will_set(config.topic_prefix+'/available', payload='offline', qos=1, retain=True)
-    if not config.user is None:
-        client.username_pw_set(config.user, password=config.password)
-    try:
-        client.connect(config.host, config.port, 60)
-    except Exception as e:
-        logger.error(f"Unable to connect to MQTT server: {e}")
-        raise
-    client.loop_start()
-    return client

frigate/object_processing.py

@@ -1,28 +1,20 @@
-import copy
-import base64
-import datetime
-import hashlib
-import itertools
 import json
-import logging
-import os
-import queue
-import threading
+import hashlib
+import datetime
 import time
-from collections import Counter, defaultdict
-from statistics import mean, median
-from typing import Callable, Dict
-
+import copy
 import cv2
-import matplotlib.pyplot as plt
+import threading
+import queue
+import copy
 import numpy as np
-
-from frigate.config import FrigateConfig, CameraConfig
-from frigate.const import RECORD_DIR, CLIPS_DIR, CACHE_DIR
+from collections import Counter, defaultdict
+import itertools
+import matplotlib.pyplot as plt
+from frigate.util import draw_box_with_label, SharedMemoryFrameManager
 from frigate.edgetpu import load_labels
-from frigate.util import SharedMemoryFrameManager, draw_box_with_label, calculate_region
-
-logger = logging.getLogger(__name__)
+from typing import Callable, Dict
+from statistics import mean, median
 
 PATH_TO_LABELS = '/labelmap.txt'
 
@@ -33,207 +25,24 @@ COLOR_MAP = {}
 for key, val in LABELS.items():
     COLOR_MAP[val] = tuple(int(round(255 * c)) for c in cmap(key)[:3])
 
-def on_edge(box, frame_shape):
-    if (
-        box[0] == 0 or
-        box[1] == 0 or
-        box[2] == frame_shape[1]-1 or
-        box[3] == frame_shape[0]-1
-    ):
-        return True
-
-def is_better_thumbnail(current_thumb, new_obj, frame_shape) -> bool:
-    # larger is better
-    # cutoff images are less ideal, but they should also be smaller?
-    # better scores are obviously better too
-
-    # if the new_thumb is on an edge, and the current thumb is not
-    if on_edge(new_obj['box'], frame_shape) and not on_edge(current_thumb['box'], frame_shape):
-        return False
-
-    # if the score is better by more than 5%
-    if new_obj['score'] > current_thumb['score']+.05:
-        return True
-    
-    # if the area is 10% larger
-    if new_obj['area'] > current_thumb['area']*1.1:
-        return True
-    
-    return False
-
-class TrackedObject():
-    def __init__(self, camera, camera_config: CameraConfig, frame_cache, obj_data):
-        self.obj_data = obj_data
-        self.camera = camera
-        self.camera_config = camera_config
-        self.frame_cache = frame_cache
-        self.current_zones = []
-        self.entered_zones = set()
-        self.false_positive = True
-        self.top_score = self.computed_score = 0.0
-        self.thumbnail_data = None
-        self.frame = None
-        self.previous = self.to_dict()
-        self._snapshot_jpg_time = 0
-        ret, jpg = cv2.imencode('.jpg', np.zeros((300,300,3), np.uint8))
-        self._snapshot_jpg = jpg.tobytes()
-
-        # start the score history
-        self.score_history = [self.obj_data['score']]
-
-    def _is_false_positive(self):
-        # once a true positive, always a true positive
-        if not self.false_positive:
-            return False
-
-        threshold = self.camera_config.objects.filters[self.obj_data['label']].threshold
-        if self.computed_score < threshold:
-            return True
-        return False
-
-    def compute_score(self):
-        scores = self.score_history[:]
-        # pad with zeros if you dont have at least 3 scores
-        if len(scores) < 3:
-            scores += [0.0]*(3 - len(scores))
-        return median(scores)
-    
-    def update(self, current_frame_time, obj_data):
-        significant_update = False
-        self.obj_data.update(obj_data)
-        # if the object is not in the current frame, add a 0.0 to the score history
-        if self.obj_data['frame_time'] != current_frame_time:
-            self.score_history.append(0.0)
-        else:
-            self.score_history.append(self.obj_data['score'])
-        # only keep the last 10 scores
-        if len(self.score_history) > 10:
-            self.score_history = self.score_history[-10:]
-
-        # calculate if this is a false positive
-        self.computed_score = self.compute_score()
-        if self.computed_score > self.top_score:
-            self.top_score = self.computed_score
-        self.false_positive = self._is_false_positive()
-
-        if not self.false_positive:
-            # determine if this frame is a better thumbnail
-            if (
-                self.thumbnail_data is None 
-                or is_better_thumbnail(self.thumbnail_data, self.obj_data, self.camera_config.frame_shape)
-            ):
-                self.thumbnail_data = {
-                    'frame_time': self.obj_data['frame_time'],
-                    'box': self.obj_data['box'],
-                    'area': self.obj_data['area'],
-                    'region': self.obj_data['region'],
-                    'score': self.obj_data['score']
-                }
-                significant_update = True
-        
-        # check zones
-        current_zones = []
-        bottom_center = (self.obj_data['centroid'][0], self.obj_data['box'][3])
-        # check each zone
-        for name, zone in self.camera_config.zones.items():
-            contour = zone.contour
-            # check if the object is in the zone
-            if (cv2.pointPolygonTest(contour, bottom_center, False) >= 0):
-                # if the object passed the filters once, dont apply again
-                if name in self.current_zones or not zone_filtered(self, zone.filters):
-                    current_zones.append(name)
-                    self.entered_zones.add(name)
-        
-        # if the zones changed, signal an update
-        if not self.false_positive and set(self.current_zones) != set(current_zones):
-            significant_update = True
-
-        self.current_zones = current_zones
-        return significant_update
-    
-    def to_dict(self, include_thumbnail: bool = False):
-        return {
-            'id': self.obj_data['id'],
-            'camera': self.camera,
-            'frame_time': self.obj_data['frame_time'],
-            'label': self.obj_data['label'],
-            'top_score': self.top_score,
-            'false_positive': self.false_positive,
-            'start_time': self.obj_data['start_time'],
-            'end_time': self.obj_data.get('end_time', None),
-            'score': self.obj_data['score'],
-            'box': self.obj_data['box'],
-            'area': self.obj_data['area'],
-            'region': self.obj_data['region'],
-            'current_zones': self.current_zones.copy(),
-            'entered_zones': list(self.entered_zones).copy(),
-            'thumbnail': base64.b64encode(self.get_jpg_bytes()).decode('utf-8') if include_thumbnail else None
-        }
-    
-    def get_jpg_bytes(self):
-        if self.thumbnail_data is None or self._snapshot_jpg_time == self.thumbnail_data['frame_time']:
-            return self._snapshot_jpg
-        
-        if not self.thumbnail_data['frame_time'] in self.frame_cache:
-            logger.error(f"Unable to create thumbnail for {self.obj_data['id']}")
-            logger.error(f"Looking for frame_time of {self.thumbnail_data['frame_time']}")
-            logger.error(f"Thumbnail frames: {','.join([str(k) for k in self.frame_cache.keys()])}")
-            return self._snapshot_jpg
-
-        # TODO: crop first to avoid converting the entire frame?
-        snapshot_config = self.camera_config.snapshots
-        best_frame = cv2.cvtColor(self.frame_cache[self.thumbnail_data['frame_time']], cv2.COLOR_YUV2BGR_I420)
-
-        if snapshot_config.draw_bounding_boxes:
-            thickness = 2
-            color = COLOR_MAP[self.obj_data['label']]
-            box = self.thumbnail_data['box']
-            draw_box_with_label(best_frame, box[0], box[1], box[2], box[3], self.obj_data['label'], 
-                f"{int(self.thumbnail_data['score']*100)}% {int(self.thumbnail_data['area'])}", thickness=thickness, color=color)
-            
-        if snapshot_config.crop_to_region:
-            box = self.thumbnail_data['box']
-            region = calculate_region(best_frame.shape, box[0], box[1], box[2], box[3], 1.1)
-            best_frame = best_frame[region[1]:region[3], region[0]:region[2]]
-
-        if snapshot_config.height: 
-            height = snapshot_config.height
-            width = int(height*best_frame.shape[1]/best_frame.shape[0])
-            best_frame = cv2.resize(best_frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
-        
-        if snapshot_config.show_timestamp:
-            time_to_show = datetime.datetime.fromtimestamp(self.thumbnail_data['frame_time']).strftime("%m/%d/%Y %H:%M:%S")
-            size = cv2.getTextSize(time_to_show, cv2.FONT_HERSHEY_SIMPLEX, fontScale=1, thickness=2)
-            text_width = size[0][0]
-            desired_size = max(150, 0.33*best_frame.shape[1])
-            font_scale = desired_size/text_width
-            cv2.putText(best_frame, time_to_show, (5, best_frame.shape[0]-7), cv2.FONT_HERSHEY_SIMPLEX, 
-                fontScale=font_scale, color=(255, 255, 255), thickness=2)
-
-        ret, jpg = cv2.imencode('.jpg', best_frame)
-        if ret:
-            self._snapshot_jpg = jpg.tobytes()
-        
-        return self._snapshot_jpg
-
-def zone_filtered(obj: TrackedObject, object_config):
-    object_name = obj.obj_data['label']
+def zone_filtered(obj, object_config):
+    object_name = obj['label']
 
     if object_name in object_config:
         obj_settings = object_config[object_name]
 
         # if the min area is larger than the
         # detected object, don't add it to detected objects
-        if obj_settings.min_area > obj.obj_data['area']:
+        if obj_settings.get('min_area',-1) > obj['area']:
             return True
         
         # if the detected object is larger than the
         # max area, don't add it to detected objects
-        if obj_settings.max_area < obj.obj_data['area']:
+        if obj_settings.get('max_area', 24000000) < obj['area']:
             return True
 
         # if the score is lower than the threshold, skip
-        if obj_settings.threshold > obj.computed_score:
+        if obj_settings.get('threshold', 0) > obj['computed_score']:
             return True
         
     return False
@@ -243,30 +52,27 @@ class CameraState():
     def __init__(self, name, config, frame_manager):
         self.name = name
         self.config = config
-        self.camera_config = config.cameras[name]
         self.frame_manager = frame_manager
-        self.best_objects: Dict[str, TrackedObject] = {}
-        self.object_counts = defaultdict(lambda: 0)
-        self.tracked_objects: Dict[str, TrackedObject] = {}
-        self.frame_cache = {}
+
+        self.best_objects = {}
+        self.object_status = defaultdict(lambda: 'OFF')
+        self.tracked_objects = {}
         self.zone_objects = defaultdict(lambda: [])
-        self._current_frame = np.zeros(self.camera_config.frame_shape_yuv, np.uint8)
+        self._current_frame = np.zeros(self.config['frame_shape'], np.uint8)
         self.current_frame_lock = threading.Lock()
         self.current_frame_time = 0.0
         self.previous_frame_id = None
         self.callbacks = defaultdict(lambda: [])
 
-    def get_current_frame(self, draw_options={}):
+    def get_current_frame(self, draw=False):
         with self.current_frame_lock:
             frame_copy = np.copy(self._current_frame)
             frame_time = self.current_frame_time
-            tracked_objects = {k: v.to_dict() for k,v in self.tracked_objects.items()}
-            motion_boxes = self.motion_boxes.copy()
-            regions = self.regions.copy()
+            tracked_objects = copy.deepcopy(self.tracked_objects)
         
         frame_copy = cv2.cvtColor(frame_copy, cv2.COLOR_YUV2BGR_I420)
         # draw on the frame
-        if draw_options.get('bounding_boxes'):
+        if draw:
             # draw the bounding boxes on the frame
             for obj in tracked_objects.values():
                 thickness = 2
@@ -279,128 +85,155 @@ class CameraState():
                 # draw the bounding boxes on the frame
                 box = obj['box']
                 draw_box_with_label(frame_copy, box[0], box[1], box[2], box[3], obj['label'], f"{int(obj['score']*100)}% {int(obj['area'])}", thickness=thickness, color=color)
-        
-        if draw_options.get('regions'):
-            for region in regions:
-                cv2.rectangle(frame_copy, (region[0], region[1]), (region[2], region[3]), (0,255,0), 2)
-        
-        if draw_options.get('timestamp'):
-            time_to_show = datetime.datetime.fromtimestamp(frame_time).strftime("%m/%d/%Y %H:%M:%S")
-            cv2.putText(frame_copy, time_to_show, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, fontScale=.8, color=(255, 255, 255), thickness=2)
+                # draw the regions on the frame
+                region = obj['region']
+                cv2.rectangle(frame_copy, (region[0], region[1]), (region[2], region[3]), (0,255,0), 1)
+            
+            if self.config['snapshots']['show_timestamp']:
+                time_to_show = datetime.datetime.fromtimestamp(frame_time).strftime("%m/%d/%Y %H:%M:%S")
+                cv2.putText(frame_copy, time_to_show, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, fontScale=.8, color=(255, 255, 255), thickness=2)
 
-        if draw_options.get('zones'):
-            for name, zone in self.camera_config.zones.items():
-                thickness = 8 if any([name in obj['current_zones'] for obj in tracked_objects.values()]) else 2
-                cv2.drawContours(frame_copy, [zone.contour], -1, zone.color, thickness)
+            if self.config['snapshots']['draw_zones']:
+                for name, zone in self.config['zones'].items():
+                    thickness = 8 if any([name in obj['zones'] for obj in tracked_objects.values()]) else 2
+                    cv2.drawContours(frame_copy, [zone['contour']], -1, zone['color'], thickness)
         
-        if draw_options.get('mask'):
-            mask_overlay = np.where(self.camera_config.mask==[0])
-            frame_copy[mask_overlay] = [0,0,0]
-        
-        if draw_options.get('motion_boxes'):
-            for m_box in motion_boxes:
-                cv2.rectangle(frame_copy, (m_box[0], m_box[1]), (m_box[2], m_box[3]), (0,0,255), 2)
-
         return frame_copy
 
-    def finished(self, obj_id):
-        del self.tracked_objects[obj_id]
+    def false_positive(self, obj):
+        # once a true positive, always a true positive
+        if not obj.get('false_positive', True):
+            return False
+
+        threshold = self.config['objects'].get('filters', {}).get(obj['label'], {}).get('threshold', 0.85)
+        if obj['computed_score'] < threshold:
+            return True
+        return False
+
+    def compute_score(self, obj):
+        scores = obj['score_history'][:]
+        # pad with zeros if you dont have at least 3 scores
+        if len(scores) < 3:
+            scores += [0.0]*(3 - len(scores))
+        return median(scores)
 
     def on(self, event_type: str, callback: Callable[[Dict], None]):
         self.callbacks[event_type].append(callback)
 
-    def update(self, frame_time, current_detections, motion_boxes, regions):
+    def update(self, frame_time, tracked_objects):
         self.current_frame_time = frame_time
-        self.motion_boxes = motion_boxes
-        self.regions = regions
-        # get the new frame
+        # get the new frame and delete the old frame
         frame_id = f"{self.name}{frame_time}"
-        current_frame = self.frame_manager.get(frame_id, self.camera_config.frame_shape_yuv)
+        current_frame = self.frame_manager.get(frame_id, (self.config['frame_shape'][0]*3//2, self.config['frame_shape'][1]))
 
-        current_ids = current_detections.keys()
+        current_ids = tracked_objects.keys()
         previous_ids = self.tracked_objects.keys()
         removed_ids = list(set(previous_ids).difference(current_ids))
         new_ids = list(set(current_ids).difference(previous_ids))
         updated_ids = list(set(current_ids).intersection(previous_ids))
 
         for id in new_ids:
-            new_obj = self.tracked_objects[id] = TrackedObject(self.name, self.camera_config, self.frame_cache, current_detections[id])
+            self.tracked_objects[id] = tracked_objects[id]
+            self.tracked_objects[id]['zones'] = []
+
+            # start the score history
+            self.tracked_objects[id]['score_history'] = [self.tracked_objects[id]['score']]
+
+            # calculate if this is a false positive
+            self.tracked_objects[id]['computed_score'] = self.compute_score(self.tracked_objects[id])
+            self.tracked_objects[id]['false_positive'] = self.false_positive(self.tracked_objects[id])
 
             # call event handlers
             for c in self.callbacks['start']:
-                c(self.name, new_obj, frame_time)
+                c(self.name, tracked_objects[id])
         
         for id in updated_ids:
-            updated_obj = self.tracked_objects[id]
-            significant_update = updated_obj.update(frame_time, current_detections[id])
+            self.tracked_objects[id].update(tracked_objects[id])
 
-            if significant_update:
-                # ensure this frame is stored in the cache
-                if updated_obj.thumbnail_data['frame_time'] == frame_time and frame_time not in self.frame_cache:
-                    self.frame_cache[frame_time] = np.copy(current_frame)
+            # if the object is not in the current frame, add a 0.0 to the score history
+            if self.tracked_objects[id]['frame_time'] != self.current_frame_time:
+                self.tracked_objects[id]['score_history'].append(0.0)
+            else:
+                self.tracked_objects[id]['score_history'].append(self.tracked_objects[id]['score'])
+            # only keep the last 10 scores
+            if len(self.tracked_objects[id]['score_history']) > 10:
+                self.tracked_objects[id]['score_history'] = self.tracked_objects[id]['score_history'][-10:]
 
-                # call event handlers
-                for c in self.callbacks['update']:
-                    c(self.name, updated_obj, frame_time)
+            # calculate if this is a false positive
+            self.tracked_objects[id]['computed_score'] = self.compute_score(self.tracked_objects[id])
+            self.tracked_objects[id]['false_positive'] = self.false_positive(self.tracked_objects[id])
+
+            # call event handlers
+            for c in self.callbacks['update']:
+                c(self.name, self.tracked_objects[id])
         
         for id in removed_ids:
             # publish events to mqtt
-            removed_obj = self.tracked_objects[id]
-            if not 'end_time' in removed_obj.obj_data:
-                removed_obj.obj_data['end_time'] = frame_time
-                for c in self.callbacks['end']:
-                    c(self.name, removed_obj, frame_time)
+            self.tracked_objects[id]['end_time'] = frame_time
+            for c in self.callbacks['end']:
+                c(self.name, self.tracked_objects[id])
+            del self.tracked_objects[id]
+
+        # check to see if the objects are in any zones
+        for obj in self.tracked_objects.values():
+            current_zones = []
+            bottom_center = (obj['centroid'][0], obj['box'][3])
+            # check each zone
+            for name, zone in self.config['zones'].items():
+                contour = zone['contour']
+                # check if the object is in the zone
+                if (cv2.pointPolygonTest(contour, bottom_center, False) >= 0):
+                    # if the object passed the filters once, dont apply again
+                    if name in obj.get('zones', []) or not zone_filtered(obj, zone.get('filters', {})):
+                        current_zones.append(name)
+                    
+            obj['zones'] = current_zones
 
-        # TODO: can i switch to looking this up and only changing when an event ends?
         # maintain best objects
         for obj in self.tracked_objects.values():
-            object_type = obj.obj_data['label']
-            # if the object's thumbnail is not from the current frame
-            if obj.false_positive or obj.thumbnail_data['frame_time'] != self.current_frame_time:
+            object_type = obj['label']
+            # if the object wasn't seen on the current frame, skip it
+            if obj['frame_time'] != self.current_frame_time or obj['false_positive']:
                 continue
+            obj_copy = copy.deepcopy(obj)
             if object_type in self.best_objects:
                 current_best = self.best_objects[object_type]
                 now = datetime.datetime.now().timestamp()
                 # if the object is a higher score than the current best score 
                 # or the current object is older than desired, use the new object
-                if (is_better_thumbnail(current_best.thumbnail_data, obj.thumbnail_data, self.camera_config.frame_shape) 
-                    or (now - current_best.thumbnail_data['frame_time']) > self.camera_config.best_image_timeout):
-                    self.best_objects[object_type] = obj
+                if obj_copy['score'] > current_best['score'] or (now - current_best['frame_time']) > self.config.get('best_image_timeout', 60):
+                    obj_copy['frame'] = np.copy(current_frame)
+                    self.best_objects[object_type] = obj_copy
                     for c in self.callbacks['snapshot']:
-                        c(self.name, self.best_objects[object_type], frame_time)
+                        c(self.name, self.best_objects[object_type])
             else:
-                self.best_objects[object_type] = obj
+                obj_copy['frame'] = np.copy(current_frame)
+                self.best_objects[object_type] = obj_copy
                 for c in self.callbacks['snapshot']:
-                    c(self.name, self.best_objects[object_type], frame_time)
+                    c(self.name, self.best_objects[object_type])
         
         # update overall camera state for each object type
         obj_counter = Counter()
         for obj in self.tracked_objects.values():
-            if not obj.false_positive:
-                obj_counter[obj.obj_data['label']] += 1
+            if not obj['false_positive']:
+                obj_counter[obj['label']] += 1
                 
         # report on detected objects
         for obj_name, count in obj_counter.items():
-            if count != self.object_counts[obj_name]:
-                self.object_counts[obj_name] = count
+            new_status = 'ON' if count > 0 else 'OFF'
+            if new_status != self.object_status[obj_name]:
+                self.object_status[obj_name] = new_status
                 for c in self.callbacks['object_status']:
-                    c(self.name, obj_name, count)
+                    c(self.name, obj_name, new_status)
 
-        # expire any objects that are >0 and no longer detected
-        expired_objects = [obj_name for obj_name, count in self.object_counts.items() if count > 0 and not obj_name in obj_counter]
+        # expire any objects that are ON and no longer detected
+        expired_objects = [obj_name for obj_name, status in self.object_status.items() if status == 'ON' and not obj_name in obj_counter]
         for obj_name in expired_objects:
-            self.object_counts[obj_name] = 0
+            self.object_status[obj_name] = 'OFF'
             for c in self.callbacks['object_status']:
-                c(self.name, obj_name, 0)
+                c(self.name, obj_name, 'OFF')
             for c in self.callbacks['snapshot']:
-                c(self.name, self.best_objects[obj_name], frame_time)
-        
-        # cleanup thumbnail frame cache
-        current_thumb_frames = set([obj.thumbnail_data['frame_time'] for obj in self.tracked_objects.values() if not obj.false_positive])
-        current_best_frames = set([obj.thumbnail_data['frame_time'] for obj in self.best_objects.values()])
-        thumb_frames_to_delete = [t for t in self.frame_cache.keys() if not t in current_thumb_frames and not t in current_best_frames]
-        for t in thumb_frames_to_delete:
-            del self.frame_cache[t]
+                c(self.name, self.best_objects[obj_name])
         
         with self.current_frame_lock:
             self._current_frame = current_frame
@@ -409,42 +242,68 @@ class CameraState():
             self.previous_frame_id = frame_id
 
 class TrackedObjectProcessor(threading.Thread):
-    def __init__(self, config: FrigateConfig, client, topic_prefix, tracked_objects_queue, event_queue, event_processed_queue, stop_event):
+    def __init__(self, camera_config, client, topic_prefix, tracked_objects_queue, event_queue, stop_event):
         threading.Thread.__init__(self)
-        self.name = "detected_frames_processor"
-        self.config = config
+        self.camera_config = camera_config
         self.client = client
         self.topic_prefix = topic_prefix
         self.tracked_objects_queue = tracked_objects_queue
         self.event_queue = event_queue
-        self.event_processed_queue = event_processed_queue
         self.stop_event = stop_event
         self.camera_states: Dict[str, CameraState] = {}
         self.frame_manager = SharedMemoryFrameManager()
 
-        def start(camera, obj: TrackedObject, current_frame_time):
-            self.event_queue.put(('start', camera, obj.to_dict()))
+        def start(camera, obj):
+            # publish events to mqtt
+            self.client.publish(f"{self.topic_prefix}/{camera}/events/start", json.dumps(obj), retain=False)
+            self.event_queue.put(('start', camera, obj))
 
-        def update(camera, obj: TrackedObject, current_frame_time):
-            after = obj.to_dict()
-            message = { 'before': obj.previous, 'after': after }
-            self.client.publish(f"{self.topic_prefix}/events", json.dumps(message), retain=False)
-            obj.previous = after
+        def update(camera, obj):
+            pass
 
-        def end(camera, obj: TrackedObject, current_frame_time):
-            if not obj.false_positive:
-                message = { 'before': obj.previous, 'after': obj.to_dict() }
-                self.client.publish(f"{self.topic_prefix}/events", json.dumps(message), retain=False)
-            self.event_queue.put(('end', camera, obj.to_dict(include_thumbnail=True)))
+        def end(camera, obj):
+            self.client.publish(f"{self.topic_prefix}/{camera}/events/end", json.dumps(obj), retain=False)
+            self.event_queue.put(('end', camera, obj))
         
-        def snapshot(camera, obj: TrackedObject, current_frame_time):
-            self.client.publish(f"{self.topic_prefix}/{camera}/{obj.obj_data['label']}/snapshot", obj.get_jpg_bytes(), retain=True)
+        def snapshot(camera, obj):
+            if not 'frame' in obj:
+                return
+            
+            best_frame = cv2.cvtColor(obj['frame'], cv2.COLOR_YUV2BGR_I420)
+            if self.camera_config[camera]['snapshots']['draw_bounding_boxes']:
+                thickness = 2
+                color = COLOR_MAP[obj['label']]
+                box = obj['box']
+                draw_box_with_label(best_frame, box[0], box[1], box[2], box[3], obj['label'], f"{int(obj['score']*100)}% {int(obj['area'])}", thickness=thickness, color=color)
+                
+            mqtt_config = self.camera_config[camera].get('mqtt', {'crop_to_region': False})
+            if mqtt_config.get('crop_to_region'):
+                region = obj['region']
+                best_frame = best_frame[region[1]:region[3], region[0]:region[2]]
+            if 'snapshot_height' in mqtt_config: 
+                height = int(mqtt_config['snapshot_height'])
+                width = int(height*best_frame.shape[1]/best_frame.shape[0])
+                best_frame = cv2.resize(best_frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
+            
+            if self.camera_config[camera]['snapshots']['show_timestamp']:
+                time_to_show = datetime.datetime.fromtimestamp(obj['frame_time']).strftime("%m/%d/%Y %H:%M:%S")
+                size = cv2.getTextSize(time_to_show, cv2.FONT_HERSHEY_SIMPLEX, fontScale=1, thickness=2)
+                text_width = size[0][0]
+                text_height = size[0][1]
+                desired_size = max(200, 0.33*best_frame.shape[1])
+                font_scale = desired_size/text_width
+                cv2.putText(best_frame, time_to_show, (5, best_frame.shape[0]-7), cv2.FONT_HERSHEY_SIMPLEX, fontScale=font_scale, color=(255, 255, 255), thickness=2)
+
+            ret, jpg = cv2.imencode('.jpg', best_frame)
+            if ret:
+                jpg_bytes = jpg.tobytes()
+                self.client.publish(f"{self.topic_prefix}/{camera}/{obj['label']}/snapshot", jpg_bytes, retain=True)
         
         def object_status(camera, object_name, status):
             self.client.publish(f"{self.topic_prefix}/{camera}/{object_name}", status, retain=False)
 
-        for camera in self.config.cameras.keys():
-            camera_state = CameraState(camera, self.config, self.frame_manager)
+        for camera in self.camera_config.keys():
+            camera_state = CameraState(camera, self.camera_config[camera], self.frame_manager)
             camera_state.on('start', start)
             camera_state.on('update', update)
             camera_state.on('end', end)
@@ -452,71 +311,83 @@ class TrackedObjectProcessor(threading.Thread):
             camera_state.on('object_status', object_status)
             self.camera_states[camera] = camera_state
 
+        self.camera_data = defaultdict(lambda: {
+            'best_objects': {},
+            'object_status': defaultdict(lambda: defaultdict(lambda: 'OFF')),
+            'tracked_objects': {},
+            'current_frame': np.zeros((720,1280,3), np.uint8),
+            'current_frame_time': 0.0,
+            'object_id': None
+        })
         # {
         #   'zone_name': {
-        #       'person': {
-        #           'camera_1': 2,
-        #           'camera_2': 1
-        #       }
+        #       'person': ['camera_1', 'camera_2']
         #   }
         # }
-        self.zone_data = defaultdict(lambda: defaultdict(lambda: {}))
+        self.zone_data = defaultdict(lambda: defaultdict(lambda: set()))
+
+        # set colors for zones
+        all_zone_names = set([zone for config in self.camera_config.values() for zone in config['zones'].keys()])
+        zone_colors = {}
+        colors = plt.cm.get_cmap('tab10', len(all_zone_names))
+        for i, zone in enumerate(all_zone_names):
+            zone_colors[zone] = tuple(int(round(255 * c)) for c in colors(i)[:3])
+
+        # create zone contours
+        for camera_config in self.camera_config.values():
+            for zone_name, zone_config in camera_config['zones'].items():
+                zone_config['color'] = zone_colors[zone_name]
+                coordinates = zone_config['coordinates']
+                if isinstance(coordinates, list):
+                    zone_config['contour'] =  np.array([[int(p.split(',')[0]), int(p.split(',')[1])] for p in coordinates])
+                elif isinstance(coordinates, str):
+                    points = coordinates.split(',')
+                    zone_config['contour'] =  np.array([[int(points[i]), int(points[i+1])] for i in range(0, len(points), 2)])
+                else:
+                    print(f"Unable to parse zone coordinates for {zone_name} - {camera}")
         
     def get_best(self, camera, label):
-        # TODO: need a lock here
-        camera_state = self.camera_states[camera]
-        if label in camera_state.best_objects:
-            best_obj = camera_state.best_objects[label]
-            best = best_obj.thumbnail_data.copy()
-            best['frame'] = camera_state.frame_cache.get(best_obj.thumbnail_data['frame_time'])
-            return best
+        best_objects = self.camera_states[camera].best_objects
+        if label in best_objects:
+            return best_objects[label]
         else:
             return {}
     
-    def get_current_frame(self, camera, draw_options={}):
-        return self.camera_states[camera].get_current_frame(draw_options)
+    def get_current_frame(self, camera, draw=False):
+        return self.camera_states[camera].get_current_frame(draw)
 
     def run(self):
         while True:
             if self.stop_event.is_set():
-                logger.info(f"Exiting object processor...")
+                print(f"Exiting object processor...")
                 break
 
             try:
-                camera, frame_time, current_tracked_objects, motion_boxes, regions = self.tracked_objects_queue.get(True, 10)
+                camera, frame_time, current_tracked_objects = self.tracked_objects_queue.get(True, 10)
             except queue.Empty:
                 continue
 
             camera_state = self.camera_states[camera]
 
-            camera_state.update(frame_time, current_tracked_objects, motion_boxes, regions)
+            camera_state.update(frame_time, current_tracked_objects)
 
-            # update zone counts for each label
-            # for each zone in the current camera
-            for zone in self.config.cameras[camera].zones.keys():
-                # count labels for the camera in the zone
-                obj_counter = Counter()
-                for obj in camera_state.tracked_objects.values():
-                    if zone in obj.current_zones and not obj.false_positive:
-                        obj_counter[obj.obj_data['label']] += 1
-                
-                # update counts and publish status
-                for label in set(list(self.zone_data[zone].keys()) + list(obj_counter.keys())):
-                    # if we have previously published a count for this zone/label
-                    zone_label = self.zone_data[zone][label]
-                    if camera in zone_label:
-                        current_count = sum(zone_label.values())
-                        zone_label[camera] = obj_counter[label] if label in obj_counter else 0
-                        new_count = sum(zone_label.values())
-                        if new_count != current_count:
-                            self.client.publish(f"{self.topic_prefix}/{zone}/{label}", new_count, retain=False)
-                    # if this is a new zone/label combo for this camera
-                    else:
-                        if label in obj_counter:
-                            zone_label[camera] = obj_counter[label]
-                            self.client.publish(f"{self.topic_prefix}/{zone}/{label}", obj_counter[label], retain=False)
-
-            # cleanup event finished queue
-            while not self.event_processed_queue.empty():
-                event_id, camera = self.event_processed_queue.get()
-                self.camera_states[camera].finished(event_id)
+            # update zone status for each label
+            for zone in camera_state.config['zones'].keys():
+                # get labels for current camera and all labels in current zone
+                labels_for_camera = set([obj['label'] for obj in camera_state.tracked_objects.values() if zone in obj['zones'] and not obj['false_positive']])
+                labels_to_check = labels_for_camera | set(self.zone_data[zone].keys())
+                # for each label in zone
+                for label in labels_to_check:
+                    camera_list = self.zone_data[zone][label]
+                    # remove or add the camera to the list for the current label
+                    previous_state = len(camera_list) > 0
+                    if label in labels_for_camera:
+                        camera_list.add(camera_state.name)
+                    elif camera_state.name in camera_list:
+                        camera_list.remove(camera_state.name)
+                    new_state = len(camera_list) > 0
+                    # if the value is changing, send over MQTT
+                    if previous_state == False and new_state == True:
+                        self.client.publish(f"{self.topic_prefix}/{zone}/{label}", 'ON', retain=False)
+                    elif previous_state == True and new_state == False:
+                        self.client.publish(f"{self.topic_prefix}/{zone}/{label}", 'OFF', retain=False)

frigate/objects.py

@@ -1,32 +1,29 @@
-import copy
+import time
 import datetime
+import threading
+import cv2
 import itertools
-import multiprocessing as mp
+import copy
+import numpy as np
 import random
 import string
-import threading
-import time
+import multiprocessing as mp
 from collections import defaultdict
-
-import cv2
-import numpy as np
 from scipy.spatial import distance as dist
-
-from frigate.config import DetectConfig
-from frigate.util import draw_box_with_label
-
+from frigate.util import draw_box_with_label, calculate_region
 
 class ObjectTracker():
-    def __init__(self, config: DetectConfig):
+    def __init__(self, max_disappeared):
         self.tracked_objects = {}
         self.disappeared = {}
-        self.max_disappeared = config.max_disappeared
+        self.max_disappeared = max_disappeared
 
     def register(self, index, obj):
         rand_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
         id = f"{obj['frame_time']}-{rand_id}"
         obj['id'] = id
         obj['start_time'] = obj['frame_time']
+        obj['top_score'] = obj['score']
         self.tracked_objects[id] = obj
         self.disappeared[id] = 0
 
@@ -37,6 +34,8 @@ class ObjectTracker():
     def update(self, id, new_obj):
         self.disappeared[id] = 0
         self.tracked_objects[id].update(new_obj)
+        if self.tracked_objects[id]['score'] > self.tracked_objects[id]['top_score']:
+            self.tracked_objects[id]['top_score'] = self.tracked_objects[id]['score']
 
     def match_and_update(self, frame_time, new_objects):
         # group by name

frigate/process_clip.py

@@ -1,208 +0,0 @@
-import datetime
-import json
-import logging
-import multiprocessing as mp
-import os
-import subprocess as sp
-import sys
-from unittest import TestCase, main
-
-import click
-import cv2
-import numpy as np
-
-from frigate.config import FRIGATE_CONFIG_SCHEMA, FrigateConfig
-from frigate.edgetpu import LocalObjectDetector
-from frigate.motion import MotionDetector
-from frigate.object_processing import COLOR_MAP, CameraState
-from frigate.objects import ObjectTracker
-from frigate.util import (DictFrameManager, EventsPerSecond,
-                          SharedMemoryFrameManager, draw_box_with_label)
-from frigate.video import (capture_frames, process_frames,
-                           start_or_restart_ffmpeg)
-
-logging.basicConfig()
-logging.root.setLevel(logging.DEBUG)
-
-logger = logging.getLogger(__name__)
-
-def get_frame_shape(source):
-    ffprobe_cmd = " ".join([
-        'ffprobe',
-        '-v',
-        'panic',
-        '-show_error',
-        '-show_streams',
-        '-of',
-        'json',
-        '"'+source+'"'
-    ])
-    p = sp.Popen(ffprobe_cmd, stdout=sp.PIPE, shell=True)
-    (output, err) = p.communicate()
-    p_status = p.wait()
-    info = json.loads(output)
-
-    video_info = [s for s in info['streams'] if s['codec_type'] == 'video'][0]
-
-    if video_info['height'] != 0 and video_info['width'] != 0:
-        return (video_info['height'], video_info['width'], 3)
-    
-    # fallback to using opencv if ffprobe didnt succeed
-    video = cv2.VideoCapture(source)
-    ret, frame = video.read()
-    frame_shape = frame.shape
-    video.release()
-    return frame_shape
-
-class ProcessClip():
-    def __init__(self, clip_path, frame_shape, config: FrigateConfig):
-        self.clip_path = clip_path
-        self.camera_name = 'camera'
-        self.config = config
-        self.camera_config = self.config.cameras['camera']
-        self.frame_shape = self.camera_config.frame_shape
-        self.ffmpeg_cmd = [c['cmd'] for c in self.camera_config.ffmpeg_cmds if 'detect' in c['roles']][0]
-        self.frame_manager = SharedMemoryFrameManager()
-        self.frame_queue = mp.Queue()
-        self.detected_objects_queue = mp.Queue()
-        self.camera_state = CameraState(self.camera_name, config, self.frame_manager)
-
-    def load_frames(self):
-        fps = EventsPerSecond()
-        skipped_fps = EventsPerSecond()
-        current_frame = mp.Value('d', 0.0)
-        frame_size = self.camera_config.frame_shape_yuv[0] * self.camera_config.frame_shape_yuv[1]
-        ffmpeg_process = start_or_restart_ffmpeg(self.ffmpeg_cmd, logger, sp.DEVNULL, frame_size)
-        capture_frames(ffmpeg_process, self.camera_name, self.camera_config.frame_shape_yuv, self.frame_manager, 
-            self.frame_queue, fps, skipped_fps, current_frame)
-        ffmpeg_process.wait()
-        ffmpeg_process.communicate()
-    
-    def process_frames(self, objects_to_track=['person'], object_filters={}):
-        mask = np.zeros((self.frame_shape[0], self.frame_shape[1], 1), np.uint8)
-        mask[:] = 255
-        motion_detector = MotionDetector(self.frame_shape, mask, self.camera_config.motion)
-
-        object_detector = LocalObjectDetector(labels='/labelmap.txt')
-        object_tracker = ObjectTracker(self.camera_config.detect)
-        process_info = {
-            'process_fps': mp.Value('d', 0.0),
-            'detection_fps': mp.Value('d', 0.0),
-            'detection_frame': mp.Value('d', 0.0)
-        }
-        stop_event = mp.Event()
-        model_shape = (self.config.model.height, self.config.model.width)
-
-        process_frames(self.camera_name, self.frame_queue, self.frame_shape, model_shape, 
-            self.frame_manager, motion_detector, object_detector, object_tracker, 
-            self.detected_objects_queue, process_info, 
-            objects_to_track, object_filters, mask, stop_event, exit_on_empty=True)
-    
-    def top_object(self, debug_path=None):
-        obj_detected = False
-        top_computed_score = 0.0
-        def handle_event(name, obj, frame_time):
-            nonlocal obj_detected
-            nonlocal top_computed_score
-            if obj.computed_score > top_computed_score:
-                top_computed_score = obj.computed_score
-            if not obj.false_positive:
-                obj_detected = True
-        self.camera_state.on('new', handle_event)
-        self.camera_state.on('update', handle_event)
-
-        while(not self.detected_objects_queue.empty()):
-            camera_name, frame_time, current_tracked_objects, motion_boxes, regions = self.detected_objects_queue.get()
-            if not debug_path is None:
-                self.save_debug_frame(debug_path, frame_time, current_tracked_objects.values())
-
-            self.camera_state.update(frame_time, current_tracked_objects, motion_boxes, regions)
-        
-        self.frame_manager.delete(self.camera_state.previous_frame_id)
-        
-        return {
-            'object_detected': obj_detected,
-            'top_score': top_computed_score
-        }
-    
-    def save_debug_frame(self, debug_path, frame_time, tracked_objects):
-        current_frame = cv2.cvtColor(self.frame_manager.get(f"{self.camera_name}{frame_time}", self.camera_config.frame_shape_yuv), cv2.COLOR_YUV2BGR_I420)
-        # draw the bounding boxes on the frame
-        for obj in tracked_objects:
-            thickness = 2
-            color = (0,0,175)
-
-            if obj['frame_time'] != frame_time:
-                thickness = 1
-                color = (255,0,0)
-            else:
-                color = (255,255,0)
-
-            # draw the bounding boxes on the frame
-            box = obj['box']
-            draw_box_with_label(current_frame, box[0], box[1], box[2], box[3], obj['id'], f"{int(obj['score']*100)}% {int(obj['area'])}", thickness=thickness, color=color)
-            # draw the regions on the frame
-            region = obj['region']
-            draw_box_with_label(current_frame, region[0], region[1], region[2], region[3], 'region', "", thickness=1, color=(0,255,0))
-        
-        cv2.imwrite(f"{os.path.join(debug_path, os.path.basename(self.clip_path))}.{int(frame_time*1000000)}.jpg", current_frame)
-
-@click.command()
-@click.option("-p", "--path", required=True, help="Path to clip or directory to test.")
-@click.option("-l", "--label", default='person', help="Label name to detect.")
-@click.option("-t", "--threshold", default=0.85, help="Threshold value for objects.")
-@click.option("-s", "--scores", default=None, help="File to save csv of top scores")
-@click.option("--debug-path", default=None, help="Path to output frames for debugging.")
-def process(path, label, threshold, scores, debug_path):
-    clips = []
-    if os.path.isdir(path):
-        files = os.listdir(path)
-        files.sort()
-        clips = [os.path.join(path, file) for file in files]
-    elif os.path.isfile(path):  
-        clips.append(path)
-
-    json_config = {
-        'mqtt': {
-            'host': 'mqtt'
-        },
-        'cameras': {
-            'camera': {
-                'ffmpeg': {
-                    'inputs': [
-                        { 'path': 'path.mp4', 'global_args': '', 'input_args': '', 'roles': ['detect'] }
-                    ]
-                },
-                'height': 1920,
-                'width': 1080
-            }
-        }
-    }
-
-    results = []
-    for c in clips:
-        logger.info(c)
-        frame_shape = get_frame_shape(c)
-        
-        json_config['cameras']['camera']['height'] = frame_shape[0]
-        json_config['cameras']['camera']['width'] = frame_shape[1]
-        json_config['cameras']['camera']['ffmpeg']['inputs'][0]['path'] = c
-
-        config = FrigateConfig(config=FRIGATE_CONFIG_SCHEMA(json_config))
-
-        process_clip = ProcessClip(c, frame_shape, config)
-        process_clip.load_frames()
-        process_clip.process_frames(objects_to_track=[label])
-
-        results.append((c, process_clip.top_object(debug_path)))
-
-    if not scores is None:
-        with open(scores, 'w') as writer:
-            for result in results:
-                writer.write(f"{result[0]},{result[1]['top_score']}\n")
-    
-    positive_count = sum(1 for result in results if result[1]['object_detected'])
-    print(f"Objects were detected in {positive_count}/{len(results)}({positive_count/len(results)*100:.2f}%) clip(s).")
-
-if __name__ == '__main__':
-    process()

frigate/record.py

@@ -1,125 +0,0 @@
-import datetime
-import json
-import logging
-import os
-import queue
-import subprocess as sp
-import threading
-import time
-from collections import defaultdict
-from pathlib import Path
-
-import psutil
-
-from frigate.config import FrigateConfig
-from frigate.const import RECORD_DIR, CLIPS_DIR, CACHE_DIR
-
-logger = logging.getLogger(__name__)
-
-SECONDS_IN_DAY = 60 * 60 * 24
-
-def remove_empty_directories(directory):
-  # list all directories recursively and sort them by path,
-  # longest first
-  paths = sorted(
-      [x[0] for x in os.walk(RECORD_DIR)],
-      key=lambda p: len(str(p)),
-      reverse=True,
-  )
-  for path in paths:
-      # don't delete the parent
-      if path == RECORD_DIR:
-          continue
-      if len(os.listdir(path)) == 0:
-          os.rmdir(path)
-
-class RecordingMaintainer(threading.Thread):
-    def __init__(self, config: FrigateConfig, stop_event):
-        threading.Thread.__init__(self)
-        self.name = 'recording_maint'
-        self.config = config
-        self.stop_event = stop_event
-
-    def move_files(self):
-        recordings = [d for d in os.listdir(RECORD_DIR) if os.path.isfile(os.path.join(RECORD_DIR, d)) and d.endswith(".mp4")]
-
-        files_in_use = []
-        for process in psutil.process_iter():
-            if process.name() != 'ffmpeg':
-                continue
-            try:
-                flist = process.open_files()
-                if flist:
-                    for nt in flist:
-                        if nt.path.startswith(RECORD_DIR):
-                            files_in_use.append(nt.path.split('/')[-1])
-            except:
-                continue
-
-        for f in recordings:
-            if f in files_in_use:
-                continue
-
-            camera = '-'.join(f.split('-')[:-1])
-            start_time = datetime.datetime.strptime(f.split('-')[-1].split('.')[0], '%Y%m%d%H%M%S')
-        
-            ffprobe_cmd = " ".join([
-                'ffprobe',
-                '-v',
-                'error',
-                '-show_entries',
-                'format=duration',
-                '-of',
-                'default=noprint_wrappers=1:nokey=1',
-                f"{os.path.join(RECORD_DIR,f)}"
-            ])
-            p = sp.Popen(ffprobe_cmd, stdout=sp.PIPE, shell=True)
-            (output, err) = p.communicate()
-            p_status = p.wait()
-            if p_status == 0:
-                duration = float(output.decode('utf-8').strip())
-            else:
-                logger.info(f"bad file: {f}")
-                os.remove(os.path.join(RECORD_DIR,f))
-                continue
-
-            directory = os.path.join(RECORD_DIR, start_time.strftime('%Y-%m/%d/%H'), camera)
-
-            if not os.path.exists(directory):
-                os.makedirs(directory)
-
-            file_name = f"{start_time.strftime('%M.%S.mp4')}"
-
-            os.rename(os.path.join(RECORD_DIR,f), os.path.join(directory,file_name))
-
-    def expire_files(self):
-        delete_before = {}
-        for name, camera in self.config.cameras.items():
-            delete_before[name] = datetime.datetime.now().timestamp() - SECONDS_IN_DAY*camera.record.retain_days
-
-        for p in Path('/media/frigate/recordings').rglob("*.mp4"):
-            if not p.parent in delete_before:
-                continue
-            if p.stat().st_mtime < delete_before[p.parent]:
-                p.unlink(missing_ok=True)
-
-    def run(self):
-        counter = 0
-        self.expire_files()
-        while(True):
-            if self.stop_event.is_set():
-                logger.info(f"Exiting recording maintenance...")
-                break
-
-            # only expire events every 10 minutes, but check for new files every 10 seconds
-            time.sleep(10)
-            counter = counter + 1
-            if counter > 60:
-                self.expire_files()
-                remove_empty_directories(RECORD_DIR)
-                counter = 0
-
-            self.move_files()
-
-
-   

frigate/test/test_config.py

@@ -1,344 +0,0 @@
-import json
-from unittest import TestCase, main
-import voluptuous as vol
-from frigate.config import FRIGATE_CONFIG_SCHEMA, FrigateConfig
-
-class TestConfig(TestCase):
-    def setUp(self):
-        self.minimal = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-    def test_empty(self):
-        FRIGATE_CONFIG_SCHEMA({})
-
-    def test_minimal(self):
-        FRIGATE_CONFIG_SCHEMA(self.minimal)
-    
-    def test_config_class(self):
-        FrigateConfig(config=self.minimal)
-    
-    def test_inherit_tracked_objects(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'objects': {
-                'track': ['person', 'dog']
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('dog' in frigate_config.cameras['back'].objects.track)
-    
-    def test_override_tracked_objects(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'objects': {
-                'track': ['person', 'dog']
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920,
-                    'objects': {
-                        'track': ['cat']
-                    }
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('cat' in frigate_config.cameras['back'].objects.track)
-    
-    def test_default_object_filters(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'objects': {
-                'track': ['person', 'dog']
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('dog' in frigate_config.cameras['back'].objects.filters)
-    
-    def test_inherit_object_filters(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'objects': {
-                'track': ['person', 'dog'],
-                'filters': {
-                    'dog': {
-                        'threshold': 0.7
-                    }
-                }
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('dog' in frigate_config.cameras['back'].objects.filters)
-        assert(frigate_config.cameras['back'].objects.filters['dog'].threshold == 0.7)
-    
-    def test_override_object_filters(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920,
-                    'objects': {
-                        'track': ['person', 'dog'],
-                        'filters': {
-                            'dog': {
-                                'threshold': 0.7
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('dog' in frigate_config.cameras['back'].objects.filters)
-        assert(frigate_config.cameras['back'].objects.filters['dog'].threshold == 0.7)
-    
-    def test_ffmpeg_params(self):
-        config = {
-            'ffmpeg': {
-                'input_args': ['-re']
-            },
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920,
-                    'objects': {
-                        'track': ['person', 'dog'],
-                        'filters': {
-                            'dog': {
-                                'threshold': 0.7
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert('-re' in frigate_config.cameras['back'].ffmpeg_cmds[0]['cmd'])
-    
-    def test_inherit_save_clips_retention(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'save_clips': {
-                'retain': {
-                    'default': 20,
-                    'objects': {
-                        'person': 30
-                    }
-                }
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-        frigate_config = FrigateConfig(config=config)
-        assert(frigate_config.cameras['back'].save_clips.retain.objects['person'] == 30)
-    
-    def test_roles_listed_twice_throws_error(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'save_clips': {
-                'retain': {
-                    'default': 20,
-                    'objects': {
-                        'person': 30
-                    }
-                }
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] },
-                            { 'path': 'rtsp://10.0.0.1:554/video2', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-        self.assertRaises(vol.MultipleInvalid, lambda: FrigateConfig(config=config))
-    
-    def test_zone_matching_camera_name_throws_error(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'save_clips': {
-                'retain': {
-                    'default': 20,
-                    'objects': {
-                        'person': 30
-                    }
-                }
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920,
-                    'zones': {
-                        'back': {
-                            'coordinates': '1,1,1,1,1,1'
-                        }
-                    }
-                }
-            }
-        }
-        self.assertRaises(vol.MultipleInvalid, lambda: FrigateConfig(config=config))
-    
-    def test_save_clips_should_default_to_global_objects(self):
-        config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'save_clips': {
-                'retain': {
-                    'default': 20,
-                    'objects': {
-                        'person': 30
-                    }
-                }
-            },
-            'objects': {
-                'track': ['person', 'dog']
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920,
-                    'save_clips': {
-                        'enabled': True
-                    }
-                }
-            }
-        }
-        config = FrigateConfig(config=config)
-        assert(len(config.cameras['back'].save_clips.objects) == 2)
-        assert('dog' in config.cameras['back'].save_clips.objects)
-        assert('person' in config.cameras['back'].save_clips.objects)
-    
-    def test_role_assigned_but_not_enabled(self):
-        json_config = {
-            'mqtt': {
-                'host': 'mqtt'
-            },
-            'cameras': {
-                'back': {
-                    'ffmpeg': {
-                        'inputs': [
-                            { 'path': 'rtsp://10.0.0.1:554/video', 'roles': ['detect', 'rtmp'] },
-                            { 'path': 'rtsp://10.0.0.1:554/clips', 'roles': ['clips'] }
-                        ]
-                    },
-                    'height': 1080,
-                    'width': 1920
-                }
-            }
-        }
-
-        config = FrigateConfig(config=json_config)
-        ffmpeg_cmds = config.cameras['back'].ffmpeg_cmds
-        assert(len(ffmpeg_cmds) == 1)
-        assert(not 'clips' in ffmpeg_cmds[0]['roles'])
-
-
-if __name__ == '__main__':
-    main(verbosity=2)

frigate/test/test_yuv_region_2_rgb.py

@@ -1,39 +0,0 @@
-import cv2
-import numpy as np
-from unittest import TestCase, main
-from frigate.util import yuv_region_2_rgb
-
-class TestYuvRegion2RGB(TestCase):
-    def setUp(self):
-        self.bgr_frame = np.zeros((100, 200, 3), np.uint8)
-        self.bgr_frame[:] = (0, 0, 255)
-        self.bgr_frame[5:55, 5:55] = (255,0,0)
-        # cv2.imwrite(f"bgr_frame.jpg", self.bgr_frame)
-        self.yuv_frame = cv2.cvtColor(self.bgr_frame, cv2.COLOR_BGR2YUV_I420)
-
-    def test_crop_yuv(self):
-        cropped = yuv_region_2_rgb(self.yuv_frame, (10,10,50,50))
-        # ensure the upper left pixel is blue
-        assert(np.all(cropped[0, 0] == [0, 0, 255]))
-
-    def test_crop_yuv_out_of_bounds(self):
-        cropped = yuv_region_2_rgb(self.yuv_frame, (0,0,200,200))
-        # cv2.imwrite(f"cropped.jpg", cv2.cvtColor(cropped, cv2.COLOR_RGB2BGR))
-        # ensure the upper left pixel is red
-        # the yuv conversion has some noise
-        assert(np.all(cropped[0, 0] == [255, 1, 0]))
-        # ensure the bottom right is black
-        assert(np.all(cropped[199, 199] == [0, 0, 0]))
-
-    def test_crop_yuv_portrait(self):
-        bgr_frame = np.zeros((1920, 1080, 3), np.uint8)
-        bgr_frame[:] = (0, 0, 255)
-        bgr_frame[5:55, 5:55] = (255,0,0)
-        # cv2.imwrite(f"bgr_frame.jpg", self.bgr_frame)
-        yuv_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2YUV_I420)
-
-        cropped = yuv_region_2_rgb(yuv_frame, (0, 852, 648, 1500))
-        # cv2.imwrite(f"cropped.jpg", cv2.cvtColor(cropped, cv2.COLOR_RGB2BGR))
-
-if __name__ == '__main__':
-    main(verbosity=2)

frigate/util.py

@@ -1,21 +1,17 @@
-import collections
-import datetime
-import hashlib
-import json
-import signal
-import subprocess as sp
-import threading
-import time
-import traceback
 from abc import ABC, abstractmethod
+import datetime
+import time
+import signal
+import traceback
+import collections
+import numpy as np
+import cv2
+import threading
+import matplotlib.pyplot as plt
+import hashlib
 from multiprocessing import shared_memory
 from typing import AnyStr
 
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-
-
 def draw_box_with_label(frame, x_min, y_min, x_max, y_max, label, info, thickness=2, color=None, position='ul'):
     if color is None:
         color = (0,0,255)
@@ -47,11 +43,14 @@ def draw_box_with_label(frame, x_min, y_min, x_max, y_max, label, info, thicknes
     cv2.putText(frame, display_text, (text_offset_x, text_offset_y + line_height - 3), font, fontScale=font_scale, color=(0, 0, 0), thickness=2)
 
 def calculate_region(frame_shape, xmin, ymin, xmax, ymax, multiplier=2):    
-    # size is the longest edge and divisible by 4
-    size = int(max(xmax-xmin, ymax-ymin)//4*4*multiplier)
+    # size is larger than longest edge
+    size = int(max(xmax-xmin, ymax-ymin)*multiplier)
     # dont go any smaller than 300
     if size < 300:
         size = 300
+    # if the size is too big to fit in the frame
+    if size > min(frame_shape[0], frame_shape[1]):
+        size = min(frame_shape[0], frame_shape[1])
 
     # x_offset is midpoint of bounding box minus half the size
     x_offset = int((xmax-xmin)/2.0+xmin-size/2.0)
@@ -59,156 +58,48 @@ def calculate_region(frame_shape, xmin, ymin, xmax, ymax, multiplier=2):
     if x_offset < 0:
         x_offset = 0
     elif x_offset > (frame_shape[1]-size):
-        x_offset = max(0, (frame_shape[1]-size))
+        x_offset = (frame_shape[1]-size)
 
     # y_offset is midpoint of bounding box minus half the size
     y_offset = int((ymax-ymin)/2.0+ymin-size/2.0)
-    # # if outside the image
+    # if outside the image
     if y_offset < 0:
         y_offset = 0
     elif y_offset > (frame_shape[0]-size):
-        y_offset = max(0, (frame_shape[0]-size))
+        y_offset = (frame_shape[0]-size)
 
     return (x_offset, y_offset, x_offset+size, y_offset+size)
 
-def get_yuv_crop(frame_shape, crop):
-    # crop should be (x1,y1,x2,y2)
-    frame_height = frame_shape[0]//3*2
-    frame_width = frame_shape[1]
-
-    # compute the width/height of the uv channels
-    uv_width = frame_width//2 # width of the uv channels
-    uv_height = frame_height//4 # height of the uv channels
-
-    # compute the offset for upper left corner of the uv channels
-    uv_x_offset = crop[0]//2 # x offset of the uv channels
-    uv_y_offset = crop[1]//4 # y offset of the uv channels
-
-    # compute the width/height of the uv crops
-    uv_crop_width  = (crop[2] - crop[0])//2 # width of the cropped uv channels
-    uv_crop_height = (crop[3] - crop[1])//4 # height of the cropped uv channels
-
-    # ensure crop dimensions are multiples of 2 and 4
-    y = (
-        crop[0],
-        crop[1],
-        crop[0]      + uv_crop_width*2,
-        crop[1]      + uv_crop_height*4
-    )
-
-    u1 = (
-        0            + uv_x_offset,
-        frame_height + uv_y_offset,
-        0            + uv_x_offset  +  uv_crop_width,
-        frame_height + uv_y_offset  +  uv_crop_height
-    )
-
-    u2 = (
-        uv_width     + uv_x_offset,
-        frame_height + uv_y_offset,
-        uv_width     + uv_x_offset  +  uv_crop_width,
-        frame_height + uv_y_offset  +  uv_crop_height
-    )
-
-    v1 = (
-        0            + uv_x_offset,
-        frame_height + uv_height    +  uv_y_offset,
-        0            + uv_x_offset  +  uv_crop_width,
-        frame_height + uv_height    +  uv_y_offset  +  uv_crop_height
-    )
-
-    v2 = (
-        uv_width     + uv_x_offset,
-        frame_height + uv_height    +  uv_y_offset,
-        uv_width     + uv_x_offset  +  uv_crop_width,
-        frame_height + uv_height    +  uv_y_offset + uv_crop_height
-    )
-
-    return y, u1, u2, v1, v2
-
 def yuv_region_2_rgb(frame, region):
-    try:
-        height = frame.shape[0]//3*2
-        width = frame.shape[1]
+    height = frame.shape[0]//3*2
+    width = frame.shape[1]
+    # make sure the size is a multiple of 4
+    size = (region[3] - region[1])//4*4
 
-        # get the crop box if the region extends beyond the frame
-        crop_x1 = max(0, region[0])
-        crop_y1 = max(0, region[1])
-        # ensure these are a multiple of 4
-        crop_x2 = min(width,  region[2])
-        crop_y2 = min(height, region[3])
-        crop_box = (crop_x1, crop_y1, crop_x2, crop_y2)
+    x1 = region[0] 
+    y1 = region[1]
 
-        y, u1, u2, v1, v2 = get_yuv_crop(frame.shape, crop_box)
+    uv_x1 = x1//2
+    uv_y1 = y1//4
 
-        # if the region starts outside the frame, indent the start point in the cropped frame
-        y_channel_x_offset = abs(min(0, region[0]))
-        y_channel_y_offset = abs(min(0, region[1]))
+    uv_width = size//2
+    uv_height = size//4
 
-        uv_channel_x_offset = y_channel_x_offset//2
-        uv_channel_y_offset = y_channel_y_offset//4
+    u_y_start = height
+    v_y_start = height + height//4
+    two_x_offset = width//2
 
-        # create the yuv region frame
-        # make sure the size is a multiple of 4
-        size = (region[3] - region[1])//4*4
-        yuv_cropped_frame = np.zeros((size+size//2, size), np.uint8)
-        # fill in black
-        yuv_cropped_frame[:] = 128
-        yuv_cropped_frame[0:size,0:size] = 16
+    yuv_cropped_frame = np.zeros((size+size//2, size), np.uint8)
+    # y channel
+    yuv_cropped_frame[0:size, 0:size] = frame[y1:y1+size, x1:x1+size]
+    # u channel
+    yuv_cropped_frame[size:size+uv_height, 0:uv_width] = frame[uv_y1+u_y_start:uv_y1+u_y_start+uv_height, uv_x1:uv_x1+uv_width]
+    yuv_cropped_frame[size:size+uv_height, uv_width:size] = frame[uv_y1+u_y_start:uv_y1+u_y_start+uv_height, uv_x1+two_x_offset:uv_x1+two_x_offset+uv_width]
+    # v channel
+    yuv_cropped_frame[size+uv_height:size+uv_height*2, 0:uv_width] = frame[uv_y1+v_y_start:uv_y1+v_y_start+uv_height, uv_x1:uv_x1+uv_width]
+    yuv_cropped_frame[size+uv_height:size+uv_height*2, uv_width:size] = frame[uv_y1+v_y_start:uv_y1+v_y_start+uv_height, uv_x1+two_x_offset:uv_x1+two_x_offset+uv_width]
 
-        # copy the y channel
-        yuv_cropped_frame[
-                y_channel_y_offset:y_channel_y_offset + y[3] - y[1],
-                y_channel_x_offset:y_channel_x_offset + y[2] - y[0]
-            ] = frame[
-                y[1]:y[3], 
-                y[0]:y[2]
-            ]
-
-        uv_crop_width = u1[2] - u1[0]
-        uv_crop_height = u1[3] - u1[1]
-
-        # copy u1
-        yuv_cropped_frame[
-                size + uv_channel_y_offset:size + uv_channel_y_offset + uv_crop_height,
-                0    + uv_channel_x_offset:0    + uv_channel_x_offset + uv_crop_width
-            ] = frame[
-                u1[1]:u1[3], 
-                u1[0]:u1[2]
-            ]
-
-        # copy u2
-        yuv_cropped_frame[
-                size    + uv_channel_y_offset:size    + uv_channel_y_offset + uv_crop_height,
-                size//2 + uv_channel_x_offset:size//2 + uv_channel_x_offset + uv_crop_width
-            ] = frame[
-                u2[1]:u2[3], 
-                u2[0]:u2[2]
-            ]
-
-        # copy v1
-        yuv_cropped_frame[
-                size+size//4 + uv_channel_y_offset:size+size//4 + uv_channel_y_offset + uv_crop_height,
-                0            + uv_channel_x_offset:0            + uv_channel_x_offset + uv_crop_width
-            ] = frame[
-                v1[1]:v1[3], 
-                v1[0]:v1[2]
-            ]
-
-        # copy v2
-        yuv_cropped_frame[
-                size+size//4 + uv_channel_y_offset:size+size//4 + uv_channel_y_offset + uv_crop_height,
-                size//2      + uv_channel_x_offset:size//2      + uv_channel_x_offset + uv_crop_width
-            ] = frame[
-                v2[1]:v2[3], 
-                v2[0]:v2[2]
-            ]
-
-        return cv2.cvtColor(yuv_cropped_frame, cv2.COLOR_YUV2RGB_I420)
-    except:
-        print(f"frame.shape: {frame.shape}")
-        print(f"region: {region}")
-        raise
+    return cv2.cvtColor(yuv_cropped_frame, cv2.COLOR_YUV2RGB_I420)
 
 def intersection(box_a, box_b):
     return (
@@ -350,4 +241,4 @@ class SharedMemoryFrameManager(FrameManager):
         if name in self.shm_store:
             self.shm_store[name].close()
             self.shm_store[name].unlink()
-            del self.shm_store[name]
+            del self.shm_store[name]

frigate/video.py

@@ -1,34 +1,57 @@
-import base64
-import copy
-import ctypes
+import os
+import time
 import datetime
+import cv2
+import queue
+import threading
+import ctypes
+import multiprocessing as mp
+import subprocess as sp
+import numpy as np
+import copy
 import itertools
 import json
-import logging
-import multiprocessing as mp
-import os
-import queue
-import subprocess as sp
-import signal
-import threading
-import time
-from collections import defaultdict
+import base64
 from typing import Dict, List
-
-import cv2
-import numpy as np
-
-from frigate.config import CameraConfig
-from frigate.edgetpu import RemoteObjectDetector
-from frigate.log import LogPipe
-from frigate.motion import MotionDetector
+from collections import defaultdict
+from frigate.util import draw_box_with_label, yuv_region_2_rgb, area, calculate_region, clipped, intersection_over_union, intersection, EventsPerSecond, listen, FrameManager, SharedMemoryFrameManager
 from frigate.objects import ObjectTracker
-from frigate.util import (EventsPerSecond, FrameManager,
-                          SharedMemoryFrameManager, area, calculate_region,
-                          clipped, draw_box_with_label, intersection,
-                          intersection_over_union, listen, yuv_region_2_rgb)
+from frigate.edgetpu import RemoteObjectDetector
+from frigate.motion import MotionDetector
 
-logger = logging.getLogger(__name__)
+def get_frame_shape(source):
+    ffprobe_cmd = " ".join([
+        'ffprobe',
+        '-v',
+        'panic',
+        '-show_error',
+        '-show_streams',
+        '-of',
+        'json',
+        '"'+source+'"'
+    ])
+    print(ffprobe_cmd)
+    p = sp.Popen(ffprobe_cmd, stdout=sp.PIPE, shell=True)
+    (output, err) = p.communicate()
+    p_status = p.wait()
+    info = json.loads(output)
+    print(info)
+
+    video_info = [s for s in info['streams'] if s['codec_type'] == 'video'][0]
+
+    if video_info['height'] != 0 and video_info['width'] != 0:
+        return (video_info['height'], video_info['width'], 3)
+    
+    # fallback to using opencv if ffprobe didnt succeed
+    video = cv2.VideoCapture(source)
+    ret, frame = video.read()
+    frame_shape = frame.shape
+    video.release()
+    return frame_shape
+
+def get_ffmpeg_input(ffmpeg_input):
+    frigate_vars = {k: v for k, v in os.environ.items() if k.startswith('FRIGATE_')}
+    return ffmpeg_input.format(**frigate_vars)
 
 def filtered(obj, objects_to_track, object_filters, mask=None):
     object_name = obj[0]
@@ -41,16 +64,16 @@ def filtered(obj, objects_to_track, object_filters, mask=None):
 
         # if the min area is larger than the
         # detected object, don't add it to detected objects
-        if obj_settings.min_area > obj[3]:
+        if obj_settings.get('min_area',-1) > obj[3]:
             return True
         
         # if the detected object is larger than the
         # max area, don't add it to detected objects
-        if obj_settings.max_area < obj[3]:
+        if obj_settings.get('max_area', 24000000) < obj[3]:
             return True
 
         # if the score is lower than the min_score, skip
-        if obj_settings.min_score > obj[1]:
+        if obj_settings.get('min_score', 0) > obj[1]:
             return True
     
         # compute the coordinates of the object and make sure
@@ -64,211 +87,142 @@ def filtered(obj, objects_to_track, object_filters, mask=None):
         
     return False
 
-def create_tensor_input(frame, model_shape, region):
+def create_tensor_input(frame, region):
     cropped_frame = yuv_region_2_rgb(frame, region)
 
     # Resize to 300x300 if needed
-    if cropped_frame.shape != (model_shape[0], model_shape[1], 3):
-        cropped_frame = cv2.resize(cropped_frame, dsize=model_shape, interpolation=cv2.INTER_LINEAR)
+    if cropped_frame.shape != (300, 300, 3):
+        cropped_frame = cv2.resize(cropped_frame, dsize=(300, 300), interpolation=cv2.INTER_LINEAR)
     
-    # Expand dimensions since the model expects images to have shape: [1, height, width, 3]
+    # Expand dimensions since the model expects images to have shape: [1, 300, 300, 3]
     return np.expand_dims(cropped_frame, axis=0)
 
-def stop_ffmpeg(ffmpeg_process, logger):
-    logger.info("Terminating the existing ffmpeg process...")
-    ffmpeg_process.terminate()
-    try:
-        logger.info("Waiting for ffmpeg to exit gracefully...")
-        ffmpeg_process.communicate(timeout=30)
-    except sp.TimeoutExpired:
-        logger.info("FFmpeg didnt exit. Force killing...")
-        ffmpeg_process.kill()
-        ffmpeg_process.communicate()
-    ffmpeg_process = None
-
-def start_or_restart_ffmpeg(ffmpeg_cmd, logger, logpipe: LogPipe, frame_size=None, ffmpeg_process=None):
+def start_or_restart_ffmpeg(ffmpeg_cmd, frame_size, ffmpeg_process=None):
     if not ffmpeg_process is None:
-        stop_ffmpeg(ffmpeg_process, logger)
+        print("Terminating the existing ffmpeg process...")
+        ffmpeg_process.terminate()
+        try:
+            print("Waiting for ffmpeg to exit gracefully...")
+            ffmpeg_process.communicate(timeout=30)
+        except sp.TimeoutExpired:
+            print("FFmpeg didnt exit. Force killing...")
+            ffmpeg_process.kill()
+            ffmpeg_process.communicate()
+        ffmpeg_process = None
 
-    if frame_size is None:
-        process = sp.Popen(ffmpeg_cmd, stdout = sp.DEVNULL, stderr=logpipe, stdin = sp.DEVNULL, start_new_session=True)
-    else:
-        process = sp.Popen(ffmpeg_cmd, stdout = sp.PIPE, stderr=logpipe, stdin = sp.DEVNULL, bufsize=frame_size*10, start_new_session=True)
+    print("Creating ffmpeg process...")
+    print(" ".join(ffmpeg_cmd))
+    process = sp.Popen(ffmpeg_cmd, stdout = sp.PIPE, stdin = sp.DEVNULL, bufsize=frame_size*10, start_new_session=True)
     return process
 
 def capture_frames(ffmpeg_process, camera_name, frame_shape, frame_manager: FrameManager, 
-    frame_queue, fps:mp.Value, skipped_fps: mp.Value, current_frame: mp.Value):
+    frame_queue, take_frame: int, fps:EventsPerSecond, skipped_fps: EventsPerSecond, 
+    stop_event: mp.Event, current_frame: mp.Value):
 
-    frame_size = frame_shape[0] * frame_shape[1]
-    frame_rate = EventsPerSecond()
-    frame_rate.start()
-    skipped_eps = EventsPerSecond()
-    skipped_eps.start()
+    frame_num = 0
+    frame_size = frame_shape[0] * frame_shape[1] * 3 // 2
+    skipped_fps.start()
     while True:
-        fps.value = frame_rate.eps()
-        skipped_fps = skipped_eps.eps()
+        if stop_event.is_set():
+            print(f"{camera_name}: stop event set. exiting capture thread...")
+            break
 
+        frame_bytes = ffmpeg_process.stdout.read(frame_size)
         current_frame.value = datetime.datetime.now().timestamp()
-        frame_name = f"{camera_name}{current_frame.value}"
-        frame_buffer = frame_manager.create(frame_name, frame_size)
-        try:
-            frame_buffer[:] = ffmpeg_process.stdout.read(frame_size)
-        except Exception as e:
-            logger.info(f"{camera_name}: ffmpeg sent a broken frame. {e}")
+
+        if len(frame_bytes) < frame_size:
+            print(f"{camera_name}: ffmpeg sent a broken frame. something is wrong.")
 
             if ffmpeg_process.poll() != None:
-                logger.info(f"{camera_name}: ffmpeg process is not running. exiting capture thread...")
-                frame_manager.delete(frame_name)
+                print(f"{camera_name}: ffmpeg process is not running. exiting capture thread...")
                 break
-            continue
+            else:
+                continue
 
-        frame_rate.update()
+        fps.update()
+
+        frame_num += 1
+        if (frame_num % take_frame) != 0:
+            skipped_fps.update()
+            continue
 
         # if the queue is full, skip this frame
         if frame_queue.full():
-            skipped_eps.update()
-            frame_manager.delete(frame_name)
+            skipped_fps.update()
             continue
 
-        # close the frame
-        frame_manager.close(frame_name)
+        # put the frame in the frame manager
+        frame_buffer = frame_manager.create(f"{camera_name}{current_frame.value}", frame_size)
+        frame_buffer[:] = frame_bytes[:]
+        frame_manager.close(f"{camera_name}{current_frame.value}")
 
         # add to the queue
         frame_queue.put(current_frame.value)
 
-class CameraWatchdog(threading.Thread):
-    def __init__(self, camera_name, config, frame_queue, camera_fps, ffmpeg_pid, stop_event):
-        threading.Thread.__init__(self)
-        self.logger = logging.getLogger(f"watchdog.{camera_name}")
-        self.camera_name = camera_name
-        self.config = config
-        self.capture_thread = None
-        self.ffmpeg_detect_process = None
-        self.logpipe = LogPipe(f"ffmpeg.{self.camera_name}.detect", logging.ERROR)
-        self.ffmpeg_other_processes = []
-        self.camera_fps = camera_fps
-        self.ffmpeg_pid = ffmpeg_pid
-        self.frame_queue = frame_queue
-        self.frame_shape = self.config.frame_shape_yuv
-        self.frame_size = self.frame_shape[0] * self.frame_shape[1]
-        self.stop_event = stop_event
-
-    def run(self):
-        self.start_ffmpeg_detect()
-
-        for c in self.config.ffmpeg_cmds:
-            if 'detect' in c['roles']:
-                continue
-            logpipe = LogPipe(f"ffmpeg.{self.camera_name}.{'_'.join(sorted(c['roles']))}", logging.ERROR)
-            self.ffmpeg_other_processes.append({
-                'cmd': c['cmd'],
-                'logpipe': logpipe,
-                'process': start_or_restart_ffmpeg(c['cmd'], self.logger, logpipe)
-            })
-        
-        time.sleep(10)
-        while True:
-            if self.stop_event.is_set():
-                stop_ffmpeg(self.ffmpeg_detect_process, self.logger)
-                for p in self.ffmpeg_other_processes:
-                    stop_ffmpeg(p['process'], self.logger)
-                    p['logpipe'].close()
-                self.logpipe.close()
-                break
-
-            now = datetime.datetime.now().timestamp()
-
-            if not self.capture_thread.is_alive():
-                self.start_ffmpeg_detect()
-            elif now - self.capture_thread.current_frame.value > 20:
-                self.logger.info(f"No frames received from {self.camera_name} in 20 seconds. Exiting ffmpeg...")
-                self.ffmpeg_detect_process.terminate()
-                try:
-                    self.logger.info("Waiting for ffmpeg to exit gracefully...")
-                    self.ffmpeg_detect_process.communicate(timeout=30)
-                except sp.TimeoutExpired:
-                    self.logger.info("FFmpeg didnt exit. Force killing...")
-                    self.ffmpeg_detect_process.kill()
-                    self.ffmpeg_detect_process.communicate()
-            
-            for p in self.ffmpeg_other_processes:
-                poll = p['process'].poll()
-                if poll == None:
-                    continue
-                p['process'] = start_or_restart_ffmpeg(p['cmd'], self.logger, p['logpipe'], ffmpeg_process=p['process'])
-            
-            # wait a bit before checking again
-            time.sleep(10)
-    
-    def start_ffmpeg_detect(self):
-        ffmpeg_cmd = [c['cmd'] for c in self.config.ffmpeg_cmds if 'detect' in c['roles']][0]
-        self.ffmpeg_detect_process = start_or_restart_ffmpeg(ffmpeg_cmd, self.logger, self.logpipe, self.frame_size)
-        self.ffmpeg_pid.value = self.ffmpeg_detect_process.pid
-        self.capture_thread = CameraCapture(self.camera_name, self.ffmpeg_detect_process, self.frame_shape, self.frame_queue, 
-            self.camera_fps)
-        self.capture_thread.start()
-
 class CameraCapture(threading.Thread):
-    def __init__(self, camera_name, ffmpeg_process, frame_shape, frame_queue, fps):
+    def __init__(self, name, ffmpeg_process, frame_shape, frame_queue, take_frame, fps, stop_event):
         threading.Thread.__init__(self)
-        self.name = f"capture:{camera_name}"
-        self.camera_name = camera_name
+        self.name = name
         self.frame_shape = frame_shape
+        self.frame_size = frame_shape[0] * frame_shape[1] * frame_shape[2]
         self.frame_queue = frame_queue
+        self.take_frame = take_frame
         self.fps = fps
         self.skipped_fps = EventsPerSecond()
         self.frame_manager = SharedMemoryFrameManager()
         self.ffmpeg_process = ffmpeg_process
         self.current_frame = mp.Value('d', 0.0)
         self.last_frame = 0
+        self.stop_event = stop_event
 
     def run(self):
         self.skipped_fps.start()
-        capture_frames(self.ffmpeg_process, self.camera_name, self.frame_shape, self.frame_manager, self.frame_queue,
-            self.fps, self.skipped_fps, self.current_frame)
+        capture_frames(self.ffmpeg_process, self.name, self.frame_shape, self.frame_manager, self.frame_queue, self.take_frame,
+            self.fps, self.skipped_fps, self.stop_event, self.current_frame)
 
-def capture_camera(name, config: CameraConfig, process_info):
-    stop_event = mp.Event()
-    def receiveSignal(signalNumber, frame):
-        stop_event.set()
-    
-    signal.signal(signal.SIGTERM, receiveSignal)
-    signal.signal(signal.SIGINT, receiveSignal)
-
-    frame_queue = process_info['frame_queue']
-    camera_watchdog = CameraWatchdog(name, config, frame_queue, process_info['camera_fps'], process_info['ffmpeg_pid'], stop_event)
-    camera_watchdog.start()
-    camera_watchdog.join()
-
-def track_camera(name, config: CameraConfig, model_shape, detection_queue, result_connection, detected_objects_queue, process_info):
-    stop_event = mp.Event()
-    def receiveSignal(signalNumber, frame):
-        stop_event.set()
-    
-    signal.signal(signal.SIGTERM, receiveSignal)
-    signal.signal(signal.SIGINT, receiveSignal)
-
-    threading.current_thread().name = f"process:{name}"
+def track_camera(name, config, frame_queue, frame_shape, detection_queue, result_connection, detected_objects_queue, fps, detection_fps, read_start, detection_frame, stop_event):
+    print(f"Starting process for {name}: {os.getpid()}")
     listen()
 
-    frame_queue = process_info['frame_queue']
+    detection_frame.value = 0.0
 
-    frame_shape = config.frame_shape
-    objects_to_track = config.objects.track
-    object_filters = config.objects.filters
-    mask = config.mask
+    # Merge the tracked object config with the global config
+    camera_objects_config = config.get('objects', {})
+    objects_to_track = camera_objects_config.get('track', [])
+    object_filters = camera_objects_config.get('filters', {})
 
-    motion_detector = MotionDetector(frame_shape, mask, config.motion)
-    object_detector = RemoteObjectDetector(name, '/labelmap.txt', detection_queue, result_connection, model_shape)
+    # load in the mask for object detection
+    if 'mask' in config:
+        if config['mask'].startswith('base64,'):
+            img = base64.b64decode(config['mask'][7:]) 
+            npimg = np.fromstring(img, dtype=np.uint8)
+            mask = cv2.imdecode(npimg, cv2.IMREAD_GRAYSCALE)
+        elif config['mask'].startswith('poly,'):
+            points = config['mask'].split(',')[1:]
+            contour =  np.array([[int(points[i]), int(points[i+1])] for i in range(0, len(points), 2)])
+            mask = np.zeros((frame_shape[0], frame_shape[1]), np.uint8)
+            mask[:] = 255
+            cv2.fillPoly(mask, pts=[contour], color=(0))
+        else:
+            mask = cv2.imread("/config/{}".format(config['mask']), cv2.IMREAD_GRAYSCALE)
+    else:
+        mask = None
 
-    object_tracker = ObjectTracker(config.detect)
+    if mask is None or mask.size == 0:
+        mask = np.zeros((frame_shape[0], frame_shape[1]), np.uint8)
+        mask[:] = 255
+
+    motion_detector = MotionDetector(frame_shape, mask, resize_factor=6)
+    object_detector = RemoteObjectDetector(name, '/labelmap.txt', detection_queue, result_connection)
+
+    object_tracker = ObjectTracker(10)
 
     frame_manager = SharedMemoryFrameManager()
 
-    process_frames(name, frame_queue, frame_shape, model_shape, frame_manager, motion_detector, object_detector,
-        object_tracker, detected_objects_queue, process_info, objects_to_track, object_filters, mask, stop_event)
+    process_frames(name, frame_queue, frame_shape, frame_manager, motion_detector, object_detector,
+        object_tracker, detected_objects_queue, fps, detection_fps, detection_frame, objects_to_track, object_filters, mask, stop_event)
 
-    logger.info(f"{name}: exiting subprocess")
+    print(f"{name}: exiting subprocess")
 
 def reduce_boxes(boxes):
     if len(boxes) == 0:
@@ -276,8 +230,8 @@ def reduce_boxes(boxes):
     reduced_boxes = cv2.groupRectangles([list(b) for b in itertools.chain(boxes, boxes)], 1, 0.2)[0]
     return [tuple(b) for b in reduced_boxes]
 
-def detect(object_detector, frame, model_shape, region, objects_to_track, object_filters, mask):
-    tensor_input = create_tensor_input(frame, model_shape, region)
+def detect(object_detector, frame, region, objects_to_track, object_filters, mask):
+    tensor_input = create_tensor_input(frame, region)
 
     detections = []
     region_detections = object_detector.detect(tensor_input)
@@ -299,40 +253,37 @@ def detect(object_detector, frame, model_shape, region, objects_to_track, object
         detections.append(det)
     return detections
 
-def process_frames(camera_name: str, frame_queue: mp.Queue, frame_shape, model_shape,
+def process_frames(camera_name: str, frame_queue: mp.Queue, frame_shape, 
     frame_manager: FrameManager, motion_detector: MotionDetector, 
     object_detector: RemoteObjectDetector, object_tracker: ObjectTracker,
-    detected_objects_queue: mp.Queue, process_info: Dict,
-    objects_to_track: List[str], object_filters, mask, stop_event,
+    detected_objects_queue: mp.Queue, fps: mp.Value, detection_fps: mp.Value, current_frame_time: mp.Value,
+    objects_to_track: List[str], object_filters: Dict, mask, stop_event: mp.Event,
     exit_on_empty: bool = False):
     
-    fps = process_info['process_fps']
-    detection_fps = process_info['detection_fps']
-    current_frame_time = process_info['detection_frame']
-
     fps_tracker = EventsPerSecond()
     fps_tracker.start()
 
     while True:
-        if stop_event.is_set():
-            break
-
-        if exit_on_empty and frame_queue.empty():
-            logger.info(f"Exiting track_objects...")
-            break
+        if stop_event.is_set() or (exit_on_empty and frame_queue.empty()):
+                print(f"Exiting track_objects...")
+                break
 
         try:
             frame_time = frame_queue.get(True, 10)
         except queue.Empty:
             continue
 
+        
         current_frame_time.value = frame_time
 
         frame = frame_manager.get(f"{camera_name}{frame_time}", (frame_shape[0]*3//2, frame_shape[1]))
 
         if frame is None:
-            logger.info(f"{camera_name}: frame {frame_time} is not in memory store.")
+            print(f"{camera_name}: frame {frame_time} is not in memory store.")
             continue
+        
+        fps_tracker.update()
+        fps.value = fps_tracker.eps()
 
         # look for motion
         motion_boxes = motion_detector.detect(frame)
@@ -356,7 +307,7 @@ def process_frames(camera_name: str, frame_queue: mp.Queue, frame_shape, model_s
         # resize regions and detect
         detections = []
         for region in regions:
-            detections.extend(detect(object_detector, frame, model_shape, region, objects_to_track, object_filters, mask))
+            detections.extend(detect(object_detector, frame, region, objects_to_track, object_filters, mask))
         
         #########
         # merge objects, check for clipped objects and look again up to 4 times
@@ -388,10 +339,8 @@ def process_frames(camera_name: str, frame_queue: mp.Queue, frame_shape, model_s
                         region = calculate_region(frame_shape, 
                             box[0], box[1],
                             box[2], box[3])
-
-                        regions.append(region)
                         
-                        selected_objects.extend(detect(object_detector, frame, model_shape, region, objects_to_track, object_filters, mask))
+                        selected_objects.extend(detect(object_detector, frame, region, objects_to_track, object_filters, mask))
 
                         refining = True
                     else:
@@ -406,13 +355,9 @@ def process_frames(camera_name: str, frame_queue: mp.Queue, frame_shape, model_s
         # now that we have refined our detections, we need to track objects
         object_tracker.match_and_update(frame_time, detections)
 
-        # add to the queue if not full
-        if(detected_objects_queue.full()):
-          frame_manager.delete(f"{camera_name}{frame_time}")
-          continue
-        else:
-          fps_tracker.update()
-          fps.value = fps_tracker.eps()
-          detected_objects_queue.put((camera_name, frame_time, object_tracker.tracked_objects, motion_boxes, regions))
-          detection_fps.value = object_detector.fps.eps()
-          frame_manager.close(f"{camera_name}{frame_time}")
+        # add to the queue
+        detected_objects_queue.put((camera_name, frame_time, object_tracker.tracked_objects))
+
+        detection_fps.value = object_detector.fps.eps()
+
+        frame_manager.close(f"{camera_name}{frame_time}")

frigate/watchdog.py

@@ -1,36 +0,0 @@
-import datetime
-import logging
-import threading
-import time
-
-logger = logging.getLogger(__name__)
-
-class FrigateWatchdog(threading.Thread):
-    def __init__(self, detectors, stop_event):
-        threading.Thread.__init__(self)
-        self.name = 'frigate_watchdog'
-        self.detectors = detectors
-        self.stop_event = stop_event
-
-    def run(self):
-        time.sleep(10)
-        while True:
-            # wait a bit before checking
-            time.sleep(10)
-
-            if self.stop_event.is_set():
-                logger.info(f"Exiting watchdog...")
-                break
-
-            now = datetime.datetime.now().timestamp()
-
-            # check the detection processes
-            for detector in self.detectors.values():
-                detection_start = detector.detection_start.value
-                if (detection_start > 0.0 and 
-                    now - detection_start > 10):
-                    logger.info("Detection appears to be stuck. Restarting detection process")
-                    detector.start_or_restart()
-                elif not detector.detect_process.is_alive():
-                    logger.info("Detection appears to have stopped. Restarting detection process")
-                    detector.start_or_restart()

frigate/zeroconf.py

@@ -1,58 +0,0 @@
-import logging
-import socket
-
-from zeroconf import (
-    ServiceInfo,
-    NonUniqueNameException,
-    InterfaceChoice,
-    IPVersion,
-    Zeroconf,
-)
-
-logger = logging.getLogger(__name__)
-
-ZEROCONF_TYPE = "_frigate._tcp.local."
-
-# Taken from: http://stackoverflow.com/a/11735897
-def get_local_ip() -> str:
-    """Try to determine the local IP address of the machine."""
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-
-        # Use Google Public DNS server to determine own IP
-        sock.connect(("8.8.8.8", 80))
-
-        return sock.getsockname()[0]  # type: ignore
-    except OSError:
-        try:
-            return socket.gethostbyname(socket.gethostname())
-        except socket.gaierror:
-            return "127.0.0.1"
-    finally:
-        sock.close()
-
-def broadcast_zeroconf(frigate_id):
-    zeroconf = Zeroconf(interfaces=InterfaceChoice.Default, ip_version=IPVersion.V4Only)
-
-    host_ip = get_local_ip()
-
-    try:
-        host_ip_pton = socket.inet_pton(socket.AF_INET, host_ip)
-    except OSError:
-        host_ip_pton = socket.inet_pton(socket.AF_INET6, host_ip)
-
-    info = ServiceInfo(
-        ZEROCONF_TYPE,
-        name=f"{frigate_id}.{ZEROCONF_TYPE}",
-        addresses=[host_ip_pton],
-        port=5000,
-    )
-
-    logger.info("Starting Zeroconf broadcast")
-    try:
-        zeroconf.register_service(info)
-    except NonUniqueNameException:
-        logger.error(
-            "Frigate instance with identical name present in the local network"
-        )
-    return zeroconf

nginx/nginx.conf

@@ -1,122 +0,0 @@
-worker_processes  1;
-
-error_log  /var/log/nginx/error.log warn;
-pid        /var/run/nginx.pid;
-
-load_module "modules/ngx_rtmp_module.so";
-
-events {
-    worker_connections  1024;
-}
-
-http {
-    include       /etc/nginx/mime.types;
-    default_type  application/octet-stream;
-
-    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
-                        '$status $body_bytes_sent "$http_referer" '
-                        '"$http_user_agent" "$http_x_forwarded_for"';
-
-    access_log  /var/log/nginx/access.log  main;
-
-    sendfile        on;
-
-    keepalive_timeout  65;
-
-    upstream frigate_api {
-      server localhost:5001;
-      keepalive 1024;
-    }
-
-    server {
-        listen 5000;
-
-        location /stream/ {
-            add_header 'Cache-Control' 'no-cache';
-            add_header 'Access-Control-Allow-Origin' "$http_origin" always;
-            add_header 'Access-Control-Allow-Credentials' 'true';
-            add_header 'Access-Control-Expose-Headers' 'Content-Length';
-            if ($request_method = 'OPTIONS') {
-                add_header 'Access-Control-Allow-Origin' "$http_origin";
-                add_header 'Access-Control-Max-Age' 1728000;
-                add_header 'Content-Type' 'text/plain charset=UTF-8';
-                add_header 'Content-Length' 0;
-                return 204;
-            }
-
-            types {
-                application/dash+xml mpd;
-                application/vnd.apple.mpegurl m3u8;
-                video/mp2t ts;
-                image/jpeg jpg;
-            }
-
-            root /tmp;
-        }
-
-        location /clips/ {
-            add_header 'Access-Control-Allow-Origin' "$http_origin" always;
-            add_header 'Access-Control-Allow-Credentials' 'true';
-            add_header 'Access-Control-Expose-Headers' 'Content-Length';
-            if ($request_method = 'OPTIONS') {
-                add_header 'Access-Control-Allow-Origin' "$http_origin";
-                add_header 'Access-Control-Max-Age' 1728000;
-                add_header 'Content-Type' 'text/plain charset=UTF-8';
-                add_header 'Content-Length' 0;
-                return 204;
-            }
-
-            types {
-                video/mp4 mp4;
-                image/jpeg jpg;
-            }
-
-            autoindex on;
-            root /media/frigate;
-        }
-
-        location /recordings/ {
-            add_header 'Access-Control-Allow-Origin' "$http_origin" always;
-            add_header 'Access-Control-Allow-Credentials' 'true';
-            add_header 'Access-Control-Expose-Headers' 'Content-Length';
-            if ($request_method = 'OPTIONS') {
-                add_header 'Access-Control-Allow-Origin' "$http_origin";
-                add_header 'Access-Control-Max-Age' 1728000;
-                add_header 'Content-Type' 'text/plain charset=UTF-8';
-                add_header 'Content-Length' 0;
-                return 204;
-            }
-
-            types {
-                video/mp4 mp4;
-            }
-
-            autoindex on;
-            autoindex_format json;
-            root /media/frigate;
-        }
-
-        location / {
-            proxy_pass http://frigate_api/;
-            proxy_pass_request_headers on;
-            proxy_set_header Host $host;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header X-Forwarded-Proto $scheme;
-        }
-    }
-}
-
-rtmp {
-    server {
-        listen 1935;
-        chunk_size 4096;
-        allow publish 127.0.0.1;
-        deny publish all;
-        allow play all;
-        application live {
-            live on;
-            record off;
-            meta copy;
-        }
-    }
-}

process_clip.py

@@ -0,0 +1,152 @@
+import sys
+import click
+import os
+import datetime
+from unittest import TestCase, main
+from frigate.video import process_frames, start_or_restart_ffmpeg, capture_frames, get_frame_shape
+from frigate.util import DictFrameManager, SharedMemoryFrameManager, EventsPerSecond, draw_box_with_label
+from frigate.motion import MotionDetector
+from frigate.edgetpu import LocalObjectDetector
+from frigate.objects import ObjectTracker
+import multiprocessing as mp
+import numpy as np
+import cv2
+from frigate.object_processing import COLOR_MAP, CameraState
+
+class ProcessClip():
+    def __init__(self, clip_path, frame_shape, config):
+        self.clip_path = clip_path
+        self.frame_shape = frame_shape
+        self.camera_name = 'camera'
+        self.frame_manager = DictFrameManager()
+        # self.frame_manager = SharedMemoryFrameManager()
+        self.frame_queue = mp.Queue()
+        self.detected_objects_queue = mp.Queue()
+        self.camera_state = CameraState(self.camera_name, config, self.frame_manager)
+
+    def load_frames(self):
+        fps = EventsPerSecond()
+        skipped_fps = EventsPerSecond()
+        stop_event = mp.Event()
+        detection_frame = mp.Value('d', datetime.datetime.now().timestamp()+100000)
+        current_frame = mp.Value('d', 0.0)
+        ffmpeg_cmd = f"ffmpeg -hide_banner -loglevel panic -i {self.clip_path} -f rawvideo -pix_fmt rgb24 pipe:".split(" ")
+        ffmpeg_process = start_or_restart_ffmpeg(ffmpeg_cmd, self.frame_shape[0]*self.frame_shape[1]*self.frame_shape[2])
+        capture_frames(ffmpeg_process, self.camera_name, self.frame_shape, self.frame_manager, self.frame_queue, 1, fps, skipped_fps, stop_event, detection_frame, current_frame)
+        ffmpeg_process.wait()
+        ffmpeg_process.communicate()
+    
+    def process_frames(self, objects_to_track=['person'], object_filters={}):
+        mask = np.zeros((self.frame_shape[0], self.frame_shape[1], 1), np.uint8)
+        mask[:] = 255
+        motion_detector = MotionDetector(self.frame_shape, mask)
+
+        object_detector = LocalObjectDetector(labels='/labelmap.txt')
+        object_tracker = ObjectTracker(10)
+        process_fps = mp.Value('d', 0.0)
+        detection_fps = mp.Value('d', 0.0)
+        current_frame = mp.Value('d', 0.0)
+        stop_event = mp.Event()
+
+        process_frames(self.camera_name, self.frame_queue, self.frame_shape, self.frame_manager, motion_detector, object_detector, object_tracker, self.detected_objects_queue, 
+            process_fps, detection_fps, current_frame, objects_to_track, object_filters, mask, stop_event, exit_on_empty=True)
+    
+    def objects_found(self, debug_path=None):
+        obj_detected = False
+        top_computed_score = 0.0
+        def handle_event(name, obj):
+            nonlocal obj_detected
+            nonlocal top_computed_score
+            if obj['computed_score'] > top_computed_score:
+                top_computed_score = obj['computed_score']
+            if not obj['false_positive']:
+                obj_detected = True
+        self.camera_state.on('new', handle_event)
+        self.camera_state.on('update', handle_event)
+
+        while(not self.detected_objects_queue.empty()):
+            camera_name, frame_time, current_tracked_objects = self.detected_objects_queue.get()
+            if not debug_path is None:
+                self.save_debug_frame(debug_path, frame_time, current_tracked_objects.values())
+
+            self.camera_state.update(frame_time, current_tracked_objects)
+            for obj in self.camera_state.tracked_objects.values():
+                print(f"{frame_time}: {obj['id']} - {obj['computed_score']} - {obj['score_history']}")
+        
+        self.frame_manager.delete(self.camera_state.previous_frame_id)
+        
+        return {
+            'object_detected': obj_detected,
+            'top_score': top_computed_score
+        }
+    
+    def save_debug_frame(self, debug_path, frame_time, tracked_objects):
+        current_frame = self.frame_manager.get(f"{self.camera_name}{frame_time}", self.frame_shape)
+        # draw the bounding boxes on the frame
+        for obj in tracked_objects:
+            thickness = 2
+            color = (0,0,175)
+
+            if obj['frame_time'] != frame_time:
+                thickness = 1
+                color = (255,0,0)
+            else:
+                color = (255,255,0)
+
+            # draw the bounding boxes on the frame
+            box = obj['box']
+            draw_box_with_label(current_frame, box[0], box[1], box[2], box[3], obj['label'], f"{int(obj['score']*100)}% {int(obj['area'])}", thickness=thickness, color=color)
+            # draw the regions on the frame
+            region = obj['region']
+            draw_box_with_label(current_frame, region[0], region[1], region[2], region[3], 'region', "", thickness=1, color=(0,255,0))
+        
+        cv2.imwrite(f"{os.path.join(debug_path, os.path.basename(self.clip_path))}.{int(frame_time*1000000)}.jpg", cv2.cvtColor(current_frame, cv2.COLOR_RGB2BGR))
+
+@click.command()
+@click.option("-p", "--path", required=True, help="Path to clip or directory to test.")
+@click.option("-l", "--label", default='person', help="Label name to detect.")
+@click.option("-t", "--threshold", default=0.85, help="Threshold value for objects.")
+@click.option("--debug-path", default=None, help="Path to output frames for debugging.")
+def process(path, label, threshold, debug_path):
+    clips = []
+    if os.path.isdir(path):
+        files = os.listdir(path)
+        files.sort()
+        clips = [os.path.join(path, file) for file in files]
+    elif os.path.isfile(path):  
+        clips.append(path)
+
+    config = {
+        'snapshots': {
+            'show_timestamp': False, 
+            'draw_zones': False
+        },
+        'zones': {},
+        'objects': {
+            'track': [label],
+            'filters': {
+                'person': {
+                    'threshold': threshold
+                }
+            }
+        }
+    }
+
+    results = []
+    for c in clips:
+        frame_shape = get_frame_shape(c)
+        config['frame_shape'] = frame_shape
+        process_clip = ProcessClip(c, frame_shape, config)
+        process_clip.load_frames()
+        process_clip.process_frames(objects_to_track=config['objects']['track'])
+
+        results.append((c, process_clip.objects_found(debug_path)))
+
+    for result in results:
+        print(f"{result[0]}: {result[1]}")
+    
+    positive_count = sum(1 for result in results if result[1]['object_detected'])
+    print(f"Objects were detected in {positive_count}/{len(results)}({positive_count/len(results)*100:.2f}%) clip(s).")
+
+if __name__ == '__main__':
+    process()

run.sh

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-service nginx start
-exec python3 -u -m frigate