hotfix/camera not connected error
This commit is contained in:
ykcheungab
@@ -1,14 +1,10 @@
|
||||
"""Capture subsystem: sources, buffering, reconnect, discovery, multi-camera."""
|
||||
"""Capture subsystem: OpenCV source, optional background thread, discovery."""
|
||||
|
||||
from .buffer import FrameBuffer, FramePacket
|
||||
from .config import (
|
||||
MAX_QUEUE_SIZE,
|
||||
MAX_SIMULTANEOUS_CAPTURES,
|
||||
CaptureConfig,
|
||||
CaptureHealth,
|
||||
CaptureMode,
|
||||
CaptureStatus,
|
||||
OverflowPolicy,
|
||||
ReconnectPolicy,
|
||||
)
|
||||
from .discovery import (
|
||||
@@ -19,31 +15,25 @@ from .discovery import (
|
||||
list_cameras,
|
||||
pick_default_camera,
|
||||
)
|
||||
from .manager import CaptureManager
|
||||
from .source import (
|
||||
CaptureSource,
|
||||
CaptureWorker,
|
||||
is_live_camera,
|
||||
normalize_source,
|
||||
open_capture,
|
||||
open_opencv_capture,
|
||||
)
|
||||
from .worker import CaptureWorker, open_capture
|
||||
|
||||
__all__ = [
|
||||
"MAX_QUEUE_SIZE",
|
||||
"MAX_SIMULTANEOUS_CAPTURES",
|
||||
"DEFAULT_MAX_CAMERA_INDEX",
|
||||
"DEFAULT_LAPTOP_WEBCAM_PATTERNS",
|
||||
"CaptureConfig",
|
||||
"CaptureHealth",
|
||||
"CaptureMode",
|
||||
"CaptureStatus",
|
||||
"OverflowPolicy",
|
||||
"ReconnectPolicy",
|
||||
"FrameBuffer",
|
||||
"FramePacket",
|
||||
"CaptureSource",
|
||||
"CaptureWorker",
|
||||
"CaptureManager",
|
||||
"CameraInfo",
|
||||
"CameraFilter",
|
||||
"list_cameras",
|
||||
|
||||
@@ -1,127 +0,0 @@
|
||||
"""Bounded frame transport for capture workers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import threading
|
||||
import time
|
||||
from collections import deque
|
||||
from dataclasses import dataclass
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
|
||||
from .config import CaptureMode, OverflowPolicy
|
||||
|
||||
|
||||
@dataclass
|
||||
class FramePacket:
|
||||
"""One captured frame with sequencing metadata."""
|
||||
|
||||
frame: np.ndarray
|
||||
seq: int
|
||||
timestamp: float
|
||||
|
||||
|
||||
class FrameBuffer:
|
||||
"""Thread-safe frame buffer supporting latest-only and bounded queue modes.
|
||||
|
||||
* ``latest``: always overwrite the single published frame (low latency).
|
||||
* ``queue``: FIFO up to ``maxsize``; overflow controlled by ``OverflowPolicy``.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
mode: CaptureMode = CaptureMode.LATEST,
|
||||
maxsize: int = 1,
|
||||
overflow: OverflowPolicy = OverflowPolicy.DROP_OLDEST,
|
||||
):
|
||||
self.mode = CaptureMode(mode) if isinstance(mode, str) else mode
|
||||
self.maxsize = max(1, int(maxsize))
|
||||
self.overflow = OverflowPolicy(overflow) if isinstance(overflow, str) else overflow
|
||||
self._lock = threading.Lock()
|
||||
self._cond = threading.Condition(self._lock)
|
||||
self._latest: Optional[FramePacket] = None
|
||||
self._queue: deque[FramePacket] = deque()
|
||||
self.dropped_frames = 0
|
||||
self._seq = 0
|
||||
|
||||
def clear(self) -> None:
|
||||
with self._cond:
|
||||
self._latest = None
|
||||
self._queue.clear()
|
||||
|
||||
def publish(self, frame: np.ndarray, *, timestamp: Optional[float] = None) -> int:
|
||||
"""Publish a frame. Returns assigned sequence number."""
|
||||
ts = time.perf_counter() if timestamp is None else float(timestamp)
|
||||
with self._cond:
|
||||
self._seq += 1
|
||||
packet = FramePacket(frame=frame, seq=self._seq, timestamp=ts)
|
||||
if self.mode == CaptureMode.LATEST:
|
||||
self._latest = packet
|
||||
self._cond.notify_all()
|
||||
return packet.seq
|
||||
|
||||
if len(self._queue) >= self.maxsize:
|
||||
if self.overflow == OverflowPolicy.DROP_NEWEST:
|
||||
self.dropped_frames += 1
|
||||
return packet.seq
|
||||
if self.overflow == OverflowPolicy.BLOCK:
|
||||
while len(self._queue) >= self.maxsize:
|
||||
self._cond.wait(timeout=0.05)
|
||||
# If still full after wait, drop oldest to avoid deadlock if
|
||||
# consumer stopped; count as dropped.
|
||||
if len(self._queue) >= self.maxsize:
|
||||
self._queue.popleft()
|
||||
self.dropped_frames += 1
|
||||
break
|
||||
else:
|
||||
# drop_oldest
|
||||
self._queue.popleft()
|
||||
self.dropped_frames += 1
|
||||
self._queue.append(packet)
|
||||
self._latest = packet
|
||||
self._cond.notify_all()
|
||||
return packet.seq
|
||||
|
||||
def read_latest(self, *, copy: bool = True, wait_s: float = 0.0) -> tuple[bool, Optional[np.ndarray], int]:
|
||||
"""Return the newest frame without consuming a queue slot."""
|
||||
deadline = time.perf_counter() + max(0.0, wait_s)
|
||||
with self._cond:
|
||||
while self._latest is None:
|
||||
remaining = deadline - time.perf_counter()
|
||||
if remaining <= 0:
|
||||
return False, None, 0
|
||||
self._cond.wait(timeout=remaining)
|
||||
packet = self._latest
|
||||
frame = packet.frame.copy() if copy else packet.frame
|
||||
return True, frame, packet.seq
|
||||
|
||||
def read_next(self, *, copy: bool = True, wait_s: float = 0.0) -> tuple[bool, Optional[np.ndarray], int]:
|
||||
"""Pop the next queued frame (queue mode) or return latest (latest mode)."""
|
||||
if self.mode == CaptureMode.LATEST:
|
||||
return self.read_latest(copy=copy, wait_s=wait_s)
|
||||
|
||||
deadline = time.perf_counter() + max(0.0, wait_s)
|
||||
with self._cond:
|
||||
while not self._queue:
|
||||
remaining = deadline - time.perf_counter()
|
||||
if remaining <= 0:
|
||||
return False, None, 0
|
||||
self._cond.wait(timeout=remaining)
|
||||
packet = self._queue.popleft()
|
||||
self._cond.notify_all()
|
||||
frame = packet.frame.copy() if copy else packet.frame
|
||||
return True, frame, packet.seq
|
||||
|
||||
@property
|
||||
def last_seq(self) -> int:
|
||||
with self._lock:
|
||||
return self._seq
|
||||
|
||||
@property
|
||||
def pending(self) -> int:
|
||||
with self._lock:
|
||||
if self.mode == CaptureMode.LATEST:
|
||||
return 0 if self._latest is None else 1
|
||||
return len(self._queue)
|
||||
@@ -7,23 +7,6 @@ from enum import Enum
|
||||
from typing import Any, Optional, Sequence, Tuple, Union
|
||||
|
||||
MAX_SIMULTANEOUS_CAPTURES = 10
|
||||
MAX_QUEUE_SIZE = 10
|
||||
DEFAULT_QUEUE_SIZE = 1
|
||||
|
||||
|
||||
class CaptureMode(str, Enum):
|
||||
"""Frame delivery mode for a live capture worker."""
|
||||
|
||||
LATEST = "latest"
|
||||
QUEUE = "queue"
|
||||
|
||||
|
||||
class OverflowPolicy(str, Enum):
|
||||
"""Behavior when a bounded queue is full."""
|
||||
|
||||
DROP_OLDEST = "drop_oldest"
|
||||
DROP_NEWEST = "drop_newest"
|
||||
BLOCK = "block"
|
||||
|
||||
|
||||
class CaptureHealth(str, Enum):
|
||||
@@ -83,11 +66,8 @@ class CaptureConfig:
|
||||
height: Optional[int] = None
|
||||
fps: Optional[float] = None
|
||||
fourcc: Optional[str] = "MJPG"
|
||||
mode: CaptureMode = CaptureMode.LATEST
|
||||
queue_size: int = DEFAULT_QUEUE_SIZE
|
||||
overflow: OverflowPolicy = OverflowPolicy.DROP_OLDEST
|
||||
background: bool = True
|
||||
reconnect: ReconnectPolicy = field(default_factory=ReconnectPolicy)
|
||||
start_worker: bool = True
|
||||
verbose: bool = False
|
||||
# Optional discovery filters (used by list/open helpers, not open itself).
|
||||
name_include: Optional[Sequence[str]] = None
|
||||
@@ -97,19 +77,8 @@ class CaptureConfig:
|
||||
min_height: Optional[int] = None
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if isinstance(self.mode, str):
|
||||
self.mode = CaptureMode(self.mode)
|
||||
if isinstance(self.overflow, str):
|
||||
self.overflow = OverflowPolicy(self.overflow)
|
||||
if not isinstance(self.reconnect, ReconnectPolicy):
|
||||
raise TypeError("reconnect must be a ReconnectPolicy")
|
||||
size = int(self.queue_size)
|
||||
if size < 1 or size > MAX_QUEUE_SIZE:
|
||||
raise ValueError(f"queue_size must be in 1..{MAX_QUEUE_SIZE}, got {size}")
|
||||
self.queue_size = size
|
||||
if self.mode == CaptureMode.LATEST:
|
||||
# Latest mode keeps only one published frame regardless of queue_size.
|
||||
self.queue_size = 1
|
||||
|
||||
@classmethod
|
||||
def from_camera_dict(
|
||||
@@ -117,12 +86,17 @@ class CaptureConfig:
|
||||
source: SourceType,
|
||||
camera: dict[str, Any],
|
||||
*,
|
||||
mode: CaptureMode | str = CaptureMode.LATEST,
|
||||
reconnect: Optional[ReconnectPolicy] = None,
|
||||
verbose: bool = False,
|
||||
**kwargs: Any,
|
||||
) -> "CaptureConfig":
|
||||
"""Build config from a sensor JSON ``camera`` section."""
|
||||
# Accept deprecated queue/worker kwargs from older callers without error.
|
||||
kwargs.pop("mode", None)
|
||||
kwargs.pop("queue_size", None)
|
||||
kwargs.pop("overflow", None)
|
||||
if "start_worker" in kwargs:
|
||||
kwargs.setdefault("background", bool(kwargs.pop("start_worker")))
|
||||
res = camera.get("resolution_raw") or [None, None]
|
||||
width = int(res[0]) if res and res[0] else None
|
||||
height = int(res[1]) if res and res[1] else None
|
||||
@@ -132,7 +106,6 @@ class CaptureConfig:
|
||||
width=width,
|
||||
height=height,
|
||||
fps=float(fps) if fps is not None else None,
|
||||
mode=mode,
|
||||
reconnect=reconnect or ReconnectPolicy(),
|
||||
verbose=verbose,
|
||||
**kwargs,
|
||||
|
||||
@@ -1,122 +0,0 @@
|
||||
"""Manage up to N simultaneous capture sources."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Dict, List, Optional, Sequence
|
||||
|
||||
from .config import (
|
||||
MAX_SIMULTANEOUS_CAPTURES,
|
||||
CaptureConfig,
|
||||
CaptureStatus,
|
||||
SourceType,
|
||||
)
|
||||
from .source import normalize_source
|
||||
from .worker import CaptureWorker, open_capture
|
||||
|
||||
|
||||
class CaptureManager:
|
||||
"""Own multiple ``CaptureWorker`` instances (default max 10).
|
||||
|
||||
Each camera is isolated: one failed USB device does not stop the others.
|
||||
Hardware USB bandwidth may still limit how many high-res streams work in
|
||||
practice even when this manager allows up to ``max_sources`` software slots.
|
||||
"""
|
||||
|
||||
def __init__(self, *, max_sources: int = MAX_SIMULTANEOUS_CAPTURES):
|
||||
if max_sources < 1 or max_sources > MAX_SIMULTANEOUS_CAPTURES:
|
||||
raise ValueError(
|
||||
f"max_sources must be in 1..{MAX_SIMULTANEOUS_CAPTURES}, got {max_sources}"
|
||||
)
|
||||
self.max_sources = int(max_sources)
|
||||
self._workers: Dict[str, CaptureWorker] = {}
|
||||
|
||||
def __len__(self) -> int:
|
||||
return len(self._workers)
|
||||
|
||||
def __contains__(self, key: SourceType) -> bool:
|
||||
return self._key(key) in self._workers
|
||||
|
||||
@staticmethod
|
||||
def _key(source: SourceType) -> str:
|
||||
return str(normalize_source(source))
|
||||
|
||||
@property
|
||||
def sources(self) -> List[str]:
|
||||
return list(self._workers.keys())
|
||||
|
||||
def open(self, config: CaptureConfig, *, factory=None) -> CaptureWorker:
|
||||
"""Open one capture; raises if capacity exceeded or source already open."""
|
||||
key = self._key(config.source)
|
||||
if key in self._workers:
|
||||
raise RuntimeError(f"Capture already open for source {key!r}")
|
||||
if len(self._workers) >= self.max_sources:
|
||||
raise RuntimeError(
|
||||
f"CaptureManager at capacity ({self.max_sources}). "
|
||||
"Close a source before opening another."
|
||||
)
|
||||
worker = open_capture(config, factory=factory)
|
||||
self._workers[key] = worker
|
||||
return worker
|
||||
|
||||
def open_many(
|
||||
self,
|
||||
configs: Sequence[CaptureConfig],
|
||||
*,
|
||||
factory=None,
|
||||
) -> List[CaptureWorker]:
|
||||
"""Open several captures atomically (rolls back on failure)."""
|
||||
if len(configs) + len(self._workers) > self.max_sources:
|
||||
raise RuntimeError(
|
||||
f"Opening {len(configs)} sources would exceed capacity "
|
||||
f"{self.max_sources} (currently {len(self._workers)} open)."
|
||||
)
|
||||
opened: List[CaptureWorker] = []
|
||||
try:
|
||||
for cfg in configs:
|
||||
opened.append(self.open(cfg, factory=factory))
|
||||
except Exception:
|
||||
for worker in opened:
|
||||
key = self._key(worker.source.config.source)
|
||||
worker.close()
|
||||
self._workers.pop(key, None)
|
||||
raise
|
||||
return opened
|
||||
|
||||
def get(self, source: SourceType) -> Optional[CaptureWorker]:
|
||||
return self._workers.get(self._key(source))
|
||||
|
||||
def read_latest(self, source: SourceType, *, wait_s: float = 0.0):
|
||||
worker = self.get(source)
|
||||
if worker is None:
|
||||
return False, None
|
||||
return worker.buffer.read_latest(wait_s=wait_s)[:2]
|
||||
|
||||
def read_latest_all(self, *, wait_s: float = 0.0) -> Dict[str, tuple]:
|
||||
"""Return ``{source_key: (ok, frame)}`` for every open capture."""
|
||||
out: Dict[str, tuple] = {}
|
||||
for key, worker in self._workers.items():
|
||||
ok, frame, _seq = worker.buffer.read_latest(wait_s=wait_s)
|
||||
out[key] = (ok, frame)
|
||||
return out
|
||||
|
||||
def status_all(self) -> Dict[str, CaptureStatus]:
|
||||
return {key: worker.source.status for key, worker in self._workers.items()}
|
||||
|
||||
def close(self, source: SourceType) -> None:
|
||||
key = self._key(source)
|
||||
worker = self._workers.pop(key, None)
|
||||
if worker is not None:
|
||||
worker.close()
|
||||
|
||||
def close_all(self) -> None:
|
||||
keys = list(self._workers.keys())
|
||||
for key in keys:
|
||||
worker = self._workers.pop(key, None)
|
||||
if worker is not None:
|
||||
worker.close()
|
||||
|
||||
def __enter__(self) -> "CaptureManager":
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc, tb) -> None:
|
||||
self.close_all()
|
||||
+225
-22
@@ -1,9 +1,10 @@
|
||||
"""OpenCV-backed capture source with optional reconnect."""
|
||||
"""OpenCV-backed capture source with optional background thread and reconnect."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from typing import Any, Optional, Protocol, runtime_checkable
|
||||
|
||||
@@ -28,6 +29,7 @@ class VideoCaptureLike(Protocol):
|
||||
def release(self) -> None: ...
|
||||
def get(self, propId: int) -> float: ...
|
||||
def set(self, propId: int, value: float) -> bool: ...
|
||||
def grab(self) -> bool: ...
|
||||
|
||||
|
||||
def normalize_source(source: SourceType | None) -> SourceType:
|
||||
@@ -40,7 +42,6 @@ def normalize_source(source: SourceType | None) -> SourceType:
|
||||
return 0
|
||||
if stripped.isdigit():
|
||||
return int(stripped)
|
||||
# Only strip trailing separators (Windows path quirk); keep leading '/'.
|
||||
return stripped.rstrip("/\\") or stripped
|
||||
return source
|
||||
|
||||
@@ -69,12 +70,10 @@ def _backend_candidates(preferred: str = "auto") -> list[tuple[str, int]]:
|
||||
elif preferred in ("v4l2", "v4l") and sys.platform.startswith("linux"):
|
||||
add("V4L2", "CAP_V4L2")
|
||||
elif preferred not in ("auto", "any", ""):
|
||||
# Unknown preference: fall through to platform defaults.
|
||||
pass
|
||||
|
||||
if not candidates:
|
||||
if sys.platform == "win32":
|
||||
# Prefer DSHOW to avoid MSMF HW-transform stalls on many USB cameras.
|
||||
add("DSHOW", "CAP_DSHOW")
|
||||
add("MSMF", "CAP_MSMF")
|
||||
elif sys.platform.startswith("linux"):
|
||||
@@ -101,6 +100,45 @@ def _decode_fourcc(value: float) -> str:
|
||||
return "".join(chr(b) if 32 <= b <= 126 else "." for b in bytes_)
|
||||
|
||||
|
||||
def _read_stream_meta(cap: VideoCaptureLike) -> tuple[int, int, float, str]:
|
||||
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
|
||||
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
|
||||
fps = float(cap.get(cv2.CAP_PROP_FPS) or 0.0)
|
||||
fourcc = _decode_fourcc(cap.get(cv2.CAP_PROP_FOURCC) or 0)
|
||||
return width, height, fps, fourcc
|
||||
|
||||
|
||||
def _apply_stream_props(
|
||||
cap: VideoCaptureLike,
|
||||
*,
|
||||
width: Optional[int],
|
||||
height: Optional[int],
|
||||
fps: Optional[float],
|
||||
fourcc: Optional[str],
|
||||
) -> None:
|
||||
"""Apply live-camera stream properties (width/height before fourcc on DSHOW)."""
|
||||
code = _fourcc_code(fourcc)
|
||||
if width is not None:
|
||||
cap.set(cv2.CAP_PROP_FRAME_WIDTH, float(width))
|
||||
if height is not None:
|
||||
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, float(height))
|
||||
if code is not None:
|
||||
cap.set(cv2.CAP_PROP_FOURCC, code)
|
||||
if fps is not None:
|
||||
cap.set(cv2.CAP_PROP_FPS, float(fps))
|
||||
# DSHOW often resets fourcc after size negotiation.
|
||||
if code is not None:
|
||||
cap.set(cv2.CAP_PROP_FOURCC, code)
|
||||
|
||||
|
||||
def _warmup_capture(cap: VideoCaptureLike, *, grabs: int = 3) -> None:
|
||||
for _ in range(max(0, grabs)):
|
||||
try:
|
||||
cap.grab()
|
||||
except Exception:
|
||||
break
|
||||
|
||||
|
||||
def open_opencv_capture(
|
||||
source: SourceType,
|
||||
*,
|
||||
@@ -115,13 +153,13 @@ def open_opencv_capture(
|
||||
|
||||
Returns ``(capture, backend_name)``.
|
||||
"""
|
||||
# Avoid MSMF HW transform stalls on Windows camera capture.
|
||||
if sys.platform == "win32":
|
||||
os.environ.setdefault("OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS", "0")
|
||||
|
||||
source = normalize_source(source)
|
||||
live = is_live_camera(source)
|
||||
last_error = "Failed to open video source."
|
||||
requested_fourcc = (fourcc or "").strip().upper()
|
||||
|
||||
backends = _backend_candidates(backend) if live else [("ANY", cv2.CAP_ANY)]
|
||||
for backend_name, backend_api in backends:
|
||||
@@ -138,22 +176,28 @@ def open_opencv_capture(
|
||||
last_error = f"Backend {backend_name} failed to open {source!r}"
|
||||
continue
|
||||
if live and apply_stream_props:
|
||||
code = _fourcc_code(fourcc)
|
||||
if code is not None:
|
||||
cap.set(cv2.CAP_PROP_FOURCC, code)
|
||||
if fps is not None:
|
||||
cap.set(cv2.CAP_PROP_FPS, float(fps))
|
||||
if width is not None:
|
||||
cap.set(cv2.CAP_PROP_FRAME_WIDTH, float(width))
|
||||
if height is not None:
|
||||
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, float(height))
|
||||
_apply_stream_props(
|
||||
cap,
|
||||
width=width,
|
||||
height=height,
|
||||
fps=fps,
|
||||
fourcc=fourcc,
|
||||
)
|
||||
_warmup_capture(cap)
|
||||
_, _, _, negotiated = _read_stream_meta(cap)
|
||||
if requested_fourcc and negotiated.upper() != requested_fourcc:
|
||||
# Retry once: some drivers need a second fourcc set after warmup.
|
||||
code = _fourcc_code(fourcc)
|
||||
if code is not None:
|
||||
cap.set(cv2.CAP_PROP_FOURCC, code)
|
||||
_warmup_capture(cap, grabs=2)
|
||||
return cap, backend_name
|
||||
|
||||
raise RuntimeError(last_error)
|
||||
|
||||
|
||||
class CaptureSource:
|
||||
"""Owns a video capture handle, health state, and reconnect logic.
|
||||
"""Owns a video capture handle, optional background reader, and reconnect logic.
|
||||
|
||||
Optionally accepts an injected ``factory`` for tests::
|
||||
|
||||
@@ -172,7 +216,13 @@ class CaptureSource:
|
||||
self._backend_name = ""
|
||||
self._status = CaptureStatus(source=normalize_source(config.source))
|
||||
self._reconnect_attempt = 0
|
||||
self._lock = __import__("threading").Lock()
|
||||
self._lock = threading.Lock()
|
||||
self._frame_lock = threading.Lock()
|
||||
self._frame_cond = threading.Condition(self._frame_lock)
|
||||
self._latest_frame: Optional[np.ndarray] = None
|
||||
self._latest_seq = 0
|
||||
self._thread: Optional[threading.Thread] = None
|
||||
self._background_running = False
|
||||
|
||||
@staticmethod
|
||||
def _default_factory(config: CaptureConfig) -> tuple[VideoCaptureLike, str]:
|
||||
@@ -186,6 +236,15 @@ class CaptureSource:
|
||||
apply_stream_props=is_live_camera(normalize_source(config.source)),
|
||||
)
|
||||
|
||||
# Compatibility with older CaptureWorker API.
|
||||
@property
|
||||
def source(self) -> "CaptureSource":
|
||||
return self
|
||||
|
||||
@property
|
||||
def running(self) -> bool:
|
||||
return self._background_running
|
||||
|
||||
@property
|
||||
def status(self) -> CaptureStatus:
|
||||
with self._lock:
|
||||
@@ -240,12 +299,27 @@ class CaptureSource:
|
||||
f"OpenCV negotiated stream: FOURCC='{st.fourcc}', "
|
||||
f"size={st.width}x{st.height}, fps={st.fps:.2f}, backend={st.backend_name}"
|
||||
)
|
||||
requested = (self.config.fourcc or "").strip().upper()
|
||||
if (
|
||||
requested
|
||||
and is_live_camera(normalize_source(self.config.source))
|
||||
and st.fourcc.upper() != requested
|
||||
):
|
||||
print(
|
||||
f"Warning: requested FOURCC '{self.config.fourcc}' but camera "
|
||||
f"negotiated '{st.fourcc}'."
|
||||
)
|
||||
|
||||
def release(self) -> None:
|
||||
self.stop_background()
|
||||
with self._lock:
|
||||
self._release_unlocked()
|
||||
self._status.health = CaptureHealth.CLOSED
|
||||
|
||||
def close(self) -> None:
|
||||
"""Stop background thread and release the capture handle."""
|
||||
self.release()
|
||||
|
||||
def _release_unlocked(self) -> None:
|
||||
if self._cap is not None:
|
||||
try:
|
||||
@@ -253,21 +327,32 @@ class CaptureSource:
|
||||
except Exception:
|
||||
pass
|
||||
self._cap = None
|
||||
with self._frame_cond:
|
||||
self._latest_frame = None
|
||||
self._latest_seq = 0
|
||||
|
||||
def _refresh_stream_meta_unlocked(self) -> None:
|
||||
cap = self._cap
|
||||
if cap is None:
|
||||
return
|
||||
try:
|
||||
self._status.width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 0)
|
||||
self._status.height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 0)
|
||||
self._status.fps = float(cap.get(cv2.CAP_PROP_FPS) or 0.0)
|
||||
self._status.fourcc = _decode_fourcc(cap.get(cv2.CAP_PROP_FOURCC) or 0)
|
||||
width, height, fps, fourcc = _read_stream_meta(cap)
|
||||
self._status.width = width
|
||||
self._status.height = height
|
||||
self._status.fps = fps
|
||||
self._status.fourcc = fourcc
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def warmup_frames(self, count: int = 3) -> None:
|
||||
"""Discard frames so the driver/format stabilizes (sync reads only)."""
|
||||
if self._background_running:
|
||||
return
|
||||
for _ in range(max(0, int(count))):
|
||||
self.read_raw()
|
||||
|
||||
def read_raw(self) -> tuple[bool, Optional[np.ndarray]]:
|
||||
"""Read one frame from the underlying capture (no reconnect)."""
|
||||
"""Read one frame directly from the underlying capture (no reconnect)."""
|
||||
cap = self._cap
|
||||
if cap is None:
|
||||
return False, None
|
||||
@@ -289,6 +374,92 @@ class CaptureSource:
|
||||
self._status.health = CaptureHealth.CONNECTED
|
||||
return True, frame
|
||||
|
||||
def read_latest(
|
||||
self,
|
||||
*,
|
||||
copy: bool = True,
|
||||
wait_s: float = 0.0,
|
||||
) -> tuple[bool, Optional[np.ndarray]]:
|
||||
"""Return the newest frame from the background thread, or read sync."""
|
||||
if not self._background_running:
|
||||
ok, frame = self.read_raw()
|
||||
if ok and copy and frame is not None:
|
||||
return ok, frame.copy()
|
||||
return ok, frame
|
||||
|
||||
deadline = time.perf_counter() + max(0.0, wait_s)
|
||||
with self._frame_cond:
|
||||
while self._latest_frame is None:
|
||||
remaining = deadline - time.perf_counter()
|
||||
if remaining <= 0:
|
||||
return False, None
|
||||
self._frame_cond.wait(timeout=remaining)
|
||||
frame = self._latest_frame.copy() if copy else self._latest_frame
|
||||
return True, frame
|
||||
|
||||
def read(self, *, copy: bool = True, wait_s: float = 1.0) -> tuple[bool, Optional[np.ndarray]]:
|
||||
"""Compat alias used by finger runtime and older worker callers."""
|
||||
wait = wait_s if wait_s > 0 else 1.0
|
||||
return self.read_latest(copy=copy, wait_s=wait)
|
||||
|
||||
def start_background(self) -> None:
|
||||
"""Start a daemon thread that keeps only the latest frame."""
|
||||
if self._thread is not None:
|
||||
return
|
||||
if not self.is_open():
|
||||
self.open()
|
||||
self._background_running = True
|
||||
self._thread = threading.Thread(
|
||||
target=self._background_loop,
|
||||
daemon=True,
|
||||
name="orisys-capture",
|
||||
)
|
||||
self._thread.start()
|
||||
if self.config.verbose:
|
||||
print("Capture background thread started.")
|
||||
|
||||
def start(self) -> None:
|
||||
"""Compat alias for ``start_background``."""
|
||||
self.start_background()
|
||||
|
||||
def stop_background(self, timeout: float = 1.0) -> None:
|
||||
self._background_running = False
|
||||
if self._thread is not None:
|
||||
self._thread.join(timeout=timeout)
|
||||
self._thread = None
|
||||
with self._frame_cond:
|
||||
self._latest_frame = None
|
||||
|
||||
def stop(self, timeout: float = 1.0) -> None:
|
||||
"""Compat alias for ``stop_background``."""
|
||||
self.stop_background(timeout=timeout)
|
||||
|
||||
def _background_loop(self) -> None:
|
||||
while self._background_running:
|
||||
if self.should_reconnect():
|
||||
if not self.reconnect():
|
||||
time.sleep(0.05)
|
||||
if self.status.health == CaptureHealth.FAILED:
|
||||
time.sleep(0.2)
|
||||
continue
|
||||
|
||||
ok, frame = self.read_raw()
|
||||
if not ok or frame is None:
|
||||
if self.should_reconnect():
|
||||
continue
|
||||
time.sleep(0.001)
|
||||
continue
|
||||
|
||||
with self._frame_cond:
|
||||
if self._latest_frame is not None:
|
||||
with self._lock:
|
||||
self._status.dropped_frames += 1
|
||||
self._latest_seq += 1
|
||||
self._latest_frame = frame
|
||||
with self._lock:
|
||||
self._status.last_seq = self._latest_seq
|
||||
self._frame_cond.notify_all()
|
||||
|
||||
def note_published(self, seq: int) -> None:
|
||||
with self._lock:
|
||||
self._status.last_seq = int(seq)
|
||||
@@ -334,7 +505,10 @@ class CaptureSource:
|
||||
|
||||
delay = policy.next_backoff(attempt)
|
||||
if self.config.verbose:
|
||||
print(f"Reconnecting to {self.config.source!r} (attempt {attempt + 1}, wait {delay:.2f}s)...")
|
||||
print(
|
||||
f"Reconnecting to {self.config.source!r} "
|
||||
f"(attempt {attempt + 1}, wait {delay:.2f}s)..."
|
||||
)
|
||||
time.sleep(delay)
|
||||
try:
|
||||
self.open()
|
||||
@@ -347,3 +521,32 @@ class CaptureSource:
|
||||
else:
|
||||
self._status.health = CaptureHealth.RECONNECTING
|
||||
return False
|
||||
|
||||
|
||||
# Backward-compatible alias for one release cycle.
|
||||
CaptureWorker = CaptureSource
|
||||
|
||||
|
||||
def open_capture(
|
||||
config: CaptureConfig,
|
||||
*,
|
||||
factory=None,
|
||||
start_background: Optional[bool] = None,
|
||||
start_worker: Optional[bool] = None,
|
||||
) -> CaptureSource:
|
||||
"""Open a capture source and optionally start its background thread.
|
||||
|
||||
For live cameras, the background thread starts by default (``config.background``).
|
||||
File/video sources stay synchronous unless ``start_background=True``.
|
||||
"""
|
||||
source = CaptureSource(config, factory=factory)
|
||||
source.open()
|
||||
should_start = config.background
|
||||
if start_background is not None:
|
||||
should_start = start_background
|
||||
elif start_worker is not None:
|
||||
should_start = start_worker
|
||||
live = is_live_camera(normalize_source(config.source))
|
||||
if should_start and live:
|
||||
source.start_background()
|
||||
return source
|
||||
|
||||
@@ -1,124 +0,0 @@
|
||||
"""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
|
||||
Reference in New Issue
Block a user