matrice-streaming 0.1.54__py3-none-any.whl → 0.1.56__py3-none-any.whl

matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py

@@ -2,10 +2,6 @@
 
 This module implements an async event loop worker that handles multiple cameras
 in a single process using asyncio for efficient I/O-bound operations.
-
-Supports two capture architectures (controlled by use_blocking_threads flag):
-1. Legacy: Per-camera asyncio tasks with ThreadPoolExecutor for capture
-2. Optimized: Dedicated blocking capture thread per camera with shared frame queue
 """
 import asyncio
 import logging
@@ -13,15 +9,11 @@ import time
 import multiprocessing
 import os
 import psutil
-import threading
-import queue
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass, field
 from typing import Dict, Any, Optional, List, Union, Tuple
 from collections import deque
 import cv2
 from pathlib import Path
-import numpy as np
 
 
 # =========================
@@ -80,425 +72,6 @@ cv2.setUseOptimized(True)
 cv2.ocl.setUseOpenCL(False)
 
 
-# =========================
-# FEATURE FLAGS
-# =========================
-USE_BLOCKING_THREADS = os.getenv("USE_BLOCKING_THREADS", "true").lower() == "true"
-
-
-# =========================
-# OPTIMIZED CAPTURE ARCHITECTURE
-# =========================
-
-@dataclass
-class CapturedFrame:
-    """Represents a captured frame ready for processing.
-
-    Used for thread-to-async communication in blocking capture mode.
-    Contains frame data and metadata needed for processing.
-    """
-    stream_key: str
-    frame: np.ndarray
-    timestamp_ns: int
-    frame_counter: int
-    width: int
-    height: int
-    camera_config: Dict[str, Any]
-    capture_time_ms: float
-    # SHM mode fields (populated by capture thread if SHM enabled)
-    shm_frame_idx: Optional[int] = None
-    shm_slot: Optional[int] = None
-    is_similar: bool = False
-    similarity_score: float = 0.0
-    reference_frame_idx: Optional[int] = None
-
-
-@dataclass
-class ShmMetadataItem:
-    """Lightweight metadata item for batched Redis writes in SHM mode.
-
-    When SHM is enabled, capture threads write frames directly to SHM
-    and enqueue only this metadata for the async loop to batch and send to Redis.
-    """
-    stream_key: str
-    stream_group_key: str
-    topic: str
-    shm_name: str
-    frame_idx: int
-    slot: int
-    ts_ns: int
-    width: int
-    height: int
-    format: str
-    is_similar: bool = False
-    reference_frame_idx: Optional[int] = None
-    similarity_score: Optional[float] = None
-    camera_location: str = "Unknown"
-    frame_counter: int = 0
-
-
-class CameraCapture:
-    """Blocking capture thread for a single camera.
-
-    Runs in a dedicated thread, captures frames at target FPS,
-    and either writes to SHM (with metadata enqueue) or enqueues
-    full frames for async processing.
-
-    Key design decisions:
-    - Uses time.sleep() for FPS throttling (not async) - no coroutine overhead
-    - Uses stop_event.wait() for interruptible sleep - fast shutdown
-    - Infinite retry with exponential backoff for camera reconnection
-    - Directly writes to SHM when enabled - minimal latency
-    """
-
-    # Retry settings
-    MIN_RETRY_COOLDOWN = 5   # 5 second minimum backoff
-    MAX_RETRY_COOLDOWN = 30  # 30 second maximum backoff
-    MAX_CONSECUTIVE_FAILURES = 10  # Max failures before reconnect
-
-    def __init__(
-        self,
-        camera_config: Dict[str, Any],
-        frame_queue: queue.Queue,
-        stop_event: threading.Event,
-        capture_manager: 'VideoCaptureManager',
-        frame_optimizer: Optional['FrameOptimizer'] = None,
-        # SHM support
-        use_shm: bool = False,
-        shm_buffer: Optional['ShmRingBuffer'] = None,
-        shm_frame_format: str = "BGR",
-        # Performance options
-        drop_stale_frames: bool = True,
-        buffer_size: int = 1,
-    ):
-        """Initialize capture thread for a single camera.
-
-        Args:
-            camera_config: Camera configuration dictionary
-            frame_queue: Queue for sending frames/metadata to async loop
-            stop_event: Event to signal thread shutdown
-            capture_manager: VideoCaptureManager for source handling
-            frame_optimizer: FrameOptimizer for similarity detection (optional)
-            use_shm: If True, write frames to SHM and enqueue metadata only
-            shm_buffer: ShmRingBuffer instance for this camera (if use_shm)
-            shm_frame_format: Frame format for SHM storage
-            drop_stale_frames: Use grab/grab/retrieve pattern for latest frame
-            buffer_size: VideoCapture buffer size
-        """
-        self.camera_config = camera_config
-        self.stream_key = camera_config['stream_key']
-        self.stream_group_key = camera_config.get('stream_group_key', 'default')
-        self.topic = camera_config['topic']
-        self.source = camera_config['source']
-        self.target_fps = camera_config.get('fps', 30)
-        self.width = camera_config.get('width')
-        self.height = camera_config.get('height')
-        self.camera_location = camera_config.get('camera_location', 'Unknown')
-        self.simulate_video_file_stream = camera_config.get('simulate_video_file_stream', False)
-
-        self.frame_queue = frame_queue
-        self.stop_event = stop_event
-        self.capture_manager = capture_manager
-        self.frame_optimizer = frame_optimizer
-
-        # SHM configuration
-        self.use_shm = use_shm
-        self.shm_buffer = shm_buffer
-        self.shm_frame_format = shm_frame_format
-
-        # Performance settings
-        self.drop_stale_frames = drop_stale_frames
-        self.buffer_size = buffer_size
-        self.frame_interval = 1.0 / self.target_fps
-
-        # State
-        self._thread: Optional[threading.Thread] = None
-        self._frame_counter = 0
-        self._last_shm_frame_idx: Optional[int] = None
-        self._is_running = False
-
-        self.logger = logging.getLogger(f"CameraCapture-{self.stream_key}")
-
-    def start(self) -> None:
-        """Start the capture thread."""
-        if self._thread and self._thread.is_alive():
-            self.logger.warning(f"Capture thread for {self.stream_key} already running")
-            return
-
-        self._is_running = True
-        self._thread = threading.Thread(
-            target=self._capture_loop,
-            name=f"capture-{self.stream_key}",
-            daemon=True
-        )
-        self._thread.start()
-        self.logger.info(f"Started capture thread for {self.stream_key}")
-
-    def stop(self, timeout: float = 5.0) -> None:
-        """Stop the capture thread gracefully."""
-        self._is_running = False
-        if self._thread and self._thread.is_alive():
-            self._thread.join(timeout=timeout)
-            if self._thread.is_alive():
-                self.logger.warning(f"Capture thread for {self.stream_key} did not stop in time")
-            else:
-                self.logger.info(f"Capture thread for {self.stream_key} stopped")
-
-    def is_alive(self) -> bool:
-        """Check if capture thread is running."""
-        return self._thread is not None and self._thread.is_alive()
-
-    def _capture_loop(self) -> None:
-        """Main blocking capture loop with infinite retry.
-
-        Structure mirrors the original _camera_handler but runs in a blocking thread:
-        - Outer loop: Infinite retry for camera reconnection
-        - Inner loop: Frame capture and processing
-        """
-        retry_cycle = 0
-        source_type = None
-
-        # OUTER LOOP: Infinite retry for reconnection
-        while not self.stop_event.is_set() and self._is_running:
-            cap = None
-            consecutive_failures = 0
-
-            try:
-                # Prepare source (download if URL)
-                prepared_source = self.capture_manager.prepare_source(
-                    self.source, self.stream_key
-                )
-
-                # Open capture (blocking)
-                cap, source_type = self.capture_manager.open_capture(
-                    prepared_source, self.width, self.height
-                )
-
-                # Get actual dimensions
-                actual_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-                actual_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-                if self.width or self.height:
-                    actual_width, actual_height = FrameProcessor.calculate_actual_dimensions(
-                        actual_width, actual_height, self.width, self.height
-                    )
-
-                # Reset retry on success
-                retry_cycle = 0
-
-                self.logger.info(
-                    f"Camera {self.stream_key} connected - "
-                    f"{actual_width}x{actual_height} @ {self.target_fps} FPS (type: {source_type})"
-                )
-
-                # INNER LOOP: Capture frames
-                while not self.stop_event.is_set() and self._is_running:
-                    frame_start = time.time()
-
-                    # Read latest frame
-                    ret, frame = self._read_latest_frame(cap)
-                    read_time = time.time() - frame_start
-
-                    if not ret:
-                        consecutive_failures += 1
-
-                        # Handle video file end
-                        if source_type == "video_file":
-                            if self.simulate_video_file_stream:
-                                self.logger.info(
-                                    f"Video {self.stream_key} ended, restarting "
-                                    f"(simulate_video_file_stream=True)"
-                                )
-                                self.stop_event.wait(1.0)  # Brief pause
-                                break  # Restart video
-                            else:
-                                self.logger.info(f"Video {self.stream_key} ended (no loop)")
-                                return  # Exit completely
-
-                        # For cameras, check failure threshold
-                        if consecutive_failures >= self.MAX_CONSECUTIVE_FAILURES:
-                            self.logger.warning(
-                                f"Camera {self.stream_key} - {self.MAX_CONSECUTIVE_FAILURES} "
-                                f"consecutive failures, reconnecting..."
-                            )
-                            break  # Reconnect
-
-                        self.stop_event.wait(0.1)
-                        continue
-
-                    # Reset failure counter
-                    consecutive_failures = 0
-                    self._frame_counter += 1
-
-                    # Resize if needed
-                    if self.width or self.height:
-                        frame = FrameProcessor.resize_frame(frame, self.width, self.height)
-
-                    # Process and enqueue frame
-                    self._process_and_enqueue_frame(
-                        frame, actual_width, actual_height, read_time
-                    )
-
-                    # FPS throttling (blocking sleep)
-                    elapsed = time.time() - frame_start
-                    sleep_time = self.frame_interval - elapsed
-                    if sleep_time > 0:
-                        # Use wait() for interruptible sleep
-                        self.stop_event.wait(sleep_time)
-
-            except Exception as exc:
-                self.logger.error(f"Camera {self.stream_key} error: {exc}", exc_info=True)
-            finally:
-                if cap:
-                    try:
-                        cap.release()
-                    except Exception:
-                        pass
-
-            # Check if we should retry
-            if self.stop_event.is_set() or not self._is_running:
-                break
-
-            # For video files with looping, restart immediately
-            if source_type == "video_file" and self.simulate_video_file_stream:
-                continue
-
-            # Exponential backoff for camera reconnection
-            cooldown = min(
-                self.MAX_RETRY_COOLDOWN,
-                self.MIN_RETRY_COOLDOWN + retry_cycle
-            )
-            self.logger.info(
-                f"Retrying camera {self.stream_key} in {cooldown}s (retry {retry_cycle})"
-            )
-            self.stop_event.wait(cooldown)
-            retry_cycle += 1
-
-        self.logger.info(f"Capture thread for {self.stream_key} exiting")
-
-    def _read_latest_frame(self, cap: cv2.VideoCapture) -> Tuple[bool, Optional[np.ndarray]]:
-        """Read latest frame, dropping stale buffered frames.
-
-        Uses grab/grab/retrieve pattern when drop_stale_frames is True.
-        """
-        if self.drop_stale_frames:
-            cap.grab()  # Clear stale frame
-            ret = cap.grab()  # Get current frame
-        else:
-            ret = cap.grab()
-
-        if not ret:
-            return False, None
-
-        ret, frame = cap.retrieve()
-        return ret, frame
-
-    def _process_and_enqueue_frame(
-        self,
-        frame: np.ndarray,
-        width: int,
-        height: int,
-        read_time: float
-    ) -> None:
-        """Process frame and add to queue for async loop.
-
-        In SHM mode: Write to SHM, enqueue metadata only
-        In JPEG mode: Enqueue full frame for encoding in async loop
-        """
-        ts_ns = int(time.time() * 1e9)
-
-        # Check frame similarity if optimizer available
-        is_similar = False
-        similarity_score = 0.0
-        reference_frame_idx = None
-
-        if self.frame_optimizer:
-            is_similar, similarity_score = self.frame_optimizer.is_similar(
-                frame, self.stream_key
-            )
-            if is_similar:
-                reference_frame_idx = self._last_shm_frame_idx
-
-        if self.use_shm and self.shm_buffer:
-            # SHM MODE: Write frame to SHM, enqueue metadata only
-            if is_similar and reference_frame_idx is not None:
-                # Similar frame - just enqueue metadata with reference
-                metadata = ShmMetadataItem(
-                    stream_key=self.stream_key,
-                    stream_group_key=self.stream_group_key,
-                    topic=self.topic,
-                    shm_name=self.shm_buffer.shm_name,
-                    frame_idx=reference_frame_idx,
-                    slot=-1,  # No new slot for similar frame
-                    ts_ns=ts_ns,
-                    width=width,
-                    height=height,
-                    format=self.shm_frame_format,
-                    is_similar=True,
-                    reference_frame_idx=reference_frame_idx,
-                    similarity_score=similarity_score,
-                    camera_location=self.camera_location,
-                    frame_counter=self._frame_counter,
-                )
-            else:
-                # Different frame - write to SHM
-                raw_bytes = self._convert_frame_for_shm(frame)
-                frame_idx, slot = self.shm_buffer.write_frame(raw_bytes)
-                self._last_shm_frame_idx = frame_idx
-
-                metadata = ShmMetadataItem(
-                    stream_key=self.stream_key,
-                    stream_group_key=self.stream_group_key,
-                    topic=self.topic,
-                    shm_name=self.shm_buffer.shm_name,
-                    frame_idx=frame_idx,
-                    slot=slot,
-                    ts_ns=ts_ns,
-                    width=width,
-                    height=height,
-                    format=self.shm_frame_format,
-                    is_similar=False,
-                    camera_location=self.camera_location,
-                    frame_counter=self._frame_counter,
-                )
-
-            # Enqueue metadata (non-blocking, drop if queue full)
-            try:
-                self.frame_queue.put_nowait(metadata)
-            except queue.Full:
-                self.logger.warning(f"Frame queue full, dropping metadata for {self.stream_key}")
-        else:
-            # JPEG MODE: Enqueue full frame for async processing
-            captured = CapturedFrame(
-                stream_key=self.stream_key,
-                frame=frame,
-                timestamp_ns=ts_ns,
-                frame_counter=self._frame_counter,
-                width=width,
-                height=height,
-                camera_config=self.camera_config,
-                capture_time_ms=read_time * 1000,
-                is_similar=is_similar,
-                similarity_score=similarity_score,
-                reference_frame_idx=reference_frame_idx,
-            )
-
-            try:
-                self.frame_queue.put_nowait(captured)
-            except queue.Full:
-                self.logger.warning(f"Frame queue full, dropping frame for {self.stream_key}")
-
-    def _convert_frame_for_shm(self, frame: np.ndarray) -> bytes:
-        """Convert frame to target format for SHM storage."""
-        if self.shm_frame_format == "RGB":
-            return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB).tobytes()
-        elif self.shm_frame_format == "NV12":
-            from matrice_common.stream.shm_ring_buffer import bgr_to_nv12
-            return bgr_to_nv12(frame)
-        else:  # BGR (default)
-            return frame.tobytes()
-
-
 class AsyncCameraWorker:
     """Async worker process that handles multiple cameras concurrently.
 
