nedo-vision-worker-core 0.2.0__py3-none-any.whl

nedo_vision_worker_core/repositories/AIModelRepository.py

@@ -0,0 +1,31 @@
+import logging
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from ..database.DatabaseManager import DatabaseManager
+from ..models.ai_model import AIModelEntity
+
+class AIModelRepository:
+    """Handles storage of AI Models into SQLite using SQLAlchemy."""
+
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("default")
+
+    def get_models(self) -> list:
+        """
+        Retrieves all AI models from the database.
+
+        Returns:
+            list: A list of AIModelEntity objects.
+        """
+        try:
+            self.session.expire_all()
+            models = self.session.query(AIModelEntity).all()
+            
+            for model in models:
+                self.session.expunge(model)
+
+            return models
+        except SQLAlchemyError as e:
+            logging.error(f"Error retrieving models: {e}")
+            return []

nedo_vision_worker_core/repositories/PPEDetectionRepository.py

@@ -0,0 +1,146 @@
+import os
+import cv2
+import datetime
+import uuid
+import logging
+from pathlib import Path
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from ..database.DatabaseManager import DatabaseManager
+from ..models.ppe_detection import PPEDetectionEntity
+from ..models.ppe_detection_label import PPEDetectionLabelEntity
+from ..util.DrawingUtils import DrawingUtils
+
+class PPEDetectionRepository:
+    """Handles storage of PPE detections into SQLite using SQLAlchemy."""
+
+    def __init__(self):
+        
+        self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "ppe_detections"
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("default")
+        os.makedirs(self.storage_dir, exist_ok=True) 
+
+    def save_ppe_detection(self, pipeline_id, worker_source_id, frame_id, tracked_objects, frame, frame_drawer):
+        """
+        Inserts new detections only if at least one attribute's detection count is >= 5.
+
+        Args:
+            pipeline_id (str): Unique ID of the video pipeline.
+            worker_source_id (str): Source of the video stream.
+            frame_id (int): Frame number.
+            tracked_objects (list): List of detected persons and their attribute counts.
+            frame (numpy.ndarray): Image frame for saving snapshots.
+        """
+        current_datetime = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d_%H%M%S")  # Timestamp
+
+        for tracked_obj in tracked_objects:
+            person_id = tracked_obj["uuid"]
+            attributes = tracked_obj["attributes"]
+            valid_attributes = []
+
+            if not any(attr.get("count", 0) == 5 for attr in attributes):
+                continue  # Skip this detection
+
+            filtered_attributes = [attr for attr in attributes if attr.get("count", 0) >= 5]
+            
+            draw_obj = tracked_obj.copy()
+            draw_obj["attributes"] = filtered_attributes
+            
+            drawn_frame = frame_drawer.draw_frame(frame.copy(), [draw_obj])
+
+            # Save full frame image
+            full_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}.jpg"
+            full_image_path = os.path.join(self.storage_dir, full_image_filename)
+            cv2.imwrite(full_image_path, drawn_frame)
+
+            # Save cropped image with buffer
+            bbox = tracked_obj["bbox"]
+            cropped_image, obj = DrawingUtils.crop_with_bounding_box(frame, tracked_obj)
+            cropped_image = frame_drawer.draw_frame(cropped_image, [obj])
+
+            cropped_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}_cropped.jpg"
+            cropped_image_path = os.path.join(self.storage_dir, cropped_image_filename)
+            cv2.imwrite(cropped_image_path, cropped_image)
+
+            try:
+                new_detection = PPEDetectionEntity(
+                    id=str(uuid.uuid4()),
+                    worker_id=pipeline_id,
+                    worker_source_id=worker_source_id,
+                    person_id=person_id,
+                    image_path=full_image_path,
+                    image_tile_path=cropped_image_path,
+                    b_box_x1=bbox[0],
+                    b_box_y1=bbox[1],
+                    b_box_x2=bbox[2],
+                    b_box_y2=bbox[3],
+                    detection_count=tracked_obj.get("detections", 0)
+                )
+                self.session.add(new_detection)
+                self.session.flush()
+
+                for attr in filtered_attributes:
+                    label = attr["label"]
+                    valid_attributes.append(label)
+
+                    if attr and "bbox" in attr:
+                        attr_bbox = attr["bbox"]
+                        # Assuming attr_bbox is in [x, y, width, height] format.
+                        attr_b_box_x1 = attr_bbox[0]
+                        attr_b_box_y1 = attr_bbox[1]
+                        attr_b_box_x2 = attr_bbox[2]
+                        attr_b_box_y2 = attr_bbox[3]
+                    else:
+                        # Fallback to default values if the attribute bbox is not available.
+                        attr_b_box_x1 = 0.0
+                        attr_b_box_y1 = 0.0
+                        attr_b_box_x2 = 0.0
+                        attr_b_box_y2 = 0.0
+
+                    # Retrieve confidence score; default to 1.0 if not available.
+                    if attr:
+                        confidence_score = attr.get("confidence", 1.0)
+                    else:
+                        confidence_score = 1.0
+
+                    new_label = PPEDetectionLabelEntity(
+                        id=str(uuid.uuid4()),
+                        detection_id=new_detection.id,
+                        code=label,
+                        confidence_score=confidence_score,
+                        detection_count=attr.get("count", 0),
+                        b_box_x1=attr_b_box_x1,
+                        b_box_y1=attr_b_box_y1,
+                        b_box_x2=attr_b_box_x2,
+                        b_box_y2=attr_b_box_y2
+                    )
+                    self.session.add(new_label)
+
+                self.session.commit()
+                logging.info(f"✅ Inserted detection for Person {person_id}, Attributes: {valid_attributes}")
+
+                # Trigger detection callback
+                try:
+                    from ..core_service import CoreService
+                    detection_data = {
+                        'type': 'ppe_detection',
+                        'pipeline_id': pipeline_id,
+                        'worker_source_id': worker_source_id,
+                        'person_id': person_id,
+                        'detection_id': new_detection.id,
+                        'attributes': valid_attributes,
+                        'confidence_score': tracked_obj.get("confidence", 1.0),
+                        'bbox': bbox,
+                        'image_path': full_image_path,
+                        'image_tile_path': cropped_image_path,
+                        'timestamp': current_datetime
+                    }
+                    CoreService.trigger_detection_callback('ppe_detection', detection_data)
+                except Exception as e:
+                    logging.warning(f"⚠️ Failed to trigger PPE detection callback: {e}")
+
+            except SQLAlchemyError as e:
+                self.session.rollback()
+                logging.error(f"❌ Database error while saving detection: {e}")
+

