python-aidot-cameras 1.0.0b31__tar.gz → 1.0.0b32__tar.gz

{python_aidot_cameras-1.0.0b31/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0b32}/PKG-INFO

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

@@ -566,6 +566,36 @@ _SERVE_REORDER_QUEUE = int(os.environ.get("AIDOT_SERVE_REORDER_QUEUE", "500"))
 #: failure this is meant to prevent.
 _SERVE_MAX_DELAY_US = int(os.environ.get("AIDOT_SERVE_MAX_DELAY_US", "500000"))
 
+#: How long (seconds) the serve ffmpeg waits with NO packets on any RTP socket
+#: before its SDP input errors out ("Error during demuxing: Operation timed
+#: out") and the serve dies.  ffmpeg's own default is 10 s (READ_PACKET_TIMEOUT_S,
+#: applied through the sdp demuxer's ``listen_timeout`` option).  Measured on an
+#: A001064 (2026-08-24/25): the camera episodically stops transmitting for
+#: >=10 s mid-session, and every reopen afterwards succeeds immediately, so the
+#: link recovers on a 10-20 s scale.  A mains camera therefore gets 30 s to ride
+#: the gap out; a battery camera keeps ffmpeg's 10 s default, because its stops
+#: are real sleeps that only a reopen (with its wake) ends - waiting longer just
+#: freezes the picture.  ``AIDOT_SERVE_INPUT_TIMEOUT_S`` overrides both.
+_SERVE_INPUT_TIMEOUT_MAINS_S = 30
+_SERVE_INPUT_TIMEOUT_BATTERY_S = 10
+
+
+def _resolve_serve_input_timeout_s(is_battery: bool) -> int:
+    """Seconds the serve's SDP input tolerates total silence before erroring.
+
+    Pure policy (unit-testable): the env override wins for every camera; else
+    mains rides out a transmit gap and battery keeps the fast default.
+    """
+    _env = os.environ.get("AIDOT_SERVE_INPUT_TIMEOUT_S")
+    if _env:
+        try:
+            return max(1, int(_env))
+        except ValueError:
+            pass
+    return (_SERVE_INPUT_TIMEOUT_BATTERY_S if is_battery
+            else _SERVE_INPUT_TIMEOUT_MAINS_S)
+
+
 #: How long to wait after a camera answers -50002 / -50015 ("no free session").
 #: Both loops used to wait _MAX_DELAY (300s) on the belief that the camera
 #: "releases slowly". Measured 2026-08-07 on an A001064: reopening 2s after a
@@ -630,6 +660,7 @@ def _build_sdes_serve_cmd(
     audio_gain_db: float = -8.0,
     push_video_only: bool = False,
     video_decoder: Optional[list] = None,
+    input_timeout_s: Optional[int] = None,
 ) -> list:
     """Build the ffmpeg argv for the SDES bridge serve.
 
@@ -778,6 +809,13 @@ def _build_sdes_serve_cmd(
         # before giving up on a gap rather than stalling the pipeline.
         "-reorder_queue_size", str(_SERVE_REORDER_QUEUE),
         "-max_delay", str(_SERVE_MAX_DELAY_US),
+        # Input silence tolerance: the sdp demuxer's ``listen_timeout`` doubles
+        # as its packet-read timeout (READ_PACKET_TIMEOUT_S, ffmpeg default
+        # 10 s).  See _resolve_serve_input_timeout_s for the mains/battery
+        # policy.  Input option, so it must sit before -i; None keeps ffmpeg's
+        # default (no behavior change for callers that do not opt in).
+        *(["-listen_timeout", str(int(input_timeout_s))]
+          if input_timeout_s is not None else []),
         "-i", sdp_path,
         *dest_args,
     ]

{python_aidot_cameras-1.0.0b31 → python_aidot_cameras-1.0.0b32}/aidot_cameras/camera/sdes_open.py

@@ -1218,6 +1218,42 @@ def _classify_ffmpeg_exit(rc: int, teardown_requested: bool) -> int:
     return logging.WARNING
 
 
+#: Mid-session stall nudge (see _stall_nudge_due): enabled by default;
+#: ``AIDOT_SDES_STALL_NUDGE=0`` turns it off and
+#: ``AIDOT_SDES_STALL_NUDGE_AFTER_S`` moves the trigger point.
+_STALL_NUDGE_ENABLED = os.environ.get("AIDOT_SDES_STALL_NUDGE", "1") != "0"
+_STALL_NUDGE_AFTER_S = float(
+    os.environ.get("AIDOT_SDES_STALL_NUDGE_AFTER_S", "2.5"))
+
+
+def _stall_nudge_due(
+    *,
+    silence_s: float,
+    nudges_sent: int,
+    since_last_nudge_s: float,
+    stall_after_s: float = 2.5,
+    max_nudges: int = 3,
+    interval_s: float = 2.0,
+) -> bool:
+    """Whether the bridge should re-send AVIO LIVING for a mid-session stall.
+
+    The A001064 episodically stops transmitting mid-session with no teardown
+    signal; every reopen afterwards succeeds immediately, so the camera is
+    awake and answering handshakes seconds after it stopped (measured
+    2026-08-24/25).  LIVING is the message that starts media on a fresh
+    session, so re-sending it on the live session is the cheapest possible
+    revive attempt.  Bounded (a few sends, spaced out) so a camera that is
+    truly asleep or out of range is not spammed - the serve's input timeout
+    and the keepalive reopen remain the unchanged fallback.  Pure function so
+    the policy is unit-testable without a live bridge.
+    """
+    if silence_s <= stall_after_s:
+        return False
+    if nudges_sent >= max_nudges:
+        return False
+    return since_last_nudge_s >= interval_s
+
+
 def _bridge_should_break(rc, teardown_requested: bool) -> bool:
     """Whether the bridge observe loop should end on this poll() result.
 