@@ -530,10 +103,6 @@ class AsyncCameraWorker:
         pin_cpu_affinity: bool = True,   # Pin worker to specific CPU cores
         total_workers: int = 1,          # Total worker count for CPU affinity calculation
         buffer_size: int = 1,            # Minimal buffer for low latency (cv2_bench uses 1)
-        # ================================================================
-        # BLOCKING THREADS: Optimized capture architecture (Phase 1)
-        # ================================================================
-        use_blocking_threads: bool = USE_BLOCKING_THREADS,  # Use blocking capture threads per camera
     ):
         """Initialize async camera worker.
 
@@ -554,7 +123,6 @@ class AsyncCameraWorker:
             pin_cpu_affinity: Pin worker process to specific CPU cores for cache locality
             total_workers: Total number of workers (for CPU affinity calculation)
             buffer_size: VideoCapture buffer size (1 = minimal latency)
-            use_blocking_threads: Use blocking capture threads instead of asyncio tasks (optimized mode)
         """
         self.worker_id = worker_id
         self.camera_configs = camera_configs
@@ -691,39 +259,6 @@ class AsyncCameraWorker:
         )
         self._log_system_resources("INIT")
 
-        # ========================================================================
-        # BLOCKING THREADS: Data structures for optimized capture architecture
-        # ========================================================================
-        self.use_blocking_threads = use_blocking_threads
-
-        if use_blocking_threads:
-            # Frame queue for thread-to-async communication
-            # Sized to handle burst: ~2 seconds of frames per camera
-            queue_size = max(1000, len(camera_configs) * 60)
-            self._frame_queue: queue.Queue = queue.Queue(maxsize=queue_size)
-
-            # Thread stop event (separate from process stop_event for cleaner shutdown)
-            self._thread_stop_event = threading.Event()
-
-            # Camera capture threads (stream_key -> CameraCapture)
-            self._capture_threads: Dict[str, CameraCapture] = {}
-
-            # Pending SHM metadata for batched Redis writes
-            self._shm_metadata_batch: List[ShmMetadataItem] = []
-            self._metadata_batch_lock = threading.Lock()
-
-            self.logger.info(
-                f"Worker {worker_id}: Blocking threads mode ENABLED "
-                f"(queue_size={queue_size}, per-camera capture threads)"
-            )
-        else:
-            self._frame_queue = None
-            self._thread_stop_event = None
-            self._capture_threads = {}
-            self._shm_metadata_batch = []
-            self._metadata_batch_lock = None
-            self.logger.info(f"Worker {worker_id}: Legacy asyncio tasks mode")
-
     async def _log_metrics(self) -> None:
         """Log comprehensive worker metrics periodically."""
         try:
@@ -811,118 +346,50 @@ class AsyncCameraWorker:
             raise
 
     async def run(self):
-        """Main worker loop - starts capture threads or async tasks based on mode."""
+        """Main worker loop - starts async tasks for all cameras and handles commands."""
         try:
-            # Initialize async resources (Redis client, etc.)
+            # Initialize async resources
             await self.initialize()
 
-            if self.use_blocking_threads:
-                # ================================================================
-                # OPTIMIZED MODE: Blocking capture threads + single async processor
-                # ================================================================
-                await self._run_blocking_threads_mode()
-            else:
-                # ================================================================
-                # LEGACY MODE: Per-camera asyncio tasks
-                # ================================================================
-                await self._run_legacy_async_mode()
-
-        except Exception as exc:
-            self.logger.error(f"Worker {self.worker_id}: Fatal error in run loop: {exc}", exc_info=True)
-            self._report_health("error", error=str(exc))
-            raise
-
-    async def _run_legacy_async_mode(self):
-        """Legacy mode: Per-camera asyncio tasks with ThreadPoolExecutor for capture."""
-        self.logger.info(f"Worker {self.worker_id}: Starting legacy asyncio mode")
-
-        # Start initial camera tasks using internal method
-        for camera_config in self.camera_configs:
-            await self._add_camera_internal(camera_config)
-
-        # Report initial health
-        self._report_health("running", len(self.camera_tasks))
+            # Start initial camera tasks using internal method
+            for camera_config in self.camera_configs:
+                await self._add_camera_internal(camera_config)
 