nedo_vision_worker_core/repositories/RestrictedAreaRepository.py

@@ -0,0 +1,90 @@
+# repositories/restricted_area_repository.py
+
+import os
+import cv2
+import datetime
+import logging
+from pathlib import Path
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from ..models.restricted_area_violation import RestrictedAreaViolationEntity
+from ..database.DatabaseManager import DatabaseManager
+from ..util.DrawingUtils import DrawingUtils
+
+class RestrictedAreaRepository:
+    def __init__(self):
+        self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "restricted_violations"
+        os.makedirs(self.storage_dir, exist_ok=True)
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("default")
+
+    def save_area_violation(self, pipeline_id, worker_source_id, frame_id, tracked_objects, frame, frame_drawer):
+        """
+        Save restricted area violation event.
+        """
+        current_datetime = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d_%H%M%S")  # Timestamp
+
+        frame_drawer.draw_polygons(frame)
+
+        for tracked_obj in tracked_objects:
+            person_id = tracked_obj["uuid"]
+            attributes = tracked_obj["attributes"]
+
+            if not any((attr.get("label") == "in_restricted_area" and attr.get("count", 0) == 5) for attr in attributes):
+                continue
+
+            drawn_frame = frame_drawer.draw_frame(frame.copy(), [tracked_obj.copy()])
+
+            # Save full frame image
+            full_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}.jpg"
+            full_image_path = os.path.join(self.storage_dir, full_image_filename)
+            cv2.imwrite(full_image_path, drawn_frame)
+
+            # Save cropped image with buffer
+            bbox = tracked_obj["bbox"]
+            cropped_image, obj = DrawingUtils.crop_with_bounding_box(frame, tracked_obj)
+            cropped_image = frame_drawer.draw_frame(cropped_image, [obj])
+
+            cropped_image_filename = f"{pipeline_id}_{person_id}_{current_datetime}_cropped.jpg"
+            cropped_image_path = os.path.join(self.storage_dir, cropped_image_filename)
+            cv2.imwrite(cropped_image_path, cropped_image)
+
+            try:
+                new_detection = RestrictedAreaViolationEntity(
+                    worker_source_id=worker_source_id,
+                    person_id=person_id,
+                    image_path=full_image_path,
+                    image_tile_path=cropped_image_path,
+                    confidence_score=tracked_obj.get("confidence", 1),
+                    b_box_x1=bbox[0],
+                    b_box_y1=bbox[1],
+                    b_box_x2=bbox[2],
+                    b_box_y2=bbox[3],
+                )
+                self.session.add(new_detection)
+                self.session.flush()
+                self.session.commit()
+                logging.info(f"✅ Inserted restricted area violation for Person {person_id}")
+
+                # Trigger detection callback
+                try:
+                    from ..core_service import CoreService
+                    detection_data = {
+                        'type': 'area_violation',
+                        'pipeline_id': pipeline_id,
+                        'worker_source_id': worker_source_id,
+                        'person_id': person_id,
+                        'detection_id': new_detection.id if hasattr(new_detection, 'id') else None,
+                        'confidence_score': tracked_obj.get("confidence", 1.0),
+                        'bbox': bbox,
+                        'image_path': full_image_path,
+                        'image_tile_path': cropped_image_path,
+                        'timestamp': current_datetime
+                    }
+                    CoreService.trigger_detection_callback('area_violation', detection_data)
+                except Exception as e:
+                    logging.warning(f"⚠️ Failed to trigger area violation callback: {e}")
+
+            except SQLAlchemyError as e:
+                self.session.rollback()
+                logging.error(f"❌ Database error while saving detection: {e}")

