python-aidot-cameras 1.0.0rc64__tar.gz → 1.0.0rc65__tar.gz

{python_aidot_cameras-1.0.0rc64/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc65}/PKG-INFO

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

@@ -1041,9 +1041,13 @@ def _build_sdes_serve_cmd(
         # instead. Moving `-t` to the input side does not help - both placements
         # fail. Only a bounded run gives this up, and a bounded run is a
         # snapshot or the `-f null` drain, never the live stream.
+        # Nor for SD playback (``keep_probe_packets``): a recording arrives
+        # faster than it plays, and its timing is put right afterwards from
+        # the camera's per-frame recording time (sd_playback.PlaybackClock),
+        # which needs the camera's own RTP timestamps in the file.
         *(
             ["-use_wallclock_as_timestamps", "1"]
-            if _SERVE_ARRIVAL_TS and not max_seconds
+            if _SERVE_ARRIVAL_TS and not max_seconds and not keep_probe_packets
             else []
         ),
         # ``nobuffer`` drops what ffmpeg reads while probing the input (up to

{python_aidot_cameras-1.0.0rc64 → python_aidot_cameras-1.0.0rc65}/aidot_cameras/camera/sd_playback.py

@@ -305,6 +305,175 @@ def playback_peer_id(camera: Any, *, sdes: bool) -> str:
     )
 
 
