OctoPrint-BitBang 0.1.2__py3-none-any.whl

octoprint_bitbang/camera.py

@@ -0,0 +1,117 @@
+"""Camera auto-detection for OctoPrint BitBang.
+
+Detects available camera sources in priority order:
+1. picamera2 CSI camera (Pi hardware, software encode in aiortc)
+2. USB webcam via V4L2/dshow/avfoundation (software encode)
+3. None (HTTP-only mode, no crash)
+"""
+
+import sys
+
+
+def detect_camera(logger=None):
+    """Detect best available camera source.
+
+    Returns dict with keys: type, device, format, options
+    Or None if no camera found.
+    """
+    log = logger.info if logger else lambda msg: print(f"[camera] {msg}")
+
+    # 1. picamera2 (Raspberry Pi CSI)
+    source = _try_picamera2()
+    if source:
+        log("Found Pi CSI camera via picamera2")
+        return source
+
+    # 2. USB webcam (platform-specific)
+    source = _try_usb_webcam()
+    if source:
+        log(f"Found USB webcam: {source['device']}")
+        return source
+
+    log("No camera found - running in HTTP-only mode")
+    return None
+
+
+def _try_picamera2():
+    """Check if picamera2 is available (Raspberry Pi CSI camera)."""
+    try:
+        from picamera2 import Picamera2
+        cam = Picamera2()
+        cam.close()
+        return {"type": "picamera2"}
+    except Exception:
+        return None
+
+
+def _try_usb_webcam():
+    """Check for USB webcam (platform-specific)."""
+    if sys.platform == 'darwin':
+        return {
+            "type": "usb",
+            "device": "0:none",
+            "format": "avfoundation",
+            "options": {"framerate": "30", "video_size": "640x480"},
+        }
+    elif sys.platform == 'win32':
+        camera = _find_windows_camera()
+        if camera:
+            return {
+                "type": "usb",
+                "device": f"video={camera}",
+                "format": "dshow",
+                "options": {"framerate": "30", "video_size": "640x480"},
+            }
+        return None
+    else:
+        # Linux: check /dev/video0 through /dev/video3
+        import os
+        for i in range(4):
+            dev = f"/dev/video{i}"
+            if os.path.exists(dev):
+                if _is_v4l2_capture(dev):
+                    return {
+                        "type": "usb",
+                        "device": dev,
+                        "format": "v4l2",
+                        "options": {"framerate": "30", "video_size": "640x480"},
+                    }
+        return None
+
+
+def _is_v4l2_capture(device):
+    """Check if a V4L2 device is a video capture device (not encoder/decoder).
+
+    Skips V4L2 M2M devices like /dev/video10, /dev/video11 on Raspberry Pi.
+    """
+    try:
+        import fcntl
+        import struct
+        VIDIOC_QUERYCAP = 0x80685600
+        with open(device, 'rb') as f:
+            buf = bytearray(104)
+            fcntl.ioctl(f, VIDIOC_QUERYCAP, buf)
+            capabilities = struct.unpack_from('<I', buf, 84)[0]
+            V4L2_CAP_VIDEO_CAPTURE = 0x00000001
+            return bool(capabilities & V4L2_CAP_VIDEO_CAPTURE)
+    except Exception:
+        # If we can't probe, assume it's a capture device
+        return True
+
+
+def _find_windows_camera():
+    """Discover first available camera on Windows via PowerShell."""
+    import subprocess
+    try:
+        result = subprocess.run(
+            ['powershell', '-Command',
+             'Get-PnpDevice -Class Camera -Status OK | '
+             'Select-Object -ExpandProperty FriendlyName'],
+            capture_output=True, text=True, timeout=5
+        )
+        name = result.stdout.strip().split('\n')[0].strip()
+        if name:
+            return name
+    except Exception:
+        pass
+    return None

octoprint_bitbang/flip_track.py

