pyibaby 0.1.0__py3-none-any.whl

pyibaby/__init__.py

@@ -0,0 +1,23 @@
+"""pyibaby - an open-source client library for iBaby monitor cameras.
+
+Reverse-engineered, vendor-cloud-optional access to iBaby (ThroughTek PPCS/PPPP)
+cameras: cloud login, P2P login-token generation, the LAN transport, the control
+channel (PTZ / two-way audio / media), and H.264 + G.711 media.
+"""
+
+from . import crypto, protocol, sensors
+from .client import LANCamera, iter_video_frames
+from .cloud import Camera, IBabyCloud
+from .sensors import SensorReading
+
+__all__ = [
+    "IBabyCloud",
+    "Camera",
+    "LANCamera",
+    "SensorReading",
+    "iter_video_frames",
+    "crypto",
+    "protocol",
+    "sensors",
+]
+__version__ = "0.1.0"

pyibaby/bridge.py

@@ -0,0 +1,224 @@
+"""Live media producer for stock go2rtc.
+
+Two output modes:
+
+* **default (video-only)** - writes a raw Annex-B H.264 elementary stream to
+  **stdout**, which go2rtc ingests directly as an ``exec:`` source (the same way
+  it ingests ``libcamera-vid``). No ffmpeg needed.
+* ``--audio`` **(video + audio)** - muxes H.264 (copy) + G.711->AAC into an
+  MPEG-TS stream on stdout using a bundled static ffmpeg. go2rtc reads it the
+  same way as the raw mode; use this when you want sound.
+
+Diagnostics go to stderr so they never corrupt stdout.
+
+Camera selection (credentials from the environment, never on the command line):
+
+* **direct** - ``IBABY_UID``, ``IBABY_CAMID``, ``IBABY_DEV_PASSWORD``
+* **cloud**  - ``IBABY_EMAIL`` + ``IBABY_PASSWORD`` (+ ``--camid`` to choose one)
+
+go2rtc examples (see ``examples/go2rtc.yaml``)::
+
+    nursery:    exec:python3 -m pyibaby.bridge#killsignal=15#restart
+    nursery-av: exec:python3 -m pyibaby.bridge --audio#killsignal=15#restart
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import queue
+import signal
+import subprocess
+import sys
+import threading
+import time
+
+from .client import LANCamera
+from .cloud import Camera, IBabyCloud
+
+
+def _log(*a) -> None:
+    print("[bridge]", *a, file=sys.stderr, flush=True)
+
+
+def resolve_camera(camid_arg: str | None) -> Camera:
+    uid = os.environ.get("IBABY_UID")
+    camid = os.environ.get("IBABY_CAMID")
+    dev_pw = os.environ.get("IBABY_DEV_PASSWORD")
+    if uid and camid and dev_pw:
+        return Camera(camid=camid, camname=camid, camtype="", p2p_uid=uid, p2p_provider="1", p2p_password=dev_pw)
+    email, password = os.environ.get("IBABY_EMAIL"), os.environ.get("IBABY_PASSWORD")
+    if not (email and password):
+        raise SystemExit("set IBABY_UID+IBABY_CAMID+IBABY_DEV_PASSWORD (direct) or IBABY_EMAIL+IBABY_PASSWORD (cloud)")
+    cameras = IBabyCloud().login(email, password)
+    if camid_arg:
+        return next(c for c in cameras if c.camid == camid_arg)
+    pppp = [c for c in cameras if c.is_pppp]
+    if not pppp:
+        raise SystemExit("no PPPP (provider != 0) camera in this account")
+    return pppp[0]
+
+
+def _run_stdout(cam: Camera, stop: dict) -> int:
+    frames = 0
+    out = sys.stdout.buffer
+
+    def on_video(_h, payload: bytes) -> None:
+        nonlocal frames
+        out.write(payload)
+        out.flush()
+        frames += 1
+
+    lan = LANCamera(cam)
+    try:
+        lan.connect()
+        _log("connected; streaming Annex-B H.264 to stdout")
+        lan.stream_video(on_video, should_stop=lambda: stop["flag"])
+    finally:
+        _close(lan)
+    return frames
+
+
+def _writer(q: queue.Queue, fd: int) -> None:
+    f = os.fdopen(fd, "wb")
+    try:
+        while True:
+            item = q.get()
+            if item is None:
+                break
+            f.write(item)
+            f.flush()
+    except (BrokenPipeError, OSError):
+        pass
+    finally:
+        try:
+            f.close()
+        except OSError:
+            pass
+
+
+def _run_audio(cam: Camera, stop: dict) -> int:
+    """Mux H.264 (copy) + G.711->AAC into MPEG-TS on stdout for a go2rtc exec source."""
+    import imageio_ffmpeg
+
+    ffmpeg = imageio_ffmpeg.get_ffmpeg_exe()
+    vr, vw = os.pipe()
+    ar, aw = os.pipe()
+    os.set_inheritable(vr, True)
+    os.set_inheritable(ar, True)
+    cmd = [
+        ffmpeg,
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-fflags",
+        "+genpts",
+        "-f",
+        "h264",
+        "-r",
+        "15",
+        "-i",
+        f"pipe:{vr}",
+        "-f",
+        "mulaw",
+        "-ar",
+        "8000",
+        "-ac",
+        "1",
+        "-i",
+        f"pipe:{ar}",
+        "-map",
+        "0:v:0",
+        "-map",
+        "1:a:0",
+        "-c:v",
+        "copy",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "64k",
+        "-f",
+        "mpegts",
+        "pipe:1",
+    ]
+    # ffmpeg writes MPEG-TS to fd 1 (the bridge's stdout, which go2rtc reads).
+    proc = subprocess.Popen(cmd, pass_fds=(vr, ar), stdin=subprocess.DEVNULL, stdout=sys.stdout.buffer.fileno())
+    os.close(vr)
+    os.close(ar)
+
+    vq: queue.Queue = queue.Queue(maxsize=300)
+    aq: queue.Queue = queue.Queue(maxsize=600)
+    threading.Thread(target=_writer, args=(vq, vw), daemon=True).start()
+    threading.Thread(target=_writer, args=(aq, aw), daemon=True).start()
+    n = {"v": 0, "a": 0}
+
+    def on_video(_h, payload: bytes) -> None:
+        n["v"] += 1
+        try:
+            vq.put_nowait(payload)
+        except queue.Full:
+            pass  # drop under backpressure rather than stall the network loop
+
+    def on_audio(_h, payload: bytes) -> None:
+        n["a"] += 1
+        try:
+            aq.put_nowait(payload)
+        except queue.Full:
+            pass
+
+    lan = LANCamera(cam)
+    try:
+        lan.connect()
+        _log("connected; muxing H.264 + AAC (MPEG-TS) to stdout")
+        lan.stream_media(on_video, on_audio, should_stop=lambda: stop["flag"] or proc.poll() is not None)
+    finally:
+        vq.put(None)
+        aq.put(None)
+        _close(lan)
+        try:
+            proc.terminate()
+            proc.wait(timeout=3)
+        except (subprocess.TimeoutExpired, OSError):
+            proc.kill()
+    return n["v"] + n["a"]
+
+
+def _close(lan: LANCamera) -> None:
+    try:
+        lan.close()
+    except OSError:
+        pass
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="iBaby -> go2rtc media bridge")
+    ap.add_argument("--audio", action="store_true", help="include audio (MPEG-TS H.264+AAC on stdout; needs ffmpeg)")
+    ap.add_argument("--camid", help="select a specific camera (cloud mode)")
+    ap.add_argument("--reconnect", action="store_true", help="auto-reconnect on failure")
+    args = ap.parse_args()
+
+    stop = {"flag": False}
+
+    def _stop(*_):
+        stop["flag"] = True
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        signal.signal(sig, _stop)
+
+    cam = resolve_camera(args.camid)
+    _log(f"camera {cam.camid} uid={cam.p2p_uid}")
+    while not stop["flag"]:
+        try:
+            count = _run_audio(cam, stop) if args.audio else _run_stdout(cam, stop)
+            _log(f"session ended ({count} frames)")
+        except (OSError, TimeoutError, ValueError) as e:
+            _log(f"error: {e!r}")
+        if not args.reconnect or stop["flag"]:
+            break
+        time.sleep(2)
+    _log("stopped")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyibaby/client.py

@@ -0,0 +1,192 @@
+"""High-level client: tie the cloud, the login token, and the PPPP transport
+together to reach a LAN camera, control it, and pull H.264 video."""
+
+from __future__ import annotations
+
+from . import crypto
+from . import protocol as P
+from .cloud import Camera
+from .pppp import PPPPConnection
+
+
+def iter_video_frames(conn: PPPPConnection):
+    """Yield (FrameHeader, payload) from the reassembled video channel."""
+    data = conn.reassemble(P.CH_VIDEO)
+    off = 0
+    while off + 16 <= len(data):
+        h = P.FrameHeader.parse(data[off : off + 16])
+        if h.codec not in P.VIDEO_CODECS or not 0 < h.size <= 800_000:
+            break
+        yield h, data[off + 16 : off + 16 + h.size]
+        off += 16 + h.size
+
+
+class LANCamera:
+    """A single camera reached over the local network (provider != 0 / PPPP)."""
+
+    def __init__(self, cam: Camera):
+        self.cam = cam
+        self.conn = PPPPConnection()
+
+    @property
+    def token(self) -> str:
+        return crypto.generate_p2p_token(self.cam.p2p_password, self.cam.camid)
+
+    def connect(self, peer: tuple[str, int] | None = None) -> LANCamera:
+        self.conn.connect(self.cam.p2p_uid, peer)
+        self.conn.send(P.CH_CMD, P.login_command(self.cam.p2p_uid, self.token))
+        self.conn.pump(1.0)
+        return self
+
+    def start_video(self, quality: str | None = None) -> None:
+        """Start the live video stream. If ``quality`` is given (a key of
+        ``protocol.STREAM_PRESETS``), set that profile first."""
+        if quality is not None:
+            self.set_quality(quality)
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_VIDEO_START))
+
+    def set_stream(self, resolution: int, bitrate: int, framerate: int) -> None:
+        """Set the live stream resolution/bitrate/framerate directly (cmd 273).
+
+        Wire-tested resolutions on M7: 1080->1920x1080, 720->1280x720, 640->640x368,
+        320->320x200; a literal 480 is clamped by the firmware to 720. The change
+        applies on the next keyframe and affects the camera's encoder globally."""
+        self.conn.send(P.CH_CMD, P.stream_config_command(resolution, bitrate, framerate))
+
+    def set_quality(self, preset: str) -> None:
+        """Switch the live stream to a named preset from ``protocol.STREAM_PRESETS``
+        (``1080p``, ``720p``, ``720p_eco``, ``360p``, ``tiny``)."""
+        res, bitrate, framerate = P.STREAM_PRESETS[preset]
+        self.set_stream(res, bitrate, framerate)
+
+    def stream_video(self, on_frame, *, should_stop=None) -> None:
+        """Stream live video frames to ``on_frame(FrameHeader, payload)`` until stopped."""
+        self.start_video()
+        self.conn.stream(on_frame, should_stop=should_stop)
+
+    def start_audio(self) -> None:
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_AUDIO_START))
+
+    def stream_media(self, on_video, on_audio, *, should_stop=None) -> None:
+        """Stream live video and audio frames until stopped (starts both channels)."""
+        self.start_video()
+        self.start_audio()
+        self.conn.stream(on_video, on_audio=on_audio, should_stop=should_stop)
+
+    def stop_video(self) -> None:
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_VIDEO_STOP))
+
+    def stop_audio(self) -> None:
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_AUDIO_STOP))
+
+    def ptz(self, direction: int) -> None:
+        self.conn.send(P.CH_CMD, P.ptz_command(direction))
+
+    def read_sensors(self, timeout: float = 8.0):
+        """Return the camera's latest environment reading (temp/humidity/CO2/VOC) or None."""
+        from .sensors import SensorReading
+
+        tags = self.conn.read_userdata(timeout)
+        return SensorReading.from_tags(tags) if tags else None
+
+    def start_talk(self) -> None:
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_TALK_START))
+
+    def stop_talk(self) -> None:
+        self.conn.send(P.CH_CMD, P.media_command(P.MEDIA_TALK_STOP))
+
+    def talk(self, g711_ulaw: bytes, *, frame_size: int = 160, pace: float = 0.02) -> None:
+        """Play G.711 u-law audio (8 kHz mono) through the camera speaker (talk-back)."""
+        import time
+
+        self.start_talk()
+        sock = self.conn.sock
+        sock.setblocking(False)
+        ts = 0
+        next_t = time.time()
+        try:
+            for i in range(0, len(g711_ulaw), frame_size):
+                chunk = g711_ulaw[i : i + frame_size].ljust(frame_size, b"\xff")  # 0xFF = u-law silence
+                self.conn.send(P.CH_TALK, P.audio_frame(chunk, ts), reliable=False)
+                ts += frame_size
+                try:  # service keepalives so the camera doesn't drop us mid-clip
+                    while True:
+                        data, _ = sock.recvfrom(2048)
+                        t, _ch, _idx, _pl = P.parse(data)
+                        if t == P.MSG_ALIVE:
+                            sock.sendto(P.pppp(P.MSG_ALIVE_ACK), self.conn.peer)
+                except (BlockingIOError, OSError):
+                    pass
+                next_t += pace
+                delay = next_t - time.time()
+                if delay > 0:
+                    time.sleep(delay)
+        finally:
+            sock.setblocking(True)
+            sock.settimeout(0.3)
+            self.stop_talk()
+
+    def moonlight(self, on: bool = True, minutes: int = 15) -> None:
+        """Projector lamp (stars + moon) on/off. The app hardcodes a 15-min auto-off
+        timer (openTime=900); ``minutes`` lets you try other values."""
+        self.conn.send(P.CH_CMD, P.moonlight_command(1 if on else 0, 0, 0, open_time=minutes * 60))
+
+    def music_light(self, on: bool = True, minutes: int = 15) -> None:
+        """Projector lamp plus a PTZ sweep (the app's 'music light'); plays no audio itself."""
+        self.conn.send(P.CH_CMD, P.moonlight_command(1 if on else 0, 0, 1 if on else 0, open_time=minutes * 60))
+
+    def privacy_mode(self, on: bool = True) -> None:
+        """Privacy mode: point the camera down (on) or restore it (off)."""
+        self.ptz(P.PTZ_PRIVACY_ON if on else P.PTZ_PRIVACY_OFF)
+
+    def play_music(
+        self,
+        track: dict | None = None,
+        *,
+        url: str | None = None,
+        track_id: int = 0,
+        playlist_id: int = 0,
+        album_id: int = 0,
+        mode: int = P.VMODE_SINGLE,
+    ) -> None:
+        """Play a built-in sound on the camera's speaker.
+
+        Pass a ``track`` dict from ``IBabyCloud.music_list()`` (preferred) - it carries
+        the camera-fetchable URL, track id, and category ``playlist_id``. Otherwise
+        pass ``url`` explicitly; it must be the plain-http S3 form
+        (``protocol.to_camera_url()``) - the CloudFront/https URL the cloud returns will
+        not play. ``mode``: 1=single, 2=single-loop, 3=sequence, 4=random.
+        """
+        if track is not None:
+            url = track.get("camera_url") or P.to_camera_url(track.get("url") or "")
+            track_id = track.get("id") or track_id
+            playlist_id = track.get("playlist_id", playlist_id)
+        self.conn.send(
+            P.CH_CMD,
+            P.play_music_v2_command(
+                url=url or "",
+                track_id=track_id or 0,
+                album_id=album_id,
+                control=P.VMUSIC_PLAY,
+                mode=mode,
+                play_list_id=playlist_id,
+            ),
+        )
+
+    def pause_music(self) -> None:
+        self.conn.send(P.CH_CMD, P.play_music_v2_command(control=P.VMUSIC_PAUSE))
+
+    def stop_music(self) -> None:
+        self.conn.send(P.CH_CMD, P.play_music_v2_command(control=P.VMUSIC_STOP))
+
+    def next_music(self) -> None:
+        self.conn.send(P.CH_CMD, P.play_music_v2_command(control=P.VMUSIC_NEXT))
+
+    def pump(self, seconds: float) -> None:
+        self.conn.pump(seconds)
+
+    def video_bitstream(self) -> bytes:
+        return b"".join(frame for _, frame in iter_video_frames(self.conn))
+
+    def close(self) -> None:
+        self.conn.close()

