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

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

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

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

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

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

@@ -101,7 +101,7 @@ class AsyncCameraWorker:
         # ================================================================
         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
+        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)
     ):
@@ -240,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
 
@@ -495,6 +495,9 @@ class AsyncCameraWorker:
             cap = None
             consecutive_failures = 0
             frame_counter = 0
+            # PTS-based pacing for video files
+            first_video_ms = None
+            first_wall_time = None
 
             try:
                 # Prepare source (download if URL)
@@ -570,6 +573,18 @@ class AsyncCameraWorker:
                         consecutive_failures = 0
                         frame_counter += 1
 
+                        # Get video file timestamp (for video files, use video PTS instead of wall clock)
+                        # This prevents timestamp jumps when pipeline stalls
+                        video_ts_ms = cap.get(cv2.CAP_PROP_POS_MSEC) if source_type == "video_file" else None
+
+                        # Frame decimation: Read ALL frames, skip based on target FPS
+                        # This avoids sleep-based throttling which misses frames
+                        source_fps = video_props.get('original_fps', 30) if video_props else 30
+                        if fps > 0 and source_fps > fps:
+                            skip_ratio = int(source_fps / fps)
+                            if skip_ratio > 1 and frame_counter % skip_ratio != 0:
+                                continue  # Skip this frame, read next immediately
+
                         # Resize if needed
                         if width or height:
                             frame = FrameProcessor.resize_frame(frame, width, height)
@@ -581,7 +596,7 @@ class AsyncCameraWorker:
                             await self._process_frame_shm_mode(
                                 frame, stream_key, stream_group_key, topic,
                                 actual_width, actual_height, frame_counter,
-                                camera_location, read_time
+                                camera_location, read_time, video_ts_ms
                             )
                         else:
                             # EXISTING FLOW: JPEG encode and send full frame
@@ -589,16 +604,22 @@ class AsyncCameraWorker:
                                 frame, stream_key, stream_group_key, topic,
                                 source, video_props, fps, quality,
                                 actual_width, actual_height, source_type,
-                                frame_counter, camera_location, read_time
+                                frame_counter, camera_location, read_time,
+                                video_ts_ms
                             )
 
-                        # Maintain target FPS for ALL sources (video files AND live cameras)
-                        # This prevents overwhelming the encoder by reading at native camera rate (30+ FPS)
-                        frame_interval = 1.0 / fps
-                        frame_elapsed = time.time() - read_start
-                        sleep_time = max(0, frame_interval - frame_elapsed)
-                        if sleep_time > 0:
-                            await asyncio.sleep(sleep_time)
+                        # PTS-based pacing for video files (smooth playback without drift)
+                        # Instead of fixed-interval sleep, pace based on video timeline
+                        if source_type == "video_file" and video_ts_ms is not None:
+                            if first_video_ms is None:
+                                first_video_ms = video_ts_ms
+                                first_wall_time = time.time()
+                            else:
+                                # Calculate target wall time based on video PTS
+                                target_wall = first_wall_time + (video_ts_ms - first_video_ms) / 1000.0
+                                sleep_time = target_wall - time.time()
+                                if sleep_time > 0:
+                                    await asyncio.sleep(sleep_time)
 
                     except asyncio.CancelledError:
                         self.logger.info(f"Worker {self.worker_id}: Camera {stream_key} task cancelled")
@@ -671,7 +692,8 @@ class AsyncCameraWorker:
         source_type: str,
         frame_counter: int,
         camera_location: str,
-        read_time: float
+        read_time: float,
+        video_ts_ms: Optional[float] = None
     ):
         """Process frame and send to Redis asynchronously.
 
@@ -692,6 +714,7 @@ class AsyncCameraWorker:
             frame_counter: Current frame number
             camera_location: Camera location
             read_time: Time taken to read frame
+            video_ts_ms: Video file timestamp in milliseconds (None for live streams)
         """
         frame_start = time.time()
 
@@ -865,7 +888,8 @@ class AsyncCameraWorker:
         height: int,
         frame_counter: int,
         camera_location: str,
-        read_time: float
+        read_time: float,
+        video_ts_ms: Optional[float] = None
     ):
         """SHM_MODE: Write raw frame to SHM, send metadata to Redis.
 
@@ -882,6 +906,7 @@ class AsyncCameraWorker:
             frame_counter: Current frame number
             camera_location: Camera location string
             read_time: Time taken to read frame
+            video_ts_ms: Video file timestamp in milliseconds (None for live streams)
         """
         frame_start = time.time()
 
@@ -895,7 +920,11 @@ class AsyncCameraWorker:
         if is_similar and reference_frame_idx is not None:
             # Frame is similar - send metadata with reference to previous frame
             # Consumer can skip reading SHM and use previous result
-            ts_ns = int(time.time() * 1e9)
+            # Use video PTS for video files, wall clock for live streams
+            if video_ts_ms is not None:
+                ts_ns = int(video_ts_ms * 1e6)  # Convert ms to ns
+            else:
+                ts_ns = int(time.time() * 1e9)
             shm_buffer = self._shm_buffers.get(stream_key)
 
             await self.redis_client.add_shm_metadata(
@@ -950,7 +979,11 @@ class AsyncCameraWorker:
         self._last_shm_frame_idx[stream_key] = frame_idx
 
         # Send metadata-only message to Redis
-        ts_ns = int(time.time() * 1e9)
+        # Use video PTS for video files, wall clock for live streams
+        if video_ts_ms is not None:
+            ts_ns = int(video_ts_ms * 1e6)  # Convert ms to ns
+        else:
+            ts_ns = int(time.time() * 1e9)
         write_start = time.time()
 
         await self.redis_client.add_shm_metadata(
@@ -1335,7 +1368,7 @@ def run_async_worker(
     # ================================================================
     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_cpu_affinity: bool = False,   # Let OS distribute (avoids cache contention)
     total_workers: int = 1,
     buffer_size: int = 1,
     # ================================================================

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

@@ -45,7 +45,7 @@ class WorkerManager:
         # ================================================================
         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
+        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
@@ -78,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)