allow mqtt password to be set by env var

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.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 \
+    && 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 \
     && rm -rf /var/lib/apt/lists/* \
     && (apt-get autoremove -y; apt-get autoclean -y)
 

README.md

@@ -16,6 +16,16 @@ 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 \
@@ -26,7 +36,7 @@ docker run --rm \
 -v /etc/localtime:/etc/localtime:ro \
 -p 5000:5000 \
 -e FRIGATE_RTSP_PASSWORD='password' \
-blakeblackshear/frigate:stable
+frigate:latest
 ```
 
 Example docker-compose:
@@ -36,7 +46,7 @@ Example docker-compose:
     restart: unless-stopped
     privileged: true
     shm_size: '1g' # should work for 5-7 cameras
-    image: blakeblackshear/frigate:stable
+    image: frigate:latest
     volumes:
       - /dev/bus/usb:/dev/bus/usb
       - /etc/localtime:/etc/localtime:ro
@@ -117,11 +127,6 @@ 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,13 +3,9 @@ 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
-  #################
-  ## Environment variables that begin with 'FRIGATE_' may be referenced in {}.
-  ##   password: '{FRIGATE_MQTT_PASSWORD}'
-  #################
-  # password: password # Optional
+#  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
 
 #################
 # 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, request
+from flask import Flask, Response, make_response, jsonify
 import paho.mqtt.client as mqtt
 
 from frigate.video import track_camera
@@ -76,7 +76,6 @@ 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():
@@ -218,26 +217,21 @@ 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, fps, height),
+            return Response(imagestream(camera_name),
                             mimetype='multipart/x-mixed-replace; boundary=frame')
         else:
             return "Camera named {} not found".format(camera_name), 404
 
-    def imagestream(camera_name, fps, height):
+    def imagestream(camera_name):
         while True:
-            # max out at specified FPS
-            time.sleep(1/fps)
+            # max out at 1 FPS
+            time.sleep(1)
             frame = object_processor.get_current_frame(camera_name)
             if frame is None:
-                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 = np.zeros((720,1280,3), np.uint8)
             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,18 +71,16 @@ 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)
 
-        if input_frame is plasma.ObjectNotAvailable:
-            continue
+        start.value = datetime.datetime.now().timestamp()
 
         # 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)
+        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))
+
         duration = datetime.datetime.now().timestamp()-start.value
         start.value = 0.0
-
         avg_speed.value = (avg_speed.value*9 + duration)/10
         
 class EdgeTPUProcess():
@@ -123,11 +121,7 @@ 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, timeout_ms=10000)
-
-        if raw_detections is plasma.ObjectNotAvailable:
-            self.plasma_client.delete([object_id_frame])
-            return detections
+        raw_detections = self.plasma_client.get(object_id_detections)
 
         for d in raw_detections:
             if d[1] < threshold: