import os # --- Global Configuration --- RECORDING_OUTPUT_DIR = "./recordings" RECORDING_FPS = 20 # Frames per second for recording RECORDING_CODEC = "mp4v" # Codec for output video (e.g., 'XVID', 'mp4v') RECORDING_DURATION_AFTER_MOTION = 10 # seconds to record after motion stops # Storage Management MAX_STORAGE_GB = 10 # Maximum storage in GB for recordings. Set to 0 for unlimited. CLEANUP_INTERVAL_HOURS = 24 # How often to check storage usage (in hours) # --- Camera Configurations --- # Add multiple cameras here as dictionaries in the list CAMERAS = [ { "id": "cam1", # Unique identifier for the camera "name": "Front Door Camera", "rtsp_url": "rtsp://your_camera_ip_1/stream", # <-- REPLACE THIS "motion_detection": { "enabled": True, "min_area": 500, # Minimum contour area "blur_size": (21, 21), "threshold_delta": 25 }, "recording": { "enabled": True, # Specific recording settings for this camera can override global ones if needed # "fps": 25, # "codec": "mp4v", # "duration_after_motion": 15 } }, # Example for a second camera: # { # "id": "cam2", # "name": "Backyard Camera", # "rtsp_url": "rtsp://your_camera_ip_2/stream", # <-- REPLACE THIS # "motion_detection": { # "enabled": True, # "min_area": 700, # "blur_size": (25, 25), # "threshold_delta": 30 # }, # "recording": { # "enabled": True, # } # }, # Add more cameras as needed ] # --- Validation --- if not CAMERAS: print("ERROR: No cameras configured in config.py. Please add at least one camera.") exit() # Check if default RTSP URL is still present for camera in CAMERAS: if camera["rtsp_url"] == "rtsp://your_camera_ip_1/stream" or camera["rtsp_url"] == "rtsp://your_camera_ip_2/stream": print(f"WARNING: Please replace the default RTSP URL for camera '{camera['name']}' (id: {camera['id']}) in config.py.") # Ensure recording directory exists os.makedirs(RECORDING_OUTPUT_DIR, exist_ok=True) import cv2 import numpy as np import time import os import threading import logging # Import configuration import config # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # --- NVR Logic --- class NVRCore: def __init__(self, camera_config, frame_callback, status_callback, stop_event): """ Initializes the NVR core for a single camera. Args: camera_config (dict): Configuration dictionary for this camera. frame_callback (function): A function to call with the latest frame (bytes). status_callback (function): A function to call with status updates (dict). stop_event (threading.Event): An event to signal the thread to stop. """ self.camera_config = camera_config self.camera_id = camera_config["id"] self.camera_name = camera_config.get("name", self.camera_id) self.rtsp_url = camera_config["rtsp_url"] self.frame_callback = frame_callback self.status_callback = status_callback self.stop_event = stop_event self.cap = None self.fgbg = None self.out = None self.is_recording = False self.motion_start_time = None self._reconnect_attempts = 0 self._max_reconnect_attempts = 10 # Increased attempts self._reconnect_delay = 5 # seconds # Get motion detection settings self.motion_enabled = camera_config.get("motion_detection", {}).get("enabled", True) self.min_area = camera_config.get("motion_detection", {}).get("min_area", config.MIN_AREA) self.blur_size = camera_config.get("motion_detection", {}).get("blur_size", config.BLUR_SIZE) self.threshold_delta = camera_config.get("motion_detection", {}).get("threshold_delta", config.THRESHOLD_DELTA) # Get recording settings (override global if specified per camera) self.recording_enabled = camera_config.get("recording", {}).get("enabled", config.RECORDING_ENABLED) self.recording_fps = camera_config.get("recording", {}).get("fps", config.RECORDING_FPS) self.recording_codec = camera_config.get("recording", {}).get("codec", config.RECORDING_CODEC) self.recording_duration_after_motion = camera_config.get("recording", {}).get("duration_after_motion", config.RECORDING_DURATION_AFTER_MOTION) if self.recording_enabled: os.makedirs(config.RECORDING_OUTPUT_DIR, exist_ok=True) self._update_status("initialized") def _update_status(self, status, details=None): """Helper to send status updates via the callback.""" self.status_callback(self.camera_id, {"status": status, "details": details, "is_recording": self.is_recording}) def _connect_stream(self): """Attempts to connect to the video stream.""" logger.info(f"{self.camera_name}: Attempting to connect to {self.rtsp_url} (Attempt {self._reconnect_attempts + 1}/{self._max_reconnect_attempts})") self._update_status("connecting", f"Attempt {self._reconnect_attempts + 1}") self.cap = cv2.VideoCapture(self.rtsp_url) if self.cap.isOpened(): logger.info(f"{self.camera_name}: Successfully connected to stream.") self._reconnect_attempts = 0 # Reset attempts on success self._update_status("connected") return True else: logger.error(f"{self.camera_name}: Error: Could not open video stream from {self.rtsp_url}") self._reconnect_attempts += 1 self._update_status("connection_failed", f"Attempt {self._reconnect_attempts}") return False def run(self): """ Runs the NVR process in a loop. Intended for a thread. """ logger.info(f"{self.camera_name}: NVR thread started.") # Initial connection attempt if not self._connect_stream(): self.frame_callback(self.camera_id, None) # Indicate failure to the app logger.error(f"{self.camera_name}: Initial connection failed. Exiting thread.") self._update_status("stopped", "Initial connection failed") return # Exit thread if initial connection fails # Initialize background subtractor after successful connection if self.motion_enabled: self.fgbg = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=self.threshold_delta, detectShadows=False) while not self.stop_event.is_set(): ret, frame = self.cap.read() if not ret: logger.warning(f"{self.camera_name}: Can't receive frame. Attempting reconnect...") self.cap.release() self._update_status("reconnecting") time.sleep(self._reconnect_delay) # Wait before trying to reconnect if not self._connect_stream(): if self._reconnect_attempts >= self._max_reconnect_attempts: logger.error(f"{self.camera_name}: Max reconnect attempts ({self._max_reconnect_attempts}) reached. Exiting thread.") self.frame_callback(self.camera_id, None) # Indicate failure self._update_status("stopped", "Max reconnect attempts reached") break # Exit the main loop continue # Continue the loop to try reconnecting again else: # Reconnected successfully if self.motion_enabled: # Re-initialize background subtractor on reconnect? # MOG2 adapts, so maybe not strictly necessary, but safer. self.fgbg = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=self.threshold_delta, detectShadows=False) pass # Continue processing frames # Process frame for motion detection if enabled motion_detected = False processed_frame = frame.copy() # Work on a copy for processing/drawing if self.motion_enabled: processed_frame, motion_detected = self._process_frame(processed_frame) # Call the callback with the processed frame (with boxes if motion enabled) # Encode frame to JPEG bytes before sending to callback try: ret_encode, buffer = cv2.imencode('.jpg', processed_frame) if ret_encode: self.frame_callback(self.camera_id, buffer.tobytes()) else: logger.error(f"{self.camera_name}: Failed to encode frame to JPEG.") self.frame_callback(self.camera_id, None) # Indicate frame error except Exception as e: logger.error(f"{self.camera_name}: Error encoding frame: {e}") self.frame_callback(self.camera_id, None) # Indicate frame error # Handle recording based on motion if self.recording_enabled: self._handle_recording(frame, motion_detected) # Use original frame for recording # Small sleep to prevent burning CPU, adjust as needed # This also affects the frame rate of processing/streaming time.sleep(0.01) # --- Cleanup --- logger.info(f"{self.camera_name}: Stop event received. Exiting NVR thread.") if self.cap is not None: self.cap.release() if self.out is not None: try: self.out.release() logger.info(f"{self.camera_name}: Recording file released.") except Exception as e: logger.error(f"{self.camera_name}: Error releasing video writer on exit: {e}") self.out = None self.is_recording = False self._update_status("stopped", "Clean exit") def _process_frame(self, frame): """Applies motion detection logic and returns processed frame and motion status.""" if not self.motion_enabled or self.fgbg is None: return frame, False # Motion detection not enabled or not initialized try: gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, self.blur_size, 0) fgmask = self.fgbg.apply(gray) thresh = cv2.threshold(fgmask, 25, 255, cv2.THRESH_BINARY)[1] thresh = cv2.dilate(thresh, None, iterations=2) contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) motion_detected = False for contour in contours: if cv2.contourArea(contour) < self.min_area: continue (x, y, w, h) = cv2.boundingRect(contour) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) # Draw green box motion_detected = True return frame, motion_detected except Exception as e: logger.error(f"{self.camera_name}: Error processing frame for motion: {e}") return frame, False # Assume no motion on error def _handle_recording(self, frame, motion_detected): """Manages recording state based on motion.""" if not self.recording_enabled: return current_time = time.time() if motion_detected: if not self.is_recording: # Start recording timestamp = time.strftime("%Y%m%d_%H%M%S") # Include camera ID in filename for clarity output_filename = os.path.join(config.RECORDING_OUTPUT_DIR, f"{self.camera_id}_motion_{timestamp}.mp4") frame_height, frame_width = frame.shape[:2] fourcc = cv2.VideoWriter_fourcc(*self.recording_codec) try: # Check if frame dimensions are valid before creating VideoWriter if frame_width > 0 and frame_height > 0: self.out = cv2.VideoWriter(output_filename, fourcc, self.recording_fps, (frame_width, frame_height)) if self.out.isOpened(): self.is_recording = True logger.info(f"{self.camera_name}: Motion detected. Starting recording: {output_filename}") self._update_status("connected", "Recording") else: logger.error(f"{self.camera_name}: Error: Could not open video writer for {output_filename}") self.is_recording = False self.out = None self._update_status("connected", "Recording failed") else: logger.error(f"{self.camera_name}: Error: Invalid frame dimensions ({frame_width}x{frame_height}) for recording.") self.is_recording = False self.out = None self._update_status("connected", "Recording failed (bad frame size)") except Exception as e: logger.error(f"{self.camera_name}: Error starting recording: {e}") self.is_recording = False # Ensure state is correct self.out = None self._update_status("connected", "Recording failed") # Update motion time self.motion_start_time = current_time elif self.is_recording: # No motion detected, check if recording duration after motion has passed if current_time - self.motion_start_time > self.recording_duration_after_motion: # Stop recording if self.out is not None: try: self.out.release() logger.info(f"{self.camera_name}: Recording stopped.") except Exception as e: logger.error(f"{self.camera_name}: Error releasing video writer: {e}") self.out = None self.is_recording = False self._update_status("connected", "Idle") # If recording, write the current frame if self.is_recording and self.out is not None: try: self.out.write(frame) except Exception as e: logger.error(f"{self.camera_name}: Error writing frame to recording: {e}") # Attempt to stop recording gracefully on error if self.out is not None: try: self.out.release() logger.info(f"{self.camera_name}: Recording stopped due to write error.") except Exception as release_e: logger.error(f"{self.camera_name}: Error releasing video writer after write error: {release_e}") self.out = None self.is_recording = False self._update_status("connected", "Recording stopped (write error)") import sys import os import threading import time import cv2 from flask import Flask, render_template, Response, send_from_directory, request, redirect, url_for import atexit import logging import shutil # For deleting directories # Import configuration and NVR core logic import config from nvr_core import NVRCore # Setup logging for the Flask app logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # --- Flask App Setup --- app = Flask(__name__) # --- Shared State --- # Dictionary to hold the latest frame (as JPEG bytes) for each camera latest_frames = {} frame_locks = {} # Lock for each camera's frame # Dictionary to hold the status for each camera camera_statuses = {} # {camera_id: {"status": "...", "details": "...", "is_recording": False}} nvr_stop_event = threading.Event() nvr_threads = {} # {camera_id: threading.Thread} # --- Callbacks from NVRCore --- def update_frame(camera_id, frame_bytes): """Callback function for NVR core to update the latest frame.""" if camera_id not in frame_locks: frame_locks[camera_id] = threading.Lock() with frame_locks[camera_id]: latest_frames[camera_id] = frame_bytes def update_status(camera_id, status_info): """Callback function for NVR core to update camera status.""" camera_statuses[camera_id] = status_info logger.info(f"Status update for {camera_id}: {status_info}") # --- MJPEG Streaming Generator --- def generate_frames(camera_id): """Generator function to yield frames for MJPEG streaming for a specific camera.""" logger.info(f"Starting MJPEG stream generator for {camera_id}") while not nvr_stop_event.is_set(): frame_bytes = None if camera_id in frame_locks: with frame_locks[camera_id]: frame_bytes = latest_frames.get(camera_id) if frame_bytes is not None: try: # Yield the frame in MJPEG format yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n') except Exception as e: logger.error(f"Flask: Error yielding frame for {camera_id}: {e}") # Continue loop, maybe the next frame will be fine else: # If no frame is available (e.g., stream disconnected), wait briefly time.sleep(0.1) logger.info(f"MJPEG stream generator stopped for {camera_id}.") # --- Storage Management --- def get_folder_size(folder_path): """Calculates the size of a folder in bytes.""" total_size = 0 if os.path.exists(folder_path): for dirpath, dirnames, filenames in os.walk(folder_path): for f in filenames: fp = os.path.join(dirpath, f) # skip if it is symbolic link if not os.path.islink(fp): total_size += os.path.getsize(fp) return total_size def cleanup_old_recordings(): """Deletes oldest recordings if total size exceeds MAX_STORAGE_GB.""" if config.MAX_STORAGE_GB <= 0: logger.info("Storage cleanup disabled (MAX_STORAGE_GB <= 0).") return max_bytes = config.MAX_STORAGE_GB * 1024 * 1024 * 1024 current_size = get_folder_size(config.RECORDING_OUTPUT_DIR) logger.info(f"Current recording storage usage: {current_size / (1024*1024*1024):.2f} GB / {config.MAX_STORAGE_GB} GB") if current_size > max_bytes: logger.warning(f"Storage limit ({config.MAX_STORAGE_GB} GB) exceeded. Starting cleanup.") files = [] # Walk through the directory to find all files for dirpath, _, filenames in os.walk(config.RECORDING_OUTPUT_DIR): for f in filenames: fp = os.path.join(dirpath, f) if os.path.isfile(fp): # Store file path and modification time files.append((fp, os.path.getmtime(fp))) # Sort files by modification time (oldest first) files.sort(key=lambda x: x[1]) # Delete oldest files until size is below limit deleted_count = 0 while current_size > max_bytes and files: oldest_file, _ = files.pop(0) try: file_size = os.path.getsize(oldest_file) os.remove(oldest_file) current_size -= file_size deleted_count += 1 logger.info(f"Deleted old recording: {oldest_file}") except OSError as e: logger.error(f"Error deleting file {oldest_file}: {e}") except FileNotFoundError: logger.warning(f"File not found during cleanup (already deleted?): {oldest_file}") logger.info(f"Cleanup finished. Deleted {deleted_count} files. Current size: {current_size / (1024*1024*1024):.2f} GB") # Thread for periodic cleanup cleanup_thread = None cleanup_stop_event = threading.Event() def periodic_cleanup(): """Runs cleanup_old_recordings periodically.""" while not cleanup_stop_event.is_set(): cleanup_old_recordings() # Wait for the interval or until stop event is set cleanup_stop_event.wait(config.CLEANUP_INTERVAL_HOURS * 3600) def start_periodic_cleanup(): """Starts the periodic cleanup thread.""" global cleanup_thread if config.MAX_STORAGE_GB > 0 and config.CLEANUP_INTERVAL_HOURS > 0: logger.info(f"Starting periodic cleanup thread (every {config.CLEANUP_INTERVAL_HOURS} hours).") cleanup_thread = threading.Thread(target=periodic_cleanup) cleanup_thread.daemon = True cleanup_thread.start() else: logger.info("Periodic cleanup disabled.") # --- Flask Routes --- @app.route('/') def index(): """Home page displaying the video feeds.""" # Pass camera configurations and current statuses to the template return render_template('index.html', cameras=config.CAMERAS, statuses=camera_statuses) @app.route('/video_feed/<camera_id>') def video_feed(camera_id): """Route to stream the video feed using MJPEG for a specific camera.""" # Ensure the NVR thread for this camera is running if camera_id not in nvr_threads or not nvr_threads[camera_id].is_alive(): # Attempt to restart or indicate error logger.warning(f"Attempted to access video feed for {camera_id}, but thread is not running.") # Return a placeholder or error image instead of crashing # For simplicity, let's return an empty response or error status return Response("Camera stream not available.", status=503) # The generator handles stream availability internally now return Response(generate_frames(camera_id), mimetype='multipart/x-mixed-replace; boundary=frame') @app.route('/recordings') def list_recordings(): """Route to list available recordings, grouped by camera.""" recordings_by_camera = {} try: # Walk through the recordings directory for root, _, files in os.walk(config.RECORDING_OUTPUT_DIR): for file in files: # Assuming filenames are like camera_id_... parts = file.split('_', 1) if len(parts) > 1: camera_id = parts[0] if camera_id not in recordings_by_camera: recordings_by_camera[camera_id] = [] file_path = os.path.join(root, file) # Store filename and full path recordings_by_camera[camera_id].append({"name": file, "path": file_path}) # Sort recordings within each camera group by name (which includes timestamp) for camera_id in recordings_by_camera: recordings_by_camera[camera_id].sort(key=lambda x: x["name"], reverse=True) # Latest first except FileNotFoundError: logger.error(f"Recordings directory not found: {config.RECORDING_OUTPUT_DIR}") pass # recordings_by_camera will be empty except Exception as e: logger.error(f"Error listing recordings: {e}") # Handle error gracefully, maybe return an error message on the page # Get camera names for display camera_names = {cam["id"]: cam.get("name", cam["id"]) for cam in config.CAMERAS} return render_template('recordings.html', recordings=recordings_by_camera, camera_names=camera_names) @app.route('/recordings/serve/<filename>') def serve_recording(filename): """Route to serve a specific recording file.""" try: # Ensure filename is safe to prevent directory traversal # send_from_directory handles this safety check return send_from_directory(config.RECORDING_OUTPUT_DIR, filename) except FileNotFoundError: return "Recording not found.", 404 except Exception as e: logger.error(f"Error serving recording {filename}: {e}") return f"Error serving recording: {e}", 500 @app.route('/recordings/play/<filename>') def play_recording(filename): """Route to play a specific recording file using an HTML5 video player.""" # Construct the URL to serve the file video_url = url_for('serve_recording', filename=filename) return render_template('playback.html', video_url=video_url, filename=filename) @app.route('/recordings/delete/<filename>', methods=['POST']) def delete_recording(filename): """Route to delete a specific recording file.""" file_path = os.path.join(config.RECORDING_OUTPUT_DIR, filename) try: if os.path.exists(file_path) and os.path.isfile(file_path): os.remove(file_path) logger.info(f"Deleted recording: {file_path}") # Redirect back to the recordings list return redirect(url_for('list_recordings')) else: logger.warning(f"Attempted to delete non-existent file: {file_path}") return "Recording not found.", 404 except Exception as e: logger.error(f"Error deleting recording {filename}: {e}") return f"Error deleting recording: {e}", 500 # --- NVR Thread Management --- def start_nvr_threads(): """Starts NVR core logic for all configured cameras in separate threads.""" logger.info("Starting NVR threads for all cameras...") if not config.CAMERAS: logger.error("No cameras configured. Cannot start NVR threads.") return for camera_config in config.CAMERAS: camera_id = camera_config["id"] rtsp_url = camera_config["rtsp_url"] if rtsp_url == "rtsp://your_camera_ip/stream" or rtsp_url == "rtsp://your_camera_ip_1/stream" or rtsp_url == "rtsp://your_camera_ip_2/stream": logger.warning(f"Skipping camera '{camera_config.get('name', camera_id)}' (id: {camera_id}) due to default RTSP URL.") update_status(camera_id, {"status": "skipped", "details": "Default URL", "is_recording": False}) continue # Skip this camera logger.info(f"Starting thread for camera: {camera_id} ({camera_config.get('name', camera_id)})") nvr_core_instance = NVRCore(camera_config, update_frame, update_status, nvr_stop_event) thread = threading.Thread(target=nvr_core_instance.run, name=f"NVR_{camera_id}") thread.daemon = True # Allow main thread to exit even if NVR thread is running nvr_threads[camera_id] = thread frame_locks[camera_id] = threading.Lock() # Initialize lock latest_frames[camera_id] = None # Initialize frame state camera_statuses[camera_id] = {"status": "starting", "details": "", "is_recording": False} # Initial status thread.start() logger.info(f"Thread started for camera: {camera_id}") def stop_nvr_threads(): """Signals all NVR threads to stop and waits for them.""" logger.info("Signaling NVR threads to stop...") nvr_stop_event.set() cleanup_stop_event.set() # Signal cleanup thread to stop for camera_id, thread in nvr_threads.items(): if thread and thread.is_alive(): logger.info(f"Waiting for thread {camera_id} to join...") thread.join(timeout=10) # Wait for thread to finish, with timeout if thread.is_alive(): logger.warning(f"Thread {camera_id} did not stop gracefully.") else: logger.info(f"Thread {camera_id} stopped.") if cleanup_thread and cleanup_thread.is_alive(): logger.info("Waiting for cleanup thread to join...") cleanup_thread.join(timeout=5) if cleanup_thread.is_alive(): logger.warning("Cleanup thread did not stop gracefully.") else: logger.info("Cleanup thread stopped.") logger.info("All NVR threads stopped.") # Register the stop function to be called on app exit atexit.register(stop_nvr_threads) # --- Main Execution --- if __name__ == '__main__': # Perform initial storage cleanup cleanup_old_recordings() # Start the periodic cleanup thread start_periodic_cleanup() # Start the NVR threads before running the Flask app start_nvr_threads() # Run the Flask app # Use host='0.0.0.0' to make it accessible from other machines on the network # debug=True is useful during development, but should be False in production # threaded=True is the default for Flask development server, good for handling multiple requests # use_reloader=False is important when using threads, otherwise threads might be started multiple times app.run(host='0.0.0.0', port=5000, debug=False, threaded=True, use_reloader=False) Basic NVR System

Live Camera Feeds

{% for camera in cameras %}

Camera Feed for {{ camera.name | default(camera.id) }}

Status: {{ statuses.get(camera.id, {}).status | default('Unknown') }} {% if statuses.get(camera.id, {}).details %}({{ statuses.get(camera.id, {}).details }}){% endif %} {% if statuses.get(camera.id, {}).is_recording %}, Recording{% endif %}

{% endfor %} {% if not cameras %}

No cameras configured. Please check your config.py file.

{% endif %}

Recordings

Back to Live Feed {% if recordings %} {% for camera_id, file_list in recordings.items() %}

{% if file_list %}

{{ file.name }} Play Download

{% else %}

No recordings found for this camera.

{% endif %} {% endfor %} {% else %}

No recordings found.

{% endif %}

Playback: {{ filename }}

Back to Recordings List

Flask opencv-python numpy

Live Camera Feeds

{{ camera.name | default(camera.id) }}

Recordings

{{ camera_names.get(camera_id, camera_id) }}

Playback: {{ filename }}