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

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

@@ -55,6 +55,7 @@ class TsCopyRecorder:
         path: str,
         device_id: Optional[str] = None,
         video_codec: Optional[str] = "h264",
+        file=None,
     ) -> None:
         self._path = path
         # None: the first keyframe names it (SD playback, H264 or H265).
@@ -67,10 +68,15 @@ class TsCopyRecorder:
         self._thread: Optional[threading.Thread] = None
         self._state: dict = {}
         self._stopped = False
-        # Opened here, before the session connects, so an unwritable path fails
-        # while there is nothing to clean up. Held open until the mux thread is
-        # done with it - no single block encloses that, so no context manager.
-        self._file = open(self._path, "wb")  # noqa: SIM115
+        # 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
+        # until the mux thread is done with it - no single block encloses
+        # that, so no context manager.
+        self._file = file if file is not None else open(self._path, "wb")  # noqa: SIM115
 
     async def start(self) -> None:
         if self._thread is not None or self._stopped:
@@ -93,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.0rc65 → python_aidot_cameras-1.0.0rc67}/aidot_cameras/camera/sd_playback.py

@@ -597,37 +597,117 @@ 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.
 
     ``feed`` takes one packet's sequence number, RTP timestamp, marker bit and
     payload, and returns the access units it completed as
     ``(bytes, rtp_timestamp, is_keyframe)`` - the shape the DTLS recorder's
-    video queue takes. A unit with a sequence gap in it is dropped rather than
-    handed on damaged. ``parameter_sets`` (from the answer's fmtp) go in front
-    of a keyframe that does not carry its own VPS.
+    video queue takes. A unit with a sequence gap in it is handed on with
+    what arrived (``damaged`` counts them): every later frame up to the next
+    keyframe refers to it, so dropping it made all of those undecodable - an
+    A000088 playback lost 122 frames to one lost packet (2026-10-29), where
+    the decoder conceals a damaged frame and carries on. ``keep_damaged=False``
+    drops them instead (``dropped``). ``parameter_sets`` (from the answer's
+    fmtp) go in front of a keyframe that does not carry its own VPS.
     """
 
-    def __init__(self, parameter_sets: "Optional[list[bytes]]" = None) -> None:
+    def __init__(
+        self,
+        parameter_sets: "Optional[list[bytes]]" = None,
+        *,
+        keep_damaged: bool = True,
+    ) -> None:
         self.parameter_sets = list(parameter_sets or [])
+        self.keep_damaged = keep_damaged
         self._ts: "Optional[int]" = None
         self._nals: "list[bytes]" = []
         self._fu: "Optional[bytearray]" = None
         self._last_seq: "Optional[int]" = None
         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 = []
         if self._fu is not None:
             self._broken = True  # a fragment never finished
-        if self._nals and not self._broken and self._ts is not None:
+            if self.keep_damaged and len(self._fu) > 2:
+                self._nals.append(bytes(self._fu))  # what arrived of it
+        keep = not self._broken or self.keep_damaged
+        if self._nals and keep and self._ts is not None:
             types = [(n[0] >> 1) & 0x3F for n in self._nals if n]
             kf = any(16 <= t <= 21 for t in types)
             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))
+            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
@@ -665,7 +745,7 @@ class H265AccessUnits:
                 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
+                        self._broken = True  # truncated or corrupt: the rest is lost
                         break
                     self._nals.append(bytes(payload[i + 2 : i + 2 + n]))
                     i += 2 + n

{python_aidot_cameras-1.0.0rc65 → 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,19 +309,24 @@ 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
             for data, ts, kf in units.feed(
                 packet.sequence_number,
                 packet.timestamp,
@@ -335,6 +341,48 @@ def _install_sd_h265_tap(pc, h265, status) -> int:
                         status("SD playback: the recorder fell behind - H265 dropped")
             if units.dropped and not lost_before:
                 status("SD playback: an H265 frame with a lost packet was dropped")
+            if units.damaged and not damaged_before:
+                status(
+                    "SD playback: an H265 frame with a lost packet was passed on"
+                    " 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
 
@@ -3155,14 +3203,24 @@ async def _dtls_open_peer_connection_setup(self, ps: _DtlsOpenState) -> None:
             track,
         )
 
-    ps.recorder = self._attach_file_recorder(
-        ps.pc,
-        ps.output_path,
-        ps.on_frame,
-        # SD playback: H264 or H265, whichever the recording is; the first
-        # keyframe names it.
-        video_codec=None if ps._sd_playback is not None else "h264",
-    )
+    # Opened off the event loop: a caller such as Home Assistant flags (and
+    # may be stalled by) a blocking open() on it. The recorder takes the open
+    # file, so an unwritable path still fails before the session connects.
+    _rec_file = await _open_ts_output(ps.output_path)
+    try:
+        ps.recorder = self._attach_file_recorder(
+            ps.pc,
+            ps.output_path,
+            ps.on_frame,
+            # SD playback: H264 or H265, whichever the recording is; the first
+            # keyframe names it.
+            video_codec=None if ps._sd_playback is not None else "h264",
+            file=_rec_file,
+        )
+    finally:
+        # A recorder that took the file closes it; nobody else will.
+        if _rec_file is not None and getattr(ps, "recorder", None) is None:
+            _rec_file.close()
     if ps._sd_playback is not None and ps.recorder is not None:
         from .sd_playback import H265AccessUnits
 
@@ -4693,8 +4751,26 @@ async def _dtls_open_ice_candidates_and_connect(
     return None
 
 
+async def _open_ts_output(path):
+    """``path`` opened for the TS recorder in an executor, or None: not a .ts
+    output (the recorder is not ours), or the open failed - the recorder then
+    tries itself and reports the error as it always has."""
+    from .recording import is_ts_path
+
+    if not path or not is_ts_path(path):
+        return None
+    try:
+        return await asyncio.get_running_loop().run_in_executor(
+            None, functools.partial(open, path, "wb")
+        )
+    except OSError:
+        return None
+
+
 class _WebRTCOpenMixin:
-    def _attach_file_recorder(self, pc, output_path, on_frame, video_codec="h264"):
+    def _attach_file_recorder(
+        self, pc, output_path, on_frame, video_codec="h264", file=None
+    ):
         """The recorder for a DTLS ``output_path``, wired to ``pc``'s tracks.
 
         MPEG-TS paths copy the camera's own streams (``TsCopyRecorder``): the
@@ -4716,6 +4792,7 @@ class _WebRTCOpenMixin:
                     output_path,
                     device_id=getattr(self, "device_id", None),
                     video_codec=video_codec,
+                    file=file,
                 )
             except OSError as exc:
                 _LOGGER.warning(

{python_aidot_cameras-1.0.0rc65 → 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.0rc65"
+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.0rc65 → 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.0rc65
+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.0rc65 → python_aidot_cameras-1.0.0rc67}/tests/test_dtls_recorder_wiring.py

@@ -122,3 +122,37 @@ def test_tapping_a_receiver_twice_for_different_queues_is_flagged(caplog):
     with caplog.at_level("WARNING"):
         CameraMixin._install_encoded_tap(rcv, second, True, serve=True)
     assert any("already tapped" in r.getMessage() for r in caplog.records)
+
+
+def test_the_recording_file_is_opened_off_the_event_loop(tmp_path, monkeypatch):
+    # Home Assistant flagged "Detected blocking call to open ... .part.ts"
+    # on every DTLS card-recording fetch (2026-10-29): the recorder opened its
+    # file in its constructor, on the loop. The open phase now opens it in an
+    # executor and hands it over.
+    import asyncio
+    import threading
+
+    from aidot_cameras.camera import webrtc_open
+    from aidot_cameras.camera.recording import TsCopyRecorder
+
+    loop_thread, opened_on = [], []
+    real_open = open
+
+    def _spy(*a, **k):
+        opened_on.append(threading.current_thread())
+        return real_open(*a, **k)
+
+    async def main():
+        loop_thread.append(threading.current_thread())
+        monkeypatch.setattr("builtins.open", _spy)
+        fh = await webrtc_open._open_ts_output(str(tmp_path / "clip.part.ts"))
+        monkeypatch.setattr("builtins.open", real_open)
+        assert await webrtc_open._open_ts_output(str(tmp_path / "clip.mp4")) is None
+        assert await webrtc_open._open_ts_output(None) is None
+        return fh
+
+    fh = asyncio.run(main())
+    assert fh is not None and opened_on and opened_on[0] is not loop_thread[0]
+    rec = TsCopyRecorder(str(tmp_path / "clip.part.ts"), file=fh)
+    assert rec._file is fh
+    fh.close()

{python_aidot_cameras-1.0.0rc65 → python_aidot_cameras-1.0.0rc67}/tests/test_sd_playback_dtls.py

@@ -164,9 +164,9 @@ def test_access_units_survive_rtp_and_back():
     assert [ts for _, ts, _ in got] == [90000 + i * 6000 for i in range(len(aus))]
 
 
-def test_a_unit_with_a_lost_packet_is_dropped_not_damaged():
+def test_in_drop_mode_a_unit_with_a_lost_packet_is_dropped():
     aus = _hevc_access_units(4)
-    units = H265AccessUnits()
+    units = H265AccessUnits(keep_damaged=False)
     got, seq = [], 7
     for i, au in enumerate(aus):
         pkts = _packetize(au, i * 6000, seq, mtu=200)
@@ -356,7 +356,7 @@ def test_a_recording_held_as_h264_is_muxed_as_h264():
 
 def test_a_lost_last_packet_drops_its_own_unit_not_the_next():
     aus = _hevc_access_units(5)
-    units = H265AccessUnits()
+    units = H265AccessUnits(keep_damaged=False)
     got, seq = [], 50
     for i, au in enumerate(aus):
         pkts = _packetize(au, i * 6000, seq, mtu=200)
@@ -419,7 +419,7 @@ def test_the_sd_mode_echo_has_one_parser():
 
 def test_a_lost_head_drops_the_new_unit_not_the_one_already_emitted():
     aus = _hevc_access_units(5)
-    units = H265AccessUnits()
+    units = H265AccessUnits(keep_damaged=False)
     got, seq = [], 300
     for i, au in enumerate(aus):
         pkts = _packetize(au, i * 6000, seq, mtu=200)
@@ -434,7 +434,7 @@ def test_a_lost_head_drops_the_new_unit_not_the_one_already_emitted():
 
 def test_a_gap_wider_than_the_lost_marker_drops_both_units():
     aus = _hevc_access_units(5)
-    units = H265AccessUnits()
+    units = H265AccessUnits(keep_damaged=False)
     got, seq = [], 900
     for i, au in enumerate(aus):
         pkts = _packetize(au, i * 6000, seq, mtu=200)
@@ -448,9 +448,130 @@ def test_a_gap_wider_than_the_lost_marker_drops_both_units():
 
 
 def test_a_truncated_aggregation_packet_breaks_its_unit():
-    units = H265AccessUnits()
+    units = H265AccessUnits(keep_damaged=False)
     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
+
+
+def test_by_default_a_damaged_unit_is_handed_on_and_counted():
+    # One lost packet used to cost every frame up to the next keyframe
+    # (A000088, 2026-10-29: 122 undecodable frames); handed on, the decoder
+    # conceals the one damaged frame.
+    aus = _hevc_access_units(5)
+    units = H265AccessUnits()
+    got, seq = [], 600
+    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 == 3:
+                continue  # one packet inside the first (keyframe) unit
+            got += units.feed(*p)
+    assert [ts for _, ts, _ in got] == [i * 6000 for i in range(len(aus))]
+    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