python-aidot-cameras 0.15.0b5__tar.gz → 0.15.2__tar.gz

{python_aidot_cameras-0.15.0b5/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.0b5
+Version: 0.15.2
 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
@@ -167,6 +167,8 @@ audio, idle release, the sprop cache path) are documented in
 
 | Variable | Purpose | Default |
 | --- | --- | --- |
+| `AIDOT_VIDEO_DECODER` | Force a video decoder instead of measuring one: a decoder name (`h264_v4l2m2m`), or an acceleration method prefixed with `hwaccel:` (`hwaccel:videotoolbox`). The prefix is required because the two are not interchangeable - VideoToolbox and VAAPI have no decoder to name. | (measured) |
+| `AIDOT_DISABLE_HWACCEL` | Keep to software decoding and skip the measurement entirely. | (unset) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently across all cameras. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |
 | `AIDOT_FAST_CONNECT` | Enable LAN-direct "fast connect" (STUN-only, skips several cloud signaling waits) when truthy. On-LAN only - off-subnet/strict-NAT viewers must leave it off. | unset (off) |

{python_aidot_cameras-0.15.0b5 → python_aidot_cameras-0.15.2}/README.md

@@ -136,6 +136,8 @@ audio, idle release, the sprop cache path) are documented in
 
 | Variable | Purpose | Default |
 | --- | --- | --- |
+| `AIDOT_VIDEO_DECODER` | Force a video decoder instead of measuring one: a decoder name (`h264_v4l2m2m`), or an acceleration method prefixed with `hwaccel:` (`hwaccel:videotoolbox`). The prefix is required because the two are not interchangeable - VideoToolbox and VAAPI have no decoder to name. | (measured) |
+| `AIDOT_DISABLE_HWACCEL` | Keep to software decoding and skip the measurement entirely. | (unset) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently across all cameras. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |
 | `AIDOT_FAST_CONNECT` | Enable LAN-direct "fast connect" (STUN-only, skips several cloud signaling waits) when truthy. On-LAN only - off-subnet/strict-NAT viewers must leave it off. | unset (off) |

{python_aidot_cameras-0.15.0b5 → python_aidot_cameras-0.15.2}/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.0b5 → python_aidot_cameras-0.15.2}/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.0b5 → python_aidot_cameras-0.15.2}/aidot_cameras/camera/hwaccel.py

@@ -393,6 +393,14 @@ def warm_decoder_cache(codecs: tuple = ("h264",)) -> "threading.Thread":
             return _warm_thread
 
     def _run() -> None:
+        # Prime the in-memory cache from disk HERE, on this thread, so
+        # cached_decoder() never has to read a file on the event loop.
+        try:
+            for k, v in _load_cache().items():
+                if isinstance(v, list):
+                    _cache_mem.setdefault(k, list(v))
+        except Exception:
+            _LOGGER.debug("decoder cache preload failed", exc_info=True)
         for codec in codecs:
             try:
                 probe_decoder(codec)
@@ -432,13 +440,15 @@ def cached_decoder(codec: str) -> Optional[List[str]]:
     if os.environ.get(_ENV_DISABLE, "").strip().lower() in ("1", "true", "yes", "on"):
         return []
 
+    # MEMORY ONLY. This runs on the event loop, so it must not touch the disk:
+    # Home Assistant detects a blocking open() here and reports it as a
+    # stability problem, correctly. The disk cache is read by
+    # warm_decoder_cache() on its own thread, which populates _cache_mem; a miss
+    # here simply means "not known yet", and the caller lets ffmpeg choose,
+    # which is the behaviour that existed before any of this.
     key = f"v{_CACHE_SCHEMA}:{codec}:{_ffmpeg_identity()}"
     if key in _cache_mem:
         return list(_cache_mem[key])
-    val = _load_cache().get(key)
-    if isinstance(val, list):
-        _cache_mem[key] = list(val)
-        return list(val)
     return None
 
 

{python_aidot_cameras-0.15.0b5 → python_aidot_cameras-0.15.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.0b5
+Version: 0.15.2
 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
@@ -167,6 +167,8 @@ audio, idle release, the sprop cache path) are documented in
 
 | Variable | Purpose | Default |
 | --- | --- | --- |
+| `AIDOT_VIDEO_DECODER` | Force a video decoder instead of measuring one: a decoder name (`h264_v4l2m2m`), or an acceleration method prefixed with `hwaccel:` (`hwaccel:videotoolbox`). The prefix is required because the two are not interchangeable - VideoToolbox and VAAPI have no decoder to name. | (measured) |
+| `AIDOT_DISABLE_HWACCEL` | Keep to software decoding and skip the measurement entirely. | (unset) |
 | `AIDOT_MAX_CONCURRENT_OPENS` | Caps how many stream opens run concurrently across all cameras. | `2` |
 | `AIDOT_MAX_CONCURRENT_STREAMS` | Caps how many cameras stream at once. | `3` |
 | `AIDOT_FAST_CONNECT` | Enable LAN-direct "fast connect" (STUN-only, skips several cloud signaling waits) when truthy. On-LAN only - off-subnet/strict-NAT viewers must leave it off. | unset (off) |

