python-aidot-cameras 0.7.32__tar.gz → 0.7.34__tar.gz

{python_aidot_cameras-0.7.32/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.32
+Version: 0.7.34
 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
@@ -140,5 +140,5 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_AUDIO_MAXGAIN_DB` | Maximum gain (dB) applied by the audio normalizer. | `30` |
 | `AIDOT_AUDIO_MINGAIN_DB` | Minimum gain (dB) applied by the audio normalizer. | `-12` |
 | `AIDOT_AUDIO_GATE_DBFS` | Noise-gate threshold (dBFS) for two-way audio. | `-45` |
-| `AIDOT_SDES_SERVE_AUDIO` | Set to `1` to serve audio on SDES cameras (off by default). | `0` (off) |
+| `AIDOT_SDES_SERVE_AUDIO` | Serve audio on SDES cameras (**on by default** — a silence-base mix keeps the audio encoder fed so battery-camera audio streams smoothly). Set to `0`/`false`/`no`/`off` to disable. | on |
 | `AIDOT_SDES_AUDIO_GAIN_DB` | Gain (dB) applied when SDES audio is served. | `-8` |

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/README.md

@@ -113,5 +113,5 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_AUDIO_MAXGAIN_DB` | Maximum gain (dB) applied by the audio normalizer. | `30` |
 | `AIDOT_AUDIO_MINGAIN_DB` | Minimum gain (dB) applied by the audio normalizer. | `-12` |
 | `AIDOT_AUDIO_GATE_DBFS` | Noise-gate threshold (dBFS) for two-way audio. | `-45` |
-| `AIDOT_SDES_SERVE_AUDIO` | Set to `1` to serve audio on SDES cameras (off by default). | `0` (off) |
+| `AIDOT_SDES_SERVE_AUDIO` | Serve audio on SDES cameras (**on by default** — a silence-base mix keeps the audio encoder fed so battery-camera audio streams smoothly). Set to `0`/`false`/`no`/`off` to disable. | on |
 | `AIDOT_SDES_AUDIO_GAIN_DB` | Gain (dB) applied when SDES audio is served. | `-8` |

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/pyproject.toml

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

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/src/aidot/camera/client.py

@@ -187,6 +187,94 @@ def _save_frame_as_jpeg(image_data: Any, output_path: str) -> bool:
     return False
 
 
+def _build_sdes_serve_cmd(
+    *,
+    sdp_path: str,
+    rtsp_push_url: Optional[str] = None,
+    output_path: Optional[str] = None,
+    max_seconds: Optional[float] = None,
+    sdes_audio: bool = False,
+    audio_gain_db: float = -8.0,
+) -> list:
+    """Build the ffmpeg argv for the SDES bridge serve.
+
+    Pure (no I/O - the caller creates any output directory and resolves
+    ``sdes_audio`` / ``audio_gain_db`` from opts/env).  Four destinations:
+
+    - ``rtsp_push_url`` is http(s)  -> PULL model: serve mpegts over an
+      ``-listen`` socket so go2rtc / HA's stream integration pull it (no go2rtc
+      pre-registration).
+    - ``rtsp_push_url`` is anything else -> legacy PUSH model: publish to an RTSP
+      server (``-f rtsp``), for callers running their own pre-registered go2rtc.
+    - ``output_path`` -> record to file.
+    - neither -> ``-f null`` (keep ffmpeg alive draining SRTP, write nothing).
+
+    AUDIO (the http-listen serve only): the mpegts mux writes its PAT/PMT once
+    every mapped stream has produced a packet.  Video is ``-c:v copy`` (parameters
+    known from the SDP at once); the ``-c:a aac`` encoder needs PCM samples to emit
+    a frame, and battery cameras send PCMA sparsely.  So we feed the encoder a
+    continuous ``anullsrc`` silence base and ``amix`` the real PCMA over it
+    (``normalize=0`` -> the 0-valued silence is a no-op whenever real audio is
+    present): the encoder is fed from t=0 so the PMT writes promptly and any gaps
+    are filled with silence.  go2rtc/HA pulls this mpegts the same way as the
+    video-only serve, so the pull model + cold-start relay are unchanged.
+    ``volume`` is the stateless hot-mic trim (dynamic normalizers regressed the
+    pipe in testing).  File recording (snapshots/diagnostics) is always -c copy."""
+    time_args = ["-t", str(int(max_seconds))] if max_seconds else []
+
+    if rtsp_push_url and rtsp_push_url.startswith("http"):
+        if sdes_audio:
+            dest_args = [
+                # Silence-base mix: a continuous a-law-rate anullsrc keeps the AAC
+                # encoder fed from t=0 so the mpegts PMT writes promptly on sparse
+                # battery PCMA; real audio mixes over the 0-valued silence
+                # (normalize=0 -> no-op when audio is present).
+                "-f", "lavfi", "-i", "anullsrc=r=8000:cl=mono",
+                "-filter_complex",
+                ("[0:a]aresample=async=1[a0];"
+                 "[a0][1:a]amix=inputs=2:duration=longest:normalize=0,"
+                 f"volume={audio_gain_db}dB[aout]"),
+                "-map", "0:v:0", "-map", "[aout]",
+                "-c:v", "copy", "-c:a", "aac", "-ar", "48000", "-b:a", "128k",
+                *time_args,
+                "-f", "mpegts", "-listen", "1",
+                rtsp_push_url,
+            ]
+        else:
+            dest_args = [
+                "-c:v", "copy", "-an",
+                *time_args,
+                "-f", "mpegts", "-listen", "1",
+                rtsp_push_url,
+            ]
+    elif rtsp_push_url:
+        dest_args = [
+            "-c", "copy",
+            *time_args,
+            "-f", "rtsp", "-rtsp_transport", "tcp",
+            rtsp_push_url,
+        ]
+    elif output_path:
+        # File recording (snapshots, diagnostics) is always a plain copy of the
+        # narrowed SDP - the audio mix is for the live serve, not file capture.
+        dest_args = ["-c", "copy", *time_args, output_path]
+    else:
+        dest_args = [*time_args, "-f", "null", "/dev/null"]
+    return [
+        "ffmpeg", "-y",
+        "-loglevel", "warning",
+        "-protocol_whitelist", "file,rtp,udp,srtp",
+        # 2 s analyzeduration: the camera sends SPS+PPS+IDR in the first burst;
+        # 15 s consumed nearly all packets during analysis.  PLI re-arms an IDR
+        # every 5 s so parameters always re-arrive.
+        "-fflags", "+nobuffer+genpts",
+        "-analyzeduration", "2000000",
+        "-probesize", "500000",
+        "-i", sdp_path,
+        *dest_args,
+    ]
+
+
 # --------------------------------------------------------------------------- #
 # TCP binary framing helpers
 # --------------------------------------------------------------------------- #
@@ -2632,6 +2720,20 @@ class CameraMixin(_CameraControlsMixin):
         return os.environ.get("AIDOT_SDES_FAST_LIVEPLAY", "").strip().lower() not in (
             "0", "false", "no", "off")
 
+    def _resolve_sdes_serve_audio(self) -> bool:
+        """Whether to include audio in the SDES camera serve.
+
+        **Default ON** for app-parity (the official app plays camera audio). The
+        serve feeds the AAC encoder a continuous silence base (anullsrc + amix) so
+        sparse battery PCMA streams cleanly through the mpegts mux. Per-camera
+        ``sdes_audio`` (via ``start_keepalive``) wins; else the
+        ``AIDOT_SDES_SERVE_AUDIO`` env (falsy = 0/false/no/off disables)."""
+        opt = getattr(self, "_sdes_audio_opt", None)
+        if opt is not None:
+            return bool(opt)
+        return os.environ.get("AIDOT_SDES_SERVE_AUDIO", "").strip().lower() not in (
+            "0", "false", "no", "off")
+
     def _resolve_sdes_skip_turn(self) -> bool:
         """EXPERIMENTAL (opt-in, default off): skip the blocking SDES TURN relay
         pre-allocation, for cameras reachable LAN-direct.
@@ -9939,106 +10041,30 @@ class CameraMixin(_CameraControlsMixin):
                 rtsp_push_url = _rewrite_serve_port(rtsp_push_url, _ff_port)
                 _relay.set_backend(_ff_port)
             # PULL model: SERVE the decrypted stream over an HTTP-listen socket so
-            # go2rtc / HA's stream integration pull it the standard way
-            # (streams.add) - no go2rtc pre-registration needed.  ffmpeg -listen 1
-            # blocks on accept() until the consumer connects, which go2rtc/HA do
-            # promptly after stream_source() returns; PLI re-arms an IDR so a
-            # late consumer still gets decodable frames within ~5 s.
-            #
-            # VIDEO-ONLY BY DEFAULT (the AAC audio transcode was DEADLOCKING the
-            # serve under loss; root-caused live 2026-06-08).  The mpegts muxer
-            # cannot write its PAT/PMT until every mapped output stream has
-            # produced a first packet.  `-c:v copy` knows the H.264 params from
-            # the input SDP immediately, but `-c:a aac` must ENCODE a first AAC
-            # frame, which needs real PCMA samples.  On a battery camera over a
-            # weak uplink the PCMA (PT=8) audio arrives sparse/late, the encoder
-            # yields "No filtered frames for output stream", the PMT is never
-            # written, and the consumer (go2rtc/HA) receives ZERO bytes -> the
-            # dashboard spins forever with no error and no timeout.  Proven by a
-            # serve-path A/B: production AAC config -> 0 bytes; `-an` -> 3.8 MB /
-            # 408 frames / 10 IDRs in 25 s.  (`-max_interleave_delta 0` does NOT
-            # rescue it - the block is the PMT, not interleaving.)  So drop audio
-            # by default and let video flow; the H.264 is `-c:v copy` untouched.
-            #
-            # Opt back into audio with AIDOT_SDES_SERVE_AUDIO=1 (e.g. a strong-
-            # signal/mains camera where PCMA arrives densely enough to keep the
-            # AAC encoder fed).  When enabled: transcode PCMA->AAC@48k with a
-            # STATELESS `volume` trim (the mic runs hot; default -8 dB, env-tunable
-            # via AIDOT_SDES_AUDIO_GAIN_DB).  Dynamic normalizers (dynaudnorm/
-            # loudnorm) and `-max_interleave_delta 0` are avoided - both regressed
-            # the pipe (buffering / ~100 ms audio cutouts) in earlier live tests.
-            _sdes_audio = getattr(self, "_sdes_audio_opt", None)
-            if _sdes_audio is None:
-                _sdes_audio = os.environ.get("AIDOT_SDES_SERVE_AUDIO", "0") == "1"
-            if _sdes_audio:
-                try:
-                    _sdes_gain_db = float(
-                        os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")
-                    )
-                except (ValueError, TypeError):
-                    _sdes_gain_db = -8.0
-                dest_args = [
-                    "-c:v", "copy",
-                    # aresample=async=1 fills timing gaps with silence so the AAC
-                    # encoder always has a full 1024-sample frame to emit.  Battery
-                    # cameras send PCMA sparsely (radio duty-cycling + weak uplink);
-                    # without this the encoder starves, the mpegts PAT/PMT is never
-                    # written, and the consumer gets ZERO bytes - the whole stream
-                    # dies.  first_pts=0 anchors the clock so the first AAC frame
-                    # (and thus the PMT) is produced promptly at stream start.
-                    "-af", f"aresample=async=1:first_pts=0,volume={_sdes_gain_db}dB",
-                    "-c:a", "aac", "-ar", "48000", "-b:a", "128k",
-                    "-f", "mpegts", "-listen", "1",
-                    rtsp_push_url,
-                ]
-            else:
-                dest_args = [
-                    "-c:v", "copy", "-an",
-                    "-f", "mpegts", "-listen", "1",
-                    rtsp_push_url,
-                ]
-        elif rtsp_push_url:
-            # Legacy PUSH model: publish to an RTSP server (e.g. go2rtc at :8554).
-            # Requires the stream to be pre-registered in go2rtc; retained for
-            # non-HA callers that run their own go2rtc config.  -rtsp_transport tcp
-            # avoids UDP fragmentation on loopback.
-            dest_args = [
-                "-c", "copy",
-                "-f", "rtsp", "-rtsp_transport", "tcp",
-                rtsp_push_url,
-            ]
+            # go2rtc / HA's stream integration pull it the standard way - the only
+            # per-camera side effect here is the cold-start serve-relay rewrite
+            # above; the destination + audio args (and the PMT-stall rationale for
+            # audio being opt-in) live in _build_sdes_serve_cmd, built once below.
         elif output_path:
-            # Ensure the output directory exists before ffmpeg tries to open the
-            # file.  ffmpeg fails with "No such file or directory" if the parent
-            # directory is missing.
+            # Ensure the output directory exists before ffmpeg opens the file
+            # (ffmpeg fails with "No such file or directory" otherwise).
             out_dir = os.path.dirname(output_path)
             if out_dir:
                 os.makedirs(out_dir, exist_ok=True)
-            dest_args = ["-c", "copy", output_path]
-        else:
-            # -c copy /dev/null fails: "Unable to find a suitable output format
-            # for '/dev/null'".  Use the null muxer instead so ffmpeg stays
-            # alive and receives the SRTP stream without writing anything.
-            dest_args = ["-f", "null", "/dev/null"]
-        # Output-side duration limit: -t N stops ffmpeg after N seconds of
-        # encoded output.  The bridge thread detects ffmpeg exit via proc.poll()
-        # and stops forwarding + sending keepalives automatically.
-        _time_args = ["-t", str(int(max_seconds))] if max_seconds else []
-        cmd = [
-            "ffmpeg", "-y",
-            "-loglevel", "warning",
-            "-protocol_whitelist", "file,rtp,udp,srtp",
-            # 2 s analyzeduration: the camera sends SPS+PPS+IDR in the very
-            # first burst (seq=0,1,2...).  15 s consumed nearly all packets
-            # during analysis, leaving only 1s of output in a 30s test.
-            # PLI forces a new IDR every 5 s, so parameters always re-arrive.
-            "-fflags", "+nobuffer+genpts",
-            "-analyzeduration", "2000000",
-            "-probesize", "500000",
-            "-i", sdp_path,
-            *_time_args,
-            *dest_args,
-        ]
+        # Build the ffmpeg command (single source of truth: _build_sdes_serve_cmd).
+        _sdes_audio = self._resolve_sdes_serve_audio()
+        try:
+            _sdes_gain_db = float(os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8"))
+        except (ValueError, TypeError):
+            _sdes_gain_db = -8.0
+        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=bool(_sdes_audio),
+            audio_gain_db=_sdes_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

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/src/aidot/camera/sdes.py

@@ -181,15 +181,23 @@ class SdesSession:
             self._talk_state["stop"] = True
             self._talk_state["provider"] = None
         self._proc.terminate()
+        _stop_loop = asyncio.get_running_loop()
         try:
-            _stop_loop = asyncio.get_running_loop()
             await _stop_loop.run_in_executor(None, lambda: self._proc.wait(5))
         except Exception:
             self._proc.kill()
+        # Read drained stderr in the executor with a hard timeout: proc.stderr.read()
+        # blocks until EOF, which never arrives if the killed process is still a
+        # zombie / stuck in uninterruptible I/O - doing it inline would hang the
+        # whole event loop (and thus all of teardown).  Bound it so a wedged ffmpeg
+        # can't stall the close; we lose only the diagnostic stderr in that case.
         stderr_bytes = b""
         try:
-            stderr_bytes = self._proc.stderr.read()
-        except Exception:
+            stderr_bytes = await asyncio.wait_for(
+                _stop_loop.run_in_executor(None, self._proc.stderr.read),
+                timeout=2.0,
+            )
+        except Exception:   # incl. asyncio.TimeoutError - never let teardown hang here
             _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
         if stderr_bytes:
             _LOGGER.warning("ffmpeg SDES stderr:\n%s", stderr_bytes.decode(errors="replace"))

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/src/aidot/device_client.py

@@ -229,14 +229,35 @@ class DeviceClient(CameraMixin):
         if ip is None:
             return
         self._ip_address = ip
-        if self._connecting is not True and self._connect_and_login is not True:
-            self._login_task = asyncio.create_task(self.async_login())
+        if self._connecting is True or self._connect_and_login is True:
+            return
+        # Throttle (shared 30s window with the reconnect chain): a repeated
+        # discovery - or a camera that slipped the _is_camera gate because its
+        # model was momentarily unknown - must not spawn a fresh TCP:10000 login
+        # every broadcast tick.  That hammers a device whose control port refuses
+        # (e.g. a battery camera) and spams "login read status error".  A device
+        # that genuinely needs to connect still does so within 30s.
+        now = time.monotonic()
+        if now - self._last_login_attempt < 30:
+            return
+        self._last_login_attempt = now
+        self._login_task = asyncio.create_task(self.async_login())
 
 
     async def async_login(self) -> None:
         """Connect and log in using the last-known IP if not already connected."""
         if self._ip_address is None:
             return
+        # The base TCP:10000 control channel is the LIGHT protocol.  Cameras never
+        # use it - their local control is the separate CameraLanClient
+        # (camera/lan_control.py) and their LAN IP comes from WebRTC signaling.  A
+        # camera reaching here means a discovered IP slipped the _is_camera gate;
+        # logging in would hammer a port the camera doesn't serve and spam
+        # "login read status error" (and never connect).  This is the single
+        # chokepoint for both the discovery and reconnect-chain login paths.
+        model = getattr(getattr(self, "info", None), "model_id", "") or ""
+        if "IPC" in model:
+            return
         if self._connecting is not True and self._connect_and_login is not True:
             await self.connect(self._ip_address)
 

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34/src/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.32
+Version: 0.7.34
 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
@@ -140,5 +140,5 @@ chosen to work out of the box; override only when tuning.
 | `AIDOT_AUDIO_MAXGAIN_DB` | Maximum gain (dB) applied by the audio normalizer. | `30` |
 | `AIDOT_AUDIO_MINGAIN_DB` | Minimum gain (dB) applied by the audio normalizer. | `-12` |
 | `AIDOT_AUDIO_GATE_DBFS` | Noise-gate threshold (dBFS) for two-way audio. | `-45` |
-| `AIDOT_SDES_SERVE_AUDIO` | Set to `1` to serve audio on SDES cameras (off by default). | `0` (off) |
+| `AIDOT_SDES_SERVE_AUDIO` | Serve audio on SDES cameras (**on by default** — a silence-base mix keeps the audio encoder fed so battery-camera audio streams smoothly). Set to `0`/`false`/`no`/`off` to disable. | on |
 | `AIDOT_SDES_AUDIO_GAIN_DB` | Gain (dB) applied when SDES audio is served. | `-8` |

{python_aidot_cameras-0.7.32 → python_aidot_cameras-0.7.34}/src/python_aidot_cameras.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/python_aidot_cameras.egg-info/requires.txt
 src/python_aidot_cameras.egg-info/top_level.txt
 tests/test_alarm_event.py
 tests/test_backoff.py
+tests/test_device_login_guard.py
 tests/test_go2rtc.py
 tests/test_highport_nomination.py
 tests/test_lan_control.py
@@ -47,6 +48,8 @@ tests/test_post_merge_hardening.py
 tests/test_sdes_adaptive.py
 tests/test_sdes_fast_liveplay.py
 tests/test_sdes_idle_release.py
+tests/test_sdes_serve_audio.py
+tests/test_sdes_serve_cmd.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_watchdog.py

python_aidot_cameras-0.7.34/tests/test_device_login_guard.py

@@ -0,0 +1,95 @@
+"""Unit tests for the base-DeviceClient local-login guard + throttle.
+
+The TCP:10000 control channel is the LIGHT protocol; cameras must never use it
+(they use the separate CameraLanClient + WebRTC signaling for their LAN IP). A
+camera reaching async_login would hammer a refusing port and spam
+"login read status error". These tests lock the camera-exclusion and the
+re-login throttle without a real socket.
+"""
+import asyncio
+import os
+import sys
+from types import SimpleNamespace
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.device_client as dc_mod
+
+DeviceClient = dc_mod.DeviceClient
+
+
+def _client(model_id):
+    c = DeviceClient.__new__(DeviceClient)
+    c.info = SimpleNamespace(model_id=model_id)
+    c._ip_address = "192.168.1.50"
+    c._connecting = False
+    c._connect_and_login = False
+    c._last_login_attempt = 0.0
+    c._connected = []  # record connect() calls
+    async def _fake_connect(ip):
+        c._connected.append(ip)
+    c.connect = _fake_connect
+    return c
+
+
+def test_camera_never_does_base_login():
+    cam = _client("LK.IPC.A001513")          # battery SDES camera
+    asyncio.run(cam.async_login())
+    assert cam._connected == []               # camera excluded - no TCP:10000 login
+
+
+def test_ptz_camera_excluded():
+    cam = _client("LK.IPC.A001064")
+    asyncio.run(cam.async_login())
+    assert cam._connected == []
+
+
+def test_light_still_logs_in():
+    light = _client("lk.WIFI-RGBWLight-D0006")
+    asyncio.run(light.async_login())
+    assert light._connected == ["192.168.1.50"]   # lights keep the base login
+
+
+def test_unknown_model_logs_in():
+    # No "IPC" in model -> treated as a (light) device that uses the base channel.
+    dev = _client("")
+    asyncio.run(dev.async_login())
+    assert dev._connected == ["192.168.1.50"]
+
+
+def test_update_ip_address_throttles_relogin():
+    light = _client("lk.WIFI-RGBWLight-D0006")
+    spawned = []
+    # update_ip_address schedules async_login via create_task; capture the calls
+    # by counting how many times the throttle lets a login attempt through.
+    light._login_task = None
+    orig = dc_mod.asyncio.create_task
+
+    def _count_task(coro):
+        spawned.append(1)
+        coro.close()            # don't actually run the login
+        return SimpleNamespace(done=lambda: True, cancel=lambda: None)
+
+    dc_mod.asyncio.create_task = _count_task
+    try:
+        light.update_ip_address("192.168.1.50")   # first: allowed
+        light.update_ip_address("192.168.1.50")   # immediate repeat: throttled
+        light.update_ip_address("192.168.1.50")   # still throttled
+    finally:
+        dc_mod.asyncio.create_task = orig
+    assert len(spawned) == 1, f"expected 1 login within the 30s window, got {len(spawned)}"
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)

python_aidot_cameras-0.7.34/tests/test_sdes_serve_audio.py

@@ -0,0 +1,68 @@
+"""Unit tests for _resolve_sdes_serve_audio - SDES serve audio (default ON).
+
+Locks the opt/env precedence (per-camera kwarg wins over AIDOT_SDES_SERVE_AUDIO,
+default on for app-parity) so the wiring is verifiable without a camera. The
+silence-mix's real-world stability is covered by live soak.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.camera.client as cc
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "_resolve_sdes_serve_audio" in v.__dict__)
+
+
+def _cam():
+    return _CAM.__new__(_CAM)
+
+
+def test_default_on(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_SERVE_AUDIO", raising=False)
+    assert _cam()._resolve_sdes_serve_audio() is True
+
+
+def test_env_disables(monkeypatch):
+    for val in ("0", "false", "no", "off", " Off "):
+        monkeypatch.setenv("AIDOT_SDES_SERVE_AUDIO", val)
+        assert _cam()._resolve_sdes_serve_audio() is False, val
+
+
+def test_env_truthy_or_unknown_stays_on(monkeypatch):
+    for val in ("1", "true", "yes", "on", "", "anything"):
+        monkeypatch.setenv("AIDOT_SDES_SERVE_AUDIO", val)
+        assert _cam()._resolve_sdes_serve_audio() is True, val
+
+
+def test_kwarg_option_wins_over_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_SERVE_AUDIO", "1")
+    cam = _cam()
+    cam._sdes_audio_opt = False           # start_keepalive(sdes_audio=False)
+    assert cam._resolve_sdes_serve_audio() is False
+
+    cam2 = _cam()
+    monkeypatch.setenv("AIDOT_SDES_SERVE_AUDIO", "0")
+    cam2._sdes_audio_opt = True
+    assert cam2._resolve_sdes_serve_audio() is True
+
+
+if __name__ == "__main__":
+    import traceback
+
+    class _MP:
+        def setenv(self, k, v): os.environ[k] = v
+        def delenv(self, k, raising=False): os.environ.pop(k, None)
+
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v(_MP()) if _v.__code__.co_argcount else _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)