@@ -1623,7 +1659,7 @@ class _SdesOpenMixin:
         SDP answer, writes it to a temp file, and launches ffmpeg to receive and
         record the SRTP stream.
         """
-        from .client import CameraMixin, _build_sdes_serve_cmd, _ffmpeg_path, _spawn_bg  # lazy: break client<->sdes_open cycle
+        from .client import CameraMixin, _build_sdes_serve_cmd, _ffmpeg_path, _resolve_serve_input_timeout_s, _spawn_bg  # lazy: break client<->sdes_open cycle
         import base64
         import subprocess
 
@@ -4099,6 +4135,9 @@ class _SdesOpenMixin:
             _trigger_peer       = None    # camera's real addr when relayed
             _sdes_probe_received = False  # True after first 0xC8 probe from camera
             _last_hb_ts         = 0.0     # time of last AVIO HEARTBEAT send
+            _stall_nudges_sent  = 0       # LIVING re-sends for the CURRENT stall
+            _stall_last_nudge   = 0.0     # wall time of the last stall nudge
+            _stall_active       = False   # media had started, then went silent
             # One-shot guard for the "ffmpeg exited" log below: while the held
             # proc keeps reporting the same stale exit code across a
             # teardown-window skip (see _bridge_should_break), only the first
@@ -4537,12 +4576,17 @@ class _SdesOpenMixin:
                             except Exception as _dw_e:
                                 _status(f"SDES DC: DCEP_WAIT LIVING err: {_dw_e}")
 
-                    # Periodic retrigger: resend AVIO LIVING every 2s until probe
-                    # received (camera acknowledged our trigger).
-                    if (_avio_living_sent
-                            and not _sdes_probe_received
-                            and _trigger_bs is not None
-                            and _time_br.time() - _last_trigger_ts >= 2.0):
+                    # One LIVING wire-build, shared by the pre-probe retrigger
+                    # below and the mid-session stall nudge: resend the AVIO
+                    # LIVING(5376) that starts media, encrypted then plaintext
+                    # exactly like the original trigger.
+                    # Default-arg binding (not closure capture): re-defined each
+                    # tick, so the CURRENT trigger socket/addrs are bound at
+                    # definition time and B023 cannot bite.
+                    def _resend_avio_living(
+                            _tb=_trigger_bs,
+                            _tsrc=_trigger_bsrc,
+                            _tpeer=_trigger_peer) -> None:
                         import struct as _st_re2
                         import random as _r_re2
                         _re_ts  = int(_time_br.time() * 1000)
@@ -4568,15 +4612,63 @@ class _SdesOpenMixin:
                             _rsz = len(_rp)
                             try:
                                 _br_send_to_cam(
-                                    _trigger_bs,
+                                    _tb,
                                     bytes([0xC8, 0x00, _rsz >> 8, _rsz & 0xFF]) + _rp,
-                                    _trigger_bsrc,
-                                    _trigger_peer,
+                                    _tsrc,
+                                    _tpeer,
                                 )
                             except Exception:
                                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
+
+                    # Periodic retrigger: resend AVIO LIVING every 2s until probe
+                    # received (camera acknowledged our trigger).
+                    if (_avio_living_sent
+                            and not _sdes_probe_received
+                            and _trigger_bs is not None
+                            and _time_br.time() - _last_trigger_ts >= 2.0):
+                        _resend_avio_living()
                         _last_trigger_ts = _time_br.time()
 
+                    # Mid-session stall nudge: the camera episodically stops
+                    # transmitting with no teardown signal (A001064, measured
+                    # 2026-08-24/25), the serve's input then times out and the
+                    # session dies - yet the camera answers a FRESH handshake
+                    # immediately afterwards.  So before letting it die, re-send
+                    # the LIVING that starts media.  The AVIO HEARTBEAT alone
+                    # does not do this: heartbeats kept flowing right through
+                    # measured stalls while the media stayed silent.  Bounded by
+                    # _stall_nudge_due; the input timeout and the keepalive
+                    # reopen remain the unchanged fallback.
+                    if (_STALL_NUDGE_ENABLED
+                            and _sdes_probe_received
+                            and _trigger_bs is not None
+                            and _media_progress[0] > 0.0):
+                        _stall_silence = (
+                            _time_br.monotonic() - _media_progress[0])
+                        if _stall_silence <= _STALL_NUDGE_AFTER_S:
+                            if _stall_active:
+                                _stall_active = False
+                                _stall_nudges_sent = 0
+                                # Ask for an immediate IDR so recovery is not
+                                # hostage to the 30s PLI cadence.
+                                _bridge_fn._last_pli_ts = 0.0
+                                _status(
+                                    "SDES: media resumed after stall"
+                                    " - PLI re-armed")
+                        elif _stall_nudge_due(
+                                silence_s=_stall_silence,
+                                nudges_sent=_stall_nudges_sent,
+                                since_last_nudge_s=(
+                                    _time_br.time() - _stall_last_nudge),
+                                stall_after_s=_STALL_NUDGE_AFTER_S):
+                            _stall_active = True
+                            _stall_nudges_sent += 1
+                            _stall_last_nudge = _time_br.time()
+                            _status(
+                                f"SDES: no media for {_stall_silence:.1f}s"
+                                f" - LIVING nudge {_stall_nudges_sent}/3")
+                            _resend_avio_living()
+
                     for _bs in _rl:
                         try:
                             _bpkt, _bsrc = _bs.recvfrom(4096)
@@ -6278,6 +6370,8 @@ class _SdesOpenMixin:
             audio_gain_db=self._resolve_sdes_audio_gain_db(),
             push_video_only=_push_video_only,
             video_decoder=_video_decoder,
+            input_timeout_s=_resolve_serve_input_timeout_s(
+                bool(getattr(self, "is_battery_camera", False))),
         )
         # Audio matters even more than video here.  A multi-PT m-line makes ffmpeg
         # bind the depacketizer to the FIRST payload type and silently discard the

{python_aidot_cameras-1.0.0b31 → python_aidot_cameras-1.0.0b32}/pyproject.toml

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

{python_aidot_cameras-1.0.0b31 → python_aidot_cameras-1.0.0b32/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -218,6 +218,7 @@ tests/test_sdp_payload_type_narrowing.py
 tests/test_security_hardening.py
 tests/test_self_peer_is_an_address_not_an_ip.py
 tests/test_serializable_login_info.py
+tests/test_serve_input_timeout.py
 tests/test_serve_loss_tolerance.py
 tests/test_serve_pt_respects_the_pin.py
 tests/test_serve_relay.py
@@ -232,6 +233,7 @@ tests/test_sprop_unstable_public.py
 tests/test_sprop_write_is_reported_truthfully.py
 tests/test_srtp_rx_rekey.py
 tests/test_srtp_tx_key_note.py
+tests/test_stall_nudge_policy.py
 tests/test_stall_report_says_what_the_answer_carried.py
 tests/test_stall_report_says_whether_the_trigger_was_answered.py
 tests/test_stall_report_separates_silence_from_undecryptable.py

python_aidot_cameras-1.0.0b32/tests/test_serve_input_timeout.py

@@ -0,0 +1,65 @@
+"""Unit tests for the serve's SDP-input silence tolerance.
+
+The sdp demuxer's ``listen_timeout`` doubles as its packet-read timeout
+(ffmpeg READ_PACKET_TIMEOUT_S, default 10 s): 10 s with no packets on any RTP
+socket errors the input ("Error during demuxing: Operation timed out") and the
+serve dies.  Measured on an A001064, the camera episodically stops
+transmitting for >=10 s mid-session and the link recovers on a 10-20 s scale,
+so a mains camera rides the gap out with a longer window while a battery
+camera keeps the fast default (its stops are real sleeps that only a reopen
+ends).
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from aidot_cameras.camera.client import (  # noqa: E402
+    _SERVE_INPUT_TIMEOUT_BATTERY_S,
+    _SERVE_INPUT_TIMEOUT_MAINS_S,
+    _build_sdes_serve_cmd as build,
+    _resolve_serve_input_timeout_s as resolve,
+)
+
+
+def test_mains_gets_the_long_window():
+    assert resolve(False) == _SERVE_INPUT_TIMEOUT_MAINS_S == 30
+
+
+def test_battery_keeps_ffmpeg_default():
+    # 10 is ffmpeg's own READ_PACKET_TIMEOUT_S: passing it changes nothing for
+    # battery cameras, whose mid-session stops are real sleeps.
+    assert resolve(True) == _SERVE_INPUT_TIMEOUT_BATTERY_S == 10
+
+
+def test_env_override_wins_for_both(monkeypatch):
+    monkeypatch.setenv("AIDOT_SERVE_INPUT_TIMEOUT_S", "45")
+    assert resolve(False) == 45
+    assert resolve(True) == 45
+
+
+def test_env_override_garbage_falls_back(monkeypatch):
+    monkeypatch.setenv("AIDOT_SERVE_INPUT_TIMEOUT_S", "soon")
+    assert resolve(False) == _SERVE_INPUT_TIMEOUT_MAINS_S
+    assert resolve(True) == _SERVE_INPUT_TIMEOUT_BATTERY_S
+
+
+def test_env_override_is_floored_at_one_second(monkeypatch):
+    monkeypatch.setenv("AIDOT_SERVE_INPUT_TIMEOUT_S", "0")
+    assert resolve(False) == 1
+
+
+def test_builder_places_listen_timeout_before_input():
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="rtsp://127.0.0.1:8554/cam",
+                input_timeout_s=30)
+    i = cmd.index("-listen_timeout")
+    assert cmd[i + 1] == "30"
+    # Input option: must precede -i, or ffmpeg reads it as an output option.
+    assert i < cmd.index("-i")
+
+
+def test_builder_default_is_unchanged_behavior():
+    # None -> no flag at all, so callers that do not opt in keep ffmpeg's own
+    # default (and the argv stays byte-identical to pre-change builds).
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="rtsp://127.0.0.1:8554/cam")
+    assert "-listen_timeout" not in cmd