nedo_vision_worker_core/repositories/WorkerSourcePipelineDebugRepository.py

@@ -0,0 +1,81 @@
+from datetime import datetime, timedelta, timezone
+import json
+import os
+import cv2
+import numpy as np
+from sqlalchemy.orm import Session
+from ..database.DatabaseManager import DatabaseManager
+from ..models.worker_source_pipeline_debug import WorkerSourcePipelineDebugEntity
+
+
+class WorkerSourcePipelineDebugRepository:
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("default")
+        self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "debug_image"
+        os.makedirs(self.storage_dir, exist_ok=True)
+
+    def get_pipeline_ids_to_debug(self):
+        """
+        Retrieve all distinct worker_source_pipeline_id values that need debugging.
+
+        :return: A list of pipeline IDs (str) with null data.
+        """
+        now = datetime.now(timezone.utc)
+        cutoff_time = now - timedelta(minutes=1)
+
+        self.session.query(WorkerSourcePipelineDebugEntity)\
+            .filter(
+                WorkerSourcePipelineDebugEntity.data == None,
+                WorkerSourcePipelineDebugEntity.created_at < cutoff_time
+            ).delete(synchronize_session=False)
+
+        self.session.commit()
+
+        results = self.session.query(
+            WorkerSourcePipelineDebugEntity.worker_source_pipeline_id
+        ).filter(
+            WorkerSourcePipelineDebugEntity.data == None
+        ).distinct().all()
+
+        return [row[0] for row in results]
+
+    def update_debug_entries_by_pipeline_id(self, pipeline_id: int, image, data: str):
+        """
+        Update all debug entries for a given pipeline ID with new data.
+
+        :param pipeline_id: The ID of the pipeline for which to update debug entries.
+        :param new_data: The new data to update the entries with.
+        :return: The number of updated entries.
+        """
+        now = datetime.now(timezone.utc)
+        current_datetime = now.strftime("%Y%m%d_%H%M%S")
+
+        stringified_data = json.dumps(
+            {
+                "timestamp": now.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "tracked_objects": data,
+            },
+            default=lambda o: (
+                float(o) if isinstance(o, np.floating) else
+                int(o) if isinstance(o, np.integer) else
+                list(o) if isinstance(o, (np.ndarray, tuple)) else
+                str(o)
+            )
+        ) 
+        
+        full_image_filename = f"{pipeline_id}_{current_datetime}.jpg"
+        full_image_path = os.path.join(self.storage_dir, full_image_filename)
+        cv2.imwrite(full_image_path, image)
+
+        updated_entries = self.session.query(WorkerSourcePipelineDebugEntity)\
+            .filter_by(worker_source_pipeline_id=pipeline_id)\
+            .update(
+                {
+                    "image_path": full_image_path,
+                    "data": stringified_data
+                },
+                synchronize_session="fetch"
+            )
+        self.session.commit()
+        return updated_entries

