matrice-streaming 0.1.63__tar.gz → 0.1.64__tar.gz

{matrice_streaming-0.1.63 → matrice_streaming-0.1.64}/PKG-INFO

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

{matrice_streaming-0.1.63 → matrice_streaming-0.1.64}/matrice_streaming.egg-info/PKG-INFO

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

{matrice_streaming-0.1.63 → matrice_streaming-0.1.64}/src/matrice_streaming/streaming_gateway/camera_streamer/nvdec.py

@@ -547,7 +547,12 @@ def surface_to_nv12(frame, target_h: int = 640, target_w: int = 640) -> Optional
         return nv12_frame[:, :, cp.newaxis] if nv12_frame is not None else None
 
     except Exception as e:
-        logger.warning(f"surface_to_nv12 failed: {e}")
+        # Safely encode error message (some CUDA errors contain non-ASCII chars like '×')
+        try:
+            err_msg = str(e).encode('ascii', errors='replace').decode('ascii')
+        except Exception:
+            err_msg = "unknown error"
+        logger.warning(f"surface_to_nv12 failed: {err_msg}")
         return None
 
 
@@ -727,7 +732,6 @@ def nvdec_pool_worker(
     frames_since_counter_update = 0
     counter_batch_size = 100
     start_time = time.perf_counter()
-    last_log_time = start_time
     camera_ids = pool.get_camera_ids_for_decoder(decoder_idx)
     num_streams = len(camera_ids)
 
@@ -745,19 +749,12 @@ def nvdec_pool_worker(
         next_frame_time = 0
         fps_mode = ", unlimited FPS"
 
-    logger.info(f"Worker {worker_id}: decoder={decoder_idx}, cams={num_streams}{fps_mode}")
+    logger.debug(f"Worker {worker_id}: decoder={decoder_idx}, cams={num_streams}{fps_mode}")
 
     while not stop_event.is_set():
         if time.perf_counter() - start_time >= duration_sec:
             break
 
-        now = time.perf_counter()
-        if now - last_log_time >= 5.0:
-            elapsed = now - start_time
-            fps = local_frames / elapsed if elapsed > 0 else 0
-            logger.info(f"Worker {worker_id}: {local_frames} frames, {fps:.0f} FPS")
-            last_log_time = now
-
         # FPS limiting: wait until next scheduled frame time
         if fps_limit_enabled:
             current_time = time.perf_counter()
@@ -952,10 +949,52 @@ def nvdec_pool_process(
             t.start()
             threads.append(t)
 
+        # Progress monitoring loop with current/avg FPS tracking
         start_time = time.perf_counter()
+        last_report_time = start_time
+        last_frame_count = 0
+        report_interval = 5.0
+        processing_start_time = None
+        frames_at_processing_start = 0
+
         while not stop_event.is_set():
-            if time.perf_counter() - start_time >= duration_sec:
+            current_time = time.perf_counter()
+            if current_time - start_time >= duration_sec:
                 break
+
+            # Periodic progress report with current and average FPS
+            if current_time - last_report_time >= report_interval:
+                elapsed = current_time - start_time
+
+                if shared_frame_count is not None:
+                    current_frames = shared_frame_count.value
+                    interval_frames = current_frames - last_frame_count
+                    interval_fps = interval_frames / report_interval
+                    per_stream_fps = interval_fps / len(camera_configs) if camera_configs else 0
+
+                    # Track when processing actually starts (exclude warmup)
+                    if processing_start_time is None and current_frames > 0:
+                        processing_start_time = last_report_time
+                        frames_at_processing_start = last_frame_count
+
+                    # Calculate average FPS excluding warmup
+                    if processing_start_time is not None:
+                        processing_elapsed = current_time - processing_start_time
+                        processing_frames = current_frames - frames_at_processing_start
+                        avg_fps = processing_frames / processing_elapsed if processing_elapsed > 0 else 0
+                        avg_per_stream = avg_fps / len(camera_configs) if camera_configs else 0
+                        remaining = max(0, duration_sec - elapsed)
+
+                        logger.info(
+                            f"GPU{gpu_id} [{elapsed:5.1f}s] {current_frames:,} frames | "
+                            f"cur: {interval_fps:,.0f} FPS ({per_stream_fps:.1f}/stream) | "
+                            f"avg: {avg_fps:,.0f} FPS ({avg_per_stream:.1f}/stream) | "
+                            f"{remaining:.0f}s left"
+                        )
+
+                    last_frame_count = current_frames
+                last_report_time = current_time
+
             time.sleep(0.1)
 
         thread_stop_event.set()