matrice-streaming 0.1.70__tar.gz → 0.1.72__tar.gz

{matrice_streaming-0.1.70 → matrice_streaming-0.1.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.70
+Version: 0.1.72
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_streaming-0.1.70 → matrice_streaming-0.1.72}/matrice_streaming.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.70
+Version: 0.1.72
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_streaming-0.1.70 → matrice_streaming-0.1.72}/src/matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py

@@ -100,7 +100,8 @@ class AsyncCameraWorker:
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
         drop_stale_frames: bool = False,  # Disabled for ML quality
-        pin_cpu_affinity: bool = True,   # Pin worker to specific CPU cores
+        use_simple_read: bool = True,    # Use cap.read() directly instead of grab/retrieve
+        pin_cpu_affinity: bool = False,  # Let OS distribute threads (avoids cache contention)
         total_workers: int = 1,          # Total worker count for CPU affinity calculation
         buffer_size: int = 1,            # Minimal buffer for low latency (cv2_bench uses 1)
     ):
@@ -120,6 +121,7 @@ class AsyncCameraWorker:
             shm_slot_count: Number of frame slots per camera ring buffer
             shm_frame_format: Frame format for SHM storage ("BGR", "RGB", or "NV12")
             drop_stale_frames: Use grab()/grab()/retrieve() pattern to get latest frame
+            use_simple_read: Use cap.read() directly instead of grab/retrieve pattern
             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)
@@ -207,6 +209,7 @@ class AsyncCameraWorker:
         # PERFORMANCE: Optimized frame capture configuration
         # ================================================================
         self.drop_stale_frames = drop_stale_frames
+        self.use_simple_read = use_simple_read
         self.pin_cpu_affinity = pin_cpu_affinity
         self.total_workers = total_workers
         self.buffer_size = buffer_size
@@ -225,6 +228,9 @@ class AsyncCameraWorker:
         if drop_stale_frames:
             self.logger.info(f"Worker {worker_id}: Frame dropping ENABLED (grab/grab/retrieve pattern)")
 
+        if use_simple_read:
+            self.logger.info(f"Worker {worker_id}: Simple read ENABLED (cap.read() directly)")
+
         # ThreadPoolExecutor for I/O-bound frame capture only
         # Encoding is done inline (cv2.imencode releases GIL, ~5ms for 480p)
         #
@@ -234,8 +240,8 @@ class AsyncCameraWorker:
         # - But TOO many threads causes burst frame arrivals → Redis write queue backup
         # - Cap at 64 threads to balance I/O parallelism vs write contention
         num_cameras = len(camera_configs)
-        # Use 1 thread per camera, capped at 64 to prevent write burst contention
-        num_capture_threads = min(64, max(8, num_cameras))
+        # Use 1 thread per camera, max 64 for reduced contention
+        num_capture_threads = min(64, num_cameras)
         self.capture_executor = ThreadPoolExecutor(max_workers=num_capture_threads)
         self.num_capture_threads = num_capture_threads
 
@@ -329,9 +335,10 @@ class AsyncCameraWorker:
 
             # Create MatriceStream with async support
             # Unpack stream_config as keyword arguments (MatriceStream expects **config)
+            # NOTE: enable_shm_batching=False for real-time frame delivery (avoids batch delays)
             self.stream = MatriceStream(
                 stream_type=StreamType.REDIS,
-                enable_shm_batching=True,
+                enable_shm_batching=False,
                 **self.stream_config
             )
 
@@ -409,23 +416,33 @@ class AsyncCameraWorker:
     async def _read_latest_frame(
         self,
         cap: cv2.VideoCapture,
-        drop_stale: bool = True
+        drop_stale: bool = False,
+        use_simple_read: bool = False,
     ) -> Tuple[bool, Optional[Any]]:
-        """Read latest frame, optionally dropping stale buffered frames.
+        """Read frame from video capture.
 
-        This optimization from cv2_bench.py uses grab()/grab()/retrieve()
-        pattern to always get the most recent frame instead of reading
-        stale frames from the buffer.
+        Three modes available:
+        1. use_simple_read=True: Uses cap.read() directly - best for video files
+        2. drop_stale=True: Uses grab/grab/retrieve to skip stale buffered frames
+        3. drop_stale=False: Uses grab/retrieve (no frame dropping)
 
         Args:
             cap: OpenCV VideoCapture object
             drop_stale: If True, use grab/grab/retrieve pattern to skip stale frames
