matrice-streaming 0.1.60__py3-none-any.whl → 0.1.61__py3-none-any.whl

matrice_streaming/streaming_gateway/camera_streamer/nvdec_worker_manager.py

@@ -0,0 +1,380 @@
+"""NVDEC Worker Manager for StreamingGateway integration.
+
+This module provides a simplified manager for the NVDEC hardware decoding backend.
+Unlike other backends, NVDEC uses static camera configuration at startup and outputs
+to CUDA IPC ring buffers (NV12 format) for zero-copy GPU inference pipelines.
+"""
+
+import logging
+import multiprocessing as mp
+import time
+from typing import Dict, List, Optional, Any
+
+from .nvdec import (
+    nvdec_pool_process,
+    StreamConfig,
+    CUPY_AVAILABLE,
+    PYNVCODEC_AVAILABLE,
+    RING_BUFFER_AVAILABLE,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def is_nvdec_available() -> bool:
+    """Check if NVDEC backend is available.
+
+    Requires:
+        - CuPy with CUDA support
+        - PyNvVideoCodec for NVDEC hardware decode
+        - cuda_shm_ring_buffer module for CUDA IPC
+    """
+    return CUPY_AVAILABLE and PYNVCODEC_AVAILABLE and RING_BUFFER_AVAILABLE
+
+
+def get_available_gpu_count() -> int:
+    """Detect the number of available CUDA GPUs.
+
+    Returns:
+        Number of available GPUs, or 1 if detection fails.
+    """
+    if not CUPY_AVAILABLE:
+        return 1
+
+    try:
+        import cupy as cp
+        return cp.cuda.runtime.getDeviceCount()
+    except Exception as e:
+        logger.warning(f"Failed to detect GPU count: {e}, defaulting to 1")
+        return 1
+
+
+class NVDECWorkerManager:
+    """Manager for NVDEC worker processes - static camera configuration.
+
+    This manager wraps the existing nvdec_pool_process function to integrate
+    with StreamingGateway. Key differences from other worker managers:
+
+    - Static camera configuration (no dynamic add/remove)
+    - Outputs to CUDA IPC ring buffers (not Redis/Kafka)
+    - NV12 format output (50% smaller than RGB)
+    - One worker process per GPU
+    """
+
+    def __init__(
+        self,
+        camera_configs: List[Dict[str, Any]],
+        stream_config: Dict[str, Any],  # Unused but kept for interface consistency
+        gpu_id: int = 0,
+        num_gpus: int = 0,  # 0 = auto-detect all available GPUs
+        nvdec_pool_size: int = 8,
+        nvdec_burst_size: int = 4,
+        frame_width: int = 640,
+        frame_height: int = 640,
+        num_slots: int = 32,
+        target_fps: int = 0,  # 0 = use per-camera FPS from config
+        duration_sec: float = 0,  # 0 = infinite
+    ):
+        """Initialize NVDEC Worker Manager.
+
+        Args:
+            camera_configs: List of camera configuration dicts with keys:
+                - camera_id or stream_key: Unique identifier (used for ring buffer naming)
+                - source: Video file path or RTSP URL
+                - width: Optional frame width (default: frame_width)
+                - height: Optional frame height (default: frame_height)
+                - fps: FPS limit for this camera (used by default)
+            stream_config: Stream configuration (unused, for interface consistency)
+            gpu_id: Primary GPU device ID (starting GPU for round-robin assignment)
+            num_gpus: Number of GPUs to use (0 = auto-detect all available GPUs)
+            nvdec_pool_size: Number of NVDEC decoders per GPU
+            nvdec_burst_size: Frames per stream before rotating to next
+            frame_width: Default output frame width (used if camera config doesn't specify)
+            frame_height: Default output frame height (used if camera config doesn't specify)
+            num_slots: Ring buffer slots per camera
+            target_fps: Global FPS override (0 = use per-camera FPS from config)
+            duration_sec: Duration to run (0 = infinite until stop)
+        """
+        if not is_nvdec_available():
+            raise RuntimeError(
+                "NVDEC not available. Requires CuPy, PyNvVideoCodec, and cuda_shm_ring_buffer"
+            )
+
+        self.camera_configs = camera_configs
+        self.stream_config = stream_config
+        self.gpu_id = gpu_id
+
+        # Auto-detect GPUs if num_gpus is 0
+        if num_gpus <= 0:
+            detected_gpus = get_available_gpu_count()
+            self.num_gpus = min(detected_gpus, 8)  # Max 8 GPUs
+            logger.info(f"Auto-detected {detected_gpus} GPU(s), using {self.num_gpus}")
+        else:
+            self.num_gpus = min(num_gpus, 8)  # Max 8 GPUs
+        self.nvdec_pool_size = nvdec_pool_size
+        self.nvdec_burst_size = nvdec_burst_size
+        self.frame_width = frame_width
+        self.frame_height = frame_height
+        self.num_slots = num_slots
+        self.target_fps = target_fps
+        self.duration_sec = duration_sec if duration_sec > 0 else float('inf')
+
+        self._workers: List[mp.Process] = []
+        self._stop_event: Optional[mp.Event] = None
+        self._result_queue: Optional[mp.Queue] = None
+        self._shared_frame_count: Optional[mp.Value] = None
+        self._start_time: Optional[float] = None
+        self._is_running = False
+
+        # Convert camera configs to StreamConfig objects and assign to GPUs
+        self._stream_configs: List[StreamConfig] = []
+        self._gpu_camera_assignments: Dict[int, List[StreamConfig]] = {
+            i: [] for i in range(self.num_gpus)
+        }
+        self._camera_to_gpu: Dict[str, int] = {}
+
+        self._prepare_camera_configs()
+
+        logger.info(
+            f"NVDECWorkerManager initialized: {len(camera_configs)} cameras, "
+            f"{self.num_gpus} GPU(s), pool_size={nvdec_pool_size}"
+        )
+
+    def _prepare_camera_configs(self):
+        """Convert dict configs to StreamConfig and distribute across GPUs.
+
+        Ring buffers are named using camera_id for SHM identification.
+        Per-camera FPS from config is used by default (target_fps=0 means use config FPS).
+        """
+        for i, config in enumerate(self.camera_configs):
+            # Extract camera ID (support both camera_id and stream_key)
+            # This ID is used for naming the CUDA IPC ring buffer
+            camera_id = config.get('camera_id') or config.get('stream_key') or f"cam_{i:04d}"
+
+            # Extract video source
+            source = config.get('source') or config.get('video_path')
+            if not source:
+                logger.warning(f"Camera {camera_id} has no source, skipping")
+                continue
+
+            # Extract dimensions (use per-camera config or fallback to defaults)
+            width = config.get('width') or self.frame_width
+            height = config.get('height') or self.frame_height
+
+            # Determine FPS: use global override if set, otherwise per-camera FPS from config
+            if self.target_fps > 0:
+                # Global FPS override is set
+                fps = self.target_fps
+            else:
+                # Use per-camera FPS from config (default streaming FPS)
+                fps = config.get('fps', 10)  # Default to 10 FPS if not specified
+
+            # Assign to GPU (round-robin starting from gpu_id)
+            gpu_id = (self.gpu_id + i) % self.num_gpus
+
+            stream_config = StreamConfig(
+                camera_id=camera_id,
+                video_path=source,
+                width=width,
+                height=height,
+                target_fps=fps,
+                gpu_id=gpu_id,
+            )
+
+            self._stream_configs.append(stream_config)
+            self._gpu_camera_assignments[gpu_id].append(stream_config)
+            self._camera_to_gpu[camera_id] = gpu_id
+
+            logger.debug(f"Camera {camera_id}: source={source}, {width}x{height}@{fps}fps, GPU{gpu_id}")
+
+    def start(self) -> None:
+        """Start NVDEC worker processes (one per GPU)."""
+        if self._is_running:
+            logger.warning("NVDECWorkerManager is already running")
+            return
+
+        if not self._stream_configs:
+            logger.warning("No cameras configured, nothing to start")
+            return
+
+        ctx = mp.get_context("spawn")
+        self._stop_event = ctx.Event()
+        self._result_queue = ctx.Queue()
+        self._shared_frame_count = ctx.Value('i', 0)
+        self._start_time = time.perf_counter()
+
+        # Start one process per GPU that has cameras
+        for gpu_id in range(self.num_gpus):
+            gpu_cameras = self._gpu_camera_assignments[gpu_id]
+            if not gpu_cameras:
+                continue
+
+            p = ctx.Process(
+                target=nvdec_pool_process,
+                args=(
+                    gpu_id,                     # process_id
+                    gpu_cameras,                # camera_configs (List[StreamConfig])
+                    self.nvdec_pool_size,       # pool_size
+                    self.duration_sec,          # duration_sec
+                    self._result_queue,         # result_queue
+                    self._stop_event,           # stop_event
+                    self.nvdec_burst_size,      # burst_size
+                    self.num_slots,             # num_slots
+                    self.target_fps,            # target_fps
+                    self._shared_frame_count,   # shared_frame_count
+                ),
+                name=f"NVDECWorker-GPU{gpu_id}",
+                daemon=False,
+            )
+            p.start()
+            self._workers.append(p)
+            logger.info(f"Started NVDEC worker on GPU {gpu_id} with {len(gpu_cameras)} cameras")
+
+        self._is_running = True
+        logger.info(f"NVDECWorkerManager started: {len(self._workers)} workers")
+
+    def stop(self, timeout: float = 15.0) -> None:
+        """Stop all worker processes.
+
+        Args:
+            timeout: Maximum time to wait for each worker to stop gracefully
+        """
+        if not self._is_running:
+            logger.warning("NVDECWorkerManager is not running")
+            return
+
+        logger.info("Stopping NVDECWorkerManager...")
+
+        # Signal workers to stop
+        if self._stop_event:
+            self._stop_event.set()
+
+        # Wait for workers to finish
+        for p in self._workers:
+            p.join(timeout=timeout)
+            if p.is_alive():
+                logger.warning(f"Worker {p.name} did not stop gracefully, terminating")
+                p.terminate()
+                p.join(timeout=2.0)
+
+        self._workers.clear()
+        self._is_running = False
+        logger.info("NVDECWorkerManager stopped")
+
+    def get_worker_statistics(self) -> Dict[str, Any]:
+        """Return statistics from workers.
+
+        Returns:
+            Dict with keys:
+                - num_workers: Number of worker processes
+                - running_workers: Number of currently running workers
+                - total_cameras: Total cameras across all workers
+                - gpu_assignments: Cameras per GPU
+                - total_frames: Total frames processed (from shared counter)
+                - elapsed_sec: Time since start
+                - aggregate_fps: Overall FPS
+                - per_stream_fps: Average FPS per camera
+                - backend: 'nvdec'
+                - gpu_results: Per-GPU results from result queue
+        """
+        stats = {
+            'backend': 'nvdec',
+            'num_workers': len(self._workers),
+            'running_workers': sum(1 for p in self._workers if p.is_alive()),
+            'total_cameras': len(self._stream_configs),
+            'gpu_assignments': {
+                gpu_id: len(cameras)
+                for gpu_id, cameras in self._gpu_camera_assignments.items()
+            },
+            'nvdec_config': {
+                'gpu_id': self.gpu_id,
+                'num_gpus': self.num_gpus,
+                'pool_size': self.nvdec_pool_size,
+                'burst_size': self.nvdec_burst_size,
+                'frame_size': f"{self.frame_width}x{self.frame_height}",
+                'num_slots': self.num_slots,
+                'target_fps': self.target_fps,
+            },
+        }
+
+        # Add frame count and FPS
+        if self._shared_frame_count:
+            total_frames = self._shared_frame_count.value
+            stats['total_frames'] = total_frames
+
+            if self._start_time:
+                elapsed = time.perf_counter() - self._start_time
+                stats['elapsed_sec'] = elapsed
+                stats['aggregate_fps'] = total_frames / elapsed if elapsed > 0 else 0
+                stats['per_stream_fps'] = (
+                    stats['aggregate_fps'] / len(self._stream_configs)
+                    if self._stream_configs else 0
+                )
+
+        # Collect any available results from queue (non-blocking)
+        gpu_results = []
+        if self._result_queue:
+            while True:
+                try:
+                    result = self._result_queue.get_nowait()
+                    gpu_results.append(result)
+                except:
+                    break
+        stats['gpu_results'] = gpu_results
+
+        return stats
+
+    def get_camera_assignments(self) -> Dict[str, int]:
+        """Return mapping of camera_id to GPU ID.
+
+        Returns:
+            Dict mapping camera_id -> gpu_id
+        """
+        return self._camera_to_gpu.copy()
+
+    def add_camera(self, camera_config: Dict[str, Any]) -> bool:
+        """Not supported - NVDEC uses static camera configuration.
+
+        Raises:
+            NotImplementedError: Always raised
+        """
+        raise NotImplementedError(
+            "NVDEC backend uses static camera configuration. "
+            "Cameras must be configured at initialization."
+        )
+
+    def remove_camera(self, stream_key: str) -> bool:
+        """Not supported - NVDEC uses static camera configuration.
+
+        Raises:
+            NotImplementedError: Always raised
+        """
+        raise NotImplementedError(
+            "NVDEC backend uses static camera configuration. "
+            "Cameras cannot be removed at runtime."
+        )
+
+    def update_camera(self, camera_config: Dict[str, Any]) -> bool:
+        """Not supported - NVDEC uses static camera configuration.
+
+        Raises:
+            NotImplementedError: Always raised
+        """
+        raise NotImplementedError(
+            "NVDEC backend uses static camera configuration. "
+            "Cameras cannot be updated at runtime."
+        )
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the manager is currently running."""
+        return self._is_running
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()

matrice_streaming/streaming_gateway/streaming_gateway.py

@@ -17,6 +17,7 @@ from .dynamic_camera_manager import DynamicCameraManager, DynamicCameraManagerFo
 
 USE_FFMPEG = os.getenv("USE_FFMPEG", "false").lower() == "true"
 USE_GSTREAMER = os.getenv("USE_GSTREAMER", "false").lower() == "true"
+USE_NVDEC = os.getenv("USE_NVDEC", "false").lower() == "true"
 
 # GStreamer imports (optional - graceful degradation)
 GSTREAMER_AVAILABLE = False
@@ -44,6 +45,15 @@ except (ImportError, FileNotFoundError):
     # FFmpeg not available or not installed
     pass
 
+# NVDEC imports (optional - graceful degradation)
+NVDEC_AVAILABLE = False
+try:
+    from .camera_streamer.nvdec_worker_manager import NVDECWorkerManager, is_nvdec_available
+    NVDEC_AVAILABLE = is_nvdec_available()
+except ImportError:
+    # NVDEC not available (requires CuPy, PyNvVideoCodec)
+    pass
+
 
 class StreamingGateway:
     """Simplified streaming gateway for managing camera streams."""
@@ -87,6 +97,16 @@ class StreamingGateway:
         ffmpeg_threads: int = 1,           # FFmpeg decode threads per stream
         ffmpeg_low_latency: bool = True,   # Enable low-latency flags
         ffmpeg_pixel_format: str = "bgr24",# Output pixel format
+        # NVDEC options (CUDA IPC ring buffer output)
+        use_nvdec: bool = USE_NVDEC,       # Use NVDEC hardware decode + CUDA IPC output
+        nvdec_gpu_id: int = 0,             # Primary GPU device ID (starting GPU)
+        nvdec_num_gpus: int = 0,           # Number of GPUs (0=auto-detect all available)
+        nvdec_pool_size: int = 8,          # NVDEC decoders per GPU
+        nvdec_burst_size: int = 4,         # Frames per stream before rotating
+        nvdec_frame_width: int = 640,      # Output frame width
+        nvdec_frame_height: int = 640,     # Output frame height
+        nvdec_num_slots: int = 32,         # Ring buffer slots per camera
+        nvdec_target_fps: int = 0,         # FPS override (0=use per-camera FPS from config)
         # SHM configuration (centralized)
         shm_slot_count: int = 1000,        # Ring buffer size per camera (increased for consumer lag)
     ):
@@ -123,6 +143,15 @@ class StreamingGateway:
             ffmpeg_threads: Number of FFmpeg decode threads per stream
             ffmpeg_low_latency: Enable FFmpeg low-latency flags
             ffmpeg_pixel_format: Output pixel format (bgr24, rgb24, nv12)
+            use_nvdec: Use NVDEC hardware decode with CUDA IPC output (requires CuPy, PyNvVideoCodec)
+            nvdec_gpu_id: Primary/starting GPU device ID for round-robin camera assignment
+            nvdec_num_gpus: Number of GPUs to use (0=auto-detect all available GPUs)
+            nvdec_pool_size: Number of NVDEC decoders per GPU
+            nvdec_burst_size: Frames per stream before rotating to next stream
+            nvdec_frame_width: Default output frame width (used if camera config doesn't specify)
+            nvdec_frame_height: Default output frame height (used if camera config doesn't specify)
+            nvdec_num_slots: Ring buffer slots per camera (named by camera_id)
+            nvdec_target_fps: Global FPS override (0=use per-camera FPS from camera config)
             shm_slot_count: Number of frame slots per camera ring buffer for SHM mode (default: 300)
         """
         if not session:
@@ -168,6 +197,17 @@ class StreamingGateway:
         self.ffmpeg_low_latency = ffmpeg_low_latency
         self.ffmpeg_pixel_format = ffmpeg_pixel_format
 
+        # NVDEC configuration
+        self.use_nvdec = use_nvdec
+        self.nvdec_gpu_id = nvdec_gpu_id
+        self.nvdec_num_gpus = nvdec_num_gpus
+        self.nvdec_pool_size = nvdec_pool_size
+        self.nvdec_burst_size = nvdec_burst_size
+        self.nvdec_frame_width = nvdec_frame_width
+        self.nvdec_frame_height = nvdec_frame_height
+        self.nvdec_num_slots = nvdec_num_slots
+        self.nvdec_target_fps = nvdec_target_fps
+
         # SHM configuration (centralized for all workers)
         self.shm_slot_count = shm_slot_count
 
@@ -178,9 +218,17 @@ class StreamingGateway:
                 "Install FFmpeg from https://ffmpeg.org/download.html"
             )
 