nedo_vision_worker_core/repositories/WorkerSourcePipelineDetectionRepository.py

@@ -0,0 +1,71 @@
+from datetime import datetime, timezone
+import json
+import os
+import cv2
+import numpy as np
+from sqlalchemy.orm import Session
+from ..ai.FrameDrawer import FrameDrawer
+from ..database.DatabaseManager import DatabaseManager
+from ..models.worker_source_pipeline_detection import WorkerSourcePipelineDetectionEntity
+
+
+class WorkerSourcePipelineDetectionRepository:
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("default")
+        self.storage_dir = DatabaseManager.STORAGE_PATHS["files"] / "detection_image"
+        os.makedirs(self.storage_dir, exist_ok=True)
+
+    def save_detection(self, pipeline_id: int, frame, tracked_objects, frame_drawer: FrameDrawer):
+        """
+        Save detection data that need to be sent to database.
+        """
+        now = datetime.now(timezone.utc)
+        current_datetime = now.strftime("%Y%m%d_%H%M%S")
+
+        frame_drawer.draw_polygons(frame)
+        filtered_objects = []
+
+        for tracked_obj in tracked_objects:
+            attributes = tracked_obj["attributes"]
+
+            if not any(attr.get("count", 0) == 5 for attr in attributes):
+                continue
+
+            obj = tracked_obj.copy()
+            obj["attributes"] = [attr for attr in attributes if attr.get("count", 0) >= 5]
+
+            filtered_objects.append(obj)
+
+        if not filtered_objects:
+            return
+
+        drawn_frame = frame_drawer.draw_frame(frame.copy(), filtered_objects)
+
+        full_image_filename = f"{pipeline_id}_{current_datetime}.jpg"
+        full_image_path = os.path.join(self.storage_dir, full_image_filename)
+        cv2.imwrite(full_image_path, drawn_frame)
+
+        stringified_data = json.dumps(filtered_objects,
+            default=lambda o: (
+                float(o) if isinstance(o, np.floating) else
+                int(o) if isinstance(o, np.integer) else
+                list(o) if isinstance(o, (np.ndarray, tuple)) else
+                str(o)
+            )
+        ) 
+
+        try:
+            new_detection = WorkerSourcePipelineDetectionEntity(
+                worker_source_pipeline_id=pipeline_id,
+                image_path=full_image_path,
+                data=stringified_data,
+                created_at=datetime.utcnow()
+            )
+            self.session.add(new_detection)
+            self.session.flush()
+            self.session.commit()
+            print(f"✅ Inserted detection data for pipeline {pipeline_id}")
+        except Exception as e:
+            self.session.rollback()
+            print(f"❌ Database error while saving detection: {e}")

nedo_vision_worker_core/repositories/WorkerSourcePipelineRepository.py

