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

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

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

@@ -746,6 +746,77 @@ def video_pt_from_answer_sdp(sdp_text: str) -> Optional[int]:
     return None
 
 
+def answer_pt_kinds(sdp_text: str) -> dict:
+    """Map each payload type in the camera's answer to the kind that owns it.
+
+    The bridge demuxes a BUNDLEd stream by RTP payload type, and until this
+    existed it did so from a fixed table: 96/97/98 video, 0/8 audio.  That
+    table is wrong for this fleet.  Measured 2026-08-26 across 107 A001064
+    opens, **15 of them (14%) negotiated H265 on payload type 0** -- announced
+    correctly in the answer as ``m=video ... 0`` with ``a=rtpmap:0 H265/90000``
+    -- and then sent 2668 full-size (1222 B) video packets on pt=0 while audio
+    ran normally on pt=8.  The fixed table posted every one of those video
+    packets to ffmpeg's AUDIO loopback, so no video was ever observed, the 75 s
+    first-media wait ran out, and the serve launched into an empty stream and
+    exited: 82 s wasted, then a full reopen.  The other 92 opens answered
+    ``m=video ... 96`` and worked.  Perfect separation, both directions.
+
+    The answer is the authority on this and is already in hand: PT numbering is
+    per-m-section by definition, so a section's fmt list names the kind of every
+    payload type in it.  ``tests/test_answer_section_selection.py`` records the
+    same renumbering on the A000088 (PT 0 carrying H265), and the DTLS path
+    already selects sections by content for it; the SDES bridge was the one
+    place still trusting a static tuple.
+
+    A payload type claimed by BOTH an audio and a video section is dropped from
+    the map rather than guessed at -- an ambiguous answer is not better evidence
+    than the fallback table, and silently preferring one section would be the
+    same class of assumption this function exists to remove.  Malformed m= lines
+    are skipped, never raised on: this feeds a media path.
+    """
+    kinds: dict = {}
+    dropped: set = set()
+    for raw in (sdp_text or "").splitlines():
+        line = raw.strip()
+        if not line.startswith("m=audio") and not line.startswith("m=video"):
+            continue
+        parts = line.split()
+        if len(parts) < 4:
+            continue
+        kind = "video" if line.startswith("m=video") else "audio"
+        for tok in parts[3:]:
+            try:
+                pt = int(tok)
+            except ValueError:
+                continue
+            if not 0 <= pt <= 127:
+                continue
+            if kinds.get(pt, kind) != kind:
+                dropped.add(pt)
+            kinds[pt] = kind
+    for pt in dropped:
+        kinds.pop(pt, None)
+    return kinds
+
+
+def rewrite_rtp_payload_type(pkt: bytes, pt: int) -> bytes:
+    """Return ``pkt`` with its RTP payload type replaced, marker bit preserved.
+
+    Used only where the bridge itself decrypted the packet (``_use_plain_rtp``),
+    so what is being edited is plaintext on its way to our own loopback -- never
+    a packet ffmpeg will authenticate, where a changed byte would fail the SRTP
+    auth tag.  RTP byte 1 is ``M(1) | PT(7)`` (RFC 3550), so only the low seven
+    bits move.
+
+    A packet too short to hold that byte is returned untouched rather than
+    rejected: this is the media path, and a malformed packet is ffmpeg's to
+    discard, not the bridge's to raise on.
+    """
+    if len(pkt) < 2:
+        return pkt
+    return pkt[:1] + bytes([(pkt[1] & 0x80) | (pt & 0x7F)]) + pkt[2:]
+
+
 #: Video payload types the SDES answer template advertises (H264, H265).
 _SDES_ANSWER_VIDEO_PTS = (96, 97)
 
@@ -1218,6 +1289,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 +1730,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
 
@@ -4002,6 +4109,10 @@ class _SdesOpenMixin:
         # list for the same reason as _first_video_pt: the serve-restart path
         # reads it from a nested scope.
         _answer_video_pt: list = [None]
+        # PT -> "video"/"audio" from the camera's answer, read by the
+        # bridge demux. Empty until the answer lands (the bridge starts
+        # first), which is exactly when the static-tuple fallback applies.
+        _answer_pt_kinds: dict = {}
         # Same for audio: the ffmpeg SDP advertises BOTH PCMU (0) and PCMA (8),
         # and ffmpeg binds the depacketizer to the first one listed - so the line
         # has to be narrowed to the payload type the camera actually sends, the
@@ -4099,6 +4210,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 +4651,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 +4687,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)
@@ -5506,7 +5673,55 @@ class _SdesOpenMixin:
                                     _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_bridge_fn', exc_info=True)
                                 continue
                             _pt = _pt_byte & 0x7F
