Add Camera Wizard

frigate/api/app.py

@@ -43,6 +43,7 @@
     update_yaml_file_bulk,
 )
 from frigate.util.config import find_config_file
+from frigate.util.image import run_ffmpeg_snapshot
 from frigate.util.services import (
     ffprobe_stream,
     get_nvidia_driver_info,
@@ -107,6 +108,80 @@
     return JSONResponse(content=stream_data)
 
 
+@router.put(
+    "/go2rtc/streams/{stream_name}", dependencies=[Depends(require_role(["admin"]))]
+)
+def go2rtc_add_stream(request: Request, stream_name: str, src: str = ""):
+    """Add or update a go2rtc stream configuration."""
+    try:
+        params = {"name": stream_name}
+        if src:
+            params["src"] = src
+
+        r = requests.put(
+            "http://127.0.0.1:1984/api/streams",
+            params=params,
+            timeout=10,
+        )
+        if not r.ok:
+            logger.error(f"Failed to add go2rtc stream {stream_name}: {r.text}")
+            return JSONResponse(
+                content=(
+                    {"success": False, "message": f"Failed to add stream: {r.text}"}
+                ),
+                status_code=r.status_code,
+            )
+        return JSONResponse(
+            content={"success": True, "message": "Stream added successfully"}
+        )
+    except requests.RequestException as e:
+        logger.error(f"Error communicating with go2rtc: {e}")
+        return JSONResponse(
+            content=(
+                {
+                    "success": False,
+                    "message": f"Error communicating with go2rtc: {str(e)}",
+                }
+            ),
+            status_code=500,
+        )
+
+
+@router.delete(
+    "/go2rtc/streams/{stream_name}", dependencies=[Depends(require_role(["admin"]))]
+)
+def go2rtc_delete_stream(stream_name: str):
+    """Delete a go2rtc stream."""
+    try:
+        r = requests.delete(
+            "http://127.0.0.1:1984/api/streams",
+            params={"src": stream_name},
+            timeout=10,
+        )
+        if not r.ok:
+            logger.error(f"Failed to delete go2rtc stream {stream_name}: {r.text}")
+            return JSONResponse(
+                content=(
+                    {"success": False, "message": f"Failed to delete stream: {r.text}"}
+                ),
+                status_code=r.status_code,
+            )
+        return JSONResponse(
+            content={"success": True, "message": "Stream deleted successfully"}
+        )
+    except requests.RequestException as e:
+        logger.error(f"Error communicating with go2rtc: {e}")
+        return JSONResponse(
+            content=(
+                {
+                    "success": False,
+                    "message": f"Error communicating with go2rtc: {str(e)}",
+                }
+            ),
+            status_code=500,
+        )
+
+
 @router.get("/version", response_class=PlainTextResponse)
 def version():
     return VERSION
@@ -453,7 +528,7 @@
 
 
 @router.get("/ffprobe")
-def ffprobe(request: Request, paths: str = ""):
+def ffprobe(request: Request, paths: str = "", detailed: bool = False):
     path_param = paths
 
     if not path_param:
@@ -492,26 +567,132 @@
     output = []
 
     for path in paths:
-        ffprobe = ffprobe_stream(request.app.frigate_config.ffmpeg, path.strip())
-        output.append(
-            {
-                "return_code": ffprobe.returncode,
-                "stderr": (
-                    ffprobe.stderr.decode("unicode_escape").strip()
-                    if ffprobe.returncode != 0
-                    else ""
-                ),
-                "stdout": (
-                    json.loads(ffprobe.stdout.decode("unicode_escape").strip())
-                    if ffprobe.returncode == 0
-                    else ""
-                ),
-            }
+        ffprobe = ffprobe_stream(
+            request.app.frigate_config.ffmpeg, path.strip(), detailed=detailed
         )
 
+        result = {
+            "return_code": ffprobe.returncode,
+            "stderr": (
+                ffprobe.stderr.decode("unicode_escape").strip()
+                if ffprobe.returncode != 0
+                else ""
+            ),
+            "stdout": (
+                json.loads(ffprobe.stdout.decode("unicode_escape").strip())
+                if ffprobe.returncode == 0
+                else ""
+            ),
+        }
+
+        # Add detailed metadata if requested and probe was successful
+        if detailed and ffprobe.returncode == 0 and result["stdout"]:
+            try:
+                probe_data = result["stdout"]
+                metadata = {}
+
+                # Extract video stream information
+                video_stream = None
+                audio_stream = None
+
+                for stream in probe_data.get("streams", []):
+                    if stream.get("codec_type") == "video":
+                        video_stream = stream
+                    elif stream.get("codec_type") == "audio":
+                        audio_stream = stream
+
+                # Video metadata
+                if video_stream:
+                    metadata["video"] = {
+                        "codec": video_stream.get("codec_name"),
+                        "width": video_stream.get("width"),
+                        "height": video_stream.get("height"),
+                        "fps": _extract_fps(video_stream.get("r_frame_rate")),
+                        "pixel_format": video_stream.get("pix_fmt"),
+                        "profile": video_stream.get("profile"),
+                        "level": video_stream.get("level"),
+                    }
+
+                    # Calculate resolution string
+                    if video_stream.get("width") and video_stream.get("height"):
+                        metadata["video"]["resolution"] = (
+                            f"{video_stream['width']}x{video_stream['height']}"
+                        )
+
+                # Audio metadata
+                if audio_stream:
+                    metadata["audio"] = {
+                        "codec": audio_stream.get("codec_name"),
+                        "channels": audio_stream.get("channels"),
+                        "sample_rate": audio_stream.get("sample_rate"),
+                        "channel_layout": audio_stream.get("channel_layout"),
+                    }
+
+                # Container/format metadata
+                if probe_data.get("format"):
+                    format_info = probe_data["format"]
+                    metadata["container"] = {
+                        "format": format_info.get("format_name"),
+                        "duration": format_info.get("duration"),
+                        "size": format_info.get("size"),
+                    }
+
+                result["metadata"] = metadata
+
+            except Exception as e:
+                logger.warning(f"Failed to extract detailed metadata: {e}")
+                # Continue without metadata if parsing fails
+
+        output.append(result)
+
     return JSONResponse(content=output)
 
 
+@router.get("/ffprobe/snapshot", dependencies=[Depends(require_role(["admin"]))])
+def ffprobe_snapshot(request: Request, url: str = "", timeout: int = 10):
+    """Get a snapshot from a stream URL using ffmpeg."""
+    if not url:
+        return JSONResponse(
+            content={"success": False, "message": "URL parameter is required"},
+            status_code=400,
+        )
+
+    config: FrigateConfig = request.app.frigate_config
+
+    image_data, error = run_ffmpeg_snapshot(
+        config.ffmpeg, url, "mjpeg", timeout=timeout
+    )
+
+    if image_data:
+        return Response(
+            image_data,
+            media_type="image/jpeg",
+            headers={"Cache-Control": "no-store"},
+        )
+    elif error == "timeout":
+        return JSONResponse(
+            content={"success": False, "message": "Timeout capturing snapshot"},
+            status_code=408,
+        )
+    else:
+        logger.error(f"ffmpeg failed: {error}")
+        return JSONResponse(
+            content={"success": False, "message": "Failed to capture snapshot"},
+            status_code=500,
+        )
+
+
+def _extract_fps(r_frame_rate: str) -> float | None:
+    """Extract FPS from ffprobe r_frame_rate string (e.g., '30/1' -> 30.0)"""
+    if not r_frame_rate:
+        return None
+    try:
+        num, den = r_frame_rate.split("/")
+        return round(float(num) / float(den), 2)
+    except (ValueError, ZeroDivisionError):
+        return None
+
+
 @router.get("/vainfo")
 def vainfo():
     vainfo = vainfo_hwaccel()

frigate/util/image.py

@@ -943,46 +943,72 @@ def add_mask(mask: str, mask_img: np.ndarray):
     cv2.fillPoly(mask_img, pts=[contour], color=(0))
 
 
-def get_image_from_recording(
-    ffmpeg,  # Ffmpeg Config
-    file_path: str,
-    relative_frame_time: float,
+def run_ffmpeg_snapshot(
+    ffmpeg,
+    input_path: str,
     codec: str,
+    seek_time: Optional[float] = None,
     height: Optional[int] = None,
-) -> Optional[Any]:
-    """retrieve a frame from given time in recording file."""
-
+    timeout: Optional[int] = None,
+) -> tuple[Optional[bytes], str]:
+    """Run ffmpeg to extract a snapshot/image from a video source."""
     ffmpeg_cmd = [
         ffmpeg.ffmpeg_path,
         "-hide_banner",
         "-loglevel",
         "warning",
-        "-ss",
-        f"00:00:{relative_frame_time}",
-        "-i",
-        file_path,
-        "-frames:v",
-        "1",
-        "-c:v",
-        codec,
-        "-f",
-        "image2pipe",
-        "-",
     ]
 
+    if seek_time is not None:
+        ffmpeg_cmd.extend(["-ss", f"00:00:{seek_time}"])
+
+    ffmpeg_cmd.extend(
+        [
+            "-i",
+            input_path,
+            "-frames:v",
+            "1",
+            "-c:v",
+            codec,
+            "-f",
+            "image2pipe",
+            "-",
+        ]
+    )
+
     if height is not None:
         ffmpeg_cmd.insert(-3, "-vf")
         ffmpeg_cmd.insert(-3, f"scale=-1:{height}")
 
-    process = sp.run(
-        ffmpeg_cmd,
-        capture_output=True,
+    try:
+        process = sp.run(
+            ffmpeg_cmd,
+            capture_output=True,
+            timeout=timeout,
+        )
+
+        if process.returncode == 0 and process.stdout:
+            return process.stdout, ""
+        else:
+            return None, process.stderr.decode() if process.stderr else "ffmpeg failed"
+    except sp.TimeoutExpired:
+        return None, "timeout"
+
+
+def get_image_from_recording(
+    ffmpeg,  # Ffmpeg Config
+    file_path: str,
+    relative_frame_time: float,
+    codec: str,
+    height: Optional[int] = None,
+) -> Optional[Any]:
+    """retrieve a frame from given time in recording file."""
+
+    image_data, _ = run_ffmpeg_snapshot(
+        ffmpeg, file_path, codec, seek_time=relative_frame_time, height=height
     )
 
-    if process.returncode == 0:
-        return process.stdout
-    else:
-        return None
+    return image_data
 
 
 def get_histogram(image, x_min, y_min, x_max, y_max):

frigate/util/services.py

@@ -515,21 +515,36 @@ def get_jetson_stats() -> Optional[dict[int, dict]]:
     return results
 
 
-def ffprobe_stream(ffmpeg, path: str) -> sp.CompletedProcess:
+def ffprobe_stream(ffmpeg, path: str, detailed: bool = False) -> sp.CompletedProcess:
     """Run ffprobe on stream."""
     clean_path = escape_special_characters(path)
+
+    # Base entries that are always included
+    stream_entries = "codec_long_name,width,height,bit_rate,duration,display_aspect_ratio,avg_frame_rate"
+
+    # Additional detailed entries
+    if detailed:
+        stream_entries += ",codec_name,profile,level,pix_fmt,channels,sample_rate,channel_layout,r_frame_rate"
+        format_entries = "format_name,size,bit_rate,duration"
+    else:
+        format_entries = None
+
     ffprobe_cmd = [
         ffmpeg.ffprobe_path,
         "-timeout",
         "1000000",
         "-print_format",
         "json",
         "-show_entries",
-        "stream=codec_long_name,width,height,bit_rate,duration,display_aspect_ratio,avg_frame_rate",
-        "-loglevel",
-        "quiet",
-        clean_path,
+        f"stream={stream_entries}",
     ]
+
+    # Add format entries for detailed mode
+    if detailed and format_entries:
+        ffprobe_cmd.extend(["-show_entries", f"format={format_entries}"])
+
+    ffprobe_cmd.extend(["-loglevel", "quiet", clean_path])
+
     return sp.run(ffprobe_cmd, capture_output=True)