python_aidot_cameras-1.0.0b32/tests/test_stall_nudge_policy.py

@@ -0,0 +1,51 @@
+"""Unit tests for _stall_nudge_due - the mid-session stall-nudge policy.
+
+The A001064 episodically stops transmitting mid-session with no teardown
+signal, yet answers a fresh handshake immediately afterwards.  The bridge
+therefore re-sends the AVIO LIVING that starts media before letting the
+serve's input timeout kill the session.  This policy decides when: bounded
+sends, spaced out, and never before a real stall threshold - the input
+timeout and the keepalive reopen remain the fallback.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from aidot_cameras.camera.sdes_open import _stall_nudge_due as due  # noqa: E402
+
+
+def test_no_nudge_while_media_flows():
+    assert not due(silence_s=0.4, nudges_sent=0, since_last_nudge_s=99.0)
+
+
+def test_no_nudge_at_or_below_threshold():
+    assert not due(silence_s=2.5, nudges_sent=0, since_last_nudge_s=99.0)
+
+
+def test_first_nudge_past_threshold():
+    assert due(silence_s=2.6, nudges_sent=0, since_last_nudge_s=99.0)
+
+
+def test_nudges_are_spaced():
+    # 1 s after the previous nudge: too soon; 2 s: due again.
+    assert not due(silence_s=5.0, nudges_sent=1, since_last_nudge_s=1.0)
+    assert due(silence_s=5.0, nudges_sent=1, since_last_nudge_s=2.0)
+
+
+def test_nudges_are_bounded():
+    # After max_nudges the camera is presumed truly asleep/out of range and
+    # the fallback path (input timeout -> reopen) takes over unmolested.
+    assert not due(silence_s=60.0, nudges_sent=3, since_last_nudge_s=99.0)
+
+
+def test_threshold_is_parameterised():
+    assert due(silence_s=1.1, nudges_sent=0, since_last_nudge_s=99.0,
+               stall_after_s=1.0)
+    assert not due(silence_s=1.1, nudges_sent=0, since_last_nudge_s=99.0,
+                   stall_after_s=2.5)
+
+
+def test_max_is_parameterised():
+    assert due(silence_s=60.0, nudges_sent=3, since_last_nudge_s=99.0,
+               max_nudges=5)