python-aidot-cameras 0.12.2__tar.gz → 0.12.6__tar.gz

{python_aidot_cameras-0.12.2/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.6}/PKG-INFO

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

@@ -11,6 +11,7 @@ from typing import Any, Callable, List, Optional
 from ..exceptions import AidotCameraBusy, AidotCameraNotReady
 from ..const import APP_ID as _AIDOT_APP_ID
 from ..const import (
+    LOGIN_INFO_MQTT_PASSWORD_KEYS,
     LOGIN_INFO_PERSISTENT_MQTT_KEY,
     LOGIN_INFO_PERSISTENT_MQTT_LOCK_KEY,
 )
@@ -141,6 +142,11 @@ _DTLS_SERVE_OPEN_TIMEOUT_S = _parse_env_float("AIDOT_DTLS_SERVE_OPEN_TIMEOUT_S",
 # discarded task can be garbage-collected mid-flight. Discarded on completion.
 _BG_TASKS: set = set()
 
+# Minimum gap between MQTT credential refetches after the broker refused one.
+# One rotation is normal (another login happened); a second refusal that fast
+# means refetching is not helping, so back off rather than loop.
+_MQTT_CREDENTIAL_REFETCH_FLOOR = 30.0
+
 
 def _spawn_bg(coro):
     _t = asyncio.ensure_future(coro)
@@ -656,6 +662,11 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
     # Optional LAN control client; when attached, attribute writes go local-first.
     _lan_client = None
 
+    # MQTT credential state, defaulted at class level so the credential path is
+    # safe on any client whose __init__ did not run to completion.
+    _mqtt_credential_refresh_cb = None
+    _mqtt_refused_at = 0.0
+
     def attach_lan_client(self, lan_client) -> None:
         """Route camera attribute writes through ``lan_client`` (local-first,
         cloud-fallback).  Pass an ``aidot.camera.lan_control.CameraLanClient``."""
@@ -709,6 +720,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         # updates the shared login_info in place, so camera HTTP calls can recover
         # from a 21026 "Please login again" instead of failing silently.
         self._token_refresh_cb: "Optional[Callable]" = None
+        # Async callback (set by AidotClient) that fetches a fresh MQTT password
+        # into the shared login_info.  The password is deliberately never
+        # persisted (it rotates on every account login), so on a restart from a
+        # stored token there is none until this runs - see
+        # _async_get_smarthome_auth, which calls it before consulting login_info.
+        self._mqtt_credential_refresh_cb: "Optional[Callable]" = None
+        # Loop timestamp of the last broker credential refusal, for the refetch
+        # floor in _async_refresh_mqtt_credential.
+        self._mqtt_refused_at: float = 0.0
         # Raw device dict retained for transport-type detection (isDTLS field)
         self._raw_device: dict = device
 
@@ -945,6 +965,49 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         """Register the AidotClient coroutine that refreshes the access token."""
         self._token_refresh_cb = cb
 
+    def set_mqtt_credential_refresh_cb(self, cb: "Callable") -> None:
+        """Register the AidotClient coroutine that re-fetches the MQTT password."""
+        self._mqtt_credential_refresh_cb = cb
+
+    def _shared_mqtt_password(self) -> Optional[str]:
+        """The account's current MQTT password, or None if it holds none.
+
+        Read from the shared ``login_info`` dict, which is the single source of
+        truth: it is what the fetch writes and what a broker refusal clears.
+        """
+        li = self._user_info if isinstance(self._user_info, dict) else {}
+        for key in LOGIN_INFO_MQTT_PASSWORD_KEYS:
+            val = li.get(key)
+            if val:
+                return val
+        return None
+
+    async def _async_refresh_mqtt_credential(self) -> None:
+        """Ask the account client for a fresh MQTT password, if it can supply one.
+
+        Never raises: every caller has fallback strategies, so a failed fetch
+        should degrade rather than break a stream open.
+        """
+        cb = self._mqtt_credential_refresh_cb
+        if cb is None:
+            return
+        # Floor between attempts.  If the freshly fetched password is refused too
+        # - another login rotated again, or the endpoint hands back the same value
+        # - every stream open would otherwise cost another credential request and
+        # another refused connection.  Better to fail this open and let the next
+        # one try than to hammer the vendor's endpoint.
+        since = asyncio.get_running_loop().time() - self._mqtt_refused_at
+        if self._mqtt_refused_at and since < _MQTT_CREDENTIAL_REFETCH_FLOOR:
+            _LOGGER.debug(
+                "skipping MQTT credential refetch: only %.1fs since the last "
+                "refusal (floor %ss)", since, _MQTT_CREDENTIAL_REFETCH_FLOOR,
+            )
+            return
+        try:
+            await cb()
+        except Exception as exc:
+            _LOGGER.debug("MQTT credential refresh failed: %s", exc)
+
     @staticmethod
     def _is_auth_error(data: Any) -> bool:
         """True if a smarthome response means the token is stale (re-login)."""
@@ -1186,15 +1249,35 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         """Fetch MQTT credentials (mqttUser + mqttPassword) for the Arnoo broker.
 
         Strategy order - stops at first success:
-          0. Already cached
-          1. mqttPassword already in AiDot login_info (from _async_fetch_user_config)
+          0. Already cached, and still agreeing with the account-shared login_info
+          1. mqttPassword in AiDot login_info, fetching it first if absent
           2. GET /user/getUser  <- documented SDK step (reqUserAuthInfoWithCallback)
              Returns LDSAuthInfo {userId, mqttUser, mqttPassword, ...}
           3. getServerUrlConfig response side-effect (if MQTT URL not yet fetched)
           4. accessToken as MQTT password (Arnoo broker fallback)
         """
-        if self._smarthome_auth and self._smarthome_auth.get("mqttPassword"):
+        # Strategy 0.  This cache is per device client but the credential is per
+        # account, so the shared login_info wins any disagreement: when a broker
+        # refusal cleared or replaced the account's password, a sibling camera's
+        # cache still holds the dead one, and trusting it would refuse again on
+        # every camera in turn.  Treating the cache as cold whenever it disagrees
+        # makes login_info the single source of truth.
+        _cached_pwd = (self._smarthome_auth or {}).get("mqttPassword")
+        if _cached_pwd and _cached_pwd == self._shared_mqtt_password():
+            return self._smarthome_auth
+        # An empty login_info is not automatically "nothing to disagree with": it
+        # is exactly the post-invalidation state, since a refusal pops the shared
+        # password but can only null the cache on the ONE client whose connection
+        # was refused.  So a cache that CAME from login_info is stale here, while
+        # one from /user/getUser or the accessToken fallback is per client and has
+        # no shared counterpart to compare against.  Strategy 1 stamps its source
+        # precisely so the two can be told apart.
+        _cached_src = ((self._smarthome_auth or {}).get("raw") or {}).get("source") or ""
+        _from_shared = _cached_src.startswith("login_info.")
+        if _cached_pwd and self._shared_mqtt_password() is None and not _from_shared:
             return self._smarthome_auth
+        if _cached_pwd:
+            self._smarthome_auth = None
 
         import aiohttp
 
@@ -1205,9 +1288,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             or str(self.user_id)
         )
 
-        # --- Strategy 1: mqttPassword already in AiDot login_info ---
-        # _async_fetch_user_config() stores it under "mqttPassword" or "mqttPwd".
-        for key in ("mqttPassword", "mqttPwd"):
+        # --- Strategy 1: mqttPassword in AiDot login_info, fetched if absent ---
+        # The password is never persisted (it rotates on every account login), so
+        # login_info has none after a restart from a stored token, and a broker
+        # refusal clears it deliberately.  Fetch before reading, or the strategies
+        # below shadow the absence: strategy 4 always "succeeds" with the access
+        # token, which the broker then refuses, and the retry loops forever.
+        if self._shared_mqtt_password() is None:
+            await self._async_refresh_mqtt_credential()
+        for key in LOGIN_INFO_MQTT_PASSWORD_KEYS:
             val = self._user_info.get(key)
             if val:
                 self._smarthome_auth = {
@@ -3271,10 +3360,19 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
     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
+        **Default ON** for app-parity (the official app plays camera audio).
+
+        This was briefly defaulted off, because mapping audio used to serve no
+        video at all: the SDP advertises two payload types per media line and
+        ffmpeg binds the first, so the synthesised PCMA (pt 8) was discarded in
+        favour of the advertised PCMU (pt 0) - and since the mpegts mux withholds
+        its PAT/PMT until every mapped stream has produced a packet, the consumer
+        got zero bytes and lost the picture too.  The audio line is now narrowed to
+        the payload type actually in use, the same way the video line already was,
+        and the serve falls back to video-only if the audio payload type cannot be
+        characterised in time.  So audio can no longer cost the video.
+
+        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:
@@ -3403,26 +3501,55 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 return None
             from .protocol import _PersistentMqtt
 
+            # paho fires on_connect on its own network thread; every mutation
+            # below has to be ordered against the get-or-create above, so it is
+            # hopped onto this loop and taken under the same account lock.
+            _loop = asyncio.get_running_loop()
+
             def _invalidate_mqtt_credentials(rc) -> None:
-                """Drop the cached MQTT password so the next use re-fetches it.
+                """Retire the refused client and drop the credential it used.
 
                 The broker rotates this password on every account login and
                 allows one connection at a time, so any other login (the phone
                 app, a second Home Assistant, a script) invalidates ours.  The
                 cached copy lives in login_info, where it short-circuits the
                 credential fetch, so it has to be cleared or every retry reuses
-                the dead password.  The persistent client itself is dropped too,
-                so the next request rebuilds it with fresh credentials.
+                the dead password.
+
+                Runs on paho's network thread, so it only schedules the work: the
+                mutations must be ordered against a concurrent get-or-create, and
+                ``retire()`` calls ``loop_stop()``, which raises if called from
+                the very thread it would join.
                 """
-                for key in ("mqttPassword", "mqttPwd"):
+                _loop.call_soon_threadsafe(_spawn_bg, _retire_and_invalidate(rc))
+
+            async def _retire_and_invalidate(rc) -> None:
+                # Deliberately outside the lock.  These are plain dict writes with
+                # no ordering requirement, and a sibling can be holding the lock
+                # across an HTTP credential fetch - taking it here would stall the
+                # invalidation behind that request's timeout for no benefit.
+                for key in LOGIN_INFO_MQTT_PASSWORD_KEYS:
                     if li.pop(key, None) is not None:
                         _LOGGER.warning(
                             "cleared the cached MQTT password after the broker "
                             "rejected it (rc=%s); it will be re-fetched", rc,
                         )
                 self._smarthome_auth = None
-                if li.get(LOGIN_INFO_PERSISTENT_MQTT_KEY) is pm:
-                    li.pop(LOGIN_INFO_PERSISTENT_MQTT_KEY, None)
+                # The URL response is the one that can carry a server-issued
+                # password (strategy 3); leaving it cached would skip that
+                # fallback entirely on the recovery path.
+                self._mqtt_url = None
+                # Note the refusal so a second failure in quick succession backs
+                # off instead of hammering the credential endpoint.
+                self._mqtt_refused_at = _loop.time()
+                # This one DOES need the lock: it is a compare-and-pop against the
+                # get-or-create above, and without it a rebuild that already read
+                # the slot could have its replacement removed instead of ours.
+                async with lock:
+                    if li.get(LOGIN_INFO_PERSISTENT_MQTT_KEY) is pm:
+                        li.pop(LOGIN_INFO_PERSISTENT_MQTT_KEY, None)
+                # Outside the lock: retire() blocks briefly joining paho's thread.
+                await _loop.run_in_executor(None, pm.retire)
 
             pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id,
                                  on_auth_failure=_invalidate_mqtt_credentials)

{python_aidot_cameras-0.12.2 → python_aidot_cameras-0.12.6}/aidot_cameras/camera/protocol.py

@@ -1434,6 +1434,17 @@ class _PersistentMqtt:
         # the owner can invalidate its cache and re-authenticate.
         self._on_auth_failure = on_auth_failure
         self._auth_failed_reported = False
+        # Latched by the owner when it retires this instance after a refusal.  A
+        # retired client must stop reconnecting: paho's own retry loop would keep
+        # offering the dead password to the vendor's broker for the life of the
+        # process, and callers still holding it would block on a _connected event
+        # that can never set.
+        self._retired = False
+        # Set when the broker refuses our credentials.  Waiters check it so they
+        # fail fast instead of sitting out a 15s timeout on a connection that is
+        # never coming, and _connected stays clear so nothing publishes into a
+        # socket the broker rejected.
+        self._auth_refused = threading.Event()
         self._client = None
         self._host = None
         self._port = None
@@ -1492,7 +1503,11 @@ class _PersistentMqtt:
             self._connected.set()
         elif rc in self._AUTH_REFUSAL_RCS:
             # Stale credential: paho would retry this password forever.  Tell the
-            # owner once so it can invalidate its cache and re-authenticate.
+            # owner once so it can invalidate its cache, retire this client and
+            # re-authenticate.  Unblock anyone waiting on _connected first - they
+            # would otherwise sit out their full timeout for a connection that is
+            # never coming.
+            self._auth_refused.set()
             _LOGGER.warning(
                 "persistent mqtt: broker rejected our credentials (rc=%s) - the "
                 "MQTT password has almost certainly been rotated by another "
@@ -1527,6 +1542,12 @@ class _PersistentMqtt:
                 _LOGGER.debug("persistent mqtt: handler raised", exc_info=True)
 
     def _ensure_started_sync(self, timeout=15.0):
+        # A retired instance must never rebuild: retire() nulls _client, which on
+        # its own would look exactly like "not started yet" and reconnect with the
+        # credential the broker just refused.  Callers still holding a retired
+        # client get a clean False and fall back to a per-op session.
+        if self._retired:
+            return False
         with self._lock:
             if self._client is None:
                 self._client = self._build()
@@ -1538,7 +1559,18 @@ class _PersistentMqtt:
                     return False
                 self._client.loop_start()  # drives keepalive + auto-reconnect
                 self._started = True
-        return self._connected.wait(timeout)
+        # Wait for either outcome.  paho retries a refused CONNACK on its own
+        # schedule, so without watching _auth_refused every caller would burn the
+        # full timeout before the owner gets a chance to re-authenticate.
+        import time as _time
+        deadline = _time.monotonic() + timeout
+        while True:
+            if self._connected.wait(0.1):
+                return True
+            if self._auth_refused.is_set() or self._retired:
+                return False
+            if _time.monotonic() >= deadline:
+                return False
 
     def _subscribe_sync(self, topics):
         new = []
@@ -1646,6 +1678,24 @@ class _PersistentMqtt:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, functools.partial(_pub))
 
+    def retire(self):
+        """Permanently shut this client down after a credential refusal.
+
+        ``close()`` alone is not enough from the owner's side: paho's retry loop
+        was configured with ``reconnect_delay_set(max_delay=30)``, so a refused
+        client keeps re-offering the dead password to the vendor's broker for the
+        life of the process - and ``_auth_failed_reported`` latches, so it does so
+        silently.  Latching ``_retired`` also releases anyone still waiting on
+        this instance instead of leaving them blocked on a timeout.
+
+        Must not be called from paho's network thread: ``loop_stop()`` there
+        raises ``cannot join current thread``.  The owner schedules it onto the
+        event loop with ``call_soon_threadsafe``.
+        """
+        self._retired = True
+        self._on_auth_failure = None
+        self.close()
+
     def close(self):
         c = self._client
         self._client = None

{python_aidot_cameras-0.12.2 → python_aidot_cameras-0.12.6}/aidot_cameras/camera/sdes_open.py

@@ -34,6 +34,54 @@ from .protocol import (
 _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}
+
+# Extra time, on top of the video payload-type wait, to characterise the audio
+# payload type before the serve launches.  Short by design: audio that has not
+# appeared by then is served on a later open (every ffmpeg restart re-runs this
+# wait, and by then the camera has been streaming for a while), which is cheaper
+# than delaying the picture for every silent camera.
+_AUDIO_PT_GRACE_S = 4.0
+
+
+def narrow_sdp_payload_types(sdp_text: str, keep_video=None, keep_audio=None) -> str:
+    """Rewrite an SDP to advertise a single payload type per media line.
+
+    ffmpeg binds each RTP depacketizer to the FIRST payload type on the m-line and
+    silently discards packets carrying any other one.  The SDP written for the
+    bridge lists both candidates per line (``m=video ... 96 97`` for H.264/H.265,
+    ``m=audio ... 0 8`` for PCMU/PCMA) because which one the camera uses varies per
+    session, so whichever it actually sends has to be promoted before launch.
+
+    Getting this wrong on the VIDEO line costs the picture.  Getting it wrong on the
+    AUDIO line costs the picture too, and less obviously: the mpegts mux withholds
+    its PAT/PMT until every mapped stream has produced a packet, so an audio stream
+    whose packets are all discarded means the consumer receives zero bytes - video
+    included - while every other signal looks healthy.
+
+    ``keep_video`` / ``keep_audio`` of None leaves that line alone.
+    """
+    drop = {_SDP_ALTERNATE_PT[k] for k in (keep_video, keep_audio)
+            if k in _SDP_ALTERNATE_PT}
+    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}")
+        elif any(
+            stripped.startswith(f"a={attr}:{pt}{sep}")
+            for pt in drop
+            for attr, sep in (("rtpmap", " "), ("fmtp", " "), ("fmtp", ";"))
+        ):
+            continue
+        kept.append(line)
+    return "".join(kept)
+
+
 def _sdes_echo_wait_timeout(skip_liveplay: bool) -> float:
     """Seconds to block on the camera's webrtcReq echo before proceeding.
 
@@ -2141,6 +2189,11 @@ class _SdesOpenMixin:
         # bridge on the first video RTP packet so the ffmpeg SDP can be narrowed
         # to the matching single codec before ffmpeg is launched.
         _first_video_pt: list = [None]
+        # 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
+        # same way the video line already is.
+        _first_audio_pt: list = [None]
         # Media-liveness: bridge sets [0] = time.monotonic() on every forwarded
         # media packet; the keepalive watchdog reads it via SdesSession to
         # restart a session the camera silently stopped feeding.
@@ -3095,10 +3148,21 @@ class _SdesOpenMixin:
                                             )
                                             if not _br_first_audio_logged:
                                                 _br_first_audio_logged = True
+                                                # Record the payload type this path
+                                                # SYNTHESISES (_tk_pt, PCMA) so the
+                                                # SDP can be narrowed to it.  Without
+                                                # this the m=audio line keeps
+                                                # advertising "0 8", ffmpeg binds
+                                                # PCMU and discards every packet, and
+                                                # the mpegts PMT is never written - so
+                                                # the consumer gets zero bytes and the
+                                                # VIDEO is lost with the audio.
+                                                _first_audio_pt[0] = _tk_pt
                                                 _status(
                                                     f"bridge: first SDES audio -> ffmpeg"
                                                     f" loopback:{_lo_audio_port}"
                                                     f" ({len(_pd_plain)}B PCMA)"
+                                                    f" pt={_tk_pt}"
                                                 )
                                         except Exception:
                                             _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_enc_c8_sctp', exc_info=True)
@@ -3190,6 +3254,7 @@ class _SdesOpenMixin:
                                 )
                             if _kind == "audio" and not _br_first_audio_logged:
                                 _br_first_audio_logged = True
+                                _first_audio_pt[0] = _pt
                                 _status(f"bridge: first audio RTP pt={_pt}")
                                 # Capture the camera's audio return address so the talk
                                 # pump (SdesSession.async_start_talk) can send outbound
@@ -3454,12 +3519,13 @@ class _SdesOpenMixin:
             if out_dir:
                 os.makedirs(out_dir, exist_ok=True)
         # Build the ffmpeg command (single source of truth: _build_sdes_serve_cmd).
+        _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=self._resolve_sdes_serve_audio(),
+            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 ----
@@ -3470,36 +3536,71 @@ class _SdesOpenMixin:
         # video pt, then rewrite the SDP to that single codec before launch.
         # ffmpeg recovers on the next periodic keyframe, so the small spawn delay
         # is harmless.  Falls back to the dual-codec SDP if no video is seen.
+        # When audio is being served the same wait has to cover the AUDIO payload
+        # type, and for a stricter reason: an unnarrowed video line merely risks the
+        # picture, while an unnarrowed audio line guarantees the mux never writes its
+        # PAT/PMT, which loses the picture AND the audio.  Wait for both, then take
+        # whatever has been observed by the deadline.
+        # Two separate budgets on purpose.  Video keeps its original 15s, because
+        # the picture is what the viewer is waiting for.  Audio gets only a short
+        # extra grace on top: sharing one deadline would make a camera that never
+        # sends audio delay the picture from a couple of seconds to the full 15,
+        # which trades the bug for a worse one.
         _vpt_deadline = time.monotonic() + 15.0
         while _first_video_pt[0] is None and time.monotonic() < _vpt_deadline:
             await asyncio.sleep(0.1)
+        if _serve_audio and _first_audio_pt[0] is None:
+            _apt_deadline = time.monotonic() + _AUDIO_PT_GRACE_S
+            while _first_audio_pt[0] is None and time.monotonic() < _apt_deadline:
+                await asyncio.sleep(0.1)
         _vpt = _first_video_pt[0]
-        if _vpt in (96, 97):
-            def _narrow_sdp_to_pt(_sdp_text: str, _keep: int) -> str:
-                _drop = 96 if _keep == 97 else 97
-                _kept = []
-                for _ln in _sdp_text.splitlines(keepends=True):
-                    _s = _ln.lstrip()
-                    if _s.startswith("m=video"):
-                        _ln = _ln.replace(" 96 97", f" {_keep}")
-                    elif (_s.startswith(f"a=rtpmap:{_drop} ")
-                          or _s.startswith(f"a=fmtp:{_drop} ")
-                          or _s.startswith(f"a=fmtp:{_drop};")):
-                        continue
-                    _kept.append(_ln)
-                return "".join(_kept)
+        _apt = _first_audio_pt[0]
+        if _serve_audio and _apt 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.
+            _LOGGER.warning(
+                "camera %s: no audio observed before the serve launched, so the "
+                "audio payload type is unknown; mapping it would stall the mpegts "
+                "mux and serve no video. Continuing without audio.",
+                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(),
+            )
+        # 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
+        # has produced a packet - so an audio line advertising "0 8" (PCMU first)
+        # 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)):
             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(
                     None, _write_text_file, sdp_path,
-                    _narrow_sdp_to_pt(_cur_sdp, int(_vpt)))
+                    narrow_sdp_payload_types(_cur_sdp, _keep_v, _keep_a))
                 _status(
-                    f"SDES: narrowed ffmpeg SDP to video pt={_vpt}"
-                    f" ({'H265' if int(_vpt) == 97 else 'H264'})")
+                    "SDES: narrowed ffmpeg SDP to"
+                    + (f" video pt={_keep_v}"
+                       f" ({'H265' if _keep_v == 97 else 'H264'})"
+                       if _keep_v is not None else "")
+                    + (f" audio pt={_keep_a}"
+                       f" ({'PCMA' if _keep_a == 8 else 'PCMU'})"
+                       if _keep_a is not None else ""))
             except Exception:
                 _LOGGER.debug("camera %s: swallowed exception in %s", getattr(self, "device_id", "?"), '_open_sdes_stream', exc_info=True)
         _LOGGER.info("SDES ffmpeg cmd: %s", " ".join(cmd))