OctoPrint-BitBang 0.1.2__py3-none-any.whl

octoprint_bitbang/__init__.py

@@ -0,0 +1,499 @@
+"""OctoPrint-BitBang plugin.
+
+Remote OctoPrint access with live H.264 video via BitBang WebRTC.
+No account, no subscription, no port forwarding. One shareable link.
+"""
+
+__plugin_name__ = "BitBang"
+__plugin_version__ = "0.1.2"
+__plugin_description__ = "Remote OctoPrint access with live H.264 video via BitBang WebRTC. No account, no port forwarding, one shareable link."
+__plugin_url__ = "https://github.com/richlegrand/OctoPrint-BitBang"
+__plugin_author__ = "Rich LeGrand"
+__plugin_license__ = "MIT"
+__plugin_privacypolicy__ = "https://github.com/richlegrand/OctoPrint-BitBang/blob/main/PRIVACY.md"
+__plugin_pythoncompat__ = ">=3.10,<4"
+
+try:
+    import threading
+    import octoprint.plugin
+
+    from bitbang.proxy import ReverseProxyASGI
+    from .octoprint_adapter import OctoPrintBitBang
+    from .camera import detect_camera
+
+    import flask
+    import asyncio
+    from aiortc import RTCPeerConnection, RTCSessionDescription
+    from aiortc.contrib.media import MediaRelay
+
+    from octoprint.schema.webcam import Webcam, WebcamCompatibility
+
+    class BitBangPlugin(
+        octoprint.plugin.StartupPlugin,
+        octoprint.plugin.ShutdownPlugin,
+        octoprint.plugin.SettingsPlugin,
+        octoprint.plugin.TemplatePlugin,
+        octoprint.plugin.AssetPlugin,
+        octoprint.plugin.BlueprintPlugin,
+        octoprint.plugin.WebcamProviderPlugin,
+    ):
+        def __init__(self):
+            super().__init__()
+            self._adapter = None
+            self._thread = None
+            self._local_pcs = set()  # track local WebRTC peer connections
+
+        def on_after_startup(self):
+            self._probe_picamera2_sensor()
+            if not self._settings.get_boolean(["enabled"]):
+                self._logger.info("BitBang disabled in settings")
+                return
+            self._start_bitbang()
+
+        def _probe_picamera2_sensor(self):
+            # Cache before the adapter opens the camera — picamera2 can't be
+            # opened twice, so the resolutions endpoint relies on this.
+            self._picam2_sensor_size = None
+            try:
+                from picamera2 import Picamera2
+                cam = Picamera2()
+                self._picam2_sensor_size = cam.sensor_resolution
+                cam.close()
+            except Exception:
+                pass
+
+        def _start_bitbang(self):
+            port = self._settings.global_get(["server", "port"]) or 5000
+            proxy_app = ReverseProxyASGI(f"localhost:{port}")
+
+            # Use configured camera or auto-detect
+            camera_device = self._settings.get(["camera_device"])
+            camera_resolution = self._settings.get(["camera_resolution"]) or "640x480"
+
+            flip_h = self._settings.get_boolean(["flip_horizontal"])
+            flip_v = self._settings.get_boolean(["flip_vertical"])
+
+            brightness = self._settings.get_int(["brightness"]) or 0
+
+            if camera_device == "picamera2":
+                w, h = (int(x) for x in camera_resolution.split("x"))
+                camera = {
+                    "type": "picamera2",
+                    "size": (w, h),
+                    "flip_horizontal": flip_h,
+                    "flip_vertical": flip_v,
+                    "brightness": brightness,
+                }
+                self._logger.info(f"Camera: picamera2 at {camera_resolution}")
+            elif camera_device:
+                camera = {
+                    "type": "usb",
+                    "device": camera_device,
+                    "format": "v4l2",
+                    "options": {"framerate": "30", "video_size": camera_resolution},
+                    "flip_horizontal": flip_h,
+                    "flip_vertical": flip_v,
+                    "brightness": brightness,
+                }
+                self._logger.info(f"Camera: {camera_device} at {camera_resolution}")
+            else:
+                camera = detect_camera(logger=self._logger)
+                if camera:
+                    camera["flip_horizontal"] = flip_h
+                    camera["flip_vertical"] = flip_v
+                    camera["brightness"] = brightness
+                    if camera["type"] == "picamera2":
+                        w, h = (int(x) for x in camera_resolution.split("x"))
+                        camera["size"] = (w, h)
+                    else:
+                        camera.setdefault("options", {})["video_size"] = camera_resolution
+                    self._logger.info(f"Camera: {camera['type']} at {camera_resolution}")
+                else:
+                    self._logger.info("No camera detected, HTTP-only mode")
+
+            pin = self._settings.get(["pin"]) or None
+
+            self._adapter = OctoPrintBitBang(
+                proxy_app,
+                camera_source=camera,
+                ws_target=f"localhost:{port}",
+                program_name="octoprint",
+                pin=pin,
+            )
+
+            # Route the adapter's connection-request event into OctoPrint's
+            # structured logger so the connecting browser IP shows up in
+            # octoprint.log (and any plugin-log filter) rather than only
+            # appearing in stdout/journald.
+            @self._adapter.on_connection_request
+            def _log_connection_request(client_id, browser_ip):
+                self._logger.info(
+                    f"Connection request from {client_id} (browser_ip={browser_ip})"
+                )
+
+            self._thread = threading.Thread(
+                target=self._adapter.run,
+                daemon=True,
+                name="BitBangThread",
+            )
+            self._thread.start()
+
+            url = self._adapter.url
+            self._settings.set(["url"], url)
+            self._settings.save()
+            self._logger.info(f"BitBang remote access: {url}")
+
+        # -- Local WebRTC video signaling --
+
+        @octoprint.plugin.BlueprintPlugin.route("/ice-servers", methods=["GET"])
+        def get_ice_servers(self):
+            """Return TURN/STUN servers for local video WebRTC."""
+            servers = self._adapter.get_ice_servers() if self._adapter else []
+            return flask.jsonify(servers)
+
+        @octoprint.plugin.BlueprintPlugin.route("/offer", methods=["POST"])
+        @octoprint.plugin.BlueprintPlugin.csrf_exempt()
+        def local_offer(self):
+            """Exchange WebRTC SDP for local H.264 video streaming."""
+            if not self._adapter or not self._adapter.player or not self._adapter.player.video:
+                return flask.jsonify({"error": "no camera"}), 503
+
+            offer_sdp = flask.request.json.get("sdp")
+            offer_type = flask.request.json.get("type", "offer")
+            if not offer_sdp:
+                return flask.jsonify({"error": "missing sdp"}), 400
+
+            # Run the async WebRTC handshake in the adapter's event loop
+            loop = self._adapter._loop
+            if not loop:
+                return flask.jsonify({"error": "not ready"}), 503
+
+            ice_servers = self._adapter.get_ice_servers()
+
+            future = asyncio.run_coroutine_threadsafe(
+                self._handle_local_offer(offer_sdp, offer_type, ice_servers), loop
+            )
+            try:
+                answer = future.result(timeout=10)
+                answer['ice_servers'] = ice_servers
+                return flask.jsonify(answer)
+            except Exception as e:
+                self._logger.error(f"Local WebRTC offer failed: {e}")
+                return flask.jsonify({"error": str(e)}), 500
+
+        def _strip_non_h264(self, sdp):
+            """Remove non-H.264 video codecs from an SDP so aiortc has no
+            choice but to negotiate H.264 (our track is pre-encoded H.264)."""
+            import re
+            lines = sdp.split("\r\n")
+            h264_pts = [m.group(1) for m in (re.match(r"a=rtpmap:(\d+) H264/", l) for l in lines) if m]
+            rtx_pts = [m.group(1) for m in (re.match(r"a=fmtp:(\d+) apt=(\d+)", l) for l in lines) if m and m.group(2) in h264_pts]
+            keep = set(h264_pts) | set(rtx_pts)
+            out = []
+            for line in lines:
+                m = re.match(r"(m=video \d+ \S+) (.+)", line)
+                if m:
+                    header, pts = m.groups()
+                    kept = [p for p in pts.split() if p in keep]
+                    out.append(f"{header} {' '.join(kept)}")
+                    continue
+                m = re.match(r"a=(rtpmap|fmtp|rtcp-fb):(\d+)", line)
+                if m and m.group(2) not in keep:
+                    continue
+                out.append(line)
+            return "\r\n".join(out)
+
+        async def _handle_local_offer(self, offer_sdp, offer_type, ice_servers=None):
+            offer_sdp = self._strip_non_h264(offer_sdp)
+            config = self._adapter._build_rtc_config(ice_servers) if ice_servers else None
+            pc = RTCPeerConnection(config) if config else RTCPeerConnection()
+            self._local_pcs.add(pc)
+
+            @pc.on("connectionstatechange")
+            async def on_state():
+                if pc.connectionState in ("failed", "closed"):
+                    self._local_pcs.discard(pc)
+                    await pc.close()
+
+            # Order matters: set remote description first so aiortc creates
+            # the transceiver matching the client's mid. Then addTrack reuses
+            # it and setCodecPreferences applies to the right one. Otherwise
+            # the answer ends up negotiating VP8.
+            offer = RTCSessionDescription(sdp=offer_sdp, type=offer_type)
+            await pc.setRemoteDescription(offer)
+
+            sender = pc.addTrack(self._adapter.relay.subscribe(self._adapter.player.video))
+
+            from .octoprint_adapter import force_h264
+            force_h264(pc, sender)
+
+            answer = await pc.createAnswer()
+            await pc.setLocalDescription(answer)
+
+            return {
+                "sdp": pc.localDescription.sdp,
+                "type": pc.localDescription.type,
+            }
+
+        # -- Camera settings API --
+
+        @octoprint.plugin.BlueprintPlugin.route("/camera/config", methods=["GET"])
+        def camera_config(self):
+            """Return current camera display / tuning config for the client."""
+            return flask.jsonify({
+                "flip_horizontal": bool(self._settings.get_boolean(["flip_horizontal"])),
+                "flip_vertical": bool(self._settings.get_boolean(["flip_vertical"])),
+                "brightness": self._settings.get_int(["brightness"]) or 0,
+            })
+
+        @octoprint.plugin.BlueprintPlugin.route("/camera/brightness", methods=["POST"])
+        @octoprint.plugin.BlueprintPlugin.csrf_exempt()
+        def set_brightness(self):
+            """Update camera brightness live. Accepts {"value": int -100..100}."""
+            try:
+                value = int(flask.request.json.get("value"))
+            except (TypeError, ValueError, AttributeError):
+                return flask.jsonify({"error": "missing or invalid value"}), 400
+            value = max(-100, min(100, value))
+
+            player = self._adapter.player if self._adapter else None
+            if player is None or not hasattr(player, "set_brightness"):
+                return flask.jsonify({"error": "brightness not supported on this camera"}), 400
+
+            if player.set_brightness(value) is False:
+                return flask.jsonify({"error": "brightness not supported on this camera"}), 400
+            self._settings.set_int(["brightness"], value)
+            self._settings.save()
+            return flask.jsonify({"value": value})
+
+        @octoprint.plugin.BlueprintPlugin.route("/cameras", methods=["GET"])
+        def list_cameras(self):
+            """List available video capture devices."""
+            import subprocess
+            cameras = []
+            # Pi CSI camera surfaces through picamera2/libcamera, not v4l2-ctl
+            if getattr(self, "_picam2_sensor_size", None):
+                cameras.append({"device": "picamera2", "name": "Pi CSI camera"})
+            try:
+                result = subprocess.run(
+                    ["v4l2-ctl", "--list-devices"],
+                    capture_output=True, text=True, timeout=5
+                )
+                current_name = None
+                for line in result.stdout.splitlines():
+                    if not line.startswith("\t"):
+                        current_name = line.strip().rstrip(":")
+                    elif "/dev/video" in line:
+                        dev = line.strip()
+                        # Only include devices that have video formats
+                        # (filters out metadata-only nodes like /dev/video1)
+                        if self._has_video_formats(dev):
+                            cameras.append({"device": dev, "name": current_name or dev})
+            except Exception as e:
+                self._logger.warning(f"Failed to list cameras: {e}")
+            return flask.jsonify(cameras)
+
+        @octoprint.plugin.BlueprintPlugin.route("/resolutions", methods=["GET"])
+        def list_resolutions(self):
+            """List supported resolutions for a camera device."""
+            import subprocess
+            device = flask.request.args.get("device", "")
+            # picamera2: explicit Pi CSI selection or auto-detect when present
+            if device == "picamera2" or not device:
+                picam_res = self._picamera2_resolutions()
+                if picam_res is not None:
+                    return flask.jsonify(picam_res)
+                if device == "picamera2":
+                    return flask.jsonify([])
+                device = "/dev/video0"
+            resolutions = []
+            try:
+                result = subprocess.run(
+                    ["v4l2-ctl", "--list-formats-ext", "-d", device],
+                    capture_output=True, text=True, timeout=5
+                )
+                seen = set()
+                for line in result.stdout.splitlines():
+                    line = line.strip()
+                    if line.startswith("Size: Discrete"):
+                        res = line.split("Discrete")[1].strip()
+                        if res in seen:
+                            continue
+                        seen.add(res)
+                        try:
+                            if int(res.split("x")[0]) > 1280:
+                                continue
+                        except ValueError:
+                            continue
+                        resolutions.append(res)
+            except Exception as e:
+                self._logger.warning(f"Failed to list resolutions: {e}")
+            # Sort by width
+            resolutions.sort(key=lambda r: int(r.split("x")[0]))
+            return flask.jsonify(resolutions)
+
+        # Standard resolutions offered for Pi CSI cameras, filtered by sensor
+        # max. Mix of 4:3 and 16:9 so users can pick their preferred ratio.
+        _PICAMERA2_STANDARD_RESOLUTIONS = [
+            (640, 480), (800, 600),
+            (1280, 720), (1280, 960),
+        ]
+
+        def _picamera2_resolutions(self):
+            """Return list of supported resolutions for the Pi CSI sensor, or None."""
+            sensor = getattr(self, "_picam2_sensor_size", None)
+            if not sensor:
+                return None
+            max_w, max_h = sensor
+            return [
+                f"{w}x{h}"
+                for (w, h) in self._PICAMERA2_STANDARD_RESOLUTIONS
+                if w <= max_w and h <= max_h
+            ]
+
+        def _has_video_formats(self, device):
+            """Check if a V4L2 device has any video capture formats."""
+            import subprocess
+            try:
+                result = subprocess.run(
+                    ["v4l2-ctl", "--list-formats-ext", "-d", device],
+                    capture_output=True, text=True, timeout=5
+                )
+                return "Size: Discrete" in result.stdout
+            except Exception:
+                return False
+
+        # -- WebcamProviderPlugin API --
+
+        def get_webcam_configurations(self):
+            return [
+                Webcam(
+                    name="bitbang",
+                    displayName="BitBang Camera",
+                    canSnapshot=True,
+                    snapshotDisplay="BitBang plugin captures snapshot from video stream",
+                )
+            ]
+
+        def take_webcam_snapshot(self, webcamName):
+            """Grab a frame from the video track and return JPEG bytes."""
+            from octoprint.webcams import WebcamNotAbleToTakeSnapshotException
+
+            if not self._adapter or not self._adapter.player or not self._adapter.player.video:
+                raise WebcamNotAbleToTakeSnapshotException(webcamName)
+
+            player = self._adapter.player
+            try:
+                # Pi CSI: grab directly via picamera2 (no H.264 decode) so we
+                # stay within the Pi 4 CPU budget. USB falls through to the
+                # relay-based decoded-frame path.
+                if hasattr(player, "capture_snapshot"):
+                    return iter([player.capture_snapshot()])
+
+                loop = self._adapter._loop
+                if not loop:
+                    raise WebcamNotAbleToTakeSnapshotException(webcamName)
+                future = asyncio.run_coroutine_threadsafe(self._capture_frame(), loop)
+                return iter([future.result(timeout=5)])
+            except WebcamNotAbleToTakeSnapshotException:
+                raise
+            except Exception as e:
+                self._logger.error(f"Snapshot failed: {e}")
+                raise WebcamNotAbleToTakeSnapshotException(webcamName)
+
+        async def _capture_frame(self):
+            """Grab one frame from the video relay and encode as JPEG."""
+            import io as _io
+            import av as _av
+
+            # Subscribe to the relay to get a frame without
+            # stealing from existing WebRTC consumers
+            track = self._adapter.relay.subscribe(self._adapter.player.video)
+            try:
+                frame = await track.recv()
+            finally:
+                track.stop()
+
+            # CRITICAL: copy the raw plane data immediately. The relay
+            # shares frame buffers with the encoder -- any sws_scale call
+            # (to_ndarray, to_image, reformat) will segfault if the encoder
+            # is concurrently accessing the same buffer.
+            planes_data = [bytes(frame.planes[i]) for i in range(len(frame.planes))]
+            width, height = frame.width, frame.height
+            fmt = frame.format.name
+
+            # Build a new independent frame from the copied data
+            new_frame = _av.VideoFrame(width, height, fmt)
+            for i, data in enumerate(planes_data):
+                new_frame.planes[i].update(data)
+
+            # Now safe to convert -- this frame's buffer is ours alone
+            buf = _io.BytesIO()
+            new_frame.to_image().save(buf, format="JPEG", quality=85)
+            return buf.getvalue()
+
+        def on_shutdown(self):
+            pass  # Daemon thread exits with OctoPrint
+
+        def get_settings_defaults(self):
+            return {
+                "enabled": True,
+                "pin": "",
+                "url": "",
+                "camera_device": "",
+                "camera_resolution": "640x480",
+                "flip_horizontal": False,
+                "flip_vertical": False,
+                "brightness": 0,
+            }
+
+        def get_template_configs(self):
+            return [
+                {"type": "settings", "custom_bindings": False},
+                {"type": "navbar", "custom_bindings": False},
+            ]
+
+        def get_template_vars(self):
+            return {"plugin_version": __plugin_version__}
+
+        def get_assets(self):
+            return {
+                "js": ["js/bitbang.js"],
+            }
+
+        def is_blueprint_csrf_protected(self):
+            return True
+
+        def is_template_autoescaped(self):
+            return True
+
+    __plugin_implementation__ = BitBangPlugin()
+
+    def __plugin_check__():
+        return True
+
+    def _get_update_information():
+        return {
+            "bitbang": {
+                "displayName": __plugin_name__,
+                "displayVersion": __plugin_version__,
+                "type": "github_release",
+                "user": "richlegrand",
+                "repo": "OctoPrint-BitBang",
+                "current": __plugin_version__,
+                "stable_branch": {
+                    "name": "Stable",
+                    "branch": "main",
+                    "commitish": ["main"],
+                },
+                "pip": "https://github.com/richlegrand/OctoPrint-BitBang/archive/{target_version}.zip",
+            }
+        }
+
+    __plugin_hooks__ = {
+        "octoprint.plugin.softwareupdate.check_config": _get_update_information,
+    }
+
+except ImportError:
+    # OctoPrint not installed - standalone CLI mode
+    pass