-                            if _pt in (96, 97, 98):
+                            # The ANSWER decides which payload type is which
+                            # kind; the tuples below are only the fallback for a
+                            # packet that beats the answer in.  See
+                            # answer_pt_kinds: this camera negotiates H265 on
+                            # pt=0 in ~14% of sessions and the fixed tuples sent
+                            # every one of those video streams to the AUDIO
+                            # loopback.
+                            _kind_answered = _answer_pt_kinds.get(_pt)
+                            _pt_out = _pt
+                            if _kind_answered == "video":
+                                _btgt, _lo_target, _kind = (
+                                    _lo_video_port, _lo_v, "video"
+                                )
+                                # The bridge starts before the answer lands, so
+                                # a video packet on an unexpected PT can beat the
+                                # map in by a few hundred ms and latch as the
+                                # session's "first audio".  Left alone that
+                                # narrows the serve's audio line to a payload
+                                # type no audio uses, and the mpegts mux then
+                                # withholds PAT/PMT waiting for a stream that
+                                # never produces - costing the picture, not just
+                                # the sound.  Undo it and let real audio latch.
+                                if _first_audio_pt[0] == _pt:
+                                    _first_audio_pt[0] = None
+                                    _br_first_audio_logged = False
+                                    _status(
+                                        "bridge: pt=%d re-classified as video"
+                                        " from the answer - clearing the audio"
+                                        " latch it took first" % _pt)
+                                # Our serve SDP describes video as 96=H264 /
+                                # 97=H265 only, so a camera-numbered payload
+                                # type we do not advertise must be translated
+                                # into our numbering before ffmpeg sees it -
+                                # the same translation video_pt_from_answer_sdp
+                                # already performs for the SDP side ("the
+                                # camera's own numbering need not agree").
+                                # Gated on _use_plain_rtp because only there is
+                                # the bridge the decryptor and the packet
+                                # reaching ffmpeg plaintext; rewriting a byte
+                                # ffmpeg will itself authenticate breaks SRTP.
+                                if (_pt not in _SDP_VIDEO_PTS
+                                        and _use_plain_rtp
+                                        and _answer_video_pt[0] is not None):
+                                    _pt_out = int(_answer_video_pt[0])
+                            elif _kind_answered == "audio":
+                                _btgt, _lo_target, _kind = (
+                                    _lo_audio_port, _lo_a, "audio"
+                                )
+                            elif _pt in (96, 97, 98):
                                 _btgt, _lo_target, _kind = (
                                     _lo_video_port, _lo_v, "video"
                                 )
@@ -5566,15 +5781,22 @@ class _SdesOpenMixin:
                                     )
                             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}")
+                                # _pt_out, not _pt: everything downstream (the
+                                # serve SDP narrowing, _serve_video_pt's
+                                # "observed beats pinned") speaks OUR numbering,
+                                # and the wire PT is preserved in the log line.
+                                _first_video_pt[0] = _pt_out
+                                _status(
+                                    f"bridge: first video RTP pt={_pt_out}"
+                                    + (f" (camera numbered it {_pt})"
+                                       if _pt_out != _pt else ""))
                                 # At INFO, not DEBUG: this is the one line that
                                 # makes a bitrate figure comparable to another
                                 # one, and it is emitted once per session.
                                 _LOGGER.info(
                                     "camera %s: video profile %s",
                                     getattr(self, "device_id", "?"),
-                                    describe_video_profile(_pt),
+                                    describe_video_profile(_pt_out),
                                 )
                                 # Camera answers BUNDLE (all media on one 5-tuple),
                                 # so the talk destination is the same address as
@@ -5799,6 +6021,9 @@ class _SdesOpenMixin:
                             if _nk_late:
                                 _bridge_fn._nack_late_drops = getattr(
                                     _bridge_fn, '_nack_late_drops', 0) + 1
