gx
a7b1d9b1d9
FrigateCameraMapping +priority +main_cam_index — для auto-layout decision.
FrigateBridgeCfg.auto_layout flag — toggle через REST.
Logic (FrigateBridge._update_auto_layout):
0 active cameras → quad (default overview)
1+ active → single, main_cam = highest priority active
Equal priority → first active wins (deterministic)
Dispatcher.set_main_cam — ZMQ streamselect@main_cam map <index>
Config.main_cam_filter_target = "streamselect@main_cam"
REST:
GET /auto-layout/{instance} — current toggle state
POST /auto-layout/{instance} — { enabled: bool }
при включении сразу применяет
UI:
+ checkbox "auto" в Layout card — toggleAuto() hits POST /auto-layout
Live verified: enable → immediately picks layout=single, main=gate_lpr
(priority=10, highest active). Visual confirms gate_lpr full screen.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
261 lines
10 KiB
Python
261 lines
10 KiB
Python
"""HTTP REST API (FastAPI)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import structlog
|
|
from fastapi import Body, FastAPI, HTTPException
|
|
from fastapi.responses import FileResponse, Response
|
|
from fastapi.staticfiles import StaticFiles
|
|
from pydantic import BaseModel, TypeAdapter
|
|
|
|
from .config import Config
|
|
from .dispatch import CommandDispatcher
|
|
from .layouts import PREDEFINED_LAYOUTS
|
|
from .overlays import Overlay
|
|
from .snapshot_history import SnapshotHistory
|
|
from .state import ControllerState
|
|
|
|
log = structlog.get_logger()
|
|
|
|
|
|
class LayoutSetReq(BaseModel):
|
|
layout: str
|
|
|
|
|
|
class AudioSetReq(BaseModel):
|
|
source: str
|
|
|
|
|
|
class AutoLayoutReq(BaseModel):
|
|
enabled: bool
|
|
|
|
|
|
def create_app(
|
|
cfg: Config, state: ControllerState, dispatcher: CommandDispatcher,
|
|
snapshot_history: SnapshotHistory | None = None,
|
|
frigate_bridge=None,
|
|
) -> FastAPI:
|
|
app = FastAPI(
|
|
title="cuda-grid-controller",
|
|
version="0.1.0",
|
|
description="Control plane для vf_cuda_grid FFmpeg filter",
|
|
)
|
|
|
|
# Static UI — http://controller:8080/ui/
|
|
static_dir = Path(__file__).parent / "static"
|
|
if static_dir.exists():
|
|
app.mount("/ui", StaticFiles(directory=str(static_dir), html=True), name="ui")
|
|
|
|
@app.get("/")
|
|
async def root_redirect():
|
|
return FileResponse(static_dir / "index.html")
|
|
|
|
def _check_instance(name: str):
|
|
inst = next((i for i in cfg.instances if i.name == name), None)
|
|
if inst is None:
|
|
raise HTTPException(404, f"unknown instance '{name}'")
|
|
return inst
|
|
|
|
@app.get("/health")
|
|
async def health() -> dict[str, Any]:
|
|
return {"status": "ok"}
|
|
|
|
@app.get("/layouts")
|
|
async def layouts() -> dict[str, Any]:
|
|
return {"predefined": PREDEFINED_LAYOUTS}
|
|
|
|
@app.get("/state")
|
|
async def get_state() -> dict[str, Any]:
|
|
out = {}
|
|
for inst in cfg.instances:
|
|
overlays = await state.get_overlays(inst.name)
|
|
out[inst.name] = {
|
|
"active_layout": await state.get_layout(inst.name),
|
|
"zmq_endpoint": inst.zmq_endpoint,
|
|
"overlays_count": len(overlays),
|
|
}
|
|
return {"instances": out}
|
|
|
|
@app.post("/layout/{instance}/set")
|
|
async def set_layout(instance: str, req: LayoutSetReq) -> dict[str, Any]:
|
|
inst = _check_instance(instance)
|
|
if req.layout not in inst.layout_map:
|
|
raise HTTPException(
|
|
400, f"unknown layout '{req.layout}'. Доступны: {list(inst.layout_map.keys())}"
|
|
)
|
|
await dispatcher.handle(instance, "layout.set", req.layout)
|
|
return {"ok": True, "instance": instance, "layout": req.layout}
|
|
|
|
@app.get("/layouts/{instance}")
|
|
async def layouts_for_instance(instance: str) -> dict[str, Any]:
|
|
inst = _check_instance(instance)
|
|
return {
|
|
"instance": instance,
|
|
"layouts": list(inst.layout_map.keys()),
|
|
"current": await state.get_layout(instance),
|
|
}
|
|
|
|
@app.get("/auto-layout/{instance}")
|
|
async def auto_layout_get(instance: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
enabled = bool(frigate_bridge and frigate_bridge.cfg.auto_layout)
|
|
return {"instance": instance, "enabled": enabled}
|
|
|
|
@app.post("/auto-layout/{instance}")
|
|
async def auto_layout_set(instance: str, req: AutoLayoutReq) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
if frigate_bridge is None:
|
|
raise HTTPException(404, "frigate_bridge не configured")
|
|
frigate_bridge.cfg.auto_layout = req.enabled
|
|
log.info("auto_layout.toggled", instance=instance, enabled=req.enabled)
|
|
# При включении — сразу применить (могут уже быть active cameras)
|
|
if req.enabled:
|
|
await frigate_bridge._update_auto_layout(instance)
|
|
return {"ok": True, "instance": instance, "enabled": req.enabled}
|
|
|
|
# ─── Overlays ──────────────────────────────────────────────────
|
|
|
|
@app.post("/overlay/{instance}/add")
|
|
async def overlay_add(
|
|
instance: str, overlay: Overlay = Body(...)
|
|
) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
await dispatcher.handle(
|
|
instance, "overlay.add", overlay.model_dump_json()
|
|
)
|
|
return {"ok": True, "id": overlay.id, "type": overlay.type}
|
|
|
|
@app.get("/overlay/{instance}")
|
|
async def overlay_list(instance: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
overlays = await state.get_overlays(instance)
|
|
return {
|
|
"instance": instance,
|
|
"count": len(overlays),
|
|
"overlays": [o.model_dump() for o in overlays],
|
|
}
|
|
|
|
@app.delete("/overlay/{instance}/{overlay_id}")
|
|
async def overlay_remove(instance: str, overlay_id: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
await dispatcher.handle(instance, "overlay.remove", overlay_id)
|
|
return {"ok": True}
|
|
|
|
@app.delete("/overlay/{instance}")
|
|
async def overlay_clear(instance: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
await dispatcher.handle(instance, "overlay.clear", "")
|
|
return {"ok": True}
|
|
|
|
# ─── Audio ─────────────────────────────────────────────────────
|
|
|
|
@app.get("/audio/{instance}")
|
|
async def audio_list(instance: str) -> dict[str, Any]:
|
|
inst = _check_instance(instance)
|
|
return {
|
|
"instance": instance,
|
|
"sources": [
|
|
{"name": s.name, "index": s.index, "label": s.label or s.name}
|
|
for s in inst.audio_sources
|
|
],
|
|
}
|
|
|
|
@app.post("/audio/{instance}/set")
|
|
async def audio_set(instance: str, req: AudioSetReq) -> dict[str, Any]:
|
|
inst = _check_instance(instance)
|
|
names = {s.name for s in inst.audio_sources}
|
|
if req.source not in names:
|
|
raise HTTPException(
|
|
400, f"unknown audio source '{req.source}'. Доступны: {sorted(names)}"
|
|
)
|
|
await dispatcher.handle(instance, "audio.set", req.source)
|
|
return {"ok": True, "instance": instance, "source": req.source}
|
|
|
|
@app.post("/intercom/{instance}/start")
|
|
async def intercom_start(instance: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
await dispatcher.handle(instance, "intercom.start", "")
|
|
return {"ok": True, "instance": instance, "intercom": "active"}
|
|
|
|
@app.post("/intercom/{instance}/end")
|
|
async def intercom_end(instance: str) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
await dispatcher.handle(instance, "intercom.end", "")
|
|
return {"ok": True, "instance": instance, "intercom": "idle"}
|
|
|
|
# ─── Snapshot ──────────────────────────────────────────────────
|
|
|
|
@app.post(
|
|
"/snapshot/{instance}",
|
|
responses={
|
|
200: {"content": {"image/png": {}}, "description": "PNG snapshot of live grid"},
|
|
504: {"description": "ffmpeg timeout"},
|
|
},
|
|
)
|
|
async def snapshot(instance: str) -> Response:
|
|
"""Capture single frame от output_rtsp_url. Returns PNG bytes (image/png)."""
|
|
inst = _check_instance(instance)
|
|
if not inst.output_rtsp_url:
|
|
raise HTTPException(400, f"instance '{instance}' has no output_rtsp_url configured")
|
|
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ffmpeg", "-hide_banner", "-loglevel", "error",
|
|
"-rtsp_transport", "tcp",
|
|
"-i", inst.output_rtsp_url,
|
|
"-frames:v", "1",
|
|
"-f", "image2pipe", "-c:v", "png", "-",
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE,
|
|
)
|
|
try:
|
|
png_data, err = await asyncio.wait_for(proc.communicate(), timeout=10)
|
|
except asyncio.TimeoutError:
|
|
proc.kill()
|
|
raise HTTPException(504, "snapshot timeout (ffmpeg >10s)")
|
|
|
|
if proc.returncode != 0 or not png_data:
|
|
err_msg = err.decode(errors="replace")[:300] if err else "no output"
|
|
log.warning("snapshot.failed", instance=instance, err=err_msg)
|
|
raise HTTPException(500, f"ffmpeg failed: {err_msg}")
|
|
|
|
log.info("snapshot.ok", instance=instance, bytes=len(png_data))
|
|
return Response(content=png_data, media_type="image/png")
|
|
|
|
# ─── Snapshot history (Phase 6+) ───────────────────────────────
|
|
|
|
@app.get("/snapshots/{instance}")
|
|
async def snapshots_list(instance: str, limit: int = 50) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
if snapshot_history is None:
|
|
raise HTTPException(404, "snapshot_history disabled")
|
|
return {"instance": instance, "items": snapshot_history.list_snapshots(instance, limit)}
|
|
|
|
@app.get("/snapshots/{instance}/{filename}")
|
|
async def snapshots_get(instance: str, filename: str) -> Response:
|
|
_check_instance(instance)
|
|
if snapshot_history is None:
|
|
raise HTTPException(404, "snapshot_history disabled")
|
|
p = snapshot_history.path(instance, filename)
|
|
if p is None:
|
|
raise HTTPException(404, "snapshot not found")
|
|
return FileResponse(p, media_type="image/png")
|
|
|
|
@app.patch("/overlay/{instance}/{overlay_id}")
|
|
async def overlay_update(
|
|
instance: str, overlay_id: str, overlay: Overlay = Body(...)
|
|
) -> dict[str, Any]:
|
|
_check_instance(instance)
|
|
# Фиксируем id из URL — игнорируем body's id если отличается
|
|
overlay.id = overlay_id
|
|
await state.update_overlay(instance, overlay)
|
|
await dispatcher.handle(
|
|
instance, "overlay.add", overlay.model_dump_json()
|
|
)
|
|
return {"ok": True, "id": overlay_id}
|
|
|
|
return app
|