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

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

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

@@ -2925,6 +2925,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 +3707,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 +3972,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 +3991,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 +4037,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.10}/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.10}/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.10}/pyproject.toml

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

python_aidot_cameras-0.12.10/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.10/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)