refractor capture to a module

src/orisys/capture/worker.py

@@ -0,0 +1,124 @@
+"""Background capture worker that feeds a FrameBuffer."""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Optional
+
+from .buffer import FrameBuffer
+from .config import CaptureConfig, CaptureHealth, CaptureMode
+from .source import CaptureSource, is_live_camera, normalize_source
+
+
+class CaptureWorker:
+    """One thread per live camera: read → publish → optional reconnect."""
+
+    def __init__(
+        self,
+        source: CaptureSource,
+        buffer: Optional[FrameBuffer] = None,
+    ):
+        self.source = source
+        self.config: CaptureConfig = source.config
+        self.buffer = buffer or FrameBuffer(
+            mode=self.config.mode,
+            maxsize=self.config.queue_size,
+            overflow=self.config.overflow,
+        )
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._last_consumed_seq = -1
+
+    @property
+    def running(self) -> bool:
+        return self._running
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        if not self.source.is_open():
+            self.source.open()
+        self._running = True
+        self._thread = threading.Thread(target=self._loop, daemon=True, name="orisys-capture")
+        self._thread.start()
+        if self.config.verbose:
+            mode = self.config.mode.value if isinstance(self.config.mode, CaptureMode) else self.config.mode
+            print(f"Capture worker started (mode={mode}).")
+
+    def stop(self, timeout: float = 1.0) -> None:
+        self._running = False
+        if self._thread is not None:
+            self._thread.join(timeout=timeout)
+            self._thread = None
+        self.buffer.clear()
+
+    def close(self) -> None:
+        self.stop()
+        self.source.release()
+
+    def read(self, *, copy: bool = True, wait_s: float = 1.0) -> tuple[bool, object]:
+        """Read according to configured mode; mirrors Sensor._read_frame semantics."""
+        if not self._running:
+            ok, frame = self.source.read_raw()
+            return ok, frame
+
+        if self.config.mode == CaptureMode.QUEUE:
+            ok, frame, seq = self.buffer.read_next(copy=copy, wait_s=wait_s)
+        else:
+            # Startup race: wait briefly for first frame.
+            wait = wait_s if wait_s > 0 else 1.0
+            ok, frame, seq = self.buffer.read_latest(copy=copy, wait_s=wait)
+        if ok:
+            self._last_consumed_seq = seq
+        return ok, frame
+
+    def _loop(self) -> None:
+        while self._running:
+            if self.source.should_reconnect():
+                if not self.source.reconnect():
+                    # Back off a bit before retrying the should_reconnect check.
+                    time.sleep(0.05)
+                    if self.source.status.health == CaptureHealth.FAILED:
+                        time.sleep(0.2)
+                    continue
+
+            ok, frame = self.source.read_raw()
+            if not ok or frame is None:
+                if self.source.should_reconnect():
+                    continue
+                time.sleep(0.001)
+                continue
+
+            before_dropped = self.buffer.dropped_frames
+            seq = self.buffer.publish(frame)
+            after_dropped = self.buffer.dropped_frames
+            if after_dropped > before_dropped:
+                self.source.note_dropped(after_dropped - before_dropped)
+            self.source.note_published(seq)
+
+
+def open_capture(
+    config: CaptureConfig,
+    *,
+    factory=None,
+    start_worker: Optional[bool] = None,
+) -> CaptureWorker:
+    """Open a capture source and optionally start its worker thread.
+
+    For live cameras, the worker starts by default (``config.start_worker``).
+    File/video sources stay synchronous unless ``start_worker=True``.
+    """
+    source = CaptureSource(config, factory=factory)
+    source.open()
+    buffer = FrameBuffer(
+        mode=config.mode,
+        maxsize=config.queue_size,
+        overflow=config.overflow,
+    )
+    worker = CaptureWorker(source, buffer)
+    should_start = config.start_worker if start_worker is None else start_worker
+    live = is_live_camera(normalize_source(config.source))
+    if should_start and live:
+        worker.start()
+    return worker