-        # Start command handler task if command queue is provided
-        command_task = None
-        if self.command_queue:
-            command_task = asyncio.create_task(
-                self._command_handler(),
-                name="command-handler"
-            )
-            self.logger.info(f"Worker {self.worker_id}: Command handler started")
-
-        # Monitor tasks and stop event
-        while not self.stop_event.is_set():
-            # Check for completed/failed tasks
-            for stream_key, task in list(self.camera_tasks.items()):
-                if task.done():
-                    try:
-                        # Check if task raised exception
-                        task.result()
-                        self.logger.warning(f"Worker {self.worker_id}: Camera {stream_key} task completed")
-                    except Exception as exc:
-                        self.logger.error(f"Worker {self.worker_id}: Camera {stream_key} task failed: {exc}")
-
-                    # Remove completed task
-                    del self.camera_tasks[stream_key]
-
-            # Report health periodically
+            # Report initial health
             self._report_health("running", len(self.camera_tasks))
 
-            # Sleep briefly
-            await asyncio.sleep(1.0)
-
-        # Stop event set - graceful shutdown
-        self.logger.info(f"Worker {self.worker_id}: Stop event detected, shutting down...")
-
-        # Cancel command handler if running
-        if command_task and not command_task.done():
-            command_task.cancel()
-            try:
-                await command_task
-            except asyncio.CancelledError:
-                pass
-
-        await self._shutdown()
-
-    async def _run_blocking_threads_mode(self):
-        """Optimized mode: Blocking capture threads + single async frame processor.
-
-        Architecture:
-        - One CameraCapture thread per camera (blocking I/O, time.sleep for FPS)
-        - Threads write to SHM (if enabled) and enqueue metadata to frame_queue
-        - Single async loop polls frame_queue and batches Redis writes
-        - Eliminates per-camera asyncio task overhead
-        """
-        self.logger.info(f"Worker {self.worker_id}: Starting blocking threads mode")
-
-        # Start capture threads for all cameras
-        self._start_capture_threads()
+            # Start command handler task if command queue is provided
+            command_task = None
+            if self.command_queue:
+                command_task = asyncio.create_task(
+                    self._command_handler(),
+                    name="command-handler"
+                )
+                self.logger.info(f"Worker {self.worker_id}: Command handler started")
+
+            # Monitor tasks and stop event
+            while not self.stop_event.is_set():
+                # Check for completed/failed tasks
+                for stream_key, task in list(self.camera_tasks.items()):
+                    if task.done():
+                        try:
+                            # Check if task raised exception
+                            task.result()
+                            self.logger.warning(f"Worker {self.worker_id}: Camera {stream_key} task completed")
+                        except Exception as exc:
+                            self.logger.error(f"Worker {self.worker_id}: Camera {stream_key} task failed: {exc}")
+
+                        # Remove completed task
+                        del self.camera_tasks[stream_key]
 