@@ -0,0 +1,59 @@
+"""MediaStreamTrack wrapper that hflip/vflips frames via PyAV.
+
+Used for USB webcams where flip can't be done at the sensor level.
+aiortc's MediaPlayer already decodes frames to av.VideoFrame before
+handing them to the H.264 encoder, so we intercept there and flip
+in-place.
+"""
+
+from aiortc import MediaStreamTrack
+
+
+class FlippedTrack(MediaStreamTrack):
+    kind = "video"
+
+    def __init__(self, source, hflip=False, vflip=False):
+        super().__init__()
+        self._source = source
+        self._hflip = bool(hflip)
+        self._vflip = bool(vflip)
+        self._graph = None
+        self._buffer_src = None
+        self._buffer_sink = None
+
+    def _init_graph(self, frame):
+        # Build a PyAV filter graph matching the first frame's format.
+        # Chaining hflip and vflip gives us a 180° rotation when both are set.
+        from av.filter import Graph
+
+        graph = Graph()
+        src = graph.add_buffer(template=frame)
+        last = src
+        if self._hflip:
+            n = graph.add("hflip")
+            last.link_to(n)
+            last = n
+        if self._vflip:
+            n = graph.add("vflip")
+            last.link_to(n)
+            last = n
+        sink = graph.add("buffersink")
+        last.link_to(sink)
+        graph.configure()
+        self._graph = graph
+        self._buffer_src = src
+        self._buffer_sink = sink
+
+    async def recv(self):
+        frame = await self._source.recv()
+        if not (self._hflip or self._vflip):
+            return frame
+        if self._graph is None:
+            self._init_graph(frame)
+        self._buffer_src.push(frame)
+        return self._buffer_sink.pull()
+
+    def stop(self):
+        super().stop()
+        if self._source and hasattr(self._source, "stop"):
+            self._source.stop()