octoprint_bitbang/__main__.py

@@ -0,0 +1,2 @@
+from octoprint_bitbang.app import main
+main()

octoprint_bitbang/app.py

@@ -0,0 +1,86 @@
+"""OctoPrint BitBang prototype - test app for video + HTTP tunnel.
+
+Run with:
+    python -m octoprint_bitbang.app
+    python -m octoprint_bitbang.app --proxy localhost:5000
+    python -m octoprint_bitbang.app --proxy localhost:8080 --camera /dev/video2
+"""
+
+from .octoprint_adapter import OctoPrintBitBang
+import os
+
+
+def _make_test_app():
+    """Create a simple ASGI test app serving the prototype HTML page."""
+    _dir = os.path.dirname(__file__)
+
+    async def test_app(scope, receive, send):
+        if scope["type"] != "http":
+            return
+        path = scope.get("path", "/")
+
+        if path == "/favicon.ico":
+            favicon_path = os.path.join(_dir, "static", "favicon.png")
+            try:
+                with open(favicon_path, "rb") as f:
+                    body = f.read()
+                await send({"type": "http.response.start", "status": 200,
+                            "headers": [(b"content-type", b"image/png")]})
+                await send({"type": "http.response.body", "body": body})
+            except FileNotFoundError:
+                await send({"type": "http.response.start", "status": 404, "headers": []})
+                await send({"type": "http.response.body", "body": b""})
+            return
+
+        # Serve index.html for everything else
+        html_path = os.path.join(_dir, "index.html")
+        with open(html_path, "rb") as f:
+            body = f.read()
+        await send({"type": "http.response.start", "status": 200,
+                    "headers": [(b"content-type", b"text/html")]})
+        await send({"type": "http.response.body", "body": body})
+
+    return test_app
+
+
+def main():
+    import argparse
+    from bitbang.adapter import add_bitbang_args, bitbang_kwargs
+
+    parser = argparse.ArgumentParser(description='OctoPrint via BitBang')
+    add_bitbang_args(parser)
+    parser.add_argument('--proxy',
+                        help='Local server to proxy (e.g. localhost:5000)')
+    parser.add_argument('--camera',
+                        help='Camera source override (e.g. /dev/video0)')
+    args = parser.parse_args()
+
+    ws_target = None
+    if args.proxy:
+        from bitbang.proxy import ReverseProxyASGI
+        asgi_app = ReverseProxyASGI(args.proxy)
+        ws_target = args.proxy
+        print(f"Proxying to {args.proxy}")
+    else:
+        asgi_app = _make_test_app()
+
+    camera_source = None
+    if args.camera:
+        camera_source = {
+            "type": "usb",
+            "device": args.camera,
+            "format": "v4l2",
+            "options": {"framerate": "30", "video_size": "640x480"},
+        }
+
+    adapter = OctoPrintBitBang(
+        asgi_app,
+        camera_source=camera_source,
+        ws_target=ws_target,
+        **bitbang_kwargs(args, program_name='octoprint'),
+    )
+    adapter.run()
+
+
+if __name__ == '__main__':
+    main()