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

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

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

@@ -2792,6 +2792,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.0rc64}/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,30 @@ 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,
+    )
+
+
 # --- 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 +468,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 +495,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.0rc64}/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
@@ -1109,9 +1110,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 +1129,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 +1144,26 @@ class _MediaHold:
         self._released = False
         self._limit = limit or _MEDIA_HOLD_MAX
         self.dropped = 0
+        self.duplicates = 0
+        self._seen: "dict" = {}
+
+    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 +1172,14 @@ class _MediaHold:
         return self._released and self._held is not None
 
     def send(self, sock, pkt: bytes, port: int, *, pace=None, log=None) -> None:
+        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 +1195,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:

{python_aidot_cameras-1.0.0rc63 → python_aidot_cameras-1.0.0rc64}/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.0rc64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "1.0.0rc63"
+version = "1.0.0rc64"
 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.0rc64/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.0rc64
 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.0rc64}/tests/test_sd_playback_dtls.py

@@ -415,3 +415,42 @@ def test_the_sd_mode_echo_has_one_parser():
         == _session_mode_echoed(avio_header(1, 5377, 0, 12, 0) + body)
     )
     assert session_mode_of(b"\x00" * 8) is None
+
+
+def test_a_lost_head_drops_the_new_unit_not_the_one_already_emitted():
+    aus = _hevc_access_units(5)
+    units = H265AccessUnits()
+    got, seq = [], 300
+    for i, au in enumerate(aus):
+        pkts = _packetize(au, i * 6000, seq, mtu=200)
+        seq += len(pkts)
+        for j, p in enumerate(pkts):
+            if i == 1 and j == 0:
+                continue  # unit 1 loses its first packet, after 0's marker
+            got += units.feed(*p)
+    assert units.dropped == 1
+    assert [ts for _, ts, _ in got] == [0, 12000, 18000, 24000]
+
+
+def test_a_gap_wider_than_the_lost_marker_drops_both_units():
+    aus = _hevc_access_units(5)
+    units = H265AccessUnits()
+    got, seq = [], 900
+    for i, au in enumerate(aus):
+        pkts = _packetize(au, i * 6000, seq, mtu=200)
+        seq += len(pkts)
+        for j, p in enumerate(pkts):
+            if (i == 0 and j == len(pkts) - 1) or (i == 1 and j == 0):
+                continue  # 0's marker and 1's head, back to back
+            got += units.feed(*p)
+    assert units.dropped == 2
+    assert [ts for _, ts, _ in got] == [12000, 18000, 24000]
+
+
+def test_a_truncated_aggregation_packet_breaks_its_unit():
+    units = H265AccessUnits()
+    vps = bytes([32 << 1, 1, 0x0C])
+    ap = bytes([48 << 1, 1]) + struct.pack("!H", 3) + vps + struct.pack("!H", 1200)
+    ap += bytes([19 << 1, 1]) + b"\x00" * 298
+    assert units.feed(1, 0, True, ap) == []
+    assert units.dropped == 1

{python_aidot_cameras-1.0.0rc63 → python_aidot_cameras-1.0.0rc64}/tests/test_sd_playback_entry.py

@@ -31,7 +31,7 @@ class _Task:
 
 
 class _Camera(_CameraSdPlaybackMixin):
-    device_id = "12b144cb12da"
+    device_id = "0123456789ab"
     generate_webrtc_peer_id = staticmethod(CameraMixin.generate_webrtc_peer_id)
 
     def __init__(self, sdes=True, live=False, streaming=False):
@@ -110,3 +110,47 @@ def test_every_camera_client_has_it():
     assert CameraMixin.async_open_sd_playback is (
         _CameraSdPlaybackMixin.async_open_sd_playback
     )
+
+
+def test_the_dtls_fallback_keeps_the_playback_peer_id_and_its_options():
+    # An SDES-flagged camera that answers only DTLS: the retry must still
+    # ask for the recording (class 0, SD card), not open a live view.
+    from aidot_cameras.camera.webrtc_open import _dtls_open_sdes_branch
+
+    class _Fut:
+        def done(self):
+            return False
+
+    class _Ps:
+        use_sdes = True
+        terminal_error_fut = _Fut()
+        ice_config_fut = _Fut()
+        mqtt_fut = None
+        output_path = "clip.part.ts"
+        max_seconds = 70.0
+        rtsp_push_url = "rtsp://127.0.0.1:1/x"
+        _sd_playback = SdPlaybackStart(request=b"", record=REC)
+
+        def _status(self, _msg):
+            pass
+
+        def __getattr__(self, _name):
+            return None
+
+    class _Cam(_Camera):
+        async def _open_sdes_stream(self, **_kw):
+            raise CameraMixin._SdesNoAnswerError()
+
+        async def _async_open_webrtc_stream_impl(self, on_frame, **kw):
+            self.opens.append((on_frame, kw))
+            return "dtls"
+
+    cam = _Cam()
+    got = asyncio.run(_dtls_open_sdes_branch(cam, _Ps()))
+    assert got.value == "dtls"
+    ((_, kw),) = cam.opens
+    assert kw["force_sdes"] is False
+    assert PEER.match(kw["reuse_peer_id"]).groups()[:3] == ("0", "1", "0")
+    assert kw["max_seconds"] == 70.0
+    # Carried so the DTLS open refuses it rather than dropping it.
+    assert kw["rtsp_push_url"] == "rtsp://127.0.0.1:1/x"

{python_aidot_cameras-1.0.0rc63 → python_aidot_cameras-1.0.0rc64}/tests/test_sd_playback_media_hold.py

@@ -68,7 +68,7 @@ def test_the_flush_is_paced_and_reported():
     assert lines == ["bridge: released 40 held packet(s) to the serve"]
 
 
-def test_the_hold_is_bounded():
+def test_the_hold_is_bounded(caplog):
     sent = []
     hold = _MediaHold(limit=3)
     for i in range(5):
@@ -77,6 +77,11 @@ def test_the_hold_is_bounded():
     hold.release()
     assert hold.flush() == 3
     assert _MEDIA_HOLD_MAX >= 1000
+    # The hole it leaves is not a debug line only.
+    assert any(
+        r.levelname == "WARNING" and "2 packet(s)" in r.getMessage()
+        for r in caplog.records
+    )
 
 
 def test_every_loopback_send_in_the_bridge_goes_through_the_hold():
@@ -138,3 +143,63 @@ def calls_to_serve_cmd():
     return calls_to(
         module_tree("aidot_cameras.camera.sdes_open"), "_build_sdes_serve_cmd"
     )
+
+
+def _rtp(seq, ssrc=0x1257, pt=8):
+    return (
+        bytes([0x80, pt])
+        + seq.to_bytes(2, "big")
+        + bytes(4)
+        + ssrc.to_bytes(4, "big")
+        + b"x"
+    )
+
+
+def test_a_packet_that_arrives_twice_is_forwarded_once():
+    # The reference box, 2026-10-28: every audio packet came twice (two
+    # routes to the camera), and the copied G.711 ran twice as long as the
+    # picture.
+    sent, lines = [], []
+    hold = _MediaHold()
+    hold.release()
+    for seq in (1, 1, 2, 3, 2, 3, 4):
+        hold.send(_Sock(sent), _rtp(seq), 5000, log=lines.append)
+    assert [int.from_bytes(p[2:4], "big") for p, _ in sent] == [1, 2, 3, 4]
+    assert hold.duplicates == 3
+    assert lines.count("bridge: dropping RTP packets that arrive twice") == 1
+
+
+def test_only_the_same_stream_and_port_count_as_a_repeat():
+    sent = []
+    hold = _MediaHold()
+    hold.release()
+    hold.send(_Sock(sent), _rtp(7), 5000)
+    hold.send(_Sock(sent), _rtp(7, ssrc=0x1259, pt=97), 5000)  # other SSRC
+    hold.send(_Sock(sent), _rtp(7), 5002)  # other port
+    rtcp = bytes([0x80, 200]) + bytes(10)
+    hold.send(_Sock(sent), rtcp, 5000)
+    hold.send(_Sock(sent), rtcp, 5000)  # RTCP is never deduplicated
+    assert len(sent) == 5 and hold.duplicates == 0
+
+
+def test_a_repeat_while_held_is_dropped_too():
+    sent = []
+    hold = _MediaHold()
+    for seq in (10, 10, 11):
+        hold.send(_Sock(sent), _rtp(seq), 5000)
+    hold.release()
+    hold.flush()
+    assert len(sent) == 2 and hold.duplicates == 1
+
+
+def test_the_window_forgets_old_numbers_so_a_wrapped_sequence_plays():
+    from aidot_cameras.camera.sdes_open import _DUPLICATE_WINDOW
+
+    sent = []
+    hold = _MediaHold()
+    hold.release()
+    n = 65536 + 10  # past a full wrap of the 16-bit sequence number
+    for i in range(n):
+        hold.send(_Sock(sent), _rtp(i & 0xFFFF), 5000)
+    assert len(sent) == n and hold.duplicates == 0
+    assert _DUPLICATE_WINDOW < 65536 // 4