python-aidot-cameras 0.15.1__tar.gz → 0.15.3__tar.gz

{python_aidot_cameras-0.15.1/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.3}/PKG-INFO

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

@@ -867,6 +867,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         self.latest_jpeg: Optional[bytes] = None
         self._streaming_active: bool = False
         self._stream_session: Optional[Any] = None
+        # Last resolution asked for, re-sent when a session starts.
+        self._desired_quality: Optional[str] = None
         self._stream_task: Optional["asyncio.Task[None]"] = None
         self._stream_mqtt_drain: Optional["asyncio.Future"] = None
         self._last_frame_time: float = 0.0
@@ -3354,6 +3356,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
             self._fast_attempt_override = None
             self._stream_session = session
+            # A remembered resolution is only deliverable once a session exists.
+            self._apply_pending_resolution()
             # Don't block solely on wait_done(): the SDES ffmpeg reads RTP over a
             # UDP socket with no input timeout, so when a battery camera tears the
             # session down (~49-72s) ffmpeg keeps waiting on dead sockets forever
@@ -3564,6 +3568,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 continue
 
             self._stream_session = session
+            self._apply_pending_resolution()
             try:
                 while self._streaming_active:
                     await asyncio.sleep(5.0)

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.3}/aidot_cameras/camera/controls.py

@@ -144,6 +144,13 @@ class _CameraControlsMixin:
         mirroring the official app's HD/SD toggle.  Rides the active stream
         session (SETSTREAMCTRL=800), so the camera must be streaming.
 
+        The choice is REMEMBERED and re-sent whenever a session next starts.
+        Without that it was simply dropped when nothing was streaming - and
+        since a camera is idle far more often than not, the usual outcome of
+        changing this was nothing at all, while the caller was told the setting
+        had been applied. Nothing else re-sent it, so "it will apply on the next
+        session" was not true of any code path.
+
         Source: f0.java g3() -> X2(800, SetStreamCtrlReq.parseContent(0, quality)).
         Payload <IB3x> = channel(0) + quality byte + 3 reserved.
         """
@@ -151,14 +158,37 @@ class _CameraControlsMixin:
         if q is None:
             _LOGGER.error("async_set_resolution: unknown quality %r", quality)
             return False
+        self._desired_quality = quality.lower()
         payload = struct.pack("<IB3x", 0, q)
         session = self._stream_session
         if session is None:
-            _LOGGER.warning("async_set_resolution: no active stream session")
-            return False
+            _LOGGER.info(
+                "resolution %s remembered; the camera is not streaming, so it "
+                "will be applied when a session next starts", quality)
+            return True
         ok = session._avio_cmd(SETSTREAMCTRL_CMD, payload)
         _LOGGER.debug(
             "set resolution %s (quality=%d) -> %s",
             quality, q, "sent" if ok else "no channel yet",
         )
         return ok
+
+    def _apply_pending_resolution(self) -> None:
+        """Re-send the remembered resolution now that a session exists.
+
+        Called when a stream session becomes active. Best-effort and silent on
+        failure: a stream that is up matters more than a quality preference, so
+        this must never be able to disturb it.
+        """
+        quality = getattr(self, "_desired_quality", None)
+        if not quality:
+            return
+        q = _STREAM_QUALITY.get(quality)
+        session = self._stream_session
+        if q is None or session is None:
+            return
+        try:
+            if session._avio_cmd(SETSTREAMCTRL_CMD, struct.pack("<IB3x", 0, q)):
+                _LOGGER.debug("re-applied remembered resolution %s", quality)
+        except Exception:
+            _LOGGER.debug("could not re-apply resolution %s", quality, exc_info=True)

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.3}/aidot_cameras/camera/sdes.py

@@ -177,6 +177,24 @@ class SdesSession:
             "audio_pt": self._first_audio_pt[0],
         }
 
+    def _drained_stderr_tail(self) -> bytes:
+        """The stderr the drain thread already consumed, for the teardown log.
+
+        The serve's stderr is drained continuously on a daemon thread (see
+        ``_start_serve_stderr_drain`` in sdes_open) so an un-drained pipe cannot
+        fill and stall ffmpeg.  A consequence is that by teardown the pipe is at
+        EOF and stop()'s ``stderr.read()`` returns nothing, which would leave
+        ``_log_ffmpeg_stderr`` with an empty buffer and silently drop the
+        teardown diagnostic - the mid-stream ffmpeg error it exists to surface
+        included.  Fall back to the bounded tail the drainer kept.  Returns
+        ``b""`` when there is no drainer or it captured nothing, which
+        ``_log_ffmpeg_stderr`` already treats as "nothing to say".
+        """
+        tail = getattr(self._proc, "_aidot_stderr_tail", None)
+        if not tail:
+            return b""
+        return "\n".join(tail).encode("utf-8", "replace")
+
     def _log_ffmpeg_stderr(self, stderr_bytes: bytes) -> None:
         """Log ffmpeg's captured stderr at a level that matches what happened.
 
