nedo-vision-worker-core 0.4.0__tar.gz → 0.4.3__tar.gz

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.4.0
+Version: 0.4.3
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core/__init__.py

@@ -7,10 +7,10 @@ A library for running AI vision processing and detection in the Nedo Vision plat
 from .core_service import CoreService
 from .callbacks import DetectionType, CallbackTrigger, DetectionData, IntervalMetadata
 
-__version__ = "0.4.0"
+__version__ = "0.4.3"
 __all__ = [
     "CoreService", 
-    "DetectionType", 
+    "DetectionType",
     "CallbackTrigger", 
     "DetectionData",
     "IntervalMetadata",

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core/pipeline/PipelineManager.py

@@ -31,6 +31,11 @@ class PipelineManager:
         self._stop_lock = threading.Lock()
         self.on_pipeline_stopped = on_pipeline_stopped
         
+        # Stagger pipeline startup to reduce CPU spikes
+        self._last_pipeline_start = 0
+        self._pipeline_start_delay = 1.0  # 1 second between pipeline starts
+        self._start_lock = threading.Lock()
+        
         logging.info(f"🚀 PipelineManager initialized with {max_workers} worker threads")
 
     def start_pipeline(self, pipeline, detector):
@@ -46,6 +51,15 @@ class PipelineManager:
             logging.warning(f"⚠️ Pipeline {pipeline_id} is already running.")
             return
 
+        # Stagger pipeline starts to reduce CPU spikes
+        with self._start_lock:
+            time_since_last_start = time.time() - self._last_pipeline_start
+            if time_since_last_start < self._pipeline_start_delay:
+                delay = self._pipeline_start_delay - time_since_last_start
+                logging.info(f"⏳ Staggering pipeline {pipeline_id} start by {delay:.2f}s to reduce CPU spike")
+                time.sleep(delay)
+            self._last_pipeline_start = time.time()
+
         logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
 
         # Acquire video stream

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -47,6 +47,10 @@ class PipelineProcessor:
         self.last_preview_check_time = 0
         self.preview_check_interval = 10.0  # Check every 10 seconds (reduced from 5s to save CPU)
         self.pipeline_repo = WorkerSourcePipelineRepository()
+        
+        # RTMP frame rate limiting to reduce CPU
+        self.last_rtmp_frame_time = 0
+        self.rtmp_frame_interval = 1.0 / 25.0  # 25 FPS for RTMP (matching render FPS)
 
         self.detection_processor_codes = [
             PPEDetectionProcessor.code,
@@ -199,9 +203,17 @@ class PipelineProcessor:
                     self._check_and_update_rtmp_streaming()
                     last_preview_check = loop_start
 
+                # Only draw frames when actually needed (RTMP active or debug)
                 should_draw = self.rtmp_streaming_active or self.debug_flag
                 
-                if should_draw:
+                # For RTMP, also check if it's time to send a frame (rate limiting)
+                should_draw_for_rtmp = (
+                    self.rtmp_streaming_active and 
+                    self.rtmp_streamer is not None and
+                    (loop_start - self.last_rtmp_frame_time >= self.rtmp_frame_interval)
+                )
+                
+                if should_draw_for_rtmp or self.debug_flag:
                     try:
                         frame_to_draw = frame.copy()
                         self.frame_drawer.draw_polygons(frame_to_draw)
@@ -215,7 +227,7 @@ class PipelineProcessor:
                         logging.error(f"❌ Draw failed, using raw frame: {e}")
                         drawn_frame = frame
                 else:
-                    drawn_frame = frame
+                    drawn_frame = None  # Don't waste CPU drawing if not needed
 
                 if self.debug_flag:
                     tracked_objects_render = self._process_frame(frame)
@@ -235,13 +247,16 @@ class PipelineProcessor:
                         try:
                             self.rtmp_streamer = RTMPStreamer(self.pipeline_id)
                             logging.info(f"🎬 RTMP streamer initialized for pipeline {pipeline_id} (preview requested)")
+                            self.last_rtmp_frame_time = 0  # Reset frame time on new stream
                         except Exception as e:
                             logging.error(f"❌ Failed to initialize RTMP streamer for pipeline {pipeline_id}: {e}")
                             self.rtmp_streamer = None
 
-                    if self.rtmp_streamer:
+                    if self.rtmp_streamer and drawn_frame is not None:
+                        # Frame already rate-limited by drawing logic above
                         try:
                             self.rtmp_streamer.push_frame(drawn_frame)
+                            self.last_rtmp_frame_time = loop_start
                         except Exception as e:
                             logging.error(f"❌ RTMP push error for pipeline {pipeline_id}: {e}")
                             if "initialization_failed" in str(e).lower():
@@ -259,9 +274,10 @@ class PipelineProcessor:
                     finally:
                         self.rtmp_streamer = None
 
-                # Simplified queue feeding - avoid expensive try-except
-                if not self.frame_queue.full():
-                    self.frame_queue.put_nowait(frame)
+                # Only feed frames to detection queue if detection processor is active
+                if self.detection_processor is not None:
+                    if not self.frame_queue.full():
+                        self.frame_queue.put_nowait(frame)
                 
                 loop_elapsed = time.time() - loop_start
                 sleep_time = max(0.001, target_frame_time - loop_elapsed)
@@ -307,7 +323,13 @@ class PipelineProcessor:
 
         while self.running:
             try:
-                frame = self.frame_queue.get(block=True, timeout=1)
+                # Calculate how long to wait for next detection
+                current_time = time.time()
+                time_since_last_detection = current_time - last_detection_time
+                time_until_next_detection = max(0.1, self.detection_interval - time_since_last_detection)
+                
+                # Wait for frame with timeout aligned to detection interval
+                frame = self.frame_queue.get(block=True, timeout=time_until_next_detection)
                 
                 # Check for poison pill (None = stop signal)
                 if frame is None:
@@ -332,9 +354,14 @@ class PipelineProcessor:
                 except queue.Empty:
                     pass
 
-                # Respect detection interval
+                # Respect detection interval - skip if too soon
                 if (current_time - last_detection_time) < self.detection_interval:
+                    # Sleep the remaining time instead of busy-waiting
+                    remaining_time = self.detection_interval - (current_time - last_detection_time)
+                    if remaining_time > 0.01:
+                        time.sleep(remaining_time)
                     continue
+                
                 last_detection_time = current_time
 
                 if self.detection_processor is None or frame is None or frame.size == 0:
@@ -363,6 +390,7 @@ class PipelineProcessor:
                     )
 
             except queue.Empty:
+                # Timeout occurred - this is normal, just continue to next iteration
                 pass
             except Exception as e:
                 logging.error(f"❌ Error in detection thread for pipeline {pipeline_id}: {e}", exc_info=True)

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -5,6 +5,7 @@ import threading
 from typing import Dict, Set, Optional
 from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
 from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
+from ..repositories.WorkerSourceRepository import WorkerSourceRepository
 from .PipelineManager import PipelineManager
 from .ModelManager import ModelManager
 from ..streams.VideoStreamManager import VideoStreamManager
@@ -19,6 +20,7 @@ class PipelineSyncThread(threading.Thread):
         self.polling_interval = polling_interval
         self.pipeline_repo = WorkerSourcePipelineRepository()
         self.debug_repo = WorkerSourcePipelineDebugRepository()
+        self.source_repo = WorkerSourceRepository()
         self.model_manager = ModelManager()
         self.running = True
         self.pipeline_manager = PipelineManager(video_manager, self.on_pipeline_stopped, max_workers)
@@ -82,6 +84,11 @@ class PipelineSyncThread(threading.Thread):
                 pipeline.pipeline_status_code = 'run'
 
             if pipeline.pipeline_status_code == 'run':
+                # Check if source is connected before starting pipeline
+                if not self.source_repo.is_source_connected(pipeline.worker_source_id):
+                    logging.warning(f"⚠️ Skipping pipeline {pid} ({pipeline.name}): Source {pipeline.worker_source_id} is disconnected")
+                    continue
+                
                 detector = self.model_manager.get_detector(pipeline.ai_model_id)
                 
                 if not detector and pipeline.ai_model_id:
@@ -146,6 +153,12 @@ class PipelineSyncThread(threading.Thread):
         if requires_restart:
             logging.info(f"🔄 Restarting pipeline due to significant changes: {pid}")
             self.pipeline_manager.stop_pipeline(pid)
+            
+            # Check if source is connected before restarting
+            if not self.source_repo.is_source_connected(db_pipeline.worker_source_id):
+                logging.warning(f"⚠️ Cannot restart pipeline {pid}: Source {db_pipeline.worker_source_id} is disconnected")
+                return
+            
             self.pipeline_manager.start_pipeline(db_pipeline, db_detector)
         else:
             # Update config for minor changes that don't require restart

nedo_vision_worker_core-0.4.3/nedo_vision_worker_core/repositories/WorkerSourceRepository.py

@@ -0,0 +1,56 @@
+from .BaseRepository import BaseRepository
+from ..models.worker_source import WorkerSourceEntity
+
+
+class WorkerSourceRepository(BaseRepository):
+    def __init__(self):
+        super().__init__(db_name="config")
+
+    def get_worker_sources(self):
+        """
+        Fetch all worker sources from the local database in a single query.
+
+        Returns:
+            list: A list of WorkerSourceEntity records.
+        """
+        with self._get_session() as session:
+            session.expire_all()
+            sources = session.query(WorkerSourceEntity).all()
+            for source in sources:
+                session.expunge(source)
+            return sources
+    
+    def get_worker_source(self, source_id: str):
+        """
+        Fetch a single worker source by ID.
+        
+        Args:
+            source_id (str): The worker source ID
+            
+        Returns:
+            WorkerSourceEntity: The worker source entity or None if not found
+        """
+        with self._get_session() as session:
+            session.expire_all()
+            source = session.query(WorkerSourceEntity).filter(
+                WorkerSourceEntity.id == source_id
+            ).first()
+            if source:
+                session.expunge(source)
+            return source
+    
+    def is_source_connected(self, source_id: str) -> bool:
+        """
+        Check if a worker source is connected.
+        
+        Args:
+            source_id (str): The worker source ID
+            
+        Returns:
+            bool: True if source is connected, False otherwise
+        """
+        source = self.get_worker_source(source_id)
+        if not source:
+            return False
+        
+        return source.status_code == "connected" if source.status_code else False

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core/streams/RTMPStreamer.py

@@ -25,7 +25,7 @@ class RTMPStreamer:
     # Class-level lock to stagger stream initialization across all instances
     _initialization_lock = threading.Lock()
     _last_initialization_time = 0
-    _min_initialization_delay = 0.5  # 500ms between stream starts
+    _min_initialization_delay = 1.5  # 1.5 seconds between stream starts (increased from 0.5s)
 
     def __init__(self, pipeline_id: str, fps: int = 25, bitrate: str = "1500k"):
         self.pipeline_id = pipeline_id
@@ -307,6 +307,7 @@ class RTMPStreamer:
                 if not self.is_active():
                     raise BrokenPipeError("FFmpeg process is not active")
                 self._ffmpeg_process.stdin.write(frame.tobytes())
+                self._ffmpeg_process.stdin.flush()  # Ensure data is sent immediately
             except (BrokenPipeError, OSError) as e:
                 
                 # Check if this failure was from a HW encoder
@@ -356,23 +357,20 @@ class RTMPStreamer:
             '-framerate', str(self.fps), '-i', '-',
         ]
         
