Merge remote-tracking branch 'origin/master' into dev

frigate/api/classification.py

@@ -218,7 +218,7 @@ async def register_face(request: Request, name: str, file: UploadFile):
         )
 
     context: EmbeddingsContext = request.app.embeddings
-    result = context.register_face(name, await file.read())
+    result = None if context is None else context.register_face(name, await file.read())
 
     if not isinstance(result, dict):
         return JSONResponse(

frigate/api/defs/query/events_query_parameters.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 DEFAULT_TIME_RANGE = "00:00,24:00"
 
@@ -21,7 +21,14 @@ class EventsQueryParams(BaseModel):
     has_clip: Optional[int] = None
     has_snapshot: Optional[int] = None
     in_progress: Optional[int] = None
-    include_thumbnails: Optional[int] = 1
+    include_thumbnails: Optional[int] = Field(
+        1,
+        description=(
+            "Deprecated. Thumbnail data is no longer included in the response. "
+            "Use the /api/events/:event_id/thumbnail.:extension endpoint instead."
+        ),
+        deprecated=True,
+    )
     favorites: Optional[int] = None
     min_score: Optional[float] = None
     max_score: Optional[float] = None
@@ -40,7 +47,14 @@ class EventsSearchQueryParams(BaseModel):
     query: Optional[str] = None
     event_id: Optional[str] = None
     search_type: Optional[str] = "thumbnail"
-    include_thumbnails: Optional[int] = 1
+    include_thumbnails: Optional[int] = Field(
+        1,
+        description=(
+            "Deprecated. Thumbnail data is no longer included in the response. "
+            "Use the /api/events/:event_id/thumbnail.:extension endpoint instead."
+        ),
+        deprecated=True,
+    )
     limit: Optional[int] = 50
     cameras: Optional[str] = "all"
     labels: Optional[str] = "all"

frigate/api/defs/query/media_query_parameters.py

@@ -11,6 +11,11 @@ class Extension(str, Enum):
     jpg = "jpg"
     jpeg = "jpeg"
 
+    def get_mime_type(self) -> str:
+        if self in (Extension.jpg, Extension.jpeg):
+            return "image/jpeg"
+        return f"image/{self.value}"
+
 
 class MediaLatestFrameQueryParams(BaseModel):
     bbox: Optional[int] = None

frigate/api/media.py

@@ -145,15 +145,13 @@ def latest_frame(
         "regions": params.regions,
     }
     quality = params.quality
-    mime_type = extension
 
-    if extension == "png":
+    if extension == Extension.png:
         quality_params = None
-    elif extension == "webp":
+    elif extension == Extension.webp:
         quality_params = [int(cv2.IMWRITE_WEBP_QUALITY), quality]
-    else:
+    else:  # jpg or jpeg
         quality_params = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
-        mime_type = "jpeg"
 
     if camera_name in request.app.frigate_config.cameras:
         frame = frame_processor.get_current_frame(camera_name, draw_options)
@@ -196,18 +194,21 @@ def latest_frame(
 
         frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
 
-        _, img = cv2.imencode(f".{extension}", frame, quality_params)
+        _, img = cv2.imencode(f".{extension.value}", frame, quality_params)
         return Response(
             content=img.tobytes(),
-            media_type=f"image/{mime_type}",
+            media_type=extension.get_mime_type(),
             headers={
-                "Content-Type": f"image/{mime_type}",
                 "Cache-Control": "no-store"
                 if not params.store
                 else "private, max-age=60",
             },
         )
-    elif camera_name == "birdseye" and request.app.frigate_config.birdseye.restream:
+    elif (
+        camera_name == "birdseye"
+        and request.app.frigate_config.birdseye.enabled
+        and request.app.frigate_config.birdseye.restream
+    ):
         frame = cv2.cvtColor(
             frame_processor.get_current_frame(camera_name),
             cv2.COLOR_YUV2BGR_I420,
@@ -218,12 +219,11 @@ def latest_frame(
 
         frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
 
-        _, img = cv2.imencode(f".{extension}", frame, quality_params)
+        _, img = cv2.imencode(f".{extension.value}", frame, quality_params)
         return Response(
             content=img.tobytes(),
-            media_type=f"image/{mime_type}",
+            media_type=extension.get_mime_type(),
             headers={
-                "Content-Type": f"image/{mime_type}",
                 "Cache-Control": "no-store"
                 if not params.store
                 else "private, max-age=60",
@@ -812,7 +812,10 @@ def vod_hour(year_month: str, day: int, hour: int, camera_name: str, tz_name: st
     "/vod/event/{event_id}",
     description="Returns an HLS playlist for the specified object. Append /master.m3u8 or /index.m3u8 for HLS playback.",
 )
-def vod_event(event_id: str):
+def vod_event(
+    event_id: str,
+    padding: int = Query(0, description="Padding to apply to the vod."),
+):
     try:
         event: Event = Event.get(Event.id == event_id)
     except DoesNotExist:
@@ -835,32 +838,23 @@ def vod_event(event_id: str):
             status_code=404,
         )
 
-    clip_path = os.path.join(CLIPS_DIR, f"{event.camera}-{event.id}.mp4")
-
-    if not os.path.isfile(clip_path):
-        end_ts = (
-            datetime.now().timestamp() if event.end_time is None else event.end_time
-        )
-        vod_response = vod_ts(event.camera, event.start_time, end_ts)
-        # If the recordings are not found and the event started more than 5 minutes ago, set has_clip to false
-        if (
-            event.start_time < datetime.now().timestamp() - 300
-            and type(vod_response) is tuple
-            and len(vod_response) == 2
-            and vod_response[1] == 404
-        ):
-            Event.update(has_clip=False).where(Event.id == event_id).execute()
-        return vod_response
-
-    duration = int((event.end_time - event.start_time) * 1000)
-    return JSONResponse(
-        content={
-            "cache": True,
-            "discontinuity": False,
-            "durations": [duration],
-            "sequences": [{"clips": [{"type": "source", "path": clip_path}]}],
-        }
+    end_ts = (
+        datetime.now().timestamp()
+        if event.end_time is None
+        else (event.end_time + padding)
     )
+    vod_response = vod_ts(event.camera, event.start_time - padding, end_ts)
+
+    # If the recordings are not found and the event started more than 5 minutes ago, set has_clip to false
+    if (
+        event.start_time < datetime.now().timestamp() - 300
+        and type(vod_response) is tuple
+        and len(vod_response) == 2
+        and vod_response[1] == 404
+    ):
+        Event.update(has_clip=False).where(Event.id == event_id).execute()
+
+    return vod_response
 
 
 @router.get(
@@ -941,7 +935,7 @@ def event_snapshot(
 def event_thumbnail(
     request: Request,
     event_id: str,
-    extension: str,
+    extension: Extension,
     max_cache_age: int = Query(
         2592000, description="Max cache age in seconds. Default 30 days in seconds."
     ),
@@ -966,7 +960,7 @@ def event_thumbnail(
                 if event_id in camera_state.tracked_objects:
                     tracked_obj = camera_state.tracked_objects.get(event_id)
                     if tracked_obj is not None:
-                        thumbnail_bytes = tracked_obj.get_thumbnail(extension)
+                        thumbnail_bytes = tracked_obj.get_thumbnail(extension.value)
         except Exception:
             return JSONResponse(
                 content={"success": False, "message": "Event not found"},
@@ -994,23 +988,21 @@ def event_thumbnail(
         )
 
         quality_params = None
-
-        if extension == "jpg" or extension == "jpeg":
+        if extension in (Extension.jpg, Extension.jpeg):
             quality_params = [int(cv2.IMWRITE_JPEG_QUALITY), 70]
-        elif extension == "webp":
+        elif extension == Extension.webp:
             quality_params = [int(cv2.IMWRITE_WEBP_QUALITY), 60]
 
-        _, img = cv2.imencode(f".{extension}", thumbnail, quality_params)
+        _, img = cv2.imencode(f".{extension.value}", thumbnail, quality_params)
         thumbnail_bytes = img.tobytes()
 
     return Response(
         thumbnail_bytes,
-        media_type=f"image/{extension}",
+        media_type=extension.get_mime_type(),
         headers={
             "Cache-Control": f"private, max-age={max_cache_age}"
             if event_complete
             else "no-store",
-            "Content-Type": f"image/{extension}",
         },
     )
 
@@ -1221,7 +1213,11 @@ def event_snapshot_clean(request: Request, event_id: str, download: bool = False
 
 
 @router.get("/events/{event_id}/clip.mp4")
-def event_clip(request: Request, event_id: str):
+def event_clip(
+    request: Request,
+    event_id: str,
+    padding: int = Query(0, description="Padding to apply to clip."),
+):
     try:
         event: Event = Event.get(Event.id == event_id)
     except DoesNotExist:
@@ -1234,8 +1230,12 @@ def event_clip(request: Request, event_id: str):
             content={"success": False, "message": "Clip not available"}, status_code=404
         )
 
-    end_ts = datetime.now().timestamp() if event.end_time is None else event.end_time
-    return recording_clip(request, event.camera, event.start_time, end_ts)
+    end_ts = (
+        datetime.now().timestamp()
+        if event.end_time is None
+        else event.end_time + padding
+    )
+    return recording_clip(request, event.camera, event.start_time - padding, end_ts)
 
 
 @router.get("/events/{event_id}/preview.gif")

frigate/config/camera/ffmpeg.py

@@ -61,6 +61,7 @@ class FfmpegConfig(FrigateBaseModel):
     retry_interval: float = Field(
         default=10.0,
         title="Time in seconds to wait before FFmpeg retries connecting to the camera.",
+        gt=0.0,
     )
     apple_compatibility: bool = Field(
         default=False,

frigate/detectors/detector_config.py

@@ -158,6 +158,9 @@ class ModelConfig(BaseModel):
         self.input_pixel_format = model_info["pixelFormat"]
         self.model_type = model_info["type"]
 
+        if model_info.get("inputDataType"):
+            self.input_dtype = model_info["inputDataType"]
+
         # generate list of attribute labels
         self.attributes_map = {
             **model_info.get("attributes", DEFAULT_ATTRIBUTE_LABEL_MAP),

frigate/genai/__init__.py

@@ -182,10 +182,15 @@ Rules:
         event: Event,
     ) -> Optional[str]:
         """Generate a description for the frame."""
-        prompt = camera_config.objects.genai.object_prompts.get(
-            event.label,
-            camera_config.objects.genai.prompt,
-        ).format(**model_to_dict(event))
+        try:
+            prompt = camera_config.genai.object_prompts.get(
+                event.label,
+                camera_config.genai.prompt,
+            ).format(**model_to_dict(event))
+        except KeyError as e:
+            logger.error(f"Invalid key in GenAI prompt: {e}")
+            return None
+
         logger.debug(f"Sending images to genai provider with prompt: {prompt}")
         return self._send(prompt, thumbnails)
 

frigate/ptz/autotrack.py

@@ -372,12 +372,13 @@ class PtzAutoTracker:
         logger.info(f"Camera calibration for {camera} in progress")
 
         # zoom levels test
+        self.zoom_time[camera] = 0
+
         if (
             self.config.cameras[camera].onvif.autotracking.zooming
             != ZoomingModeEnum.disabled
         ):
             logger.info(f"Calibration for {camera} in progress: 0% complete")
-            self.zoom_time[camera] = 0
 
             for i in range(2):
                 # absolute move to 0 - fully zoomed out
@@ -1332,7 +1333,11 @@ class PtzAutoTracker:
 
         if camera_config.onvif.autotracking.enabled:
             if not self.autotracker_init[camera]:
-                self._autotracker_setup(camera_config, camera)
+                future = asyncio.run_coroutine_threadsafe(
+                    self._autotracker_setup(camera_config, camera), self.onvif.loop
+                )
+                # Wait for the coroutine to complete
+                future.result()
 
             if self.calibrating[camera]:
                 logger.debug(f"{camera}: Calibrating camera")
@@ -1479,7 +1484,8 @@ class PtzAutoTracker:
             self.tracked_object[camera] = None
             self.tracked_object_history[camera].clear()
 
-            self.ptz_metrics[camera].motor_stopped.wait()
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
+                await self.onvif.get_camera_status(camera)
             logger.debug(
                 f"{camera}: Time is {self.ptz_metrics[camera].frame_time.value}, returning to preset: {autotracker_config.return_preset}"
             )
@@ -1489,7 +1495,7 @@ class PtzAutoTracker:
             )
 
             # update stored zoom level from preset
-            if not self.ptz_metrics[camera].motor_stopped.is_set():
+            while not self.ptz_metrics[camera].motor_stopped.is_set():
                 await self.onvif.get_camera_status(camera)
 
             self.ptz_metrics[camera].tracking_active.clear()

frigate/ptz/onvif.py

@@ -50,6 +50,8 @@ class OnvifController:
         self.config = config
         self.ptz_metrics = ptz_metrics
 
+        self.status_locks: dict[str, asyncio.Lock] = {}
+
         # Create a dedicated event loop and run it in a separate thread
         self.loop = asyncio.new_event_loop()
         self.loop_thread = threading.Thread(target=self._run_event_loop, daemon=True)
@@ -61,6 +63,7 @@ class OnvifController:
                 continue
             if cam.onvif.host:
                 self.camera_configs[cam_name] = cam
+                self.status_locks[cam_name] = asyncio.Lock()
 
         asyncio.run_coroutine_threadsafe(self._init_cameras(), self.loop)
 
@@ -827,105 +830,110 @@ class OnvifController:
             return False
 
     async def get_camera_status(self, camera_name: str) -> None:
-        if camera_name not in self.cams.keys():
-            logger.error(f"ONVIF is not configured for {camera_name}")
-            return
-
-        if not self.cams[camera_name]["init"]:
-            if not await self._init_onvif(camera_name):
+        async with self.status_locks[camera_name]:
+            if camera_name not in self.cams.keys():
+                logger.error(f"ONVIF is not configured for {camera_name}")
                 return
 
-        status_request = self.cams[camera_name]["status_request"]
-        try:
-            status = await self.cams[camera_name]["ptz"].GetStatus(status_request)
-        except Exception:
-            pass  # We're unsupported, that'll be reported in the next check.
+            if not self.cams[camera_name]["init"]:
+                if not await self._init_onvif(camera_name):
+                    return
 
-        try:
-            pan_tilt_status = getattr(status.MoveStatus, "PanTilt", None)
-            zoom_status = getattr(status.MoveStatus, "Zoom", None)
+            status_request = self.cams[camera_name]["status_request"]
+            try:
+                status = await self.cams[camera_name]["ptz"].GetStatus(status_request)
+            except Exception:
+                pass  # We're unsupported, that'll be reported in the next check.
 
-            # if it's not an attribute, see if MoveStatus even exists in the status result
-            if pan_tilt_status is None:
-                pan_tilt_status = getattr(status, "MoveStatus", None)
+            try:
+                pan_tilt_status = getattr(status.MoveStatus, "PanTilt", None)
+                zoom_status = getattr(status.MoveStatus, "Zoom", None)
 
-                # we're unsupported
-                if pan_tilt_status is None or pan_tilt_status not in [
-                    "IDLE",
-                    "MOVING",
-                ]:
-                    raise Exception
-        except Exception:
-            logger.warning(
-                f"Camera {camera_name} does not support the ONVIF GetStatus method. Autotracking will not function correctly and must be disabled in your config."
+                # if it's not an attribute, see if MoveStatus even exists in the status result
+                if pan_tilt_status is None:
+                    pan_tilt_status = getattr(status, "MoveStatus", None)
+
+                    # we're unsupported
+                    if pan_tilt_status is None or pan_tilt_status not in [
+                        "IDLE",
+                        "MOVING",
+                    ]:
+                        raise Exception
+            except Exception:
+                logger.warning(
+                    f"Camera {camera_name} does not support the ONVIF GetStatus method. Autotracking will not function correctly and must be disabled in your config."
+                )
+                return
+
+            logger.debug(
+                f"{camera_name}: Pan/tilt status: {pan_tilt_status}, Zoom status: {zoom_status}"
             )
-            return
 
-        logger.debug(
-            f"{camera_name}: Pan/tilt status: {pan_tilt_status}, Zoom status: {zoom_status}"
-        )
+            if pan_tilt_status == "IDLE" and (
+                zoom_status is None or zoom_status == "IDLE"
+            ):
+                self.cams[camera_name]["active"] = False
+                if not self.ptz_metrics[camera_name].motor_stopped.is_set():
+                    self.ptz_metrics[camera_name].motor_stopped.set()
 
-        if pan_tilt_status == "IDLE" and (zoom_status is None or zoom_status == "IDLE"):
-            self.cams[camera_name]["active"] = False
-            if not self.ptz_metrics[camera_name].motor_stopped.is_set():
-                self.ptz_metrics[camera_name].motor_stopped.set()
+                    logger.debug(
+                        f"{camera_name}: PTZ stop time: {self.ptz_metrics[camera_name].frame_time.value}"
+                    )
 
+                    self.ptz_metrics[camera_name].stop_time.value = self.ptz_metrics[
+                        camera_name
+                    ].frame_time.value
+            else:
+                self.cams[camera_name]["active"] = True
+                if self.ptz_metrics[camera_name].motor_stopped.is_set():
+                    self.ptz_metrics[camera_name].motor_stopped.clear()
+
+                    logger.debug(
+                        f"{camera_name}: PTZ start time: {self.ptz_metrics[camera_name].frame_time.value}"
+                    )
+
+                    self.ptz_metrics[camera_name].start_time.value = self.ptz_metrics[
+                        camera_name
+                    ].frame_time.value
+                    self.ptz_metrics[camera_name].stop_time.value = 0
+
+            if (
+                self.config.cameras[camera_name].onvif.autotracking.zooming
+                != ZoomingModeEnum.disabled
+            ):
+                # store absolute zoom level as 0 to 1 interpolated from the values of the camera
+                self.ptz_metrics[camera_name].zoom_level.value = numpy.interp(
+                    round(status.Position.Zoom.x, 2),
+                    [
+                        self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Min"],
+                        self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Max"],
+                    ],
+                    [0, 1],
+                )
                 logger.debug(
-                    f"{camera_name}: PTZ stop time: {self.ptz_metrics[camera_name].frame_time.value}"
+                    f"{camera_name}: Camera zoom level: {self.ptz_metrics[camera_name].zoom_level.value}"
                 )
 
+            # some hikvision cams won't update MoveStatus, so warn if it hasn't changed
+            if (
+                not self.ptz_metrics[camera_name].motor_stopped.is_set()
+                and not self.ptz_metrics[camera_name].reset.is_set()
+                and self.ptz_metrics[camera_name].start_time.value != 0
+                and self.ptz_metrics[camera_name].frame_time.value
+                > (self.ptz_metrics[camera_name].start_time.value + 10)
+                and self.ptz_metrics[camera_name].stop_time.value == 0
+            ):
+                logger.debug(
+                    f"Start time: {self.ptz_metrics[camera_name].start_time.value}, Stop time: {self.ptz_metrics[camera_name].stop_time.value}, Frame time: {self.ptz_metrics[camera_name].frame_time.value}"
+                )
+                # set the stop time so we don't come back into this again and spam the logs
                 self.ptz_metrics[camera_name].stop_time.value = self.ptz_metrics[
                     camera_name
                 ].frame_time.value
-        else:
-            self.cams[camera_name]["active"] = True
-            if self.ptz_metrics[camera_name].motor_stopped.is_set():
-                self.ptz_metrics[camera_name].motor_stopped.clear()
-
-                logger.debug(
-                    f"{camera_name}: PTZ start time: {self.ptz_metrics[camera_name].frame_time.value}"
+                logger.warning(
+                    f"Camera {camera_name} is still in ONVIF 'MOVING' status."
                 )
 
-                self.ptz_metrics[camera_name].start_time.value = self.ptz_metrics[
-                    camera_name
-                ].frame_time.value
-                self.ptz_metrics[camera_name].stop_time.value = 0
-
-        if (
-            self.config.cameras[camera_name].onvif.autotracking.zooming
-            != ZoomingModeEnum.disabled
-        ):
-            # store absolute zoom level as 0 to 1 interpolated from the values of the camera
-            self.ptz_metrics[camera_name].zoom_level.value = numpy.interp(
-                round(status.Position.Zoom.x, 2),
-                [
-                    self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Min"],
-                    self.cams[camera_name]["absolute_zoom_range"]["XRange"]["Max"],
-                ],
-                [0, 1],
-            )
-            logger.debug(
-                f"{camera_name}: Camera zoom level: {self.ptz_metrics[camera_name].zoom_level.value}"
-            )
-
-        # some hikvision cams won't update MoveStatus, so warn if it hasn't changed
-        if (
-            not self.ptz_metrics[camera_name].motor_stopped.is_set()
-            and not self.ptz_metrics[camera_name].reset.is_set()
-            and self.ptz_metrics[camera_name].start_time.value != 0
-            and self.ptz_metrics[camera_name].frame_time.value
-            > (self.ptz_metrics[camera_name].start_time.value + 10)
-            and self.ptz_metrics[camera_name].stop_time.value == 0
-        ):
-            logger.debug(
-                f"Start time: {self.ptz_metrics[camera_name].start_time.value}, Stop time: {self.ptz_metrics[camera_name].stop_time.value}, Frame time: {self.ptz_metrics[camera_name].frame_time.value}"
-            )
-            # set the stop time so we don't come back into this again and spam the logs
-            self.ptz_metrics[camera_name].stop_time.value = self.ptz_metrics[
-                camera_name
-            ].frame_time.value
-            logger.warning(f"Camera {camera_name} is still in ONVIF 'MOVING' status.")
-
     def close(self) -> None:
         """Gracefully shut down the ONVIF controller."""
         if not hasattr(self, "loop") or self.loop.is_closed():