python-aidot-cameras 0.7.12__tar.gz → 0.7.14__tar.gz

{python_aidot_cameras-0.7.12/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.12
+Version: 0.7.14
 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.7.12 → python_aidot_cameras-0.7.14}/pyproject.toml

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

{python_aidot_cameras-0.7.12 → python_aidot_cameras-0.7.14}/src/aidot/camera/client.py

@@ -39,6 +39,7 @@ from .sdes import SdesSession  # re-exported (split into sdes.py)
 from .controls import _CameraControlsMixin
 from .protocol import (  # split into protocol.py; re-imported for use + back-compat
     _mqtt_timestamp,
+    next_backoff,
     _build_stun_binding_success_response,
     _terminal_webrtc_ack,
     _install_highport_nomination_patch,
@@ -2101,7 +2102,11 @@ class CameraMixin(_CameraControlsMixin):
         """Background task: keep SDES stream alive; push to go2rtc via RTSP."""
         _MIN_DELAY = 10.0
         _MAX_DELAY = 300.0
-        _retry_delay = _MIN_DELAY
+        # Consecutive failed / no-media opens; drives jittered exponential
+        # backoff so a degraded camera (or a fleet reconnecting at once) isn't
+        # hammered into further degradation / cloud rate-limiting. Reset only
+        # after a session that actually delivered media (see end of loop).
+        _attempt = 0
 
         while self._streaming_active:
             try:
@@ -2112,18 +2117,18 @@ class CameraMixin(_CameraControlsMixin):
             except asyncio.CancelledError:
                 return
             except Exception as exc:
+                _delay = next_backoff(_attempt, base=_MIN_DELAY, cap=_MAX_DELAY)
                 _LOGGER.warning(
                     "SDES keepalive: stream open failed for %s (retry in %.0fs): %s",
-                    self.device_id, _retry_delay, exc,
+                    self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(_retry_delay)
+                    await asyncio.sleep(_delay)
                 except asyncio.CancelledError:
                     return
-                _retry_delay = min(_retry_delay * 2, _MAX_DELAY)
+                _attempt += 1
                 continue
 
-            _retry_delay = _MIN_DELAY  # reset on success
             self._stream_session = session
             # Don't block solely on wait_done(): the SDES ffmpeg reads RTP over a
             # UDP socket with no input timeout, so when a battery camera tears the
@@ -2208,8 +2213,19 @@ class CameraMixin(_CameraControlsMixin):
                 _LOGGER.debug("camera %s: swallowed exception", '_sdes_keepalive_loop', exc_info=True)
 
             if self._streaming_active:
+                # Escalate backoff only when the session never delivered media
+                # (camera refused / degraded on a rapid reconnect); a session
+                # that streamed fine and then ended (battery teardown, consumer
+                # gone) is a normal lifecycle event and resets to the base
+                # interval so the next view reconnects promptly.
+                if session.last_media_monotonic > 0.0:
+                    _attempt = 0
+                    _delay = _MIN_DELAY
+                else:
+                    _attempt += 1
+                    _delay = next_backoff(_attempt, base=_MIN_DELAY, cap=_MAX_DELAY)
                 try:
-                    await asyncio.sleep(_MIN_DELAY)
+                    await asyncio.sleep(_delay)
                 except asyncio.CancelledError:
                     return
 
@@ -2225,7 +2241,9 @@ class CameraMixin(_CameraControlsMixin):
         # to 15 s here (+ the SDES/serve loops) if strict app parity is wanted.
         _MIN_DELAY = 5.0
         _MAX_DELAY = 300.0
-        _retry_delay = _MIN_DELAY
+        # Consecutive failed / frameless opens; drives jittered backoff (see
+        # next_backoff). Reset after a session that produced frames.
+        _attempt = 0
 
         def _on_frame(frame) -> None:
             # Accept keyframes always; accept P-frames only after first keyframe.
@@ -2248,6 +2266,7 @@ class CameraMixin(_CameraControlsMixin):
                 _LOGGER.debug("Streaming encode failed for %s: %s", self.device_id, enc_exc)
 
         while self._streaming_active:
+            _open_time = asyncio.get_running_loop().time()
             try:
                 session = await self.async_open_webrtc_stream(on_frame=_on_frame)
             except asyncio.CancelledError:
@@ -2266,18 +2285,18 @@ class CameraMixin(_CameraControlsMixin):
                     return
                 continue
             except Exception as exc:
+                _delay = next_backoff(_attempt, base=_MIN_DELAY, cap=_MAX_DELAY)
                 _LOGGER.warning(
                     "Stream open failed for %s (retry in %.0fs): %s",
-                    self.device_id, _retry_delay, exc,
+                    self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(_retry_delay)
+                    await asyncio.sleep(_delay)
                 except asyncio.CancelledError:
                     return
-                _retry_delay = min(_retry_delay * 2, _MAX_DELAY)
+                _attempt += 1
                 continue
 
-            _retry_delay = _MIN_DELAY  # reset on success
             self._stream_session = session
             try:
                 while self._streaming_active:
@@ -2302,8 +2321,17 @@ class CameraMixin(_CameraControlsMixin):
                 _LOGGER.debug("camera %s: swallowed exception", '_on_frame', exc_info=True)
 
             if self._streaming_active:
+                # Reset backoff if this session produced frames (a normal drop
+                # after good streaming); escalate with jitter if it never did
+                # (the camera-degradation case).
+                if self._last_frame_time > _open_time:
+                    _attempt = 0
+                    _delay = _MIN_DELAY
+                else:
+                    _attempt += 1
+                    _delay = next_backoff(_attempt, base=_MIN_DELAY, cap=_MAX_DELAY)
                 try:
-                    await asyncio.sleep(_MIN_DELAY)
+                    await asyncio.sleep(_delay)
                 except asyncio.CancelledError:
                     return
 
@@ -2419,7 +2447,7 @@ class CameraMixin(_CameraControlsMixin):
         # attempts so no code path (reset bug, fast PC-death) can pound the camera.
         _MIN_DELAY, _MAX_DELAY = 15.0, 300.0
         _open_gate = float(os.environ.get("AIDOT_DTLS_RETRY_GATE_S", "15"))
-        retry_delay = _MIN_DELAY
+        _attempt = 0  # consecutive failed opens; drives jittered backoff
         _last_open_at = 0.0  # monotonic of the previous open attempt (0 = none yet)
         loop = asyncio.get_running_loop()
         while self._streaming_active:
@@ -2428,7 +2456,7 @@ class CameraMixin(_CameraControlsMixin):
             aq: "_queue.Queue" = _queue.Queue(maxsize=600)
             self._serve_ready.clear()  # fresh (cold) session: not ready until bound
             # Hard inter-attempt gate (APK parity): never start an open within
-            # _open_gate seconds of the previous one, regardless of retry_delay.
+            # _open_gate seconds of the previous one, regardless of the backoff.
             _since_open = loop.time() - _last_open_at
             if _last_open_at and _since_open < _open_gate:
                 try:
@@ -2455,18 +2483,19 @@ class CameraMixin(_CameraControlsMixin):
                     return
                 continue
             except Exception as exc:
+                _delay = next_backoff(_attempt, base=_MIN_DELAY, cap=_MAX_DELAY)
                 _LOGGER.warning(
                     "DTLS serve: open failed for %s (retry %.0fs): %s",
-                    self.device_id, retry_delay, exc,
+                    self.device_id, _delay, exc,
                 )
                 try:
-                    await asyncio.sleep(retry_delay)
+                    await asyncio.sleep(_delay)
                 except asyncio.CancelledError:
                     return
-                retry_delay = min(retry_delay * 2, _MAX_DELAY)
+                _attempt += 1
                 continue
 
-            retry_delay = _MIN_DELAY
+            _attempt = 0
             self._stream_session = session
             pc = session._pc
             # PC-dead test for the serve loop.  closed/failed are terminal at
@@ -8091,6 +8120,10 @@ class CameraMixin(_CameraControlsMixin):
         # Proc holder: set to the ffmpeg Popen object after launch so the
         # bridge thread can poll for exit without a NameError race.
         _proc_holder: list = [None]
+        # Camera's actual video payload type (96=H.264 / 97=H.265), set by the
+        # bridge on the first video RTP packet so the ffmpeg SDP can be narrowed
+        # to the matching single codec before ffmpeg is launched.
+        _first_video_pt: list = [None]
         # Media-liveness: bridge sets [0] = time.monotonic() on every forwarded
         # media packet; the keepalive watchdog reads it via SdesSession to
         # restart a session the camera silently stopped feeding.
@@ -9108,6 +9141,7 @@ class CameraMixin(_CameraControlsMixin):
                                     )
                             elif _kind == "video" and not _br_first_video_logged:
                                 _br_first_video_logged = True
+                                _first_video_pt[0] = _pt
                                 _status(f"bridge: first video RTP pt={_pt}")
                                 # Camera answers BUNDLE (all media on one 5-tuple),
                                 # so the talk destination is the same address as
@@ -9426,6 +9460,46 @@ class CameraMixin(_CameraControlsMixin):
             *_time_args,
             *dest_args,
         ]
+        # --- H.265 fix: narrow the ffmpeg SDP to the camera's actual codec ----
+        # The camera streams H.264 (pt=96) OR H.265 (pt=97), varying per session.
+        # An m=video line listing both ("96 97") makes ffmpeg bind the RTP
+        # depacketizer to the FIRST pt (96/H.264) and silently drop the camera's
+        # H.265 packets -> 0 frames.  Wait for the bridge to observe the real
+        # video pt, then rewrite the SDP to that single codec before launch.
+        # ffmpeg recovers on the next periodic keyframe, so the small spawn delay
+        # is harmless.  Falls back to the dual-codec SDP if no video is seen.
+        _vpt_deadline = time.monotonic() + 15.0
+        while _first_video_pt[0] is None and time.monotonic() < _vpt_deadline:
+            await asyncio.sleep(0.1)
+        _vpt = _first_video_pt[0]
+        if _vpt in (96, 97):
+            def _narrow_sdp_to_pt(_sdp_text: str, _keep: int) -> str:
+                _drop = 96 if _keep == 97 else 97
+                _kept = []
+                for _ln in _sdp_text.splitlines(keepends=True):
+                    _s = _ln.lstrip()
+                    if _s.startswith("m=video"):
+                        _ln = _ln.replace(" 96 97", f" {_keep}")
+                    elif (_s.startswith(f"a=rtpmap:{_drop} ")
+                          or _s.startswith(f"a=fmtp:{_drop} ")
+                          or _s.startswith(f"a=fmtp:{_drop};")):
+                        continue
+                    _kept.append(_ln)
+                return "".join(_kept)
+            def _read_sdp_file() -> str:
+                with open(sdp_path, encoding="utf-8") as _f_sdp:
+                    return _f_sdp.read()
+            try:
+                _cur_sdp = await asyncio.get_running_loop().run_in_executor(
+                    None, _read_sdp_file)
+                await asyncio.get_running_loop().run_in_executor(
+                    None, _write_text_file, sdp_path,
+                    _narrow_sdp_to_pt(_cur_sdp, int(_vpt)))
+                _status(
+                    f"SDES: narrowed ffmpeg SDP to video pt={_vpt}"
+                    f" ({'H265' if int(_vpt) == 97 else 'H264'})")
+            except Exception:
+                _LOGGER.debug("camera %s: swallowed exception", '_open_sdes_stream', exc_info=True)
         _LOGGER.info("SDES ffmpeg cmd: %s", " ".join(cmd))
         if _ffmpeg_path() is None:
             # ffmpeg is not installed - clean up and surface a clear error

{python_aidot_cameras-0.7.12 → python_aidot_cameras-0.7.14}/src/aidot/camera/protocol.py

@@ -396,6 +396,39 @@ async def _webrtc_consume_video(track: Any, on_frame: Callable) -> None:
             break
 
 
+def next_backoff(
+    attempt: int,
+    *,
+    base: float,
+    cap: float,
+    rand: Optional[Callable[[], float]] = None,
+) -> float:
+    """Jittered exponential backoff (AWS-style) with a hard floor at ``base``.
+
+    Returns the retry delay for 0-based ``attempt``: an exponential ceiling
+    ``base * 2**attempt`` (capped at ``cap``), with the actual delay drawn
+    uniformly in ``[base, ceiling]``. The random spread de-synchronizes
+    concurrent reconnects so a fleet of cameras (or repeated failures of one)
+    recovering at the same moment doesn't stampede the cloud / MQTT broker into
+    a reconnect storm or rate-limit -- plain ``delay *= 2`` keeps every retrier
+    in lockstep, jitter breaks the lockstep while preserving the same average
+    growth.
+
+    ``attempt`` 0 always returns exactly ``base`` (preserving the loops'
+    existing minimum spacing). ``rand`` defaults to ``random.random`` and is
+    injectable so the policy is unit-testable without randomness.
+    """
+    if rand is None:
+        rand = random.random
+    # Clamp the exponent: a long-lived failing camera can drive ``attempt`` high,
+    # and 2**attempt overflows float64 around attempt~1024. The ceiling saturates
+    # at ``cap`` long before that, so 30 doublings is always enough headroom.
+    ceiling = min(cap, base * (2 ** min(max(attempt, 0), 30)))
+    if ceiling <= base:
+        return base
+    return base + rand() * (ceiling - base)
+
+
 def _write_text_file(path: str, text: str) -> None:
     """Write ``text`` to ``path`` synchronously.
 

{python_aidot_cameras-0.7.12 → python_aidot_cameras-0.7.14/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -35,6 +35,7 @@ src/python_aidot_cameras.egg-info/dependency_links.txt
 src/python_aidot_cameras.egg-info/requires.txt
 src/python_aidot_cameras.egg-info/top_level.txt
 tests/test_alarm_event.py
+tests/test_backoff.py
 tests/test_go2rtc.py
 tests/test_highport_nomination.py
 tests/test_lan_control.py

python_aidot_cameras-0.7.14/tests/test_backoff.py

@@ -0,0 +1,84 @@
+"""Unit tests for the jittered exponential-backoff helper.
+
+next_backoff() is the pure reconnect-delay policy the camera keepalive/serve
+loops use so a degraded camera (or a fleet reconnecting at once) is met with
+spread-out, escalating retries instead of a synchronized storm. Randomness is
+injected so the bounds are deterministic. No camera/network needed.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+from aidot.camera.protocol import next_backoff
+
+_BASE = 10.0
+_CAP = 300.0
+
+
+def _lo():  # rand() -> 0.0 : the low end of the jitter window
+    return 0.0
+
+
+def _hi():  # rand() -> ~1.0 : the high end of the jitter window
+    return 1.0
+
+
+def test_attempt_zero_is_exactly_base():
+    # First retry must preserve the loops' existing minimum spacing.
+    assert next_backoff(0, base=_BASE, cap=_CAP, rand=_lo) == _BASE
+    assert next_backoff(0, base=_BASE, cap=_CAP, rand=_hi) == _BASE
+
+
+def test_floor_is_always_base():
+    # Low end of the window never dips below base, at any attempt.
+    for a in range(0, 12):
+        assert next_backoff(a, base=_BASE, cap=_CAP, rand=_lo) >= _BASE
+
+
+def test_ceiling_grows_exponentially_until_cap():
+    # rand()->1 gives the ceiling: base*2**attempt, capped at cap.
+    assert next_backoff(1, base=_BASE, cap=_CAP, rand=_hi) == 20.0
+    assert next_backoff(2, base=_BASE, cap=_CAP, rand=_hi) == 40.0
+    assert next_backoff(3, base=_BASE, cap=_CAP, rand=_hi) == 80.0
+
+
+def test_ceiling_saturates_at_cap():
+    # 10*2**5 = 320 > cap(300) -> saturates at cap.
+    assert next_backoff(5, base=_BASE, cap=_CAP, rand=_hi) == _CAP
+    assert next_backoff(50, base=_BASE, cap=_CAP, rand=_hi) == _CAP
+
+
+def test_delay_within_bounds_for_real_rng():
+    # With the real RNG every draw stays in [base, min(cap, base*2**attempt)].
+    for a in range(0, 10):
+        ceiling = min(_CAP, _BASE * (2 ** a))
+        for _ in range(200):
+            d = next_backoff(a, base=_BASE, cap=_CAP)
+            assert _BASE <= d <= ceiling
+
+
+def test_large_attempt_does_not_overflow():
+    # A long-lived failing camera can drive attempt very high; the exponent is
+    # clamped so base*2**attempt never overflows float64.
+    assert next_backoff(5000, base=_BASE, cap=_CAP, rand=_hi) == _CAP
+    assert next_backoff(5000, base=_BASE, cap=_CAP, rand=_lo) == _BASE
+
+
+def test_negative_attempt_treated_as_zero():
+    assert next_backoff(-3, base=_BASE, cap=_CAP, rand=_lo) == _BASE
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)