+        # Add encoder and encoder-specific parameters
         cmd.extend(encoder_args)
         
+        # Common video parameters
         cmd.extend([
-            '-profile:v', 'main', '-pix_fmt', 'yuv420p',
+            '-pix_fmt', 'yuv420p',
             '-b:v', f"{self.bitrate}k", '-maxrate', f"{self.bitrate}k", '-bufsize', f"{self.bitrate*2}k",
             '-g', str(self.fps * 2), '-keyint_min', str(self.fps),
-            '-force_key_frames', 'expr:gte(t,n_forced*1)', '-an',
-            '-flvflags', 'no_duration_filesize', '-f', 'flv', self.rtmp_url,
+            '-force_key_frames', 'expr:gte(t,n_forced*1)', 
+            '-an',  # No audio
+            '-flvflags', 'no_duration_filesize', 
+            '-f', 'flv', self.rtmp_url,
         ])
         
-        if encoder_name == "libx264":
-            cmd.extend([
-                "-preset", "ultrafast",
-                "-tune", "zerolatency",
-                "-x264-params", "open_gop=0:aud=1:repeat-headers=1:nal-hrd=cbr",
-            ])
-        
         return cmd, encoder_name
 
     def _select_ffmpeg_encoder(self, force_cpu: bool = False) -> Tuple[List[str], str]:
