python-aidot-cameras 0.15.4__tar.gz → 0.15.6__tar.gz

{python_aidot_cameras-0.15.4/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.4
+Version: 0.15.6
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6}/aidot_cameras/__main__.py

@@ -45,9 +45,18 @@ go2rtc.yaml example (SDES camera - native RTSP push, video + audio):
     streams:
       frontdoor: exec:aidot-go2rtc 8d2521ea... {output}
 
-For a DTLS camera (A000088) there is no RTSP-push path; pass an http serve URL
-(http://127.0.0.1:PORT/name.ts) and add it to go2rtc as an http-mpegts source -
-but this process must stay running to keep that serve bound.
+A DTLS camera (A000088) has no RTSP-push path, but a stdout producer works the
+same lazy way. Pass ``-`` as the output and this process writes MPEG-TS (video
+plus AAC audio) to stdout, which go2rtc's exec: source reads directly:
+
+    streams:
+      driveway: exec:aidot-go2rtc 7c89a5c1... -
+
+go2rtc then owns the lifecycle - spawn on the first viewer, kill when idle -
+exactly as it does with ``{output}`` for an SDES camera. An
+``http://host:port/name.ts`` output still works too: the older HTTP-listen
+serve, useful for a persistent consumer that is not go2rtc, but that process
+must stay running to keep the serve bound.
 """
 
 from __future__ import annotations
@@ -225,7 +234,21 @@ async def cmd_stream(dev_id: str, output_url: str) -> int:
 
         dc = client.get_device_client(device)
 
-        if not output_url.startswith("rtsp") and dc.is_sdes_camera:
+        if output_url == "-":
+            # Stdout producer: MPEG-TS on this process's stdout, for a go2rtc
+            # exec: source.  SDES cameras already have {output} (RTSP push) and
+            # do not take this path, so say which one to use rather than
+            # producing an empty stream.
+            if dc.is_sdes_camera:
+                sys.exit(
+                    f"{dev_id} is an SDES camera - '-' (stdout) is the DTLS "
+                    "producer path. Use {output} (RTSP push) instead."
+                )
+            _LOGGER.info(
+                "DTLS stdout mode: writing MPEG-TS (video + AAC audio) to "
+                "stdout for a go2rtc exec: consumer."
+            )
+        elif not output_url.startswith("rtsp") and dc.is_sdes_camera:
             _LOGGER.warning(
                 "SDES camera but output %r is not rtsp:// - the library will "
                 "HTTP-serve (video only by default) instead of pushing audio+video. "
@@ -235,7 +258,8 @@ async def cmd_stream(dev_id: str, output_url: str) -> int:
         if output_url.startswith("rtsp") and not dc.is_sdes_camera:
             sys.exit(
                 f"{dev_id} is a DTLS camera - the library has no RTSP-push path "
-                "for it. Use an http://host:port/name.ts serve URL instead."
+                "for it. Use '-' (stdout, for a go2rtc exec: source) or an "
+                "http://host:port/name.ts serve URL instead."
             )
 
         await dc.async_login()

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6}/aidot_cameras/camera/client.py

@@ -4552,16 +4552,36 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             # AIDOT_DTLS_RETRY_GATE_S and added dead latency after healthy drops.)
 
     async def _spawn_dtls_serve_ffmpeg(self, serve_url: Optional[str], stdin_fd: int):
-        """Launch ffmpeg to serve the mux thread's MPEG-TS (read from ``stdin_fd``)
-        on an HTTP-listen socket go2rtc pulls.  The stream is already cleanly
-        timestamped + AAC-muxed (with the gain/limiter applied) by PyAV, so
-        ffmpeg just copies and serves - re-encoding here dropped the live audio
-        (mpegts PMT-timing on the real-time pipe).  Returns the process, or None."""
+        """Launch ffmpeg to serve the mux thread's MPEG-TS (read from ``stdin_fd``).
+
+        The stream is already cleanly timestamped + AAC-muxed (with the
+        gain/limiter applied) by PyAV, so ffmpeg just copies and serves -
+        re-encoding here dropped the live audio (mpegts PMT-timing on the
+        real-time pipe).  Returns the process, or None.
+
+        Two destinations:
+
+        - ``serve_url == "-"`` -> STDOUT model: write MPEG-TS to this process's
+          own stdout (``pipe:1``), so a parent that spawned us - go2rtc's
+          ``exec:`` source - consumes the camera directly and owns the process
+          lifecycle (spawn on first viewer, kill on idle).  No listen port and
+          no cold-start relay, which is the DTLS analogue of the SDES
+          ``{output}`` RTSP push.  Logging already goes to stderr, so stdout
+          carries nothing but media.
+        - anything else -> HTTP-listen model, unchanged: serve on a ``-listen``
+          socket that go2rtc pulls.
+        """
         if not serve_url:
             return None
         if _ffmpeg_path() is None:
             _LOGGER.error("DTLS serve: %s", _FFMPEG_MISSING_MSG)
             return None
+        if serve_url == "-":
+            out_args = ["-f", "mpegts", "pipe:1"]
+            out_target = 1               # this process's real stdout
+        else:
+            out_args = ["-f", "mpegts", "-listen", "1", serve_url]
+            out_target = asyncio.subprocess.DEVNULL
         cmd = [
             "ffmpeg", "-y", "-loglevel", "warning",
             # Suppress input-side buffering: the PyAV mux already writes
@@ -4572,13 +4592,13 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             # bursty/choppy audio pattern.  Matches the SDES serve's approach.
             "-fflags", "+nobuffer",
             "-i", "pipe:0",
-            "-c", "copy", "-f", "mpegts", "-listen", "1", serve_url,
+            "-c", "copy", *out_args,
         ]
         try:
             return await asyncio.create_subprocess_exec(
                 *cmd,
                 stdin=stdin_fd,
-                stdout=asyncio.subprocess.DEVNULL,
+                stdout=out_target,
                 stderr=asyncio.subprocess.DEVNULL,
             )
         except FileNotFoundError:

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6}/aidot_cameras/camera/sdes_open.py

@@ -39,6 +39,41 @@ from .protocol import (
 _LOGGER = logging.getLogger(__name__)
 
 
+#: What we ask the kernel for on a media receive socket.  The kernel clamps to
+#: ``net.core.rmem_max`` (4 MB on Home Assistant OS), and doubles what it grants
+#: for bookkeeping, so asking for more than the cap is harmless.
+_MEDIA_RCVBUF_BYTES = 4 * 1024 * 1024
+
+
+def _widen_media_rcvbuf(sock, kind: str, device_id: str = "?") -> int:
+    """Ask for a large receive buffer on a camera media socket.
+
+    These sockets ran on the OS default, which is 208 KB on Home Assistant OS.
+    A keyframe from an A001064 is 146-190 KB and arrives as one burst of ~130
+    packets, so a single keyframe nearly fills that buffer: any delay in the
+    reader - the GIL while another camera's bridge runs, an ffmpeg write
+    blocking - and the kernel drops the tail of the burst.  ffmpeg then reports
+    ``RTP: missed N packets`` and backs up its input queue.
+
+    Returns the buffer the kernel actually granted (it reports double what it
+    reserves), or 0 if the option could not be set.  Best-effort by design: a
+    platform that refuses the option must not stop a camera from streaming.
+    """
+    try:
+        import socket as _sock_rb
+
+        sock.setsockopt(_sock_rb.SOL_SOCKET, _sock_rb.SO_RCVBUF,
+                        _MEDIA_RCVBUF_BYTES)
+        got = sock.getsockopt(_sock_rb.SOL_SOCKET, _sock_rb.SO_RCVBUF)
+    except Exception:
+        _LOGGER.debug("camera %s: could not widen the %s receive buffer",
+                      device_id, kind, exc_info=True)
+        return 0
+    _LOGGER.debug("camera %s: %s receive buffer %d bytes (asked %d)",
+                  device_id, kind, got, _MEDIA_RCVBUF_BYTES)
+    return got
+
+
 def _start_serve_stderr_drain(proc, *, maxlines: int = 40) -> None:
     """Drain a serve ffmpeg's stderr continuously into a bounded tail on the proc.
 
@@ -529,11 +564,13 @@ class _SdesOpenMixin:
         import socket as _socket
 
         _audio_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
+        _widen_media_rcvbuf(_audio_sock, "audio", getattr(self, "device_id", "?"))
         _audio_sock.bind(("0.0.0.0", 0))
         audio_port = _audio_sock.getsockname()[1]
         _cl(_audio_sock.close)   # also unblocks the bridge thread's recv on cleanup
 
         _video_sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
+        _widen_media_rcvbuf(_video_sock, "video", getattr(self, "device_id", "?"))
         _video_sock.bind(("0.0.0.0", 0))
         video_port = _video_sock.getsockname()[1]
         _cl(_video_sock.close)

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.4"
+version = "0.15.6"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.4
+Version: 0.15.6
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.4 → python_aidot_cameras-0.15.6}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ tests/test_dtls_serve_decode_skip.py
 tests/test_dtls_serve_open_timeout.py
 tests/test_dtls_skip_signaling_wait.py
 tests/test_dtls_slow_probe.py