+        # Validate NVDEC availability if requested
+        if use_nvdec and not NVDEC_AVAILABLE:
+            raise RuntimeError(
+                "NVDEC requested but not available. "
+                "Requires CuPy, PyNvVideoCodec, and cuda_shm_ring_buffer module."
+            )
+
         # Validate exclusive backend selection
-        if use_gstreamer and use_ffmpeg:
-            raise ValueError("Cannot enable both GStreamer and FFmpeg backends")
+        backends_enabled = sum([use_gstreamer, use_ffmpeg, use_nvdec])
+        if backends_enabled > 1:
+            raise ValueError("Cannot enable multiple backends (GStreamer, FFmpeg, NVDEC) simultaneously")
 
         # Initialize utility for API interactions
         self.gateway_util = StreamingGatewayUtil(session, streaming_gateway_id, server_id, action_id=action_id)
@@ -228,15 +276,54 @@ class StreamingGateway:
                 raise ValueError(f"Input config {i} must be an InputStream instance")
 
         # Initialize streaming backend based on configuration
-        # Options: use_ffmpeg, use_gstreamer, use_async_workers (AsyncCameraWorker), or CameraStreamer
+        # Options: use_nvdec, use_ffmpeg, use_gstreamer, use_async_workers (AsyncCameraWorker), or CameraStreamer
         self.camera_streamer: Optional[CameraStreamer] = None
         self.worker_manager: Optional[WorkerManager] = None
         self.gstreamer_streamer: Optional[Any] = None  # GStreamerCameraStreamer
         self.gstreamer_worker_manager: Optional[Any] = None  # GStreamerWorkerManager
         self.ffmpeg_streamer: Optional[Any] = None  # FFmpegCameraStreamer
         self.ffmpeg_worker_manager: Optional[Any] = None  # FFmpegWorkerManager
