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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.73
+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.73 → 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.73
+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.73 → 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