@@ -381,26 +379,74 @@ class RTMPStreamer:
         Will force CPU if force_cpu is True.
         """
         if force_cpu:
-            return ["-c:v", "libx264"], "libx264"
+            return [
+                "-c:v", "libx264",
+                "-preset", "ultrafast",
+                "-tune", "zerolatency",
+                "-profile:v", "main",
+            ], "libx264"
         
         force_encoder = os.environ.get("RTMP_ENCODER", "").lower()
         
         if force_encoder == "cpu" or force_encoder == "libx264":
-            return ["-c:v", "libx264"], "libx264"
+            return [
+                "-c:v", "libx264",
+                "-preset", "ultrafast",
+                "-tune", "zerolatency",
+                "-profile:v", "main",
+            ], "libx264"
         elif force_encoder == "nvenc":
-            return ["-c:v", "h264_nvenc", "-preset", "llhp"], "h264_nvenc"
+            return [
+                "-c:v", "h264_nvenc",
+                "-preset", "p1",  # p1 = fastest, p7 = slowest
+                "-tune", "ull",  # ultra-low latency
+                "-rc:v", "cbr",  # constant bitrate for streaming
+                "-rc-lookahead", "0",  # disable lookahead for lower latency
+                "-delay", "0",  # zero delay
+                "-zerolatency", "1",  # enable zero latency mode
+                "-profile:v", "main",
+                "-gpu", "0",  # Use first GPU
+            ], "h264_nvenc"
         
         if self._platform.is_jetson():
-            # Jetson-specific encoder
-            return ["-c:v", "h264_omx"], "h264_omx"
+            # Jetson-specific encoder with optimizations
+            return [
+                "-c:v", "h264_nvenc",
+                "-preset", "p1",
+                "-tune", "ull",
+                "-rc:v", "cbr",
+                "-rc-lookahead", "0",
+                "-delay", "0",
+                "-zerolatency", "1",
+                "-profile:v", "main",
+            ], "h264_nvenc"
 
         if sys.platform == "darwin": 
-            return ["-c:v", "h264_videotoolbox"], "h264_videotoolbox"
+            return [
+                "-c:v", "h264_videotoolbox",
+                "-profile:v", "main",
+                "-realtime", "1",
+            ], "h264_videotoolbox"
         
         has_nvidia = (os.environ.get("NVIDIA_VISIBLE_DEVICES") is not None or 
                       os.path.exists("/proc/driver/nvidia/version"))
         
         if has_nvidia:
-            return ["-c:v", "h264_nvenc", "-preset", "llhp"], "h264_nvenc"
+            return [
+                "-c:v", "h264_nvenc",
+                "-preset", "p1",  # p1 = fastest preset
+                "-tune", "ull",  # ultra-low latency
+                "-rc:v", "cbr",  # constant bitrate
+                "-rc-lookahead", "0",  # disable lookahead
+                "-delay", "0",  # zero delay
+                "-zerolatency", "1",  # zero latency mode
+                "-profile:v", "main",
+                "-gpu", "0",  # Use first GPU
+            ], "h264_nvenc"
         
-        return ["-c:v", "libx264"], "libx264"
+        return [
+            "-c:v", "libx264",
+            "-preset", "ultrafast",
+            "-tune", "zerolatency",
+            "-profile:v", "main",
+        ], "libx264"

{nedo_vision_worker_core-0.4.0 → nedo_vision_worker_core-0.4.3}/nedo_vision_worker_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.4.0
+Version: 0.4.3
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>

nedo_vision_worker_core-0.4.0/nedo_vision_worker_core/repositories/WorkerSourceRepository.py

@@ -1,21 +0,0 @@
-from .BaseRepository import BaseRepository
-from ..models.worker_source import WorkerSourceEntity
-
-
-class WorkerSourceRepository(BaseRepository):
-    def __init__(self):
-        super().__init__(db_name="config")
-
-    def get_worker_sources(self):
-        """
-        Fetch all worker sources from the local database in a single query.
-
-        Returns:
-            list: A list of WorkerSourceEntity records.
-        """
-        with self._get_session() as session:
-            session.expire_all()
-            sources = session.query(WorkerSourceEntity).all()
-            for source in sources:
-                session.expunge(source)
-            return sources