gx
37232ae1b9
cuda-grid-controller (Python 3.11+) — control plane между HA/MQTT/HTTP
и FFmpeg's vf_cuda_grid filter через ZMQ.
Modules (~700 LOC Python):
- config.py — Pydantic schema (broker, instances[], ha_discovery, http, log) + YAML loader
- layouts.py — registry известных layouts (sync с vf_cuda_grid.c Phase 2)
- ha_discovery.py — HA MQTT Discovery payloads (select.layout, sensor.current_layout,
binary_sensor.online per instance + global device entry)
- zmq_client.py — async ZMQ REQ socket к FFmpeg zmq filter
(target command args → reply parsing)
- state.py — in-memory ControllerState (active_layout per instance, asyncio.Lock)
- mqtt_loop.py — aiomqtt async loop: subscribe cuda_grid/cmd/<inst>/+/+,
publish cuda_grid/state/* (retained) + cuda_grid/event/*, LWT, HA status reconnect
- dispatch.py — CommandDispatcher: layout.set action → ZMQ send_command + state update + events
- http_api.py — FastAPI: /health, /layouts, /state, POST /layout/{inst}/set
- __main__.py — typer CLI, asyncio.gather(mqtt_loop, uvicorn.server)
Examples + Dockerfile:
- examples/controller.yaml — 2 instances (livingroom_tv, public_stream)
- Dockerfile — python:3.11-slim, ENTRYPOINT cuda-grid-controller
- README — overview, usage, FFmpeg side filter graph
End-to-end flow ready:
HA dashboard → MQTT → controller → ZMQ → FFmpeg process_command → layout switch
↓
state публикуется обратно в MQTT → HA UI обновляется
Phase 3 deliverable per gx/vf-cuda-grid#1. Phase 4 = overlays (rect/text/icon).
67 lines
2.3 KiB
Python
67 lines
2.3 KiB
Python
"""ZMQ клиент к FFmpeg's `zmq` filter.
|
|
|
|
FFmpeg zmq filter принимает строки формата:
|
|
`target command [args]`
|
|
|
|
Например для cuda_grid в filter graph:
|
|
`cuda_grid@livingroom_tv set_layout quad`
|
|
|
|
См. https://ffmpeg.org/ffmpeg-filters.html#zmq_002c-azmq
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import structlog
|
|
import zmq
|
|
import zmq.asyncio
|
|
|
|
log = structlog.get_logger()
|
|
|
|
|
|
class FFmpegZmqClient:
|
|
"""REQ-socket к FFmpeg zmq filter. Один client = один FFmpeg pipeline."""
|
|
|
|
def __init__(self, endpoint: str, request_timeout_ms: int = 2000) -> None:
|
|
self.endpoint = endpoint
|
|
self.request_timeout_ms = request_timeout_ms
|
|
self._ctx = zmq.asyncio.Context.instance()
|
|
self._sock: zmq.asyncio.Socket | None = None
|
|
|
|
async def connect(self) -> None:
|
|
if self._sock is not None:
|
|
return
|
|
self._sock = self._ctx.socket(zmq.REQ)
|
|
self._sock.setsockopt(zmq.LINGER, 0)
|
|
self._sock.setsockopt(zmq.RCVTIMEO, self.request_timeout_ms)
|
|
self._sock.setsockopt(zmq.SNDTIMEO, self.request_timeout_ms)
|
|
self._sock.connect(self.endpoint)
|
|
log.info("zmq.connected", endpoint=self.endpoint)
|
|
|
|
async def send_command(self, target: str, command: str, args: str | None = None) -> str:
|
|
"""Отправить команду filter'у. Возвращает ответ от ffmpeg ('0 Success' / error string)."""
|
|
if self._sock is None:
|
|
await self.connect()
|
|
assert self._sock is not None
|
|
|
|
cmd_str = f"{target} {command}"
|
|
if args:
|
|
cmd_str = f"{cmd_str} {args}"
|
|
|
|
log.debug("zmq.send", endpoint=self.endpoint, cmd=cmd_str)
|
|
try:
|
|
await self._sock.send_string(cmd_str)
|
|
reply = await self._sock.recv_string()
|
|
log.debug("zmq.reply", reply=reply)
|
|
return reply
|
|
except zmq.error.Again:
|
|
log.warning("zmq.timeout", endpoint=self.endpoint, cmd=cmd_str)
|
|
# Reset REQ socket state — после timeout REQ нельзя re-use
|
|
self._sock.close(linger=0)
|
|
self._sock = None
|
|
raise TimeoutError(f"zmq command timeout: {cmd_str}")
|
|
|
|
async def close(self) -> None:
|
|
if self._sock is not None:
|
|
self._sock.close(linger=0)
|
|
self._sock = None
|