+# --- The recording's own clock (SDES) ---------------------------------------
+#
+# The camera stamps a recording's RTP as if it had been recorded at its live
+# frame rate and sends it at that pace: an A001064 night recording made at
+# 5 fps (200 ms a frame) went out at 20 fps (50 ms a frame), its 60 s in 15 s,
+# and its sound - sent in real time - stopped when the video ran out
+# (2026-10-29). The vendor app plays it at the right speed because every
+# packet also carries the frame's time in the recording, in an RTP header
+# extension the camera adds once the offer names transport-cc and
+# rtp-stream-id (OfferUtils.processRtp keeps exactly those two extmap lines;
+# the answer then says ``supportRtpExt: 1``). The 11-byte value is a 2-byte
+# playback channel, a flag byte (0xf0) and the time in Unix milliseconds, all
+# big-endian; all ones marks the end of the recording, on the packets the
+# camera sends after its last frame.
+
+#: The two header extensions the vendor app's offer keeps, with the ids this
+#: library offers them under.
+EXT_TRANSPORT_CC = (
+    "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01"
+)
+EXT_FRAME_TIME = "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id"
+EXT_TRANSPORT_CC_ID = 3
+EXT_FRAME_TIME_ID = 4
+#: The frame-time value the camera sends once the recording has run out.
+FRAME_TIME_END = 0xFFFFFFFFFFFFFFFF
+
+_AUDIO_CLOCKS = {0: 8000, 8: 8000}
+
+
+def offer_with_frame_times(sdp: str) -> str:
+    """``sdp`` asking for the per-frame recording time: both extmap lines in
+    every audio and video section, after its mid, and transport-cc feedback
+    on each video payload type."""
+    extmaps = [
+        f"a=extmap:{EXT_TRANSPORT_CC_ID} {EXT_TRANSPORT_CC}",
+        f"a=extmap:{EXT_FRAME_TIME_ID} {EXT_FRAME_TIME}",
+    ]
+    out = []
+    kind, pts = "", []
+    for line in sdp.split("\r\n"):
+        if line.startswith("m="):
+            kind = line[2:].split(" ", 1)[0]
+            pts = line.split()[3:]
+        out.append(line)
+        if line.startswith("a=mid:") and kind in ("audio", "video"):
+            out.extend(extmaps)
+            if kind == "video":
+                out.extend(f"a=rtcp-fb:{pt} transport-cc" for pt in pts)
+    return "\r\n".join(out)
+
+
+def rtp_extension(pkt: bytes, ext_id: int) -> "Optional[bytes]":
+    """The value of header extension ``ext_id`` in RTP packet ``pkt`` (RFC
+    8285, one- or two-byte form), or None. The header is in the clear under
+    SRTP, so this reads a packet still encrypted."""
+    if len(pkt) < 12 or not pkt[0] & 0x10:
+        return None
+    off = 12 + 4 * (pkt[0] & 0x0F)
+    if len(pkt) < off + 4:
+        return None
+    profile = int.from_bytes(pkt[off : off + 2], "big")
+    end = off + 4 + 4 * int.from_bytes(pkt[off + 2 : off + 4], "big")
+    if end > len(pkt):
+        return None
+    i = off + 4
+    while i < end:
+        if profile == 0xBEDE:
+            b = pkt[i]
+            if b == 0:
+                i += 1
+                continue
+            eid, n, i = b >> 4, (b & 0x0F) + 1, i + 1
+        elif profile >> 4 == 0x100 and i + 1 < end:
+            if pkt[i] == 0:
+                i += 1
+                continue
+            eid, n, i = pkt[i], pkt[i + 1], i + 2
+        else:
+            return None
+        if eid == ext_id:
+            return bytes(pkt[i : i + n])
+        i += n
+    return None
+
+
+def frame_time_ms(value: "Optional[bytes]") -> "Optional[int]":
+    """The recording time (Unix ms) in a frame-time extension value;
+    ``FRAME_TIME_END`` at the end of the recording; None if absent."""
+    if value is None or len(value) != 11:
+        return None
+    return int.from_bytes(value[3:11], "big")
+
+
+class PlaybackClock:
+    """Pairs each stream's RTP timestamps with the recording's own time.
+
+    Fed every packet the playback forwards; keeps one (rtp timestamp, ms)
+    pair per change of recording time, per payload type. ``ended`` turns
+    True on the first end-of-recording mark. ``timing()`` is what
+    ``retime_playback_ts`` needs.
+    """
+
+    def __init__(self) -> None:
+        self._pairs: "dict[int, list[tuple[int, int]]]" = {}
+        self.ended = False
+
+    def observe(self, pkt: bytes) -> bool:
+        """Note ``pkt``; True if it is an end-of-recording packet (forward
+        nothing of those: the recording is over)."""
+        ms = frame_time_ms(rtp_extension(pkt, EXT_FRAME_TIME_ID))
+        if ms is None:
+            return False
+        if ms == FRAME_TIME_END:
+            self.ended = True
+            return True
+        pairs = self._pairs.setdefault(pkt[1] & 0x7F, [])
+        if not pairs or pairs[-1][1] != ms:
+            pairs.append((int.from_bytes(pkt[4:8], "big"), ms))
+        return False
+
+    def timing(self) -> "dict[str, tuple[float, float]]":
+        """Per stream kind (``"video"``, ``"audio"``): (scale, start_s) - each
+        second of RTP time is ``scale`` seconds of recording, and the stream
+        starts ``start_s`` after the earliest stream does. Empty when no
+        frame times arrived."""
+        # One stream per kind: the payload type with the most frame times
+        # (a stray second video type would otherwise decide by dict order).
+        best: "dict[str, int]" = {}
+        for pt, pairs in self._pairs.items():
+            kind = "audio" if pt in _AUDIO_CLOCKS else "video"
+            if len(pairs) > len(self._pairs.get(best.get(kind, -1), ())):
+                best[kind] = pt
+        firsts = [self._pairs[pt][0][1] for pt in best.values()]
+        if not firsts:
+            return {}
+        origin = min(firsts)
+        out = {}
+        for kind, pt in best.items():
+            pairs = self._pairs[pt]
+            clock = _AUDIO_CLOCKS.get(pt, 90000)
+            (r0, m0), (r1, m1) = pairs[0], pairs[-1]
+            rtp_s = ((r1 - r0) & 0xFFFFFFFF) / clock
+            scale = (m1 - m0) / 1000 / rtp_s if rtp_s > 0 else 1.0
+            out[kind] = (scale, (m0 - origin) / 1000)
+        return out
+
+
+def retime_argv(
+    binary: str, src: str, dst: str, timing: "dict[str, tuple[float, float]]"
+) -> "list[str]":
+    """ffmpeg command that copies ``src`` to ``dst`` with each stream moved
+    onto the recording's clock (``PlaybackClock.timing``). An SDES capture's
+    G.711 rides a data stream, which takes the audio timing."""
+
+    def setts(scale: float, start_s: float) -> str:
+        def at(ts: str) -> str:
+            return f"({ts}-START{ts})*{scale:.6f}+{start_s:.6f}/TB"
+
+        return f"setts=pts={at('PTS')}:dts={at('DTS')}"
+
+    argv = [binary, "-hide_banner", "-loglevel", "error", "-nostdin", "-y"]
+    argv += ["-i", src, "-map", "0", "-c", "copy"]
+    if "video" in timing:
+        argv += ["-bsf:v", setts(*timing["video"])]
+    if "audio" in timing:
+        argv += ["-bsf:a", setts(*timing["audio"]), "-bsf:d", setts(*timing["audio"])]
+    return [*argv, "-f", "mpegts", dst]
+
+
 # --- DTLS (A000088): the recording's H265 is taken raw ----------------------
 #
 # aiortc has no H265, and the camera sends a recording it holds as H265 on a

{python_aidot_cameras-1.0.0rc64 → python_aidot_cameras-1.0.0rc65}/aidot_cameras/camera/sdes.py

@@ -63,6 +63,8 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
         abort_chan=None,
         playback_waiter=None,
         playback=None,
+        playback_clock=None,
+        playback_output=None,
     ) -> None:
         # Which camera this session belongs to, for logging only.  Optional so
         # an existing caller that does not pass it still works; the logs then
@@ -135,6 +137,11 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
         # channel), for pause, resume and seek; None for live.
         self._sd_playback = playback
         self._sd_seek_count = 0
+        # SD playback: the recording's own clock as the bridge saw it
+        # (sd_playback.PlaybackClock) and the .ts it was written to, which
+        # stop() moves onto that clock.
+        self._playback_clock = playback_clock
+        self._playback_output = playback_output
         # Shared talk state (dict) for outbound two-way audio, or None when the
         # session was not opened talk-capable (offer stayed recvonly).  Populated
         # by the bridge (camera audio addr) and by async_start_talk (provider).
@@ -254,6 +261,13 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
         """time.monotonic() of the camera's last STUN answer, 0.0 if none yet."""
         return self._ice_progress[0]
 
+    @property
+    def playback_ended(self) -> bool:
+        """True once the camera has marked the end of the recording this
+        session plays (False for live, and before the end)."""
+        clock = self._playback_clock
+        return bool(clock is not None and clock.ended)
+
     def media_stats(self) -> dict:
         """Snapshot of media actually forwarded to ffmpeg by the bridge.
 
@@ -372,6 +386,62 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
         # others are waiting on.
         await asyncio.shield(task)
 
+    async def _retime_playback(self) -> None:
+        """Move a played recording's .ts onto the recording's own clock.
+
+        The camera's RTP clock runs at the live frame rate even for a
+        recording made slower (sd_playback.PlaybackClock), so the file ffmpeg
+        wrote plays fast; the frame-time extension says by how much. Left as
+        written when there is nothing to correct (no frame times, a live
+        session, an output that is not a .ts) or when the copy fails.
+        """
+        clock, path = self._playback_clock, self._playback_output
+        if clock is None or not path or not str(path).endswith(".ts"):
+            return
+        timing = clock.timing()
+        if not timing or all(
+            abs(s - 1.0) < 0.02 and o < 0.05 for s, o in timing.values()
+        ):
+            return
+        import os
+        import subprocess
+
+        from .sd_playback import retime_argv
+
+        tmp = f"{path}.retime.ts"
+        argv = retime_argv("ffmpeg", path, tmp, timing)
+
+        def _run() -> bool:
+            try:
+                done = subprocess.run(argv, capture_output=True, timeout=120)
+            except Exception:
+                return False
+            if done.returncode != 0 or not os.path.exists(tmp):
+                return False
+            os.replace(tmp, path)
+            return True
+
+        try:
+            ok = await asyncio.get_running_loop().run_in_executor(None, _run)
+        except Exception:
+            ok = False
+        if not ok:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            _LOGGER.warning(
+                "camera %s: the played recording could not be put on its own"
+                " clock and plays at the camera's send rate",
+                self._device_id,
+            )
+            return
+        _LOGGER.info(
+            "camera %s: played recording put on its own clock (%s)",
+            self._device_id,
+            ", ".join(f"{k} x{s:.2f} from +{o:.1f}s" for k, (s, o) in timing.items()),
+        )
+
     async def _stop_once(self) -> None:
         if self._talk_state is not None:
             # Ask the bridge to close the camera speaker, then give it a brief
@@ -454,6 +524,7 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
             except Exception:
                 _LOGGER.debug("swallowed exception in %s", "_stop_once", exc_info=True)
         self._log_ffmpeg_stderr(stderr_bytes or self._drained_stderr_tail())
+        await self._retime_playback()
         import os
 
         try:
@@ -465,7 +536,9 @@ class SdesSession(_PlaybackControls, AvioRequestMixin):
                 try:
                     _sock.close()
                 except Exception:
-                    _LOGGER.debug("swallowed exception in %s", "_stop_once", exc_info=True)
+                    _LOGGER.debug(
+                        "swallowed exception in %s", "_stop_once", exc_info=True
+                    )
         self._outgoing_q.put_nowait(None)
         try:
             await asyncio.wait_for(self._mqtt_fut, timeout=_STOP_MQTT_WAIT_S)

{python_aidot_cameras-1.0.0rc64 → python_aidot_cameras-1.0.0rc65}/aidot_cameras/camera/sdes_open.py

@@ -36,6 +36,7 @@ from .constants import (
 )
 from .models import VideoFrame  # noqa: F401 - forward-ref annotation
 from .sdes import SdesSession
+from .sd_playback import EXT_FRAME_TIME, EXT_TRANSPORT_CC
 from .rtsp_publish import (
     redact_url,
     LoopbackRtpPublisher,
@@ -1146,6 +1147,11 @@ class _MediaHold:
         self.dropped = 0
         self.duplicates = 0
         self._seen: "dict" = {}
+        # The recording's own clock, from each packet's frame-time extension
+        # (sd_playback.PlaybackClock); its end mark ends the recording.
+        from .sd_playback import PlaybackClock
+
+        self.clock = PlaybackClock()
 
     def _repeat(self, pkt: bytes, port: int) -> bool:
         """Is ``pkt`` an RTP packet this hold has already passed on?"""
@@ -1172,6 +1178,16 @@ class _MediaHold:
         return self._released and self._held is not None
 
     def send(self, sock, pkt: bytes, port: int, *, pace=None, log=None) -> None:
+        was_ended = self.clock.ended
+        if self.clock.observe(pkt):
+            # After its last frame the camera marks packets as the end of the
+            # recording; there is nothing more of it to serve.
+            if not was_ended and log is not None:
+                try:
+                    log("bridge: the camera marked the end of the recording")
+                except Exception:
+                    pass
+            return
         if self._repeat(pkt, port):
             self.duplicates += 1
             if self.duplicates == 1 and log is not None:
@@ -2100,6 +2116,11 @@ def turn_install_permissions(
     return _perm_ok
 
 
+#: The extmap lines the vendor app's offer filter keeps (OfferUtils.processRtp):
+#: the two a playback offer adds (sd_playback.offer_with_frame_times).
+_KEPT_EXTMAPS = (EXT_TRANSPORT_CC, EXT_FRAME_TIME)
+
+
 def compress_sdp_req(device_id, _sdp: str) -> str:
     """g.b() equivalent - selective SDP filter for wPayload."""
     _out: list = []
@@ -2128,6 +2149,14 @@ def compress_sdp_req(device_id, _sdp: str) -> str:
         if any(_d in _ln for _d in ("sendrecv", "recvonly", "sendonly")):
             _k(_ln)
             continue
+        if _ln.startswith("a=extmap"):
+            # OfferUtils.processRtp keeps these two, once each across the
+            # SDP; firmware that reads wPayload sees no others. A live offer
+            # names neither, so this changes nothing for it.
+            for _uri in _KEPT_EXTMAPS:
+                if _uri in _ln and _seen.get(_uri) is None:
+                    _k(_ln, _uri)
+            continue
         for _ak in (
             "ice-ufrag",
             "ice-pwd",
@@ -6699,6 +6728,13 @@ async def _sdes_open_build_offer(self, ps: _SdesOpenState) -> None:
         )
         if ps._status:
             ps._status(f"SDES: offer pinned to video pt={_pin_video_pt}")
+    if ps.sd_playback is not None:
+        # The per-frame recording time the camera adds once the offer names
+        # transport-cc and rtp-stream-id, as the vendor app's does: its RTP
+        # clock runs at the live frame rate even for a slower recording.
+        from .sd_playback import offer_with_frame_times
+
+        ps.sdes_offer_sdp = offer_with_frame_times(ps.sdes_offer_sdp)
 
     _relay_str = (
         f"  relay-audio={ps._relay_addrs[ps._audio_sock][0]}:{ps._relay_addrs[ps._audio_sock][1]}"
@@ -9854,4 +9890,6 @@ class _SdesOpenMixin:
             # holding the started stream back for it.
             playback_waiter=_sd_start_waiter,
             playback=ps.sd_playback,
+            playback_clock=_media_hold.clock if _media_hold is not None else None,
+            playback_output=output_path if ps.sd_playback is not None else None,
         )

{python_aidot_cameras-1.0.0rc64 → python_aidot_cameras-1.0.0rc65}/pyproject.toml

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

{python_aidot_cameras-1.0.0rc64 → python_aidot_cameras-1.0.0rc65/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -259,6 +259,7 @@ tests/test_sd_event_decode.py
 tests/test_sd_event_probe_payloads.py
 tests/test_sd_listing.py
 tests/test_sd_playback.py
+tests/test_sd_playback_clock.py
 tests/test_sd_playback_controls.py
 tests/test_sd_playback_dtls.py
 tests/test_sd_playback_entry.py

python_aidot_cameras-1.0.0rc65/tests/test_sd_playback_clock.py

@@ -0,0 +1,225 @@
+"""SD playback puts a recording on its own clock.
+
+An A001064 night recording made at 5 fps went out stamped and paced at the
+live 20 fps (2026-10-29): 60 s of video in 15 s, its sound sent in real time
+and cut off when the video ran out. Every packet carries the frame's time in
+the recording in an RTP header extension once the offer names transport-cc
+and rtp-stream-id, as the vendor app's does; the library offers both, keeps
+them through the wPayload filter, reads the time off each packet and moves
+the written file onto it.
+"""
+
+import os
+import shutil
+import subprocess
+
+import pytest
+
+from aidot_cameras.camera.sd_playback import (
+    EXT_FRAME_TIME,
+    EXT_FRAME_TIME_ID,
+    EXT_TRANSPORT_CC,
+    EXT_TRANSPORT_CC_ID,
+    FRAME_TIME_END,
+    PlaybackClock,
+    frame_time_ms,
+    offer_with_frame_times,
+    retime_argv,
+    rtp_extension,
+)
+from aidot_cameras.camera.sdes_open import _MediaHold, compress_sdp_req
+
+T0 = 1_792_988_619_319  # 2026-10-26T04:23:39.319Z, a played night clip
+
+
+def _value(ms, channel=0x14D4):
+    return channel.to_bytes(2, "big") + b"\xf0" + ms.to_bytes(8, "big")
+
+
+def _rtp(pt, seq, ts, ms=None, *, two_byte=False):
+    hdr = bytes([0x80, pt]) + seq.to_bytes(2, "big") + ts.to_bytes(4, "big")
+    hdr += (0x1259).to_bytes(4, "big")
+    if ms is None:
+        return hdr + b"payload"
+    if two_byte:
+        ext = bytes([EXT_TRANSPORT_CC_ID, 2]) + seq.to_bytes(2, "big")
+        ext += bytes([EXT_FRAME_TIME_ID, 11]) + _value(ms)
+        profile = b"\x10\x00"
+    else:
+        ext = bytes([(EXT_TRANSPORT_CC_ID << 4) | 1]) + seq.to_bytes(2, "big")
+        ext += bytes([(EXT_FRAME_TIME_ID << 4) | 10]) + _value(ms)
+        profile = b"\xbe\xde"
+    ext += b"\x00" * (-len(ext) % 4)
+    hdr = bytes([0x90]) + hdr[1:]
+    return hdr + profile + (len(ext) // 4).to_bytes(2, "big") + ext + b"payload"
+
+
+def test_the_frame_time_is_read_in_either_extension_form():
+    for two in (False, True):
+        pkt = _rtp(97, 7, 1000, T0, two_byte=two)
+        assert frame_time_ms(rtp_extension(pkt, EXT_FRAME_TIME_ID)) == T0
+        assert rtp_extension(pkt, EXT_TRANSPORT_CC_ID) == (7).to_bytes(2, "big")
+    assert rtp_extension(_rtp(97, 7, 1000), EXT_FRAME_TIME_ID) is None
+    assert frame_time_ms(None) is None
+    assert frame_time_ms(b"short") is None
+
+
+def test_a_night_clip_is_stretched_to_the_recording_and_its_sound_placed():
+    # Measured: 200 ms of recording per frame, 50 ms of RTP (4500 ticks);
+    # the sound starts 6 s into the clip and runs in real time.
+    clock = PlaybackClock()
+    for i in range(301):
+        clock.observe(_rtp(97, i, 1000 + i * 4500, T0 + i * 200))
+    for i in range(200):
+        clock.observe(_rtp(8, i, 50 + i * 512, T0 + 6002 + i * 64))
+    timing = clock.timing()
+    assert timing["video"] == (pytest.approx(4.0), 0.0)
+    assert timing["audio"] == (pytest.approx(1.0), pytest.approx(6.002))
+    assert not clock.ended
+    assert clock.observe(_rtp(97, 999, 0, FRAME_TIME_END)) is True
+    assert clock.ended
+
+
+def test_no_frame_times_means_nothing_to_correct():
+    clock = PlaybackClock()
+    clock.observe(_rtp(97, 1, 1000))
+    assert clock.timing() == {}
+
+
+def test_the_playback_offer_names_both_extensions_in_each_media_section():
+    sdp = (
+        "v=0\r\nm=audio 9 RTP/SAVPF 8\r\na=mid:0\r\na=rtpmap:8 PCMA/8000\r\n"
+        "m=video 9 RTP/SAVPF 96 97\r\na=mid:1\r\n"
+        "m=application 9 SCTP webrtc-datachannel\r\na=mid:2\r\n"
+    )
+    out = offer_with_frame_times(sdp)
+    for mid in ("a=mid:0", "a=mid:1"):
+        after = out.split(mid + "\r\n")[1]
+        assert after.startswith(
+            f"a=extmap:{EXT_TRANSPORT_CC_ID} {EXT_TRANSPORT_CC}\r\n"
+            f"a=extmap:{EXT_FRAME_TIME_ID} {EXT_FRAME_TIME}\r\n"
+        )
+    assert "a=rtcp-fb:97 transport-cc" in out
+    assert out.split("a=mid:2")[1].count("extmap") == 0
+
+
+def test_the_wpayload_filter_keeps_the_two_extmaps_once_as_the_app_does():
+    sdp = offer_with_frame_times(
+        "v=0\r\ns=-\r\nm=audio 9 RTP/SAVPF 8\r\na=mid:0\r\na=rtpmap:8 PCMA/8000\r\n"
+        "a=extmap:9 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n"
+        "m=video 9 RTP/SAVPF 97\r\na=mid:1\r\na=rtpmap:97 H265/90000\r\n"
+    )
+    out = compress_sdp_req("dev", sdp)
+    assert out.count(EXT_TRANSPORT_CC) == 1 and out.count(EXT_FRAME_TIME) == 1
+    assert "ssrc-audio-level" not in out
+    # A live offer names neither, and comes out as it always did.
+    assert "extmap" not in compress_sdp_req("dev", sdp.replace("a=extmap", "a=x"))
+
+
+class _Sock:
+    def __init__(self):
+        self.sent = []
+
+    def sendto(self, pkt, addr):
+        self.sent.append(pkt)
+
+
+def test_the_hold_reads_the_clock_and_forwards_nothing_after_the_end():
+    sock, lines = _Sock(), []
+    hold = _MediaHold()
+    hold.release()
+    hold.send(sock, _rtp(97, 1, 1000, T0), 5000, log=lines.append)
+    hold.send(sock, _rtp(97, 2, 5500, T0 + 200), 5000, log=lines.append)
+    for seq in (3, 4):
+        hold.send(sock, _rtp(97, seq, 0, FRAME_TIME_END), 5000, log=lines.append)
+    assert len(sock.sent) == 2
+    assert hold.clock.ended
+    assert lines.count("bridge: the camera marked the end of the recording") == 1
+
+
+def test_a_playback_serve_keeps_the_camera_s_timestamps():
+    from aidot_cameras.camera import client
+
+    def argv(**kw):
+        return client._build_sdes_serve_cmd(
+            sdp_path="in.sdp", output_path="out.ts", **kw
+        )
+
+    if not client._SERVE_ARRIVAL_TS:
+        pytest.skip("arrival stamping is off in this environment")
+    assert "-use_wallclock_as_timestamps" in argv()
+    assert "-use_wallclock_as_timestamps" not in argv(keep_probe_packets=True)
+
+
+@pytest.mark.skipif(shutil.which("ffmpeg") is None, reason="needs ffmpeg")
+def test_the_retime_command_stretches_video_and_places_the_data_stream(tmp_path):
+    src, dst = tmp_path / "in.ts", tmp_path / "out.ts"
+    subprocess.run(
+        [
+            "ffmpeg",
+            "-loglevel",
+            "error",
+            "-y",
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc=size=64x64:rate=20:duration=3",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:sample_rate=8000:duration=3",
+            "-c:v",
+            "libx264",
+            "-c:a",
+            "pcm_alaw",
+            "-f",
+            "mpegts",
+            str(src),
+        ],
+        check=True,
+    )
+    timing = {"video": (4.0, 0.0), "audio": (1.0, 2.0)}
+    subprocess.run(retime_argv("ffmpeg", str(src), str(dst), timing), check=True)
+    out = subprocess.run(
+        [
+            "ffprobe",
+            "-v",
+            "error",
+            "-show_entries",
+            "stream=codec_type,start_time,duration",
+            "-of",
+            "csv=p=0",
+            str(dst),
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout.split()
+    rows = {r.split(",")[0]: [float(x) for x in r.split(",")[1:]] for r in out}
+    assert rows["video"][1] == pytest.approx(12.0, abs=0.3)  # 3 s x4
+    # MPEG-TS has no type for A-law: like an SDES capture, it is a data stream.
+    sound = rows.get("audio") or rows["data"]
+    assert sound[0] - rows["video"][0] == pytest.approx(2.0, abs=0.1)
+    assert os.path.getsize(dst) > 0
+
+
+def test_a_stray_second_video_type_does_not_decide_the_timing():
+    clock = PlaybackClock()
+    for i in range(50):
+        clock.observe(_rtp(97, i, 1000 + i * 4500, T0 + i * 200))
+    for i in range(3):  # a few packets of another type, its own pace
+        clock.observe(_rtp(96, i, 5000 + i * 90000, T0 + i * 1000))
+    assert clock.timing()["video"][0] == pytest.approx(4.0)
+
+
+def test_the_offer_finds_sections_by_media_type_not_by_mid():
+    sdp = (
+        "v=0\r\nm=video 9 RTP/SAVPF 97\r\na=mid:20\r\n"
+        "m=audio 9 RTP/SAVPF 8\r\na=mid:video\r\n"
+        "m=application 9 SCTP webrtc-datachannel\r\na=mid:1\r\n"
+    )
+    out = offer_with_frame_times(sdp)
+    assert out.count(f"a=extmap:{EXT_FRAME_TIME_ID}") == 2
+    assert "a=rtcp-fb:97 transport-cc" in out
+    assert "a=rtcp-fb:8 transport-cc" not in out
+    assert out.split("m=application")[1].count("extmap") == 0