+        self.nvdec_worker_manager: Optional[Any] = None  # NVDECWorkerManager
 
-        if self.use_ffmpeg:
+        if self.use_nvdec:
+            # NVDEC-based streaming flow (CUDA IPC output, static camera config)
+            logging.info(
+                f"Initializing NVDEC worker flow - GPUs: {nvdec_num_gpus}, "
+                f"pool_size: {nvdec_pool_size}, output: NV12 ({nvdec_frame_width}x{nvdec_frame_height})"
+            )
+
+            # Build stream config (unused by NVDEC but needed for interface consistency)
+            stream_config = build_stream_config(
+                gateway_util=self.gateway_util,
+                server_type=server_type,
+                service_id=streaming_gateway_id,
+                stream_maxlen=self.shm_slot_count,
+            )
+
+            # Convert InputStream configs to camera_config dicts
+            camera_configs = [
+                input_stream_to_camera_config(inp) for inp in self.inputs_config
+            ]
+
+            self.nvdec_worker_manager = NVDECWorkerManager(
+                camera_configs=camera_configs,
+                stream_config=stream_config,
+                gpu_id=nvdec_gpu_id,
+                num_gpus=nvdec_num_gpus,
+                nvdec_pool_size=nvdec_pool_size,
+                nvdec_burst_size=nvdec_burst_size,
+                frame_width=nvdec_frame_width,
+                frame_height=nvdec_frame_height,
+                num_slots=nvdec_num_slots,
+                target_fps=nvdec_target_fps,
+            )
+
+            # NVDEC uses static camera configuration - no dynamic camera manager
+            # Set camera_manager to None to indicate static mode
+            self.camera_manager = None
+            logging.info("NVDEC backend initialized (static camera configuration)")
+
+        elif self.use_ffmpeg:
             # FFmpeg-based streaming flow
             # Build stream config for workers
             stream_config = build_stream_config(
@@ -444,12 +531,15 @@ class StreamingGateway:
             )
 
         # Initialize with current camera configurations
