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

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

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

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

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

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

@@ -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(

{matrice_streaming-0.1.72 → matrice_streaming-0.1.74}/src/matrice_streaming/streaming_gateway/camera_streamer/nvdec.py

@@ -393,6 +393,16 @@ class StreamConfig:
     height: int = 640
     target_fps: int = 10
     gpu_id: int = 0
+    stream_type: str = "file"  # "file" or "rtsp"
+
+    def __post_init__(self):
+        """Auto-detect stream_type from video_path if not explicitly set."""
+        if self.video_path.startswith("rtsp://") or self.video_path.startswith("rtsps://"):
+            self.stream_type = "rtsp"
+        elif self.video_path.startswith("http://") or self.video_path.startswith("https://"):
+            self.stream_type = "file"  # Downloaded files
+        else:
+            self.stream_type = "file"
 
 
 @dataclass
@@ -424,6 +434,8 @@ class StreamState:
     empty_packets: int = 0
     decode_errors: int = 0  # Consecutive decode errors
     MAX_DECODE_ERRORS: int = 5  # Restart demuxer after this many consecutive errors
+    stream_type: str = "file"  # "file" or "rtsp"
+    source_fps: float = 30.0  # Source video FPS for timestamp calculation
 
 
 # =============================================================================
@@ -620,11 +632,20 @@ class NVDECDecoderPool:
         logger.info(f"Created NVDEC pool: {self.actual_pool_size}/{pool_size} decoders on GPU {gpu_id}")
 
     def assign_stream(self, stream_id: int, camera_id: str, video_path: str,
-                      width: int = 640, height: int = 640) -> bool:
+                      width: int = 640, height: int = 640,
+                      stream_type: str = "file") -> bool:
         """Assign a stream to a decoder (round-robin).
 
         Automatically downloads HTTPS URLs to local files since PyNvVideoCodec's
         bundled FFmpeg doesn't support HTTPS protocol.
+
+        Args:
+            stream_id: Stream identifier
+            camera_id: Camera identifier
+            video_path: Video file path or RTSP URL
+            width: Target width
+            height: Target height
+            stream_type: Source type ("file" or "rtsp")
         """
         if self.actual_pool_size == 0:
             return False
@@ -641,23 +662,40 @@ class NVDECDecoderPool:
             logger.error(f"Failed to create demuxer for {camera_id}: {e}")
             return False
 
+        # Extract source FPS from demuxer for video timestamp calculation
+        source_fps = 30.0  # Default fallback
+        try:
+            # PyNvVideoCodec demuxer provides frame rate info
+            fps_num = demuxer.FrameRate()[0]
+            fps_den = demuxer.FrameRate()[1]
+            if fps_den > 0:
+                source_fps = fps_num / fps_den
+                logger.debug(f"{camera_id}: Detected source FPS = {source_fps:.2f}")
+        except Exception as e:
+            logger.debug(f"{camera_id}: Could not get FPS from demuxer, using default: {e}")
+
         stream_state = StreamState(
             stream_id=stream_id,
             camera_id=camera_id,
             video_path=local_path,  # Store local path for video looping
             demuxer=demuxer,
             width=width,
-            height=height
+            height=height,
+            stream_type=stream_type,
+            source_fps=source_fps,
         )
         self.streams_per_decoder[decoder_idx].append(stream_state)
         return True
 
     def decode_round(self, decoder_idx: int, frames_per_stream: int = 4,
-                     target_h: int = 640, target_w: int = 640) -> Tuple[int, List[Tuple[str, cp.ndarray]]]:
+                     target_h: int = 640, target_w: int = 640) -> Tuple[int, List[Tuple[str, cp.ndarray, int, str]]]:
         """Decode frames and convert to NV12.
 
         Returns:
-            (total_frames, [(camera_id, nv12_tensor), ...])
+            (total_frames, [(camera_id, nv12_tensor, timestamp_ns, stream_type), ...])
+            where:
+            - timestamp_ns: For RTSP = UTC nanoseconds, for files = video timestamp ns (frame_num / fps * 1e9)
+            - stream_type: "rtsp" or "file"
         """
         if decoder_idx >= self.actual_pool_size:
             return 0, []
@@ -676,6 +714,8 @@ class NVDECDecoderPool:
                     if packet is None:
                         stream.demuxer = nvc.CreateDemuxer(stream.video_path)
                         stream.empty_packets = 0
+                        # Reset frame counter on loop for consistent video timestamps
+                        stream.frames_decoded = 0
                         packet = stream.demuxer.Demux()
                         if packet is None:
                             break
@@ -685,10 +725,21 @@ class NVDECDecoderPool:
                     # Wrap decode loop in try/except to catch decode errors
                     try:
                         for surface in decoder.Decode(packet):
+                            # Calculate timestamp based on stream type:
+                            # - RTSP: UTC nanoseconds for real-time sync
+                            # - File: Video timestamp (frame_num / fps * 1e9) for video playback sync
+                            if stream.stream_type == "rtsp":
+                                decode_timestamp_ns = time.time_ns()
+                            else:
+                                # Video file: use video timestamp based on frame number
+                                # This allows syncing to the video timeline instead of wall clock
+                                video_time_seconds = stream.frames_decoded / stream.source_fps
+                                decode_timestamp_ns = int(video_time_seconds * 1_000_000_000)
+
                             tensor = surface_to_nv12(surface, target_h, target_w)
 
                             if tensor is not None:
-                                decoded_frames.append((stream.camera_id, tensor))
+                                decoded_frames.append((stream.camera_id, tensor, decode_timestamp_ns, stream.stream_type))
                                 frames_this_stream += 1
                                 stream.frames_decoded += 1
                                 total_frames += 1
@@ -839,7 +890,7 @@ def nvdec_pool_worker(
                     target_w=TARGET_WIDTH    # Always 640
                 )
 
-                for cam_id, tensor in decoded_frames:
+                for cam_id, tensor, decode_timestamp_ns, stream_type in decoded_frames:
                     if cam_id in ring_buffers:
                         try:
                             # Validate frame shape matches expected NV12 dimensions
@@ -853,7 +904,11 @@ def nvdec_pool_worker(
                                     )
                                 continue  # Skip this frame
 
-                            ring_buffers[cam_id].write_frame_fast(tensor, sync=False)
+                            # Pass decode-time timestamp for accurate frame timing
+                            # For RTSP: UTC nanoseconds, for files: video timestamp ns
+                            ring_buffers[cam_id].write_frame_fast(
+                                tensor, sync=False, timestamp_ns=decode_timestamp_ns
+                            )
                             local_frames += 1
                             frames_since_counter_update += 1
 
@@ -880,7 +935,7 @@ def nvdec_pool_worker(
                     # Sync all buffers that received frames in this round
                     # Critical for cross-container IPC - ensures GPU writes are visible
                     synced_cams = set()
-                    for cam_id, _ in decoded_frames:
+                    for cam_id, _, _, _ in decoded_frames:
                         if cam_id in ring_buffers and cam_id not in synced_cams:
                             ring_buffers[cam_id].sync_writes()
                             synced_cams.add(cam_id)
@@ -1047,7 +1102,8 @@ def nvdec_pool_process(
                 camera_id=config.camera_id,
                 video_path=config.video_path,
                 width=TARGET_WIDTH,   # Use fixed width
-                height=TARGET_HEIGHT  # Use fixed height
+                height=TARGET_HEIGHT,  # Use fixed height
+                stream_type=config.stream_type,  # Pass stream type for timestamp mode
             )
 
         # Write all GPU mappings at once