@@ -0,0 +1,79 @@
+import json
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import SQLAlchemyError
+from ..database.DatabaseManager import DatabaseManager
+from ..models.worker_source_pipeline import WorkerSourcePipelineEntity
+from ..models.worker_source_pipeline_config import WorkerSourcePipelineConfigEntity
+
+
+class WorkerSourcePipelineRepository:
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("config")
+
+    def get_all_pipelines(self):
+        """
+        Fetch all worker source pipelines from the local database in a single query.
+
+        Returns:
+            list: A list of WorkerSourcePipelineEntity records.
+        """
+        self.session.expire_all()
+        return self.session.query(WorkerSourcePipelineEntity).all()
+
+    def get_pipeline_configs_by_pipeline_id(self, pipeline_id):
+        """
+        Retrieves all pipeline configurations for a given pipeline ID and returns them as a dictionary.
+
+        The dictionary format:
+        {
+            "config_code_1": { "id": "xxx", "is_enabled": true, "value": "some_value", "name": "Config Name" },
+            "config_code_2": { "id": "yyy", "is_enabled": false, "value": "another_value", "name": "Another Config Name" }
+        }
+
+        Args:
+            pipeline_id (str): The unique identifier of the pipeline.
+
+        Returns:
+            dict: A dictionary mapping pipeline_config_code to its configuration details.
+        """
+        try:
+            pipeline_configs = (
+                self.session.query(WorkerSourcePipelineConfigEntity)
+                .filter(WorkerSourcePipelineConfigEntity.worker_source_pipeline_id == pipeline_id)
+                .all()
+            )
+
+            def parse_value(value):
+                """Attempts to parse the value as JSON if applicable."""
+                if not value:
+                    return value  # Keep None or empty string as is
+                
+                value = value.strip()  # Remove leading/trailing spaces
+                if (value.startswith("{") and value.endswith("}")) or (value.startswith("[") and value.endswith("]")):
+                    try:
+                        return json.loads(value)  # Parse JSON object or list
+                    except json.JSONDecodeError:
+                        pass  # Keep as string if parsing fails
+                return value  # Return original value if not JSON
+
+            # Convert result into a dictionary with pipeline_config_code as key
+            config_dict = {
+                config.pipeline_config_code: {
+                    "id": config.id,
+                    "is_enabled": config.is_enabled,  # Keep original boolean value
+                    "value": parse_value(config.value),  # Parse JSON if applicable
+                    "name": config.pipeline_config_name
+                }
+                for config in pipeline_configs
+            }
+
+            return config_dict
+
+        except SQLAlchemyError as e:
+            print(f"Database error while retrieving pipeline configs: {e}")
+            return {}
+        
+    def get_worker_source_pipeline(self, pipeline_id):
+        self.session.expire_all()
+        return self.session.query(WorkerSourcePipelineEntity).filter_by(id=pipeline_id).first()

nedo_vision_worker_core/repositories/WorkerSourceRepository.py

