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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.4
+Version: 0.15.5
 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.5}/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.5}/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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.4"
+version = "0.15.5"
 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.5/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.5
 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.5}/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

python_aidot_cameras-0.15.5/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