python_aidot_cameras-0.7.34/tests/test_sdes_serve_cmd.py

@@ -0,0 +1,99 @@
+"""Unit tests for _build_sdes_serve_cmd - the SDES bridge ffmpeg command builder.
+
+This is the pure, side-effect-free seam extracted so every serve destination
+(http-listen pull / RTSP push / file / null) and the audio trade-off can be
+asserted without a live camera. The real-time PMT-stall behaviour on sparse
+battery PCMA is validated by live soak, not here.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+from aidot.camera.client import _build_sdes_serve_cmd as build
+
+
+def _idx(cmd, item):
+    return cmd.index(item)
+
+
+def test_http_pull_video_only_default():
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="http://127.0.0.1:9000")
+    assert cmd[0] == "ffmpeg"
+    assert "-c:v" in cmd and cmd[_idx(cmd, "-c:v") + 1] == "copy"
+    assert "-an" in cmd                       # audio dropped by default
+    assert "-c:a" not in cmd                  # no AAC encoder
+    assert cmd[-3:] == ["-listen", "1", "http://127.0.0.1:9000"]
+
+
+def test_http_pull_with_audio_silence_mix():
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="http://127.0.0.1:9000",
+                sdes_audio=True, audio_gain_db=-8.0)
+    assert "-an" not in cmd
+    assert cmd[_idx(cmd, "-c:a") + 1] == "aac"
+    # Continuous silence second input keeps the encoder fed from t=0.
+    assert "anullsrc=r=8000:cl=mono" in cmd
+    fc = cmd[_idx(cmd, "-filter_complex") + 1]
+    assert "amix=inputs=2:duration=longest:normalize=0" in fc  # silence-base mix
+    assert "volume=-8.0dB" in fc
+    # explicit maps: copied video + mixed audio
+    assert "0:v:0" in cmd and "[aout]" in cmd
+    # output muxer is mpegts (the first -f is the lavfi silence input)
+    assert "mpegts" in cmd and cmd[cmd.index("mpegts") - 1] == "-f"
+    assert cmd[-4:] == ["mpegts", "-listen", "1", "http://127.0.0.1:9000"]
+
+
+def test_audio_gain_is_parameterised():
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="http://h", sdes_audio=True, audio_gain_db=-3.5)
+    assert "volume=-3.5dB" in cmd[_idx(cmd, "-filter_complex") + 1]
+
+
+def test_video_copy_present_even_with_audio():
+    # The whole point: video is always -c:v copy, never gated on audio, so an
+    # audio-side stall can't block the video PMT being known from the SDP.
+    for audio in (False, True):
+        cmd = build(sdp_path="/x.sdp", rtsp_push_url="http://h", sdes_audio=audio)
+        assert cmd[_idx(cmd, "-c:v") + 1] == "copy"
+
+
+def test_file_recording_is_always_copy_even_with_audio():
+    # File output (snapshots/diagnostics) never transcodes audio - the silence
+    # mix is for the live serve only.  Keeps snapshots a fast video-only copy and
+    # avoids referencing [0:a] on a video-narrowed SDP.
+    for ext in ("ts", "mkv", "mp4"):
+        cmd = build(sdp_path="/x.sdp", output_path=f"/tmp/rec.{ext}", sdes_audio=True, max_seconds=30)
+        assert "anullsrc" not in " ".join(cmd), ext
+        assert cmd[_idx(cmd, "-c") + 1] == "copy", ext
+        assert cmd[-1] == f"/tmp/rec.{ext}", ext
+
+
+def test_rtsp_push_copies_both():
+    cmd = build(sdp_path="/x.sdp", rtsp_push_url="rtsp://127.0.0.1:8554/cam")
+    assert cmd[_idx(cmd, "-c") + 1] == "copy"
+    assert cmd[_idx(cmd, "-f") + 1] == "rtsp"
+    assert cmd[-1] == "rtsp://127.0.0.1:8554/cam"
+
+
+def test_file_output():
+    cmd = build(sdp_path="/x.sdp", output_path="/tmp/o.ts")
+    assert cmd[-2:] == ["-c", "copy"][:1] + ["/tmp/o.ts"] or cmd[-1] == "/tmp/o.ts"
+    assert cmd[-1] == "/tmp/o.ts"
+
+
+def test_null_when_no_destination():
+    cmd = build(sdp_path="/x.sdp")
+    assert cmd[-2:] == ["-f", "null"][:1] + ["/dev/null"] or cmd[-1] == "/dev/null"
+    assert "null" in cmd
+
+
+def test_max_seconds_adds_t_flag():
+    cmd = build(sdp_path="/x.sdp", output_path="/tmp/o.ts", max_seconds=30)
+    assert cmd[_idx(cmd, "-t") + 1] == "30"
+    # no -t when unset
+    assert "-t" not in build(sdp_path="/x.sdp", output_path="/tmp/o.ts")
+
+
+def test_sdp_input_always_present():
+    cmd = build(sdp_path="/path/to/session.sdp")
+    assert cmd[_idx(cmd, "-i") + 1] == "/path/to/session.sdp"
+    assert "file,rtp,udp,srtp" in cmd