allow specifying debug view fps and size

Dockerfile

@@ -38,9 +38,9 @@ RUN apt -qq update && apt -qq install --no-install-recommends -y \
     && apt -qq install --no-install-recommends -y \
         libedgetpu1-max \
     ## Tensorflow lite (python 3.7 only)
-    && wget -q https://dl.google.com/coral/python/tflite_runtime-2.1.0-cp37-cp37m-linux_x86_64.whl \
+    && wget -q https://dl.google.com/coral/python/tflite_runtime-2.1.0.post1-cp37-cp37m-linux_x86_64.whl \
-    && python3.7 -m pip install tflite_runtime-2.1.0-cp37-cp37m-linux_x86_64.whl \
+    && python3.7 -m pip install tflite_runtime-2.1.0.post1-cp37-cp37m-linux_x86_64.whl \
-    && rm tflite_runtime-2.1.0-cp37-cp37m-linux_x86_64.whl \
+    && rm tflite_runtime-2.1.0.post1-cp37-cp37m-linux_x86_64.whl \
     && rm -rf /var/lib/apt/lists/* \
     && (apt-get autoremove -y; apt-get autoclean -y)
 

README.md

@@ -16,16 +16,6 @@ You see multiple bounding boxes because it draws bounding boxes from all frames
 [![](http://img.youtube.com/vi/nqHbCtyo4dY/0.jpg)](http://www.youtube.com/watch?v=nqHbCtyo4dY "Frigate")
 
 ## Getting Started
-Build the container with
-```
-docker build -t frigate .
-```
-
-Models for both CPU and EdgeTPU (Coral) are bundled in the image. You can use your own models with volume mounts:
-- CPU Model: `/cpu_model.tflite`
-- EdgeTPU Model: `/edgetpu_model.tflite`
-- Labels: `/labelmap.txt`
-
 Run the container with
 ```bash
 docker run --rm \
@@ -36,7 +26,7 @@ docker run --rm \
 -v /etc/localtime:/etc/localtime:ro \
 -p 5000:5000 \
 -e FRIGATE_RTSP_PASSWORD='password' \
-frigate:latest
+blakeblackshear/frigate:stable
 ```
 
 Example docker-compose:
@@ -46,7 +36,7 @@ Example docker-compose:
     restart: unless-stopped
     privileged: true
     shm_size: '1g' # should work for 5-7 cameras
-    image: frigate:latest
+    image: blakeblackshear/frigate:stable
     volumes:
       - /dev/bus/usb:/dev/bus/usb
       - /etc/localtime:/etc/localtime:ro
@@ -127,6 +117,11 @@ sensor:
         value_template: '{{ states.sensor.frigate_debug.attributes["coral"]["inference_speed"] }}' 
         unit_of_measurement: 'ms'
 ```
+## Using a custom model
+Models for both CPU and EdgeTPU (Coral) are bundled in the image. You can use your own models with volume mounts:
+- CPU Model: `/cpu_model.tflite`
+- EdgeTPU Model: `/edgetpu_model.tflite`
+- Labels: `/labelmap.txt`
 
 ## Tips
 - Lower the framerate of the video feed on the camera to reduce the CPU usage for capturing the feed

benchmark.py

@@ -1,18 +1,79 @@
-import statistics
+import os
+from statistics import mean
+import multiprocessing as mp
 import numpy as np
-import time
+import datetime
-from frigate.edgetpu import ObjectDetector
+from frigate.edgetpu import ObjectDetector, EdgeTPUProcess, RemoteObjectDetector, load_labels
 
-object_detector = ObjectDetector()
+my_frame = np.expand_dims(np.full((300,300,3), 1, np.uint8), axis=0)
+labels = load_labels('/labelmap.txt')
 
-frame = np.zeros((300,300,3), np.uint8)
+######
-input_frame = np.expand_dims(frame, axis=0)
+# Minimal same process runner
+######
+# object_detector = ObjectDetector()
+# tensor_input = np.expand_dims(np.full((300,300,3), 0, np.uint8), axis=0)
 
-detection_times = []
+# start = datetime.datetime.now().timestamp()
 
-for x in range(0, 100):
+# frame_times = []
-    start = time.monotonic()
+# for x in range(0, 1000):
-    object_detector.detect_raw(input_frame)
+#   start_frame = datetime.datetime.now().timestamp()
-    detection_times.append(time.monotonic()-start)
 
-print(f"Average inference time: {statistics.mean(detection_times)*1000:.2f}ms")
+#   tensor_input[:] = my_frame
+#   detections = object_detector.detect_raw(tensor_input)
+#   parsed_detections = []
+#   for d in detections:
+#       if d[1] < 0.4:
+#           break
+#       parsed_detections.append((
+#           labels[int(d[0])],
+#           float(d[1]),
+#           (d[2], d[3], d[4], d[5])
+#       ))
+#   frame_times.append(datetime.datetime.now().timestamp()-start_frame)
+
+# duration = datetime.datetime.now().timestamp()-start
+# print(f"Processed for {duration:.2f} seconds.")
+# print(f"Average frame processing time: {mean(frame_times)*1000:.2f}ms")
+
+######
+# Separate process runner
+######
+def start(id, num_detections, detection_queue):
+  object_detector = RemoteObjectDetector(str(id), '/labelmap.txt', detection_queue)
+  start = datetime.datetime.now().timestamp()
+
+  frame_times = []
+  for x in range(0, num_detections):
+    start_frame = datetime.datetime.now().timestamp()
+    detections = object_detector.detect(my_frame)
+    frame_times.append(datetime.datetime.now().timestamp()-start_frame)
+
+  duration = datetime.datetime.now().timestamp()-start
+  print(f"{id} - Processed for {duration:.2f} seconds.")
+  print(f"{id} - Average frame processing time: {mean(frame_times)*1000:.2f}ms")
+
+edgetpu_process = EdgeTPUProcess()
+
+# start(1, 1000, edgetpu_process.detect_lock, edgetpu_process.detect_ready, edgetpu_process.frame_ready)
+
+####
+# Multiple camera processes
+####
+camera_processes = []
+for x in range(0, 10):
+  camera_process = mp.Process(target=start, args=(x, 100, edgetpu_process.detection_queue))
+  camera_process.daemon = True
+  camera_processes.append(camera_process)
+
+start = datetime.datetime.now().timestamp()
+
+for p in camera_processes:
+  p.start()
+
+for p in camera_processes:
+  p.join()
+
+duration = datetime.datetime.now().timestamp()-start
+print(f"Total - Processed for {duration:.2f} seconds.")

config/config.example.yml

@@ -3,9 +3,13 @@ web_port: 5000
 mqtt:
   host: mqtt.server.com
   topic_prefix: frigate
-#  client_id: frigate # Optional -- set to override default client id of 'frigate' if running multiple instances
+  # client_id: frigate # Optional -- set to override default client id of 'frigate' if running multiple instances
-#  user: username # Optional -- Uncomment for use
+  # user: username # Optional
-#  password: password # Optional -- Uncomment for use
+  #################
+  ## Environment variables that begin with 'FRIGATE_' may be referenced in {}.
+  ##   password: '{FRIGATE_MQTT_PASSWORD}'
+  #################
+  # password: password # Optional
 
 #################
 # Default ffmpeg args. Optional and can be overwritten per camera.

detect_objects.py

@@ -1,3 +1,4 @@
+import os
 import cv2
 import time
 import datetime
@@ -8,7 +9,7 @@ import multiprocessing as mp
 import subprocess as sp
 import numpy as np
 import logging
-from flask import Flask, Response, make_response, jsonify
+from flask import Flask, Response, make_response, jsonify, request
 import paho.mqtt.client as mqtt
 
 from frigate.video import track_camera
@@ -16,6 +17,8 @@ from frigate.object_processing import TrackedObjectProcessor
 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)
 
@@ -24,6 +27,8 @@ 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
@@ -68,27 +73,21 @@ class CameraWatchdog(threading.Thread):
             # wait a bit before checking
             time.sleep(30)
 
+            if (self.tflite_process.detection_start.value > 0.0 and 
+                datetime.datetime.now().timestamp() - self.tflite_process.detection_start.value > 10):
+                print("Detection appears to be stuck. Restarting detection process")
+                self.tflite_process.start_or_restart()
+                time.sleep(30)
+
             for name, camera_process in self.camera_processes.items():
                 process = camera_process['process']
-                if (not self.object_processor.get_current_frame_time(name) is None and 
-                    (datetime.datetime.now().timestamp() - self.object_processor.get_current_frame_time(name)) > 30):
-                    print(f"Last frame for {name} is more than 30 seconds old...")
-                    if process.is_alive():
-                        process.terminate()
-                        print("Waiting for process to exit gracefully...")
-                        process.join(timeout=30)
-                        if process.exitcode is None:
-                            print("Process didnt exit. Force killing...")
-                            process.kill()
-                            process.join()
                 if not process.is_alive():
                     print(f"Process for {name} is not alive. Starting again...")
                     camera_process['fps'].value = float(self.config[name]['fps'])
                     camera_process['skipped_fps'].value = 0.0
                     camera_process['detection_fps'].value = 0.0
-                    self.object_processor.camera_data[name]['current_frame_time'] = None
                     process = mp.Process(target=track_camera, args=(name, self.config[name], FFMPEG_DEFAULT_CONFIG, GLOBAL_OBJECT_CONFIG, 
-                        self.tflite_process.detect_lock, self.tflite_process.detect_ready, self.tflite_process.frame_ready, self.tracked_objects_queue, 
+                        self.tflite_process.detection_queue, self.tracked_objects_queue, 
                         camera_process['fps'], camera_process['skipped_fps'], camera_process['detection_fps']))
                     process.daemon = True
                     camera_process['process'] = process
@@ -150,7 +149,7 @@ def main():
             'detection_fps': mp.Value('d', 0.0)
         }
         camera_process = mp.Process(target=track_camera, args=(name, config, FFMPEG_DEFAULT_CONFIG, GLOBAL_OBJECT_CONFIG, 
-            tflite_process.detect_lock, tflite_process.detect_ready, tflite_process.frame_ready, tracked_objects_queue, 
+            tflite_process.detection_queue, tracked_objects_queue, 
             camera_processes[name]['fps'], camera_processes[name]['skipped_fps'], camera_processes[name]['detection_fps']))
         camera_process.daemon = True
         camera_processes[name]['process'] = camera_process
@@ -184,14 +183,16 @@ def main():
         for name, camera_stats in camera_processes.items():
             total_detection_fps += camera_stats['detection_fps'].value
             stats[name] = {
-                'fps': camera_stats['fps'].value,
+                'fps': round(camera_stats['fps'].value, 2),
-                'skipped_fps': camera_stats['skipped_fps'].value,
+                'skipped_fps': round(camera_stats['skipped_fps'].value, 2),
-                'detection_fps': camera_stats['detection_fps'].value
+                'detection_fps': round(camera_stats['detection_fps'].value, 2)
             }
         
         stats['coral'] = {
-            'fps': total_detection_fps,
+            'fps': round(total_detection_fps, 2),
-            'inference_speed': round(tflite_process.avg_inference_speed.value*1000, 2)
+            'inference_speed': round(tflite_process.avg_inference_speed.value*1000, 2),
+            'detection_queue': tflite_process.detection_queue.qsize(),
+            'detection_start': tflite_process.detection_start.value
         }
 
         rc = plasma_process.poll()
@@ -217,21 +218,26 @@ def main():
 
     @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),
+            return Response(imagestream(camera_name, fps, height),
                             mimetype='multipart/x-mixed-replace; boundary=frame')
         else:
             return "Camera named {} not found".format(camera_name), 404
 
-    def imagestream(camera_name):
+    def imagestream(camera_name, fps, height):
         while True:
-            # max out at 1 FPS
+            # max out at specified FPS
-            time.sleep(1)
+            time.sleep(1/fps)
             frame = object_processor.get_current_frame(camera_name)
             if frame is None:
-                frame = np.zeros((720,1280,3), np.uint8)
+                frame = np.zeros((height,int(height*16/9),3), np.uint8)
+
+            frame = cv2.resize(frame, dsize=(int(height*16/9), height), interpolation=cv2.INTER_LINEAR)
             frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+
             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/edgetpu.py

@@ -1,8 +1,10 @@
 import os
 import datetime
+import hashlib
 import multiprocessing as mp
 import numpy as np
 import SharedArray as sa
+import pyarrow.plasma as plasma
 import tflite_runtime.interpreter as tflite
 from tflite_runtime.interpreter import load_delegate
 from frigate.util import EventsPerSecond
@@ -60,77 +62,81 @@ class ObjectDetector():
         
         return detections
 
+def run_detector(detection_queue, avg_speed, start):
+    print(f"Starting detection process: {os.getpid()}")
+    plasma_client = plasma.connect("/tmp/plasma")
+    object_detector = ObjectDetector()
+
+    while True:
+        object_id_str = detection_queue.get()
+        object_id_hash = hashlib.sha1(str.encode(object_id_str))
+        object_id = plasma.ObjectID(object_id_hash.digest())
+        object_id_out = plasma.ObjectID(hashlib.sha1(str.encode(f"out-{object_id_str}")).digest())
+        input_frame = plasma_client.get(object_id, timeout_ms=0)
+
+        if input_frame is plasma.ObjectNotAvailable:
+            continue
+
+        # detect and put the output in the plasma store
+        start.value = datetime.datetime.now().timestamp()
+        plasma_client.put(object_detector.detect_raw(input_frame), object_id_out)
+        duration = datetime.datetime.now().timestamp()-start.value
+        start.value = 0.0
+
+        avg_speed.value = (avg_speed.value*9 + duration)/10
+        
 class EdgeTPUProcess():
     def __init__(self):
-        # TODO: see if we can use the plasma store with a queue and maintain the same speeds
+        self.detection_queue = mp.Queue()
-        try:
-            sa.delete("frame")
-        except:
-            pass
-        try:
-            sa.delete("detections")
-        except:
-            pass
-
-        self.input_frame = sa.create("frame", shape=(1,300,300,3), dtype=np.uint8)
-        self.detections = sa.create("detections", shape=(20,6), dtype=np.float32)
-
-        self.detect_lock = mp.Lock()
-        self.detect_ready = mp.Event()
-        self.frame_ready = mp.Event()
         self.avg_inference_speed = mp.Value('d', 0.01)
+        self.detection_start = mp.Value('d', 0.0)
+        self.detect_process = None
+        self.start_or_restart()
 
-        def run_detector(detect_ready, frame_ready, avg_speed):
+    def start_or_restart(self):
-            print(f"Starting detection process: {os.getpid()}")
+        self.detection_start.value = 0.0
-            object_detector = ObjectDetector()
+        if (not self.detect_process is None) and self.detect_process.is_alive():
-            input_frame = sa.attach("frame")
+            self.detect_process.terminate()
-            detections = sa.attach("detections")
+            print("Waiting for detection process to exit gracefully...")
-
+            self.detect_process.join(timeout=30)
-            while True:
+            if self.detect_process.exitcode is None:
-                # wait until a frame is ready
+                print("Detection process didnt exit. Force killing...")
-                frame_ready.wait()
+                self.detect_process.kill()
-                start = datetime.datetime.now().timestamp()
+                self.detect_process.join()
-                # signal that the process is busy
+        self.detect_process = mp.Process(target=run_detector, args=(self.detection_queue, self.avg_inference_speed, self.detection_start))
-                frame_ready.clear()
-                detections[:] = object_detector.detect_raw(input_frame)
-                # signal that the process is ready to detect
-                detect_ready.set()
-                duration = datetime.datetime.now().timestamp()-start
-                avg_speed.value = (avg_speed.value*9 + duration)/10
-
-        self.detect_process = mp.Process(target=run_detector, args=(self.detect_ready, self.frame_ready, self.avg_inference_speed))
         self.detect_process.daemon = True
         self.detect_process.start()
 
 class RemoteObjectDetector():
-    def __init__(self, labels, detect_lock, detect_ready, frame_ready):
+    def __init__(self, name, labels, detection_queue):
         self.labels = load_labels(labels)
-
+        self.name = name
-        self.input_frame = sa.attach("frame")
-        self.detections = sa.attach("detections")
-
         self.fps = EventsPerSecond()
-
+        self.plasma_client = plasma.connect("/tmp/plasma")
-        self.detect_lock = detect_lock
+        self.detection_queue = detection_queue
-        self.detect_ready = detect_ready
-        self.frame_ready = frame_ready
     
     def detect(self, tensor_input, threshold=.4):
         detections = []
-        with self.detect_lock:
+
-            self.input_frame[:] = tensor_input
+        now = f"{self.name}-{str(datetime.datetime.now().timestamp())}"
-            # unset detections and signal that a frame is ready
+        object_id_frame = plasma.ObjectID(hashlib.sha1(str.encode(now)).digest())
-            self.detect_ready.clear()
+        object_id_detections = plasma.ObjectID(hashlib.sha1(str.encode(f"out-{now}")).digest())
-            self.frame_ready.set()
+        self.plasma_client.put(tensor_input, object_id_frame)
-            # wait until the detection process is finished,
+        self.detection_queue.put(now)
-            self.detect_ready.wait()
+        raw_detections = self.plasma_client.get(object_id_detections, timeout_ms=10000)
-            for d in self.detections:
+
-                if d[1] < threshold:
+        if raw_detections is plasma.ObjectNotAvailable:
-                    break
+            self.plasma_client.delete([object_id_frame])
-                detections.append((
+            return detections
-                    self.labels[int(d[0])],
+
-                    float(d[1]),
+        for d in raw_detections:
-                    (d[2], d[3], d[4], d[5])
+            if d[1] < threshold:
-                ))
+                break
+            detections.append((
+                self.labels[int(d[0])],
+                float(d[1]),
+                (d[2], d[3], d[4], d[5])
+            ))
+        self.plasma_client.delete([object_id_frame, object_id_detections])
         self.fps.update()
         return detections

frigate/object_processing.py

@@ -34,7 +34,6 @@ class TrackedObjectProcessor(threading.Thread):
             'best_objects': {},
             'object_status': defaultdict(lambda: defaultdict(lambda: 'OFF')),
             'tracked_objects': {},
-            'current_frame_time': None,
             'current_frame': np.zeros((720,1280,3), np.uint8),
             'object_id': None
         })
@@ -48,9 +47,6 @@ class TrackedObjectProcessor(threading.Thread):
     def get_current_frame(self, camera):
         return self.camera_data[camera]['current_frame']
 
-    def get_current_frame_time(self, camera):
-        return self.camera_data[camera]['current_frame_time']
-
     def run(self):
         while True:
             camera, frame_time, tracked_objects = self.tracked_objects_queue.get()
@@ -93,7 +89,6 @@ class TrackedObjectProcessor(threading.Thread):
                 # Set the current frame as ready
                 ###
                 self.camera_data[camera]['current_frame'] = current_frame
-                self.camera_data[camera]['current_frame_time'] = frame_time
 
                 # store the object id, so you can delete it at the next loop
                 previous_object_id = self.camera_data[camera]['object_id']

frigate/video.py

@@ -98,7 +98,23 @@ def create_tensor_input(frame, region):
     # Expand dimensions since the model expects images to have shape: [1, 300, 300, 3]
     return np.expand_dims(cropped_frame, axis=0)
 
-def track_camera(name, config, ffmpeg_global_config, global_objects_config, detect_lock, detect_ready, frame_ready, detected_objects_queue, fps, skipped_fps, detection_fps):
+def start_or_restart_ffmpeg(ffmpeg_cmd, frame_size, ffmpeg_process=None):
+    if not ffmpeg_process is None:
+        print("Terminating the existing ffmpeg process...")
+        ffmpeg_process.terminate()
+        try:
+            print("Waiting for ffmpeg to exit gracefully...")
+            ffmpeg_process.wait(timeout=30)
+        except sp.TimeoutExpired:
+            print("FFmpeg didnt exit. Force killing...")
+            ffmpeg_process.kill()
+            ffmpeg_process.wait()
+
+    print("Creating ffmpeg process...")
+    print(" ".join(ffmpeg_cmd))
+    return sp.Popen(ffmpeg_cmd, stdout = sp.PIPE, bufsize=frame_size*10)
+
+def track_camera(name, config, ffmpeg_global_config, global_objects_config, detection_queue, detected_objects_queue, fps, skipped_fps, detection_fps):
     print(f"Starting process for {name}: {os.getpid()}")
 
     # Merge the ffmpeg config with the global config
@@ -108,6 +124,13 @@ def track_camera(name, config, ffmpeg_global_config, global_objects_config, dete
     ffmpeg_hwaccel_args = ffmpeg.get('hwaccel_args', ffmpeg_global_config['hwaccel_args'])
     ffmpeg_input_args = ffmpeg.get('input_args', ffmpeg_global_config['input_args'])
     ffmpeg_output_args = ffmpeg.get('output_args', ffmpeg_global_config['output_args'])
+    ffmpeg_cmd = (['ffmpeg'] +
+            ffmpeg_global_args +
+            ffmpeg_hwaccel_args +
+            ffmpeg_input_args +
+            ['-i', ffmpeg_input] +
+            ffmpeg_output_args +
+            ['pipe:'])
 
     # Merge the tracked object config with the global config
     camera_objects_config = config.get('objects', {})    
@@ -149,21 +172,11 @@ def track_camera(name, config, ffmpeg_global_config, global_objects_config, dete
         mask[:] = 255
 
     motion_detector = MotionDetector(frame_shape, mask, resize_factor=6)
-    object_detector = RemoteObjectDetector('/labelmap.txt', detect_lock, detect_ready, frame_ready)
+    object_detector = RemoteObjectDetector(name, '/labelmap.txt', detection_queue)
 
     object_tracker = ObjectTracker(10)
     
-    ffmpeg_cmd = (['ffmpeg'] +
+    ffmpeg_process = start_or_restart_ffmpeg(ffmpeg_cmd, frame_size)
-            ffmpeg_global_args +
-            ffmpeg_hwaccel_args +
-            ffmpeg_input_args +
-            ['-i', ffmpeg_input] +
-            ffmpeg_output_args +
-            ['pipe:'])
-
-    print(" ".join(ffmpeg_cmd))
-    
-    ffmpeg_process = sp.Popen(ffmpeg_cmd, stdout = sp.PIPE, bufsize=frame_size)
     
     plasma_client = plasma.connect("/tmp/plasma")
     frame_num = 0
@@ -180,7 +193,14 @@ def track_camera(name, config, ffmpeg_global_config, global_objects_config, dete
         avg_wait = (avg_wait*99+duration)/100
 
         if not frame_bytes:
-            break
+            rc = ffmpeg_process.poll()
+            if rc is not None:
+                print(f"{name}: ffmpeg_process exited unexpectedly with {rc}")
+                ffmpeg_process = start_or_restart_ffmpeg(ffmpeg_cmd, frame_size, ffmpeg_process)
+                time.sleep(10)
+            else:
+                print(f"{name}: ffmpeg_process is still running but didnt return any bytes")
+            continue
 
         # limit frame rate
         frame_num += 1
@@ -353,3 +373,5 @@ def track_camera(name, config, ffmpeg_global_config, global_objects_config, dete
         plasma_client.put(frame, plasma.ObjectID(object_id))
         # add to the queue
         detected_objects_queue.put((name, frame_time, object_tracker.tracked_objects))
+
+    print(f"{name}: exiting subprocess")