@@ -285,7 +303,7 @@ class SdesSession:
                 self._proc.stderr.close()
             except Exception:
                 _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
-        self._log_ffmpeg_stderr(stderr_bytes)
+        self._log_ffmpeg_stderr(stderr_bytes or self._drained_stderr_tail())
         import os
         try:
             os.unlink(self._sdp_path)

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.3}/aidot_cameras/camera/sdes_open.py

@@ -38,6 +38,38 @@ from .protocol import (
 
 _LOGGER = logging.getLogger(__name__)
 
+
+def _start_serve_stderr_drain(proc, *, maxlines: int = 40) -> None:
+    """Drain a serve ffmpeg's stderr continuously into a bounded tail on the proc.
+
+    The serve is spawned with ``stderr=PIPE`` but the bridge loop only polls the
+    process and reads its RTP sockets - it never reads stderr.  An un-drained
+    ``PIPE`` fills its ~64KB kernel buffer and then blocks ffmpeg on its next
+    stderr write, stalling the serve; and when ffmpeg exits non-zero the reason is
+    otherwise lost (the RTSP-push ANNOUNCE error in particular).  Read it on a
+    daemon thread that ends at EOF when the process exits, keeping the last
+    ``maxlines`` lines on ``proc._aidot_stderr_tail`` for the exit logger.
+    """
+    import collections
+    import threading
+
+    tail = collections.deque(maxlen=maxlines)
+    proc._aidot_stderr_tail = tail
+    if proc.stderr is None:
+        return
+
+    def _drain() -> None:
+        try:
+            for _line in iter(proc.stderr.readline, b""):
+                tail.append(_line.decode("utf-8", "replace").rstrip())
+        except Exception:
+            pass
+
+    threading.Thread(
+        target=_drain, daemon=True, name="aidot-sdes-serve-stderr"
+    ).start()
+
+
 # Strong references to detached per-session helper tasks, so the event loop
 # cannot garbage-collect one mid-flight.  Entries remove themselves on done.
 _SDES_BACKGROUND_TASKS: set = set()
@@ -2803,6 +2835,15 @@ class _SdesOpenMixin:
                                 _log_br.getLogger(__name__).log(
                                     _br_level, _br_msg, _br_rc
                                 )
+                                if _br_level >= _log_br.WARNING:
+                                    _serr_tail = getattr(
+                                        _br_proc, "_aidot_stderr_tail", None)
+                                    if _serr_tail:
+                                        _log_br.getLogger(__name__).warning(
+                                            "SDES serve ffmpeg stderr (last %d"
+                                            " lines):\n%s", len(_serr_tail),
+                                            "\n".join(_serr_tail),
+                                        )
                             if _bridge_should_break(
                                 _br_rc, _br_teardown_requested
                             ):
@@ -4462,6 +4503,7 @@ class _SdesOpenMixin:
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.PIPE,
             )
+            _start_serve_stderr_drain(proc)
             _proc_holder[0] = proc
             _cl(_reap, proc)   # kill ffmpeg if the open is cancelled before hand-off
         except FileNotFoundError:
@@ -4745,6 +4787,7 @@ class _SdesOpenMixin:
                             stdout=subprocess.DEVNULL,
                             stderr=subprocess.PIPE,
                         )
+                        _start_serve_stderr_drain(proc)
                         # Point the shared holder at the live proc immediately.
                         # The bridge thread polls _proc_holder[0]; if it still
                         # sees the terminated old proc it logs "stream ended",

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.3}/pyproject.toml

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

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.3/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -125,6 +125,7 @@ tests/test_persistent_mqtt.py
 tests/test_persistent_mqtt_robustness.py
 tests/test_playback_tls.py
 tests/test_post_merge_hardening.py
+tests/test_resolution_persists.py
 tests/test_restart_cycle.py
 tests/test_retry_policy.py
 tests/test_scripts_importable.py
@@ -137,6 +138,7 @@ tests/test_sdes_idle_release.py
 tests/test_sdes_open_cleanup.py
 tests/test_sdes_serve_audio.py
 tests/test_sdes_serve_cmd.py
+tests/test_sdes_serve_stderr_drain.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_teardown_exit_log.py

python_aidot_cameras-0.15.3/tests/test_resolution_persists.py

@@ -0,0 +1,95 @@
+"""A resolution choice must survive being made while nothing is streaming.
+
+The setter rides the live session (SETSTREAMCTRL): with no session there is
+nothing to send it over. It used to return False and drop the choice entirely,
+and nothing re-sent it - so the usual outcome of changing resolution was
+nothing at all, because a camera is idle far more often than it is streaming.
+The caller was told the setting had been applied, and the comment in the
+integration's select claimed it would "take effect on the next session", which
+no code path did.
+"""
+
+import os
+import sys
+from unittest.mock import MagicMock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import pytest
+
+from aidot_cameras.camera.constants import _STREAM_QUALITY, SETSTREAMCTRL_CMD
+from aidot_cameras.camera.controls import _CameraControlsMixin
+
+
+class _Cam(_CameraControlsMixin):
+    def __init__(self, session=None):
+        self._stream_session = session
+        self._desired_quality = None
+
+
+def _session():
+    s = MagicMock()
+    s._avio_cmd = MagicMock(return_value=True)
+    return s
+
+
+@pytest.mark.asyncio
+async def test_choice_made_while_idle_is_remembered_not_dropped():
+    cam = _Cam(session=None)
+
+    assert await cam.async_set_resolution("sd") is True
+    assert cam._desired_quality == "sd"
+
+
+@pytest.mark.asyncio
+async def test_remembered_choice_is_sent_when_a_session_starts():
+    cam = _Cam(session=None)
+    await cam.async_set_resolution("sd")
+
+    cam._stream_session = _session()
+    cam._apply_pending_resolution()
+
+    cam._stream_session._avio_cmd.assert_called_once()
+    cmd, payload = cam._stream_session._avio_cmd.call_args[0]
+    assert cmd == SETSTREAMCTRL_CMD
+    assert payload[4] == _STREAM_QUALITY["sd"]   # AVIOCTRL_QUALITY_MIDDLE
+
+
+@pytest.mark.asyncio
+async def test_hd_round_trips_too():
+    cam = _Cam(session=None)
+    await cam.async_set_resolution("hd")
+    cam._stream_session = _session()
+    cam._apply_pending_resolution()
+    assert cam._stream_session._avio_cmd.call_args[0][1][4] == _STREAM_QUALITY["hd"]
+
+
+@pytest.mark.asyncio
+async def test_a_live_session_still_gets_it_immediately():
+    """Unchanged behaviour when the camera is already streaming."""
+    cam = _Cam(session=_session())
+
+    assert await cam.async_set_resolution("sd") is True
+    cam._stream_session._avio_cmd.assert_called_once()
+
+
+def test_nothing_is_sent_when_no_choice_was_ever_made():
+    cam = _Cam(session=_session())
+    cam._apply_pending_resolution()
+    cam._stream_session._avio_cmd.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_an_unknown_quality_is_still_rejected():
+    cam = _Cam(session=_session())
+    assert await cam.async_set_resolution("ultra") is False
+    assert cam._desired_quality is None
+
+
+def test_reapply_never_disturbs_a_working_stream():
+    """A quality preference must never be able to break a stream that is up."""
+    cam = _Cam(session=_session())
+    cam._desired_quality = "sd"
+    cam._stream_session._avio_cmd.side_effect = RuntimeError("channel gone")
+
+    cam._apply_pending_resolution()          # must not raise

python_aidot_cameras-0.15.3/tests/test_sdes_serve_stderr_drain.py

