python-aidot-cameras 0.17.3b2__tar.gz → 1.0.0b3__tar.gz

{python_aidot_cameras-0.17.3b2/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.17.3b2
+Version: 1.0.0b3
 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
@@ -209,6 +209,8 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_SKIP_TURN_PREALLOC` | Skip the SDES TURN relay pre-allocation (~2-3 s of cold-start latency) so signaling goes straight out with the host candidate. Faster on a LAN, at the cost of no relay fallback for a camera on a different segment / behind strict NAT. Experimental, opt-in (truthy = `1`/`true`/`yes`/`on`). | unset (off) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed. Truthy value enables. Ignored for battery cameras, where the fast path cannot win and its short grace truncates the cold start. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_SDES_VIDEO_PT` | Pin the SDES offer to ONE video codec by payload type, so the camera cannot choose. The offer advertises 96 (H264) and 97 (H265) and the camera decides which to send; on an A001064 that means the same request comes back h264 1280x720 most sessions and hevc 2560x1440 occasionally, at a third of the bitrate. Set to `96` for H264 only (measured h264 720p in 4 of 4 sessions). **Do not set it to `97`** - an H265-only offer returned no video at all in 3 of 3 rounds; narrowing to H265 removes the option rather than selecting it. | unset (both offered) |
+| `AIDOT_SDES_VIDEO_PT_ORDER` | Reorder the SDES offer's video codec list without narrowing it, as a comma-separated preference list (`97,96`). RFC 3264 makes the `m=video` payload-type list a preference list, most-preferred first, and ours has always read `96 97` - not by decision, it has simply never been varied. Whatever is named leads and the rest is appended, so this can express a preference and can never produce a narrowed or empty video m-line. **Experimental and untested on hardware:** whether the camera acts on the order is the open question, so the default is deliberately unchanged. | unset (`96 97`) |
 | `AIDOT_DTLS_FAST_LIVEPLAY` | The DTLS (A000088) analogue: skip the `livePlayReq`-echo and `livePlayResp` waits (the dominant LAN cold-start cost) while keeping the full ICE/TURN/DTLS handshake, so remote/relay viewing is unaffected. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soaks cut SDES NO_MEDIA from ~57% to ~11-19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Hold the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |

{python_aidot_cameras-0.17.3b2 → python_aidot_cameras-1.0.0b3}/README.md

@@ -178,6 +178,8 @@ audio, idle release, the sprop cache path) are documented in
 | `AIDOT_SDES_SKIP_TURN_PREALLOC` | Skip the SDES TURN relay pre-allocation (~2-3 s of cold-start latency) so signaling goes straight out with the host candidate. Faster on a LAN, at the cost of no relay fallback for a camera on a different segment / behind strict NAT. Experimental, opt-in (truthy = `1`/`true`/`yes`/`on`). | unset (off) |
 | `AIDOT_SDES_ADAPTIVE` | Adaptive fast-with-fallback for the SDES keepalive loop: try the fast path first and fall back to the full relay path if a fast attempt delivers no media. A per-device cache skips the fast attempt on later views once it has failed. Truthy value enables. Ignored for battery cameras, where the fast path cannot win and its short grace truncates the cold start. | unset (off) |
 | `AIDOT_SDES_FAST_LIVEPLAY` | Don't block on the `livePlayResp` wait for eligible SDES cameras (~4.5 s faster cold start). Role-reversal models (A001064 PTZ) always excluded for correctness. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
