python-aidot-cameras 0.12.12__tar.gz → 0.12.14__tar.gz

{python_aidot_cameras-0.12.12/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.14}/PKG-INFO

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

@@ -3155,6 +3155,19 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 self._cancel_keepalive_renew()
                 self._keepalive_rtsp_url = None
                 self._serve_ready.clear()
+                # Take the stream out of go2rtc too. Leaving it registered
+                # points go2rtc at a source that no longer exists, so a viewer
+                # attaching while the camera is dormant gets a hard refusal
+                # ("connection refused" on the serve port) instead of a clean
+                # "no such stream" - and in push mode that source was never
+                # dialable in the first place. stream_source() re-registers on
+                # the next view.
+                try:
+                    await self._deregister_go2rtc()
+                except Exception:
+                    _LOGGER.debug("camera %s: swallowed exception in %s",
+                                  getattr(self, "device_id", "?"),
+                                  "_deregister_go2rtc", exc_info=True)
                 _LOGGER.debug(
                     "SDES serve: %s idle (no viewer) - released until next view",
                     self.device_id,
@@ -4067,7 +4080,15 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                                 # Unknown: keep the old staleness heuristic rather
                                 # than holding the stream open forever.
                                 idle_release = True
-                            break
+                            # Only an actual idle release ends this serve cycle.
+                            # (This break was unconditional - any idle_secs > 0
+                            # tore down a HEALTHY ffmpeg after one 0.5s tick,
+                            # respawning it forever: ffmpeg died at output-open
+                            # with "Immediate exit requested" and every DTLS
+                            # camera served nothing. stream_idle_s=0 masked it,
+                            # which is why never-release fleets still worked.)
+                            if idle_release:
+                                break
                     # Tear down this ffmpeg+mux cycle before the next.
                     stop_flag.set()
                     try:
@@ -4116,6 +4137,14 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 self._cancel_keepalive_renew()
                 self._keepalive_rtsp_url = None
                 self._serve_ready.clear()
+                # Same as the SDES path: do not leave go2rtc holding a stream
+                # whose source no longer exists.
+                try:
+                    await self._deregister_go2rtc()
+                except Exception:
+                    _LOGGER.debug("camera %s: swallowed exception in %s",
+                                  getattr(self, "device_id", "?"),
+                                  "_deregister_go2rtc", exc_info=True)
                 _LOGGER.debug(
                     "DTLS serve: %s idle (no viewer) - released until next view",
                     self.device_id,

{python_aidot_cameras-0.12.12 → python_aidot_cameras-0.12.14}/aidot_cameras/camera/protocol.py

@@ -925,8 +925,52 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
     except Exception as exc:  # pragma: no cover
         _LOGGER.warning("DTLS A/V mux: PyAV unavailable: %s", exc)
         return
+
+    class _FailFlagWriter:
+        """Write-only stand-in for the pipe that RECORDS write failures.
+
+        FFmpeg's mpegts muxer checks avio write errors lazily: a dead pipe
+        (EPIPE after its ffmpeg exits) makes ``out.mux()`` appear to succeed
+        forever, and the error only surfaces - or hangs - at trailer time.
+        PyAV's pyio callback DOES see each failed ``write``; recording it here
+        lets the mux loop notice within one iteration and exit, instead of an
+        abandoned thread draining the SHARED vq/aq into a dead pipe and
+        starving the next cycle's ffmpeg (the 2026-07 dead-DTLS-video field
+        failure).  Deliberately exposes no seek/tell: the pipe is streaming.
+        """
+
+        def __init__(self, f):
+            self._f = f
+            self.failed = False
+
+        def write(self, b):
+            try:
+                return self._f.write(b)
+            except Exception:
+                self.failed = True
+                raise
+
+        def flush(self):
+            try:
+                self._f.flush()
+            except Exception:
+                self.failed = True
+                raise
+
+        def close(self):
+            self._f.close()
+
+    wsink = _FailFlagWriter(out_fileobj)
     try:
-        out = av.open(out_fileobj, "w", format="mpegts")
+        # max_interleave_delta (default 10s of stream time): with an AAC stream
+        # declared but no audio packets arriving, libavformat's interleave
+        # queue holds EVERY video packet waiting to order them against audio -
+        # zero bytes reach the pipe, the serve ffmpeg starves at its input
+        # probe and never binds its -listen port (field failure 2026-07: all
+        # DTLS cameras dark while the taps were full of frames).  100ms keeps
+        # video flowing whether or not audio ever shows up.
+        out = av.open(wsink, "w", format="mpegts",
+                      options={"max_interleave_delta": "100000"})
     except Exception as exc:
         _LOGGER.warning("DTLS A/V mux: av.open failed: %s", exc)
         return
@@ -975,6 +1019,14 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
     a_rtp0 = [None]      # first audio RTP timestamp (8 kHz units), for gap detection
     a_in = [0]           # 8 kHz samples emitted to the resampler so far (incl. concealed)
     vstarted = [False]
+    # A failed container write is TERMINAL for this mux: the pipe's ffmpeg is
+    # gone (EPIPE) and can never come back for this cycle.  Swallowing it and
+    # looping used to leave abandoned mux threads (the teardown join(2.0) gives
+    # up on a thread blocked in write) racing the NEXT cycle's thread for the
+    # SHARED vq/aq - stealing its frames into a dead pipe, starving the new
+    # ffmpeg at its input probe so it never bound its -listen port.  One dead
+    # write -> exit the thread and leave the queues alone.
+    mux_dead = [False]
 
     def _flush_video():
         while True:
@@ -995,7 +1047,9 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                 out.mux(pkt)
                 progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("swallowed exception in %s", '_flush_video', exc_info=True)
+                mux_dead[0] = True
+                _LOGGER.debug("DTLS A/V mux: video write failed - ending mux thread", exc_info=True)
+                return
 
     def _flush_audio(drain=False):
         if not have_audio:
@@ -1115,20 +1169,34 @@ def _dtls_av_mux_run(vq, aq, out_fileobj, progress, stop_flag) -> None:
                     out.mux(opkt)
                     progress[0] = _t.monotonic()
             except Exception:
-                _LOGGER.debug("swallowed exception in %s", '_flush_audio', exc_info=True)
+                mux_dead[0] = True
+                _LOGGER.debug("DTLS A/V mux: audio write failed - ending mux thread", exc_info=True)
+                return
+
+    def _dead() -> bool:
+        return mux_dead[0] or wsink.failed
 
-    while not stop_flag.is_set():
+    while not stop_flag.is_set() and not _dead():
         _flush_video()
         _flush_audio()
         _t.sleep(0.005)  # 5 ms - processes audio within 5 ms of arrival vs 20 ms
-    _flush_video()
-    _flush_audio(drain=True)  # final: pad the last partial frame so it flushes
+    if not _dead():
+        _flush_video()
+        _flush_audio(drain=True)  # final: pad the last partial frame so it flushes
     try:
-        if have_audio:
+        if have_audio and not _dead():
             for opkt in aenc.encode(None):  # flush
                 out.mux(opkt)
     except Exception:
         _LOGGER.debug("swallowed exception in %s", '_dtls_av_mux_run', exc_info=True)
+    if _dead():
+        # Close the raw pipe FIRST: the container's trailer flush then fails
+        # fast ("closed file") instead of hanging on the dead pipe.
+        _LOGGER.debug("DTLS A/V mux: sink write failed - ending mux thread")
+        try:
+            wsink.close()
+        except Exception:
+            pass
     try:
         out.close()
     except Exception:

{python_aidot_cameras-0.12.12 → python_aidot_cameras-0.12.14}/aidot_cameras/camera/sdes_open.py

@@ -102,6 +102,11 @@ def _sdes_echo_wait_timeout(skip_liveplay: bool) -> float:
     return 0.0 if skip_liveplay else 2.0
 
 
+# ffmpeg returns AVERROR(EPIPE) = -32 when its output consumer disappears, and a
+# process exit status is truncated to an unsigned byte: -32 & 0xFF = 224.
+_FFMPEG_EXIT_EPIPE = 224
+
+
 def _classify_ffmpeg_exit(rc: int, teardown_requested: bool) -> int:
     """Log level for the bridge observe loop's "ffmpeg exited" line.
 
@@ -116,6 +121,12 @@ def _classify_ffmpeg_exit(rc: int, teardown_requested: bool) -> int:
     """
     if rc < 0 and teardown_requested:
         return logging.DEBUG
+    if rc == _FFMPEG_EXIT_EPIPE:
+        # Broken pipe: the consumer went away. That is the NORMAL end of a
+        # `-listen 1` serve - go2rtc disconnects and ffmpeg exits - so warning
+        # about it trains the reader to ignore real failures. A process exit
+        # status is an unsigned byte, so AVERROR(EPIPE) = -32 surfaces as 224.
+        return logging.DEBUG
     return logging.WARNING
 
 

{python_aidot_cameras-0.12.12 → python_aidot_cameras-0.12.14}/pyproject.toml

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

{python_aidot_cameras-0.12.12 → python_aidot_cameras-0.12.14/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -72,6 +72,8 @@ tests/test_backoff.py
 tests/test_deferred_hardening.py
 tests/test_device_login_guard.py
 tests/test_device_user_info_cache.py
+tests/test_dormant_camera_cleanup.py
+tests/test_dtls_mux_terminal_write.py
 tests/test_dtls_not_ready_burst.py
 tests/test_dtls_pinning.py
 tests/test_dtls_serve_decode_skip.py

python_aidot_cameras-0.12.14/tests/test_dormant_camera_cleanup.py

@@ -0,0 +1,65 @@
+"""A dormant camera must not leave a dead stream registered in go2rtc.
+
+Idle-release stops the serve but used to leave the go2rtc stream in place,
+pointing at a source that no longer exists. A viewer attaching then gets a hard
+"connection refused" on the serve port rather than a clean miss - and in PUSH mode
+that source was never dialable at all, because the keepalive publishes INTO go2rtc
+rather than serving over HTTP.
+
+Observed live: four go2rtc streams registered against serve ports with nothing
+listening, and go2rtc reporting
+`dial tcp 127.0.0.1:18981: connect: connection refused`.
+"""
+import inspect
+
+import aidot_cameras.camera.client as cc
+from aidot_cameras.camera.sdes_open import (
+    _FFMPEG_EXIT_EPIPE,
+    _classify_ffmpeg_exit,
+)
+import logging
+
+
+def _src(name):
+    return inspect.getsource(getattr(cc.CameraMixin, name))
+
+
+def test_sdes_idle_release_deregisters_from_go2rtc():
+    src = _src("_sdes_keepalive_loop_inner")
+    idle = src[src.index("if _idle_release:"):]
+    assert "_deregister_go2rtc" in idle
+
+
+def test_dtls_idle_release_deregisters_from_go2rtc():
+    src = _src("_dtls_serve_loop_inner")
+    idle = src[src.index("if idle_release:"):]
+    assert "_deregister_go2rtc" in idle
+
+
+def test_deregistration_failure_cannot_break_the_release():
+    # Going dormant must still complete if go2rtc is unreachable.
+    for name, marker in (("_sdes_keepalive_loop_inner", "if _idle_release:"),
+                         ("_dtls_serve_loop_inner", "if idle_release:")):
+        idle = _src(name)
+        idle = idle[idle.index(marker):]
+        block = idle[idle.index("_deregister_go2rtc") - 200:
+                     idle.index("_deregister_go2rtc") + 300]
+        assert "try:" in block and "except Exception" in block
+
+
+def test_consumer_disconnect_is_not_logged_as_a_failure():
+    # ffmpeg returns AVERROR(EPIPE) = -32 when its consumer goes away, and an exit
+    # status is an unsigned byte, so it surfaces as 224. That is the normal end of
+    # a `-listen 1` serve, not a fault.
+    assert _FFMPEG_EXIT_EPIPE == 224
+    assert _classify_ffmpeg_exit(224, teardown_requested=False) == logging.DEBUG
+    assert _classify_ffmpeg_exit(224, teardown_requested=True) == logging.DEBUG
+
+
+def test_real_failures_still_warn():
+    assert _classify_ffmpeg_exit(1, teardown_requested=False) == logging.WARNING
+    assert _classify_ffmpeg_exit(255, teardown_requested=False) == logging.WARNING
+    # A signal death with no teardown in flight is still unexpected.
+    assert _classify_ffmpeg_exit(-9, teardown_requested=False) == logging.WARNING
+    # ...but an expected teardown is quiet.
+    assert _classify_ffmpeg_exit(-9, teardown_requested=True) == logging.DEBUG

python_aidot_cameras-0.12.14/tests/test_dtls_mux_terminal_write.py

@@ -0,0 +1,126 @@
+"""A failed container write must END the DTLS mux thread, not be swallowed.
+
+Regression for the abandoned-mux-thread leak: teardown's join(2.0) gives up on
+a thread blocked in a pipe write; once that pipe's ffmpeg dies the write raises
+EPIPE forever.  The old per-packet swallow kept the abandoned thread looping,
+stealing frames from the SHARED vq/aq that the next cycle's thread needed - the
+new ffmpeg starved at its input probe and never bound its -listen port (the
+field "dead DTLS video" of 2026-07).  A dead write now exits the thread and
+leaves the queues alone.
+"""
+
+import os
+import queue
+import threading
+import time
+
+import pytest
+
+av = pytest.importorskip("av")
+
+from aidot_cameras.camera.protocol import _dtls_av_mux_run
+
+
+def _h264_payloads(n=60):
+    """Real encoded H.264 access units (the mux needs valid-ish annex-b).
+
+    Noise frames compress terribly on purpose: the total must exceed PyAV's
+    ~32KB avio buffer so the container performs REAL pipe writes (a smaller
+    payload sits in the buffer forever and never observes the dead pipe).
+    """
+    import numpy as np
+
+    rng = np.random.default_rng(7)
+    enc = av.CodecContext.create("libx264", "w")
+    enc.width, enc.height, enc.pix_fmt = 320, 240, "yuv420p"
+    from fractions import Fraction
+
+    enc.time_base = Fraction(1, 15)
+    enc.options = {"tune": "zerolatency"}
+    out = []
+    for i in range(n):
+        img = rng.integers(0, 255, (240, 320, 3), dtype=np.uint8)
+        fr = av.VideoFrame.from_ndarray(img, format="rgb24").reformat(format="yuv420p")
+        fr.pts = i
+        for p in enc.encode(fr):
+            out.append((bytes(p), bool(p.is_keyframe)))
+    for p in enc.encode(None):
+        out.append((bytes(p), bool(p.is_keyframe)))
+    assert sum(len(d) for d, _ in out) > 100_000
+    return out
+
+
+def test_dead_pipe_ends_mux_thread_and_spares_queues():
+    payloads = _h264_payloads()
+    assert payloads and payloads[0][1], "first packet should be a keyframe"
+
+    vq: queue.Queue = queue.Queue()
+    aq: queue.Queue = queue.Queue()
+    ts = 0
+    for data, kf in payloads:
+        vq.put((data, ts, kf))
+        ts += 6000
+
+    r, w = os.pipe()
+    os.close(r)  # reader already gone -> every flushed write is EPIPE
+    wfile = os.fdopen(w, "wb", buffering=0)
+    progress = [time.monotonic()]
+    stop_flag = threading.Event()
+
+    t = threading.Thread(
+        target=_dtls_av_mux_run, args=(vq, aq, wfile, progress, stop_flag), daemon=True
+    )
+    t.start()
+    t.join(timeout=10.0)
+
+    # The thread must have exited on its own (stop_flag was never set).
+    assert not t.is_alive(), "mux thread must end on a dead pipe, not loop forever"
+    assert not stop_flag.is_set()
+    # And it must not have drained the whole queue into the dead pipe: once the
+    # avio buffer first flushes and EPIPEs, remaining frames stay for the next
+    # cycle's consumer.  (The avio buffer absorbs the first ~32KB, so a few
+    # packets are legitimately consumed before the first real write.)
+    assert not vq.empty(), "a dead mux must leave queued frames for the next cycle"
+
+
+def test_healthy_pipe_still_muxes():
+    payloads = _h264_payloads()
+    vq: queue.Queue = queue.Queue()
+    aq: queue.Queue = queue.Queue()
+    ts = 0
+    for data, kf in payloads:
+        vq.put((data, ts, kf))
+        ts += 6000
+
+    r, w = os.pipe()
+    got = [0]
+
+    def drain():
+        while True:
+            try:
+                b = os.read(r, 65536)
+            except OSError:
+                return
+            if not b:
+                return
+            got[0] += len(b)
+
+    threading.Thread(target=drain, daemon=True).start()
+    wfile = os.fdopen(w, "wb", buffering=0)
+    progress = [time.monotonic()]
+    stop_flag = threading.Event()
+    t = threading.Thread(
+        target=_dtls_av_mux_run, args=(vq, aq, wfile, progress, stop_flag), daemon=True
+    )
+    t.start()
+    time.sleep(1.5)
+    # REGRESSION (interleave stall): with an AAC stream declared but zero audio
+    # packets, libavformat used to buffer ALL video in its interleave queue -
+    # bytes only appeared at close().  They must flow DURING muxing.
+    assert got[0] > 10_000, (
+        "video must reach the pipe while muxing, without any audio packets"
+    )
+    stop_flag.set()
+    t.join(timeout=10.0)
+    assert not t.is_alive()
+    assert vq.empty(), "healthy mux consumes the queue"

{python_aidot_cameras-0.12.12 → python_aidot_cameras-0.12.14}/tests/test_viewer_check_throttle.py

@@ -8,7 +8,6 @@ anywhere. Idle release is measured in minutes, so a few seconds of staleness in
 the answer costs nothing.
 """
 import asyncio
-import time
 
 import aidot_cameras.camera.client as cc
 from aidot_cameras.device_client import CameraDeviceClient