pyibaby/cloud.py

@@ -0,0 +1,150 @@
+"""iBaby cloud API client (aapiibc.ibabycloud.com), reverse-engineered.
+
+Flow, all over HTTPS with ``application/x-www-form-urlencoded`` bodies of the
+form ``uuid=<plaintext>&data=<rncryptor-b64>``:
+
+1. ``index/get-secret-key`` (encrypted under the fixed bootstrap key) returns a
+   per-session ``secret_key``; the session AES password is ``secret_key[2:10]``
+   and the returned ``uuid`` is echoed on every later request.
+2. ``user/login`` returns ``auth_key`` plus the ``camera_list`` device array.
+
+Validated against the live global endpoint. Only read operations are used here.
+"""
+
+from __future__ import annotations
+
+import base64
+import gzip
+import json
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+
+from . import crypto
+from . import protocol as P
+
+GLOBAL_BASE = "https://aapiibc.ibabycloud.com"
+CN_BASE = "https://cn.ibabycloud.com"
+APP_ID = "45615cf6-09cf-11e5-8dc5-12314305"
+
+# Built-in music categories (IBabyMediaCore TYPE_*). "Generation" (age playlists)
+# and "Favorites" (user playlists) use separate APIs and are not covered here.
+MUSIC_CATEGORIES = {"lullabies": "1", "stories": "2", "white_noise": "3", "nature": "4", "songs": "10"}
+
+_HEADERS = {
+    "charset": "utf-8",
+    "x-ibl-appversion": "2.14.5",
+    "accept-language": "en_CA",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "Accept-Encoding": "gzip",
+    "User-Agent": "okhttp/4.3.1",
+    "http_user_agent": "iBabyCare/2.14.5 (Linux; pyibaby)",
+}
+
+
+@dataclass
+class Camera:
+    camid: str
+    camname: str
+    camtype: str
+    p2p_uid: str
+    p2p_provider: str
+    p2p_password: str  # decrypted, ready for generate_p2p_token / avClientStart
+    firmware_version: str = ""
+    init_string: str = ""
+
+    @property
+    def is_pppp(self) -> bool:
+        """provider != 0 -> ThroughTek PPCS/PPPP (the M6S/M7 family handled here)."""
+        return str(self.p2p_provider) != "0"
+
+
+class CloudError(RuntimeError):
+    pass
+
+
+class IBabyCloud:
+    def __init__(self, base: str = GLOBAL_BASE, timeout: int = 30):
+        self.base = base
+        self.timeout = timeout
+        self._session_key: str | None = None
+        self._uuid: str = ""
+        self.auth_key: str | None = None
+
+    def _post(self, path: str, payload: dict, key: str) -> dict:
+        data = crypto.rncryptor_encrypt(json.dumps(payload).encode(), key, 2)
+        body = urllib.parse.urlencode({"uuid": self._uuid, "data": base64.b64encode(data).decode()}).encode()
+        req = urllib.request.Request(self.base + path, data=body, headers=_HEADERS, method="POST")
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            raw = resp.read()
+            if resp.headers.get("Content-Encoding") == "gzip":
+                raw = gzip.decompress(raw)
+        env = json.loads(raw.decode("utf-8", "replace"))
+        if env.get("status") != 0:
+            raise CloudError(f"{path}: status={env.get('status')} msg={env.get('msg')!r}")
+        return json.loads(crypto.rncryptor_decrypt(base64.b64decode(env["data"]), key, 2))
+
+    def get_secret_key(self) -> None:
+        out = self._post("/ibabycare/index/get-secret-key", {"appid": APP_ID, "uuid": ""}, crypto.BOOTSTRAP_KEY)
+        self._session_key = out["secret_key"][2:10]
+        self._uuid = out["uuid"]
+
+    def login(self, email: str, password: str) -> list[Camera]:
+        if self._session_key is None:
+            self.get_secret_key()
+        out = self._post(
+            "/ibabycare/user/login",
+            {"email": email, "password": crypto.login_password(password)},
+            self._session_key,
+        )
+        self.auth_key = out.get("auth_key")
+        return [self._camera(c) for c in out.get("camera_list", [])]
+
+    def music_list(self, category: str = "lullabies") -> list[dict]:
+        """Built-in sounds for a category - name or numeric type:
+        lullabies=1, stories=2, white_noise=3, nature=4, songs=10.
+
+        Returns ``[{id, name, url, camera_url, play_time, type, playlist_id}, ...]``.
+        ``url`` is the CloudFront/https link (for display); ``camera_url`` is the
+        plain-http S3 form the camera actually fetches. ``playlist_id`` is the
+        category's pseudo-playlist id (negated cloud type) to pass to ``play_music``.
+        """
+        if self._session_key is None or self.auth_key is None:
+            raise CloudError("must login() before fetching the music list")
+        ctype = str(MUSIC_CATEGORIES.get(category, category))
+        out = self._post(
+            "/ibabycare/music/get-built-in-music-list",
+            {"auth_key": self.auth_key, "type": ctype},
+            self._session_key,
+        )
+        type_num = int(ctype) if ctype.lstrip("-").isdigit() else None
+        playlist_id = -type_num if type_num is not None else 0
+        tracks = []
+        for item in out.get("list", []):
+            media = item.get("media") or {}
+            cloud_url = media.get("url")
+            tracks.append(
+                {
+                    "id": item.get("id"),
+                    "name": item.get("media_name"),
+                    "url": cloud_url,
+                    "camera_url": P.to_camera_url(cloud_url) if cloud_url else None,
+                    "play_time": item.get("play_time"),
+                    "type": type_num,
+                    "playlist_id": playlist_id,
+                }
+            )
+        return tracks
+
+    @staticmethod
+    def _camera(c: dict) -> Camera:
+        return Camera(
+            camid=c.get("camid", ""),
+            camname=c.get("camname", ""),
+            camtype=c.get("camtype", ""),
+            p2p_uid=c.get("p2p_uid", ""),
+            p2p_provider=str(c.get("p2p_provider", "")),
+            p2p_password=crypto.decrypt_p2p_password(c["p2p_new_password"]) if c.get("p2p_new_password") else "",
+            firmware_version=c.get("firmware_version", ""),
+            init_string=c.get("init_string", ""),
+        )