nedo-vision-worker 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

nedo_vision_worker/services/VideoStreamClient.py

@@ -7,6 +7,8 @@ import ffmpeg
 import fractions
 from urllib.parse import urlparse
 from .GrpcClientBase import GrpcClientBase
+from .SharedDirectDeviceClient import SharedDirectDeviceClient
+from ..util.FFmpegUtil import get_rtsp_ffmpeg_options, get_rtsp_probe_options
 from ..protos.VisionWorkerService_pb2_grpc import VideoStreamServiceStub
 from ..protos.VisionWorkerService_pb2 import VideoFrame
 
@@ -15,9 +17,12 @@ class VideoStreamClient(GrpcClientBase):
     def __init__(self, server_host: str, server_port: int = 50051):
         """Initialize the video stream client."""
         super().__init__(server_host, server_port)
+        self.shared_device_client = SharedDirectDeviceClient()
 
     def _detect_stream_type(self, url):
-        """Detect whether the stream is RTSP or HLS based on the URL scheme."""
+        if isinstance(url, str) and url.isdigit():
+            return "direct"
+        
         parsed_url = urlparse(url)
         if parsed_url.scheme == "rtsp":
             return "rtsp"
@@ -27,8 +32,12 @@ class VideoStreamClient(GrpcClientBase):
             return "unknown"
 
     def _get_video_properties(self, url, stream_type):
-        """Extract FPS, resolution, and pixel format dynamically for RTSP or HLS."""
         try:
+            if stream_type == "direct":
+                # Use the shared device client for direct devices
+                width, height, fps, pixel_format = self.shared_device_client.get_video_properties(url)
+                return width, height, fps, pixel_format
+            
             probe_cmd = [
                 "ffprobe",
                 "-i", url,
@@ -39,8 +48,10 @@ class VideoStreamClient(GrpcClientBase):
             ]
 
             if stream_type == "rtsp":
-                probe_cmd.insert(1, "-rtsp_transport")
-                probe_cmd.insert(2, "tcp")
+                probe_options = get_rtsp_probe_options()
+                # Insert options at the beginning (after ffprobe)
+                for i, option in enumerate(probe_options):
+                    probe_cmd.insert(1 + i, option)
 
             result = subprocess.run(probe_cmd, capture_output=True, text=True)
             probe_data = json.loads(result.stdout)
@@ -59,12 +70,10 @@ class VideoStreamClient(GrpcClientBase):
         return None, None, None, None
 
     def _get_bytes_per_pixel(self, pixel_format):
-        """Determine bytes per pixel based on pixel format."""
         pixel_map = {"rgb24": 3, "yuv420p": 1.5, "gray": 1}
-        return pixel_map.get(pixel_format, 3)  # Default to 3 bytes (RGB)
+        return pixel_map.get(pixel_format, 3)
 
     def _generate_frames(self, url, worker_id, uuid, stream_duration):
-        """Generator function to continuously stream video frames to gRPC."""
         stream_type = self._detect_stream_type(url)
         if stream_type == "unknown":
             logging.error(f"Unsupported stream type: {url}")
@@ -77,17 +86,22 @@ class VideoStreamClient(GrpcClientBase):
 
         bytes_per_pixel = self._get_bytes_per_pixel(pixel_format)
         frame_size = int(width * height * bytes_per_pixel)
-        frame_interval = 1.0 / fps  # Time between frames
+        frame_interval = 1.0 / fps
         start_time = time.time()
         empty_frame_count = 0
 
         logging.info(f"Streaming {stream_type.upper()} from: {url} for {stream_duration} seconds...")
 