@@ -0,0 +1,161 @@
+"""Tests for the SDES serve ffmpeg stderr drain.
+
+The serve is spawned with ``stderr=PIPE`` but the bridge loop never reads it, so an
+un-drained pipe can fill and stall ffmpeg and a non-zero exit loses its reason.
+``_start_serve_stderr_drain`` reads the pipe on a daemon thread and keeps a bounded
+tail on ``proc._aidot_stderr_tail`` for the exit logger.
+"""
+
+import asyncio
+import io
+import logging
+import time
+
+from aidot_cameras.camera.sdes import SdesSession
+from aidot_cameras.camera.sdes_open import _start_serve_stderr_drain
+
+
+class _FakeProc:
+    """Minimal stand-in exposing a readable ``stderr``, like ``subprocess.Popen``."""
+
+    def __init__(self, data: bytes) -> None:
+        self.stderr = io.BytesIO(data)
+
+
+def _tail(proc) -> list:
+    """The captured stderr tail (attribute is set dynamically by the drainer)."""
+    return list(getattr(proc, "_aidot_stderr_tail"))
+
+
+def _wait_until(pred, timeout: float = 2.0) -> None:
+    deadline = time.monotonic() + timeout
+    while not pred():
+        if time.monotonic() > deadline:
+            break
+        time.sleep(0.01)
+
+
+def test_stderr_drain_captures_lines() -> None:
+    proc = _FakeProc(b"line one\nline two\nline three\n")
+    _start_serve_stderr_drain(proc)
+    _wait_until(lambda: _tail(proc)[-1:] == ["line three"])
+    assert _tail(proc) == ["line one", "line two", "line three"]
+
+
+def test_stderr_drain_is_bounded_to_the_tail() -> None:
+    data = b"".join(f"l{i}\n".encode() for i in range(100))
+    proc = _FakeProc(data)
+    _start_serve_stderr_drain(proc, maxlines=10)
+    _wait_until(lambda: _tail(proc)[-1:] == ["l99"])
+    assert _tail(proc) == [f"l{i}" for i in range(90, 100)]
+
+
+def test_stderr_none_is_safe() -> None:
+    class _NoStderr:
+        stderr = None
+
+    proc = _NoStderr()
+    _start_serve_stderr_drain(proc)  # must not raise
+    assert _tail(proc) == []
+
+
+class _TornDownProc:
+    """A serve proc whose stderr pipe the drainer already emptied.
+
+    ``stop()`` reads ``stderr`` after the process is gone; with the drain thread
+    running that read returns nothing, so the teardown diagnostic has to come
+    from the tail the drainer kept.
+    """
+
+    def __init__(self, tail: list) -> None:
+        self._alive = True
+        self.returncode = 0
+        self.stderr = self
+        self._aidot_stderr_tail = tail
+
+    def poll(self):
+        return None if self._alive else self.returncode
+
+    def terminate(self):
+        self._alive = False
+
+    def wait(self, timeout=None):
+        self._alive = False
+        return self.returncode
+
+    def kill(self):
+        self._alive = False
+
+    def read(self):  # stderr.read() - the drainer got there first
+        return b""
+
+
+class _FakeSock:
+    def close(self) -> None:
+        pass
+
+
+class _FakeQ:
+    def put_nowait(self, _x) -> None:
+        pass
+
+
+def _stopped_session(tail: list) -> None:
+    """Run the real ``SdesSession.stop()`` against a drained serve proc."""
+    session = SdesSession(
+        proc=_TornDownProc(tail),
+        sdp_path="/tmp/aidot_test_does_not_exist.sdp",
+        outgoing_q=_FakeQ(),
+        mqtt_fut=None,
+        audio_sock=_FakeSock(),
+        video_sock=_FakeSock(),
+        cmd_chan=[None],
+        talk_state=None,
+    )
+    asyncio.run(session.stop())
+
+
+def test_teardown_logs_the_drained_tail_when_the_pipe_is_empty(caplog) -> None:
+    # Without the fallback this diagnostic is lost entirely: the drain thread
+    # consumed the pipe, so stop()'s stderr.read() has nothing left to log.
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session(["frame= 120 fps=20", "Error writing trailer: Broken pipe"])
+    warnings = [
+        r for r in caplog.records
+        if r.levelno == logging.WARNING and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+    assert warnings, "a mid-stream ffmpeg error must still reach the log"
+    assert "Error writing trailer: Broken pipe" in warnings[0].getMessage()
+
+
+def test_teardown_tail_still_demotes_the_expected_no_media_shape(caplog) -> None:
+    # The tail feeds the SAME classifier, so a camera that never sent media does
+    # not start warning once per retry just because the stderr route changed.
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session(["Output file is empty, nothing was encoded"])
+    assert not [
+        r for r in caplog.records
+        if r.levelno == logging.WARNING and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+    assert [
+        r for r in caplog.records
+        if r.levelno == logging.DEBUG and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+
+
+def test_teardown_without_a_tail_logs_nothing(caplog) -> None:
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session([])
+    assert not [
+        r for r in caplog.records if "ffmpeg SDES stderr" in r.getMessage()
+    ]
+
+
+def test_undecodable_bytes_do_not_crash_the_drain() -> None:
+    proc = _FakeProc(b"good\n\xff\xfe bad bytes\ndone\n")
+    _start_serve_stderr_drain(proc)
+    _wait_until(lambda: _tail(proc)[-1:] == ["done"])
+    tail = _tail(proc)
+    assert tail[0] == "good"
+    assert tail[-1] == "done"
+    assert len(tail) == 3