+            use_simple_read: If True, use cap.read() directly (ignores drop_stale)
 
         Returns:
             Tuple of (success, frame) where frame is None if read failed
         """
         loop = asyncio.get_event_loop()
 
+        # SIMPLE READ: Use cap.read() directly - best for video files
+        # This reads frames sequentially without any buffer manipulation
+        if use_simple_read:
+            ret, frame = await loop.run_in_executor(self.capture_executor, cap.read)
+            return ret, frame
+
+        # GRAB/RETRIEVE PATTERN: For live streams where we want latest frame
         if drop_stale:
             # Aggressive frame dropping: grab twice to get latest frame
             # First grab clears any stale frame, second grab gets current
@@ -514,7 +531,9 @@ class AsyncCameraWorker:
                         # This gets the latest frame and drops stale buffered frames
                         read_start = time.time()
                         ret, frame = await self._read_latest_frame(
-                            cap, drop_stale=self.drop_stale_frames
+                            cap,
+                            drop_stale=self.drop_stale_frames,
+                            use_simple_read=self.use_simple_read,
                         )
                         read_time = time.time() - read_start
 
@@ -586,7 +605,8 @@ class AsyncCameraWorker:
                         return  # Exit completely on cancellation
                     except Exception as exc:
                         self.logger.error(
-                            f"Worker {self.worker_id}: Error in camera {stream_key}: {exc}",
+                            f"Worker {self.worker_id}: Error in camera {stream_key} "
+                            f"at frame {frame_counter}: {exc}",
                             exc_info=True
                         )
                         consecutive_failures += 1
@@ -596,7 +616,7 @@ class AsyncCameraWorker:
                                 f"max failures in inner loop, reconnecting..."
                             )
                             break  # Break inner loop to reconnect
-                        await asyncio.sleep(1.0)
+                        await asyncio.sleep(0.1)  # Reduced from 1.0s to minimize frame loss
 
             except asyncio.CancelledError:
                 self.logger.info(f"Worker {self.worker_id}: Camera {stream_key} task cancelled during setup")
@@ -1314,7 +1334,8 @@ def run_async_worker(
     # PERFORMANCE: New parameters for optimized frame capture
     # ================================================================
     drop_stale_frames: bool = False,  # Disabled for ML quality
-    pin_cpu_affinity: bool = True,
+    use_simple_read: bool = True,     # Use cap.read() directly instead of grab/retrieve
+    pin_cpu_affinity: bool = False,   # Let OS distribute (avoids cache contention)
     total_workers: int = 1,
     buffer_size: int = 1,
     # ================================================================
@@ -1338,6 +1359,7 @@ def run_async_worker(
         shm_slot_count: Number of frame slots per camera ring buffer
         shm_frame_format: Frame format for SHM storage
         drop_stale_frames: Use grab()/grab()/retrieve() pattern for latest frame
+        use_simple_read: Use cap.read() directly instead of grab/retrieve pattern
         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)
@@ -1380,6 +1402,7 @@ def run_async_worker(
             shm_frame_format=shm_frame_format,
             # PERFORMANCE: Pass through optimized frame capture parameters
             drop_stale_frames=drop_stale_frames,
+            use_simple_read=use_simple_read,
             pin_cpu_affinity=pin_cpu_affinity,
             total_workers=total_workers,
             buffer_size=buffer_size,

{matrice_streaming-0.1.70 → matrice_streaming-0.1.72}/src/matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py

@@ -44,7 +44,8 @@ class WorkerManager:
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
         drop_stale_frames: bool = False,   # Use grab()/grab()/retrieve() for latest frame (disabled for ML quality)
-        pin_cpu_affinity: bool = True,    # Pin workers to specific CPU cores
+        use_simple_read: bool = True,      # Use cap.read() directly instead of grab/retrieve
+        pin_cpu_affinity: bool = False,   # Let OS distribute (avoids cache contention)
         buffer_size: int = 1,             # VideoCapture buffer size (1 = minimal latency)
         # ================================================================
         # FRAME OPTIMIZER: Control frame similarity detection
@@ -64,6 +65,7 @@ class WorkerManager:
             shm_slot_count: Number of frame slots per camera ring buffer
             shm_frame_format: Frame format for SHM storage
             drop_stale_frames: Use grab()/grab()/retrieve() pattern for latest frame
+            use_simple_read: Use cap.read() directly instead of grab/retrieve pattern
             pin_cpu_affinity: Pin worker processes to specific CPU cores for cache locality
             buffer_size: VideoCapture buffer size (1 = minimal latency)
             frame_optimizer_enabled: Enable frame similarity detection (skip similar frames for bandwidth saving)
@@ -76,17 +78,18 @@ class WorkerManager:
             cpu_count = os.cpu_count() or 4  # Fallback to 4 if can't detect
             num_cameras = len(camera_configs)
 
-            # For systems with 16+ cores OR large camera counts, use camera-based calculation
-            # This applies to Docker containers with limited CPU allocation (e.g., 20 cores)
-            # Too many workers = process overhead; too few = underutilization
-            # Target: ~25 cameras per worker for better read parallelism with video files
-            if cpu_count >= 16 or num_cameras >= 100:
+            # Small deployments: 1 worker per camera for maximum parallelism
+            # Each worker process has its own GIL, enabling true CPU parallelism
+            if num_cameras <= 10:
+                calculated_workers = max(1, num_cameras)
+            # Large deployments: use camera-based calculation
+            elif cpu_count >= 16 or num_cameras >= 100:
                 # Use camera-based calculation for better distribution
                 # 1000 cameras / 25 cameras per worker = 40 workers
                 target_cameras_per_worker = 25
                 calculated_workers = max(4, min(num_cameras // target_cameras_per_worker, 50))
             else:
-                # Standard calculation for smaller systems
+                # Standard calculation for medium systems
                 calculated_workers = max(4, int(cpu_count * cpu_percentage))
 
             # Cap at camera count (no point having more workers than cameras)
@@ -124,6 +127,7 @@ class WorkerManager:
         # PERFORMANCE: Store optimized frame capture configuration
         # ================================================================
         self.drop_stale_frames = drop_stale_frames
+        self.use_simple_read = use_simple_read
         self.pin_cpu_affinity = pin_cpu_affinity
         self.buffer_size = buffer_size
 
@@ -307,6 +311,7 @@ class WorkerManager:
                     self.shm_frame_format,
                     # PERFORMANCE: Pass optimized frame capture parameters
                     self.drop_stale_frames,
+                    self.use_simple_read,
                     self.pin_cpu_affinity,
                     self.num_workers,     # Total workers for CPU affinity calculation
                     self.buffer_size,