{python_aidot_cameras-0.15.0b5 → python_aidot_cameras-0.15.2}/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

{python_aidot_cameras-0.15.0b5 → python_aidot_cameras-0.15.2}/tests/test_hwaccel_probe.py

@@ -158,6 +158,18 @@ def test_no_sample_falls_back_to_software(monkeypatch):
     assert hwaccel.probe_decoder("h264", force=True) == []
 
 
+def test_warm_cache_primes_memory_from_disk(monkeypatch):
+    """Since cached_decoder() is memory-only, something has to load the disk
+    cache - and it must be the background thread, not the event loop."""
+    monkeypatch.setattr(hwaccel, "_ffmpeg_identity", lambda: "b")
+    key = f"v{hwaccel._CACHE_SCHEMA}:h264:b"
+    hwaccel._save_cache({key: ["-c:v", "h264_v4l2m2m"]})
+    assert hwaccel.cached_decoder("h264") is None      # not yet in memory
+    monkeypatch.setattr(hwaccel, "probe_decoder", lambda c: [])
+    hwaccel.warm_decoder_cache(("h264",)).join(timeout=30)
+    assert hwaccel.cached_decoder("h264") == ["-c:v", "h264_v4l2m2m"]
+
+
 def test_software_verdict_is_not_confused_with_unprobed(monkeypatch):
     """[] means "software, proven"; None means "not probed yet". Collapsing the
     two would re-probe forever on any host with no hardware decoding."""
@@ -168,7 +180,7 @@ def test_software_verdict_is_not_confused_with_unprobed(monkeypatch):
                         lambda cand, sample: 1.0 if not cand else None)
     assert hwaccel.cached_decoder("h264") is None      # nothing probed yet
     assert hwaccel.probe_decoder("h264") == []         # proven software
-    assert hwaccel.cached_decoder("h264") == []        # remembered, not None
+    assert hwaccel.cached_decoder("h264") == []        # memoised, not None
 
 
 def test_a_stale_schema_entry_is_ignored(monkeypatch):
@@ -176,6 +188,8 @@ def test_a_stale_schema_entry_is_ignored(monkeypatch):
     Reading that back as a verdict would put a string into the ffmpeg argv."""
     monkeypatch.setattr(hwaccel, "_ffmpeg_identity", lambda: "b")
     hwaccel._save_cache({"h264:b": "h264_v4l2m2m"})    # v1-shaped entry
+    monkeypatch.setattr(hwaccel, "probe_decoder", lambda c: [])
+    hwaccel.warm_decoder_cache(("h264",)).join(timeout=30)
     assert hwaccel.cached_decoder("h264") is None
 
 
@@ -231,13 +245,18 @@ def test_no_verdict_leaves_ffmpeg_to_choose():
         sdp_path="/tmp/x.sdp", video_decoder=None)
 
 
-def test_cached_decoder_never_probes(monkeypatch):
-    """It runs on the event loop, so it must not shell out."""
+def test_cached_decoder_touches_neither_disk_nor_subprocess(monkeypatch):
+    """It runs on the event loop, so it must not shell out AND must not read a
+    file. Home Assistant detects a blocking open() on the loop and reports it as
+    a stability problem - it did, on a shipped release. The disk cache is read
+    by warm_decoder_cache() on its own thread instead."""
+    monkeypatch.setattr(hwaccel, "_load_cache",
+                        lambda: pytest.fail("must not read the cache file"))
     monkeypatch.setattr(hwaccel, "_try_decoder",
                         lambda cand, sample: pytest.fail("must not probe"))
     monkeypatch.setattr(hwaccel, "_make_sample",
                         lambda codec, path: pytest.fail("must not probe"))
-    assert hwaccel.cached_decoder("h264") is None  # empty cache, no probing
+    assert hwaccel.cached_decoder("h264") is None  # nothing memoised, no I/O
 
 
 # --------------------------------------------------------------------------- #
@@ -266,7 +285,7 @@ def test_software_is_not_timed_when_no_hardware_qualifies(monkeypatch):
 
     def _try(cand, sample):
         tried.append(tuple(cand))
-        return None                      # nothing decodes
+        return                           # nothing decodes here
 
     monkeypatch.setattr(hwaccel, "_try_decoder", _try)
     assert hwaccel.probe_decoder("h264") == []

python_aidot_cameras-0.15.2/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