python-aidot-cameras 0.12.13__tar.gz → 0.12.15__tar.gz

{python_aidot_cameras-0.12.13/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.15}/PKG-INFO

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

@@ -369,6 +369,7 @@ def _build_sdes_serve_cmd(
     max_seconds: Optional[float] = None,
     sdes_audio: bool = False,
     audio_gain_db: float = -8.0,
+    push_video_only: bool = False,
 ) -> list:
     """Build the ffmpeg argv for the SDES bridge serve.
 
@@ -425,8 +426,13 @@ def _build_sdes_serve_cmd(
                 rtsp_push_url,
             ]
     elif rtsp_push_url:
+        # PUSH is G.711 passthrough (-c copy) as always - EXCEPT when the audio
+        # payload type was never observed (push_video_only): announcing an
+        # un-narrowed audio line the server cannot accept kills the whole
+        # publish with 400 Bad Request, so map video only and announce clean.
         dest_args = [
-            "-c", "copy",
+            *(["-map", "0:v:0", "-c:v", "copy"] if push_video_only
+              else ["-c", "copy"]),
             *time_args,
             "-f", "rtsp", "-rtsp_transport", "tcp",
             rtsp_push_url,
@@ -2695,9 +2701,11 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         from a Home Assistant config-entry option, since HA OS can't set env vars).
 
         ``live_stream_param`` toggles the battery-camera cloud pre-connect
-        (liveStreamParam); like ``fast_connect`` it overrides the
-        ``AIDOT_LIVESTREAM_PARAM`` env var, so an integration on HA OS (no env vars)
-        can still disable it per camera.
+        (liveStreamParam), which is **off by default**: it provisions the camera
+        toward AWS KVS and diverts an A001513's media away from the SDES bridge
+        (no video RTP arrives).  Like ``fast_connect`` it overrides the
+        ``AIDOT_LIVESTREAM_PARAM`` env var; set True only to re-enable the
+        pre-connect for a camera that needs it.
 
         ``serve_relay`` toggles the cold-start serve-port relay (holds the public
         serve port connectable through the WebRTC handshake so an eager go2rtc
@@ -3571,7 +3579,18 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
         Per-camera ``sdes_skip_turn`` (set via start_keepalive) wins; else the
         ``AIDOT_SDES_SKIP_TURN_PREALLOC`` env (truthy = 1/true/yes/on), default
-        off.  Only consulted for SDES cameras."""
+        off.  Only consulted for SDES cameras.
+
+        NEVER skipped for a battery camera, whatever the opt/env say: a battery
+        camera sleeps and is woken through the cloud, so it is reached over the
+        TURN relay rather than a host-direct LAN path.  Skipping the relay
+        pre-allocation there means the camera has no reachable path back and
+        sends no media at all (validated live on an A001513: with the relay it
+        streams h264 1280x960, with skip_turn it serves nothing).  The LAN-direct
+        latency win only applies to a mains camera that actually has a host
+        candidate on the HA segment."""
+        if getattr(self, "is_battery_camera", False):
+            return False
         opt = getattr(self, "_sdes_skip_turn_opt", None)
         if opt is not None:
             return bool(opt)
@@ -4080,7 +4099,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                                 # Unknown: keep the old staleness heuristic rather
                                 # than holding the stream open forever.
                                 idle_release = True
-                            break
+                            # Only an actual idle release ends this serve cycle.
+                            # (This break was unconditional - any idle_secs > 0
+                            # tore down a HEALTHY ffmpeg after one 0.5s tick,
+                            # respawning it forever: ffmpeg died at output-open
+                            # with "Immediate exit requested" and every DTLS
+                            # camera served nothing. stream_idle_s=0 masked it,
+                            # which is why never-release fleets still worked.)
+                            if idle_release:
+                                break
                     # Tear down this ffmpeg+mux cycle before the next.
                     stop_flag.set()
                     try:

{python_aidot_cameras-0.12.13 → python_aidot_cameras-0.12.15}/aidot_cameras/camera/protocol.py

@@ -925,8 +925,52 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
     except Exception as exc:  # pragma: no cover
         _LOGGER.warning("DTLS A/V mux: PyAV unavailable: %s", exc)
         return
+
+    class _FailFlagWriter:
+        """Write-only stand-in for the pipe that RECORDS write failures.
+
+        FFmpeg's mpegts muxer checks avio write errors lazily: a dead pipe
+        (EPIPE after its ffmpeg exits) makes ``out.mux()`` appear to succeed
+        forever, and the error only surfaces - or hangs - at trailer time.
+        PyAV's pyio callback DOES see each failed ``write``; recording it here
+        lets the mux loop notice within one iteration and exit, instead of an
+        abandoned thread draining the SHARED vq/aq into a dead pipe and
+        starving the next cycle's ffmpeg (the 2026-07 dead-DTLS-video field
+        failure).  Deliberately exposes no seek/tell: the pipe is streaming.
+        """
+
+        def __init__(self, f):
+            self._f = f
+            self.failed = False
+
+        def write(self, b):
+            try:
+                return self._f.write(b)
+            except Exception:
+                self.failed = True
+                raise
+
+        def flush(self):
+            try:
+                self._f.flush()
+            except Exception:
+                self.failed = True
+                raise
+
+        def close(self):
+            self._f.close()
+
+    wsink = _FailFlagWriter(out_fileobj)
     try:
-        out = av.open(out_fileobj, "w", format="mpegts")
+        # max_interleave_delta (default 10s of stream time): with an AAC stream
+        # declared but no audio packets arriving, libavformat's interleave
+        # queue holds EVERY video packet waiting to order them against audio -
+        # zero bytes reach the pipe, the serve ffmpeg starves at its input
+        # probe and never binds its -listen port (field failure 2026-07: all
+        # DTLS cameras dark while the taps were full of frames).  100ms keeps
+        # video flowing whether or not audio ever shows up.
+        out = av.open(wsink, "w", format="mpegts",
+                      options={"max_interleave_delta": "100000"})
     except Exception as exc:
         _LOGGER.warning("DTLS A/V mux: av.open failed: %s", exc)
         return
@@ -975,6 +1019,14 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
     a_rtp0 = [None]      # first audio RTP timestamp (8 kHz units), for gap detection
     a_in = [0]           # 8 kHz samples emitted to the resampler so far (incl. concealed)
     vstarted = [False]
+    # A failed container write is TERMINAL for this mux: the pipe's ffmpeg is
+    # gone (EPIPE) and can never come back for this cycle.  Swallowing it and
+    # looping used to leave abandoned mux threads (the teardown join(2.0) gives
+    # up on a thread blocked in write) racing the NEXT cycle's thread for the
+    # SHARED vq/aq - stealing its frames into a dead pipe, starving the new
+    # ffmpeg at its input probe so it never bound its -listen port.  One dead
+    # write -> exit the thread and leave the queues alone.
+    mux_dead = [False]
 
     def _flush_video():
         while True:
@@ -995,7 +1047,9 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                 out.mux(pkt)
                 progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("swallowed exception in %s", '_flush_video', exc_info=True)
+                mux_dead[0] = True
+                _LOGGER.debug("DTLS A/V mux: video write failed - ending mux thread", exc_info=True)
+                return
 
     def _flush_audio(drain=False):
         if not have_audio:
@@ -1115,20 +1169,34 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                     out.mux(opkt)
                     progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
+                mux_dead[0] = True
+                _LOGGER.debug("DTLS A/V mux: audio write failed - ending mux thread", exc_info=True)
+                return
+
+    def _dead() -> bool:
+        return mux_dead[0] or wsink.failed
 
-    while not stop_flag.is_set():
+    while not stop_flag.is_set() and not _dead():
         _flush_video()
         _flush_audio()
         _t.sleep(0.005)  # 5 ms - processes audio within 5 ms of arrival vs 20 ms
-    _flush_video()
-    _flush_audio(drain=True)  # final: pad the last partial frame so it flushes
+    if not _dead():
+        _flush_video()
+        _flush_audio(drain=True)  # final: pad the last partial frame so it flushes
     try:
-        if have_audio:
+        if have_audio and not _dead():
             for opkt in aenc.encode(None):  # flush
                 out.mux(opkt)
     except Exception:
         _LOGGER.debug("swallowed exception in %s", '_dtls_av_mux_run', exc_info=True)
+    if _dead():
+        # Close the raw pipe FIRST: the container's trailer flush then fails
+        # fast ("closed file") instead of hanging on the dead pipe.
+        _LOGGER.debug("DTLS A/V mux: sink write failed - ending mux thread")
+        try:
+            wsink.close()
+        except Exception:
+            pass
     try:
         out.close()
     except Exception:

{python_aidot_cameras-0.12.13 → python_aidot_cameras-0.12.15}/aidot_cameras/camera/sdes_open.py

@@ -36,7 +36,9 @@ _LOGGER = logging.getLogger(__name__)
 
 # Payload types the ffmpeg SDP advertises per media line, and their alternates.
 # The SDP offers both because the camera picks one per session.
-_SDP_ALTERNATE_PT = {96: 97, 97: 96, 0: 8, 8: 0}
+# Video payloads the cameras negotiate: 96=H.264, 97/98=H.265 (two variants).
+_SDP_VIDEO_PTS = (96, 97, 98)
+_SDP_AUDIO_PTS = (0, 8)
 
 # How long to wait for the FIRST media of a session before launching the serve.
 # Nothing useful can happen before then: the payload types are unknown, so the SDP
@@ -70,16 +72,33 @@ def narrow_sdp_payload_types(sdp_text: str, keep_video=None, keep_audio=None) ->
     included - while every other signal looks healthy.
 
     ``keep_video`` / ``keep_audio`` of None leaves that line alone.
+
+    Handles any payload list on the m-line (``96 97``, ``96 97 98``, ...): the
+    kept line advertises ONLY the kept payload and the rtpmap/fmtp lines of
+    every dropped payload are removed.  The old implementation replaced the
+    literal ``" 96 97"``, so the day the SDP template grew a third video
+    payload (98, the second H.265 variant) narrowing silently stopped working
+    for it - and an un-narrowed multi-codec SDP makes the RTSP-push ANNOUNCE
+    carry a parameterless H.265 stream that go2rtc rejects with 400.
     """