+| `AIDOT_SDES_VIDEO_PT` | Pin the SDES offer to ONE video codec by payload type, so the camera cannot choose. The offer advertises 96 (H264) and 97 (H265) and the camera decides which to send; on an A001064 that means the same request comes back h264 1280x720 most sessions and hevc 2560x1440 occasionally, at a third of the bitrate. Set to `96` for H264 only (measured h264 720p in 4 of 4 sessions). **Do not set it to `97`** - an H265-only offer returned no video at all in 3 of 3 rounds; narrowing to H265 removes the option rather than selecting it. | unset (both offered) |
+| `AIDOT_SDES_VIDEO_PT_ORDER` | Reorder the SDES offer's video codec list without narrowing it, as a comma-separated preference list (`97,96`). RFC 3264 makes the `m=video` payload-type list a preference list, most-preferred first, and ours has always read `96 97` - not by decision, it has simply never been varied. Whatever is named leads and the rest is appended, so this can express a preference and can never produce a narrowed or empty video m-line. **Experimental and untested on hardware:** whether the camera acts on the order is the open question, so the default is deliberately unchanged. | unset (`96 97`) |
 | `AIDOT_DTLS_FAST_LIVEPLAY` | The DTLS (A000088) analogue: skip the `livePlayReq`-echo and `livePlayResp` waits (the dominant LAN cold-start cost) while keeping the full ICE/TURN/DTLS handshake, so remote/relay viewing is unaffected. **On by default**; set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_PERSISTENT_MQTT` | Reuse ONE account-level persistent MQTT connection for commands, attribute fetches, and stream-open signaling (matching the official app) instead of connecting per operation. **On by default** (live soaks cut SDES NO_MEDIA from ~57% to ~11-19%); set to `0`/`false`/`no`/`off` to disable. | enabled (on) |
 | `AIDOT_SERVE_RELAY` | Hold the public stream port via an internal relay that proxies to ffmpeg, so the first (cold) view connects instead of failing while ffmpeg can't pre-bind the port. Set to `0` to serve ffmpeg directly. | `1` (enabled) |

{python_aidot_cameras-0.17.3b2 → python_aidot_cameras-1.0.0b3}/aidot_cameras/camera/client.py

@@ -1823,13 +1823,22 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                               self.device_id, len(data))
             elif isinstance(body, dict):
                 data = body.get("data") or {}
+                # Keys, never values: this response can carry the per-device
+                # streaming credentials (tutkAccount / tutkPassword - see
+                # docs/DEFERRED_FEATURES.md), and the warning below is logged
+                # at default level, so a whole-body dump lands in every user's
+                # home-assistant.log.  The matched-device log further down
+                # already prints keys only; these two did not.
                 if data:
-                    _LOGGER.debug("batchGetDeviceUserInfo response for %s (status=%d): %s",
-                                  self.device_id, status, body)
+                    _LOGGER.debug(
+                        "batchGetDeviceUserInfo response for %s (status=%d):"
+                        " keys=%s, %d item(s)",
+                        self.device_id, status, sorted(body.keys()), len(data),
+                    )
                 else:
                     _LOGGER.warning(
-                        "batchGetDeviceUserInfo no data for %s (status=%d): %s",
-                        self.device_id, status, body,
+                        "batchGetDeviceUserInfo no data for %s (status=%d): keys=%s",
+                        self.device_id, status, sorted(body.keys()),
                     )
             else:
                 data = {}
@@ -3468,6 +3477,22 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     rtsp_push_url=self._keepalive_rtsp_url,
                     timeout=(_FAST_OPEN_TIMEOUT if _use_fast else 120.0),
                     reuse_peer_id=_loop_peer_id,
+                    # Ask for talk so THIS session can carry it. async_speak
+                    # reuses _stream_session only when it is talk-capable, and
+                    # an SDES session that did not ask never gets a return audio
+                    # track - so without this every press-to-talk opened a
+                    # second camera session alongside the live view, and the
+                    # camera holds a viewer slot for about 120 s after one ends.
+                    #
+                    # This changes the SDP offer on the path every SDES live
+                    # view takes, which is the kind of change that has caused
+                    # fleet-wide blackouts here, so it rests on evidence rather
+                    # than reasoning: the release harness has opened all seven
+                    # cameras talk-capable across three fleet runs with no
+                    # streaming regression. The flag reaches only the offer
+                    # (audio sendrecv + a=ssrc) and the shared talk state; it
+                    # does not touch the rtsp_push branch this loop uses.
+                    talk=True,
                 )
             except asyncio.CancelledError:
                 self._fast_attempt_override = None

{python_aidot_cameras-0.17.3b2 → python_aidot_cameras-1.0.0b3}/aidot_cameras/camera/protocol.py

@@ -662,8 +662,14 @@ def _load_sprop(devid: str) -> "Optional[str]":
         return None
 
 
-def _save_sprop(devid: str, sprop: str) -> None:
-    """Persist the ``sprop-parameter-sets`` string for ``devid`` (best-effort).
+def _save_sprop(devid: str, sprop: str) -> bool:
+    """Persist the ``sprop-parameter-sets`` for ``devid``.  True if it wrote.
+
+    Returns whether anything was actually cached, because two of the three
+    outcomes here write nothing and the caller announces the write in the only
+    log line this feature has.  An unconditional announcement claims a cache
+    that an unstable camera provably does not have, which is the observable an
+    investigation reads first.
 
     If a DIFFERENT value was already cached, this camera does not keep its
     parameter sets stable: mark it and drop the cache, so nothing is injected
@@ -672,7 +678,7 @@ def _save_sprop(devid: str, sprop: str) -> None:
     loses nothing by the injection being skipped.
     """
     if _sprop_is_unstable(devid):
-        return          # already known unstable; nothing to cache for this camera
+        return False    # already known unstable; nothing to cache for this camera
     try:
         prev = _load_sprop(devid)
         if prev is not None and prev != sprop:
@@ -689,17 +695,19 @@ def _save_sprop(devid: str, sprop: str) -> None:
                 os.remove(_sprop_cache_path(devid))
             except OSError:
                 pass
-            return
+            return False
         os.makedirs(_SPROP_DIR, exist_ok=True)
         tmp = _sprop_cache_path(devid) + ".tmp"
         with open(tmp, "w") as fh:
             fh.write(sprop)
         os.replace(tmp, _sprop_cache_path(devid))
+        return True
     except OSError as exc:
         # Surface (don't swallow): if the cache dir isn't writable the whole
         # sprop feature is silently inert.  AIDOT_SPROP_DIR can redirect it.
         _LOGGER.warning("sprop cache write failed (%s): %s - set AIDOT_SPROP_DIR "
                         "to a writable path", _SPROP_DIR, exc)
+        return False
 
 
 def _inject_sprop(sdp: str, devid: str) -> str:

{python_aidot_cameras-0.17.3b2 → python_aidot_cameras-1.0.0b3}/aidot_cameras/camera/sdes.py

@@ -133,12 +133,19 @@ class SdesSession(AvioRequestMixin):
     def talk_supported(self) -> bool:
         """True if two-way audio can be used on this SDES session.
 
-        Requires a talk-capable open (offer advertised sendrecv + a=ssrc).  The
-        camera audio address is filled in by the bridge on first inbound audio;
-        async_start_talk tolerates being called before that - the pump waits for
-        the address before emitting.
+        Requires a talk-capable open (offer advertised sendrecv + a=ssrc) AND a
+        session that is still running.  The camera audio address is filled in by
+        the bridge on first inbound audio; async_start_talk tolerates being
+        called before that - the pump waits for the address before emitting.
+
+        Liveness is part of the answer because the talk state is a plain dict
+        that outlives ffmpeg, while everything that acts on it - the bridge
+        thread that sends SPEAKERSTART, the socket the pump writes to - dies
+        with ffmpeg.  ``async_speak`` reuses the warm session whenever this is
+        true, so answering from the dict alone routed talk into a session that
+        could no longer carry it instead of opening a fresh one.
         """
-        return bool(self._talk_state)
+        return bool(self._talk_state) and self.is_alive
 
     async def async_start_talk(
         self, pcm_provider: "Callable[[], Optional[bytes]]"
@@ -170,10 +177,23 @@ class SdesSession(AvioRequestMixin):
                 target=_run_sdes_talk_pump, args=(self._talk_state,), daemon=True
             )
             self._talk_thread.start()
-        if await _speaker_ack_accepted(waiter, SDES_SPEAKER_ACK_TIMEOUT_S):
+        accepted = await _speaker_ack_accepted(waiter, SDES_SPEAKER_ACK_TIMEOUT_S)
+        # _speaker_ack_accepted is generous by design: it treats an unfamiliar or
+        # absent ack as acceptance, because no genuine refusal has ever been
+        # identified and guessing at one would break working cameras.  That
+        # generosity is about INTERPRETING the camera's answer, and it has
+        # nothing to say about the case where the question was never asked.
+        # `speaker_on` is set on exactly one line - immediately after the bridge
+        # thread dispatches SPEAKERSTART(848) - so a falsy flag here means our
+        # own bridge never sent the command, which happens whenever ffmpeg (and
+        # with it that thread) has already exited.  The ack budget above already
+        # covers SDES_SPEAKERSTART_DELAY, so a live bridge has always set it by
+        # now and this cannot race a working session.
+        if accepted and self._talk_state.get("speaker_on"):
             return True
-        # The camera refused. Stop the microphone rather than stream viewer
-        # audio at a speaker that never opened.
+        # Either the camera refused, or the speaker command never left this
+        # process.  Stop the microphone rather than stream viewer audio at a
+        # speaker that never opened.
         self._talk_state["want_speaker"] = False
         self._talk_state["provider"] = None
         return False