python-aidot-cameras 0.12.9__tar.gz → 0.12.11__tar.gz

{python_aidot_cameras-0.12.9/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.9
+Version: 0.12.11
 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.12.9 → python_aidot_cameras-0.12.11}/aidot_cameras/camera/client.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+from urllib.parse import urlparse
 import os
 import random
 import time
@@ -337,6 +338,22 @@ def _save_frame_as_jpeg(image_data: Any, output_path: str) -> bool:
     return False
 
 
+def _is_self_referential_source(source: str, stream_name: str) -> bool:
+    """True when registering ``source`` under ``stream_name`` would loop.
+
+    A go2rtc stream whose source is its own RTSP address becomes its own
+    producer: the stream lists a producer, nothing feeds it, and every consumer
+    gets a connection with no media.  That is exactly the shape of a PUSH URL,
+    ``rtsp://host:8554/<stream name>`` - the address the keepalive publishes to.
+    """
+    if not source or not stream_name:
+        return False
+    if not source.lower().startswith(("rtsp://", "rtsps://")):
+        return False
+    path = urlparse(source).path.strip("/")
+    return path == stream_name
+
+
 def _build_sdes_serve_cmd(
     *,
     sdp_path: str,
@@ -2763,6 +2780,18 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         if not (self._streaming_active and self._go2rtc_url and self._keepalive_rtsp_url):
             return
         name = self._go2rtc_stream_name()
+        if _is_self_referential_source(self._keepalive_rtsp_url, name):
+            # PUSH mode: the keepalive publishes INTO go2rtc, so this URL is
+            # go2rtc's own address for this very stream.  Registering it as the
+            # stream's source makes go2rtc its own producer - a loop that yields
+            # a stream with a producer attached and no media coming out of it.
+            # In push mode the publisher already feeds the stream; there is
+            # nothing to register.
+            _LOGGER.debug(
+                "camera %s: not registering %s with go2rtc - the push URL is that "
+                "stream's own address", self.device_id, name,
+            )
+            return
         try:
             async with aiohttp.ClientSession() as _s2:
                 url = await prefer_go2rtc(
@@ -2925,6 +2954,21 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         """
         name = self._go2rtc_stream_name()
         base = self._go2rtc_url
+        if not base:
+            # No go2rtc to ask.  In PUSH mode the fallback below is not merely
+            # unavailable, it is WRONG: the "serve port" is go2rtc's shared RTSP
+            # port (8554), where every camera's own publisher is connected, so the
+            # check reports a viewer for every camera forever and nothing ever
+            # releases.  Answer "unknown" instead of a confident lie - the caller
+            # then holds the stream rather than tearing down a live view, and the
+            # honest way out is for the consumer to pass go2rtc_url.
+            if self._keepalive_rtsp_url and not str(
+                    self._keepalive_rtsp_url).startswith("http"):
+                _LOGGER.debug(
+                    "no go2rtc url and the serve is an RTSP push to a shared "
+                    "port; cannot tell whether anyone is watching",
+                )
+                return None
         if base and name:
             try:
                 import aiohttp
@@ -3692,8 +3736,14 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 self.device_id,
             )
         await slots.acquire()
-        self._serve_relay = self._maybe_start_serve_relay(self._keepalive_rtsp_url)
         try:
+            # Inside the try on purpose: _maybe_start_serve_relay catches OSError
+            # but Thread.start() raises RuntimeError when the host is out of
+            # threads, and escaping here would skip slots.release() and burn a
+            # permit for the life of the process - the cap would silently shrink
+            # until nothing could stream at all.
+            self._serve_relay = self._maybe_start_serve_relay(
+                self._keepalive_rtsp_url)
             await self._dtls_serve_loop_inner()
         finally:
             _relay = self._serve_relay
@@ -3951,6 +4001,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     _stall_pli_s = float(os.environ.get("AIDOT_STALL_PLI_S", "1.0"))
                     _last_gop_pli = loop.time()
                     _stall_pli_armed = True
+                    _last_viewer_dtls = loop.time()
+                    _serve_port_dtls = _sdes_serve_port(serve_url) or 0
                     # Wait for ffmpeg to exit (go2rtc disconnect) or idle release.
                     while self._streaming_active and proc.returncode is None:
                         await asyncio.sleep(0.5)
@@ -3968,11 +4020,26 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                             await self._send_video_pli(pc)
                             _last_gop_pli = _now           # also satisfies cadence
                             _stall_pli_armed = False       # one shot per stall
-                        # No consumer -> the pipe fills, the mux blocks, progress
-                        # goes stale.  A real viewer keeps it fresh.  idle_secs<=0
-                        # disables release entirely (keep warm for instant views).
-                        if idle_secs > 0 and _now - progress[0] > idle_secs:
-                            idle_release = True
+                        # Whether anyone is WATCHING.  Pipe-progress staleness
+                        # cannot answer that: the pipe only backs up when nothing
+                        # drains the serve socket, and go2rtc drains it forever as
+                        # the stream's producer, viewer or not.  So progress never
+                        # goes stale, the release never fires, and every DTLS
+                        # camera streams for the life of the process - the same
+                        # defect fixed for the SDES loop, in the other loop.
+                        # Ask go2rtc, and only fall back to staleness when it
+                        # cannot answer.
+                        if idle_secs > 0:
+                            _watching = await self._viewer_present(_serve_port_dtls)
+                            if _watching:
+                                _last_viewer_dtls = _now
+                            elif _watching is False:
+                                if _now - _last_viewer_dtls > idle_secs:
+                                    idle_release = True
+                            elif _now - progress[0] > idle_secs:
+                                # Unknown: keep the old staleness heuristic rather
+                                # than holding the stream open forever.
+                                idle_release = True
                             break
                     # Tear down this ffmpeg+mux cycle before the next.
                     stop_flag.set()
@@ -3999,7 +4066,12 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                         wfile.close()
                     except Exception:
                         _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_pc_dead', exc_info=True)
-                if mux_thread is not None:
+                if mux_thread is not None and mux_thread.is_alive():
+                    # is_alive() guards the never-started case: if Thread.start()
+                    # itself raised, join() raises "cannot join thread before it
+                    # is started", which would replace the real exception AND skip
+                    # the ffmpeg terminate plus session stop below - orphaning the
+                    # process on its serve port and leaking the camera's session.
                     mux_thread.join(timeout=2.0)
                 _terminate_proc(proc)  # never orphan ffmpeg on teardown
                 self._stream_session = None

{python_aidot_cameras-0.12.9 → python_aidot_cameras-0.12.11}/aidot_cameras/camera/sdes_open.py

@@ -45,7 +45,7 @@ _SDP_ALTERNATE_PT = {96: 97, 97: 96, 0: 8, 8: 0}
 # session started media at ~21s, which the previous 15s deadline missed entirely -
 # it launched blind with BOTH payload types still unknown, which is what left the
 # audio line advertising PCMU on a PCMA camera.
-_FIRST_MEDIA_WAIT_S = 45.0
+_FIRST_MEDIA_WAIT_S = 75.0
 
 # Extra time for the audio payload type once video is known.  Measured on an
 # A001513: audio follows video by 40-70ms, because the camera answers BUNDLE and
@@ -3843,20 +3843,44 @@ class _SdesOpenMixin:
                         except Exception:
                             proc.kill()
                         _ts2 = int(time.time())
+                        # Match the PRIMARY SDP on both counts, or this restart
+                        # undoes two fixes at once.
+                        #
+                        # Transport: for _use_plain_rtp models - which is every
+                        # SDES camera this library supports - the bridge decrypts
+                        # and forwards PLAIN RTP, so the primary SDP is RTP/AVP
+                        # with no a=crypto.  Writing RTP/SAVP here makes ffmpeg
+                        # try to authenticate already-decrypted packets: every one
+                        # fails its HMAC check and a working stream drops to zero
+                        # bytes mid-session.
+                        #
+                        # Payload types: hard-coding "0 8" and "96 97" throws away
+                        # the narrowing, and ffmpeg binds the FIRST type on each
+                        # line - so an H.265 camera silently loses all video (and
+                        # with it the PAT/PMT, hence the whole output), and a PCMA
+                        # camera loses its audio.  Both types are known by now.
+                        _proto = "RTP/AVP" if _use_plain_rtp else "RTP/SAVP"
+
+                        def _crypto(key: str) -> str:
+                            if _use_plain_rtp:
+                                return ""
+                            return (f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
+                                    f"inline:{key}\r\n")
+
                         _new_sdp = (
                             "v=0\r\n"
                             f"o=- {_ts2} {_ts2} IN IP4 0.0.0.0\r\n"
                             "s=aidot-sdes-rx\r\n"
                             "t=0 0\r\n"
-                            f"m=audio {_lo_audio_port} RTP/SAVP 0 8\r\n"
+                            f"m=audio {_lo_audio_port} {_proto} 0 8\r\n"
                             "c=IN IP4 127.0.0.1\r\n"
-                            f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_audio}\r\n"
+                            f"{_crypto(srtp_key_audio)}"
                             "a=rtpmap:0 PCMU/8000\r\n"
                             "a=rtpmap:8 PCMA/8000\r\n"
                             "a=rtcp-mux\r\n"
-                            f"m=video {_lo_video_port} RTP/SAVP 96 97\r\n"
+                            f"m=video {_lo_video_port} {_proto} 96 97\r\n"
                             "c=IN IP4 127.0.0.1\r\n"
-                            f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_video}\r\n"
+                            f"{_crypto(srtp_key_video)}"
                             "a=rtpmap:96 H264/90000\r\n"
                             "a=fmtp:96 level-asymmetry-allowed=1;packetization-mode=1;"
                             "profile-level-id=42e01f\r\n"
@@ -3864,6 +3888,13 @@ class _SdesOpenMixin:
                             "a=fmtp:97 level-id=93\r\n"
                             "a=rtcp-mux\r\n"
                         )
+                        _new_sdp = narrow_sdp_payload_types(
+                            _new_sdp,
+                            keep_video=(_first_video_pt[0]
+                                        if _first_video_pt[0] in (96, 97) else None),
+                            keep_audio=(_first_audio_pt[0]
+                                        if _first_audio_pt[0] in (0, 8) else None),
+                        )
                         try:
                             # Re-apply the cached sprop-parameter-sets here too:
                             # this serve-restart rewrite is the SDP the keepalive

{python_aidot_cameras-0.12.9 → python_aidot_cameras-0.12.11}/aidot_cameras/camera/webrtc_open.py

@@ -1660,6 +1660,22 @@ class _WebRTCOpenMixin:
                     _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_on_remote_dc_message', exc_info=True)
 
         track_tasks: list = []
+
+        def _cancel_track_tasks() -> None:
+            """Cancel the per-session background tasks.
+
+            Only ``WebRTCSession.stop()`` cancels these, and it is reached only
+            when a session is actually returned.  Every failure exit below closes
+            the peer connection and re-raises, which leaves them running - and the
+            AVIO heartbeat loop has no terminal condition (its senders swallow
+            every error), so a camera that fails to open repeatedly accumulates
+            one immortal 10s-tick task per attempt, each pinning the closed
+            RTCPeerConnection graph in memory.
+            """
+            for _t in track_tasks:
+                if not _t.done():
+                    _t.cancel()
+            track_tasks.clear()
         _kvs_dc = None
         if self._offer_should_include_datachannel:
             # Match the official client's label exactly: f0.java:2923 uses
@@ -2346,10 +2362,12 @@ class _WebRTCOpenMixin:
                 _code, _desc = terminal_error_fut.result()
                 _status(f"camera refused: ack {_code} {_desc} - terminal, not retrying")
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise AidotCameraBusy(_code, _desc)
             _status(f"no webrtcResp in {timeout}s")
             outgoing_q.put_nowait(None)
+            _cancel_track_tasks()
             await pc.close()
             raise RuntimeError(
                 f"async_open_webrtc_stream: no webrtcResp received within {timeout}s"
@@ -2556,6 +2574,7 @@ class _WebRTCOpenMixin:
                     f" {_rr_srd_exc}"
                 )
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise RuntimeError(
                     f"async_open_webrtc_stream: setRemoteDescription failed:"
@@ -3205,6 +3224,7 @@ class _WebRTCOpenMixin:
                 # co-fail into the full 15s-gated generic retry.
                 outgoing_q.put_nowait(None)   # stop MQTT thread (avoid orphan)
                 try:
+                    _cancel_track_tasks()
                     await pc.close()
                 except Exception:
                     pass
@@ -3347,6 +3367,7 @@ class _WebRTCOpenMixin:
                 )
                 _status(f"setRemoteDescription failed: {exc}")
                 outgoing_q.put_nowait(None)
+                _cancel_track_tasks()
                 await pc.close()
                 raise RuntimeError(
                     f"async_open_webrtc_stream: setRemoteDescription failed: {exc}"
@@ -3569,6 +3590,7 @@ class _WebRTCOpenMixin:
 
         if pc.connectionState not in ("connected", "completed"):
             outgoing_q.put_nowait(None)
+            _cancel_track_tasks()
             await pc.close()
             raise RuntimeError(
                 f"async_open_webrtc_stream: ICE connection not established "

{python_aidot_cameras-0.12.9 → python_aidot_cameras-0.12.11}/pyproject.toml

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

{python_aidot_cameras-0.12.9 → python_aidot_cameras-0.12.11/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.9
+Version: 0.12.11
 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.12.9 → python_aidot_cameras-0.12.11}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -84,7 +84,9 @@ tests/test_go2rtc_cli.py
 tests/test_h264_decode_rate_limit.py
 tests/test_highport_nomination.py
 tests/test_ice_config_cache.py
+tests/test_idle_release_both_loops.py
 tests/test_keepalive_renew.py
+tests/test_key_restart_sdp.py
 tests/test_keyframe_prompter.py
 tests/test_lan_control.py
 tests/test_light_active_color_mode.py
@@ -96,6 +98,7 @@ tests/test_mqtt_credential_self_heal.py
 tests/test_mqtt_password_not_persisted.py
 tests/test_mqtt_session_reconnect.py
 tests/test_narrow_pc_ice.py
+tests/test_no_self_referential_go2rtc.py
 tests/test_no_undefined_names.py
 tests/test_offline_keepalive_pause.py
 tests/test_open_fail_logger.py

python_aidot_cameras-0.12.11/tests/test_idle_release_both_loops.py

@@ -0,0 +1,48 @@
+"""Both serve loops must decide idleness by asking who is WATCHING.
+
+0.12.9 fixed this for the SDES loop and left the DTLS loop on its old signal -
+pipe-progress staleness - which is the same unanswerable question in disguise: the
+pipe only backs up when nothing drains the serve socket, and go2rtc drains it
+forever as the stream's producer. On a fleet that is mostly DTLS cameras (this one
+is 4 of 5) the fix therefore did nothing.
+"""
+import inspect
+
+import aidot_cameras.camera.client as cc
+
+
+def _src(name):
+    return inspect.getsource(getattr(cc.CameraMixin, name))
+
+
+def test_sdes_loop_asks_who_is_watching():
+    assert "_viewer_present" in _src("_sdes_keepalive_loop_inner")
+
+
+def test_dtls_loop_asks_who_is_watching():
+    # The regression: this loop used only `_now - progress[0] > idle_secs`.
+    assert "_viewer_present" in _src("_dtls_serve_loop_inner")
+
+
+def test_dtls_loop_still_has_a_fallback_when_nobody_can_answer():
+    # If go2rtc cannot be reached the old staleness heuristic must remain, so an
+    # unreachable go2rtc does not mean "hold every stream open forever".
+    src = _src("_dtls_serve_loop_inner")
+    assert "progress[0] > idle_secs" in src
+
+
+def test_the_stream_slot_is_released_even_if_the_relay_fails_to_start():
+    # _maybe_start_serve_relay catches OSError, but Thread.start() raises
+    # RuntimeError under thread exhaustion. Starting it outside the try meant the
+    # permit was lost for the life of the process and the cap silently shrank.
+    src = _src("_dtls_serve_loop")
+    acquire = src.index("slots.acquire()")
+    try_at = src.index("try:", acquire)
+    relay_at = src.index("_maybe_start_serve_relay", acquire)
+    assert try_at < relay_at, "relay start must be inside the try that releases"
+
+
+def test_teardown_does_not_join_a_thread_that_never_started():
+    # join() on an unstarted thread raises and would skip the ffmpeg terminate
+    # and the session stop that follow it.
+    assert "mux_thread.is_alive()" in _src("_dtls_serve_loop_inner")

python_aidot_cameras-0.12.11/tests/test_key_restart_sdp.py

@@ -0,0 +1,61 @@
+"""The SRTP key-restart must rewrite the SDP the same way the primary path does.
+
+It rebuilds the ffmpeg SDP from scratch and relaunches. Two things it got wrong,
+each undoing a shipped fix:
+
+- Transport. Every SDES model this library supports is in `_use_plain_rtp`: the
+  bridge decrypts and forwards PLAIN RTP, so the primary SDP is RTP/AVP with no
+  a=crypto. Writing RTP/SAVP makes ffmpeg authenticate already-decrypted packets,
+  every HMAC check fails, and a working stream drops to zero bytes mid-session.
+- Payload types. Hard-coding "0 8" and "96 97" discards the narrowing, and ffmpeg
+  binds the FIRST type per line - so an H.265 camera loses all video, and with it
+  the PAT/PMT and therefore the entire output.
+"""
+import re
+
+import aidot_cameras.camera.sdes_open as so
+
+
+def _restart_block() -> str:
+    src = so.__loader__.get_source("aidot_cameras.camera.sdes_open")
+    i = src.index("_new_sdp = (")
+    return src[i:i + 3000]
+
+
+def test_restart_respects_plain_rtp_transport():
+    block = _restart_block()
+    assert "_proto" in block, "transport must follow _use_plain_rtp, not be fixed"
+    assert 'f"m=audio {_lo_audio_port} {_proto}' in block
+    assert 'f"m=video {_lo_video_port} {_proto}' in block
+
+
+def test_restart_omits_crypto_for_plain_rtp():
+    block = _restart_block()
+    assert "_crypto(" in block, "a=crypto must be conditional on the transport"
+    assert "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_audio}" not in block
+
+
+def test_restart_narrows_the_payload_types():
+    block = _restart_block()
+    assert "narrow_sdp_payload_types(" in block
+    assert "keep_video=" in block and "keep_audio=" in block
+
+
+def test_first_media_wait_covers_the_documented_cold_start():
+    # The repo documents a 25-70s cold start for battery cameras in several
+    # places. A 45s deadline sat inside that range, so a camera at the slow end
+    # launched with no payload types known - the exact failure the wait exists to
+    # prevent.
+    assert so._FIRST_MEDIA_WAIT_S >= 70.0
+
+
+def test_narrowing_still_produces_a_single_payload_type_per_line():
+    sdp = (
+        "m=audio 1000 RTP/AVP 0 8\r\n"
+        "a=rtpmap:0 PCMU/8000\r\na=rtpmap:8 PCMA/8000\r\n"
+        "m=video 1002 RTP/AVP 96 97\r\n"
+        "a=rtpmap:96 H264/90000\r\na=rtpmap:97 H265/90000\r\n"
+    )
+    out = so.narrow_sdp_payload_types(sdp, keep_video=97, keep_audio=8)
+    assert re.search(r"m=audio 1000 RTP/AVP 8\r\n", out)
+    assert re.search(r"m=video 1002 RTP/AVP 97\r\n", out)

python_aidot_cameras-0.12.11/tests/test_no_self_referential_go2rtc.py

@@ -0,0 +1,47 @@
+"""A go2rtc stream must never be registered as its own source.
+
+In PUSH mode the keepalive publishes INTO go2rtc, so the "keepalive rtsp url" is
+go2rtc's own address for that stream. Registering it as the stream's source makes
+go2rtc its own producer: the stream lists a producer, nothing feeds it, and every
+consumer gets a connection with no media.
+
+Seen live after the integration began passing go2rtc_url: one camera's stream had
+two producers, one of them `rtsp://127.0.0.1:8554/aidot_12b144cb12da` - its own
+address - and go2rtc returned HTTP 200 with a zero-byte frame for it.
+"""
+from aidot_cameras.camera.client import _is_self_referential_source as loops
+
+
+def test_push_url_for_the_same_stream_is_self_referential():
+    assert loops("rtsp://127.0.0.1:8554/aidot_12b144cb12da",
+                 "aidot_12b144cb12da") is True
+
+
+def test_push_url_for_a_different_stream_is_fine():
+    # Publishing camera A into stream B is odd but not a loop.
+    assert loops("rtsp://127.0.0.1:8554/aidot_other", "aidot_12b144cb12da") is False
+
+
+def test_the_http_serve_url_is_a_real_source():
+    # PULL mode: go2rtc fetches from the library's own serve. Must still register.
+    assert loops("http://127.0.0.1:18931/ecf4937b640c4c96a102ffdc9b51c2a0.ts",
+                 "aidot_ecf4937b640c") is False
+
+
+def test_rtsps_is_covered_too():
+    assert loops("rtsps://127.0.0.1:8554/aidot_x", "aidot_x") is True
+
+
+def test_trailing_slash_and_case_do_not_hide_it():
+    assert loops("RTSP://127.0.0.1:8554/aidot_x/", "aidot_x") is True
+
+
+def test_missing_values_are_not_self_referential():
+    assert loops("", "aidot_x") is False
+    assert loops("rtsp://127.0.0.1:8554/aidot_x", "") is False
+
+
+def test_a_remote_go2rtc_push_url_still_counts():
+    # The host does not matter; publishing into the stream you are registering is
+    # a loop wherever go2rtc lives.
+    assert loops("rtsp://go2rtc.lan:8554/aidot_x", "aidot_x") is True