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 \
-    && python3.7 -m pip install tflite_runtime-2.1.0-cp37-cp37m-linux_x86_64.whl \
-    && rm 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.post1-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

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
-#  user: username # Optional -- Uncomment for use
-#  password: password # Optional -- Uncomment for use
+  # 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
 
 #################
 # Default ffmpeg args. Optional and can be overwritten per camera.

detect_objects.py

@@ -9,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
@@ -76,6 +76,7 @@ class CameraWatchdog(threading.Thread):
             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():
@@ -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
-            time.sleep(1)
+            # max out at specified FPS
+            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

@@ -71,16 +71,18 @@ def run_detector(detection_queue, avg_speed, start):
         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)
 
-        start.value = datetime.datetime.now().timestamp()
+        if input_frame is plasma.ObjectNotAvailable:
+            continue
 
         # detect and put the output in the plasma store
-        object_id_out = hashlib.sha1(str.encode(f"out-{object_id_str}")).digest()
-        plasma_client.put(object_detector.detect_raw(input_frame), plasma.ObjectID(object_id_out))
-
+        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():
@@ -121,7 +123,11 @@ class RemoteObjectDetector():
         object_id_detections = plasma.ObjectID(hashlib.sha1(str.encode(f"out-{now}")).digest())
         self.plasma_client.put(tensor_input, object_id_frame)
         self.detection_queue.put(now)
-        raw_detections = self.plasma_client.get(object_id_detections)
+        raw_detections = self.plasma_client.get(object_id_detections, timeout_ms=10000)
+
+        if raw_detections is plasma.ObjectNotAvailable:
+            self.plasma_client.delete([object_id_frame])
+            return detections
 
         for d in raw_detections:
             if d[1] < threshold: