python-aidot-cameras 0.7.33__tar.gz → 0.7.35__tar.gz

{python_aidot_cameras-0.7.33/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.7.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.33
+Version: 0.7.35
 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.33 → python_aidot_cameras-0.7.35}/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.33 → python_aidot_cameras-0.7.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.7.33"
+version = "0.7.35"
 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.33 → python_aidot_cameras-0.7.35}/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
 # --------------------------------------------------------------------------- #
@@ -1983,6 +2071,7 @@ class CameraMixin(_CameraControlsMixin):
         sdes_fast_liveplay: Optional[bool] = None,
         sdes_skip_turn: Optional[bool] = None,
         sdes_adaptive: Optional[bool] = None,
+        sdes_audio_gain_db: Optional[float] = None,
     ) -> None:
         """Start a persistent stream that keeps the camera session alive.
 
@@ -2025,6 +2114,8 @@ class CameraMixin(_CameraControlsMixin):
             self._fast_connect_opt = fast_connect
         if sdes_audio is not None:
             self._sdes_audio_opt = sdes_audio
+        if sdes_audio_gain_db is not None:
+            self._sdes_audio_gain_opt = sdes_audio_gain_db
         if live_stream_param is not None:
             self._live_stream_param_opt = live_stream_param
         if serve_relay is not None:
@@ -2632,6 +2723,33 @@ 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_audio_gain_db(self) -> float:
+        """Gain (dB) applied to the served SDES audio (the camera mic runs hot).
+
+        Per-camera ``sdes_audio_gain_db`` (via ``start_keepalive``) wins; else the
+        ``AIDOT_SDES_AUDIO_GAIN_DB`` env; else ``-8``.  A bad value falls back to
+        the default rather than raising."""
+        opt = getattr(self, "_sdes_audio_gain_opt", None)
+        src = opt if opt is not None else os.environ.get("AIDOT_SDES_AUDIO_GAIN_DB", "-8")
+        try:
+            return float(src)
+        except (ValueError, TypeError):
+            return -8.0
+
     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 +10057,25 @@ 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).
+        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(),
+            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

{python_aidot_cameras-0.7.33 → python_aidot_cameras-0.7.35/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -48,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.35/tests/test_sdes_serve_audio.py

@@ -0,0 +1,90 @@
+"""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
+
+
+def test_gain_default(monkeypatch):
+    monkeypatch.delenv("AIDOT_SDES_AUDIO_GAIN_DB", raising=False)
+    assert _cam()._resolve_sdes_audio_gain_db() == -8.0
+
+
+def test_gain_env(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "-3.5")
+    assert _cam()._resolve_sdes_audio_gain_db() == -3.5
+
+
+def test_gain_opt_wins(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "-3")
+    cam = _cam()
+    cam._sdes_audio_gain_opt = 2.0
+    assert cam._resolve_sdes_audio_gain_db() == 2.0
+
+
+def test_gain_bad_value_falls_back(monkeypatch):
+    monkeypatch.setenv("AIDOT_SDES_AUDIO_GAIN_DB", "loud")
+    assert _cam()._resolve_sdes_audio_gain_db() == -8.0
+
+
+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.35/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