matrice-streaming 0.1.14__py3-none-any.whl → 0.1.65__py3-none-any.whl

matrice_streaming/streaming_gateway/camera_streamer/camera_streamer.py

@@ -5,6 +5,7 @@ import threading
 import time
 from typing import Dict, Optional, Union, Any
 from matrice_common.stream.matrice_stream import MatriceStream, StreamType
+from matrice_common.optimize import FrameOptimizer
 
 # Import our modular components
 from .video_capture_manager import VideoCaptureManager
@@ -40,9 +41,11 @@ class CameraStreamer:
         gateway_util: StreamingGatewayUtil = None,
         connection_refresh_threshold: int = 10,
         connection_refresh_interval: float = 60.0,
+        frame_optimizer_enabled: bool = True,
+        frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize CameraStreamer.
-        
+
         Args:
             session: Session object for making RPC calls
             service_id: ID of the deployment
@@ -55,6 +58,8 @@ class CameraStreamer:
             gateway_util: StreamingGatewayUtil instance for fetching connection info
             connection_refresh_threshold: Number of consecutive failures before refreshing connection
             connection_refresh_interval: Minimum seconds between connection refresh attempts
+            frame_optimizer_enabled: Enable frame optimization to skip similar frames
+            frame_optimizer_config: Configuration for FrameOptimizer (scale, diff_threshold, etc.)
         """
         self.session = session
         self.service_id = service_id
@@ -66,6 +71,17 @@ class CameraStreamer:
         self.encoder_manager = EncoderManager(h265_mode, h265_quality, use_hardware)
         self.statistics = StreamStatistics()
         self.message_builder = StreamMessageBuilder(service_id, strip_input_content)
+
+        # Initialize frame optimizer for skipping similar frames
+        optimizer_config = frame_optimizer_config or {}
+        self.frame_optimizer = FrameOptimizer(
+            enabled=frame_optimizer_enabled,
+            scale=optimizer_config.get("scale", 0.4),
+            diff_threshold=optimizer_config.get("diff_threshold", 15),
+            similarity_threshold=optimizer_config.get("similarity_threshold", 0.05),
+            bg_update_interval=optimizer_config.get("bg_update_interval", 10),
+        )
+        self._last_sent_frame_ids: Dict[str, str] = {}  # stream_key -> last sent frame_id
         
         # Video codec configuration
         self.video_codec = self._normalize_video_codec(video_codec, h265_mode)
@@ -82,6 +98,12 @@ class CameraStreamer:
         self.connection_refresh_interval = connection_refresh_interval
         self._send_failure_count = 0
         self._last_connection_refresh_time = 0.0
+
+        # Metrics logging state
+        self._last_metrics_log_time = time.time()
+        self._last_aggregated_log_time = time.time()  # Separate tracker for aggregated stats
+        self._metrics_log_interval = 30.0  # seconds (configurable)
+        self._aggregated_log_interval = 60.0  # seconds for aggregated stats
         self._connection_lock = threading.RLock()
         
         # Initialize MatriceStream
@@ -93,7 +115,17 @@ class CameraStreamer:
             self.logger = logging.getLogger(__name__)
             self.logger.error("No gateway_util provided, connection refresh will be disabled")
             self.stream_config = {}
-        
+
+        # Add Redis configuration with conservative batching defaults
+        # (Worker manager will automatically optimize based on camera count)
+        if self.server_type == "redis":
+            self.stream_config.update({
+                'pool_max_connections': 500,  # High connection pool for 1000+ cameras
+                'enable_batching': True,      # Enable message batching
+                'batch_size': 10,             # Conservative default (low latency for single camera)
+                'batch_timeout': 0.01         # 10ms timeout (minimal delay)
+            })
+
         self.matrice_stream = MatriceStream(
             StreamType.REDIS if self.server_type == "redis" else StreamType.KAFKA,
             **self.stream_config
@@ -620,8 +652,8 @@ class CameraStreamer:
                 read_time
             )
             
-            # Log statistics periodically
-            self.statistics.log_periodic_stats(stream_key, read_time, encoding_time, write_time)
+            # Log statistics periodically (time-based)
+            self._maybe_log_metrics(stream_key)
             
             # Maintain FPS for non-RTSP streams
             if not is_rtsp:
@@ -650,7 +682,7 @@ class CameraStreamer:
         camera_location: str,
         read_time: float
     ) -> tuple:
-        """Process frame: encode, build message, and send."""
+        """Process frame: check similarity, encode if needed, build message, and send."""
         # Build metadata
         metadata = self.message_builder.build_frame_metadata(
             source, video_props, fps, quality, actual_width, actual_height,
@@ -660,8 +692,60 @@ class CameraStreamer:
         metadata["feed_type"] = "disk" if source_type == "video_file" else "camera"
         metadata["frame_count"] = 1
         metadata["stream_unit"] = "segment" if is_video_chunk else "frame"
-        
-        # Encode frame
+
+        # Check frame similarity BEFORE encoding (saves CPU if frame is similar)
+        is_similar, similarity_score = self.frame_optimizer.is_similar(frame, stream_key)
+        reference_frame_id = self._last_sent_frame_ids.get(stream_key)
+
+        # Get timing stats
+        last_read, last_write, last_process = self.statistics.get_timing(stream_key)
+        input_order = self.statistics.get_next_input_order(stream_key)
+
+        if is_similar and reference_frame_id:
+            # Frame is similar to previous - send message with empty content + cached_frame_id
+            encoding_time = 0.0  # No encoding needed
+            metadata["similarity_score"] = similarity_score
+
+            write_start = time.time()
+            try:
+                message = self.message_builder.build_message(
+                    frame_data=b"",  # EMPTY content for cached frame
+                    stream_key=stream_key,
+                    stream_group_key=stream_group_key,
+                    codec="cached",  # Special codec to indicate cached frame
+                    metadata=metadata,
+                    topic=topic,
+                    broker_config=self.matrice_stream.config.get('bootstrap_servers', 'localhost:9092'),
+                    input_order=input_order,
+                    last_read_time=last_read,
+                    last_write_time=last_write,
+                    last_process_time=last_process,
+                    cached_frame_id=reference_frame_id,  # Reference to cached frame
+                )
+
+                self.matrice_stream.add_message(
+                    topic_or_channel=topic,
+                    message=message,
+                    key=str(stream_key)
+                )
+                write_time = time.time() - write_start
+
+                # Record success
+                self._record_send_success()
+
+                # Update statistics - frame was skipped (no encoding)
+                self.statistics.increment_frames_skipped()
+                process_time = read_time + write_time
+                self.statistics.update_timing(stream_key, read_time, write_time, process_time, 0, encoding_time)
+
+            except Exception as e:
+                write_time = time.time() - write_start
+                self.logger.error(f"Failed to send cached frame message for {stream_key}: {e}")
+                self._record_send_failure()
+
+            return encoding_time, write_time
+
+        # Frame is different - encode and send full frame
         encoding_start = time.time()
         if self.video_codec in ["h265-frame", "h265-chunk"]:
             frame_data, metadata, codec = self.encoder_manager.encode_frame(
@@ -673,52 +757,59 @@ class CameraStreamer:
             # Keep codec as "h264" for downstream compatibility, but actual data is JPEG
             encode_success, jpeg_buffer = cv2.imencode('.jpg', frame, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
             if encode_success:
-                frame_data = jpeg_buffer.tobytes()
+                # ZERO-COPY: Use buffer directly instead of tobytes()
+                # jpeg_buffer is numpy array - convert via memoryview to avoid copy
+                # Only final bytes() call creates copy, but minimizes intermediate copies
+                frame_data = bytes(jpeg_buffer.data)
                 codec = "h264"  # Keep as h264 for downstream systems
                 metadata["encoding_type"] = "jpeg"  # Actual encoding format
             else:
                 self.logger.error(f"JPEG encoding failed for {stream_key}, using raw fallback")
-                frame_data = frame.tobytes()
+                # ZERO-COPY: Use buffer protocol instead of tobytes()
+                frame_data = bytes(memoryview(frame).cast('B'))
                 codec = "h264"
                 metadata["encoding_type"] = "raw"
         encoding_time = time.time() - encoding_start
-        
-        # Get timing stats
-        last_read, last_write, last_process = self.statistics.get_timing(stream_key)
-        input_order = self.statistics.get_next_input_order(stream_key)
-        
-        # Build and send message
+
+        # Build and send message (normal frame with content)
         write_start = time.time()
         try:
             message = self.message_builder.build_message(
                 frame_data, stream_key, stream_group_key, codec, metadata, topic,
                 self.matrice_stream.config.get('bootstrap_servers', 'localhost:9092'),
-                input_order, last_read, last_write, last_process
+                input_order, last_read, last_write, last_process,
+                cached_frame_id=None,  # Normal frame, no cache reference
             )
-            
+
             self.matrice_stream.add_message(
                 topic_or_channel=topic,
                 message=message,
                 key=str(stream_key)
             )
             write_time = time.time() - write_start
-            
+
             # Record success
             self._record_send_success()
-            
+
+            # Track this frame_id as the last sent for future cached frames
+            new_frame_id = message.get("frame_id")
+            if new_frame_id:
+                self._last_sent_frame_ids[stream_key] = new_frame_id
+                self.frame_optimizer.set_last_frame_id(stream_key, new_frame_id)
+
             # Update statistics
             self.statistics.increment_frames_sent()
             process_time = read_time + write_time
             frame_size = len(frame_data) if frame_data else 0
-            self.statistics.update_timing(stream_key, read_time, write_time, process_time, frame_size)
-            
+            self.statistics.update_timing(stream_key, read_time, write_time, process_time, frame_size, encoding_time)
+
         except Exception as e:
             write_time = time.time() - write_start
             self.logger.error(f"Failed to send message for {stream_key}: {e}")
-            
+
             # Record failure (will trigger connection refresh if threshold reached)
             self._record_send_failure()
-        
+
         return encoding_time, write_time
     
     # ========================================================================
@@ -746,12 +837,85 @@ class CameraStreamer:
         
         return masked
     
+    @staticmethod
+    def calculate_batch_parameters(num_cameras: int, fps: int = 10) -> Dict[str, Any]:
+        """Calculate optimal batch parameters based on number of cameras.
+
+        Uses conservative defaults for small camera counts to minimize latency,
+        then scales up for better throughput with many cameras.
+
+        Note: This should be called with per-worker camera count, not total
+        cameras in deployment. WorkerManager calls this for each worker.
+
+        Args:
+            num_cameras: Number of cameras being streamed (per worker)
+            fps: Target frames per second (default: 10)
+
+        Returns:
+            Dictionary with 'batch_size' and 'batch_timeout' parameters
+
+        Examples:
+            - 1-10 cameras: batch_size=10, timeout=10ms (low latency)
+            - 11-50 cameras: batch_size=50, timeout=20ms
+            - 51-200 cameras: batch_size=100, timeout=50ms
+            - 201-500 cameras: batch_size=100, timeout=20ms
+            - 500+ cameras: batch_size=50, timeout=10ms (per-worker optimized)
+        """
+        if num_cameras <= 10:
+            # Single/few cameras: Use conservative defaults for low latency
+            return {
+                'batch_size': 10,
+                'batch_timeout': 0.01  # 10ms
+            }
+        elif num_cameras <= 50:
+            # Small deployment: Fast flushes for low latency
+            return {
+                'batch_size': 25,
+                'batch_timeout': 0.01  # 10ms
+            }
+        else:
+            # 50+ cameras per worker: Minimize batching to reduce write latency
+            # With many concurrent frame arrivals, large batches cause queue backup
+            # Small batch + fast timeout = frames flush immediately
+            return {
+                'batch_size': 10,
+                'batch_timeout': 0.005  # 5ms - flush quickly
+            }
+
+    def _maybe_log_metrics(self, stream_key: str) -> None:
+        """Log metrics if interval has elapsed.
+
+        Args:
+            stream_key: Stream identifier
+        """
+        current_time = time.time()
+        if (current_time - self._last_metrics_log_time) >= self._metrics_log_interval:
+            # Log per-stream metrics
+            self.statistics.log_detailed_stats(stream_key)
+
+            # Log frame optimizer metrics
+            if self.frame_optimizer.enabled:
+                opt_metrics = self.frame_optimizer.get_metrics()
+                self.logger.info(
+                    f"Frame Optimizer: "
+                    f"similarity_rate={opt_metrics['similarity_rate']:.1f}%, "
+                    f"active_streams={opt_metrics['active_streams']}, "
+                    f"threshold={opt_metrics['config']['similarity_threshold']}"
+                )
+
+            self._last_metrics_log_time = current_time
+
+        # Log aggregated stats less frequently (separate timer to avoid bug)
+        if (current_time - self._last_aggregated_log_time) >= self._aggregated_log_interval:
+            self.statistics.log_aggregated_stats()
+            self._last_aggregated_log_time = current_time
+
     @staticmethod
     def _normalize_video_codec(video_codec: Optional[str], h265_mode: str) -> str:
         """Normalize codec selection."""
         if not video_codec or str(video_codec).strip() == "":
             return "h264"
-        
+
         vc = str(video_codec).lower().strip()
         if vc in {"h264", "h265-frame", "h265-chunk"}:
             return vc