-        # Report initial health
-        active_cameras = len(self._capture_threads)
-        self._report_health("running", active_cameras)
+                # Report health periodically
+                self._report_health("running", len(self.camera_tasks))
 
-        # Start command handler task if command queue is provided
-        command_task = None
-        if self.command_queue:
-            command_task = asyncio.create_task(
-                self._command_handler(),
-                name="command-handler"
-            )
-            self.logger.info(f"Worker {self.worker_id}: Command handler started")
+                # Sleep briefly
+                await asyncio.sleep(1.0)
 
-        # Run the frame processor loop
-        try:
-            await self._run_frame_processor()
-        finally:
             # Stop event set - graceful shutdown
-            self.logger.info(f"Worker {self.worker_id}: Stop event detected, shutting down threads...")
-
-            # Signal threads to stop
-            if self._thread_stop_event:
-                self._thread_stop_event.set()
+            self.logger.info(f"Worker {self.worker_id}: Stop event detected, shutting down...")
 
             # Cancel command handler if running
             if command_task and not command_task.done():
@@ -934,276 +401,10 @@ class AsyncCameraWorker:
 
             await self._shutdown()
 
-    def _start_capture_threads(self) -> None:
-        """Start blocking capture threads for all cameras."""
-        for camera_config in self.camera_configs:
-            self._start_capture_thread(camera_config)
-
-        self.logger.info(
-            f"Worker {self.worker_id}: Started {len(self._capture_threads)} capture threads"
-        )
-
-    def _start_capture_thread(self, camera_config: Dict[str, Any]) -> None:
-        """Start a capture thread for a single camera."""
-        stream_key = camera_config.get('stream_key')
-        if not stream_key:
-            self.logger.error("Camera config missing stream_key")
-            return
-
-        if stream_key in self._capture_threads:
-            self.logger.warning(f"Capture thread for {stream_key} already exists")
-            return
-
-        # Get or create SHM buffer if needed
-        shm_buffer = None
-        if self.use_shm:
-            width = camera_config.get('width', 1920)
-            height = camera_config.get('height', 1080)
-            shm_buffer = self._get_or_create_shm_buffer(stream_key, width, height)
-
-        # Create and start capture thread
-        capture = CameraCapture(
-            camera_config=camera_config,
-            frame_queue=self._frame_queue,
-            stop_event=self._thread_stop_event,
-            capture_manager=self.capture_manager,
-            frame_optimizer=self.frame_optimizer if self.frame_optimizer.enabled else None,
-            use_shm=self.use_shm,
-            shm_buffer=shm_buffer,
-            shm_frame_format=self.shm_frame_format,
-            drop_stale_frames=self.drop_stale_frames,
-            buffer_size=self.buffer_size,
-        )
-        capture.start()
-        self._capture_threads[stream_key] = capture
-
-    async def _run_frame_processor(self) -> None:
-        """Main async loop that polls frame queue and batches Redis writes.
-
-        This replaces per-camera asyncio tasks with a single efficient loop:
-        - Polls frame queue (non-blocking)
-        - Batches metadata for Redis writes
-        - Flushes batches periodically or when full
-        - Reports health
-        """
-        poll_interval_ms = 1  # 1ms polling when idle
-        batch_timeout_ms = 25  # 25ms max batch wait (allows 4 flushes in 100ms SLA)
-        batch_size_limit = 100  # Max items per batch
-        health_report_interval = 1.0  # Report health every second
-
-        last_health_report = time.time()
-        last_batch_flush = time.time()
-
-        self.logger.info(
-            f"Worker {self.worker_id}: Frame processor started "
-            f"(batch_timeout={batch_timeout_ms}ms, batch_size={batch_size_limit})"
-        )
-
-        while not self.stop_event.is_set():
-            try:
-                frames_processed = 0
-                process_start = time.time()
-
-                # Poll queue for available items (non-blocking)
-                while True:
-                    try:
-                        item = self._frame_queue.get_nowait()
-                        await self._process_queue_item(item)
-                        frames_processed += 1
-
-                        # Check if batch is full or timeout reached
-                        if len(self._shm_metadata_batch) >= batch_size_limit:
-                            await self._flush_metadata_batch()
-                            last_batch_flush = time.time()
-                        elif (time.time() - last_batch_flush) * 1000 > batch_timeout_ms:
-                            await self._flush_metadata_batch()
-                            last_batch_flush = time.time()
-
-                        # Limit items per iteration to prevent starvation
-                        if frames_processed >= batch_size_limit * 2:
-                            break
-
-                    except queue.Empty:
-                        break
-
-                # Flush any remaining items if timeout reached
-                if self._shm_metadata_batch and (time.time() - last_batch_flush) * 1000 > batch_timeout_ms:
-                    await self._flush_metadata_batch()
-                    last_batch_flush = time.time()
-
-                # Report health periodically
-                current_time = time.time()
-                if current_time - last_health_report >= health_report_interval:
-                    active_threads = sum(1 for c in self._capture_threads.values() if c.is_alive())
-                    self._report_health("running", active_threads)
-                    last_health_report = current_time
-
-                # Brief yield to prevent busy-waiting when queue is empty
-                if frames_processed == 0:
-                    await asyncio.sleep(poll_interval_ms / 1000)
-
-            except Exception as exc:
-                self.logger.error(
-                    f"Worker {self.worker_id}: Error in frame processor: {exc}",
-                    exc_info=True
-                )
-                await asyncio.sleep(0.1)  # Brief pause on error
-
-        # Final flush of remaining items
-        if self._shm_metadata_batch:
-            await self._flush_metadata_batch()
-
-        self.logger.info(f"Worker {self.worker_id}: Frame processor stopped")
-
-    async def _process_queue_item(self, item: Union[ShmMetadataItem, CapturedFrame]) -> None:
-        """Process an item from the frame queue.
-
-        Args:
-            item: Either ShmMetadataItem (SHM mode) or CapturedFrame (JPEG mode)
-        """
-        if isinstance(item, ShmMetadataItem):
-            # SHM mode: Collect metadata for batched write
-            self._shm_metadata_batch.append(item)
-            # Update statistics
-            if item.is_similar:
-                self.statistics.increment_frames_skipped()
-            else:
-                self.statistics.increment_frames_sent()
-
-        elif isinstance(item, CapturedFrame):
-            # JPEG mode: Process and send frame
-            await self._process_captured_frame(item)
-
-    async def _process_captured_frame(self, captured: CapturedFrame) -> None:
-        """Process a captured frame in JPEG mode.
-
-        Args:
-            captured: CapturedFrame from queue
-        """
-        stream_key = captured.stream_key
-        config = captured.camera_config
-
-        # Get timing stats
-        last_read, last_write, last_process = self.statistics.get_timing(stream_key)
-        input_order = self.statistics.get_next_input_order(stream_key)
-
-        if captured.is_similar and captured.reference_frame_idx is not None:
-            # Similar frame - send cached reference
-            reference_frame_id = self._last_sent_frame_ids.get(stream_key)
-            if reference_frame_id:
-                metadata = self.message_builder.build_frame_metadata(
-                    config['source'], {}, config.get('fps', 30), config.get('quality', 90),
-                    captured.width, captured.height, "camera",
-                    captured.frame_counter, False, None, None, config.get('camera_location', 'Unknown')
-                )
-                metadata["similarity_score"] = captured.similarity_score
-
-                message = self.message_builder.build_message(
-                    frame_data=b"",
-                    stream_key=stream_key,
-                    stream_group_key=config.get('stream_group_key', 'default'),
-                    codec="cached",
-                    metadata=metadata,
-                    topic=config['topic'],
-                    broker_config=self.stream_config.get('bootstrap_servers', 'localhost:9092'),
-                    input_order=input_order,
-                    last_read_time=last_read,
-                    last_write_time=last_write,
-                    last_process_time=last_process,
-                    cached_frame_id=reference_frame_id,
-                )
-
-                write_start = time.time()
-                await self.redis_client.add_message(config['topic'], message)
-                write_time = time.time() - write_start
-
-                self.statistics.increment_frames_skipped()
-                self.statistics.update_timing(stream_key, captured.capture_time_ms / 1000, write_time, write_time, 0, 0)
-                return
-
-        # Encode frame
-        quality = config.get('quality', 90)
-        frame_data, codec = await self._encode_frame_async(captured.frame, quality)
-
-        # Build and send message
-        metadata = self.message_builder.build_frame_metadata(
-            config['source'], {}, config.get('fps', 30), quality,
-            captured.width, captured.height, "camera",
-            captured.frame_counter, False, None, None, config.get('camera_location', 'Unknown')
-        )
-        metadata["encoding_type"] = "jpeg"
-
-        message = self.message_builder.build_message(
-            frame_data, stream_key, config.get('stream_group_key', 'default'),
-            codec, metadata, config['topic'],
-            self.stream_config.get('bootstrap_servers', 'localhost:9092'),
-            input_order, last_read, last_write, last_process,
-            cached_frame_id=None,
-        )
-
-        write_start = time.time()
-        await self.redis_client.add_message(config['topic'], message)
-        write_time = time.time() - write_start
-
-        # Track frame_id for future cached references
-        new_frame_id = message.get("frame_id")
-        if new_frame_id:
-            self._last_sent_frame_ids[stream_key] = new_frame_id
-
-        # Update statistics
-        self.statistics.increment_frames_sent()
-        frame_size = len(frame_data) if frame_data else 0
-        self.statistics.update_timing(
-            stream_key, captured.capture_time_ms / 1000, write_time,
-            write_time + captured.capture_time_ms / 1000, frame_size, 0
-        )
-
-    async def _flush_metadata_batch(self) -> None:
-        """Flush pending SHM metadata to Redis as a batch.
-
-        Uses Redis pipeline for efficient multi-message writes.
-        """
-        if not self._shm_metadata_batch:
-            return
-
-        batch = self._shm_metadata_batch
-        self._shm_metadata_batch = []
-
-        batch_start = time.time()
-
-        try:
-            # Send each metadata item (batching is handled by redis_client)
-            for item in batch:
-                await self.redis_client.add_shm_metadata(
-                    stream_name=item.topic,
-                    cam_id=item.stream_key,
-                    shm_name=item.shm_name,
-                    frame_idx=item.frame_idx,
-                    slot=item.slot if item.slot >= 0 else None,
-                    ts_ns=item.ts_ns,
-                    width=item.width,
-                    height=item.height,
-                    format=item.format,
-                    is_similar=item.is_similar,
-                    reference_frame_idx=item.reference_frame_idx,
-                    similarity_score=item.similarity_score,
-                    stream_group_key=item.stream_group_key,
-                    camera_location=item.camera_location,
-                    frame_counter=item.frame_counter,
-                )
-
-            batch_time = (time.time() - batch_start) * 1000
-            if batch_time > 50:  # Log slow batches
-                self.logger.warning(
-                    f"Worker {self.worker_id}: Slow batch flush - "
-                    f"{len(batch)} items in {batch_time:.1f}ms"
-                )
-
         except Exception as exc:
-            self.logger.error(
-                f"Worker {self.worker_id}: Failed to flush metadata batch: {exc}",
-                exc_info=True
-            )
+            self.logger.error(f"Worker {self.worker_id}: Fatal error in run loop: {exc}", exc_info=True)
+            self._report_health("error", error=str(exc))
+            raise
 
     async def _read_latest_frame(
         self,
@@ -1801,22 +1002,8 @@ class AsyncCameraWorker:
     # ========================================================================
 
     async def _command_handler(self):
-        """Process commands from the manager (runs in async loop).
-
-        Phase 6: Adaptive backoff polling to reduce overhead for rare commands.
-        - Start at 100ms poll interval
-        - Exponential backoff when idle (up to 1s)
-        - Speed up after command received (down to 50ms)
-        """
-        self.logger.info(f"Worker {self.worker_id}: Command handler started (adaptive polling)")
-
-        # Adaptive polling parameters (Phase 6)
-        MIN_POLL_INTERVAL = 0.05  # 50ms - fast when active
-        MAX_POLL_INTERVAL = 1.0   # 1s - slow when idle
-        INITIAL_POLL_INTERVAL = 0.1  # 100ms - starting point
-        BACKOFF_MULTIPLIER = 1.5  # Exponential backoff factor
-
-        poll_interval = INITIAL_POLL_INTERVAL
+        """Process commands from the manager (runs in async loop)."""
+        self.logger.info(f"Worker {self.worker_id}: Command handler started")
 
         while not self.stop_event.is_set():
             try:
@@ -1828,12 +1015,9 @@ class AsyncCameraWorker:
 
                 if command:
                     await self._process_command(command)
-                    # Speed up polling after receiving command (more likely to get another)
-                    poll_interval = MIN_POLL_INTERVAL
                 else:
-                    # Exponential backoff when idle to reduce polling overhead
-                    poll_interval = min(poll_interval * BACKOFF_MULTIPLIER, MAX_POLL_INTERVAL)
-                    await asyncio.sleep(poll_interval)
+                    # Small sleep when no commands to avoid busy-waiting
+                    await asyncio.sleep(0.1)
 
             except asyncio.CancelledError:
                 self.logger.info(f"Worker {self.worker_id}: Command handler cancelled")
@@ -1984,35 +1168,7 @@ class AsyncCameraWorker:
         """Gracefully shutdown worker - cancel tasks and cleanup."""
         self.logger.info(f"Worker {self.worker_id}: Starting graceful shutdown")
 
-        # ================================================================
-        # BLOCKING THREADS: Stop capture threads first
-        # ================================================================
-        if self.use_blocking_threads and self._thread_stop_event:
-            self.logger.info(f"Worker {self.worker_id}: Stopping capture threads...")
-            self._thread_stop_event.set()
-
-            # Stop each capture thread
-            for stream_key, capture in list(self._capture_threads.items()):
-                try:
-                    capture.stop()
-                    self.logger.debug(f"Worker {self.worker_id}: Stopped capture thread for {stream_key}")
-                except Exception as e:
-                    self.logger.warning(f"Worker {self.worker_id}: Error stopping capture {stream_key}: {e}")
-            self._capture_threads.clear()
-
-            # Drain frame queue to prevent blocking
-            if self._frame_queue:
-                drained = 0
-                while not self._frame_queue.empty():
-                    try:
-                        self._frame_queue.get_nowait()
-                        drained += 1
-                    except queue.Empty:
-                        break
-                if drained > 0:
-                    self.logger.debug(f"Worker {self.worker_id}: Drained {drained} items from frame queue")
-
-        # Cancel all camera tasks (legacy mode)
+        # Cancel all camera tasks
         for stream_key, task in self.camera_tasks.items():
             if not task.done():
                 task.cancel()
@@ -2022,7 +1178,7 @@ class AsyncCameraWorker:
         if self.camera_tasks:
             await asyncio.gather(*self.camera_tasks.values(), return_exceptions=True)
 
-        # Release all captures (legacy mode uses self.captures)
+        # Release all captures
         for stream_key, cap in list(self.captures.items()):
             cap.release()
             self.logger.info(f"Worker {self.worker_id}: Released capture {stream_key}")
@@ -2161,10 +1317,6 @@ def run_async_worker(
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
     buffer_size: int = 1,
-    # ================================================================
-    # BLOCKING THREADS: Optimized capture architecture (Phase 1)
-    # ================================================================
-    use_blocking_threads: bool = USE_BLOCKING_THREADS,
 ):
     """Entry point for async worker process.
 
@@ -2185,7 +1337,6 @@ def run_async_worker(
         pin_cpu_affinity: Pin worker process to specific CPU cores
         total_workers: Total number of workers for CPU affinity calculation
         buffer_size: VideoCapture buffer size (1 = minimal latency)
-        use_blocking_threads: Use blocking capture threads instead of asyncio tasks
     """
     # Setup logging for this process
     logging.basicConfig(
@@ -2227,8 +1378,6 @@ def run_async_worker(
             pin_cpu_affinity=pin_cpu_affinity,
             total_workers=total_workers,
             buffer_size=buffer_size,
-            # BLOCKING THREADS: Pass through optimized capture architecture parameter
-            use_blocking_threads=use_blocking_threads,
         )
 
         # Run event loop