nedo-vision-worker-core 0.2.0__py3-none-any.whl

nedo_vision_worker_core/streams/StreamSyncThread.py

@@ -0,0 +1,66 @@
+import logging
+import os
+import time
+import threading
+from ..database.DatabaseManager import DatabaseManager
+from ..repositories.WorkerSourceRepository import WorkerSourceRepository
+from .VideoStreamManager import VideoStreamManager
+
+class StreamSyncThread(threading.Thread):
+    """Thread responsible for synchronizing video streams from the database in real-time."""
+
+    def __init__(self, manager: VideoStreamManager, polling_interval=5):
+        super().__init__()  # Set as a daemon so it stops with the main process
+
+        self.source_file_path = DatabaseManager.STORAGE_PATHS["files"] / "source_files"
+
+        self.manager = manager
+        self.polling_interval = polling_interval
+        self.worker_source_repo = WorkerSourceRepository()
+        self.running = True
+
+    def _get_source_file_path(self, file):
+        """Returns the file path for a given source file."""
+        return self.source_file_path / os.path.basename(file)
+
+    def run(self):
+        """Continuously updates the VideoStreamManager with database changes."""
+        while self.running:
+            try:
+                sources = self.worker_source_repo.get_worker_sources()
+                db_sources = {
+                    source.id: (source.url if source.type_code == "live" else self._get_source_file_path(source.file_path), source.status_code) for source in sources
+                    }  # Store latest sources
+                active_stream_ids = set(self.manager.get_active_stream_ids())
+
+                # **1️⃣ Add new streams**
+                for source_id, (url, status_code) in db_sources.items():
+                    if source_id not in active_stream_ids and status_code == "connected":
+                        logging.info(f"🟢 Adding new stream: {source_id} ({url})")
+                        self.manager.add_stream(source_id, url)
+
+                # **2️⃣ Remove deleted streams**
+                for stream_id in active_stream_ids:
+                    if stream_id not in db_sources or db_sources[stream_id][1] != "connected":
+                        logging.info(f"🔴 Removing deleted stream: {stream_id}")
+                        self.manager.remove_stream(stream_id)
+
+                active_stream_ids = set(self.manager.get_active_stream_ids())
+
+                # **3️⃣ Update streams if URL has changed**
+                for source_id, (url, status_code) in db_sources.items():
+                    if source_id in active_stream_ids:
+                        existing_url = self.manager.get_stream_url(source_id)
+                        if existing_url != url:
+                            logging.info(f"🟡 Updating stream {source_id}: New URL {url}")
+                            self.manager.remove_stream(source_id)
+                            self.manager.add_stream(source_id, url)
+
+            except Exception as e:
+                logging.error(f"⚠️ Error syncing streams from database: {e}")
+
+            time.sleep(self.polling_interval)  # Poll every X seconds
+
+    def stop(self):
+        """Stops the synchronization thread."""
+        self.running = False

nedo_vision_worker_core/streams/VideoStream.py

