matrice-streaming 0.1.69__tar.gz → 0.1.71__tar.gz

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/PKG-INFO

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

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/matrice_streaming.egg-info/PKG-INFO

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

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/async_camera_worker.py

@@ -88,7 +88,7 @@ class AsyncCameraWorker:
         health_queue: multiprocessing.Queue,
         command_queue: Optional[multiprocessing.Queue] = None,
         response_queue: Optional[multiprocessing.Queue] = None,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
         # ================================================================
         # SHM_MODE: New parameters for shared memory architecture
@@ -99,7 +99,8 @@ class AsyncCameraWorker:
         # ================================================================
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
-        drop_stale_frames: bool = True,  # Use grab()/grab()/retrieve() pattern for latest frame
+        drop_stale_frames: bool = False,  # Disabled for ML quality
+        use_simple_read: bool = True,    # Use cap.read() directly instead of grab/retrieve
         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)
@@ -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)
         #
@@ -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")
@@ -1313,10 +1333,15 @@ def run_async_worker(
     # ================================================================
     # PERFORMANCE: New parameters for optimized frame capture
     # ================================================================
-    drop_stale_frames: bool = True,
+    drop_stale_frames: bool = False,  # Disabled for ML quality
+    use_simple_read: bool = True,     # Use cap.read() directly instead of grab/retrieve
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
     buffer_size: int = 1,
+    # ================================================================
+    # FRAME OPTIMIZER: Control frame similarity detection
+    # ================================================================
+    frame_optimizer_enabled: bool = False,  # Disabled for ML quality
 ):
     """Entry point for async worker process.
 
@@ -1334,9 +1359,11 @@ 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)
+        frame_optimizer_enabled: Enable frame similarity detection (skip similar frames)
     """
     # Setup logging for this process
     logging.basicConfig(
@@ -1375,9 +1402,12 @@ 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,
+            # FRAME OPTIMIZER: Pass through frame similarity detection setting
+            frame_optimizer_enabled=frame_optimizer_enabled,
         )
 
         # Run event loop

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/async_ffmpeg_worker.py

@@ -86,7 +86,7 @@ class AsyncFFmpegWorker:
         pin_cpu_affinity: bool = True,
         total_workers: int = 1,
         # Frame optimizer options
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize async FFmpeg worker.
@@ -905,7 +905,7 @@ def run_ffmpeg_worker(
     shm_frame_format: str = "BGR",
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
-    frame_optimizer_enabled: bool = True,
+    frame_optimizer_enabled: bool = False,  # Disabled for ML quality
     frame_optimizer_config: Optional[Dict[str, Any]] = None,
 ):
     """Entry point for FFmpeg worker process.

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/camera_streamer.py

@@ -41,7 +41,7 @@ class CameraStreamer:
         gateway_util: StreamingGatewayUtil = None,
         connection_refresh_threshold: int = 10,
         connection_refresh_interval: float = 60.0,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize CameraStreamer.

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_camera_streamer.py

@@ -315,7 +315,7 @@ class FFmpegCameraStreamer:
         shm_slot_count: int = 1000,
         shm_frame_format: str = "BGR",
         # Frame optimizer options
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
         # CPU affinity options
         pin_cpu_affinity: bool = False,

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/gstreamer_camera_streamer.py

@@ -532,7 +532,7 @@ class GStreamerCameraStreamer:
         video_codec: Optional[str] = None,
         gateway_util: StreamingGatewayUtil = None,
         gstreamer_config: Optional[GStreamerConfig] = None,
-        frame_optimizer_enabled: bool = True,
+        frame_optimizer_enabled: bool = False,  # Disabled for ML quality
         frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize GStreamerCameraStreamer.

{matrice_streaming-0.1.69 → matrice_streaming-0.1.71}/src/matrice_streaming/streaming_gateway/camera_streamer/worker_manager.py

@@ -43,9 +43,14 @@ class WorkerManager:
         # ================================================================
         # PERFORMANCE: New parameters for optimized frame capture
         # ================================================================
-        drop_stale_frames: bool = True,   # Use grab()/grab()/retrieve() for latest frame
+        drop_stale_frames: bool = False,   # Use grab()/grab()/retrieve() for latest frame (disabled for ML quality)
+        use_simple_read: bool = True,      # Use cap.read() directly instead of grab/retrieve
         pin_cpu_affinity: bool = True,    # Pin workers to specific CPU cores
         buffer_size: int = 1,             # VideoCapture buffer size (1 = minimal latency)
+        # ================================================================
+        # FRAME OPTIMIZER: Control frame similarity detection
+        # ================================================================
+        frame_optimizer_enabled: bool = False,  # Enable frame similarity detection (disabled for ML quality)
     ):
         """Initialize worker manager with dynamic CPU-based scaling.
 
@@ -60,8 +65,10 @@ 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)
         """
         self.camera_configs = camera_configs
         self.stream_config = stream_config
@@ -119,17 +126,32 @@ 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
 
-        if drop_stale_frames or pin_cpu_affinity:
+        # ================================================================
+        # FRAME OPTIMIZER: Store frame similarity detection configuration
+        # ================================================================
+        self.frame_optimizer_enabled = frame_optimizer_enabled
+
+        if frame_optimizer_enabled:
             self.logger.info(
-                f"PERFORMANCE OPTIMIZATIONS ENABLED: "
-                f"drop_stale_frames={drop_stale_frames}, "
-                f"pin_cpu_affinity={pin_cpu_affinity}, "
-                f"buffer_size={buffer_size}"
+                "FRAME OPTIMIZER ENABLED: Similar frames will be skipped (may reduce ML quality)"
             )
 
+        if drop_stale_frames:
+            self.logger.info(
+                "DROP STALE FRAMES ENABLED: Using grab/grab/retrieve pattern (may reduce ML quality)"
+            )
+
+        self.logger.info(
+            f"Worker config: frame_optimizer={frame_optimizer_enabled}, "
+            f"drop_stale_frames={drop_stale_frames}, "
+            f"pin_cpu_affinity={pin_cpu_affinity}, "
+            f"buffer_size={buffer_size}"
+        )
+
         # Note: Batch parameters are calculated per-worker in _start_worker()
         # based on each worker's camera count, not the global total.
         # This ensures optimal batching when cameras are distributed across workers.
@@ -288,9 +310,12 @@ 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,
+                    # FRAME OPTIMIZER: Pass frame similarity detection setting
+                    self.frame_optimizer_enabled,
                 ),
                 name=f"AsyncWorker-{worker_id}",
                 daemon=False  # Non-daemon so we can properly wait for shutdown