matrice-streaming 0.1.58__tar.gz → 0.1.59__tar.gz

{matrice_streaming-0.1.58 → matrice_streaming-0.1.59}/PKG-INFO

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

{matrice_streaming-0.1.58 → matrice_streaming-0.1.59}/matrice_streaming.egg-info/PKG-INFO

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

{matrice_streaming-0.1.58 → matrice_streaming-0.1.59}/src/matrice_streaming/streaming_gateway/camera_streamer/async_ffmpeg_worker.py

@@ -20,6 +20,8 @@ import numpy as np
 import cv2
 import psutil
 
+from matrice_common.optimize import FrameOptimizer
+
 from .ffmpeg_config import FFmpegConfig, is_ffmpeg_available
 from .ffmpeg_camera_streamer import FFmpegPipeline
 
@@ -83,6 +85,9 @@ class AsyncFFmpegWorker:
         # Performance options
         pin_cpu_affinity: bool = True,
         total_workers: int = 1,
+        # Frame optimizer options
+        frame_optimizer_enabled: bool = True,
+        frame_optimizer_config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize async FFmpeg worker.
 
@@ -100,6 +105,8 @@ class AsyncFFmpegWorker:
             shm_frame_format: Frame format for SHM storage
             pin_cpu_affinity: Pin worker to specific CPU cores
             total_workers: Total number of workers for CPU affinity calculation
+            frame_optimizer_enabled: Enable frame optimizer for skipping similar frames
+            frame_optimizer_config: Frame optimizer configuration dict
         """
         self.worker_id = worker_id
         self.camera_configs = camera_configs
@@ -128,6 +135,17 @@ class AsyncFFmpegWorker:
         self._shm_buffers: Dict[str, Any] = {}
         self._last_shm_frame_idx: Dict[str, int] = {}
 
+        # Initialize frame optimizer for skipping similar frames
+        frame_optimizer_config = frame_optimizer_config or {}
+        self.frame_optimizer = FrameOptimizer(
+            enabled=frame_optimizer_enabled,
+            scale=frame_optimizer_config.get("scale", 0.4),
+            diff_threshold=frame_optimizer_config.get("diff_threshold", 15),
+            similarity_threshold=frame_optimizer_config.get("similarity_threshold", 0.05),
+            bg_update_interval=frame_optimizer_config.get("bg_update_interval", 10),
+        )
+        self._last_sent_frame_ids: Dict[str, str] = {}  # stream_key -> last sent frame_id
+
         # Register atexit handler for SHM cleanup
         if use_shm:
             import atexit
@@ -455,7 +473,47 @@ class AsyncFFmpegWorker:
         """
         frame_start = time.time()
 