-        if stream_type == "rtsp":
-            ffmpeg_input = (
-                ffmpeg
-                .input(url, rtsp_transport="tcp", fflags="nobuffer", timeout="5000000")
-            )
+        if stream_type == "direct":
+            # Use the shared device client for direct devices
+            try:
+                ffmpeg_input = self.shared_device_client.create_ffmpeg_input(url, width, height, fps)
+            except Exception as e:
+                logging.error(f"Failed to create ffmpeg input for direct device: {e}")
+                return
+        elif stream_type == "rtsp":
+            rtsp_options = get_rtsp_ffmpeg_options()
+            ffmpeg_input = ffmpeg.input(url, **rtsp_options)
         elif stream_type == "hls":
             ffmpeg_input = (
                 ffmpeg
@@ -112,12 +126,12 @@ class VideoStreamClient(GrpcClientBase):
                     empty_frame_count += 1
                     logging.warning(f"Empty frame received ({empty_frame_count}), retrying...")
 
-                    if empty_frame_count > 5:  # Stop if 5 consecutive empty frames
+                    if empty_frame_count > 5:
                         logging.error("Too many empty frames, stopping stream...")
                         break
-                    continue  # Try reading the next frame
+                    continue
 
-                empty_frame_count = 0  # Reset empty frame count
+                empty_frame_count = 0
                 yield VideoFrame(
                     worker_id=worker_id,
                     uuid=uuid,
@@ -125,16 +139,25 @@ class VideoStreamClient(GrpcClientBase):
                     timestamp=int(time.time() * 1000),
                 )
 
-                time.sleep(frame_interval)  # Ensure proper frame timing
+                time.sleep(frame_interval)
 
         except Exception as e:
             logging.error(f"Streaming error: {e}")
 
         finally:
-            stderr_output = process.stderr.read().decode()
-            logging.error(f"FFmpeg stderr: {stderr_output}")  # Log errors from FFmpeg
+            # Release device access for direct devices
+            if stream_type == "direct":
+                self.shared_device_client.release_device_access(url)
+            
+            try:
+                stderr_output = process.stderr.read().decode()
+                if stderr_output.strip():  # Only log if there's actual error content
+                    logging.error(f"FFmpeg stderr for {stream_type} stream: {stderr_output}")
+            except Exception as e:
+                logging.warning(f"Could not read FFmpeg stderr: {e}")
+            
             process.terminate()
-            process.wait()  # Ensures cleanup
+            process.wait()
 
     def stream_video(self, worker_id, uuid, url, stream_duration):
         """

nedo_vision_worker/services/WorkerSourceClient.py

@@ -87,7 +87,7 @@ class WorkerSourceClient(GrpcClientBase):
         if existing_source.worker_id != source.worker_id:
             changes.append(f"worker_id: {existing_source.worker_id} → {source.worker_id}")
         if existing_source.type_code != source.type_code:
-            if source.type_code == "live":
+            if source.type_code in ["live", "direct"]:
                 self.delete_local_source_file(existing_source.file_path)
             elif existing_source.file_path == source.file_path:
                 self.download_source_file(source)

nedo_vision_worker/services/WorkerSourcePipelineClient.py

@@ -8,7 +8,9 @@ from pathlib import Path
 from ..database.DatabaseManager import _get_storage_paths
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineDetectionRepository import WorkerSourcePipelineDetectionRepository
+from ..util.FFmpegUtil import get_rtsp_ffmpeg_options, get_stream_timeout_duration
 from .GrpcClientBase import GrpcClientBase
+from .SharedDirectDeviceClient import SharedDirectDeviceClient
 from ..protos.WorkerSourcePipelineService_pb2_grpc import WorkerSourcePipelineServiceStub
 from ..protos.WorkerSourcePipelineService_pb2 import GetListByWorkerIdRequest, SendPipelineImageRequest, UpdatePipelineStatusRequest, SendPipelineDebugRequest, SendPipelineDetectionDataRequest
 from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
@@ -22,6 +24,7 @@ class WorkerSourcePipelineClient(GrpcClientBase):
         self.detection_repo = WorkerSourcePipelineDetectionRepository()
         storage_paths = _get_storage_paths()
         self.source_file_path = storage_paths["files"] / "source_files"
+        self.shared_device_client = SharedDirectDeviceClient()
         
         # Track video playback positions and last fetch times
         self.video_positions = {}  # {video_path: current_position_in_seconds}
@@ -34,7 +37,9 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             self.stub = None
 
     def _detect_stream_type(self, url):
-        """Detect whether the stream is RTSP, HLS, or video file based on the URL scheme."""
+        if isinstance(url, str) and url.isdigit():
+            return "direct"
+        
         parsed_url = urlparse(url)
         if parsed_url.scheme == "rtsp":
             return "rtsp"
@@ -169,14 +174,29 @@ class WorkerSourcePipelineClient(GrpcClientBase):
         return status
     
     def _get_single_frame_bytes(self, url):
-        """Get a single frame from RTSP, HLS, or video file as JPEG bytes."""
         stream_type = self._detect_stream_type(url)
         
-        if stream_type == "rtsp":
-            ffmpeg_input = (
-                ffmpeg
-                .input(url, rtsp_transport="tcp", fflags="nobuffer", timeout="5000000")
-            )
+        if stream_type == "direct":
+            device_index = int(url)
+            logging.info(f"📹 [APP] Capturing frame from direct video device: {device_index}")
+            
+            # Use the shared device client for direct devices
+            try:
+                # Get device properties first
+                width, height, fps, pixel_format = self.shared_device_client.get_video_properties(url)
+                if not width or not height:
+                    logging.error(f"Failed to get properties for device {device_index}")
+                    return None
+                
+                # Create ffmpeg input using shared device client
+                ffmpeg_input = self.shared_device_client.create_ffmpeg_input(url, width, height, fps)
+                
+            except Exception as e:
+                logging.error(f"Error setting up direct device {device_index}: {e}")
+                return None
+        elif stream_type == "rtsp":
+            rtsp_options = get_rtsp_ffmpeg_options()
+            ffmpeg_input = ffmpeg.input(url, **rtsp_options)
         elif stream_type == "hls":
             ffmpeg_input = (
                 ffmpeg
@@ -186,13 +206,11 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             file_path = self.source_file_path / os.path.basename(url)
             file_path_str = str(file_path)
             
-            # Check if file exists
             if not os.path.exists(file_path_str):
                 logging.error(f"Video file does not exist: {file_path_str}")
                 return None
             
             current_position = self._get_current_video_position(file_path_str)
-            
             logging.info(f"🎬 [APP] Capturing video frame at position {current_position:.2f}s from {file_path_str}")
             
             ffmpeg_input = (
@@ -201,7 +219,6 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             )
         elif stream_type == "image_file":
             file_path = self.source_file_path / os.path.basename(url)
-            
             logging.info(f"🖼️ [APP] Capturing image frame from {file_path}")
             
             ffmpeg_input = (
@@ -228,11 +245,13 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             )
             
         try:    
-            stdout, stderr = process.communicate(timeout=15)
+            # Use appropriate timeout for different stream types
+            timeout_duration = get_stream_timeout_duration(stream_type)
+            stdout, stderr = process.communicate(timeout=timeout_duration)
             
             if process.returncode != 0:
                 error_msg = stderr.decode('utf-8', errors='ignore')
-                logging.error(f"FFmpeg error: {error_msg}")
+                logging.error(f"FFmpeg error for {stream_type} stream: {error_msg}")
                 return None
             
             if not stdout:
@@ -246,6 +265,10 @@ class WorkerSourcePipelineClient(GrpcClientBase):
             return None
         
         finally:
+            # Release device access for direct devices
+            if stream_type == "direct":
+                self.shared_device_client.release_device_access(url)
+            
             process.terminate()
             process.wait()
 

nedo_vision_worker/services/WorkerSourceUpdater.py

@@ -27,8 +27,13 @@ class WorkerSourceUpdater:
         self._lock = threading.RLock()
 
     def _get_source_metadata(self, source):
-        """Get metadata for a worker source."""
-        url = source.url if source.type_code == "live" else source.file_path
+        if source.type_code == "live":
+            url = source.url
+        elif source.type_code == "direct":
+            url = source.url
+        else:
+            url = source.file_path
+            
         if not url:
             return None
         
@@ -50,7 +55,29 @@ class WorkerSourceUpdater:
                 for source in worker_sources:
                     metadata = self._get_source_metadata(source)
                     if not metadata:
-                        logger.warning(f"⚠️ [APP] Failed to probe video for Worker Source ID {source.id}")
+                        logger.warning(f"⚠️ [APP] Failed to probe video for Worker Source ID {source.id} (type: {source.type_code}, url: {source.url if hasattr(source, 'url') else 'N/A'})")
+                        # Set disconnected status for failed probes
+                        if source.status_code != "disconnected":
+                            source.status_code = "disconnected"
+                            source.resolution = None
+                            source.frame_rate = None
+                            updated_records.append(source)
+                            
+                            # Send gRPC update for disconnected status
+                            worker_timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+                            response = self.client.update_worker_source(
+                                worker_source_id=source.id,
+                                resolution=None,
+                                status_code="disconnected",
+                                frame_rate=None,
+                                worker_timestamp=worker_timestamp,
+                                token=self.token,
+                            )
+                            
+                            if response.get("success"):
+                                logger.info(f"✅ [APP] Updated Worker Source ID {source.id} to disconnected")
+                            else:
+                                logger.error(f"🚨 [APP] Failed to update Worker Source ID {source.id} to disconnected: {response.get('message')}")
                         continue
 
                     # Extract details

nedo_vision_worker/util/FFmpegUtil.py

@@ -0,0 +1,124 @@
+"""
+FFmpeg utilities for Jetson compatibility and RTSP stream handling.
+
+This module provides common FFmpeg configurations and utilities that work
+reliably on Jetson devices with FFmpeg 4.4.1 and newer versions.
+"""
+
+import logging
+import subprocess
+import re
+from typing import Dict, Any, Tuple
+
+
+def get_ffmpeg_version() -> Tuple[int, int, int]:
+    """
+    Get the FFmpeg version as a tuple of (major, minor, patch).
+    
+    Returns:
+        Tuple[int, int, int]: Version tuple (major, minor, patch)
+    """
+    try:
+        result = subprocess.run(['ffmpeg', '-version'], capture_output=True, text=True, timeout=5)
+        if result.returncode == 0:
+            # Extract version from output like "ffmpeg version n7.1.1" or "ffmpeg version 4.4.1"
+            match = re.search(r'ffmpeg version n?(\d+)\.(\d+)\.(\d+)', result.stdout)
+            if match:
+                return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+    except Exception as e:
+        logging.warning(f"Could not determine FFmpeg version: {e}")
+    
+    # Default to a reasonable version if detection fails
+    return (4, 4, 1)
+
+
+def get_rtsp_ffmpeg_options() -> Dict[str, Any]:
+    """
+    Get FFmpeg options optimized for RTSP streams with version compatibility.
+    
+    These options work across different FFmpeg versions:
+    - FFmpeg 4.4.x: Uses stimeout
+    - FFmpeg 5.x+: Uses timeout 
+    - FFmpeg 7.x+: Uses timeout
+    
+    Returns:
+        Dict[str, Any]: FFmpeg input options for RTSP streams
+    """
+    version = get_ffmpeg_version()
+    major, minor, patch = version
+    
+    # Base options that work across all versions
+    options = {
+        "rtsp_transport": "tcp",
+        "fflags": "nobuffer+genpts", 
+        "max_delay": "5000000",  # Max buffering delay
+        "buffer_size": "1024000",  # Input buffer size
+        "avoid_negative_ts": "make_zero"  # Handle timestamp issues
+    }
+    
+    # Add version-specific timeout option
+    if major == 4 and minor == 4:
+        # FFmpeg 4.4.x uses stimeout
+        options["stimeout"] = "5000000"
+        logging.debug("Using stimeout for FFmpeg 4.4.x")
+    else:
+        # FFmpeg 5.x+ uses timeout (microseconds)
+        options["timeout"] = "5000000"
+        logging.debug(f"Using timeout for FFmpeg {major}.{minor}.{patch}")
+    
+    return options
+
+
+def get_rtsp_probe_options() -> list:
+    """
+    Get ffprobe command line options for RTSP streams with version compatibility.
+    
+    Returns:
+        list: Command line options to insert into ffprobe command
+    """
+    version = get_ffmpeg_version()
+    major, minor, patch = version
+    
+    base_options = ["-rtsp_transport", "tcp"]
+    
+    # Add version-specific timeout option
+    if major == 4 and minor == 4:
+        # FFmpeg 4.4.x uses stimeout
+        return base_options + ["-stimeout", "5000000"]
+    else:
+        # FFmpeg 5.x+ uses timeout
+        return base_options + ["-timeout", "5000000"]
+
+
+def log_ffmpeg_version_info():
+    """Log information about FFmpeg compatibility."""
+    version = get_ffmpeg_version()
+    major, minor, patch = version
+    
+    logging.info(f"Detected FFmpeg version: {major}.{minor}.{patch}")
+    
+    if major == 4 and minor == 4:
+        logging.info("Using 'stimeout' parameter for FFmpeg 4.4.x compatibility")
+    else:
+        logging.info(f"Using 'timeout' parameter for FFmpeg {major}.{minor}.{patch}")
+    
+    logging.info("RTSP configuration optimized for embedded devices")
+
+
+def get_stream_timeout_duration(stream_type: str) -> int:
+    """
+    Get appropriate timeout duration for different stream types.
+    
+    Args:
+        stream_type (str): Type of stream (rtsp, hls, direct, etc.)
+        
+    Returns:
+        int: Timeout duration in seconds
+    """
+    timeouts = {
+        "rtsp": 30,     # RTSP streams may take longer to connect
+        "hls": 20,      # HLS streams need time for manifest download
+        "direct": 10,   # Direct device access should be faster
+        "video_file": 5 # Local files should be very fast
+    }
+    return timeouts.get(stream_type, 15)  # Default 15 seconds