-        self.camera_manager.initialize_from_config(self.inputs_config)
+        # (skip for NVDEC which uses static configuration)
+        if self.camera_manager is not None:
+            self.camera_manager.initialize_from_config(self.inputs_config)
 
-        # Initialize event system (if enabled)
+        # Initialize event system (if enabled and camera_manager exists)
+        # NVDEC doesn't support dynamic cameras, so event listening is disabled
         self.event_listener: Optional[EventListener] = None
-        
-        if self.enable_event_listening:
+
+        if self.enable_event_listening and self.camera_manager is not None:
             try:
                 self.event_listener = EventListener(
                     session=self.session,
@@ -459,6 +549,8 @@ class StreamingGateway:
             except Exception as e:
                 logging.warning(f"Could not initialize event system: {e}")
                 logging.info("Continuing without event listening")
+        elif self.enable_event_listening and self.use_nvdec:
+            logging.info("Event listening disabled for NVDEC backend (static camera configuration)")
 
         # State management
         self.is_streaming = False
@@ -537,7 +629,9 @@ class StreamingGateway:
         self._register_as_active()
 
         try:
-            if self.use_ffmpeg:
+            if self.use_nvdec:
+                success = self._start_nvdec_worker_streaming()
+            elif self.use_ffmpeg:
                 if self.use_async_workers:
                     success = self._start_ffmpeg_worker_streaming()
                 else:
@@ -754,6 +848,45 @@ class StreamingGateway:
 
         return True
 
+    def _start_nvdec_worker_streaming(self) -> bool:
+        """Start streaming using NVDEC hardware decode with CUDA IPC output.
+
+        NVDEC outputs NV12 frames to CUDA IPC ring buffers for zero-copy
+        GPU inference pipelines. Unlike other backends, NVDEC:
+        - Uses static camera configuration (no dynamic add/remove)
+        - Outputs to CUDA IPC ring buffers (not Redis/Kafka)
+        - Outputs NV12 format (50% smaller than RGB)
+
+        Returns:
+            bool: True if started successfully, False otherwise
+        """
+        num_cameras = len(self.inputs_config) if self.inputs_config else 0
+        logging.info(
+            f"Starting NVDEC worker streaming with {num_cameras} cameras "
+            f"(GPUs: {self.nvdec_num_gpus}, pool_size: {self.nvdec_pool_size}, "
+            f"output: NV12 {self.nvdec_frame_width}x{self.nvdec_frame_height})"
+        )
+
+        # Build stream key mappings for tracking
+        if self.inputs_config:
+            for i, input_config in enumerate(self.inputs_config):
+                stream_key = input_config.camera_key or f"stream_{i}"
+                camera_id = input_config.camera_id or stream_key
+                self._stream_key_to_camera_id[stream_key] = camera_id
+                self._my_stream_keys.add(stream_key)
+
+        # Start the NVDEC worker manager
+        try:
+            self.nvdec_worker_manager.start()
+            logging.info(
+                f"Started NVDECWorkerManager with {self.nvdec_num_gpus} GPU(s), "
+                f"{num_cameras} cameras"
+            )
+            return True
+        except Exception as exc:
+            logging.error(f"Failed to start NVDECWorkerManager: {exc}", exc_info=True)
+            return False
+
     def _start_ffmpeg_worker_streaming(self) -> bool:
         """Start streaming using FFmpeg worker processes.
 
@@ -867,7 +1000,16 @@ class StreamingGateway:
                 logging.error(f"Error stopping event listener: {exc}")
 
         # Stop streaming backend based on which flow is active
-        if self.use_ffmpeg:
+        if self.use_nvdec:
+            # Stop NVDEC backend
+            if self.nvdec_worker_manager:
+                try:
+                    logging.info("Stopping NVDECWorkerManager")
+                    self.nvdec_worker_manager.stop()
+                    logging.info("NVDEC worker manager stopped")
+                except Exception as exc:
+                    logging.error(f"Error stopping NVDECWorkerManager: {exc}")
+        elif self.use_ffmpeg:
             # Stop FFmpeg backends
             if self.use_async_workers:
                 # Stop FFmpegWorkerManager
@@ -1000,9 +1142,28 @@ class StreamingGateway:
         stats["use_async_workers"] = self.use_async_workers
         stats["use_gstreamer"] = self.use_gstreamer
         stats["use_ffmpeg"] = self.use_ffmpeg
+        stats["use_nvdec"] = self.use_nvdec
 
         # Add backend-specific statistics
-        if self.use_ffmpeg:
+        if self.use_nvdec:
+            # NVDEC statistics
+            stats["nvdec_config"] = {
+                "gpu_id": self.nvdec_gpu_id,
+                "num_gpus": self.nvdec_num_gpus,
+                "pool_size": self.nvdec_pool_size,
+                "burst_size": self.nvdec_burst_size,
+                "frame_width": self.nvdec_frame_width,
+                "frame_height": self.nvdec_frame_height,
+                "num_slots": self.nvdec_num_slots,
+                "target_fps": self.nvdec_target_fps,
+            }
+            if self.nvdec_worker_manager:
+                try:
+                    stats["worker_stats"] = self.nvdec_worker_manager.get_worker_statistics()
+                    stats["camera_assignments"] = self.nvdec_worker_manager.get_camera_assignments()
+                except Exception as exc:
+                    logging.warning(f"Failed to get NVDEC worker stats: {exc}")
+        elif self.use_ffmpeg:
             # FFmpeg statistics
             stats["ffmpeg_config"] = {
                 "hwaccel": self.ffmpeg_hwaccel,
@@ -1130,6 +1291,16 @@ class StreamingGateway:
             "gstreamer_frame_optimizer_mode": self.gstreamer_frame_optimizer_mode,
             "gstreamer_fallback_on_error": self.gstreamer_fallback_on_error,
             "gstreamer_verbose_logging": self.gstreamer_verbose_logging,
+            # NVDEC configuration
+            "use_nvdec": self.use_nvdec,
+            "nvdec_gpu_id": self.nvdec_gpu_id,
+            "nvdec_num_gpus": self.nvdec_num_gpus,
+            "nvdec_pool_size": self.nvdec_pool_size,
+            "nvdec_burst_size": self.nvdec_burst_size,
+            "nvdec_frame_width": self.nvdec_frame_width,
+            "nvdec_frame_height": self.nvdec_frame_height,
+            "nvdec_num_slots": self.nvdec_num_slots,
+            "nvdec_target_fps": self.nvdec_target_fps,
         }
 
     def _emergency_cleanup(self):

{matrice_streaming-0.1.60.dist-info → matrice_streaming-0.1.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_streaming
-Version: 0.1.60
+Version: 0.1.61
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT