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

{python_aidot_cameras-0.12.4/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.4
+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.4 → python_aidot_cameras-0.12.6}/aidot_cameras/camera/client.py

@@ -3360,27 +3360,25 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
     def _resolve_sdes_serve_audio(self) -> bool:
         """Whether to include audio in the SDES camera serve.
 
-        **Default OFF**, because including it can cost the video entirely.  The
-        mpegts mux writes its PAT/PMT only once EVERY mapped stream has produced a
-        packet, and ``amix`` does not emit until every one of its inputs has
-        delivered a frame - so on a camera that sends no PCMA, the AAC encoder
-        never produces, the PMT is never written, and a consumer gets an accepted
-        connection and then zero bytes.  The continuous ``anullsrc`` silence base
-        was meant to prevent exactly that and does not: verified live on a battery
-        camera, audio on gave 0 bytes across 45 consecutive attach attempts while
-        audio off gave 303 KB of 1280x960 H.264 from the same session, and
-        reordering the mix so the silence drives it did not help.
-
-        Missing audio is a worse experience than the app; NO VIDEO is a broken
-        integration, so video wins the tie.  Turn audio back on per camera with
-        ``sdes_audio`` (via ``start_keepalive``), or globally with
-        ``AIDOT_SDES_SERVE_AUDIO=1`` - on a camera that does send audio steadily
-        it works, which is why this stays an option rather than being removed."""
+        **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:
             return bool(opt)
-        return os.environ.get("AIDOT_SDES_SERVE_AUDIO", "").strip().lower() in (
-            "1", "true", "yes", "on")
+        return os.environ.get("AIDOT_SDES_SERVE_AUDIO", "").strip().lower() not in (
+            "0", "false", "no", "off")
 
     def _resolve_sdes_audio_gain_db(self) -> float:
         """Gain (dB) applied to the served SDES audio (the camera mic runs hot).

{python_aidot_cameras-0.12.4 → 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))

{python_aidot_cameras-0.12.4 → python_aidot_cameras-0.12.6}/pyproject.toml

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

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

@@ -118,6 +118,7 @@ tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_teardown_exit_log.py
 tests/test_sdes_watchdog.py
+tests/test_sdp_payload_type_narrowing.py
 tests/test_security_hardening.py
 tests/test_serializable_login_info.py
 tests/test_serve_relay.py

{python_aidot_cameras-0.12.4 → python_aidot_cameras-0.12.6}/tests/test_sdes_serve_audio.py

@@ -1,13 +1,14 @@
-"""Unit tests for _resolve_sdes_serve_audio - SDES serve audio (default OFF).
+"""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)
-so the wiring is verifiable without a camera.
+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 default is OFF because mapping audio into the pull serve can cost the video
-entirely: mpegts writes its PAT/PMT only once every mapped stream has produced a
-packet, and amix does not emit until every input has delivered a frame, so a
-camera that sends no PCMA yields an accepted connection and zero bytes. Verified
-live - see the docstring on the method for the measurements.
+The default was briefly OFF because mapping audio served no video at all - the
+audio m-line advertised PCMU while the bridge sends PCMA, so ffmpeg discarded
+every audio packet and the mpegts mux never wrote its PAT/PMT. The audio payload
+type is narrowed now, with a video-only fallback when it cannot be characterised,
+so audio can no longer cost the picture and the default is back on. The narrowing
+itself is covered by test_sdp_payload_type_narrowing.py.
 """
 import os
 import sys
@@ -24,23 +25,21 @@ def _cam():
     return _CAM.__new__(_CAM)
 
 
-def test_default_off_so_a_silent_camera_still_serves_video(monkeypatch):
+def test_default_on_for_app_parity(monkeypatch):
     monkeypatch.delenv("AIDOT_SDES_SERVE_AUDIO", raising=False)
-    assert _cam()._resolve_sdes_serve_audio() is False
+    assert _cam()._resolve_sdes_serve_audio() is True
 
 
-def test_env_enables(monkeypatch):
-    for val in ("1", "true", "yes", "on", " On "):
+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 True, val
+        assert _cam()._resolve_sdes_serve_audio() is False, val
 
 
-def test_env_falsy_or_unknown_stays_off(monkeypatch):
-    # Anything that is not an explicit opt-in leaves video protected: an
-    # unrecognised value must not silently re-enable the mux-stalling path.
-    for val in ("0", "false", "no", "off", "", "anything"):
+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 False, val
+        assert _cam()._resolve_sdes_serve_audio() is True, val
 
 
 def test_kwarg_option_wins_over_env(monkeypatch):

python_aidot_cameras-0.12.6/tests/test_sdp_payload_type_narrowing.py

@@ -0,0 +1,83 @@
+"""The ffmpeg SDP must advertise ONE 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 lists both candidates
+per line because the camera picks one per session, so whichever it actually sends
+has to be promoted before launch.
+
+On the video line, getting this wrong costs the picture - that was the known
+H.265 bug. On the audio line it also costs the picture, and far 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 leaves the consumer
+with zero bytes, video included, while signaling looks perfectly healthy. That is
+what made enabling serve audio look like it broke streaming outright.
+"""
+from aidot_cameras.camera.sdes_open import narrow_sdp_payload_types
+
+_SDP = (
+    "v=0\r\n"
+    "o=- 1 1 IN IP4 0.0.0.0\r\n"
+    "s=aidot-sdes-rx\r\n"
+    "t=0 0\r\n"
+    "m=audio 34162 RTP/AVP 0 8\r\n"
+    "c=IN IP4 127.0.0.1\r\n"
+    "a=rtpmap:0 PCMU/8000\r\n"
+    "a=rtpmap:8 PCMA/8000\r\n"
+    "m=video 38738 RTP/AVP 96 97\r\n"
+    "c=IN IP4 127.0.0.1\r\n"
+    "a=rtpmap:96 H264/90000\r\n"
+    "a=rtpmap:97 H265/90000\r\n"
+    "a=fmtp:96 packetization-mode=1\r\n"
+)
+
+
+def test_pcma_camera_gets_an_audio_line_advertising_only_pcma():
+    # The live failure: the camera sends PCMA (8) but PCMU (0) is listed first, so
+    # ffmpeg bound PCMU and discarded every audio packet.
+    out = narrow_sdp_payload_types(_SDP, keep_video=96, keep_audio=8)
+    assert "m=audio 34162 RTP/AVP 8\r\n" in out
+    assert "a=rtpmap:8 PCMA/8000" in out
+    assert "a=rtpmap:0 PCMU/8000" not in out
+
+
+def test_pcmu_camera_gets_the_other_one():
+    out = narrow_sdp_payload_types(_SDP, keep_video=96, keep_audio=0)
+    assert "m=audio 34162 RTP/AVP 0\r\n" in out
+    assert "a=rtpmap:0 PCMU/8000" in out
+    assert "a=rtpmap:8 PCMA/8000" not in out
+
+
+def test_h265_video_narrowing_still_works():
+    # The pre-existing behaviour this generalises; it must not regress.
+    out = narrow_sdp_payload_types(_SDP, keep_video=97, keep_audio=8)
+    assert "m=video 38738 RTP/AVP 97\r\n" in out
+    assert "a=rtpmap:97 H265/90000" in out
+    assert "a=rtpmap:96 H264/90000" not in out
+    assert "a=fmtp:96 " not in out          # the dropped codec's fmtp goes too
+
+
+def test_h264_keeps_its_fmtp():
+    out = narrow_sdp_payload_types(_SDP, keep_video=96, keep_audio=8)
+    assert "a=fmtp:96 packetization-mode=1" in out
+
+
+def test_none_leaves_a_line_untouched():
+    # Video observed, audio not (or audio not being served): the audio line must
+    # be left exactly as it was rather than half-rewritten.
+    out = narrow_sdp_payload_types(_SDP, keep_video=96, keep_audio=None)
+    assert "m=audio 34162 RTP/AVP 0 8\r\n" in out
+    assert "a=rtpmap:0 PCMU/8000" in out
+    assert "a=rtpmap:8 PCMA/8000" in out
+    assert "m=video 38738 RTP/AVP 96\r\n" in out
+
+
+def test_both_none_is_an_exact_passthrough():
+    assert narrow_sdp_payload_types(_SDP) == _SDP
+
+
+def test_line_endings_and_ordering_survive():
+    # ffmpeg is strict about SDP framing; the rewrite must not reflow it.
+    out = narrow_sdp_payload_types(_SDP, keep_video=96, keep_audio=8)
+    assert out.endswith("\r\n")
+    assert "\n\n" not in out
+    assert out.index("m=audio") < out.index("m=video")   # stream order preserved