+                            if _pt_out != _pt and _decrypted:
+                                _fwd_pkt = rewrite_rtp_payload_type(
+                                    _fwd_pkt, _pt_out)
                             try:
                                 if not _nk_late:
                                     _lo_target.sendto(
@@ -6085,6 +6310,7 @@ class _SdesOpenMixin:
         _early_nominated = bool(_cam_ice_ufrag and _cam_ice_pwd and _cam_ice_cands)
         _media_deadline = time.monotonic() + _FIRST_MEDIA_WAIT_S
         _media_wait_started = time.monotonic()
+        _pt_kinds_read = False
 
         def _report_first_media_stall(_waited_s, _cancelled=False):
             """Emit the one line that says why nothing arrived.
@@ -6150,6 +6376,34 @@ class _SdesOpenMixin:
                     _status(f"camera refused: ack {_code} {_desc}"
                             " - terminal, abandoning the first-media wait")
                     raise AidotCameraBusy(_code, _desc)
+                if (not _pt_kinds_read and answer_fut is not None
+                        and answer_fut.done() and not answer_fut.cancelled()):
+                    # One-shot, here rather than in the answer-logging block
+                    # further down: that block runs AFTER this wait, which is
+                    # 75 s too late for the demux that the map exists to fix.
+                    _pt_kinds_read = True
+                    try:
+                        if answer_fut.exception() is None:
+                            _pk_sdp = (
+                                answer_fut.result() or {}).get("sdp", "") or ""
+                            if _pk_sdp:
+                                _answer_pt_kinds.update(answer_pt_kinds(_pk_sdp))
+                                _answer_video_pt[0] = video_pt_from_answer_sdp(
+                                    _pk_sdp)
+                                _vpts = sorted(
+                                    pt for pt, k in _answer_pt_kinds.items()
+                                    if k == "video")
+                                if any(pt not in _SDP_VIDEO_PTS for pt in _vpts):
+                                    _status(
+                                        "answer numbers video on payload"
+                                        " type(s) %s - demuxing by the answer,"
+                                        " serving as our pt=%s"
+                                        % (_vpts, _answer_video_pt[0]))
+                    except Exception:
+                        _LOGGER.debug(
+                            "camera %s: swallowed exception in %s",
+                            getattr(self, "device_id", "?"),
+                            'answer_pt_kinds', exc_info=True)
                 if (not _early_nominated and answer_fut is not None
                         and answer_fut.done() and not answer_fut.cancelled()):
                     # Read-only peek: the real await below still consumes this
@@ -6278,6 +6532,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.0b33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "1.0.0b31"
+version = "1.0.0b33"
 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.0b33/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.0b33
 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.0b33}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ python_aidot_cameras.egg-info/requires.txt
 python_aidot_cameras.egg-info/top_level.txt
 tests/test_aioice_compat.py
 tests/test_alarm_event.py
+tests/test_answer_pt_kinds.py
 tests/test_answer_sdp_video_pt.py
 tests/test_answer_section_selection.py
 tests/test_audio_mux_offline.py
@@ -218,6 +219,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 +234,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.0b33/tests/test_answer_pt_kinds.py

@@ -0,0 +1,141 @@
+"""Demuxing the camera's media by the ANSWER's payload numbering, not a table.
+
+The bridge splits a BUNDLEd stream into ffmpeg's audio and video loopbacks by
+RTP payload type. It used to do that from a fixed table -- 96/97/98 video,
+0/8 audio -- and that table is wrong for this fleet.
+
+Measured 2026-08-26 across 107 A001064 opens on the live camera: 15 of them
+(14%) negotiated H265 on payload type 0, announced it correctly in the answer
+as ``m=video ... 0`` with ``a=rtpmap:0 H265/90000``, and then sent 2668
+full-size (1222 B) video packets on pt=0 while audio ran normally on pt=8
+(verified on the wire, tshark by SSRC: two streams, 0x29d9/pt=0 video and
+0x29d7/pt=8 audio). The fixed table posted every one of those video packets to
+the AUDIO loopback, so no video was ever observed, the 75 s first-media wait
+expired, and the serve launched into an empty stream and exited -- 82 s, then a
+full reopen. The other 92 opens answered ``m=video ... 96`` and worked. Perfect
+separation in both directions.
+
+The same renumbering is already on record for the A000088 in
+``test_answer_section_selection.py`` (PT 0 carrying H265), where the DTLS path
+handles it by selecting sections by content. The SDES bridge was the one place
+left trusting a static tuple.
+
+The m-lines below are transcribed from the live log; the ``a=rtpmap:0
+H265/90000`` line is inferred from ``video_pt_from_answer_sdp`` returning 97 on
+every one of those 15 sessions (logged as "the camera's answer (97)"), which is
+reachable only through the H265 branch of ``_SDP_VIDEO_PT_BY_CODEC``.
+"""
+
+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 (
+    answer_pt_kinds,
+    rewrite_rtp_payload_type,
+    video_pt_from_answer_sdp,
+)
+
+# The 92-of-107 shape: ordinary 3-section answer, video on 96.
+_HEALTHY = (
+    "v=0\r\n"
+    "m=audio 9 RTP/SAVPF 8\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "m=video 9 RTP/SAVPF 96\r\n"
+    "a=rtpmap:96 H264/90000\r\n"
+    "m=application 9 SCTP webrtc-datachannel\r\n"
+)
+
+# The 15-of-107 shape: a leading video section numbering H265 as payload type 0.
+_PT0_VIDEO = (
+    "v=0\r\n"
+    "m=video 9 RTP/SAVPF 0\r\n"
+    "a=rtpmap:0 H265/90000\r\n"
+    "m=audio 9 RTP/SAVPF 8\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "m=video 9 RTP/SAVPF 96\r\n"
+    "a=rtpmap:96 H264/90000\r\n"
+    "m=application 9 SCTP webrtc-datachannel\r\n"
+)
+
+# A000088 H265-capable firmware: legitimately four sections, reordered. A
+# predicate keyed on the section COUNT would break this model, which works.
+_A000088_REORDERED = (
+    "v=0\r\n"
+    "m=video 9 UDP/TLS/RTP/SAVPF 0\r\n"
+    "a=rtpmap:0 H265/90000\r\n"
+    "m=audio 9 UDP/TLS/RTP/SAVPF 8\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "m=video 9 UDP/TLS/RTP/SAVPF 101 102\r\n"
+    "a=rtpmap:101 H264/90000\r\n"
+    "m=application 9 DTLS/SCTP 5000\r\n"
+)
+
+
+def test_healthy_answer_maps_kinds():
+    assert answer_pt_kinds(_HEALTHY) == {8: "audio", 96: "video"}
+
+
+def test_pt0_video_is_reported_as_video_not_audio():
+    # The whole defect in one assertion: without the answer, pt=0 reads as PCMU.
+    kinds = answer_pt_kinds(_PT0_VIDEO)
+    assert kinds[0] == "video"
+    assert kinds[8] == "audio"
+    assert kinds[96] == "video"
+
+
+def test_pt0_video_answer_resolves_to_our_h265_payload_type():
+    # What the bridge translates the wire PT into before ffmpeg sees it.
+    assert video_pt_from_answer_sdp(_PT0_VIDEO) == 97
+
+
+def test_a000088_reordered_four_sections_still_map_correctly():
+    kinds = answer_pt_kinds(_A000088_REORDERED)
+    assert kinds[0] == "video"
+    assert kinds[8] == "audio"
+    assert kinds[101] == "video"
+    assert kinds[102] == "video"
+
+
+def test_payload_type_claimed_by_both_kinds_is_dropped():
+    # Ambiguity is not better evidence than the fallback table, so the map
+    # declines to answer for that payload type rather than guessing.
+    ambiguous = (
+        "m=video 9 RTP/SAVPF 0\r\n"
+        "m=audio 9 RTP/SAVPF 0 8\r\n"
+    )
+    kinds = answer_pt_kinds(ambiguous)
+    assert 0 not in kinds
+    assert kinds[8] == "audio"
+
+
+def test_malformed_and_empty_answers_do_not_raise():
+    assert answer_pt_kinds("") == {}
+    # Out of contract, but the media path must not raise on it either.
+    assert answer_pt_kinds(None) == {}  # type: ignore[arg-type]
+    assert answer_pt_kinds("m=video\r\nm=audio 9\r\n") == {}
+    # Non-numeric and out-of-range payload tokens are skipped, not raised on.
+    assert answer_pt_kinds("m=video 9 RTP/SAVPF x 300 96\r\n") == {96: "video"}
+
+
+def test_rewrite_payload_type_preserves_the_marker_bit():
+    # byte1 = M(1) | PT(7). 0x80 is marker set + pt 0; 0x00 is marker clear.
+    marked = bytes([0x80, 0x80]) + b"rest"
+    assert rewrite_rtp_payload_type(marked, 97) == bytes([0x80, 0xE1]) + b"rest"
+    unmarked = bytes([0x80, 0x00]) + b"rest"
+    assert rewrite_rtp_payload_type(unmarked, 97) == bytes([0x80, 0x61]) + b"rest"
+
+
+def test_rewrite_payload_type_leaves_the_rest_of_the_packet_alone():
+    pkt = bytes([0x80, 0x00]) + bytes(range(2, 40))
+    out = rewrite_rtp_payload_type(pkt, 96)
+    assert out[0] == pkt[0]
+    assert out[2:] == pkt[2:]
+    assert out[1] & 0x7F == 96
+
+
+def test_rewrite_payload_type_ignores_a_runt_packet():
+    # Media path: a malformed packet is ffmpeg's to discard, not ours to raise.
+    assert rewrite_rtp_payload_type(b"", 97) == b""
+    assert rewrite_rtp_payload_type(b"\x80", 97) == b"\x80"