-        # Encode to JPEG
+        # 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)
+
+        import uuid
+
+        if is_similar and reference_frame_id:
+            # Frame is similar - send message with empty content + cached_frame_id
+            message = {
+                "frame_id": str(uuid.uuid4()),
+                "input_name": stream_key,
+                "input_stream": {
+                    "content": b"",  # EMPTY content for cached frame
+                    "metadata": {
+                        "width": width,
+                        "height": height,
+                        "frame_count": frame_counter,
+                        "camera_location": camera_location,
+                        "stream_group_key": stream_group_key,
+                        "encoding_type": "cached",
+                        "codec": "cached",
+                        "feed_type": "ffmpeg",
+                        "timestamp": time.time(),
+                        "similarity_score": similarity_score,
+                        "cached_frame_id": reference_frame_id,
+                    },
+                },
+            }
+
+            # Send to Redis
+            write_start = time.time()
+            await self.redis_client.add_message(topic, message)
+            write_time = time.time() - write_start
+
+            # Track metrics (no encoding)
+            self._frames_per_camera[stream_key] = self._frames_per_camera.get(stream_key, 0) + 1
+            total_time = time.time() - frame_start
+            self._frame_times.append(total_time)
+            return
+
+        # Frame is different - encode and send full frame
         encode_start = time.time()
         success, jpeg_buffer = cv2.imencode(
             '.jpg', frame, [int(cv2.IMWRITE_JPEG_QUALITY), quality]
@@ -473,9 +531,9 @@ class AsyncFFmpegWorker:
         frame_data = bytes(jpeg_buffer)
 
         # Build message
-        import uuid
+        new_frame_id = str(uuid.uuid4())
         message = {
-            "frame_id": str(uuid.uuid4()),
+            "frame_id": new_frame_id,
             "input_name": stream_key,
             "input_stream": {
                 "content": frame_data,
@@ -498,6 +556,10 @@ class AsyncFFmpegWorker:
         await self.redis_client.add_message(topic, message)
         write_time = time.time() - write_start
 
+        # Track this frame_id as the last sent for future reference frames
+        self._last_sent_frame_ids[stream_key] = new_frame_id
+        self.frame_optimizer.set_last_frame_id(stream_key, new_frame_id)
+
         # Track metrics
         total_time = time.time() - frame_start
         self._frame_times.append(total_time)
@@ -529,6 +591,40 @@ class AsyncFFmpegWorker:
         """
         frame_start = time.time()
 
+        # Check frame similarity BEFORE writing to SHM (saves SHM writes for static scenes)
+        is_similar, similarity_score = self.frame_optimizer.is_similar(frame, stream_key)
+        reference_frame_idx = self._last_shm_frame_idx.get(stream_key)
+
+        if is_similar and reference_frame_idx is not None:
+            # Frame is similar - send metadata with reference to previous frame
+            ts_ns = int(time.time() * 1e9)
+            shm_buffer = self._shm_buffers.get(stream_key)
+
+            await self.redis_client.add_shm_metadata(
+                stream_name=topic,
+                cam_id=stream_key,
+                shm_name=shm_buffer.shm_name if shm_buffer else "",
+                frame_idx=reference_frame_idx,  # Reference to cached frame
+                slot=None,  # No new slot written
+                ts_ns=ts_ns,
+                width=width,
+                height=height,
+                format=self.shm_frame_format,
+                is_similar=True,
+                reference_frame_idx=reference_frame_idx,
+                similarity_score=similarity_score,
+                stream_group_key=stream_group_key,
+                camera_location=camera_location,
+                frame_counter=frame_counter,
+            )
+
+            # Track metrics (no SHM write)
+            self._frames_per_camera[stream_key] = self._frames_per_camera.get(stream_key, 0) + 1
+            total_time = time.time() - frame_start
+            self._frame_times.append(total_time)
+            return
+
+        # Frame is different - write to SHM
         # Get or create SHM buffer
         shm_buffer = self._get_or_create_shm_buffer(stream_key, width, height)
 
@@ -809,6 +905,8 @@ def run_ffmpeg_worker(
     shm_frame_format: str = "BGR",
     pin_cpu_affinity: bool = True,
     total_workers: int = 1,
+    frame_optimizer_enabled: bool = True,
+    frame_optimizer_config: Optional[Dict[str, Any]] = None,
 ):
     """Entry point for FFmpeg worker process.
 
@@ -826,6 +924,8 @@ def run_ffmpeg_worker(
         shm_frame_format: Frame format for SHM storage
         pin_cpu_affinity: Pin worker to specific CPU cores
         total_workers: Total number of workers
+        frame_optimizer_enabled: Enable frame optimizer
+        frame_optimizer_config: Frame optimizer configuration dict
     """
     logging.basicConfig(
         level=logging.INFO,
@@ -855,6 +955,8 @@ def run_ffmpeg_worker(
             shm_frame_format=shm_frame_format,
             pin_cpu_affinity=pin_cpu_affinity,
             total_workers=total_workers,
+            frame_optimizer_enabled=frame_optimizer_enabled,
+            frame_optimizer_config=frame_optimizer_config,
         )
 
         asyncio.run(worker.run())

{matrice_streaming-0.1.58 → matrice_streaming-0.1.59}/src/matrice_streaming/streaming_gateway/camera_streamer/ffmpeg_camera_streamer.py

@@ -23,6 +23,10 @@ from collections import deque
 
 import numpy as np
 import cv2
+import psutil
+
+from matrice_common.optimize import FrameOptimizer
+from matrice_common.stream.shm_ring_buffer import ShmRingBuffer
 
 from .ffmpeg_config import FFmpegConfig, is_ffmpeg_available, detect_hwaccel
 
@@ -306,6 +310,16 @@ class FFmpegCameraStreamer:
         video_codec: Optional[str] = None,
         gateway_util=None,
         ffmpeg_config: Optional[FFmpegConfig] = None,
+        # SHM mode options
+        use_shm: bool = False,
+        shm_slot_count: int = 300,
+        shm_frame_format: str = "BGR",
+        # Frame optimizer options
+        frame_optimizer_enabled: bool = True,
+        frame_optimizer_config: Optional[Dict[str, Any]] = None,
+        # CPU affinity options
+        pin_cpu_affinity: bool = False,
+        cpu_affinity_core: Optional[int] = None,
     ):
         """Initialize FFmpeg camera streamer.
 
@@ -316,6 +330,13 @@ class FFmpegCameraStreamer:
             video_codec: Video codec (h264 or h265)
             gateway_util: Gateway utility for API interactions
             ffmpeg_config: FFmpeg configuration
+            use_shm: Enable SHM mode for raw frame sharing
+            shm_slot_count: Number of frame slots per camera ring buffer
+            shm_frame_format: Frame format for SHM storage ("BGR", "RGB", or "NV12")
+            frame_optimizer_enabled: Enable frame optimizer for skipping similar frames
+            frame_optimizer_config: Frame optimizer configuration dict
+            pin_cpu_affinity: Pin process to specific CPU core
+            cpu_affinity_core: CPU core to pin to (None = auto-assign)
         """
         self.session = session
         self.service_id = service_id
@@ -355,12 +376,136 @@ class FFmpegCameraStreamer:
         # MatriceStream client
         self.stream_client = None
 
+        # ================================================================
+        # SHM Mode Configuration
+        # ================================================================
+        self.use_shm = use_shm
+        self.shm_slot_count = shm_slot_count
+        self.shm_frame_format = shm_frame_format
+        self._shm_buffers: Dict[str, ShmRingBuffer] = {}
+        self._last_shm_frame_idx: Dict[str, int] = {}
+
+        # Register signal handlers for SHM cleanup
+        if use_shm:
+            self._setup_signal_handlers()
+            self.logger.info(
+                f"SHM mode ENABLED: format={shm_frame_format}, slots={shm_slot_count}"
+            )
+
+        # ================================================================
+        # Frame Optimizer Configuration
+        # ================================================================
+        frame_optimizer_config = frame_optimizer_config or {}
+        self.frame_optimizer = FrameOptimizer(
+            enabled=frame_optimizer_enabled,
+            scale=frame_optimizer_config.get("scale", 0.4),
+            diff_threshold=frame_optimizer_config.get("diff_threshold", 15),
+            similarity_threshold=frame_optimizer_config.get("similarity_threshold", 0.05),
+            bg_update_interval=frame_optimizer_config.get("bg_update_interval", 10),
+        )
+        self._last_sent_frame_ids: Dict[str, str] = {}
+
+        # ================================================================
+        # CPU Affinity Configuration
+        # ================================================================
+        self.pin_cpu_affinity = pin_cpu_affinity
+        self.cpu_affinity_core = cpu_affinity_core
+        self.pinned_cores: Optional[List[int]] = None
+
+        if pin_cpu_affinity:
+            self._apply_cpu_affinity()
+
         self.logger.info(
             f"FFmpegCameraStreamer initialized: "
             f"hwaccel={self.ffmpeg_config.hwaccel}, "
-            f"pixel_format={self.ffmpeg_config.pixel_format}"
+            f"pixel_format={self.ffmpeg_config.pixel_format}, "
+            f"shm={use_shm}, optimizer={frame_optimizer_enabled}"
         )
 
+    def _setup_signal_handlers(self):
+        """Setup signal handlers for graceful SHM cleanup on termination."""
+        def cleanup_handler(signum, frame):
+            """Handle SIGTERM/SIGINT for graceful SHM cleanup."""
+            sig_name = signal.Signals(signum).name if hasattr(signal.Signals, 'name') else str(signum)
+            self.logger.info(f"Received {sig_name}, cleaning up SHM buffers...")
+            self._cleanup_shm_buffers()
+            # Re-raise the signal to allow normal termination
+            signal.signal(signum, signal.SIG_DFL)
+            os.kill(os.getpid(), signum)
+
+        # Register signal handlers
+        signal.signal(signal.SIGINT, cleanup_handler)
+        if sys.platform != 'win32':
+            signal.signal(signal.SIGTERM, cleanup_handler)
+
+        # Also register atexit handler
+        import atexit
+        atexit.register(self._cleanup_shm_buffers)
+
+    def _cleanup_shm_buffers(self):
+        """Cleanup all SHM buffers."""
+        for camera_id, shm_buffer in list(self._shm_buffers.items()):
+            try:
+                shm_buffer.close()
+                self.logger.info(f"Closed SHM buffer for {camera_id}")
+            except Exception as e:
+                self.logger.warning(f"Failed to cleanup SHM {camera_id}: {e}")
+        self._shm_buffers.clear()
+
+    def _apply_cpu_affinity(self):
+        """Apply CPU affinity pinning."""
+        try:
+            p = psutil.Process()
+            if self.cpu_affinity_core is not None:
+                # Pin to specific core
+                self.pinned_cores = [self.cpu_affinity_core]
+            else:
+                # Auto-assign to first available core
+                cpu_count = psutil.cpu_count(logical=True)
+                self.pinned_cores = [0] if cpu_count > 0 else None
+
+            if self.pinned_cores:
+                p.cpu_affinity(self.pinned_cores)
+                self.logger.info(f"CPU affinity pinned to cores: {self.pinned_cores}")
+        except Exception as e:
+            self.logger.warning(f"Failed to set CPU affinity: {e}")
+            self.pinned_cores = None
+
+    def _get_or_create_shm_buffer(
+        self, stream_key: str, width: int, height: int
+    ) -> ShmRingBuffer:
+        """Get existing or create new SHM buffer for stream.
+
+        Args:
+            stream_key: Stream identifier
+            width: Frame width
+            height: Frame height
+
+        Returns:
+            ShmRingBuffer instance for this stream
+        """
+        if stream_key not in self._shm_buffers:
+            format_map = {
+                "BGR": ShmRingBuffer.FORMAT_BGR,
+                "RGB": ShmRingBuffer.FORMAT_RGB,
+                "NV12": ShmRingBuffer.FORMAT_NV12,
+            }
+            frame_format = format_map.get(self.shm_frame_format, ShmRingBuffer.FORMAT_BGR)
+
+            self._shm_buffers[stream_key] = ShmRingBuffer(
+                camera_id=stream_key,
+                width=width,
+                height=height,
+                frame_format=frame_format,
+                slot_count=self.shm_slot_count,
+                create=True,
+            )
+            self.logger.info(
+                f"Created SHM buffer for {stream_key}: "
+                f"{width}x{height} {self.shm_frame_format}, {self.shm_slot_count} slots"
+            )
+        return self._shm_buffers[stream_key]
+
     def register_stream_topic(self, stream_key: str, topic: str):
         """Register a topic for a stream.
 
@@ -538,39 +683,32 @@ class FFmpegCameraStreamer:
 
                 frame_counter += 1
 
-                # Encode to JPEG
-                encode_start = time.time()
-                success, jpeg_buffer = cv2.imencode(
-                    '.jpg', frame, [int(cv2.IMWRITE_JPEG_QUALITY), quality]
-                )
-                encode_time = time.time() - encode_start
-
-                if not success:
-                    self.logger.warning(f"JPEG encode failed for {stream_key}")
-                    continue
-
-                frame_data = bytes(jpeg_buffer)
-
-                # Send to stream backend
-                if self.stream_client:
-                    try:
-                        message = self._build_message(
-                            frame_data=frame_data,
-                            stream_key=stream_key,
-                            stream_group_key=stream_group_key,
-                            width=pipeline.width,
-                            height=pipeline.height,
-                            frame_counter=frame_counter,
-                            camera_location=camera_location,
-                        )
-                        self.stream_client.add_message(topic, message, key=stream_key)
-
-                        # Update stats
-                        self._transmission_stats["total_frames"] += 1
-                        self._transmission_stats["total_bytes"] += len(frame_data)
-
-                    except Exception as e:
-                        self.logger.error(f"Failed to send frame: {e}")
+                # ================================================================
+                # SHM Mode vs JPEG Mode
+                # ================================================================
+                if self.use_shm:
+                    self._process_frame_shm_mode(
+                        frame=frame,
+                        stream_key=stream_key,
+                        stream_group_key=stream_group_key,
+                        topic=topic,
+                        width=pipeline.width,
+                        height=pipeline.height,
+                        frame_counter=frame_counter,
+                        camera_location=camera_location,
+                    )
+                else:
+                    self._process_frame_jpeg_mode(
+                        frame=frame,
+                        stream_key=stream_key,
+                        stream_group_key=stream_group_key,
+                        topic=topic,
+                        width=pipeline.width,
+                        height=pipeline.height,
+                        quality=quality,
+                        frame_counter=frame_counter,
+                        camera_location=camera_location,
+                    )
 
                 # Maintain target FPS
                 elapsed = time.time() - loop_start
@@ -584,6 +722,206 @@ class FFmpegCameraStreamer:
 
         self.logger.info(f"Stream loop stopped for {stream_key}")
 
+    def _process_frame_jpeg_mode(
+        self,
+        frame: np.ndarray,
+        stream_key: str,
+        stream_group_key: str,
+        topic: str,
+        width: int,
+        height: int,
+        quality: int,
+        frame_counter: int,
+        camera_location: str,
+    ):
+        """Process frame in JPEG mode with frame optimizer.
+
+        Args:
+            frame: Raw frame from FFmpeg
+            stream_key: Stream identifier
+            stream_group_key: Stream group identifier
+            topic: Topic name
+            width: Frame width
+            height: Frame height
+            quality: JPEG quality
+            frame_counter: Current frame number
+            camera_location: Camera location
+        """
+        # Check frame similarity BEFORE encoding
+        is_similar, similarity_score = self.frame_optimizer.is_similar(frame, stream_key)
+        reference_frame_id = self._last_sent_frame_ids.get(stream_key)
+
+        import uuid
+
+        if is_similar and reference_frame_id:
+            # Frame is similar - send cached reference
+            message = {
+                "frame_id": str(uuid.uuid4()),
+                "input_name": stream_key,
+                "input_stream": {
+                    "content": b"",  # Empty for cached frame
+                    "metadata": {
+                        "width": width,
+                        "height": height,
+                        "frame_count": frame_counter,
+                        "camera_location": camera_location,
+                        "stream_group_key": stream_group_key,
+                        "encoding_type": "cached",
+                        "codec": "cached",
+                        "timestamp": time.time(),
+                        "similarity_score": similarity_score,
+                        "cached_frame_id": reference_frame_id,
+                    },
+                },
+            }
+
+            if self.stream_client:
+                try:
+                    self.stream_client.add_message(topic, message, key=stream_key)
+                    self._transmission_stats["total_frames"] += 1
+                except Exception as e:
+                    self.logger.error(f"Failed to send cached frame: {e}")
+            return
+
+        # Frame is different - encode and send full frame
+        success, jpeg_buffer = cv2.imencode(
+            '.jpg', frame, [int(cv2.IMWRITE_JPEG_QUALITY), quality]
+        )
+
+        if not success:
+            self.logger.warning(f"JPEG encode failed for {stream_key}")
+            return
+
+        frame_data = bytes(jpeg_buffer)
+
+        # Build and send message
+        new_frame_id = str(uuid.uuid4())
+        message = {
+            "frame_id": new_frame_id,
+            "input_name": stream_key,
+            "input_stream": {
+                "content": frame_data,
+                "metadata": {
+                    "width": width,
+                    "height": height,
+                    "frame_count": frame_counter,
+                    "camera_location": camera_location,
+                    "stream_group_key": stream_group_key,
+                    "encoding_type": "jpeg",
+                    "codec": "h264",
+                    "timestamp": time.time(),
+                },
+            },
+        }
+
+        if self.stream_client:
+            try:
+                self.stream_client.add_message(topic, message, key=stream_key)
+                self._transmission_stats["total_frames"] += 1
+                self._transmission_stats["total_bytes"] += len(frame_data)
+
+                # Track this frame_id for future references
+                self._last_sent_frame_ids[stream_key] = new_frame_id
+                self.frame_optimizer.set_last_frame_id(stream_key, new_frame_id)
+            except Exception as e:
+                self.logger.error(f"Failed to send frame: {e}")
+
+    def _process_frame_shm_mode(
+        self,
+        frame: np.ndarray,
+        stream_key: str,
+        stream_group_key: str,
+        topic: str,
+        width: int,
+        height: int,
+        frame_counter: int,
+        camera_location: str,
+    ):
+        """Process frame in SHM mode - write raw frame to SHM, metadata to Redis.
+
+        Args:
+            frame: Raw frame from FFmpeg (BGR format)
+            stream_key: Stream identifier
+            stream_group_key: Stream group identifier
+            topic: Topic name
+            width: Frame width
+            height: Frame height
+            frame_counter: Current frame number
+            camera_location: Camera location
+        """
+        # Check frame similarity BEFORE writing to SHM
+        is_similar, similarity_score = self.frame_optimizer.is_similar(frame, stream_key)
+        reference_frame_idx = self._last_shm_frame_idx.get(stream_key)
+
+        if is_similar and reference_frame_idx is not None:
+            # Frame is similar - send metadata with reference to previous frame
+            ts_ns = int(time.time() * 1e9)
+            shm_buffer = self._shm_buffers.get(stream_key)
+
+            if self.stream_client:
+                try:
+                    self.stream_client.add_shm_metadata(
+                        stream_name=topic,
+                        cam_id=stream_key,
+                        shm_name=shm_buffer.shm_name if shm_buffer else "",
+                        frame_idx=reference_frame_idx,
+                        slot=None,
+                        ts_ns=ts_ns,
+                        width=width,
+                        height=height,
+                        format=self.shm_frame_format,
+                        is_similar=True,
+                        reference_frame_idx=reference_frame_idx,
+                        similarity_score=similarity_score,
+                        stream_group_key=stream_group_key,
+                        camera_location=camera_location,
+                        frame_counter=frame_counter,
+                    )
+                    self._transmission_stats["total_frames"] += 1
+                except Exception as e:
+                    self.logger.error(f"Failed to send SHM metadata: {e}")
+            return
+
+        # Frame is different - write to SHM
+        shm_buffer = self._get_or_create_shm_buffer(stream_key, width, height)
+
+        # Convert frame to target format
+        if self.shm_frame_format == "RGB":
+            raw_bytes = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB).tobytes()
+        elif self.shm_frame_format == "NV12":
+            from matrice_common.stream.shm_ring_buffer import bgr_to_nv12
+            raw_bytes = bgr_to_nv12(frame)
+        else:  # BGR default
+            raw_bytes = frame.tobytes()
+
+        # Write to SHM ring buffer
+        frame_idx, slot = shm_buffer.write_frame(raw_bytes)
+        self._last_shm_frame_idx[stream_key] = frame_idx
+
+        # Send metadata to stream backend
+        ts_ns = int(time.time() * 1e9)
+        if self.stream_client:
+            try:
+                self.stream_client.add_shm_metadata(
+                    stream_name=topic,
+                    cam_id=stream_key,
+                    shm_name=shm_buffer.shm_name,
+                    frame_idx=frame_idx,
+                    slot=slot,
+                    ts_ns=ts_ns,
+                    width=width,
+                    height=height,
+                    format=self.shm_frame_format,
+                    is_similar=False,
+                    stream_group_key=stream_group_key,
+                    camera_location=camera_location,
+                    frame_counter=frame_counter,
+                )
+                self._transmission_stats["total_frames"] += 1
+                self._transmission_stats["total_bytes"] += len(raw_bytes)
+            except Exception as e:
+                self.logger.error(f"Failed to send SHM metadata: {e}")
+
     def _build_message(
         self,
         frame_data: bytes,
@@ -641,6 +979,15 @@ class FFmpegCameraStreamer:
                     self.pipelines[stream_key].close()
                     del self.pipelines[stream_key]
                     self.logger.info(f"Stopped stream: {stream_key}")
+
+                # Cleanup SHM buffer for this stream
+                if stream_key in self._shm_buffers:
+                    try:
+                        self._shm_buffers[stream_key].close()
+                        del self._shm_buffers[stream_key]
+                        self.logger.info(f"Closed SHM buffer for {stream_key}")
+                    except Exception as e:
+                        self.logger.warning(f"Failed to close SHM buffer {stream_key}: {e}")
             else:
                 # Stop all streams
                 self._stop_streaming = True
@@ -657,6 +1004,11 @@ class FFmpegCameraStreamer:
                         thread.join(timeout=5.0)
 
                 self.streaming_threads.clear()
+
+                # Cleanup all SHM buffers
+                if self.use_shm:
+                    self._cleanup_shm_buffers()
+
                 self.logger.info("All FFmpeg streams stopped")
 
     def get_transmission_stats(self) -> Dict[str, Any]: