python-aidot-cameras 1.0.0rc66__tar.gz → 1.0.0rc67__tar.gz

{python_aidot_cameras-1.0.0rc66/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0rc67}/PKG-INFO

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

@@ -68,6 +68,9 @@ class TsCopyRecorder:
         self._thread: Optional[threading.Thread] = None
         self._state: dict = {}
         self._stopped = False
+        # Called first thing in stop(), for whoever still holds packets for
+        # this recording (the SD playback tap's reorder buffer).
+        self.on_stop: "list" = []
         # Opened before the session connects, so an unwritable path fails
         # while there is nothing to clean up: by the caller in an executor
         # (``file``; an open() on an event loop blocks it), or here. Held open
@@ -96,6 +99,11 @@ class TsCopyRecorder:
         if self._stopped:
             return
         self._stopped = True
+        for _cb in self.on_stop:
+            try:
+                _cb()
+            except Exception:
+                _LOGGER.debug("recording stop callback failed", exc_info=True)
         if self._thread is None:
             self._close()
             return

{python_aidot_cameras-1.0.0rc66 → python_aidot_cameras-1.0.0rc67}/aidot_cameras/camera/sd_playback.py

@@ -597,6 +597,59 @@ def answer_h265_parameter_sets(sdp: str, pt: Optional[int]) -> "list[bytes]":
     return out
 
 
+class SeqReorder:
+    """Puts one RTP stream back in sequence order, waiting a little for gaps.
+
+    A packet the camera resends after a NACK arrives after the ones that
+    followed it; the access-unit assembler takes packets in order, so they
+    are held here until the gap fills or ``max_wait_s`` passes, then handed
+    on in order (a gap given up on reaches the assembler as a gap, and its
+    unit is handed on damaged). ``push`` returns what is ready; ``flush``
+    returns the rest at the end.
+    """
+
+    #: Most packets held; past this the oldest gap is given up at once.
+    MAX_HELD = 1500
+
+    def __init__(self, max_wait_s: float = 0.3) -> None:
+        self.max_wait_s = max_wait_s
+        self._next: "Optional[int]" = None
+        self._held: "dict[int, tuple[float, Any]]" = {}
+        self.late = 0  # arrived after its gap was given up
+
+    def push(self, seq: int, item: Any, now: float) -> "list":
+        if self._next is None:
+            self._next = seq
+        if (seq - self._next) & 0x8000:  # before the next expected one
+            self.late += 1
+            return []
+        self._held.setdefault(seq, (now, item))
+        return self._release(now)
+
+    def _release(self, now: float) -> "list":
+        out = []
+        while True:
+            while self._next in self._held:
+                out.append(self._held.pop(self._next)[1])
+                self._next = (self._next + 1) & 0xFFFF
+            if not self._held:
+                return out
+            oldest = min(t for t, _ in self._held.values())
+            if now - oldest < self.max_wait_s and len(self._held) < self.MAX_HELD:
+                return out
+            # Give up on the gap: carry on from the earliest packet held.
+            self._next = min(self._held, key=lambda s: (s - self._next) & 0xFFFF)
+
+    def flush(self) -> "list":
+        out = []
+        while self._held:
+            if self._next not in self._held:
+                self._next = min(self._held, key=lambda s: (s - self._next) & 0xFFFF)
+            out.append(self._held.pop(self._next)[1])
+            self._next = (self._next + 1) & 0xFFFF
+        return out
+
+
 class H265AccessUnits:
     """RTP payloads (RFC 7798) in, Annex B access units out.
 
@@ -627,6 +680,12 @@ class H265AccessUnits:
         self._broken = False
         self.dropped = 0
         self.damaged = 0
+        # The camera sends a recording's last frame twice, under a new
+        # timestamp (A000088, 2026-10-30): a decoder then sees the same picture
+        # order count twice. A unit identical to the one before is not handed
+        # on (``repeats`` counts them).
+        self.repeats = 0
+        self._last_unit: "Optional[bytes]" = None
 
     def _emit(self) -> "list[tuple[bytes, int, bool]]":
         out = []
@@ -641,9 +700,14 @@ class H265AccessUnits:
             nals = self._nals
             if kf and 32 not in types and self.parameter_sets:
                 nals = self.parameter_sets + nals
-            out.append((b"".join(_NAL_SC + n for n in nals), self._ts, kf))
-            if self._broken:
-                self.damaged += 1
+            unit = b"".join(_NAL_SC + n for n in nals)
+            if unit == self._last_unit:
+                self.repeats += 1
+            else:
+                out.append((unit, self._ts, kf))
+                self._last_unit = unit
+                if self._broken:
+                    self.damaged += 1
         elif self._nals or self._broken:
             self.dropped += 1
         self._nals, self._fu, self._broken = [], None, False

{python_aidot_cameras-1.0.0rc66 → python_aidot_cameras-1.0.0rc67}/aidot_cameras/camera/webrtc_open.py

@@ -295,7 +295,8 @@ def _install_sd_h265_tap(pc, h265, status) -> int:
     PCMU by number, but its answer's audio was PCMA alone, so nothing else
     claims it. Returns the routers tapped.
     """
-    from .sd_playback import starts_h265_stream
+    from .._vendor.aiortc.rtcrtpreceiver import NackGenerator
+    from .sd_playback import SeqReorder, starts_h265_stream
 
     if h265 is None:
         return 0
@@ -308,17 +309,21 @@ def _install_sd_h265_tap(pc, h265, status) -> int:
             routers.append(router)
 
     def _make(router):
-        def _tap(packet) -> None:
-            pt = h265["pt"]
-            if pt is None:
-                if packet.payload_type in router.payload_type_table or not (
-                    starts_h265_stream(packet.payload)
-                ):
-                    return
-                h265["pt"] = pt = packet.payload_type
-                status(f"SD playback: taking pt={pt} as the recording's H265")
-            if packet.payload_type != pt:
-                return
+        # A video receiver on this transport sends the NACKs: aiortc only
+        # asks for resends on streams it routes, and this one it does not.
+        rx = None
+        for t in pc.getTransceivers():
+            r = t.receiver
+            if getattr(getattr(r, "transport", None), "_rtp_router", None) is router:
+                if rx is None or getattr(t, "kind", None) == "video":
+                    rx = r
+        reorder = SeqReorder()
+        nack_gen = NackGenerator()
+        # The loop holds tasks weakly: a NACK not referenced here can be
+        # collected before it is sent.
+        nack_tasks: "set" = set()
+
+        def _feed(packet) -> None:
             units = h265["units"]
             lost_before = units.dropped
             damaged_before = units.damaged
@@ -342,6 +347,43 @@ def _install_sd_h265_tap(pc, h265, status) -> int:
                     " damaged (the decoder conceals it)"
                 )
 
+        def _flush() -> None:
+            for held in reorder.flush():
+                _feed(held)
+
+        on_stop = getattr(h265["recorder"], "on_stop", None)
+        if on_stop is not None:
+            on_stop.append(_flush)
+
+        def _tap(packet) -> None:
+            pt = h265["pt"]
+            if pt is None:
+                if packet.payload_type in router.payload_type_table or not (
+                    starts_h265_stream(packet.payload)
+                ):
+                    return
+                h265["pt"] = pt = packet.payload_type
+                status(f"SD playback: taking pt={pt} as the recording's H265")
+            if packet.payload_type != pt:
+                return
+            # Ask for what never arrived; the resend is put back in place
+            # by the reorder buffer before the assembler sees it.
+            if nack_gen.add(packet) and rx is not None and nack_gen.missing:
+                h265["nacks"] = h265.get("nacks", 0) + 1
+                if h265["nacks"] == 1:
+                    status("SD playback: asking the camera to resend lost H265 (NACK)")
+                try:
+                    task = asyncio.get_running_loop().create_task(
+                        rx._send_rtcp_nack(packet.ssrc, sorted(nack_gen.missing))
+                    )
+                except RuntimeError:
+                    pass  # no loop: nothing to send on
+                else:
+                    nack_tasks.add(task)
+                    task.add_done_callback(nack_tasks.discard)
+            for ready in reorder.push(packet.sequence_number, packet, time.monotonic()):
+                _feed(ready)
+
         return _tap
 
     for router in routers:

{python_aidot_cameras-1.0.0rc66 → python_aidot_cameras-1.0.0rc67}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0rc66
+Version: 1.0.0rc67
 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.0rc66 → python_aidot_cameras-1.0.0rc67}/tests/test_sd_playback_dtls.py

@@ -474,3 +474,104 @@ def test_by_default_a_damaged_unit_is_handed_on_and_counted():
     assert units.damaged == 1 and units.dropped == 0
     assert got[0][2] is True  # still marked a keyframe
     assert got[1:] and [_nals(d) for d, _, _ in got[1:]] == [_nals(a) for a in aus[1:]]
+
+
+def test_a_unit_sent_twice_is_handed_on_once():
+    # The A000088 sent a recording's last frame twice under a new timestamp
+    # (2026-10-30); the decoder then reported a duplicate picture order count.
+    aus = _hevc_access_units(3)
+    units = H265AccessUnits()
+    got, seq = [], 10
+    for i, au in enumerate([*aus, aus[-1]]):
+        pkts = _packetize(au, i * 6000, seq)
+        seq += len(pkts)
+        for p in pkts:
+            got += units.feed(*p)
+    assert [ts for _, ts, _ in got] == [0, 6000, 12000]
+    assert units.repeats == 1
+
+
+def test_a_resent_packet_is_put_back_in_place():
+    from aidot_cameras.camera.sd_playback import SeqReorder
+
+    r = SeqReorder(max_wait_s=0.3)
+    assert r.push(10, "a", 0.0) == ["a"]
+    assert r.push(12, "c", 0.01) == []  # 11 missing: hold 12
+    assert r.push(13, "d", 0.02) == []
+    assert r.push(11, "b", 0.1) == ["b", "c", "d"]  # the resend fills it
+
+
+def test_a_gap_that_never_fills_is_given_up_in_time():
+    from aidot_cameras.camera.sd_playback import SeqReorder
+
+    r = SeqReorder(max_wait_s=0.3)
+    r.push(65534, "a", 0.0)
+    assert r.push(1, "d", 0.01) == []  # 65535 and 0 missing, across the wrap
+    assert r.push(2, "e", 0.35) == ["d", "e"]  # past the wait: carry on
+    assert r.push(0, "late", 0.4) == [] and r.late == 1
+    r.push(5, "h", 0.5)
+    assert r.flush() == ["h"]
+
+
+def test_the_tap_asks_for_a_lost_packet_and_puts_the_resend_in_place():
+    # The A000088 resends what a NACK names (2026-10-30: three plays, no
+    # frame damaged or dropped, 0 decode errors, against 147 error lines
+    # from one dropped frame before). aiortc does not NACK this stream, as it
+    # does not route it; the tap asks, and holds packets until the resend.
+    import asyncio
+
+    from aidot_cameras.camera.webrtc_open import _install_sd_h265_tap
+
+    sent = []
+
+    class _Rx:
+        def __init__(self, router):
+            self.transport = type("T", (), {"_rtp_router": router})()
+
+        async def _send_rtcp_nack(self, ssrc, lost):
+            sent.append((ssrc, list(lost)))
+
+    class _PcNack:
+        def __init__(self, router):
+            self._t = [type("Tr", (), {"receiver": _Rx(router), "kind": "video"})()]
+
+        def getTransceivers(self):
+            return self._t
+
+    def _p(seq, ts, marker, payload):
+        p = _pkt(98, seq, ts, marker, payload)
+        p.ssrc = 0x1234
+        return p
+
+    rec = type("Rec", (), {"vq": queue.Queue(), "on_stop": []})()
+    state = {"pt": 98, "units": H265AccessUnits(), "recorder": rec, "dropped": 0}
+    router = _Router()
+
+    # One IDR in three fragments, and the next unit.
+    idr = bytes([19 << 1, 1]) + bytes(range(60))
+    fu_ind = bytes([(idr[0] & 0x81) | (49 << 1), idr[1]])
+    body = idr[2:]
+    frags = [
+        fu_ind + bytes([19 | 0x80]) + body[:20],
+        fu_ind + bytes([19]) + body[20:40],
+        fu_ind + bytes([19 | 0x40]) + body[40:],
+    ]
+    trail = bytes([1 << 1, 1, 0xBB])
+
+    async def main():
+        assert _install_sd_h265_tap(_PcNack(router), state, lambda m: None) == 1
+        router.raw_tap(_p(100, 3000, False, frags[0]))
+        router.raw_tap(_p(102, 3000, True, frags[2]))  # 101 lost
+        router.raw_tap(_p(103, 9000, True, trail))
+        await asyncio.sleep(0)
+        assert sent == [(0x1234, [101])]
+        assert rec.vq.empty()  # held for the resend
+        router.raw_tap(_p(101, 3000, False, frags[1]))  # the resend
+        await asyncio.sleep(0)
+
+    asyncio.run(main())
+    first = rec.vq.get_nowait()
+    assert first == (b"\x00\x00\x00\x01" + idr, 3000, True, "hevc")
+    assert state["units"].damaged == 0 and state["units"].dropped == 0
+    assert rec.vq.get_nowait()[1] == 9000
+    assert rec.on_stop  # the tap flushes what it holds when the recording stops