+tests/test_dtls_stdout_producer.py
 tests/test_egress_guard.py
 tests/test_env_seams.py
 tests/test_go2rtc.py
@@ -108,6 +109,7 @@ tests/test_light_active_color_mode.py
 tests/test_live_stream_param.py
 tests/test_live_validate_policy.py
 tests/test_logging_caps.py
+tests/test_media_socket_rcvbuf.py
 tests/test_media_wait_floor.py
 tests/test_motion_poll.py
 tests/test_mqtt_credential_refetch.py

python_aidot_cameras-0.15.6/tests/test_dtls_stdout_producer.py

@@ -0,0 +1,77 @@
+"""The DTLS serve can write MPEG-TS to stdout for a go2rtc ``exec:`` source.
+
+SDES cameras get a lazily-managed producer for free: go2rtc spawns the process
+per ``{output}``, the library RTSP-pushes into it, and go2rtc kills it when the
+last viewer leaves. DTLS had no equivalent - it could only serve on an
+``-listen`` socket, which has to be bound before anyone asks for it and stays
+bound afterwards.
+
+``-`` closes that gap: ffmpeg writes to this process's own stdout, so whoever
+spawned us is the consumer and owns the lifecycle. Everything else about the
+serve is untouched, which is what these tests pin - a regression here would
+either break every existing HTTP-listen serve or silently send media to
+/dev/null.
+"""
+import asyncio
+import types
+
+import aidot_cameras.camera.client as client_mod
+from aidot_cameras.camera.client import CameraMixin
+
+
+def _spawn(monkeypatch, serve_url):
+    """Run the real _spawn_dtls_serve_ffmpeg, capturing what it would exec."""
+    seen = {}
+
+    async def _fake_exec(*cmd, stdin=None, stdout=None, stderr=None):
+        seen["cmd"] = list(cmd)
+        seen["stdout"] = stdout
+        seen["stdin"] = stdin
+        return object()
+
+    monkeypatch.setattr(client_mod, "_ffmpeg_path", lambda: "/usr/bin/ffmpeg")
+    monkeypatch.setattr(asyncio, "create_subprocess_exec", _fake_exec)
+    obj = types.SimpleNamespace()
+    fn = CameraMixin._spawn_dtls_serve_ffmpeg.__get__(obj)
+    proc = asyncio.run(fn(serve_url, 7))
+    return proc, seen
+
+
+def test_stdout_mode_writes_mpegts_to_this_process_stdout(monkeypatch):
+    proc, seen = _spawn(monkeypatch, "-")
+    assert proc is not None
+    assert seen["cmd"][-3:] == ["-f", "mpegts", "pipe:1"], seen["cmd"]
+    # fd 1, not DEVNULL: the media has to reach the parent that spawned us.
+    assert seen["stdout"] == 1, (
+        "stdout mode must hand ffmpeg this process's real stdout - anything "
+        "else sends the camera to nowhere while looking healthy"
+    )
+    assert "-listen" not in seen["cmd"]
+
+
+def test_http_listen_mode_is_unchanged(monkeypatch):
+    url = "http://127.0.0.1:18981/cam.ts"
+    proc, seen = _spawn(monkeypatch, url)
+    assert proc is not None
+    assert seen["cmd"][-4:] == ["-f", "mpegts", "-listen", "1", url][-4:]
+    assert seen["cmd"][-1] == url
+    assert "-listen" in seen["cmd"]
+    assert seen["stdout"] == asyncio.subprocess.DEVNULL, (
+        "the listen serve must keep stdout discarded; writing media to our own "
+        "stdout there would corrupt whatever the parent reads"
+    )
+
+
+def test_both_modes_still_copy_from_the_mux_pipe(monkeypatch):
+    for url in ("-", "http://127.0.0.1:1/x.ts"):
+        _proc, seen = _spawn(monkeypatch, url)
+        cmd = seen["cmd"]
+        assert cmd[:2] == ["ffmpeg", "-y"]
+        assert "-i" in cmd and cmd[cmd.index("-i") + 1] == "pipe:0"
+        assert "-c" in cmd and cmd[cmd.index("-c") + 1] == "copy"
+        assert seen["stdin"] == 7
+
+
+def test_no_serve_url_still_returns_none(monkeypatch):
+    proc, seen = _spawn(monkeypatch, "")
+    assert proc is None and "cmd" not in seen

