nedo-vision-worker 1.1.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

nedo_vision_worker/services/VideoStreamClient.py

@@ -7,6 +7,7 @@ import ffmpeg
 import fractions
 from urllib.parse import urlparse
 from .GrpcClientBase import GrpcClientBase
+from .SharedDirectDeviceClient import SharedDirectDeviceClient
 from ..protos.VisionWorkerService_pb2_grpc import VideoStreamServiceStub
 from ..protos.VisionWorkerService_pb2 import VideoFrame
 
@@ -15,9 +16,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 +31,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,
@@ -59,12 +67,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,13 +83,20 @@ 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":
+        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":
             ffmpeg_input = (
                 ffmpeg
                 .input(url, rtsp_transport="tcp", fflags="nobuffer", timeout="5000000")
@@ -112,12 +125,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 +138,20 @@ 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:
+            # Release device access for direct devices
+            if stream_type == "direct":
+                self.shared_device_client.release_device_access(url)
+            
             stderr_output = process.stderr.read().decode()
-            logging.error(f"FFmpeg stderr: {stderr_output}")  # Log errors from FFmpeg
+            logging.error(f"FFmpeg stderr: {stderr_output}")
             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

@@ -9,6 +9,7 @@ from ..database.DatabaseManager import _get_storage_paths
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineDetectionRepository import WorkerSourcePipelineDetectionRepository
 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 +23,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 +36,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,10 +173,27 @@ 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":
+        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":
             ffmpeg_input = (
                 ffmpeg
                 .input(url, rtsp_transport="tcp", fflags="nobuffer", timeout="5000000")
@@ -186,13 +207,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 +220,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 = (
@@ -246,6 +264,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/VideoProbeUtil.py

@@ -4,16 +4,35 @@ import logging
 import json
 import fractions
 import shutil
+import sys
+import platform
+from pathlib import Path
 from urllib.parse import urlparse
 
+
+try:
+    from nedo_vision_worker.services.VideoSharingDaemon import VideoSharingClient
+except ImportError:
+    logging.warning("VideoSharingDaemon not available")
+    VideoSharingClient = None
+
+# Import DatabaseManager for storage path
+try:
+    from nedo_vision_worker.database.DatabaseManager import get_storage_path
+except ImportError:
+    get_storage_path = None
+
 class VideoProbeUtil:
     """Utility to extract metadata from video URLs using OpenCV and ffmpeg."""
     
     @staticmethod
     def get_video_metadata(video_url: str) -> dict:
-        """Extracts resolution and frame rate from a video URL using OpenCV or ffmpeg."""
         try:
-            # metadata = VideoProbeUtil._get_metadata_opencv(video_url)
+            if isinstance(video_url, str) and video_url.isdigit():
+                metadata = VideoProbeUtil._get_metadata_direct_device(video_url)
+                if metadata:
+                    return metadata
+            
             metadata = VideoProbeUtil._get_metadata_ffmpeg(video_url)
             return metadata
         
@@ -45,13 +64,208 @@ class VideoProbeUtil:
             "timestamp": None
         }
     
+    @staticmethod
+    def _get_metadata_opencv_direct_device(device_idx: int) -> dict:
+        """Fallback method to get metadata directly from camera device using OpenCV."""
+        try:
+            logging.debug(f"Attempting direct OpenCV access to device {device_idx}")
+            cap = cv2.VideoCapture(device_idx)
+            
+            if not cap.isOpened():
+                logging.warning(f"⚠️ [APP] OpenCV failed to open device {device_idx}")
+                return None
+
+            # Set a reasonable timeout and try to read a frame
+            cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)  # Reduce buffer to get fresh frames
+            
+            # Try multiple attempts to read a frame (some cameras need warm-up)
+            ret, frame = False, None
+            for attempt in range(3):
+                ret, frame = cap.read()
+                if ret and frame is not None:
+                    break
+                logging.debug(f"Attempt {attempt + 1} failed to read frame from device {device_idx}")
+            
+            if not ret or frame is None:
+                logging.warning(f"⚠️ [APP] OpenCV failed to read frame from device {device_idx} after 3 attempts")
+                cap.release()
+                return None
+
+            # Get video properties
+            height, width = frame.shape[:2]
+            frame_rate = cap.get(cv2.CAP_PROP_FPS)
+            
+            # Some cameras report 0 FPS, use a reasonable default
+            if frame_rate <= 0:
+                frame_rate = 30.0
+            else:
+                frame_rate = round(frame_rate, 2)
+            
+            cap.release()
+            
+            logging.info(f"✅ [APP] Successfully probed device {device_idx} directly: {width}x{height} @ {frame_rate}fps")
+            
+            return {
+                "resolution": f"{width}x{height}",
+                "frame_rate": frame_rate,
+                "timestamp": None
+            }
+            
+        except Exception as e:
+            logging.error(f"❌ [APP] Error probing device {device_idx} with OpenCV: {e}")
+            return None
+    
+    @staticmethod
+    def _get_metadata_ffmpeg_direct_device(device_idx: int) -> dict:
+        """Fallback method to get metadata from camera device using FFmpeg."""
+        if not shutil.which("ffprobe"):
+            logging.warning("⚠️ [APP] ffprobe not available for device probing")
+            return None
+            
+        try:
+            system = platform.system().lower()
+            
+            # Determine the device input format based on OS
+            if system == "linux":
+                device_path = f"/dev/video{device_idx}"
+                input_format = "v4l2"
+                cmd = ["ffprobe", "-f", input_format, "-i", device_path]
+            elif system == "windows":
+                # Windows DirectShow device
+                input_format = "dshow"
+                device_name = f"video={device_idx}"  # This might need adjustment based on actual device names
+                cmd = ["ffprobe", "-f", input_format, "-i", device_name]
+            elif system == "darwin":  # macOS
+                input_format = "avfoundation"
+                cmd = ["ffprobe", "-f", input_format, "-i", str(device_idx)]
+            else:
+                logging.warning(f"⚠️ [APP] Unsupported platform for FFmpeg device access: {system}")
+                return None
+            
+            # Add common ffprobe arguments
+            cmd.extend([
+                "-v", "error",
+                "-select_streams", "v:0",
+                "-show_entries", "stream=width,height,avg_frame_rate",
+                "-of", "json"
+            ])
+            
+            logging.debug(f"Running FFmpeg command: {' '.join(cmd)}")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            
+            if result.returncode != 0:
+                logging.warning(f"⚠️ [APP] FFmpeg failed for device {device_idx}: {result.stderr.strip()}")
+                return None
+                
+            if not result.stdout.strip():
+                logging.warning(f"⚠️ [APP] No output from FFmpeg for device {device_idx}")
+                return None
+
+            metadata = json.loads(result.stdout)
+            streams = metadata.get("streams", [])
+            
+            if not streams:
+                logging.warning(f"⚠️ [APP] No video streams found for device {device_idx}")
+                return None
+                
+            stream = streams[0]
+            width = stream.get("width")
+            height = stream.get("height")
+            avg_fps = stream.get("avg_frame_rate", "30/1")
+
+            try:
+                frame_rate = round(float(fractions.Fraction(avg_fps)), 2)
+            except (ValueError, ZeroDivisionError):
+                frame_rate = 30.0
+
+            if not width or not height:
+                logging.warning(f"⚠️ [APP] Invalid resolution from FFmpeg for device {device_idx}")
+                return None
+
+            logging.info(f"✅ [APP] Successfully probed device {device_idx} with FFmpeg: {width}x{height} @ {frame_rate}fps")
+            
+            return {
+                "resolution": f"{width}x{height}",
+                "frame_rate": frame_rate,
+                "timestamp": None
+            }
+
+        except subprocess.TimeoutExpired:
+            logging.warning(f"⚠️ [APP] FFmpeg timeout for device {device_idx}")
+        except json.JSONDecodeError:
+            logging.error(f"❌ [APP] Failed to parse FFmpeg output for device {device_idx}")
+        except Exception as e:
+            logging.error(f"❌ [APP] Error probing device {device_idx} with FFmpeg: {e}")
+            
+        return None
+    
+    @staticmethod
+    def _get_metadata_direct_device(device_index: str) -> dict:
+        try:
+            device_idx = int(device_index)
+            
+            logging.debug(f"VideoSharingClient available: {VideoSharingClient is not None}")
+            
+            # Try to use VideoSharingClient first for cross-process access
+            if VideoSharingClient:
+                try:
+                    logging.debug("Attempting to use VideoSharingClient...")
+                    
+                    # Get storage path from DatabaseManager
+                    storage_path = None
+                    if get_storage_path:
+                        try:
+                            storage_path = str(get_storage_path())
+                            logging.debug(f"Got storage path: {storage_path}")
+                        except Exception as e:
+                            logging.debug(f"Could not get storage path: {e}")
+                    
+                    # Create temporary client to get device properties
+                    video_client = VideoSharingClient(device_idx, storage_path=storage_path)
+                    logging.debug(f"Created VideoSharingClient, info_file: {video_client.info_file}")
+                    
+                    # Load daemon info to get properties without connecting
+                    if video_client._load_daemon_info():
+                        width = video_client.width
+                        height = video_client.height
+                        fps = video_client.fps
+                        
+                        return {
+                            "resolution": f"{width}x{height}",
+                            "frame_rate": round(fps, 2) if fps > 0 else 30.0,
+                            "timestamp": None
+                        }
+                    else:
+                        logging.debug(f"Video sharing daemon not available for device {device_idx}")
+                    
+                except Exception as e:
+                    logging.debug(f"Video sharing not available for device {device_idx}: {e}")
+                    import traceback
+                    logging.debug(traceback.format_exc())
+            
+            # Fallback 1: Try direct OpenCV access
+            logging.info(f"🔄 [APP] Daemon not available for device {device_idx}, falling back to direct OpenCV access")
+            metadata = VideoProbeUtil._get_metadata_opencv_direct_device(device_idx)
+            if metadata:
+                return metadata
+            
+            # Fallback 2: Try FFmpeg for device access (Linux v4l2, Windows dshow)
+            logging.info(f"🔄 [APP] OpenCV failed for device {device_idx}, trying FFmpeg device access")
+            return VideoProbeUtil._get_metadata_ffmpeg_direct_device(device_idx)
+            
+        except Exception as e:
+            logging.error(f"❌ [APP] Error getting metadata from direct device {device_index}: {e}")
+            return None
+    
     @staticmethod
     def _detect_stream_type(video_url: str) -> str:
-        """Detect whether the URL is RTSP, local file, or other type."""
-        # Convert PosixPath to string if needed
         if hasattr(video_url, '__str__'):
             video_url = str(video_url)
         
+        if isinstance(video_url, str) and video_url.isdigit():
+            return "direct"
+        
         parsed_url = urlparse(video_url)
         if parsed_url.scheme == "rtsp":
             return "rtsp"
@@ -62,45 +276,38 @@ class VideoProbeUtil:
     
     @staticmethod
     def _get_metadata_ffmpeg(video_url: str) -> dict:
-        # Check if ffprobe is available
         if not shutil.which("ffprobe"):
             logging.error("⚠️ [APP] ffprobe is not installed or not found in PATH.")
             return None
 
-        # Detect stream type
         stream_type = VideoProbeUtil._detect_stream_type(video_url)
         
-        # Build ffprobe command based on stream type
+        if stream_type == "direct":
+            return VideoProbeUtil._get_metadata_direct_device(video_url)
+        
         cmd = ["ffprobe", "-v", "error", "-select_streams", "v:0", 
                "-show_entries", "stream=width,height,avg_frame_rate", "-of", "json"]
         
-        # Add RTSP transport option only for RTSP streams
         if stream_type == "rtsp":
             cmd.insert(1, "-rtsp_transport")
             cmd.insert(2, "tcp")
         
-        # Add the video URL
         cmd.append(video_url)
 
         try:
-            # Run ffprobe command
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
 
-            # Check for errors
             if result.returncode != 0 or not result.stdout.strip():
                 logging.warning(f"⚠️ [APP] ffprobe failed for {video_url}: {result.stderr.strip()}")
                 return None
 
-            # Parse JSON output
             metadata = json.loads(result.stdout)
             streams = metadata.get("streams", [{}])[0]
 
-            # Extract metadata
             width = streams.get("width")
             height = streams.get("height")
             avg_fps = streams.get("avg_frame_rate", "0/1")
 
-            # Convert FPS safely
             try:
                 frame_rate = round(float(fractions.Fraction(avg_fps)), 2)
             except (ValueError, ZeroDivisionError):
@@ -109,7 +316,7 @@ class VideoProbeUtil:
             return {
                 "resolution": f"{width}x{height}" if width and height else None,
                 "frame_rate": frame_rate,
-                "timestamp": None  # Placeholder if you need a timestamp later
+                "timestamp": None
             }
 
         except subprocess.TimeoutExpired:

nedo_vision_worker/worker/DataSyncWorker.py

@@ -64,6 +64,7 @@ class DataSyncWorker:
         """Stop the data sync worker."""
         logging.info("🛑 [DATA SYNC] Stopping DataSyncWorker.")
         self.running = False
+        self.ai_model_client.cleanup_downloads()
         safe_join_thread(self.thread)
         logging.info("🛑 [DATA SYNC] DataSyncWorker stopped.")
 

nedo_vision_worker/worker/PipelineImageWorker.py

@@ -112,7 +112,7 @@ class PipelineImageWorker:
             response = self.worker_source_pipeline_client.send_pipeline_image(
                 worker_source_pipeline_id=worker_source_pipeline_id,
                 uuid=uuid,
-                url=worker_source.url if worker_source.type_code == "live" else worker_source.file_path,
+                url=worker_source.url if worker_source.type_code in ["live", "direct"] else worker_source.file_path,
                 token=self.token
             )
 

nedo_vision_worker/worker/VideoStreamWorker.py

@@ -4,6 +4,8 @@ import logging
 import json
 from ..database.DatabaseManager import get_storage_path
 from ..services.FileToRTMPServer import FileToRTMPStreamer
+from ..services.DirectDeviceToRTMPStreamer import DirectDeviceToRTMPStreamer
+from ..services.SharedDirectDeviceClient import SharedDirectDeviceClient
 from .RabbitMQListener import RabbitMQListener
 from ..services.RTSPtoRTMPStreamer import RTSPtoRTMPStreamer
 
@@ -44,6 +46,9 @@ class VideoStreamWorker:
         self.thread = None
         self.stop_event = threading.Event()
         self.lock = threading.Lock()
+        
+        # Initialize shared device client for direct video devices
+        self.shared_device_client = SharedDirectDeviceClient()
 
         # Initialize RabbitMQ listener
         self.listener = RabbitMQListener(
@@ -75,6 +80,11 @@ class VideoStreamWorker:
             safe_join_thread(self.thread)  # Ensures the thread stops gracefully
             self.thread = None
             logger.info(f"🛑 [APP] Stream Worker stopped (Device: {self.worker_id}).")
+    
+    def _is_direct_device(self, url) -> bool:
+        """Check if the URL is a direct video device."""
+        is_device, _ = self.shared_device_client._is_direct_device(url)
+        return is_device
 
     def _run(self):
         """Main loop to manage RabbitMQ listener."""
@@ -108,8 +118,19 @@ class VideoStreamWorker:
 
             logger.info(f"📡 [APP] Received video preview message ({data})")
 
-            if not url or (not url.startswith("rtsp://") and not url.startswith("worker-source/")):
-                logger.error(f"⚠️ [APP] Invalid URL: {url}")
+            # Validate URL - support RTSP, worker-source files, and direct devices
+            if not url:
+                logger.error(f"⚠️ [APP] Missing URL in message")
+                return
+            
+            is_valid_url = (
+                url.startswith("rtsp://") or 
+                url.startswith("worker-source/") or 
+                self._is_direct_device(url)
+            )
+            
+            if not is_valid_url:
+                logger.error(f"⚠️ [APP] Invalid URL: {url} (must be RTSP, worker-source file, or direct device)")
                 return
 
             if stream_duration <= 0:
@@ -131,13 +152,16 @@ class VideoStreamWorker:
             logger.error("🚨 [APP] Error processing video preview message.", exc_info=True)
 
     def _start_stream(self, url, rtmp_server, stream_key, stream_duration, worker_id):
-        """Runs RTSP-to-RTMP streaming in a separate thread."""
+        """Runs streaming to RTMP in a separate thread."""
         try:
             logger.info(f"🎥 [APP] Starting RTMP stream (Worker: {worker_id})")
             
             if url.startswith("worker-source/"):
                 streamer = FileToRTMPStreamer(self.source_file_path / os.path.basename(url), rtmp_server, stream_key, stream_duration)
+            elif self._is_direct_device(url):
+                streamer = DirectDeviceToRTMPStreamer(url, rtmp_server, stream_key, stream_duration)
             else:
+                # Assume RTSP or other supported protocols
                 streamer = RTSPtoRTMPStreamer(url, rtmp_server, stream_key, stream_duration)
 
             streamer.start_stream()