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

{python_aidot_cameras-1.0.0rc63/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.0rc63
+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.0rc63 → 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
@@ -2792,6 +2796,12 @@ class CameraMixin(
         Taken from the SDES bridge thread (SESSION_MODE, control commands) as
         well as the event loop (livePlayReq), so read-and-increment is one
         locked step: a repeated seq is a SESSION_MODE the camera ignores.
+
+        Starting again at 100 in every new client is safe: the camera keeps
+        the last accepted seq per session, not per camera. Back-to-back
+        playbacks from fresh clients, each counting from 100 where the one
+        before had already gone past it, had SD mode echoed every time on all
+        three models (2026-10-27), as the app's own restarts rely on.
         """
         with _DSEQ_LOCK:
             d = self._live_dseq

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

@@ -274,16 +274,6 @@ class _CameraSdPlaybackMixin:
             record=record,
             sd_channel=sd_channel,
         )
-        peer_id = self.generate_webrtc_peer_id(
-            live_type=PLAY_CMD_SDCARD,
-            # Field 4, a literal 0 in the app - not the StreamID, which is
-            # field 5 (``stream``).
-            stream_id=0,
-            sdes=bool(self.is_sdes_camera),
-            device_id=self.device_id,
-            client_class=PLAYBACK_CLIENT_CLASS,
-            stream=PLAYBACK_STREAM,
-        )
         return await self.async_open_webrtc_stream(
             on_frame,
             timeout=timeout,
@@ -291,11 +281,199 @@ class _CameraSdPlaybackMixin:
             max_seconds=max_seconds,
             status_callback=status_callback,
             rtsp_push_url=rtsp_push_url,
-            reuse_peer_id=peer_id,
+            reuse_peer_id=playback_peer_id(self, sdes=bool(self.is_sdes_camera)),
             _sd_playback=start,
         )
 
 
+def playback_peer_id(camera: Any, *, sdes: bool) -> str:
+    """The peer id a playback open announces, for the SDES or DTLS transport.
+
+    The SDES-to-DTLS fallback builds a fresh one with ``sdes=False``: the
+    SDES id's transport digit is wrong for DTLS, and a live id (class 2,
+    PRE_LINK) would get audio alone from an H265-recording camera.
+    """
+    return camera.generate_webrtc_peer_id(
+        live_type=PLAY_CMD_SDCARD,
+        # Field 4, a literal 0 in the app - not the StreamID, which is
+        # field 5 (``stream``).
+        stream_id=0,
+        sdes=sdes,
+        device_id=camera.device_id,
+        client_class=PLAYBACK_CLIENT_CLASS,
+        stream=PLAYBACK_STREAM,
+    )
+
+
+# --- 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
@@ -459,13 +637,21 @@ class H265AccessUnits:
         self, seq: int, ts: int, marker: bool, payload: bytes
     ) -> "list[tuple[bytes, int, bool]]":
         out = []
-        gap = self._last_seq is not None and (seq - self._last_seq) & 0xFFFF != 1
+        missing = 0
+        if self._last_seq is not None:
+            missing = (seq - self._last_seq - 1) & 0xFFFF
+        gap = missing != 0
         if self._ts is not None and ts != self._ts:
-            # What went missing before this packet was the end of the unit
-            # in hand (or whole units between): that unit is the damaged one.
-            if gap:
+            # A unit in hand that never saw its marker lost at least its last
+            # packet; one already emitted at its marker lost nothing. Whatever
+            # else went missing is the head of this new unit (its VPS/SPS, or
+            # the first slice of a keyframe), so it is not handed on either.
+            pending = bool(self._nals) or self._fu is not None
+            if gap and pending:
                 self._broken = True
             out += self._emit()
+            if missing > (1 if pending else 0):
+                self._broken = True
         elif gap:
             self._broken = True
             self._fu = None
@@ -478,6 +664,9 @@ class H265AccessUnits:
                 i = 2
                 while i + 2 <= len(payload):
                     n = struct.unpack_from("!H", payload, i)[0]
+                    if n == 0 or i + 2 + n > len(payload):
+                        self._broken = True  # truncated or corrupt
+                        break
                     self._nals.append(bytes(payload[i + 2 : i + 2 + n]))
                     i += 2 + n
             elif t == 49 and len(payload) >= 3:  # fragmentation unit

{python_aidot_cameras-1.0.0rc63 → 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.0rc63 → python_aidot_cameras-1.0.0rc65}/aidot_cameras/camera/sdes_open.py

@@ -8,6 +8,7 @@ breaks the client<->sdes_open cycle).  CameraMixin inherits this mixin, so
 """
 
 import asyncio
+import collections
 import functools
 import hashlib as _hashlib_mod
 import logging
@@ -35,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,
@@ -1109,9 +1111,18 @@ def _session_mode_echoed(frame: bytes) -> "Optional[int]":
 
 #: How many packets a playback open holds for its serve (see _new_media_hold).
 #: The serve is up within a second; ~70 packets/s on an A001064 recording.
+#: The hold is released once the serve binds or 4.5 s after it is launched
+#: (the bind wait and its fallback), so the cap is several times what one
+#: open can hold; a drop past it is logged as a warning, since the served
+#: clip then has a hole after its opening.
 _MEDIA_HOLD_MAX = 4000
 
 
+#: How many recent sequence numbers per stream a playback remembers, to drop
+#: a packet that arrives twice. A few seconds of video at 2560x1440.
+_DUPLICATE_WINDOW = 2048
+
+
 class _MediaHold:
     """Packets for the serve, held in order until it is listening.
 
@@ -1119,6 +1130,14 @@ class _MediaHold:
     loopback port; ``release`` by the open once the serve is bound. The first
     ``send`` (or ``flush``) after the release hands over everything held -
     still on the bridge thread, so nothing can overtake it.
+
+    It also drops an RTP packet already forwarded (same port, SSRC and
+    sequence number). On a host that reaches the camera by two routes every
+    packet can arrive twice: measured on the reference box 2026-10-28, each
+    playback audio packet came twice and video packets up to six times. ffmpeg
+    discards a repeated video packet, but the G.711 is copied as data, so
+    every repeat was written too and the clip's sound ran twice as long as its
+    picture.
     """
 
     def __init__(self, limit: int = 0) -> None:
@@ -1126,6 +1145,31 @@ class _MediaHold:
         self._released = False
         self._limit = limit or _MEDIA_HOLD_MAX
         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?"""
+        if len(pkt) < 12 or pkt[0] >> 6 != 2 or 192 <= pkt[1] <= 223:
+            return False  # not RTP, or RTCP (payload types 192-223)
+        ssrc = int.from_bytes(pkt[8:12], "big")
+        seq = int.from_bytes(pkt[2:4], "big")
+        seen = self._seen.get((port, ssrc))
+        if seen is None:
+            seen = self._seen[(port, ssrc)] = (set(), collections.deque())
+        recent, order = seen
+        if seq in recent:
+            return True
+        recent.add(seq)
+        order.append(seq)
+        if len(order) > _DUPLICATE_WINDOW:
+            recent.discard(order.popleft())
+        return False
 
     def release(self) -> None:
         self._released = True
@@ -1134,6 +1178,24 @@ 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:
+                try:
+                    log("bridge: dropping RTP packets that arrive twice")
+                except Exception:
+                    pass
+            return
         if self._held is not None:
             if not self._released:
                 if len(self._held) < self._limit:
@@ -1149,6 +1211,14 @@ class _MediaHold:
         first keyframe alone is ~130 packets and one burst of all of them can
         overrun the serve's socket. Returns how many were sent."""
         held, self._held = self._held or [], None
+        if self.dropped:
+            _LOGGER.warning(
+                "SD playback: %d packet(s) over the %d-packet hold were"
+                " dropped before the serve listened; the clip has a gap"
+                " after its opening",
+                self.dropped,
+                self._limit,
+            )
         sent = 0
         for i, (sock, pkt, port) in enumerate(held):
             try:
@@ -2046,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 = []
@@ -2074,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",
@@ -6645,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]}"
@@ -9800,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.0rc63 → python_aidot_cameras-1.0.0rc65}/aidot_cameras/camera/webrtc_open.py

@@ -2458,6 +2458,18 @@ async def _dtls_open_sdes_branch(self, ps: _DtlsOpenState) -> _PhaseReturn | Non
                 await asyncio.wait_for(ps.mqtt_fut, timeout=5.0)
             except Exception:
                 pass  # MQTT thread exit errors don't affect the retry
+            # A playback keeps what it asked for across the fallback: its own
+            # peer id rebuilt for DTLS (the live default is class 2 and
+            # PRE_LINK, which an H265-recording camera sends audio alone),
+            # and rtsp_push_url, so the DTLS open refuses what it cannot
+            # serve instead of dropping it. A live open mints a fresh id.
+            _fallback_peer_id = None
+            _fallback_push_url = None
+            if ps._sd_playback is not None:
+                from .sd_playback import playback_peer_id
+
+                _fallback_peer_id = playback_peer_id(self, sdes=False)
+                _fallback_push_url = ps.rtsp_push_url
             # Call the UNGATED impl, not the public async_open_webrtc_stream:
             # we are already holding the global open-gate permit (acquired in
             # async_open_webrtc_stream), and the gate's semaphore is not
@@ -2472,8 +2484,11 @@ async def _dtls_open_sdes_branch(self, ps: _DtlsOpenState) -> _PhaseReturn | Non
                     stream_id=ps.stream_id,
                     timeout=ps.timeout,
                     output_path=ps.output_path,
+                    max_seconds=ps.max_seconds,
                     status_callback=ps.status_callback,
                     force_sdes=False,
+                    rtsp_push_url=_fallback_push_url,
+                    reuse_peer_id=_fallback_peer_id,
                     _skip_ice_config=True,
                     _ice_config=(
                         ps.ice_config_fut.result() if ps.ice_config_fut.done() else None

{python_aidot_cameras-1.0.0rc63 → 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.0rc63"
+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.0rc63 → 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.0rc63
+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.0rc63 → 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