@@ -0,0 +1,324 @@
+import os
+import cv2
+import threading
+import time
+import logging
+from typing import Optional
+
+
+class VideoStream(threading.Thread):
+    """Threaded class for capturing video from a source, with automatic reconnection.
+    
+    This class provides a thread-safe way to capture video frames from various sources
+    (cameras, files, network streams) with automatic reconnection on failure.
+    
+    Attributes:
+        source: The video source (int for webcams, string for files/URLs)
+        reconnect_interval: Time in seconds to wait before reconnecting on failure
+        retry_limit: Maximum number of consecutive retries before giving up
+    """
+    def __init__(
+        self, 
+        source: str, 
+        reconnect_interval: int = 5,
+        retry_limit: int = 5,
+        max_reconnect_attempts: int = 10,
+        reconnect_backoff_factor: float = 1.5
+    ):
+        super().__init__()
+        
+        # Stream configuration
+        self.source = source
+        self.reconnect_interval = reconnect_interval
+        self.retry_limit = retry_limit
+        
+        # Stream state
+        self.capture = None
+        self.running = True
+        self.connected = False
+        self.start_time = time.time()
+        self.is_file = isinstance(source, (int, str, bytes, os.PathLike)) and os.path.isfile(source)
+        self.fps = 30  # Default FPS until determined
+        self.frame_count = 0
+        
+        # Reconnection control
+        self.max_reconnect_attempts = max_reconnect_attempts
+        self.reconnect_attempts = 0
+        self.reconnect_backoff_factor = reconnect_backoff_factor
+        self.current_reconnect_interval = reconnect_interval
+        
+        # Thread synchronization
+        self.lock = threading.Lock()
+        self._latest_frame = None
+        
+        # Start the capture thread
+        self.start()
+
+    def _initialize_capture(self) -> bool:
+        """Initialize or reinitialize the capture device.
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            logging.info(f"🔄 Attempting to connect to stream: {self.source} (attempt {self.reconnect_attempts + 1}/{self.max_reconnect_attempts})")
+            
+            # Clean up existing capture if needed
+            if self.capture:
+                self.capture.release()
+                
+            # Create new capture object
+            self.capture = cv2.VideoCapture(self.source)
+            
+            if not self.capture.isOpened():
+                logging.error(f"❌ Failed to open video source: {self.source}")
+                return False
+                
+            # Get FPS if available or estimate it
+            self.fps = self.capture.get(cv2.CAP_PROP_FPS)
+            
+            # Check FPS validity and estimate if needed
+            if not self.fps or self.fps <= 0 or self.fps > 240:
+                if self.reconnect_attempts:
+                    return False
+
+                logging.warning(f"⚠️ Invalid FPS reported ({self.fps}). Using default 30 FPS.")
+                self.fps = 30
+            
+            if self.is_file:
+                total_frames = self.capture.get(cv2.CAP_PROP_FRAME_COUNT)
+                duration = (total_frames / self.fps) if self.fps > 0 and total_frames > 0 else 0
+                logging.info(f"✅ Connected to video file {self.source} at {self.fps:.2f} FPS, {total_frames} frames, {duration:.2f}s duration")
+            else:
+                logging.info(f"✅ Connected to stream {self.source} at {self.fps:.2f} FPS")
+                
+            self.connected = True
+            return True
+            
+        except Exception as e:
+            logging.error(f"❌ Error initializing capture for {self.source}: {e}")
+            self.connected = False
+            if self.capture:
+                try:
+                    self.capture.release()
+                except:
+                    pass
+                self.capture = None
+            return False
+
+    def run(self):
+        """Main thread loop that continuously captures frames with automatic reconnection."""
+        retry_count = 0
+        frame_interval = 0  # Will be calculated once we know the FPS
+        
+        while self.running:
+            try:
+                # Check if we should exit
+                if not self.running:
+                    break
+                    
+                # (Re)connect if needed
+                if self.capture is None or not self.capture.isOpened():
+                    # Check if we've exceeded the maximum reconnection attempts
+                    if self.reconnect_attempts >= self.max_reconnect_attempts:
+                        logging.error(f"❌ Exceeded maximum reconnection attempts ({self.max_reconnect_attempts}) for {self.source}. Giving up.")
+                        self.running = False
+                        break
+                    
+                    if retry_count:
+                        self.reconnect_attempts += 1
+
+                    if not self._initialize_capture():
+                        # Apply exponential backoff to reconnection interval
+                        self.current_reconnect_interval *= self.reconnect_backoff_factor
+                        
+                        logging.warning(f"⚠️ Reconnection attempt {self.reconnect_attempts}/{self.max_reconnect_attempts} "
+                                      f"failed. Next attempt in {self.current_reconnect_interval:.1f}s...")
+                        
+                        # Check for thread stop before sleeping
+                        if not self.running:
+                            break
+                            
+                        time.sleep(self.current_reconnect_interval)
+                        continue
+                    
+                    # Reset counters on successful connection
+                    retry_count = 0
+                    # Only reset reconnect_attempts if we've been connected for a meaningful duration
+                    # This prevents rapid success/fail cycles from resetting the counter
+                    if self.connected:
+                        self.reconnect_attempts = 0
+                        self.current_reconnect_interval = self.reconnect_interval
+                    
+                    frame_interval = 1.0 / self.fps if self.fps > 0 else 0.033
+                
+                # Check if we should exit before reading frame
+                if not self.running:
+                    break
+                
+                # Read the next frame
+                read_start = time.time()
+                ret, frame = self.capture.read()
+                
+                # Handle frame read failure
+                if not ret or frame is None or frame.size == 0:
+                    if self.is_file:
+                        # For video files, check if we've reached the end
+                        current_pos = self.capture.get(cv2.CAP_PROP_POS_FRAMES)
+                        total_frames = self.capture.get(cv2.CAP_PROP_FRAME_COUNT)
+                        
+                        # If we're at or beyond the end of the video, restart from beginning
+                        if current_pos >= total_frames - 1:
+                            logging.info(f"🔄 Video file {self.source} reached end. Restarting from beginning...")
+                            self.capture.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                            # Reset retry count for video files when restarting
+                            retry_count = 0
+                            continue
+                        else:
+                            # We're not at the end, this might be a real error
+                            retry_count += 1
+                            logging.warning(f"⚠️ Failed to read frame from {self.source} at position {current_pos}/{total_frames} (attempt {retry_count}/{self.retry_limit})")
+                    else:
+                        # For non-file sources (cameras, streams), increment retry count
+                        retry_count += 1
+                        logging.warning(f"⚠️ Failed to read frame from {self.source} (attempt {retry_count}/{self.retry_limit})")
+                    
+                    if retry_count > self.retry_limit:
+                        logging.error(f"❌ Too many consecutive frame failures. Reconnecting...")
+                        self.connected = False
+                        if self.capture and self.running:  # Only release if we're still running
+                            try:
+                                self.capture.release()
+                                self.capture = None
+                            except Exception as e:
+                                logging.error(f"Error releasing capture during failure: {e}")
+                        continue
+                    
+                    if not self.running:
+                        break
+
+                    time.sleep(0.1)
+                    continue
+                
+                # Reset retry count on successful frame
+                retry_count = 0
+                self.frame_count += 1
+                
+                # Store the frame - but make sure we're still running first
+                if not self.running:
+                    break
+                    
+                with self.lock:
+                    self._latest_frame = frame.copy()
+                
+                # Regulate frame rate to match source FPS for efficiency
+                # This helps prevent CPU overuse when reading from fast sources
+                elapsed = time.time() - read_start
+                sleep_time = max(0, frame_interval - elapsed)
+                if sleep_time > 0 and self.running:  # Check running before sleep
+                    time.sleep(sleep_time)
+                    
+            except cv2.error as cv_err:
+                logging.error(f"❌ OpenCV error in frame processing: {cv_err}")
+                self.connected = False
+                if not self.running:
+                    break
+                time.sleep(1)  # Brief pause before retry
+                
+            except Exception as e:
+                logging.error(f"❌ Error in VideoStream {self.source}: {e}", exc_info=True)
+                self.connected = False
+                if not self.running:
+                    break
+                time.sleep(self.reconnect_interval)
+        
+        # Final cleanup
+        self._cleanup()
+
+    def _cleanup(self):
+        """Release resources and perform cleanup."""
+        try:
+            if self.capture:
+                self.capture.release()
+                self.capture = None
+                
+            with self.lock:
+                self._latest_frame = None
+                        
+            self.connected = False
+            logging.info(f"🔴 Stream {self.source} stopped and cleaned up.")
+            
+        except Exception as e:
+            logging.error(f"Error during final VideoStream cleanup: {e}")
+
+    def get_frame(self) -> Optional[cv2.Mat]:
+        """Returns the latest available frame (thread-safe).
+        
+        Returns:
+            A copy of the latest frame or None if no frames are available
+        """
+        if not self.running:
+            return None
+        
+        with self.lock:
+            if self._latest_frame is not None:
+                return self._latest_frame.copy()
+        return None
+
+    def is_video_ended(self) -> bool:
+        """Check if a video file has reached its end (only for video files).
+        
+        Returns:
+            True if video file has ended, False otherwise
+        """
+        if not self.is_file or not self.capture or not self.capture.isOpened():
+            return False
+            
+        try:
+            current_pos = self.capture.get(cv2.CAP_PROP_POS_FRAMES)
+            total_frames = self.capture.get(cv2.CAP_PROP_FRAME_COUNT)
+            return current_pos >= total_frames - 1
+        except Exception:
+            return False
+
+    def stop(self):
+        """Stops the video stream and releases resources safely."""
+        if not self.running:  # Prevent multiple stops
+            return
+    
+        # Step 1: Signal the thread to stop
+        self.running = False
+        
+        # Step 2: Wait for any ongoing OpenCV operations to complete
+        time.sleep(0.2)  # Short delay to let operations finish
+        
+        # Step 3: Explicitly release capture device before joining thread
+        # This is critical to avoid segmentation faults in some OpenCV implementations
+        if self.capture:
+            try:
+                logging.debug(f"Releasing capture device for {self.source}")
+                with self.lock:  # Use lock to ensure thread isn't accessing capture during release
+                    if self.capture:
+                        self.capture.release()
+                        self.capture = None
+            except Exception as e:
+                logging.error(f"Error releasing capture device: {e}")
+        
+        # Step 4: Clear any references to frames to help garbage collection
+        with self.lock:
+            self._latest_frame = None
+                
+        # Step 5: Wait for thread to exit
+        try:
+            if self.is_alive():
+                logging.debug(f"Waiting for thread to exit for stream {self.source}")
+                self.join(timeout=30)  # Reduced timeout since we already released resources
+                
+                # Check if thread is still alive
+                if self.is_alive():
+                    logging.warning(f"⚠️ Stream {self.source} thread did not exit cleanly within timeout")
+        except Exception as e:
+            logging.error(f"Error joining thread: {e}")
+        
+        # Final status update
+        self.connected = False

nedo_vision_worker_core/streams/VideoStreamManager.py

@@ -0,0 +1,121 @@
+import logging
+import time
+from .VideoStream import VideoStream
+import threading
+
+class VideoStreamManager:
+    """Manages multiple video streams dynamically using VideoStream threads."""
+
+    def __init__(self):
+        self.streams = {}  # Store streams as {worker_source_id: VideoStream}
+        self.running = False
+        self.lock = threading.Lock()  # Add thread lock
+
+    def add_stream(self, worker_source_id, url):
+        """Adds a new video stream if it's not already active."""
+        if worker_source_id not in self.streams:
+            self.streams[worker_source_id] = VideoStream(url)  # Create and start the VideoStream thread
+
+        else:
+            logging.warning(f"⚠️ Stream {worker_source_id} is already active.")
+
+    def remove_stream(self, worker_source_id):
+        """Removes and stops a video stream."""
+        if not worker_source_id:
+            return
+
+        with self.lock:
+            if worker_source_id not in self.streams:
+                logging.warning(f"⚠️ Stream {worker_source_id} not found in manager.")
+                return
+
+            logging.info(f"🛑 Removing video stream: {worker_source_id}")
+
+            # Get reference before removing from dict
+            stream = self.streams.pop(worker_source_id, None)
+
+        if stream:
+            try:
+                stream.stop()
+
+            except Exception as e:
+                logging.error(f"❌ Error stopping stream {worker_source_id}: {e}")
+            finally:
+                stream = None  # Ensure cleanup
+
+        logging.info(f"✅ Stream {worker_source_id} removed successfully.")
+
+    def start_all(self):
+        """Starts all video streams."""
+        logging.info("🔄 Starting all video streams...")
+        for stream in self.streams.values():
+            if not stream.is_alive():
+                stream.start()  # Start thread if not already running
+        self.running = True
+    def stop_all(self):
+        """Stops all video streams."""
+        logging.info("🛑 Stopping all video streams...")
+        
+        with self.lock:
+            # Get a list of IDs to avoid modification during iteration
+            stream_ids = list(self.streams.keys())
+            
+        # Stop each stream
+        for worker_source_id in stream_ids:
+            try:
+                self.remove_stream(worker_source_id)
+            except Exception as e:
+                logging.error(f"Error stopping stream {worker_source_id}: {e}")
+        
+        self.running = False
+
+    def get_frame(self, worker_source_id):
+        """Retrieves the latest frame for a specific stream."""
+        with self.lock:  # Add lock protection for stream access
+            stream = self.streams.get(worker_source_id)
+            if stream is None:
+                return None
+
+            # Check if stream is still running
+            if not stream.running:
+                return None
+
+            try:
+                # **Ignore warnings for the first 5 seconds**
+                elapsed_time = time.time() - stream.start_time
+                if elapsed_time < 5:
+                    return None
+
+                # Check if video file has ended
+                if stream.is_file and stream.is_video_ended():
+                    logging.debug(f"Video file {worker_source_id} has ended, waiting for restart...")
+                    # Small delay to allow the video to restart
+                    time.sleep(0.1)
+                    return None
+
+                return stream.get_frame()  # Already returns a copy
+            except Exception as e:
+                logging.error(f"Error getting frame from stream {worker_source_id}: {e}")
+                return None
+
+    def get_active_stream_ids(self):
+        """Returns a list of active stream IDs."""
+        return list(self.streams.keys())
+
+    def get_stream_url(self, worker_source_id):
+        """Returns the URL of a specific stream."""
+        stream = self.streams.get(worker_source_id)
+        return stream.source if stream else None
+    
+    def has_stream(self, worker_source_id):
+        """Checks if a stream is active."""
+        return worker_source_id in self.streams
+
+    def is_running(self):
+        """Checks if the manager is running."""
+        return self.running
+
+    def is_video_file(self, worker_source_id):
+        """Check if a stream is a video file."""
+        stream = self.streams.get(worker_source_id)
+        return stream.is_file if stream else False

nedo_vision_worker_core/streams/__init__.py

@@ -0,0 +1 @@
+