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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.5
+Version: 0.15.7
 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.5 → python_aidot_cameras-0.15.7}/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)
@@ -3600,7 +3637,16 @@ class _SdesOpenMixin:
                                 if not _sdes_probe_received:
                                     _sdes_probe_received = True
                                     _last_hb_ts = _time_br.time()  # HB fires in 10s
-                                if not hasattr(_bridge_fn, '_tutk_seq'):
+                                # Guard on a counter that is actually assigned.
+                                # This used to test `_tutk_seq`, a name nothing
+                                # ever set, so hasattr was False on EVERY packet
+                                # and both counters were reset to 0 each time -
+                                # every synthesized packet went out with
+                                # sequence number 1.  ffmpeg reads a constant
+                                # sequence as a stream of discontinuities and
+                                # reports `RTP: missed N packets` for loss that
+                                # never happened.
+                                if not hasattr(_bridge_fn, '_tutk_seq_v'):
                                     _bridge_fn._tutk_seq_a = 0
                                     _bridge_fn._tutk_seq_v = 0
                                 if _tk_audio:

{python_aidot_cameras-0.15.5 → python_aidot_cameras-0.15.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.5"
+version = "0.15.7"
 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.5 → python_aidot_cameras-0.15.7/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -78,6 +78,7 @@ tests/test_battery_detection.py
 tests/test_battery_evidence_corroboration.py
 tests/test_battery_skip_turn.py
 tests/test_ble_gateway.py
+tests/test_bridge_state_sentinels.py
 tests/test_constants_imports_resolve.py
 tests/test_deferred_hardening.py
 tests/test_device_login_guard.py
@@ -109,6 +110,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.7/tests/test_bridge_state_sentinels.py

@@ -0,0 +1,68 @@
+"""Lazy-init guards on the bridge must name a variable something actually sets.
+
+The bridge keeps its per-session state as attributes on its own function object
+and initialises them with `if not hasattr(_bridge_fn, 'X')`. That idiom fails
+silently when `X` is not the attribute the block goes on to assign: the guard is
+true on every packet, so the state resets every packet, and nothing raises.
+
+It happened. The TUTK-to-RTP synthesis guarded on `_tutk_seq` while assigning
+`_tutk_seq_a` and `_tutk_seq_v`, so both sequence counters reset on every packet
+and every synthesized RTP packet carried sequence number 1. ffmpeg reads a
+constant sequence as a stream of discontinuities and logs `RTP: missed N
+packets` - loss that never happened, on a hop where the kernel counters showed
+zero drops. Measured on the box: 0 drops on every socket in the path while
+ffmpeg reported 21 new missed-packet lines in one window.
+
+These tests read the source because the bridge is one long closure that cannot
+be called in isolation.
+"""
+import inspect
+import re
+
+from aidot_cameras.camera import sdes_open
+
+_SRC = inspect.getsource(sdes_open)
+
+
+def _assigned_attrs() -> set:
+    """Every `_bridge_fn.X = ...` attribute assigned anywhere in the module."""
+    return set(re.findall(r"_bridge_fn\.([A-Za-z_][A-Za-z0-9_]*)\s*=[^=]", _SRC))
+
+
+def test_every_hasattr_sentinel_is_a_name_something_assigns():
+    guarded = set(re.findall(r"hasattr\(_bridge_fn,\s*'([^']+)'\)", _SRC))
+    assigned = _assigned_attrs()
+    orphans = sorted(guarded - assigned)
+    assert not orphans, (
+        "these hasattr guards name attributes nothing ever assigns, so they are "
+        f"true on every packet and reset their state each time: {orphans}"
+    )
+
+
+def test_the_tutk_sequence_counters_survive_between_packets():
+    """The specific regression: a constant RTP sequence number.
+
+    Pin the guard to a counter the block assigns, so a reset-per-packet cannot
+    come back by renaming one side of the pair.
+    """
+    block = re.search(
+        r"if not hasattr\(_bridge_fn,\s*'([^']+)'\):\s*\n"
+        r"\s*_bridge_fn\._tutk_seq_a = 0\s*\n"
+        r"\s*_bridge_fn\._tutk_seq_v = 0",
+        _SRC,
+    )
+    assert block, "the TUTK sequence init block moved - re-point this test"
+    sentinel = block.group(1)
+    assert sentinel in ("_tutk_seq_a", "_tutk_seq_v"), (
+        f"the guard tests {sentinel!r}, which is not one of the counters it "
+        "initialises - the counters will reset on every packet and every "
+        "synthesized packet will carry the same sequence number"
+    )
+
+
+def test_the_counters_increment_rather_than_being_reassigned():
+    """Both counters must advance from their previous value, not restart."""
+    for name in ("_tutk_seq_a", "_tutk_seq_v"):
+        assert re.search(
+            rf"_bridge_fn\.{name} = \(_bridge_fn\.{name} \+ 1\) & 0xFFFF", _SRC
+        ), f"{name} no longer advances from its own previous value"

python_aidot_cameras-0.15.7/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"