@@ -0,0 +1,19 @@
+from sqlalchemy.orm import Session
+from ..database.DatabaseManager import DatabaseManager
+from ..models.worker_source import WorkerSourceEntity
+
+
+class WorkerSourceRepository:
+    def __init__(self):
+        self.db_manager = DatabaseManager()
+        self.session: Session = self.db_manager.get_session("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.
+        """
+        self.session.expire_all()
+        return self.session.query(WorkerSourceEntity).all()

nedo_vision_worker_core/repositories/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/streams/RTMPStreamer.py

@@ -0,0 +1,146 @@
+import subprocess
+import logging
+import cv2
+import numpy as np
+import os
+
+class RTMPStreamer:
+    """Handles streaming video frames to an RTMP server using FFmpeg."""
+
+    def __init__(self, pipeline_id, fps=25, bitrate="1500k"):
+        """
+        Initializes the RTMP streaming process.
+
+        :param pipeline_id: Unique identifier for the stream (used as the stream key).
+        :param fps: Frames per second.
+        :param bitrate: Bitrate for video encoding.
+        """
+        self.rtmp_server = os.environ.get("RTMP_SERVER", "rtmp://localhost:1935/live")
+        self.rtmp_url = f"{self.rtmp_server}/{pipeline_id}"  # RTMP URL with dynamic stream key
+        self.fps = fps
+        self.bitrate = bitrate
+        self.width = None
+        self.height = None
+        self.ffmpeg_process = None
+        self.started = False  # Ensure FFmpeg starts only once
+        self.active = False  # Add status flag
+
+    def _calculate_resolution(self, frame):
+        """Determines resolution with max width 1024 while maintaining aspect ratio."""
+        original_height, original_width = frame.shape[:2]
+        if original_width > 1024:
+            scale_factor = 1024 / original_width
+            new_width = 1024
+            new_height = int(original_height * scale_factor)
+        else:
+            new_width, new_height = original_width, original_height
+
+        logging.info(f"📏 Adjusted resolution: {new_width}x{new_height} (Original: {original_width}x{original_height})")
+        return new_width, new_height
+
+    def is_active(self):
+        """Check if the RTMP streamer is active and ready to send frames."""
+        return self.active and self.ffmpeg_process and self.ffmpeg_process.poll() is None
+
+    def _start_ffmpeg_stream(self):
+        """Starts an FFmpeg process to stream frames to the RTMP server silently."""
+        ffmpeg_command = [
+            "ffmpeg",
+            "-y",
+            "-loglevel", "panic",  # 🔇 Suppress all output except fatal errors
+            "-nostats",             # 🔇 Hide encoding progress updates
+            "-hide_banner",         # 🔇 Hide FFmpeg banner information
+            "-f", "rawvideo",
+            "-pixel_format", "bgr24",
+            "-video_size", f"{self.width}x{self.height}",
+            "-framerate", str(self.fps),
+            "-i", "-",
+            "-c:v", "libx264",
+            "-preset", "ultrafast",
+            "-tune", "zerolatency",
+            "-b:v", self.bitrate,
+            # ❌ Disable Audio (Avoid unnecessary encoding overhead)
+            "-an",
+            "-maxrate", "2000k",
+            "-bufsize", "4000k",
+            "-f", "flv",
+            self.rtmp_url,
+        ]
+
+        try:
+            with open(os.devnull, "w") as devnull:
+                self.ffmpeg_process = subprocess.Popen(
+                    ffmpeg_command,
+                    stdin=subprocess.PIPE,
+                    stdout=devnull,
+                    stderr=devnull
+                )
+            logging.info(f"📡 RTMP streaming started: {self.rtmp_url} ({self.width}x{self.height})")
+            self.started = True
+            self.active = True
+        except Exception as e:
+            logging.error(f"❌ Failed to start FFmpeg: {e}")
+            self.ffmpeg_process = None
+            self.active = False
+
+    def send_frame(self, frame):
+        """Sends a video frame to the RTMP stream with dynamic resolution."""
+        if frame is None or not isinstance(frame, np.ndarray):
+            logging.error("❌ Invalid frame received")
+            return
+
+        try:
+            # Validate frame before processing
+            if frame.size == 0 or not frame.data:
+                logging.error("❌ Empty frame detected")
+                return
+
+            # Set resolution on the first frame
+            if not self.started:
+                self.width, self.height = self._calculate_resolution(frame)
+                self._start_ffmpeg_stream()
+
+            if self.is_active():
+                # Create a copy of the frame to prevent reference issues
+                frame_copy = frame.copy()
+                
+                # Resize only if necessary
+                if frame_copy.shape[1] > 1024:
+                    frame_copy = cv2.resize(frame_copy, (self.width, self.height), 
+                                         interpolation=cv2.INTER_AREA)
+
+                # Additional frame validation
+                if frame_copy.size == 0 or not frame_copy.data:
+                    logging.error("❌ Frame became invalid after processing")
+                    return
+
+                if self.ffmpeg_process and self.ffmpeg_process.stdin:
+                    self.ffmpeg_process.stdin.write(frame_copy.tobytes())
+                    self.ffmpeg_process.stdin.flush()  # Ensure data is written
+
+        except BrokenPipeError:
+            logging.error("❌ RTMP connection broken")
+            self.stop_stream()
+        except Exception as e:
+            logging.error(f"❌ Failed to send frame to RTMP: {e}")
+            self.stop_stream()
+
+    def stop_stream(self):
+        """Stops the FFmpeg streaming process."""
+        self.active = False
+        if self.ffmpeg_process:
+            try:
+                if self.ffmpeg_process.stdin:
+                    self.ffmpeg_process.stdin.close()
+                self.ffmpeg_process.terminate()
+                self.ffmpeg_process.wait(timeout=5)
+            except Exception as e:
+                logging.error(f"❌ Error stopping RTMP stream: {e}")
+                # Force kill if normal termination fails
+                try:
+                    self.ffmpeg_process.kill()
+                except Exception:
+                    pass
+            finally:
+                self.ffmpeg_process = None
+                logging.info("✅ RTMP streaming process stopped.")