Refactor birdseye activity modes as a list and add alerts/detections (#24012)

* backend

* tests

* frontend and i18n

* e2e test schema

* docs

docker/main/rootfs/usr/local/nginx/conf/nginx.conf

@@ -75,6 +75,12 @@ http {
         vod_align_segments_to_key_frames on;
         vod_manifest_segment_durations_mode accurate;
         vod_ignore_edit_list on;
+        # short leading segments at each playlist start; sources start at
+        # the seek target, so the ladder applies to every seek. Only
+        # effective when clips declare real keyFrameDurations
+        vod_bootstrap_segment_durations 1000;
+        vod_bootstrap_segment_durations 2000;
+        vod_bootstrap_segment_durations 4000;
         vod_segment_duration 10000;
 
         # MPEG-TS settings (not used when fMP4 is enabled, kept for reference)

docs/docs/configuration/advanced/reference.md

@@ -252,16 +252,14 @@ birdseye:
   # 1 is the highest quality, and 31 is the lowest. Lower quality feeds utilize less CPU resources.
   quality: 8
   # Optional: Activity types that include cameras in Birdseye (default: shown below)
-  # Multiple activity types can be enabled at the same time.
-  mode:
-    # Optional: All cameras are included always (default: shown below)
-    continuous: False
-    # Optional: Cameras are included if motion was detected in the last 30 seconds (default: shown below)
-    motion: False
-    # Optional: Cameras are included if they have had an active tracked object within the last 30 seconds (default: shown below)
-    objects: True
-    # Optional: Cameras are included while they have a stationary tracked object (default: shown below)
-    stationary_objects: False
+  # Multiple activity types can be listed at the same time.
+  #   continuous:  all cameras are included always
+  #   motion:      included if motion was detected within the inactivity threshold
+  #   all_objects: included if a tracked object was present within the inactivity threshold
+  #   alerts:      included while an alert review item is in progress
+  #   detections:  included while a detection review item is in progress
+  modes:
+    - all_objects
   # Optional: Threshold for camera activity to stop showing camera (default: shown below)
   inactivity_threshold: 30
   # Optional: Configure the birdseye layout

docs/docs/configuration/birdseye.md

@@ -20,12 +20,15 @@ Each camera tile in Birdseye is composed from the frames of the stream assigned
 
 ### Birdseye Activity Types
 
-Birdseye offers independent activity types that control when cameras are shown. Multiple activity types can be enabled together.
+Birdseye offers independent activity types that control when cameras are shown. Multiple activity types can be listed together.
 
 - **continuous:** The camera is always included
 - **motion:** The camera is included when motion was detected within the last 30 seconds
-- **objects:** The camera is included when an active object was tracked within the last 30 seconds
-- **stationary_objects:** The camera is included while a stationary object is tracked
+- **all_objects:** The camera is included when a tracked object is present, active or stationary
+- **alerts:** The camera is included while an alert review item is in progress
+- **detections:** The camera is included while a detection review item is in progress
+
+`alerts` and `detections` follow the review item's own lifetime, so the camera is removed as soon as the review item ends. Which objects qualify for each is set in [review configuration](./review.md).
 
 ### Custom Birdseye Icon
 
@@ -50,20 +53,19 @@ To include a camera in Birdseye view only for specific circumstances, or exclude
 </TabItem>
 <TabItem value="yaml">
 
-```yaml {8-11,13-15}
+```yaml {10-12,15-16}
 # Include all cameras by default in Birdseye view
 birdseye:
   enabled: True
-  mode:
-    continuous: True
+  modes:
+    - continuous
 
 cameras:
   front:
-    # Only include the "front" camera in Birdseye view when objects are detected
+    # Only include the "front" camera in Birdseye view when an alert is in progress
     birdseye:
-      mode:
-        continuous: False
-        objects: True
+      modes:
+        - alerts
   back:
     # Exclude the "back" camera from Birdseye view
     birdseye:
@@ -75,7 +77,7 @@ cameras:
 
 ### Birdseye Inactivity
 
-By default birdseye shows all cameras that have had the configured activity in the last 30 seconds. This threshold can be configured.
+By default birdseye shows all cameras that have had the configured activity in the last 30 seconds. This threshold can be configured, and applies to the `motion` and `all_objects` activity types only.
 
 <ConfigTabs>
 <TabItem value="ui">
@@ -144,7 +146,8 @@ Navigate to <NavPath path="Settings > System > Birdseye" /> and in the **Camera
 # Include all cameras by default in Birdseye view
 birdseye:
   enabled: True
-  mode: continuous
+  modes:
+    - continuous
 
 cameras:
   front:

docs/docs/integrations/mqtt.md

@@ -553,23 +553,25 @@ must be enabled in the configuration.
 
 Topic with current state of Birdseye for a camera. Published values are `ON` and `OFF`.
 
-### `frigate/<camera_name>/birdseye_mode/set`
+### `frigate/<camera_name>/birdseye_modes/set`
 
-Topic to set the Birdseye activity types for a camera. Send one uppercase activity type or combine multiple types with commas, for example `MOTION,OBJECTS,STATIONARY_OBJECTS`.
+Topic to set the Birdseye activity types for a camera. Send one uppercase activity type or combine multiple types with commas, for example `MOTION,ALERTS`.
 
 _Note: Changing the value from `CONTINUOUS` to non-continuous activity types will take up to 30 seconds for
 the camera to be removed from the view._
 
-| Command              | Description                                                      |
-| -------------------- | ---------------------------------------------------------------- |
-| `CONTINUOUS`         | Always included                                                  |
-| `MOTION`             | Shown if motion was detected within the last 30 seconds          |
-| `OBJECTS`            | Shown if an active object was tracked within the last 30 seconds |
-| `STATIONARY_OBJECTS` | Shown while a stationary object is tracked                       |
+| Command       | Description                                                      |
+| ------------- | ---------------------------------------------------------------- |
+| `CONTINUOUS`  | Always included                                                  |
+| `MOTION`      | Shown if motion was detected within the last 30 seconds          |
+| `ALL_OBJECTS` | Shown if a tracked object was present within the last 30 seconds |
+| `ALERTS`      | Shown while an alert review item is in progress                  |
+| `DETECTIONS`  | Shown while a detection review item is in progress               |
+| `NONE`        | Never included                                                   |
 
-### `frigate/<camera_name>/birdseye_mode/state`
+### `frigate/<camera_name>/birdseye_modes/state`
 
-Topic with the current Birdseye activity types for a camera. Multiple enabled types are published as a comma-separated value in the order `OBJECTS`, `MOTION`, `STATIONARY_OBJECTS`, `CONTINUOUS`.
+Topic with the current Birdseye activity types for a camera. Multiple enabled types are published as a comma-separated value in the order `CONTINUOUS`, `MOTION`, `ALL_OBJECTS`, `ALERTS`, `DETECTIONS`. `NONE` is published when no activity types are enabled.
 
 ### `frigate/<camera_name>/notifications/set`
 

docs/static/frigate-api.yaml

@@ -713,7 +713,7 @@ paths:
         | `improve_contrast` | `ON`, `OFF` |
         | `ptz_autotracker` | `ON`, `OFF` |
         | `birdseye` | `ON`, `OFF` |
-        | `birdseye_mode` | `CONTINUOUS`, `MOTION`, `OBJECTS` |
+        | `birdseye_modes` | `CONTINUOUS`, `MOTION`, `ALL_OBJECTS`, `ALERTS`, `DETECTIONS`, `NONE`, or a comma-separated combination |
         | `motion_contour_area` | integer |
         | `motion_threshold` | integer |
         | `motion_mask` | `ON`, `OFF` |
@@ -803,7 +803,7 @@ paths:
         | `improve_contrast` | `ON`, `OFF` |
         | `ptz_autotracker` | `ON`, `OFF` |
         | `birdseye` | `ON`, `OFF` |
-        | `birdseye_mode` | `CONTINUOUS`, `MOTION`, `OBJECTS` |
+        | `birdseye_modes` | `CONTINUOUS`, `MOTION`, `ALL_OBJECTS`, `ALERTS`, `DETECTIONS`, `NONE`, or a comma-separated combination |
         | `motion_contour_area` | integer |
         | `motion_threshold` | integer |
         | `motion_mask` | `ON`, `OFF` |

frigate/api/camera.py

@@ -1386,7 +1386,7 @@ def camera_set(
     | `improve_contrast` | `ON`, `OFF` |
     | `ptz_autotracker` | `ON`, `OFF` |
     | `birdseye` | `ON`, `OFF` |
-    | `birdseye_mode` | `CONTINUOUS`, `MOTION`, `OBJECTS` |
+    | `birdseye_modes` | `CONTINUOUS`, `MOTION`, `ALL_OBJECTS`, `ALERTS`, `DETECTIONS`, `NONE`, or a comma-separated combination |
     | `motion_contour_area` | integer |
     | `motion_threshold` | integer |
     | `motion_mask` | `ON`, `OFF` |

frigate/api/media.py

@@ -598,7 +598,15 @@ def _build_vod_clip(
     clip: dict[str, Any] = {"type": "source", "path": row.path}
     if plan.clip_from_ms is not None:
         clip["clipFrom"] = plan.clip_from_ms
-    clip["keyFrameDurations"] = [plan.duration_ms]
+    if plan.key_frame_durations is not None:
+        # real gaps enable keyframe-aligned sub-file segments (bootstrap
+        # ladder); the whole-clip fallback keeps one segment per file,
+        # the only safe cut without an index
+        if plan.first_key_frame_offset_ms > 0:
+            clip["firstKeyFrameOffset"] = plan.first_key_frame_offset_ms
+        clip["keyFrameDurations"] = plan.key_frame_durations
+    else:
+        clip["keyFrameDurations"] = [plan.duration_ms]
     logger.debug(
         "VOD: added clip %s duration_ms=%s clipFrom=%s",
         row.path,
@@ -740,14 +748,15 @@ async def _vod_response(
             NGINX_VOD_MAX_CLIPS,
         )
 
+    # segmentation comes from the vod_* nginx directives plus per-clip
+    # keyFrameDurations; a segment_duration field here was always ignored
+    # (nginx-vod parses only camelCase segmentDuration)
     hour_ago = datetime.now() - timedelta(hours=1)
     content = {
         "cache": hour_ago.timestamp() > start_ts,
         "discontinuity": force_discontinuity or use_discontinuity,
         "consistentSequenceMediaInfo": True,
         "durations": durations,
-        # aligns segments to recording file boundaries
-        "segment_duration": max(durations),
         "sequences": [{"clips": clips}],
     }
     if use_discontinuity:

frigate/api/record.py

@@ -71,7 +71,7 @@ def get_recordings_storage_usage(request: Request):
 
 
 @router.get("/recordings/summary", dependencies=[Depends(allow_any_authenticated())])
-def all_recordings_summary(
+async def all_recordings_summary(
     request: Request,
     params: MediaRecordingsSummaryQueryParams = Depends(),
     allowed_cameras: list[str] = Depends(get_allowed_cameras_for_filter),
@@ -88,18 +88,23 @@ def all_recordings_summary(
     else:
         camera_list = allowed_cameras
 
-    time_range_query = (
-        Recordings.select(
-            fn.MIN(Recordings.start_time).alias("min_time"),
-            fn.MAX(Recordings.start_time).alias("max_time"),
+    min_time: float | None = None
+    max_time: float | None = None
+    for camera in camera_list:
+        cam_min = (
+            Recordings.select(fn.MIN(Recordings.start_time))
+            .where(Recordings.camera == camera)
+            .scalar()
         )
-        .where(Recordings.camera << camera_list)
-        .dicts()
-        .get()
-    )
-
-    min_time = time_range_query.get("min_time")
-    max_time = time_range_query.get("max_time")
+        if cam_min is None:
+            continue
+        cam_max = (
+            Recordings.select(fn.MAX(Recordings.start_time))
+            .where(Recordings.camera == camera)
+            .scalar()
+        )
+        min_time = cam_min if min_time is None else min(min_time, cam_min)
+        max_time = cam_max if max_time is None else max(max_time, cam_max)
 
     if min_time is None or max_time is None:
         return JSONResponse(content={})
@@ -109,22 +114,60 @@ def all_recordings_summary(
     days: dict[str, bool] = {}
 
     for period_start, period_end, period_offset in dst_periods:
-        day_expr = ((Recordings.start_time + period_offset) / 86400).cast("int")
+        first_start = max(min_time, period_start - MAX_SEGMENT_DURATION)
+        first_day = int((first_start + period_offset) // 86400)
+        last_day = int((min(max_time, period_end) + period_offset) // 86400)
 
-        period_query = (
-            Recordings.select(day_expr.alias("day_idx"))
-            .where(
-                (Recordings.camera << camera_list)
-                & (Recordings.end_time >= period_start)
-                & (Recordings.start_time <= period_end)
+        day_idx = first_day
+        while day_idx <= last_day:
+            day_str = (dt.date(1970, 1, 1) + dt.timedelta(days=day_idx)).isoformat()
+            day_start = day_idx * 86400 - period_offset
+            day_end = day_start + 86400
+
+            if day_str in days:
+                day_idx += 1
+                continue
+
+            if day_end <= period_end:
+                upper = Recordings.start_time < day_end
+            else:
+                upper = Recordings.start_time <= period_end
+
+            has_recordings = (
+                Recordings.select(Recordings.id)
+                .where(
+                    (Recordings.camera << camera_list)
+                    & (Recordings.end_time >= period_start)
+                    & (Recordings.start_time >= day_start)
+                    & upper
+                )
+                .exists()
             )
-            .distinct()
-            .namedtuples()
-        )
+            if has_recordings:
+                days[day_str] = True
+                day_idx += 1
+                continue
 
-        for g in period_query:
-            day_str = (dt.date(1970, 1, 1) + dt.timedelta(days=g.day_idx)).isoformat()
-            days[day_str] = True
+            # empty day
+            next_start: float | None = None
+            for camera in camera_list:
+                cam_next = (
+                    Recordings.select(fn.MIN(Recordings.start_time))
+                    .where(
+                        Recordings.camera == camera,
+                        Recordings.start_time >= day_end,
+                        Recordings.start_time <= period_end,
+                    )
+                    .scalar()
+                )
+                if cam_next is not None and (
+                    next_start is None or cam_next < next_start
+                ):
+                    next_start = cam_next
+
+            if next_start is None:
+                break
+            day_idx = max(day_idx + 1, int((next_start + period_offset) // 86400))
 
     return JSONResponse(content=dict(sorted(days.items())))
 
@@ -373,22 +416,22 @@ async def no_recordings(
     )
     scale = params.scale
 
-    clauses = [
-        (Recordings.end_time >= after) & (Recordings.start_time <= before),
-        (Recordings.camera << camera_list),
-    ]
+    recordings: list[tuple[float, float]] = []
+    for camera in camera_list:
+        recordings.extend(
+            Recordings.select(Recordings.start_time, Recordings.end_time)
+            .where(
+                Recordings.camera == camera,
+                Recordings.start_time >= after - MAX_SEGMENT_DURATION,
+                Recordings.end_time >= after,
+                Recordings.start_time <= before,
+            )
+            .tuples()
+            .iterator()
+        )
 
-    # Get recording start times
-    data: list[Recordings] = (
-        Recordings.select(Recordings.start_time, Recordings.end_time)
-        .where(reduce(operator.and_, clauses))
-        .order_by(Recordings.start_time.asc())
-        .dicts()
-        .iterator()
-    )
-
-    # Convert recordings to list of (start, end) tuples, ordered by start_time
-    recordings = [(r["start_time"], r["end_time"]) for r in data]
+    # the merge pass below expects a single start-ordered timeline
+    recordings.sort()
 
     # Merge overlapping/adjacent recordings into covered intervals. The query
     # orders by start_time, so a single pass merges them

frigate/comms/dispatcher.py

@@ -11,7 +11,11 @@ from frigate.camera.activity_manager import AudioActivityManager, CameraActivity
 from frigate.comms.base_communicator import Communicator
 from frigate.comms.runtime_state import RuntimeStatePersistence
 from frigate.comms.webpush import WebPushClient
-from frigate.config import BirdseyeModeConfig, FrigateConfig
+from frigate.config import (
+    FrigateConfig,
+    birdseye_modes_from_mqtt_payload,
+    birdseye_modes_to_mqtt_payload,
+)
 from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdatePublisher,
@@ -84,7 +88,7 @@ class Dispatcher:
             "recordings": self._on_recordings_command,
             "snapshots": self._on_snapshots_command,
             "birdseye": self._on_birdseye_command,
-            "birdseye_mode": self._on_birdseye_mode_command,
+            "birdseye_modes": self._on_birdseye_modes_command,
             "review_alerts": self._on_alerts_command,
             "review_detections": self._on_detections_command,
             "object_descriptions": self._on_object_description_command,
@@ -879,12 +883,12 @@ class Dispatcher:
         )
         self.publish(f"{camera_name}/birdseye/state", payload, retain=True)
 
-    def _on_birdseye_mode_command(self, camera_name: str, payload: str) -> None:
+    def _on_birdseye_modes_command(self, camera_name: str, payload: str) -> None:
         """Callback for birdseye mode topic."""
 
-        mode = BirdseyeModeConfig.from_mqtt_payload(payload)
-        if mode is None:
-            logger.info("Invalid birdseye_mode command: %s", payload)
+        modes = birdseye_modes_from_mqtt_payload(payload)
+        if modes is None:
+            logger.info("Invalid birdseye_modes command: %s", payload)
             return
 
         birdseye_settings = self.config.cameras[camera_name].birdseye
@@ -893,9 +897,9 @@ class Dispatcher:
             logger.info(f"Birdseye mode not enabled for {camera_name}")
             return
 
-        birdseye_settings.mode = mode
+        birdseye_settings.modes = modes
         logger.info(
-            f"Setting birdseye mode for {camera_name} to {birdseye_settings.mode}"
+            f"Setting birdseye mode for {camera_name} to {birdseye_settings.modes}"
         )
 
         self.config_updater.publish_update(
@@ -903,7 +907,9 @@ class Dispatcher:
             birdseye_settings,
         )
         self.publish(
-            f"{camera_name}/birdseye_mode/state", mode.to_mqtt_payload(), retain=True
+            f"{camera_name}/birdseye_modes/state",
+            birdseye_modes_to_mqtt_payload(modes),
+            retain=True,
         )
 
     def _on_camera_notification_command(self, camera_name: str, payload: str) -> None:

frigate/comms/mqtt.py

@@ -7,7 +7,7 @@ import paho.mqtt.client as mqtt
 from paho.mqtt.enums import CallbackAPIVersion
 
 from frigate.comms.base_communicator import Communicator
-from frigate.config import FrigateConfig
+from frigate.config import FrigateConfig, birdseye_modes_to_mqtt_payload
 
 logger = logging.getLogger(__name__)
 
@@ -123,9 +123,9 @@ class MqttClient(Communicator):
                 retain=True,
             )
             self.publish(
-                f"{camera_name}/birdseye_mode/state",
+                f"{camera_name}/birdseye_modes/state",
                 (
-                    camera.birdseye.mode.to_mqtt_payload()
+                    birdseye_modes_to_mqtt_payload(camera.birdseye.modes)
                     if camera.birdseye.enabled
                     else "OFF"
                 ),
@@ -270,7 +270,7 @@ class MqttClient(Communicator):
             "motion_threshold",
             "motion_contour_area",
             "birdseye",
-            "birdseye_mode",
+            "birdseye_modes",
             "review_alerts",
             "review_detections",
             "object_descriptions",

frigate/config/camera/birdseye.py

@@ -1,3 +1,5 @@
+from enum import Enum
+
 from pydantic import BaseModel, Field
 
 from ..base import FrigateBaseModel
@@ -6,78 +8,58 @@ __all__ = [
     "BirdseyeCameraConfig",
     "BirdseyeConfig",
     "BirdseyeLayoutConfig",
-    "BirdseyeModeConfig",
+    "BirdseyeModeEnum",
+    "birdseye_modes_from_mqtt_payload",
+    "birdseye_modes_to_mqtt_payload",
 ]
 
-BIRDSEYE_ACTIVITY_TYPES = (
-    "objects",
-    "motion",
-    "stationary_objects",
-    "continuous",
-)
+# canonical MQTT payload for an empty mode list
+MQTT_NO_MODES = "NONE"
 
 
-class BirdseyeModeConfig(FrigateBaseModel):
-    continuous: bool = Field(
-        default=False,
-        title="Continuous",
-        description="Always include the camera in Birdseye.",
-    )
-    motion: bool = Field(
-        default=False,
-        title="Motion",
-        description="Include the camera in Birdseye when motion is detected.",
-    )
-    objects: bool = Field(
-        default=False,
-        title="Active objects",
-        description="Include the camera in Birdseye while an active object is tracked.",
-    )
-    stationary_objects: bool = Field(
-        default=False,
-        title="Stationary objects",
-        description="Include the camera in Birdseye while a stationary object is tracked.",
-    )
+class BirdseyeModeEnum(str, Enum):
+    continuous = "continuous"
+    motion = "motion"
+    all_objects = "all_objects"
+    alerts = "alerts"
+    detections = "detections"
 
-    @classmethod
-    def from_mqtt_payload(cls, payload: str) -> "BirdseyeModeConfig | None":
-        """Create mode options from an uppercase MQTT payload."""
-        raw_modes = payload.split(",")
-        if not raw_modes or any(not mode for mode in raw_modes):
+
+def birdseye_modes_from_mqtt_payload(payload: str) -> list[BirdseyeModeEnum] | None:
+    """Parse an uppercase MQTT payload into activity modes, or None when invalid."""
+    raw_modes = payload.split(",")
+
+    if any(not raw_mode or raw_mode != raw_mode.upper() for raw_mode in raw_modes):
+        return None
+
+    if raw_modes == [MQTT_NO_MODES]:
+        return []
+
+    modes: list[BirdseyeModeEnum] = []
+
+    for raw_mode in raw_modes:
+        try:
+            mode = BirdseyeModeEnum(raw_mode.lower())
+        except ValueError:
             return None
 
-        modes = [mode.lower() for mode in raw_modes]
-        if any(
-            raw_mode != mode.upper() or mode not in BIRDSEYE_ACTIVITY_TYPES
-            for raw_mode, mode in zip(raw_modes, modes)
-        ):
+        if mode in modes:
             return None
 
-        if len(modes) != len(set(modes)):
-            return None
+        modes.append(mode)
 
-        return cls(**{mode: True for mode in modes})
-
-    def has_enabled_activity(self) -> bool:
-        """Return whether at least one activity type is enabled."""
-        return any(getattr(self, activity) for activity in BIRDSEYE_ACTIVITY_TYPES)
-
-    def to_mqtt_payload(self) -> str:
-        """Serialize enabled mode options for MQTT state topics."""
-        payload = ",".join(
-            activity.upper()
-            for activity in BIRDSEYE_ACTIVITY_TYPES
-            if getattr(self, activity)
-        )
-        if not payload:
-            raise ValueError("At least one Birdseye activity type must be enabled")
-
-        return payload
+    return modes
 
 
-def default_birdseye_mode() -> BirdseyeModeConfig:
-    """Return the default Birdseye mode configuration."""
-    return BirdseyeModeConfig(objects=True)
+def birdseye_modes_to_mqtt_payload(modes: list[BirdseyeModeEnum]) -> str:
+    """Serialize activity modes for MQTT state topics."""
+    payload = ",".join(mode.value.upper() for mode in BirdseyeModeEnum if mode in modes)
+    return payload or MQTT_NO_MODES
+
+
+def default_birdseye_modes() -> list[BirdseyeModeEnum]:
+    """Return the default Birdseye activity modes."""
+    return [BirdseyeModeEnum.all_objects]
 
 
 class BirdseyeLayoutConfig(FrigateBaseModel):
@@ -101,8 +83,8 @@ class BirdseyeConfig(FrigateBaseModel):
         title="Enable Birdseye",
         description="Enable or disable the Birdseye view feature.",
     )
-    mode: BirdseyeModeConfig = Field(
-        default_factory=default_birdseye_mode,
+    modes: list[BirdseyeModeEnum] = Field(
+        default_factory=default_birdseye_modes,
         title="Activity types",
         description="Activity types that include cameras in Birdseye.",
     )
@@ -156,8 +138,8 @@ class BirdseyeCameraConfig(BaseModel):
         title="Enable Birdseye",
         description="Enable or disable the Birdseye view feature.",
     )
-    mode: BirdseyeModeConfig = Field(
-        default_factory=default_birdseye_mode,
+    modes: list[BirdseyeModeEnum] = Field(
+        default_factory=default_birdseye_modes,
         title="Activity types",
         description="Activity types that include cameras in Birdseye.",
     )

frigate/config/config.py

@@ -41,7 +41,7 @@ from .auth import AuthConfig
 from .base import FrigateBaseModel
 from .camera import CameraConfig, CameraLiveConfig
 from .camera.audio import AudioConfig, AudioFilterConfig
-from .camera.birdseye import BirdseyeConfig, BirdseyeModeConfig
+from .camera.birdseye import BirdseyeConfig
 from .camera.detect import DetectConfig
 from .camera.ffmpeg import FfmpegConfig
 from .camera.genai import GenAIConfig, GenAIRoleEnum
@@ -349,20 +349,8 @@ def verify_required_zones_exist(camera_config: CameraConfig) -> None:
 
 
 def verify_profile_overrides_match_base(camera_config: CameraConfig) -> None:
-    """Verify profile overrides against the resolved base camera configuration."""
+    """Verify that profile zone and mask IDs reference entries defined on the base camera."""
     for profile_name, profile in camera_config.profiles.items():
-        if profile.birdseye is not None:
-            overrides = profile.birdseye.mode.model_dump(exclude_unset=True)
-            base_mode = camera_config.birdseye.mode.model_dump()
-            resolved_mode = BirdseyeModeConfig.model_validate(
-                deep_merge(overrides, base_mode)
-            )
-            if not resolved_mode.has_enabled_activity():
-                raise ValueError(
-                    f"Camera '{camera_config.name}' profile '{profile_name}' must "
-                    "enable at least one Birdseye activity type"
-                )
-
         if profile.zones:
             for zone_name in profile.zones:
                 if zone_name not in camera_config.zones:
@@ -1033,10 +1021,6 @@ class FrigateConfig(FrigateBaseModel):
             self.cameras[name] = camera_config
 
             verify_config_roles(camera_config)
-            if not camera_config.birdseye.mode.has_enabled_activity():
-                raise ValueError(
-                    f"Camera '{name}' must enable at least one Birdseye activity type"
-                )
             verify_valid_live_stream_names(self, camera_config)
             verify_recording_segments_setup_with_reasonable_time(camera_config)
             verify_zone_objects_are_tracked(camera_config)

frigate/config/profile_manager.py

@@ -8,6 +8,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
+from frigate.config.camera.birdseye import birdseye_modes_to_mqtt_payload
 from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdatePublisher,
@@ -42,9 +43,11 @@ SECTION_STATE_TOPICS: dict[str, list[tuple[str, Callable[[Any], Any]]]] = {
     "birdseye": [
         ("birdseye", lambda c: "ON" if c.birdseye.enabled else "OFF"),
         (
-            "birdseye_mode",
+            "birdseye_modes",
             lambda c: (
-                c.birdseye.mode.to_mqtt_payload() if c.birdseye.enabled else "OFF"
+                birdseye_modes_to_mqtt_payload(c.birdseye.modes)
+                if c.birdseye.enabled
+                else "OFF"
             ),
         ),
     ],

frigate/genai/prompts.py

@@ -453,7 +453,7 @@ def get_tool_definitions(
                                 "motion",
                                 "enabled",
                                 "birdseye",
-                                "birdseye_mode",
+                                "birdseye_modes",
                                 "improve_contrast",
                                 "ptz_autotracker",
                                 "motion_contour_area",
@@ -468,7 +468,7 @@ def get_tool_definitions(
                             ],
                             "description": (
                                 "The feature to change. Most features accept ON or OFF. "
-                                "birdseye_mode accepts CONTINUOUS, MOTION, OBJECTS, STATIONARY_OBJECTS, or a comma-separated combination. "
+                                "birdseye_modes accepts CONTINUOUS, MOTION, ALL_OBJECTS, ALERTS, DETECTIONS, NONE, or a comma-separated combination. "
                                 "motion_contour_area and motion_threshold accept a number. "
                                 "profile accepts a profile name or 'none' to deactivate (requires camera='*')."
                             ),

frigate/output/birdseye.py

@@ -17,9 +17,11 @@ import cv2
 import numpy as np
 
 from frigate.comms.inter_process import InterProcessRequestor
-from frigate.config import BirdseyeModeConfig, FfmpegConfig, FrigateConfig
+from frigate.comms.review_updater import ReviewDataSubscriber
+from frigate.config import BirdseyeModeEnum, FfmpegConfig, FrigateConfig
 from frigate.const import BASE_DIR, BIRDSEYE_PIPE, INSTALL_DIR, UPDATE_BIRDSEYE_LAYOUT
 from frigate.output.ws_auth import ws_has_camera_access
+from frigate.review.types import SeverityEnum
 from frigate.util.image import (
     SharedMemoryFrameManager,
     copy_yuv_to_position,
@@ -33,9 +35,9 @@ logger = logging.getLogger(__name__)
 class BirdseyeActivity:
     """Activity signals used to decide whether a camera is shown in Birdseye."""
 
-    has_active_object: bool
-    has_stationary_object: bool
+    has_object: bool
     has_motion: bool
+    severity: str | None
 
 
 def get_standard_aspect_ratio(width: int, height: int) -> tuple[int, int]:
@@ -367,6 +369,7 @@ class BirdsEyeFrameManager:
                 settings.detect.height,
             ],
             "last_active_frame": 0.0,
+            "live_active": False,
             "current_frame": 0.0,
             "layout_frame": 0.0,
             "channel_dims": {
@@ -418,16 +421,32 @@ class BirdsEyeFrameManager:
             channel_dims,
         )
 
-    def camera_active(
+    def camera_threshold_active(
         self,
-        mode: BirdseyeModeConfig,
+        modes: list[BirdseyeModeEnum],
         activity: BirdseyeActivity,
     ) -> bool:
+        """Return whether activity subject to inactivity_threshold is present."""
+        return (BirdseyeModeEnum.motion in modes and activity.has_motion) or (
+            BirdseyeModeEnum.all_objects in modes and activity.has_object
+        )
+
+    def camera_live_active(
+        self,
+        modes: list[BirdseyeModeEnum],
+        activity: BirdseyeActivity,
+    ) -> bool:
+        """Return whether activity that ends the moment it stops is present."""
         return (
-            mode.continuous
-            or (mode.motion and activity.has_motion)
-            or (mode.objects and activity.has_active_object)
-            or (mode.stationary_objects and activity.has_stationary_object)
+            BirdseyeModeEnum.continuous in modes
+            or (
+                BirdseyeModeEnum.alerts in modes
+                and activity.severity == SeverityEnum.alert
+            )
+            or (
+                BirdseyeModeEnum.detections in modes
+                and activity.severity == SeverityEnum.detection
+            )
         )
 
     def get_camera_coordinates(self) -> dict[str, dict[str, int]]:
@@ -459,9 +478,15 @@ class BirdsEyeFrameManager:
                 and self.config.cameras[cam].birdseye.enabled
                 and self.config.cameras[cam].enabled_in_config
                 and self.config.cameras[cam].enabled
-                and cam_data["last_active_frame"] > 0
-                and cam_data["current_frame_time"] - cam_data["last_active_frame"]
-                < self.config.birdseye.inactivity_threshold
+                and (
+                    cam_data["live_active"]
+                    or (
+                        cam_data["last_active_frame"] > 0
+                        and cam_data["current_frame_time"]
+                        - cam_data["last_active_frame"]
+                        < self.config.birdseye.inactivity_threshold
+                    )
+                )
             ]
         )
         logger.debug(f"Active cameras: {active_cameras}")
@@ -478,7 +503,9 @@ class BirdsEyeFrameManager:
                 limited_active_cameras = sorted(
                     active_cameras,
                     key=lambda active_camera: (
-                        self.cameras[active_camera]["current_frame_time"]
+                        0.0
+                        if self.cameras[active_camera]["live_active"]
+                        else self.cameras[active_camera]["current_frame_time"]
                         - self.cameras[active_camera]["last_active_frame"]
                     ),
                 )
@@ -754,10 +781,10 @@ class BirdsEyeFrameManager:
 
         # disabling birdseye is a little tricky
         if not camera_config.birdseye.enabled or not camera_config.enabled:
-            # if we've rendered a frame (we have a value for last_active_frame)
-            # then we need to set it to zero
-            if camera_state["last_active_frame"] > 0:
+            # if we've rendered a frame (we have activity state) then clear it
+            if camera_state["last_active_frame"] > 0 or camera_state["live_active"]:
                 camera_state["last_active_frame"] = 0
+                camera_state["live_active"] = False
                 force_update = True
             else:
                 return False, False
@@ -765,12 +792,13 @@ class BirdsEyeFrameManager:
         # update the last active frame for the camera
         camera_state["current_frame"] = frame.copy()
         camera_state["current_frame_time"] = frame_time
-        if self.camera_active(
-            camera_config.birdseye.mode,
-            activity,
-        ):
+        modes = camera_config.birdseye.modes
+
+        if self.camera_threshold_active(modes, activity):
             camera_state["last_active_frame"] = frame_time
 
+        camera_state["live_active"] = self.camera_live_active(modes, activity)
+
         now = datetime.datetime.now().timestamp()
 
         # limit output to 10 fps
@@ -828,6 +856,8 @@ class Birdseye:
         self.frame_manager = SharedMemoryFrameManager()
         self.stop_event = stop_event
         self.requestor = InterProcessRequestor()
+        self.review_subscriber = ReviewDataSubscriber("")
+        self.review_severity: dict[str, str] = {}
         self.idle_fps: float = self.config.birdseye.idle_heartbeat_fps
         self._idle_interval: float | None = (
             (1.0 / self.idle_fps) if self.idle_fps > 0 else None
@@ -858,6 +888,21 @@ class Birdseye:
         self.birdseye_manager.clear_frame()
         self.__send_new_frame()
 
+    def check_review_updates(self) -> None:
+        """Drain review updates so each camera's active severity stays current."""
+        while True:
+            update = self.review_subscriber.check_for_update(timeout=0)
+
+            if update is None:
+                break
+
+            camera = update["after"]["camera"]
+
+            if update["type"] == "end":
+                self.review_severity.pop(camera, None)
+            else:
+                self.review_severity[camera] = update["after"]["severity"]
+
     def add_camera(self, camera: str) -> None:
         """Add a camera to the birdseye manager."""
         self.birdseye_manager.add_camera(camera)
@@ -866,6 +911,7 @@ class Birdseye:
     def remove_camera(self, camera: str) -> None:
         """Remove a camera from the birdseye manager."""
         self.birdseye_manager.remove_camera(camera)
+        self.review_severity.pop(camera, None)
         logger.debug(f"Removed camera {camera} from birdseye")
 
     def write_data(
@@ -876,24 +922,13 @@ class Birdseye:
         frame_time: float,
         frame: np.ndarray,
     ) -> None:
-        has_active_object = False
-        has_stationary_object = False
-        for tracked_object in current_tracked_objects:
-            if tracked_object["stationary"]:
-                if not tracked_object["false_positive"]:
-                    has_stationary_object = True
-            else:
-                # Preserve the existing objects activity behavior, which includes
-                # non-stationary trackers before they are confirmed.
-                has_active_object = True
-
-            if has_active_object and has_stationary_object:
-                break
-
         activity = BirdseyeActivity(
-            has_active_object=has_active_object,
-            has_stationary_object=has_stationary_object,
+            has_object=any(
+                not tracked_object["false_positive"]
+                for tracked_object in current_tracked_objects
+            ),
             has_motion=bool(motion_boxes),
+            severity=self.review_severity.get(camera),
         )
 
         frame_changed, frame_layout_changed = self.birdseye_manager.update(
@@ -919,5 +954,6 @@ class Birdseye:
                 self.__send_new_frame()
 
     def stop(self) -> None:
+        self.review_subscriber.stop()
         self.converter.join()
         self.broadcaster.join()

frigate/output/output.py

@@ -188,6 +188,11 @@ class OutputProcess(FrigateProcess):
                 self.config.birdseye = birdseye_config
                 logger.debug("Applied dynamic birdseye config update")
 
+            # drain review updates every iteration, not just when birdseye is
+            # being consumed, so a dropped end never strands a camera
+            if birdseye is not None:
+                birdseye.check_review_updates()
+
             # check if there is an updated config
             updates = config_subscriber.check_for_updates()
 

frigate/record/cleanup.py

@@ -167,6 +167,10 @@ class RecordingCleanup(threading.Thread):
             .where(
                 (Recordings.camera == config.name)
                 & (Recordings.stream_type == stream_type)
+                & (
+                    Recordings.start_time
+                    < max(continuous_expire_date, motion_expire_date)
+                )
                 & (
                     (
                         (Recordings.end_time < continuous_expire_date)
@@ -333,27 +337,45 @@ class RecordingCleanup(threading.Thread):
         expire_before = (
             datetime.datetime.now() - datetime.timedelta(days=expire_days)
         ).timestamp()
-        no_camera_recordings = (
-            Recordings.select(
-                Recordings.id,
-                Recordings.path,
-            )
-            .where(
-                Recordings.camera.not_in(list(self.config.cameras.keys())),  # type: ignore[call-arg, arg-type, misc]
-                Recordings.end_time < expire_before,
-            )
-            .namedtuples()
-            .iterator()
-        )
+
+        # enumerate the distinct cameras with one index seek each
+        db_cameras: list[str] = []
+        last_camera: str | None = None
+        while True:
+            query = Recordings.select(Recordings.camera)
+            if last_camera is not None:
+                query = query.where(Recordings.camera > last_camera)
+            next_camera = query.order_by(Recordings.camera.asc()).limit(1).scalar()
+            if next_camera is None:
+                break
+            db_cameras.append(next_camera)
+            last_camera = next_camera
 
         maybe_empty_dirs = set()
 
         deleted_recordings = set()
-        for recording in no_camera_recordings:
-            recording_path = Path(recording.path)
-            recording_path.unlink(missing_ok=True)
-            deleted_recordings.add(recording.id)
-            maybe_empty_dirs.add(recording_path.parent)
+        for camera in db_cameras:
+            if camera in self.config.cameras:
+                continue
+
+            no_camera_recordings = (
+                Recordings.select(
+                    Recordings.id,
+                    Recordings.path,
+                )
+                .where(
+                    Recordings.camera == camera,
+                    Recordings.end_time < expire_before,
+                )
+                .namedtuples()
+                .iterator()
+            )
+
+            for recording in no_camera_recordings:
+                recording_path = Path(recording.path)
+                recording_path.unlink(missing_ok=True)
+                deleted_recordings.add(recording.id)
+                maybe_empty_dirs.add(recording_path.parent)
 
         logger.debug(f"Expiring {len(deleted_recordings)} recordings")
         # delete up to 100,000 at a time

frigate/storage.py

@@ -6,7 +6,7 @@ import threading
 from multiprocessing.synchronize import Event as MpEvent
 from pathlib import Path
 
-from peewee import SQL, fn
+from peewee import SQL, Case, fn
 
 from frigate.config import FrigateConfig
 from frigate.const import (
@@ -35,6 +35,35 @@ class StorageMaintainer(threading.Thread):
         self.stop_event = stop_event
         self.camera_storage_stats: dict[str, dict] = {}
 
+    def _recent_stream_bandwidth(
+        self, camera: str, stream_type: str, window: int
+    ) -> float | None:
+        """Average MB/s over a stream's most recent rows, or None if no sample.
+
+        Zero-size rows are excluded inside the projection, not the WHERE
+        clause: a segment_size predicate baits the planner into the
+        (camera, segment_size) index plus a full sort of the camera's
+        history instead of the time-ordered index.
+        """
+        recent = (
+            Recordings.select(
+                Case(
+                    None,
+                    [(Recordings.segment_size > 0, bandwidth_equation)],
+                    None,
+                ).alias("bw")
+            )
+            .where(
+                Recordings.camera == camera,
+                Recordings.stream_type == stream_type,
+            )
+            .order_by(Recordings.start_time.desc())
+            .limit(window)
+            .alias("recent")
+        )
+        avg: float | None = Recordings.select(fn.AVG(SQL("bw"))).from_(recent).scalar()
+        return avg
+
     def calculate_camera_bandwidth(self) -> None:
         """Calculate an average MB/hr for each camera."""
         for camera in self.config.cameras.keys():
@@ -47,9 +76,10 @@ class StorageMaintainer(threading.Thread):
             if self.camera_storage_stats.get(camera, {}).get("needs_refresh", True):
                 self.camera_storage_stats[camera] = {
                     "needs_refresh": (
-                        Recordings.select(fn.COUNT("*"))
+                        Recordings.select(Recordings.id)
                         .where(Recordings.camera == camera, Recordings.segment_size > 0)
-                        .scalar()
+                        .limit(50)
+                        .count()
                         < 50
                     )
                 }
@@ -58,31 +88,18 @@ class StorageMaintainer(threading.Thread):
                 # type and sum the rates; mixing streams would average small
                 # sub segments against large main segments and underestimate
                 # the true write rate
-                bandwidth = 0
+                bandwidth = 0.0
                 for stream_type in (STREAM_TYPE_MAIN, STREAM_TYPE_SUB):
-                    try:
-                        # Subquery to get last 100 segments, then average their bandwidth
-                        last_100 = (
-                            Recordings.select(bandwidth_equation.alias("bw"))
-                            .where(
-                                Recordings.camera == camera,
-                                Recordings.segment_size > 0,
-                                Recordings.stream_type == stream_type,
-                            )
-                            .order_by(Recordings.start_time.desc())
-                            .limit(100)
-                            .alias("recent")
+                    avg_bw = self._recent_stream_bandwidth(camera, stream_type, 100)
+                    if avg_bw is None:
+                        # the recent window can be all zero-size ingest
+                        # glitches; look further back before concluding
+                        # the stream writes nothing
+                        avg_bw = self._recent_stream_bandwidth(
+                            camera, stream_type, 1000
                         )
-
-                        bandwidth += round(
-                            Recordings.select(fn.AVG(SQL("bw")))
-                            .from_(last_100)
-                            .scalar()
-                            * 3600,
-                            2,
-                        )
-                    except TypeError:
-                        pass
+                    if avg_bw is not None:
+                        bandwidth += round(avg_bw * 3600, 2)
 
                 bandwidth = round(bandwidth, 2)
 

frigate/test/http_api/test_http_config_set.py

@@ -7,7 +7,7 @@ from unittest.mock import MagicMock, Mock, patch
 
 import ruamel.yaml
 
-from frigate.config import FrigateConfig
+from frigate.config import BirdseyeModeEnum, FrigateConfig
 from frigate.config.camera.updater import (
     CameraConfigUpdateEnum,
     CameraConfigUpdatePublisher,
@@ -383,22 +383,15 @@ class TestConfigSetWildcardPropagation(BaseTestHttp):
         Global birdseye only seeds enabled and mode; the camera copies are what
         the output process actually reads. Sending just the global object makes
         a worker guess which cameras were inheriting, and the only available
-        guess (mode still equals the previous global) wrongly claims a camera
-        whose explicit yaml mode happens to match.
+        guess (modes still equals the previous global) wrongly claims a camera
+        whose explicit yaml modes happens to match.
         """
         self.minimal_config["birdseye"] = {
             "enabled": True,
-            "mode": {"motion": True},
+            "modes": ["motion"],
         }
         # explicit override that matches the global value being replaced
-        self.minimal_config["cameras"]["front_door"]["birdseye"] = {
-            "mode": {
-                "continuous": False,
-                "motion": True,
-                "objects": False,
-                "stationary_objects": False,
-            }
-        }
+        self.minimal_config["cameras"]["front_door"]["birdseye"] = {"modes": ["motion"]}
 
         config_path = self._write_config_file()
         mock_find_config.return_value = config_path
@@ -409,16 +402,7 @@ class TestConfigSetWildcardPropagation(BaseTestHttp):
                 resp = client.put(
                     "/config/set",
                     json={
-                        "config_data": {
-                            "birdseye": {
-                                "mode": {
-                                    "continuous": True,
-                                    "motion": False,
-                                    "objects": False,
-                                    "stationary_objects": False,
-                                }
-                            }
-                        },
+                        "config_data": {"birdseye": {"modes": ["continuous"]}},
                         "update_topic": "config/birdseye",
                         "requires_restart": 0,
                     },
@@ -430,7 +414,7 @@ class TestConfigSetWildcardPropagation(BaseTestHttp):
                 mock_publisher.publisher.publish.assert_called_once()
                 topic, settings = mock_publisher.publisher.publish.call_args[0]
                 self.assertEqual(topic, "config/birdseye")
-                self.assertEqual(settings.mode.to_mqtt_payload(), "CONTINUOUS")
+                self.assertEqual(settings.modes, [BirdseyeModeEnum.continuous])
 
                 published = {
                     call[0][0].camera: call[0][1]
@@ -445,10 +429,10 @@ class TestConfigSetWildcardPropagation(BaseTestHttp):
 
                 # the override survives, the inheriting camera follows global
                 self.assertEqual(
-                    published["front_door"].mode.to_mqtt_payload(), "MOTION"
+                    published["front_door"].modes, [BirdseyeModeEnum.motion]
                 )
                 self.assertEqual(
-                    published["back_yard"].mode.to_mqtt_payload(), "CONTINUOUS"
+                    published["back_yard"].modes, [BirdseyeModeEnum.continuous]
                 )
         finally:
             os.unlink(config_path)

frigate/test/http_api/test_http_media.py

@@ -119,7 +119,6 @@ class TestHttpMedia(BaseTestHttp):
         ] == expected_clips
         expected_durations = [clip[2] for clip in expected_clips]
         assert vod["durations"] == expected_durations
-        assert vod["segment_duration"] == max(expected_durations)
 
     def test_recordings_summary_across_dst_spring_forward(self):
         """
@@ -481,6 +480,129 @@ class TestHttpMedia(BaseTestHttp):
             assert "2024-03-10" in summary
             assert summary["2024-03-10"] is True
 
+    def test_recordings_summary_includes_sub_only_days(self):
+        """
+        A day covered only by sub-stream rows still gets a day marker.
+
+        Retention can expire main rows while keeping sub history, so the
+        calendar must not filter by stream type.
+        """
+        march_9_utc = datetime(2024, 3, 9, 12, 0, 0, tzinfo=UTC).timestamp()
+        march_10_utc = datetime(2024, 3, 10, 12, 0, 0, tzinfo=UTC).timestamp()
+
+        with AuthTestClient(self.app) as client:
+            self._insert_recording(
+                "main_march_9", march_9_utc, march_9_utc + 3600, stream_type="main"
+            )
+            self._insert_recording(
+                "sub_march_10", march_10_utc, march_10_utc + 3600, stream_type="sub"
+            )
+
+            response = client.get(
+                "/recordings/summary", params={"timezone": "utc", "cameras": "all"}
+            )
+
+            assert response.status_code == 200
+            summary = response.json()
+            assert len(summary) == 2
+            assert summary["2024-03-09"] is True
+            assert summary["2024-03-10"] is True
+
+    def test_recordings_summary_sparse_days_across_large_gap(self):
+        """
+        Only recorded days are reported when a large empty gap separates them.
+        """
+        early = datetime(2023, 1, 5, 12, 0, 0, tzinfo=UTC).timestamp()
+        late = datetime(2024, 3, 10, 12, 0, 0, tzinfo=UTC).timestamp()
+
+        with AuthTestClient(self.app) as client:
+            self._insert_recording("early_day", early, early + 3600)
+            self._insert_recording("late_day", late, late + 3600)
+
+            response = client.get(
+                "/recordings/summary", params={"timezone": "utc", "cameras": "all"}
+            )
+
+            assert response.status_code == 200
+            summary = response.json()
+            assert summary == {"2023-01-05": True, "2024-03-10": True}
+
+    def test_recordings_unavailable_merges_cameras(self):
+        """
+        Gaps are computed against the union of all requested cameras' coverage.
+        """
+
+        async def allow_both_cameras(request: Request):
+            return ["front_door", "back_door"]
+
+        self.app.dependency_overrides[get_allowed_cameras_for_filter] = (
+            allow_both_cameras
+        )
+
+        with AuthTestClient(self.app) as client:
+            for id, camera, start, end in [
+                ("front_a", "front_door", 1000, 1100),
+                ("front_b", "front_door", 1200, 1300),
+                ("back_a", "back_door", 1100, 1160),
+            ]:
+                Recordings.insert(
+                    id=id,
+                    path=f"/media/recordings/{id}.mp4",
+                    camera=camera,
+                    start_time=start,
+                    end_time=end,
+                    duration=end - start,
+                    motion=0,
+                    objects=0,
+                ).execute()
+
+            response = client.get(
+                "/recordings/unavailable",
+                params={
+                    "after": 1000,
+                    "before": 1300,
+                    "scale": 10,
+                    "cameras": "front_door,back_door",
+                },
+            )
+            assert response.status_code == 200
+            assert response.json() == [{"start_time": 1160, "end_time": 1200}]
+
+            # single camera: back_door alone leaves both edges uncovered
+            response = client.get(
+                "/recordings/unavailable",
+                params={
+                    "after": 1000,
+                    "before": 1300,
+                    "scale": 10,
+                    "cameras": "back_door",
+                },
+            )
+            assert response.status_code == 200
+            assert response.json() == [
+                {"start_time": 1000, "end_time": 1100},
+                {"start_time": 1160, "end_time": 1300},
+            ]
+
+    def test_recordings_summary_day_attribution_by_start_time(self):
+        """
+        A recording spanning midnight marks only its start day.
+        """
+        # starts 23:30 March 9, ends 00:30 March 10 (UTC)
+        start = datetime(2024, 3, 9, 23, 30, 0, tzinfo=UTC).timestamp()
+
+        with AuthTestClient(self.app) as client:
+            self._insert_recording("midnight_span", start, start + 3600)
+
+            response = client.get(
+                "/recordings/summary", params={"timezone": "utc", "cameras": "all"}
+            )
+
+            assert response.status_code == 200
+            summary = response.json()
+            assert len(summary) == 1
+            assert summary["2024-03-09"] is True
+
     def _insert_recording(
         self,
         id: str,
@@ -585,7 +707,6 @@ class TestHttpMedia(BaseTestHttp):
                 "/media/recordings/main_1.mp4",
                 "/media/recordings/main_2.mp4",
             ]
-            assert body["segment_duration"] == 10000
 
     def test_vod_merges_intervals_split_by_other_stream_boundaries(self):
         """A recording spanning several coverage intervals stays one clip.
@@ -790,7 +911,6 @@ class TestHttpMedia(BaseTestHttp):
             assert "initialClipIndex" not in body
             assert body["consistentSequenceMediaInfo"] is True
             assert body["durations"] == [10000, 10000]
-            assert body["segment_duration"] == 10000
             assert len(body["sequences"]) == 1
             clips = body["sequences"][0]["clips"]
             assert [c["path"] for c in clips] == [
@@ -853,8 +973,8 @@ class TestHttpMedia(BaseTestHttp):
         A long sub-only stretch means the merged sequence mixes muxed
         main files and audio-less sub files. Track-PRESENCE mixing
         across discontinuities is unproven in MSE, so every clip is
-        stripped to video tracks rather than the tracks being carried
-        through the discontinuity the stream mix already forces.
+        stripped to video tracks (the cross-stream hand-off still serves
+        the range in discontinuity mode).
         """
         with AuthTestClient(self.app) as client:
             self._insert_recording("main_1", 1000, 1010, "main", has_audio=True)
@@ -1240,7 +1360,8 @@ class TestHttpMedia(BaseTestHttp):
         """Uniformly-unknown rows (the pre-feature case) are never stripped.
 
         Legacy rows have has_audio NULL and audio_rate NULL; they share a
-        single signature, so no audio policy fires and audio plays.
+        single signature, so audio plays (the cross-stream hand-off still
+        serves the range in discontinuity mode).
         """
         with AuthTestClient(self.app) as client:
             self._insert_recording("main_1", 1000, 1010, "main")

frigate/test/test_birdseye.py

@@ -4,7 +4,12 @@ import multiprocessing as mp
 import unittest
 from unittest.mock import Mock
 
-from frigate.config import BirdseyeModeConfig, FrigateConfig
+from frigate.config import (
+    BirdseyeModeEnum,
+    FrigateConfig,
+    birdseye_modes_from_mqtt_payload,
+    birdseye_modes_to_mqtt_payload,
+)
 from frigate.output.birdseye import (
     Birdseye,
     BirdseyeActivity,
@@ -215,11 +220,7 @@ class TestBirdseyeActivity(unittest.TestCase):
             "mqtt": {"enabled": False},
             "birdseye": {
                 "enabled": True,
-                "mode": {
-                    "motion": True,
-                    "objects": True,
-                    "stationary_objects": True,
-                },
+                "modes": ["motion", "all_objects"],
             },
             "cameras": {
                 "front": {
@@ -234,53 +235,93 @@ class TestBirdseyeActivity(unittest.TestCase):
         }
         self.manager = BirdsEyeFrameManager(FrigateConfig(**config), mp.Event())
 
-    def test_existing_modes_keep_their_activity_rules(self):
-        continuous = BirdseyeModeConfig(continuous=True)
-        motion = BirdseyeModeConfig(motion=True)
-        objects = BirdseyeModeConfig(objects=True)
+    def test_each_mode_matches_only_its_own_activity(self):
+        motion_activity = BirdseyeActivity(
+            has_object=False, has_motion=True, severity=None
+        )
+        object_activity = BirdseyeActivity(
+            has_object=True, has_motion=False, severity=None
+        )
+        no_activity = BirdseyeActivity(
+            has_object=False, has_motion=False, severity=None
+        )
 
-        no_activity = BirdseyeActivity(False, False, False)
-        motion_activity = BirdseyeActivity(False, False, True)
-        stationary_activity = BirdseyeActivity(False, True, False)
-        active_object_activity = BirdseyeActivity(True, False, False)
+        assert self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.motion], motion_activity
+        )
+        assert not self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.motion], object_activity
+        )
+        assert self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.all_objects], object_activity
+        )
+        assert not self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.all_objects], motion_activity
+        )
+        assert self.manager.camera_live_active(
+            [BirdseyeModeEnum.continuous], no_activity
+        )
 
-        assert self.manager.camera_active(continuous, no_activity)
-        assert self.manager.camera_active(motion, motion_activity)
-        assert not self.manager.camera_active(motion, stationary_activity)
-        assert self.manager.camera_active(objects, active_object_activity)
-        assert not self.manager.camera_active(objects, stationary_activity)
+    def test_continuous_is_not_threshold_activity(self):
+        no_activity = BirdseyeActivity(
+            has_object=False, has_motion=False, severity=None
+        )
+
+        assert not self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.continuous], no_activity
+        )
 
     def test_modes_can_be_combined(self):
-        mode = BirdseyeModeConfig(motion=True, stationary_objects=True)
+        modes = [BirdseyeModeEnum.motion, BirdseyeModeEnum.all_objects]
 
-        assert self.manager.camera_active(mode, BirdseyeActivity(False, False, True))
-        assert self.manager.camera_active(mode, BirdseyeActivity(False, True, False))
-        assert not self.manager.camera_active(
-            mode, BirdseyeActivity(False, False, False)
+        assert self.manager.camera_threshold_active(
+            modes, BirdseyeActivity(has_object=False, has_motion=True, severity=None)
+        )
+        assert self.manager.camera_threshold_active(
+            modes, BirdseyeActivity(has_object=True, has_motion=False, severity=None)
+        )
+        assert not self.manager.camera_threshold_active(
+            modes, BirdseyeActivity(has_object=False, has_motion=False, severity=None)
         )
 
-    def test_stationary_objects_are_independent_from_active_objects(self):
-        stationary_objects = BirdseyeModeConfig(stationary_objects=True)
+    def test_empty_modes_never_activate(self):
+        activity = BirdseyeActivity(has_object=True, has_motion=True, severity=None)
 
-        assert self.manager.camera_active(
-            stationary_objects, BirdseyeActivity(False, True, False)
+        assert not self.manager.camera_threshold_active([], activity)
+        assert not self.manager.camera_live_active([], activity)
+
+    def test_alerts_and_detections_match_review_severity(self):
+        alert = BirdseyeActivity(has_object=False, has_motion=False, severity="alert")
+        detection = BirdseyeActivity(
+            has_object=False, has_motion=False, severity="detection"
         )
-        assert not self.manager.camera_active(
-            stationary_objects, BirdseyeActivity(True, False, False)
+        idle = BirdseyeActivity(has_object=False, has_motion=False, severity=None)
+
+        assert self.manager.camera_live_active([BirdseyeModeEnum.alerts], alert)
+        assert not self.manager.camera_live_active([BirdseyeModeEnum.alerts], detection)
+        assert not self.manager.camera_live_active([BirdseyeModeEnum.alerts], idle)
+        assert self.manager.camera_live_active([BirdseyeModeEnum.detections], detection)
+        assert not self.manager.camera_live_active([BirdseyeModeEnum.detections], alert)
+
+    def test_review_severity_is_not_threshold_activity(self):
+        alert = BirdseyeActivity(has_object=False, has_motion=False, severity="alert")
+
+        assert not self.manager.camera_threshold_active(
+            [BirdseyeModeEnum.alerts, BirdseyeModeEnum.motion], alert
         )
 
-    def test_write_data_preserves_active_and_confirms_stationary_activity(self):
+    def test_all_objects_covers_active_and_stationary_objects(self):
         birdseye = Birdseye.__new__(Birdseye)
         birdseye.birdseye_manager = Mock()
         birdseye.birdseye_manager.update.return_value = (False, False)
         birdseye._idle_interval = None
+        birdseye.review_severity = {}
         frame = Mock()
 
         birdseye.write_data(
             "front",
             [
                 {"stationary": True, "false_positive": True},
-                {"stationary": False, "false_positive": True},
                 {"stationary": True, "false_positive": False},
             ],
             [[0, 0, 10, 10]],
@@ -289,26 +330,36 @@ class TestBirdseyeActivity(unittest.TestCase):
         )
 
         birdseye.birdseye_manager.update.assert_called_once_with(
-            "front", BirdseyeActivity(True, True, True), 1.0, frame
+            "front",
+            BirdseyeActivity(has_object=True, has_motion=True, severity=None),
+            1.0,
+            frame,
         )
 
-    def test_stationary_false_positive_does_not_activate_birdseye(self):
+    def test_false_positives_do_not_count_as_objects(self):
         birdseye = Birdseye.__new__(Birdseye)
         birdseye.birdseye_manager = Mock()
         birdseye.birdseye_manager.update.return_value = (False, False)
         birdseye._idle_interval = None
+        birdseye.review_severity = {}
         frame = Mock()
 
         birdseye.write_data(
             "front",
-            [{"stationary": True, "false_positive": True}],
+            [
+                {"stationary": True, "false_positive": True},
+                {"stationary": False, "false_positive": True},
+            ],
             [],
             1.0,
             frame,
         )
 
         birdseye.birdseye_manager.update.assert_called_once_with(
-            "front", BirdseyeActivity(False, False, False), 1.0, frame
+            "front",
+            BirdseyeActivity(has_object=False, has_motion=False, severity=None),
+            1.0,
+            frame,
         )
 
 
@@ -318,7 +369,7 @@ class TestBirdseyeCameraOrder(unittest.TestCase):
     def setUp(self):
         config = {
             "mqtt": {"enabled": False},
-            "birdseye": {"enabled": True, "mode": {"continuous": True}},
+            "birdseye": {"enabled": True, "modes": ["continuous"]},
             "cameras": {
                 camera: {
                     "ffmpeg": {
@@ -340,6 +391,7 @@ class TestBirdseyeCameraOrder(unittest.TestCase):
             camera_data["current_frame"] = None
             camera_data["current_frame_time"] = 1.0
             camera_data["last_active_frame"] = 1.0
+            camera_data["live_active"] = True
 
     def layout_order(self) -> list[str]:
         """Return the cameras in the order the current layout renders them."""
@@ -377,3 +429,155 @@ class TestBirdseyeCameraOrder(unittest.TestCase):
 
         assert not layout_changed
         assert self.layout_order() == ["back", "front", "side"]
+
+
+class TestBirdseyeLiveActivity(unittest.TestCase):
+    """Test that live activity bypasses the inactivity threshold."""
+
+    def setUp(self):
+        config = {
+            "mqtt": {"enabled": False},
+            "birdseye": {
+                "enabled": True,
+                "modes": ["continuous"],
+                "inactivity_threshold": 30,
+            },
+            "cameras": {
+                camera: {
+                    "ffmpeg": {
+                        "inputs": [
+                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
+                        ]
+                    },
+                    "detect": {"height": 1080, "width": 1920, "fps": 5},
+                }
+                for camera in ("back", "front")
+            },
+        }
+        self.config = FrigateConfig(**config)
+        self.manager = BirdsEyeFrameManager(self.config, mp.Event())
+
+        for camera_data in self.manager.cameras.values():
+            camera_data["current_frame"] = None
+            camera_data["current_frame_time"] = 1000.0
+            camera_data["last_active_frame"] = 0.0
+            camera_data["live_active"] = False
+
+    def test_live_active_camera_is_shown_without_a_recent_active_frame(self):
+        self.manager.cameras["front"]["live_active"] = True
+
+        self.manager.update_frame()
+
+        assert self.manager.active_cameras == {"front"}
+
+    def test_live_active_camera_drops_out_immediately(self):
+        self.manager.cameras["front"]["live_active"] = True
+        self.manager.update_frame()
+        assert self.manager.active_cameras == {"front"}
+
+        self.manager.cameras["front"]["live_active"] = False
+        self.manager.update_frame()
+
+        assert self.manager.active_cameras == set()
+
+    def test_threshold_activity_lingers_then_expires(self):
+        self.manager.cameras["front"]["last_active_frame"] = 980.0
+        self.manager.update_frame()
+        assert self.manager.active_cameras == {"front"}
+
+        self.manager.cameras["front"]["last_active_frame"] = 960.0
+        self.manager.update_frame()
+
+        assert self.manager.active_cameras == set()
+
+    def test_max_cameras_ranks_live_active_cameras_first(self):
+        self.config.birdseye.layout.max_cameras = 1
+        self.manager.cameras["front"]["live_active"] = True
+        self.manager.cameras["back"]["last_active_frame"] = 995.0
+
+        self.manager.update_frame()
+
+        assert self.manager.active_cameras == {"front"}
+
+
+class TestBirdseyeModePayload(unittest.TestCase):
+    """Test the MQTT payload contract for Birdseye activity modes."""
+
+    def test_single_mode_round_trips(self):
+        modes = birdseye_modes_from_mqtt_payload("ALERTS")
+
+        assert modes == [BirdseyeModeEnum.alerts]
+        assert birdseye_modes_to_mqtt_payload(modes) == "ALERTS"
+
+    def test_combined_modes_are_published_in_enum_order(self):
+        modes = birdseye_modes_from_mqtt_payload("ALERTS,MOTION")
+
+        assert modes == [BirdseyeModeEnum.alerts, BirdseyeModeEnum.motion]
+        assert birdseye_modes_to_mqtt_payload(modes) == "MOTION,ALERTS"
+
+    def test_none_round_trips_to_an_empty_list(self):
+        assert birdseye_modes_from_mqtt_payload("NONE") == []
+        assert birdseye_modes_to_mqtt_payload([]) == "NONE"
+
+    def test_invalid_payloads_are_rejected(self):
+        for payload in (
+            "UNKNOWN",
+            "motion",
+            "MOTION_OBJECTS",
+            "NONE,MOTION",
+            "MOTION,MOTION",
+            "MOTION,",
+            "",
+        ):
+            with self.subTest(payload=payload):
+                assert birdseye_modes_from_mqtt_payload(payload) is None
+
+
+class TestBirdseyeReviewSeverity(unittest.TestCase):
+    """Test that review updates drive the per-camera severity map."""
+
+    def setUp(self):
+        self.birdseye = Birdseye.__new__(Birdseye)
+        self.birdseye.review_subscriber = Mock()
+        self.birdseye.review_severity = {}
+        self.birdseye.birdseye_manager = Mock()
+        self.birdseye.birdseye_manager.update.return_value = (False, False)
+        self.birdseye._idle_interval = None
+
+    def _drain(self, *updates):
+        self.birdseye.review_subscriber.check_for_update.side_effect = [*updates, None]
+        self.birdseye.check_review_updates()
+
+    def test_new_segment_sets_severity(self):
+        self._drain({"type": "new", "after": {"camera": "front", "severity": "alert"}})
+
+        assert self.birdseye.review_severity == {"front": "alert"}
+
+    def test_update_upgrades_severity(self):
+        self._drain(
+            {"type": "new", "after": {"camera": "front", "severity": "detection"}},
+            {"type": "update", "after": {"camera": "front", "severity": "alert"}},
+        )
+
+        assert self.birdseye.review_severity == {"front": "alert"}
+
+    def test_end_clears_severity(self):
+        self._drain(
+            {"type": "new", "after": {"camera": "front", "severity": "alert"}},
+            {"type": "end", "after": {"camera": "front", "severity": "alert"}},
+        )
+
+        assert self.birdseye.review_severity == {}
+
+    def test_write_data_passes_the_tracked_severity(self):
+        self.birdseye.review_severity = {"front": "alert"}
+        frame = Mock()
+
+        self.birdseye.write_data("front", [], [], 1.0, frame)
+
+        self.birdseye.birdseye_manager.update.assert_called_once_with(
+            "front",
+            BirdseyeActivity(has_object=False, has_motion=False, severity="alert"),
+            1.0,
+            frame,
+        )

frigate/test/test_config.py

@@ -8,7 +8,7 @@ import numpy as np
 from pydantic import ValidationError
 from ruamel.yaml.constructor import DuplicateKeyError
 
-from frigate.config import FrigateConfig, RetainModeEnum
+from frigate.config import BirdseyeModeEnum, FrigateConfig, RetainModeEnum
 from frigate.const import MODEL_CACHE_DIR
 from frigate.detectors import DetectorTypeEnum
 from frigate.util.builtin import deep_merge
@@ -171,7 +171,7 @@ class TestConfig(unittest.TestCase):
     def test_override_birdseye(self):
         config = {
             "mqtt": {"host": "mqtt"},
-            "birdseye": {"enabled": True, "mode": {"continuous": True}},
+            "birdseye": {"enabled": True, "modes": ["continuous"]},
             "cameras": {
                 "back": {
                     "ffmpeg": {
@@ -186,7 +186,7 @@ class TestConfig(unittest.TestCase):
                     },
                     "birdseye": {
                         "enabled": False,
-                        "mode": {"continuous": False, "motion": True},
+                        "modes": ["motion"],
                     },
                 }
             },
@@ -194,18 +194,16 @@ class TestConfig(unittest.TestCase):
 
         frigate_config = FrigateConfig(**config)
         assert not frigate_config.cameras["back"].birdseye.enabled
-        mode = frigate_config.cameras["back"].birdseye.mode
-        assert mode.motion
-        assert not mode.continuous
-        assert not mode.objects
-        assert not mode.stationary_objects
+        assert frigate_config.cameras["back"].birdseye.modes == [
+            BirdseyeModeEnum.motion
+        ]
 
     def test_override_birdseye_non_inheritable(self):
         config = {
             "mqtt": {"host": "mqtt"},
             "birdseye": {
                 "enabled": True,
-                "mode": {"continuous": True},
+                "modes": ["continuous"],
                 "height": 1920,
             },
             "cameras": {
@@ -229,109 +227,38 @@ class TestConfig(unittest.TestCase):
 
     def test_inherit_birdseye(self):
         config = {
-            "mqtt": {"host": "mqtt"},
-            "birdseye": {"enabled": True, "mode": {"continuous": True}},
-            "cameras": {
-                "back": {
-                    "ffmpeg": {
-                        "inputs": [
-                            {"path": "rtsp://10.0.0.1:554/video", "roles": ["detect"]}
-                        ]
-                    },
-                    "detect": {
-                        "height": 1080,
-                        "width": 1920,
-                        "fps": 5,
-                    },
-                }
-            },
+            **self.minimal,
+            "birdseye": {"enabled": True, "modes": ["continuous"]},
         }
 
         frigate_config = FrigateConfig(**config)
         assert frigate_config.cameras["back"].birdseye.enabled
-        mode = frigate_config.cameras["back"].birdseye.mode
-        assert mode.continuous
-        assert not mode.motion
-        assert not mode.objects
-        assert not mode.stationary_objects
+        assert frigate_config.cameras["back"].birdseye.modes == [
+            BirdseyeModeEnum.continuous
+        ]
 
-    def test_combine_birdseye_activity_types(self):
+    def test_camera_modes_replace_the_global_list(self):
+        """A camera list fully replaces the global one, it does not merge into it."""
         config = {
             **self.minimal,
-            "birdseye": {
-                "mode": {
-                    "motion": True,
-                    "stationary_objects": True,
-                }
-            },
+            "birdseye": {"modes": ["motion", "all_objects"]},
         }
+        config["cameras"]["back"]["birdseye"] = {"modes": ["alerts"]}
 
         frigate_config = FrigateConfig(**config)
-        mode = frigate_config.cameras["back"].birdseye.mode
-        assert mode.motion
-        assert mode.stationary_objects
-        assert not mode.continuous
-        assert not mode.objects
+        assert frigate_config.cameras["back"].birdseye.modes == [
+            BirdseyeModeEnum.alerts
+        ]
 
-    def test_birdseye_requires_an_activity_type(self):
+    def test_camera_can_select_no_modes(self):
         config = {
             **self.minimal,
-            "birdseye": {
-                "mode": {
-                    "continuous": False,
-                    "motion": False,
-                    "objects": False,
-                    "stationary_objects": False,
-                }
-            },
+            "birdseye": {"modes": ["motion"]},
         }
-
-        with self.assertRaisesRegex(
-            ValidationError, "must enable at least one Birdseye activity type"
-        ):
-            FrigateConfig(**config)
-
-    def test_camera_can_disable_an_inherited_activity_type(self):
-        config = {
-            **self.minimal,
-            "birdseye": {"mode": {"motion": True, "objects": True}},
-        }
-        config["cameras"]["back"]["birdseye"] = {"mode": {"motion": False}}
+        config["cameras"]["back"]["birdseye"] = {"modes": []}
 
         frigate_config = FrigateConfig(**config)
-        mode = frigate_config.cameras["back"].birdseye.mode
-        assert not mode.motion
-        assert mode.objects
-
-    def test_profile_must_leave_an_activity_type_enabled(self):
-        config = {
-            **self.minimal,
-            "profiles": {"away": {"friendly_name": "Away"}},
-            "birdseye": {"mode": {"objects": True}},
-        }
-        config["cameras"]["back"]["profiles"] = {
-            "away": {"birdseye": {"mode": {"objects": False}}}
-        }
-
-        with self.assertRaisesRegex(
-            ValidationError, "must enable at least one Birdseye activity type"
-        ):
-            FrigateConfig(**config)
-
-    def test_camera_birdseye_activity_types_override_global_values(self):
-        config = {
-            **self.minimal,
-            "birdseye": {"mode": {"motion": True, "objects": True}},
-        }
-        config["cameras"]["back"]["birdseye"] = {
-            "mode": {"motion": False, "stationary_objects": True}
-        }
-
-        frigate_config = FrigateConfig(**config)
-        mode = frigate_config.cameras["back"].birdseye.mode
-        assert not mode.motion
-        assert mode.objects
-        assert mode.stationary_objects
+        assert frigate_config.cameras["back"].birdseye.modes == []
 
     def test_override_tracked_objects(self):
         config = {

frigate/test/test_dispatcher_runtime_state.py

@@ -8,7 +8,7 @@ from unittest.mock import MagicMock, patch
 from frigate.app import FrigateApp
 from frigate.comms.dispatcher import Dispatcher
 from frigate.comms.runtime_state import RuntimeStatePersistence
-from frigate.config import BirdseyeModeConfig
+from frigate.config import BirdseyeModeEnum
 
 
 def _make_camera_mock(
@@ -53,7 +53,7 @@ def _build_dispatcher(cameras: dict[str, MagicMock]) -> Dispatcher:
 
 
 class TestBirdseyeModeCommands(unittest.TestCase):
-    """Verify Birdseye mode commands use the boolean mode contract."""
+    """Verify Birdseye mode commands use the activity list contract."""
 
     def setUp(self) -> None:
         self.camera = _make_camera_mock()
@@ -62,30 +62,33 @@ class TestBirdseyeModeCommands(unittest.TestCase):
         self.dispatcher.publish = MagicMock()
 
     def test_combined_modes_are_accepted(self) -> None:
-        self.dispatcher._on_birdseye_mode_command(
-            "front_door", "STATIONARY_OBJECTS,MOTION"
-        )
+        self.dispatcher._on_birdseye_modes_command("front_door", "ALERTS,MOTION")
 
         self.assertEqual(
-            self.camera.birdseye.mode,
-            BirdseyeModeConfig(motion=True, stationary_objects=True),
+            self.camera.birdseye.modes,
+            [BirdseyeModeEnum.alerts, BirdseyeModeEnum.motion],
         )
         self.dispatcher.config_updater.publish_update.assert_called_once()
         self.dispatcher.publish.assert_called_once_with(
-            "front_door/birdseye_mode/state",
-            "MOTION,STATIONARY_OBJECTS",
+            "front_door/birdseye_modes/state",
+            "MOTION,ALERTS",
             retain=True,
         )
 
     def test_single_activity_type_is_accepted(self) -> None:
-        self.dispatcher._on_birdseye_mode_command("front_door", "OBJECTS")
+        self.dispatcher._on_birdseye_modes_command("front_door", "ALL_OBJECTS")
 
-        self.assertEqual(
-            self.camera.birdseye.mode,
-            BirdseyeModeConfig(objects=True),
-        )
+        self.assertEqual(self.camera.birdseye.modes, [BirdseyeModeEnum.all_objects])
         self.dispatcher.publish.assert_called_once_with(
-            "front_door/birdseye_mode/state", "OBJECTS", retain=True
+            "front_door/birdseye_modes/state", "ALL_OBJECTS", retain=True
+        )
+
+    def test_none_clears_every_activity_type(self) -> None:
+        self.dispatcher._on_birdseye_modes_command("front_door", "NONE")
+
+        self.assertEqual(self.camera.birdseye.modes, [])
+        self.dispatcher.publish.assert_called_once_with(
+            "front_door/birdseye_modes/state", "NONE", retain=True
         )
 
     def test_unknown_mode_is_rejected(self) -> None:
@@ -93,13 +96,12 @@ class TestBirdseyeModeCommands(unittest.TestCase):
             "UNKNOWN",
             "motion",
             "MOTION_OBJECTS",
-            "NONE",
             "NONE,MOTION",
             "MOTION,MOTION",
             "MOTION,",
         ):
             with self.subTest(payload=payload):
-                self.dispatcher._on_birdseye_mode_command("front_door", payload)
+                self.dispatcher._on_birdseye_modes_command("front_door", payload)
 
         self.dispatcher.config_updater.publish_update.assert_not_called()
 

frigate/test/test_profiles.py

@@ -6,7 +6,7 @@ import os
 import unittest
 from unittest.mock import MagicMock, patch
 
-from frigate.config import FrigateConfig
+from frigate.config import BirdseyeModeEnum, FrigateConfig
 from frigate.config.camera.profile import CameraProfileConfig
 from frigate.config.profile import ProfileDefinitionConfig
 from frigate.config.profile_manager import PERSISTENCE_FILE, ProfileManager
@@ -561,23 +561,22 @@ class TestProfileManager(unittest.TestCase):
         assert self.config.cameras["front"].enabled is False
 
     @patch.object(ProfileManager, "_persist_active_profile")
-    def test_profile_can_disable_inherited_birdseye_activity(self, mock_persist):
-        """A false-only mode override inherits the other base activity types."""
+    def test_profile_replaces_birdseye_activity_modes(self, mock_persist):
+        """A profile mode list replaces the base list rather than merging into it."""
         self.config.profiles["away"] = ProfileDefinitionConfig(friendly_name="Away")
-        base_mode = self.config.cameras["front"].birdseye.mode
-        base_mode.motion = True
-        base_mode.objects = True
+        self.config.cameras["front"].birdseye.modes = [
+            BirdseyeModeEnum.motion,
+            BirdseyeModeEnum.all_objects,
+        ]
         self.config.cameras["front"].profiles["away"] = CameraProfileConfig(
-            birdseye={"mode": {"motion": False}}
+            birdseye={"modes": ["alerts"]}
         )
         self.manager = ProfileManager(self.config, self.mock_updater)
 
         err = self.manager.activate_profile("away")
 
         assert err is None
-        mode = self.config.cameras["front"].birdseye.mode
-        assert not mode.motion
-        assert mode.objects
+        assert self.config.cameras["front"].birdseye.modes == [BirdseyeModeEnum.alerts]
 
     @patch.object(ProfileManager, "_persist_active_profile")
     def test_deactivate_restores_enabled(self, mock_persist):

frigate/test/test_record_cleanup_sub.py

@@ -49,14 +49,19 @@ class TestRecordingCleanupSubRetention(unittest.TestCase):
         return RecordingCleanup(config, MagicMock())
 
     def _insert_recording(
-        self, id: str, stream_type: str, age_days: float, motion: int = 0
+        self,
+        id: str,
+        stream_type: str,
+        age_days: float,
+        motion: int = 0,
+        camera: str = "front_door",
     ) -> None:
         end_time = (
             datetime.datetime.now() - datetime.timedelta(days=age_days)
         ).timestamp()
         Recordings.create(
             id=id,
-            camera="front_door",
+            camera=camera,
             path=f"/media/frigate/recordings/{id}.mp4",
             start_time=end_time - 10,
             end_time=end_time,
@@ -208,3 +213,41 @@ class TestRecordingCleanupSubRetention(unittest.TestCase):
 
         assert Recordings.get_or_none(Recordings.id == "s_old") is None
         assert Recordings.get_or_none(Recordings.id == "s_new") is not None
+
+    def test_deleted_camera_recordings_expire(self):
+        # rows for a camera no longer in the config expire by the GLOBAL
+        # record retention window; newer orphan rows and configured-camera
+        # rows are untouched by the deleted-cameras sweep
+        config = FrigateConfig(
+            **{
+                "mqtt": {"host": "mqtt"},
+                "record": {"continuous": {"days": 7}},
+                "cameras": {
+                    "front_door": {
+                        "ffmpeg": {
+                            "inputs": [
+                                {
+                                    "path": "rtsp://10.0.0.1:554/video",
+                                    "roles": ["detect", "record"],
+                                },
+                            ]
+                        },
+                        "record": {"enabled": True, "continuous": {"days": 7}},
+                    }
+                },
+            }
+        )
+        cleanup = RecordingCleanup(config, MagicMock())
+        self._insert_recording("gone_old", "main", 10, camera="removed_cam")
+        self._insert_recording("gone_new", "main", 5, camera="removed_cam")
+        self._insert_recording("gone_blank", "main", 10, camera="")
+        self._insert_recording("kept", "main", 5)
+
+        cleanup.expire_recordings()
+
+        assert Recordings.get_or_none(Recordings.id == "gone_old") is None
+        assert Recordings.get_or_none(Recordings.id == "gone_new") is not None
+        # empty-string camera names sort before every real name and must
+        # still be enumerated by the sweep
+        assert Recordings.get_or_none(Recordings.id == "gone_blank") is None
+        assert Recordings.get_or_none(Recordings.id == "kept") is not None

frigate/test/test_recording_coverage.py

@@ -303,3 +303,74 @@ class TestVodManifestPolicy(CoverageDbTestCase):
         mapping = self._mapping(1000.0, 1020.0, stream="sub")
         assert mapping["discontinuity"] is False
         assert "initialClipIndex" not in mapping
+
+
+class TestClipKeyFrames(unittest.TestCase):
+    """Keyframe data emitted for nginx-vod segmentation."""
+
+    def _row(self, keyframes):
+        return SimpleNamespace(
+            path="/tmp/kf.mp4",
+            start_time=1000.0,
+            end_time=1010.0,
+            duration=10.0,
+            keyframes=keyframes,
+        )
+
+    def test_whole_file_clip_emits_keyframe_gaps(self):
+        keyframes = [0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000]
+        plan = plan_clip(self._row(keyframes), 1000.0, 1010.0)
+        assert plan.clip_from_ms is None
+        assert plan.key_frame_durations == [1000] * 9
+        assert plan.first_key_frame_offset_ms == 0
+
+    def test_mid_file_clip_offsets_are_clip_relative(self):
+        # start 3.5s in: clipFrom snaps back to the 3000ms keyframe, so
+        # the emitted offsets must be relative to that snapped start
+        keyframes = [0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000]
+        plan = plan_clip(self._row(keyframes), 1003.5, 1010.0)
+        assert plan.clip_from_ms == 3000
+        assert plan.duration_ms == 7000
+        assert plan.key_frame_durations == [1000] * 6
+        assert plan.first_key_frame_offset_ms == 0
+
+    def test_no_index_reports_none(self):
+        plan = plan_clip(self._row(None), 1000.0, 1010.0)
+        assert plan.key_frame_durations is None
+
+    def test_single_keyframe_in_range_reports_none(self):
+        # one cut point cannot split anything; the manifest falls back
+        # to a whole-clip declaration
+        plan = plan_clip(self._row([0]), 1000.0, 1010.0)
+        assert plan.key_frame_durations is None
+
+    def test_keyframe_on_clip_end_excluded(self):
+        # a keyframe landing exactly on the clip end would only declare
+        # a zero-length tail segment
+        plan = plan_clip(self._row([0, 5000, 10000]), 1000.0, 1010.0)
+        assert plan.key_frame_durations == [5000]
+
+
+class TestVodManifestKeyFrames(CoverageDbTestCase):
+    """Mapping emission of real vs placeholder keyFrameDurations."""
+
+    def _clips(self, start, end):
+        response = asyncio.run(_vod_response("front_door", start, end))
+        return json.loads(response.body)["sequences"][0]["clips"]
+
+    def test_indexed_row_emits_real_gaps(self):
+        self._insert(
+            "m1",
+            1000.0,
+            1010.0,
+            "main",
+            keyframes=[0, 2000, 4000, 6000, 8000],
+        )
+        clips = self._clips(1000.0, 1010.0)
+        assert clips[0]["keyFrameDurations"] == [2000, 2000, 2000, 2000]
+        assert "firstKeyFrameOffset" not in clips[0]
+
+    def test_unindexed_row_keeps_whole_clip_placeholder(self):
+        self._insert("m1", 1000.0, 1010.0, "main")
+        clips = self._clips(1000.0, 1010.0)
+        assert clips[0]["keyFrameDurations"] == [10000]

frigate/test/test_storage.py

@@ -139,6 +139,41 @@ class TestHttp(unittest.TestCase):
             "front_door": {"bandwidth": 0, "needs_refresh": True},
         }
 
+    def test_segment_calculations_with_recent_zero_segments(self):
+        """A run of recent zero-size segments must not zero out the bandwidth.
+
+        Older nonzero segments still describe the camera's real write rate.
+        """
+        config = FrigateConfig(**self.minimal_config)
+        storage = StorageMaintainer(config, MagicMock())
+
+        time_keep = datetime.datetime.now().timestamp()
+        for i in range(10):
+            _insert_mock_recording(
+                f"nonzero_{i}.frontdoor",
+                os.path.join(self.test_dir, f"nonzero_{i}.tmp"),
+                time_keep + i * 10,
+                time_keep + i * 10 + 10,
+                camera="front_door",
+                seg_size=4,
+                seg_dur=10,
+            )
+        for i in range(100):
+            _insert_mock_recording(
+                f"zero_{i}.frontdoor",
+                os.path.join(self.test_dir, f"zero_{i}.tmp"),
+                time_keep + 1000 + i * 10,
+                time_keep + 1000 + i * 10 + 10,
+                camera="front_door",
+                seg_size=0,
+                seg_dur=10,
+            )
+
+        storage.calculate_camera_bandwidth()
+        assert storage.camera_storage_stats == {
+            "front_door": {"bandwidth": 1440, "needs_refresh": True},
+        }
+
     def test_storage_cleanup(self):
         """Ensure that all recordings are cleaned up when necessary."""
         config = FrigateConfig(**self.minimal_config)

frigate/util/config.py

@@ -533,19 +533,26 @@ def _convert_legacy_mask_to_dict(
     return result
 
 
+# the 0.18 scalar Birdseye modes, mapped to their activity mode names
+_LEGACY_BIRDSEYE_MODES = {
+    "continuous": "continuous",
+    "motion": "motion",
+    "objects": "all_objects",
+}
+
+
 def _migrate_birdseye_mode(birdseye: dict[str, Any] | None) -> None:
-    """Convert a scalar Birdseye mode to composable activity types."""
+    """Convert a scalar Birdseye mode to an activity mode list."""
     if not birdseye or not isinstance(birdseye.get("mode"), str):
         return
 
     legacy_mode = birdseye["mode"]
-    activity_types = ("continuous", "motion", "objects", "stationary_objects")
-    if legacy_mode not in activity_types:
+
+    if legacy_mode not in _LEGACY_BIRDSEYE_MODES:
         return
 
-    birdseye["mode"] = {
-        activity_type: activity_type == legacy_mode for activity_type in activity_types
-    }
+    del birdseye["mode"]
+    birdseye["modes"] = [_LEGACY_BIRDSEYE_MODES[legacy_mode]]
 
 
 def migrate_018_0(config: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:

frigate/util/recording_coverage.py

@@ -310,11 +310,18 @@ class ClipPlan:
 
     clip_from_ms is the keyframe-snapped clipFrom, or None when the whole
     file is served. skipped means the clip is omitted from the manifest.
+
+    key_frame_durations / first_key_frame_offset_ms carry clip-relative
+    keyframe data for nginx-vod sub-file segmentation; None means no
+    usable index, and the manifest declares one whole-clip segment (the
+    only safe cut without keyframe knowledge).
     """
 
     clip_from_ms: int | None
     duration_ms: int
     skipped: bool
+    key_frame_durations: list[int] | None = None
+    first_key_frame_offset_ms: int = 0
 
 
 def plan_clip(row: Any, start: float, end: float) -> ClipPlan:
@@ -378,7 +385,38 @@ def plan_clip(row: Any, start: float, end: float) -> ClipPlan:
         logger.warning(f"Recording clip is missing or empty: {row.path}")
         return ClipPlan(None, 0, True)
 
-    return ClipPlan(clip_from, duration, False)
+    return ClipPlan(
+        clip_from,
+        duration,
+        False,
+        *_clip_key_frames(row.keyframes, clip_from, duration),
+    )
+
+
+def _clip_key_frames(
+    keyframes: Any, clip_from: int | None, duration: int
+) -> tuple[list[int] | None, int]:
+    """Clip-relative keyframe gaps and first offset for a served range.
+
+    nginx-vod validates firstKeyFrameOffset against the clip duration,
+    so offsets are clip-relative. A keyframe exactly on the clip end is
+    excluded (it would declare a zero-length tail), and fewer than two
+    keyframes returns (None, 0): one cut point cannot split anything.
+    """
+    if not keyframes:
+        return None, 0
+
+    clip_start = clip_from if clip_from is not None else 0
+    relative = [
+        int(k) - clip_start
+        for k in keyframes
+        if clip_start <= k < clip_start + duration
+    ]
+
+    if len(relative) < 2:
+        return None, 0
+
+    return [b - a for a, b in zip(relative, relative[1:])], relative[0]
 
 
 def realized_timeline(

migrations/037_add_recordings_stream_index.py

@@ -0,0 +1,43 @@
+"""Peewee migrations -- 037_add_recordings_stream_index.py.
+
+Some examples (model - class or model name)::
+
+    > Model = migrator.orm['model_name']            # Return model in current state by name
+
+    > migrator.sql(sql)                             # Run custom SQL
+    > migrator.python(func, *args, **kwargs)        # Run python code
+    > migrator.create_model(Model)                  # Create a model (could be used as decorator)
+    > migrator.remove_model(model, cascade=True)    # Remove a model
+    > migrator.add_fields(model, **fields)          # Add fields to a model
+    > migrator.change_fields(model, **fields)       # Change fields
+    > migrator.remove_fields(model, *field_names, cascade=True)
+    > migrator.rename_field(model, old_field_name, new_field_name)
+    > migrator.rename_table(model, new_table_name)
+    > migrator.add_index(model, *col_names, unique=False)
+    > migrator.drop_index(model, *col_names)
+    > migrator.add_not_null(model, *field_names)
+    > migrator.drop_not_null(model, *field_names)
+    > migrator.add_default(model, field_name, default)
+
+"""
+
+import peewee as pw
+
+SQL = pw.SQL
+
+
+def migrate(migrator, database, fake=False, **kwargs):
+    # time-ordered per-stream lookups (bandwidth estimation, pinned-stream
+    # queries) need this ordering; without it, a per-stream ORDER BY
+    # start_time query on a camera with no rows for that stream walks the
+    # camera's entire history via per-row table lookups
+    migrator.sql(
+        'CREATE INDEX IF NOT EXISTS "recordings_camera_stream_type_start_time" ON "recordings" ("camera", "stream_type", "start_time" DESC)'
+    )
+    # the 036 index is a strict prefix of the one above, so keeping it
+    # would only add write amplification on the hottest table
+    migrator.sql('DROP INDEX IF EXISTS "recordings_camera_stream_type"')
+
+
+def rollback(migrator, database, fake=False, **kwargs):
+    pass

web/public/locales/en/config/cameras.json

@@ -70,25 +70,9 @@
       "label": "Enable Birdseye",
       "description": "Enable or disable the Birdseye view feature."
     },
-    "mode": {
+    "modes": {
       "label": "Activity types",
-      "description": "Activity types that include cameras in Birdseye.",
-      "continuous": {
-        "label": "Continuous",
-        "description": "Always include the camera in Birdseye."
-      },
-      "motion": {
-        "label": "Motion",
-        "description": "Include the camera in Birdseye when motion is detected."
-      },
-      "objects": {
-        "label": "Active objects",
-        "description": "Include the camera in Birdseye while an active object is tracked."
-      },
-      "stationary_objects": {
-        "label": "Stationary objects",
-        "description": "Include the camera in Birdseye while a stationary object is tracked."
-      }
+      "description": "Activity types that include cameras in Birdseye."
     },
     "order": {
       "label": "Position",

web/public/locales/en/config/global.json

@@ -557,25 +557,9 @@
       "label": "Enable Birdseye",
       "description": "Enable or disable the Birdseye view feature."
     },
-    "mode": {
+    "modes": {
       "label": "Activity types",
-      "description": "Activity types that include cameras in Birdseye.",
-      "continuous": {
-        "label": "Continuous",
-        "description": "Always include the camera in Birdseye."
-      },
-      "motion": {
-        "label": "Motion",
-        "description": "Include the camera in Birdseye when motion is detected."
-      },
-      "objects": {
-        "label": "Active objects",
-        "description": "Include the camera in Birdseye while an active object is tracked."
-      },
-      "stationary_objects": {
-        "label": "Stationary objects",
-        "description": "Include the camera in Birdseye while a stationary object is tracked."
-      }
+      "description": "Activity types that include cameras in Birdseye."
     },
     "restream": {
       "label": "Restream RTSP",

web/public/locales/en/views/settings.json

@@ -1657,6 +1657,16 @@
       "summary": "{{count}} selected",
       "empty": "No zones available"
     },
+    "birdseyeModes": {
+      "summary": "{{count}} selected",
+      "options": {
+        "continuous": "Continuous",
+        "motion": "Motion",
+        "all_objects": "All objects",
+        "alerts": "Alerts",
+        "detections": "Detections"
+      }
+    },
     "inputRoles": {
       "summary": "{{count}} roles selected",
       "empty": "No roles available",
@@ -1856,11 +1866,6 @@
     }
   },
   "birdseye": {
-    "trackingMode": {
-      "objects": "Objects",
-      "motion": "Motion",
-      "continuous": "Continuous"
-    },
     "cameraOrder": {
       "label": "Camera order",
       "description": "Drag cameras to set their order in the Birdseye layout.",

web/src/components/config-form/section-configs/birdseye.ts

@@ -10,29 +10,26 @@ const birdseye: SectionConfigOverrides = {
         severity: "info",
         condition: (ctx) => {
           if (ctx.level !== "camera" || !ctx.fullCameraConfig) return false;
-          const mode = ctx.formData?.mode;
-          if (!mode || typeof mode !== "object" || Array.isArray(mode)) {
+          const modes = ctx.formData?.modes;
+          if (!Array.isArray(modes)) {
             return false;
           }
 
           return (
-            (mode.objects === true || mode.stationary_objects === true) &&
+            modes.includes("all_objects") &&
             ctx.fullCameraConfig.detect?.enabled === false
           );
         },
       },
     ],
     restartRequired: [],
-    fieldOrder: ["enabled", "mode", "order"],
+    fieldOrder: ["enabled", "modes", "order"],
     hiddenFields: ["order"],
     advancedFields: [],
-    overrideFields: ["enabled", "mode"],
+    overrideFields: ["enabled", "modes"],
     uiSchema: {
-      mode: {
-        continuous: { "ui:size": "xs" },
-        motion: { "ui:size": "xs" },
-        objects: { "ui:size": "xs" },
-        stationary_objects: { "ui:size": "xs" },
+      modes: {
+        "ui:widget": "birdseyeModes",
       },
     },
   },
@@ -43,7 +40,7 @@ const birdseye: SectionConfigOverrides = {
       "width",
       "height",
       "quality",
-      "mode",
+      "modes",
       "layout",
       "inactivity_threshold",
       "idle_heartbeat_fps",
@@ -59,7 +56,7 @@ const birdseye: SectionConfigOverrides = {
       "idle_heartbeat_fps",
     ],
     uiSchema: {
-      mode: {
+      modes: {
         "ui:after": { render: "BirdseyeCameraReorder" },
       },
     },

web/src/components/config-form/theme/frigateTheme.ts

@@ -22,6 +22,7 @@ import { ObjectLabelSwitchesWidget } from "./widgets/ObjectLabelSwitchesWidget";
 import { AudioLabelSwitchesWidget } from "./widgets/AudioLabelSwitchesWidget";
 import { ReviewLabelSwitchesWidget } from "./widgets/ReviewLabelSwitchesWidget";
 import { ZoneSwitchesWidget } from "./widgets/ZoneSwitchesWidget";
+import { BirdseyeModesWidget } from "./widgets/BirdseyeModesWidget";
 import { ArrayAsTextWidget } from "./widgets/ArrayAsTextWidget";
 import { FfmpegArgsWidget } from "./widgets/FfmpegArgsWidget";
 import { GenAIModelWidget } from "./widgets/GenAIModelWidget";
@@ -87,6 +88,7 @@ export const frigateTheme: FrigateTheme = {
     audioLabels: AudioLabelSwitchesWidget,
     reviewLabels: ReviewLabelSwitchesWidget,
     zoneNames: ZoneSwitchesWidget,
+    birdseyeModes: BirdseyeModesWidget,
     timezoneSelect: TimezoneSelectWidget,
     optionalField: OptionalFieldWidget,
     semanticSearchModel: SemanticSearchModelWidget,

web/src/components/config-form/theme/widgets/BirdseyeModesWidget.tsx

@@ -0,0 +1,44 @@
+// Birdseye Modes Widget - For selecting Birdseye activity types via switches
+import type { WidgetProps } from "@rjsf/utils";
+import { SwitchesWidget } from "./SwitchesWidget";
+import type { FormContext } from "./SwitchesWidget";
+
+// order matches BirdseyeModeEnum in frigate/config/camera/birdseye.py
+const BIRDSEYE_MODES: string[] = [
+  "continuous",
+  "motion",
+  "all_objects",
+  "alerts",
+  "detections",
+];
+
+function getBirdseyeModes(): string[] {
+  return BIRDSEYE_MODES;
+}
+
+function getBirdseyeModeLabel(mode: string, context?: FormContext): string {
+  const t = context?.t;
+
+  if (!t) {
+    return mode;
+  }
+
+  return t(`configForm.birdseyeModes.options.${mode}`, {
+    ns: "views/settings",
+    defaultValue: mode,
+  });
+}
+
+export function BirdseyeModesWidget(props: WidgetProps) {
+  return (
+    <SwitchesWidget
+      {...props}
+      options={{
+        ...props.options,
+        getEntities: getBirdseyeModes,
+        getDisplayLabel: getBirdseyeModeLabel,
+        i18nKey: "birdseyeModes",
+      }}
+    />
+  );
+}

web/src/components/player/dynamic/DynamicVideoPlayer.tsx

@@ -45,6 +45,16 @@ import { useUserPersistence } from "@/hooks/use-user-persistence";
 // a longer buffer cheap and it rides out connection variance better
 const SUB_STREAM_BUFFER_LENGTH_S = 30;
 
+// seeks rebuild the source starting at the seek target so the vod
+// bootstrap segment ladder applies to every seek; quantizing keeps
+// seek URLs repeatable for nginx's mapping/response caches
+const SOURCE_START_GRID_S = 10;
+
+// seeks beyond this bridge the source load with the preview player (the
+// held video frame is pre-seek content); continuations (quality switch,
+// natural chunk advance) keep the held frame
+const REPOSITION_PREVIEW_THRESHOLD_S = 2;
+
 /**
  * Dynamically switches between video playback and scrubbing preview player.
  */
@@ -157,6 +167,11 @@ export default function DynamicVideoPlayer({
 
   useEffect(() => {
     if (!isScrubbing) {
+      // never overwrite a pending timer: an orphaned one escapes
+      // onPlaying's clearTimeout and flashes loading mid-playback
+      if (loadingTimeoutRef.current) {
+        clearTimeout(loadingTimeoutRef.current);
+      }
       loadingTimeoutRef.current = setTimeout(() => setIsLoading(true), 1000);
     }
 
@@ -179,6 +194,85 @@ export default function DynamicVideoPlayer({
   // playlist, so the playback effect skips its loading indicator
   const modelOnlyUpdateRef = useRef(false);
 
+  // re-anchors quality-switch rebuilds and classifies rebuilds as
+  // repositioning vs continuation
+  const lastPlayedTimestampRef = useRef<number | undefined>(undefined);
+
+  // start of the current source window within the chunk; undefined plays
+  // from the chunk start. Follows explicit seeks (startTimestamp),
+  // cleared when a chunk change leaves the seek target behind
+  const [sourceAfter, setSourceAfter] = useState<number | undefined>(undefined);
+
+  // adjusted during render: an effect lands one commit late, briefly
+  // painting the stale video frame between drag preview and load bridge
+  const nextSourceAfter =
+    startTimestamp !== undefined &&
+    startTimestamp > timeRange.after &&
+    startTimestamp < timeRange.before
+      ? Math.max(
+          timeRange.after,
+          Math.floor(startTimestamp / SOURCE_START_GRID_S) *
+            SOURCE_START_GRID_S,
+        )
+      : undefined;
+
+  if (nextSourceAfter !== sourceAfter) {
+    setSourceAfter(nextSourceAfter);
+
+    const lastPlayed = lastPlayedTimestampRef.current;
+    if (
+      !isLoading &&
+      startTimestamp !== undefined &&
+      lastPlayed !== undefined &&
+      Math.abs(startTimestamp - lastPlayed) > REPOSITION_PREVIEW_THRESHOLD_S
+    ) {
+      setIsLoading(true);
+    }
+  }
+
+  // the release anchor lands one commit after isScrubbing flips false
+  // (the view writes playbackStart from an effect), which would flash
+  // the stale frame; hold one commit. The clearing effect runs before
+  // the parent's release effect, so clear and anchor batch into one render
+  const [releaseHold, setReleaseHold] = useState(false);
+  const [wasScrubbing, setWasScrubbing] = useState(isScrubbing);
+
+  if (isScrubbing !== wasScrubbing) {
+    setWasScrubbing(isScrubbing);
+    if (!isScrubbing) {
+      setReleaseHold(true);
+    }
+  }
+
+  useEffect(() => {
+    if (releaseHold) {
+      setReleaseHold(false);
+    }
+  }, [releaseHold]);
+
+  const recordingParams = useMemo(
+    () => ({
+      before: timeRange.before,
+      // clamp: during the adjust-render pass this memo can evaluate with
+      // the previous sourceAfter against a new timeRange
+      after:
+        sourceAfter !== undefined &&
+        sourceAfter > timeRange.after &&
+        sourceAfter < timeRange.before
+          ? sourceAfter
+          : timeRange.after,
+      timelines: true,
+    }),
+    [timeRange, sourceAfter],
+  );
+
+  // the window the current source covers; the seek model, in-range
+  // checks, and stale-report guard use this, not the chunk timeRange
+  const sourceTimeRange = useMemo<TimeRange>(
+    () => ({ after: recordingParams.after, before: recordingParams.before }),
+    [recordingParams],
+  );
+
   const onPlayerLoaded = useCallback(() => {
     sourceLoadedRef.current = true;
     governorRef.current?.sourceLoadEnded();
@@ -189,9 +283,9 @@ export default function DynamicVideoPlayer({
       return;
     }
 
-    // an anchor outside this chunk is stale (e.g. a natural clip
+    // an anchor outside this source window is stale (e.g. a natural clip
     // advance); the playlist already starts where playback should
-    if (anchor < timeRange.after || anchor > timeRange.before) {
+    if (anchor < sourceTimeRange.after || anchor > sourceTimeRange.before) {
       return;
     }
 
@@ -199,11 +293,7 @@ export default function DynamicVideoPlayer({
     // start it: a mid-drag chunk prefetch can audibly blip before
     // onPlaying pauses it. The release seek starts playback
     controller.seekToTimestamp(anchor, !isScrubbing);
-  }, [controller, timeRange, isScrubbing]);
-
-  // used to re-anchor the source when an auto quality switch rebuilds
-  // the playlist mid-playback
-  const lastPlayedTimestampRef = useRef<number | undefined>(undefined);
+  }, [controller, sourceTimeRange, isScrubbing]);
 
   // the range the controller's playback model was last built for; while
   // a chunk change awaits its coverage, the outgoing source reports
@@ -223,10 +313,10 @@ export default function DynamicVideoPlayer({
         return;
       }
 
-      // drop reports until the controller's model matches this chunk
+      // drop reports until the controller's model matches this source
       if (
-        modelTimeRangeRef.current?.after !== timeRange.after ||
-        modelTimeRangeRef.current?.before !== timeRange.before
+        modelTimeRangeRef.current?.after !== sourceTimeRange.after ||
+        modelTimeRangeRef.current?.before !== sourceTimeRange.before
       ) {
         return;
       }
@@ -249,7 +339,7 @@ export default function DynamicVideoPlayer({
       isBuffering,
       isLoading,
       isScrubbing,
-      timeRange,
+      sourceTimeRange,
     ],
   );
 
@@ -310,14 +400,6 @@ export default function DynamicVideoPlayer({
 
   // state of playback player
 
-  const recordingParams = useMemo(
-    () => ({
-      before: timeRange.before,
-      after: timeRange.after,
-      timelines: true,
-    }),
-    [timeRange],
-  );
   const { data: coverage } = useSWR<RecordingCoverage>(
     [`${camera}/recordings/coverage`, recordingParams],
     { revalidateOnFocus: false },
@@ -628,8 +710,8 @@ export default function DynamicVideoPlayer({
     const anchorTimestamp =
       qualityChanged &&
       lastPlayed !== undefined &&
-      lastPlayed >= timeRange.after &&
-      lastPlayed <= timeRange.before
+      lastPlayed >= recordingParams.after &&
+      lastPlayed <= recordingParams.before
         ? lastPlayed
         : startTimestamp;
     sourceAnchorRef.current = anchorTimestamp;
@@ -679,6 +761,10 @@ export default function DynamicVideoPlayer({
       HTMLMediaElement.HAVE_CURRENT_DATA;
 
     if (!modelOnlyUpdate) {
+      // an overwritten pending timer would escape onPlaying's clearTimeout
+      if (loadingTimeoutRef.current) {
+        clearTimeout(loadingTimeoutRef.current);
+      }
       loadingTimeoutRef.current = setTimeout(
         () => (hasDecodedFrame ? setIsBuffering(true) : setIsLoading(true)),
         1000,
@@ -687,9 +773,9 @@ export default function DynamicVideoPlayer({
 
     controller.newPlayback({
       recordings: recordings ?? [],
-      timeRange,
+      timeRange: sourceTimeRange,
     });
-    modelTimeRangeRef.current = timeRange;
+    modelTimeRangeRef.current = sourceTimeRange;
 
     // we only want this to change when controller or recordings update
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -733,7 +819,7 @@ export default function DynamicVideoPlayer({
         <HlsVideoPlayer
           videoRef={playerRef}
           containerRef={containerRef}
-          visible={!(isScrubbing || isLoading)}
+          visible={!(isScrubbing || isLoading || releaseHold)}
           currentSource={source}
           hotKeys={hotKeys}
           supportsFullscreen={supportsFullscreen}
@@ -788,7 +874,7 @@ export default function DynamicVideoPlayer({
       <PreviewPlayer
         className={cn(
           className,
-          isScrubbing || isLoading ? "visible" : "hidden",
+          isScrubbing || isLoading || releaseHold ? "visible" : "hidden",
         )}
         camera={camera}
         timeRange={timeRange}

web/src/hooks/use-config-override.ts

@@ -480,7 +480,7 @@ export const OVERRIDABLE_SECTIONS: ReadonlyArray<{
     key: "audio_transcription",
     compareFields: ["enabled", "live_enabled"],
   },
-  { key: "birdseye", compareFields: ["enabled", "mode"] },
+  { key: "birdseye", compareFields: ["enabled", "modes"] },
   { key: "face_recognition", compareFields: ["enabled", "min_area"] },
   {
     key: "ffmpeg",

web/src/types/frigateConfig.ts

@@ -13,18 +13,18 @@ export interface UiConfig {
 export interface BirdseyeConfig {
   enabled: boolean;
   height: number;
-  mode: BirdseyeModeConfig;
+  modes: BirdseyeMode[];
   quality: number;
   restream: boolean;
   width: number;
 }
 
-export interface BirdseyeModeConfig {
-  continuous: boolean;
-  motion: boolean;
-  objects: boolean;
-  stationary_objects: boolean;
-}
+export type BirdseyeMode =
+  | "continuous"
+  | "motion"
+  | "all_objects"
+  | "alerts"
+  | "detections";
 
 export interface FaceRecognitionConfig {
   enabled: boolean;
@@ -56,7 +56,7 @@ export interface CameraConfig {
   best_image_timeout: number;
   birdseye: {
     enabled: boolean;
-    mode: BirdseyeModeConfig;
+    modes: BirdseyeMode[];
     order: number;
   };
   detect: {