octoprint_bitbang/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        body { font-family: sans-serif; text-align: center; padding: 20px; }
+        video { width: 100%; max-width: 640px; background: #000; }
+        #status { color: #666; margin-top: 10px; }
+    </style>
+</head>
+<body>
+    <h2>OctoPrint BitBang Prototype</h2>
+    <video data-bitbang-stream="camera" autoplay playsinline muted></video>
+    <p id="status">Camera stream + HTTP tunnel active</p>
+    <p>In the real plugin, OctoPrint's full UI loads here via the BitBang HTTP tunnel.</p>
+</body>
+</html>

octoprint_bitbang/octoprint_adapter.py

@@ -0,0 +1,103 @@
+"""OctoPrint BitBang adapter - extends BitBangASGI with camera video track.
+
+Subclasses BitBangASGI to add a camera video track alongside async HTTP
+reverse proxy. Fully async -- no WSGI thread pool.
+Camera source is auto-detected or explicitly configured.
+"""
+
+from bitbang import BitBangASGI
+from aiortc.contrib.media import MediaRelay
+
+from .camera import detect_camera
+
+
+def force_h264(pc, sender):
+    """Force H.264 codec on a transceiver so aiortc doesn't negotiate VP8."""
+    from aiortc.rtcrtpsender import RTCRtpSender
+    h264 = [c for c in RTCRtpSender.getCapabilities("video").codecs
+            if c.name == "H264"]
+    for t in pc.getTransceivers():
+        if t.sender is sender:
+            t.setCodecPreferences(h264)
+            break
+
+
+class OctoPrintBitBang(BitBangASGI):
+    """BitBang adapter with camera video for OctoPrint remote access.
+
+    Extends BitBangASGI to capture video from the best available camera
+    source and share it with all connected clients using MediaRelay.
+    Falls back to HTTP-only mode if no camera is found.
+    """
+
+    def __init__(self, app, camera_source=None, ws_target=None, **kwargs):
+        super().__init__(app, **kwargs)
+        self.ws_target = ws_target  # host:port for WebSocket bridging
+        self.relay = MediaRelay()
+        self.player = None
+        self._init_camera(camera_source)
+
+    def _init_camera(self, camera_source):
+        """Initialize camera from explicit source or auto-detect."""
+        source = camera_source or detect_camera()
+        if not source:
+            print("No camera - running in HTTP-only mode")
+            return
+
+        if source["type"] == "usb":
+            # USB webcam (software H.264 encode via aiortc)
+            try:
+                from .usb_camera_source import UsbCameraSource
+                self.player = UsbCameraSource(
+                    device=source["device"],
+                    format=source.get("format"),
+                    options=source.get("options", {}),
+                    brightness=source.get("brightness", 0),
+                    flip_horizontal=source.get("flip_horizontal", False),
+                    flip_vertical=source.get("flip_vertical", False),
+                )
+                print(f"Opened USB camera: {source['device']}")
+            except Exception as e:
+                print(f"Warning: Could not open camera '{source['device']}': {e}")
+
+        elif source["type"] == "picamera2":
+            # Pi CSI camera - picamera2 H264Encoder (hw on Pi 4, sw on Pi 5)
+            # emits Annex-B H.264 that aiortc packetizes without re-encoding.
+            try:
+                from .pi_h264_source import PiH264Track
+                size = source.get("size", (640, 480))
+                framerate = source.get("framerate", 30)
+                bitrate = source.get("bitrate", 4_000_000)
+                brightness = source.get("brightness", 0)
+                self.player = PiH264Track(
+                    size=size, framerate=framerate, bitrate=bitrate,
+                    brightness=brightness,
+                    flip_horizontal=source.get("flip_horizontal", False),
+                    flip_vertical=source.get("flip_vertical", False),
+                )
+                print(f"Opened Pi CSI camera via H264Encoder ({size[0]}x{size[1]}@{framerate})")
+            except Exception as e:
+                print(f"Warning: Could not open Pi CSI camera: {e}")
+
+    def setup_peer_connection(self, pc, client_id):
+        """Add camera video track to peer connection."""
+        if self.player and self.player.video:
+            sender = pc.addTrack(self.relay.subscribe(self.player.video))
+            force_h264(pc, sender)
+            print(f"Added camera video track for {client_id}")
+
+    def get_stream_metadata(self):
+        """Return stream name for video track."""
+        if self.player and self.player.video:
+            return {"0": "camera"}
+        return {}
+
+    async def close(self):
+        """Close peer connections and media player."""
+        await super().close()
+        if self.player:
+            if hasattr(self.player, "stop"):
+                self.player.stop()
+            elif self.player.video:
+                self.player.video.stop()
+            self.player = None

octoprint_bitbang/pi_camera_track.py

@@ -0,0 +1,48 @@
+"""aiortc video track backed by picamera2 (Raspberry Pi CSI camera).
+
+Captures frames from picamera2 and yields them as aiortc VideoFrames.
+aiortc handles software H.264 encoding downstream.
+"""
+
+import asyncio
+import fractions
+
+from aiortc import MediaStreamTrack
+from av import VideoFrame
+
+
+class PiCameraTrack(MediaStreamTrack):
+    kind = "video"
+
+    def __init__(self, size=(640, 480), framerate=30):
+        super().__init__()
+        from picamera2 import Picamera2
+
+        self.picam2 = Picamera2()
+        config = self.picam2.create_video_configuration(
+            main={"size": size, "format": "RGB888"}
+        )
+        self.picam2.configure(config)
+        self.picam2.start()
+
+        self.framerate = framerate
+        self._timestamp = 0
+        self._time_base = fractions.Fraction(1, 90000)
+        self._ticks_per_frame = int(90000 / framerate)
+
+    async def recv(self):
+        loop = asyncio.get_event_loop()
+        array = await loop.run_in_executor(None, self.picam2.capture_array)
+        frame = VideoFrame.from_ndarray(array, format="bgr24")
+        frame.pts = self._timestamp
+        frame.time_base = self._time_base
+        self._timestamp += self._ticks_per_frame
+        return frame
+
+    def stop(self):
+        super().stop()
+        try:
+            self.picam2.stop()
+            self.picam2.close()
+        except Exception:
+            pass

octoprint_bitbang/pi_h264_source.py

@@ -0,0 +1,149 @@
+"""picamera2 H264Encoder → aiortc MediaStreamTrack passthrough.
+
+Hardware H.264 on Pi 4 (V4L2 M2M at /dev/video11), software (LibavH264Encoder)
+on Pi 5. picamera2 delivers Annex-B NAL units plus a microsecond timestamp
+via Output.outputframe(); we wrap each as an av.Packet with pts set, so
+aiortc's H264Payloader.pack() packetizes into RTP without re-encoding.
+"""
+
+import asyncio
+import io
+from fractions import Fraction
+
+import av
+from aiortc import MediaStreamTrack
+from picamera2.outputs import Output
+
+# picamera2's V4L2Encoder reports timestamps as integer microseconds
+# (seconds * 1_000_000 + microseconds from V4L2 buffer timestamp).
+_TIME_BASE = Fraction(1, 1_000_000)
+
+
+class _QueueOutput(Output):
+    """picamera2 Output that turns each encoded frame into an av.Packet
+    and enqueues it on a provided asyncio.Queue (thread-safely)."""
+
+    def __init__(self, loop, queue):
+        super().__init__()
+        self._loop = loop
+        self._queue = queue
+
+    def outputframe(self, frame, keyframe=True, timestamp=None, packet=None, audio=False):
+        if timestamp is None:
+            return
+        data = frame if isinstance(frame, (bytes, bytearray)) else bytes(frame)
+        pkt = av.Packet(data)
+        pkt.pts = timestamp
+        pkt.dts = timestamp
+        pkt.time_base = _TIME_BASE
+        pkt.is_keyframe = keyframe
+        self._loop.call_soon_threadsafe(self._try_put, pkt)
+
+    def _try_put(self, pkt):
+        # Drop oldest on overflow so live stream doesn't stall.
+        if self._queue.full():
+            try:
+                self._queue.get_nowait()
+            except asyncio.QueueEmpty:
+                pass
+        try:
+            self._queue.put_nowait(pkt)
+        except asyncio.QueueFull:
+            pass
+
+
+class PiH264Track(MediaStreamTrack):
+    """aiortc video track backed by picamera2's H264Encoder."""
+
+    kind = "video"
+
+    def __init__(self, size=(640, 480), framerate=30, bitrate=1_500_000,
+                 brightness=0, flip_horizontal=False, flip_vertical=False):
+        super().__init__()
+        from picamera2 import Picamera2
+        from picamera2.encoders import H264Encoder
+        from libcamera import Transform
+
+        self._size = size
+        self._framerate = framerate
+        self._brightness = brightness  # -100..100, scaled to picamera2's -1.0..1.0
+
+        self.picam2 = Picamera2()
+        config = self.picam2.create_video_configuration(
+            main={"size": size, "format": "YUV420"},
+            transform=Transform(hflip=bool(flip_horizontal), vflip=bool(flip_vertical)),
+            controls={
+                "FrameRate": float(framerate),
+                "Brightness": self._brightness / 100.0,
+            },
+        )
+        self.picam2.configure(config)
+        # Start the camera up front (no encoder yet) so capture_image works
+        # before any WebRTC client connects — needed for timelapse snapshots.
+        self.picam2.start()
+
+        # Let the encoder pick its own GOP length (V4L2 default is ~60
+        # frames on Pi 4). repeat=True → SPS/PPS before each IDR so late-
+        # joining WebRTC subscribers can start decoding when one arrives.
+        self.encoder = H264Encoder(
+            bitrate=bitrate,
+            repeat=True,
+            profile="baseline",
+        )
+
+        self._encoder_started = False
+        self._queue: asyncio.Queue | None = None
+        self._output: _QueueOutput | None = None
+
+    def _ensure_started(self):
+        if self._encoder_started:
+            return
+        self._queue = asyncio.Queue(maxsize=30)
+        self._output = _QueueOutput(asyncio.get_running_loop(), self._queue)
+        self.picam2.start_encoder(self.encoder, self._output)
+        self._encoder_started = True
+
+    async def recv(self):
+        self._ensure_started()
+        return await self._queue.get()
+
+    def set_brightness(self, value):
+        """Update brightness live. `value` is -100..100 (mapped to -1.0..1.0)."""
+        self._brightness = max(-100, min(100, int(value)))
+        self.picam2.set_controls({"Brightness": self._brightness / 100.0})
+
+    def capture_snapshot(self):
+        """Return a JPEG snapshot grabbed straight from the camera. Safe to
+        call concurrently with the H.264 encoder — picamera2/libcamera
+        delivers a separate frame to the application without disturbing
+        the encoder pipeline. Uses request.save's YUV420→JPEG fast path
+        (simplejpeg.encode_jpeg_yuv_planes) so we never go through PIL,
+        which doesn't support a YUV420 mode."""
+        buf = io.BytesIO()
+        request = self.picam2.capture_request()
+        try:
+            request.save("main", buf, format="jpeg")
+        finally:
+            request.release()
+        return buf.getvalue()
+
+    @property
+    def video(self):
+        # MediaPlayer-shaped interface so the adapter can treat us like one.
+        return self
+
+    def stop(self):
+        super().stop()
+        try:
+            if self._encoder_started:
+                self.picam2.stop_encoder()
+        except Exception:
+            pass
+        try:
+            self.picam2.stop()
+        except Exception:
+            pass
+        try:
+            self.picam2.close()
+        except Exception:
+            pass