-    drop = {_SDP_ALTERNATE_PT[k] for k in (keep_video, keep_audio)
-            if k in _SDP_ALTERNATE_PT}
+    drop: set = set()
     kept = []
     for line in sdp_text.splitlines(keepends=True):
         stripped = line.lstrip()
-        if stripped.startswith("m=video") and keep_video is not None:
-            line = line.replace(" 96 97", f" {keep_video}")
-        elif stripped.startswith("m=audio") and keep_audio is not None:
-            line = line.replace(" 0 8", f" {keep_audio}")
+        m_kind = keep = None
+        if stripped.startswith("m=video"):
+            m_kind, keep = "video", keep_video
+        elif stripped.startswith("m=audio"):
+            m_kind, keep = "audio", keep_audio
+        if m_kind is not None and keep is not None:
+            head, _, pts = stripped.partition(" RTP/")
+            proto, _, pt_list = pts.partition(" ")
+            listed = pt_list.split()
+            if str(keep) in listed:
+                drop.update(p for p in listed if p != str(keep))
+                line = (line[: len(line) - len(stripped)]
+                        + f"{head} RTP/{proto} {keep}"
+                        + ("\r\n" if line.endswith("\r\n") else "\n"))
         elif any(
             stripped.startswith(f"a={attr}:{pt}{sep}")
             for pt in drop
@@ -3537,16 +3556,11 @@ class _SdesOpenMixin:
             out_dir = os.path.dirname(output_path)
             if out_dir:
                 os.makedirs(out_dir, exist_ok=True)
-        # Build the ffmpeg command (single source of truth: _build_sdes_serve_cmd).
+        # The ffmpeg command is built once below, AFTER the first-media wait
+        # resolves the real payload types (single source of truth:
+        # _build_sdes_serve_cmd) - so both the SDP narrowing and the push
+        # video-only decision see the observed codecs.
         _serve_audio = self._resolve_sdes_serve_audio()
-        cmd = _build_sdes_serve_cmd(
-            sdp_path=sdp_path,
-            rtsp_push_url=rtsp_push_url,
-            output_path=output_path,
-            max_seconds=max_seconds,
-            sdes_audio=_serve_audio,
-            audio_gain_db=self._resolve_sdes_audio_gain_db(),
-        )
         # --- 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
@@ -3578,10 +3592,15 @@ class _SdesOpenMixin:
                 await asyncio.sleep(0.1)
         _vpt = _first_video_pt[0]
         _apt = _first_audio_pt[0]
-        if _serve_audio and _apt is None:
+        # Which single payload type (if any) each line can be narrowed to. Audio
+        # is usable only when its type was actually observed; otherwise the "0 8"
+        # line cannot be narrowed.
+        _keep_v = int(_vpt) if _vpt in _SDP_VIDEO_PTS else None
+        _keep_a = int(_apt) if _apt in _SDP_AUDIO_PTS else None
+        if _serve_audio and _keep_a is None:
             # No audio observed in the window, so the line cannot be narrowed and
-            # mapping audio would stall the mux.  Serve video only rather than
-            # serving nothing, and say so.
+            # mapping audio would stall the mux (pull) or break the ANNOUNCE
+            # (push).  Serve video only rather than serving nothing, and say so.
             _LOGGER.warning(
                 "camera %s: no audio observed before the serve launched, so the "
                 "audio payload type is unknown; mapping it would stall the mpegts "
@@ -3589,14 +3608,22 @@ class _SdesOpenMixin:
                 getattr(self, "device_id", "?"),
             )
             _serve_audio = False
-            cmd = _build_sdes_serve_cmd(
-                sdp_path=sdp_path,
-                rtsp_push_url=rtsp_push_url,
-                output_path=output_path,
-                max_seconds=max_seconds,
-                sdes_audio=False,
-                audio_gain_db=self._resolve_sdes_audio_gain_db(),
-            )
+        # RTSP-PUSH copies EVERY input stream (-c copy). If the audio line was
+        # never narrowed to a single type, its multi-PT ANNOUNCE is rejected by
+        # the RTSP server (400 Bad Request) and takes the whole publish down - so
+        # push must map video only whenever audio is not usable. (Pull already
+        # gates audio via sdes_audio in _build_sdes_serve_cmd.)
+        _is_push = bool(rtsp_push_url) and not rtsp_push_url.startswith("http")
+        _push_video_only = _is_push and _keep_a is None
+        cmd = _build_sdes_serve_cmd(
+            sdp_path=sdp_path,
+            rtsp_push_url=rtsp_push_url,
+            output_path=output_path,
+            max_seconds=max_seconds,
+            sdes_audio=_serve_audio,
+            audio_gain_db=self._resolve_sdes_audio_gain_db(),
+            push_video_only=_push_video_only,
+        )
         # 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
         # rest, and the mpegts mux withholds its PAT/PMT until EVERY mapped stream
@@ -3604,13 +3631,11 @@ class _SdesOpenMixin:
         # on a camera that sends PCMA discards every audio packet and the consumer
         # receives zero bytes.  That takes the video down with it, which is why
         # enabling serve audio appeared to break streaming outright.
-        if _vpt in (96, 97) or (_serve_audio and _apt in (0, 8)):
+        if _keep_v is not None or _keep_a is not None:
             def _read_sdp_file() -> str:
                 with open(sdp_path, encoding="utf-8") as _f_sdp:
                     return _f_sdp.read()
             try:
-                _keep_v = int(_vpt) if _vpt in (96, 97) else None
-                _keep_a = int(_apt) if (_serve_audio and _apt in (0, 8)) else None
                 _cur_sdp = await asyncio.get_running_loop().run_in_executor(
                     None, _read_sdp_file)
                 await asyncio.get_running_loop().run_in_executor(
@@ -3619,7 +3644,7 @@ class _SdesOpenMixin:
                 _status(
                     "SDES: narrowed ffmpeg SDP to"
                     + (f" video pt={_keep_v}"
-                       f" ({'H265' if _keep_v == 97 else 'H264'})"
+                       f" ({'H264' if _keep_v == 96 else 'H265'})"
                        if _keep_v is not None else "")
                     + (f" audio pt={_keep_a}"
                        f" ({'PCMA' if _keep_a == 8 else 'PCMU'})"
@@ -3902,7 +3927,7 @@ class _SdesOpenMixin:
                         _new_sdp = narrow_sdp_payload_types(
                             _new_sdp,
                             keep_video=(_first_video_pt[0]
-                                        if _first_video_pt[0] in (96, 97) else None),
+                                        if _first_video_pt[0] in _SDP_VIDEO_PTS else None),
                             keep_audio=(_first_audio_pt[0]
                                         if _first_audio_pt[0] in (0, 8) else None),
                         )

{python_aidot_cameras-0.12.13 → python_aidot_cameras-0.12.15}/aidot_cameras/camera/webrtc_open.py

@@ -237,16 +237,20 @@ class _WebRTCOpenMixin:
         # Battery cameras must have their live-stream session provisioned by the
         # cloud BEFORE MQTT signaling, or the camera rejects livePlayReq with
         # -50019 ("not ready") and never runs ICE -> no media.  App parity:
-        # KVSPreConnectStrategy.fetchKvsParams calls liveStreamParam first.  We
-        # only need the provisioning side effect (we stream over MQTT/SDES, not
-        # AWS KVS).  Mains cameras are always stream-ready, so skip them.
-        # Validated live on L2_170 (A001513): with this call livePlay succeeds and
-        # decrypted RTP flows; without it, persistent -50019.  Controllable like
-        # fast_connect/sdes_audio: start_keepalive(live_stream_param=...) wins,
-        # else the AIDOT_LIVESTREAM_PARAM env var (default on).
+        # KVSPreConnectStrategy.fetchKvsParams calls liveStreamParam first, which
+        # provisions the camera's session toward AWS KVS.  DEFAULT OFF: we stream
+        # over MQTT/SDES, not KVS, and on A001513 "L2" cameras this pre-connect
+        # DIVERTS the camera's media to KVS - the SDES bridge then receives no
+        # video RTP at all (validated live: with the call the L2 serves nothing;
+        # with AIDOT_LIVESTREAM_PARAM=0 it streams h264 1280x960 + PCMA, matching
+        # the pre-0.7 behaviour that always worked).  It was added under #43 to
+        # cure a -50019 ("not ready") livePlayResp, but -50019 is benign - mains
+        # cameras emit it too and recover via ICE - so the pre-connect fixed a
+        # non-bug at the cost of the battery live view.  Kept as an opt-in escape
+        # hatch: start_keepalive(live_stream_param=True) or AIDOT_LIVESTREAM_PARAM=1.
         _lsp = getattr(self, "_live_stream_param_opt", None)
         if _lsp is None:
-            _lsp = os.environ.get("AIDOT_LIVESTREAM_PARAM", "1") != "0"
+            _lsp = os.environ.get("AIDOT_LIVESTREAM_PARAM", "0") != "0"
         if self.is_battery_camera and _lsp:
             _lsp_ok = await self._async_fetch_live_stream_param()
             _LOGGER.debug("camera %s: liveStreamParam provisioned ok=%s",

{python_aidot_cameras-0.12.13 → python_aidot_cameras-0.12.15}/pyproject.toml

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

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

@@ -69,10 +69,12 @@ python_aidot_cameras.egg-info/top_level.txt
 tests/test_aioice_compat.py
 tests/test_alarm_event.py
 tests/test_backoff.py
+tests/test_battery_skip_turn.py
 tests/test_deferred_hardening.py
 tests/test_device_login_guard.py
 tests/test_device_user_info_cache.py
 tests/test_dormant_camera_cleanup.py
+tests/test_dtls_mux_terminal_write.py
 tests/test_dtls_not_ready_burst.py
 tests/test_dtls_pinning.py
 tests/test_dtls_serve_decode_skip.py

python_aidot_cameras-0.12.15/tests/test_battery_skip_turn.py

@@ -0,0 +1,59 @@
+"""A battery SDES camera must NEVER skip the TURN relay pre-allocation.
+
+A battery camera sleeps and is woken through the cloud, so its media returns
+over the TURN relay, not a host-direct LAN path. Skipping the relay (the
+LAN-direct latency optimization) leaves the camera with no reachable path back
+and it sends no media at all. Validated live on an A001513: with the relay it
+streams h264 1280x960; with skip_turn it serves nothing. The opt/env must not be
+able to turn the relay off for a battery camera; the optimization applies only to
+mains SDES cameras that actually have a host candidate on the HA segment.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import aidot_cameras.camera.client as cc
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "_resolve_sdes_skip_turn" in v.__dict__)
+
+
+class _Info:
+    def __init__(self, model_id):
+        self.model_id = model_id
+
+
+def _cam(battery, **attrs):
+    c = _CAM.__new__(_CAM)
+    # is_battery_camera is a property derived from info.model_id.
+    c.info = _Info("LK.IPC.A001513" if battery else "LK.IPC.A001064")
+    for k, v in attrs.items():
+        setattr(c, k, v)
+    return c
+
+
+def test_battery_never_skips_turn_even_with_opt():
+    c = _cam(True, _sdes_skip_turn_opt=True)
+    assert c._resolve_sdes_skip_turn() is False
+
+
+def test_battery_never_skips_turn_even_with_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_SKIP_TURN_PREALLOC", "1")
+    c = _cam(True)
+    assert c._resolve_sdes_skip_turn() is False
+
+
+def test_battery_never_skips_turn_with_fast_attempt_override():
+    c = _cam(True, _fast_attempt_override=True)
+    assert c._resolve_sdes_skip_turn() is False
+
+
+def test_mains_still_honors_the_opt():
+    assert _cam(False, _sdes_skip_turn_opt=True)._resolve_sdes_skip_turn() is True
+    assert _cam(False, _sdes_skip_turn_opt=False)._resolve_sdes_skip_turn() is False
+
+
+def test_mains_default_off(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_SKIP_TURN_PREALLOC", raising=False)
+    assert _cam(False)._resolve_sdes_skip_turn() is False

python_aidot_cameras-0.12.15/tests/test_dtls_mux_terminal_write.py

@@ -0,0 +1,126 @@
+"""A failed container write must END the DTLS mux thread, not be swallowed.
+
+Regression for the abandoned-mux-thread leak: teardown's join(2.0) gives up on
+a thread blocked in a pipe write; once that pipe's ffmpeg dies the write raises
+EPIPE forever.  The old per-packet swallow kept the abandoned thread looping,
+stealing frames from the SHARED vq/aq that the next cycle's thread needed - the
+new ffmpeg starved at its input probe and never bound its -listen port (the
+field "dead DTLS video" of 2026-07).  A dead write now exits the thread and
+leaves the queues alone.
+"""
+
+import os
+import queue
+import threading
+import time
+
+import pytest
+
+av = pytest.importorskip("av")
+
+from aidot_cameras.camera.protocol import _dtls_av_mux_run
+
+
+def _h264_payloads(n=60):
+    """Real encoded H.264 access units (the mux needs valid-ish annex-b).
+
+    Noise frames compress terribly on purpose: the total must exceed PyAV's
+    ~32KB avio buffer so the container performs REAL pipe writes (a smaller
+    payload sits in the buffer forever and never observes the dead pipe).
+    """
+    import numpy as np
+
+    rng = np.random.default_rng(7)
+    enc = av.CodecContext.create("libx264", "w")
+    enc.width, enc.height, enc.pix_fmt = 320, 240, "yuv420p"
+    from fractions import Fraction
+
+    enc.time_base = Fraction(1, 15)
+    enc.options = {"tune": "zerolatency"}
+    out = []
+    for i in range(n):
+        img = rng.integers(0, 255, (240, 320, 3), dtype=np.uint8)
+        fr = av.VideoFrame.from_ndarray(img, format="rgb24").reformat(format="yuv420p")
+        fr.pts = i
+        for p in enc.encode(fr):
+            out.append((bytes(p), bool(p.is_keyframe)))
+    for p in enc.encode(None):
+        out.append((bytes(p), bool(p.is_keyframe)))
+    assert sum(len(d) for d, _ in out) > 100_000
+    return out
+
+
+def test_dead_pipe_ends_mux_thread_and_spares_queues():
+    payloads = _h264_payloads()
+    assert payloads and payloads[0][1], "first packet should be a keyframe"
+
+    vq: queue.Queue = queue.Queue()
+    aq: queue.Queue = queue.Queue()
+    ts = 0
+    for data, kf in payloads:
+        vq.put((data, ts, kf))
+        ts += 6000
+
+    r, w = os.pipe()
+    os.close(r)  # reader already gone -> every flushed write is EPIPE
+    wfile = os.fdopen(w, "wb", buffering=0)
+    progress = [time.monotonic()]
+    stop_flag = threading.Event()
+
+    t = threading.Thread(
+        target=_dtls_av_mux_run, args=(vq, aq, wfile, progress, stop_flag), daemon=True
+    )
+    t.start()
+    t.join(timeout=10.0)
+
+    # The thread must have exited on its own (stop_flag was never set).
+    assert not t.is_alive(), "mux thread must end on a dead pipe, not loop forever"
+    assert not stop_flag.is_set()
+    # And it must not have drained the whole queue into the dead pipe: once the
+    # avio buffer first flushes and EPIPEs, remaining frames stay for the next
+    # cycle's consumer.  (The avio buffer absorbs the first ~32KB, so a few
+    # packets are legitimately consumed before the first real write.)
+    assert not vq.empty(), "a dead mux must leave queued frames for the next cycle"
+
+
+def test_healthy_pipe_still_muxes():
+    payloads = _h264_payloads()
+    vq: queue.Queue = queue.Queue()
+    aq: queue.Queue = queue.Queue()
+    ts = 0
+    for data, kf in payloads:
+        vq.put((data, ts, kf))
+        ts += 6000
+
+    r, w = os.pipe()
+    got = [0]
+
+    def drain():
+        while True:
+            try:
+                b = os.read(r, 65536)
+            except OSError:
+                return
+            if not b:
+                return
+            got[0] += len(b)
+
+    threading.Thread(target=drain, daemon=True).start()
+    wfile = os.fdopen(w, "wb", buffering=0)
+    progress = [time.monotonic()]
+    stop_flag = threading.Event()
+    t = threading.Thread(
+        target=_dtls_av_mux_run, args=(vq, aq, wfile, progress, stop_flag), daemon=True
+    )
+    t.start()
+    time.sleep(1.5)
+    # REGRESSION (interleave stall): with an AAC stream declared but zero audio
+    # packets, libavformat used to buffer ALL video in its interleave queue -
+    # bytes only appeared at close().  They must flow DURING muxing.
+    assert got[0] > 10_000, (
+        "video must reach the pipe while muxing, without any audio packets"
+    )
+    stop_flag.set()
+    t.join(timeout=10.0)
+    assert not t.is_alive()
+    assert vq.empty(), "healthy mux consumes the queue"

{python_aidot_cameras-0.12.13 → python_aidot_cameras-0.12.15}/tests/test_live_stream_param.py

@@ -73,3 +73,51 @@ if __name__ == "__main__":
                 print(f"FAIL {_k}")
                 traceback.print_exc()
     raise SystemExit(1 if _fail else 0)
+
+
+# --- default OFF regression --------------------------------------------------
+# The liveStreamParam KVS pre-connect is OFF by default. It was added under #43
+# to cure a -50019 livePlayResp, but -50019 is benign (mains cameras emit it and
+# recover via ICE), and on A001513 "L2" cameras the pre-connect diverts the
+# camera's media to AWS KVS so the SDES bridge receives no video RTP. Validated
+# live: with the pre-connect the L2 serves nothing; with it off the L2 streams
+# h264 1280x960 + PCMA. Lock the default so it cannot silently flip back on.
+import asyncio
+
+
+def _resolve_lsp(opt, env):
+    # Mirror the gate in webrtc_open._async_open_webrtc_stream_impl.
+    _lsp = opt
+    if _lsp is None:
+        _lsp = env.get("AIDOT_LIVESTREAM_PARAM", "0") != "0"
+    return _lsp
+
+
+def test_liveStreamParam_defaults_off():
+    assert _resolve_lsp(None, {}) is False
+
+
+def test_liveStreamParam_env_opt_in():
+    assert _resolve_lsp(None, {"AIDOT_LIVESTREAM_PARAM": "1"}) is True
+
+
+def test_liveStreamParam_explicit_opt_wins_over_env():
+    assert _resolve_lsp(True, {"AIDOT_LIVESTREAM_PARAM": "0"}) is True
+    assert _resolve_lsp(False, {"AIDOT_LIVESTREAM_PARAM": "1"}) is False
+
+
+def test_open_path_skips_arm_by_default(monkeypatch):
+    # The real gate: a battery camera with no opt/env must NOT call the arm.
+    called = {"n": 0}
+
+    async def _fake_arm(self):
+        called["n"] += 1
+        return True
+
+    # Exercise the exact resolution + guard the open path uses.
+    monkeypatch.delenv("AIDOT_LIVESTREAM_PARAM", raising=False)
+    is_battery = True
+    _lsp = _resolve_lsp(None, os.environ)
+    if is_battery and _lsp:
+        asyncio.get_event_loop().run_until_complete(_fake_arm(object()))
+    assert called["n"] == 0, "arm must not run by default on a battery camera"