python_aidot_cameras-0.15.6/tests/test_media_socket_rcvbuf.py

@@ -0,0 +1,69 @@
+"""Camera media sockets must ask for a receive buffer big enough for a keyframe.
+
+These sockets ran on the OS default - 208 KB on Home Assistant OS. An A001064
+keyframe is 146-190 KB delivered as one burst of ~130 packets, so a single
+keyframe nearly fills that buffer. Any delay in the reader (the GIL while
+another camera's bridge runs, an ffmpeg write blocking) and the kernel drops the
+tail of the burst, which ffmpeg reports as ``RTP: missed N packets`` while its
+input queue backs up. The box carried 44.3 million ``RcvbufErrors`` against
+161 million datagrams received over four days, and every UDP receive error on it
+was a buffer overflow rather than a checksum or port error.
+"""
+import socket
+
+from aidot_cameras.camera.sdes_open import (
+    _MEDIA_RCVBUF_BYTES,
+    _widen_media_rcvbuf,
+)
+
+
+def test_the_request_clears_a_keyframe_burst():
+    # 190 KB is the largest keyframe measured on the A001064; the request has to
+    # leave room for that plus scheduling jitter, not merely match it.
+    assert _MEDIA_RCVBUF_BYTES >= 8 * 190 * 1024
+
+
+def test_a_real_socket_gets_more_than_the_os_default():
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        default = sock.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)
+        got = _widen_media_rcvbuf(sock, "video", "dev-abc")
+        assert got > 0, "the option was not set at all"
+        # Kernels clamp to rmem_max and report double what they reserve, so the
+        # exact number is not assertable - only that it grew, and that it now
+        # clears one keyframe.
+        assert got >= default
+        assert got >= 190 * 1024, f"granted {got} bytes, under one keyframe"
+    finally:
+        sock.close()
+
+
+def test_failure_is_survivable():
+    """A platform that refuses the option must not stop a camera streaming."""
+
+    class _Refuses:
+        def setsockopt(self, *_a):
+            raise OSError("nope")
+
+        def getsockopt(self, *_a):
+            raise OSError("nope")
+
+    assert _widen_media_rcvbuf(_Refuses(), "audio", "dev-abc") == 0
+
+
+def test_both_media_sockets_are_widened_before_bind():
+    """Pin the call sites: a socket widened after bind may already have dropped.
+
+    The open path is one long method that cannot be called in isolation, so
+    assert on its source - both the audio and video sockets must be widened, and
+    each before its own bind.
+    """
+    import inspect
+
+    from aidot_cameras.camera import sdes_open
+
+    src = inspect.getsource(sdes_open)
+    for kind in ("_audio_sock", "_video_sock"):
+        widen = src.index(f"_widen_media_rcvbuf({kind}")
+        bind = src.index(f"{kind}.bind(")
+        assert widen < bind, f"{kind} is bound before its receive buffer is set"