307 lines
No EOL
12 KiB
Python
307 lines
No EOL
12 KiB
Python
"""
|
|
Frame readers for RTSP streams and HTTP snapshots.
|
|
Extracted from app.py for modular architecture.
|
|
"""
|
|
import cv2
|
|
import logging
|
|
import time
|
|
import threading
|
|
import requests
|
|
import numpy as np
|
|
from typing import Optional, Callable
|
|
from queue import Queue
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class RTSPReader:
|
|
"""RTSP stream frame reader using OpenCV."""
|
|
|
|
def __init__(self, camera_id: str, rtsp_url: str, max_retries: int = 3):
|
|
self.camera_id = camera_id
|
|
self.rtsp_url = rtsp_url
|
|
self.max_retries = max_retries
|
|
self.cap = None
|
|
self.stop_event = threading.Event()
|
|
self.thread = None
|
|
self.frame_callback: Optional[Callable] = None
|
|
|
|
def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
|
|
"""Set callback function to handle captured frames."""
|
|
self.frame_callback = callback
|
|
|
|
def start(self):
|
|
"""Start the RTSP reader thread."""
|
|
if self.thread and self.thread.is_alive():
|
|
logger.warning(f"RTSP reader for {self.camera_id} already running")
|
|
return
|
|
|
|
self.stop_event.clear()
|
|
self.thread = threading.Thread(target=self._read_frames, daemon=True)
|
|
self.thread.start()
|
|
logger.info(f"Started RTSP reader for camera {self.camera_id}")
|
|
|
|
def stop(self):
|
|
"""Stop the RTSP reader thread."""
|
|
self.stop_event.set()
|
|
if self.thread:
|
|
self.thread.join(timeout=5.0)
|
|
if self.cap:
|
|
self.cap.release()
|
|
logger.info(f"Stopped RTSP reader for camera {self.camera_id}")
|
|
|
|
def _read_frames(self):
|
|
"""Main frame reading loop."""
|
|
retries = 0
|
|
frame_count = 0
|
|
last_log_time = time.time()
|
|
|
|
try:
|
|
# Initialize video capture
|
|
self.cap = cv2.VideoCapture(self.rtsp_url)
|
|
|
|
# Set buffer size to 1 to get latest frames
|
|
self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
|
|
|
|
if self.cap.isOpened():
|
|
width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
|
|
height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
|
|
fps = self.cap.get(cv2.CAP_PROP_FPS)
|
|
logger.info(f"Camera {self.camera_id} opened: {width}x{height}, FPS: {fps}")
|
|
else:
|
|
logger.error(f"Camera {self.camera_id} failed to open initially")
|
|
|
|
while not self.stop_event.is_set():
|
|
try:
|
|
if not self.cap.isOpened():
|
|
logger.error(f"Camera {self.camera_id} not open, attempting to reopen")
|
|
self.cap.open(self.rtsp_url)
|
|
time.sleep(1)
|
|
continue
|
|
|
|
ret, frame = self.cap.read()
|
|
|
|
if not ret or frame is None:
|
|
logger.warning(f"Failed to read frame from camera {self.camera_id}")
|
|
retries += 1
|
|
if retries > self.max_retries and self.max_retries != -1:
|
|
logger.error(f"Max retries reached for camera {self.camera_id}")
|
|
break
|
|
time.sleep(0.1)
|
|
continue
|
|
|
|
# Reset retry counter on successful read
|
|
retries = 0
|
|
frame_count += 1
|
|
|
|
# Call frame callback if set
|
|
if self.frame_callback:
|
|
self.frame_callback(self.camera_id, frame)
|
|
|
|
# Log progress every 30 seconds
|
|
current_time = time.time()
|
|
if current_time - last_log_time >= 30:
|
|
logger.info(f"Camera {self.camera_id}: {frame_count} frames processed")
|
|
last_log_time = current_time
|
|
|
|
# Small delay to prevent CPU overload
|
|
time.sleep(0.033) # ~30 FPS
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error reading frame from camera {self.camera_id}: {e}")
|
|
retries += 1
|
|
if retries > self.max_retries and self.max_retries != -1:
|
|
break
|
|
time.sleep(1)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fatal error in RTSP reader for camera {self.camera_id}: {e}")
|
|
finally:
|
|
if self.cap:
|
|
self.cap.release()
|
|
logger.info(f"RTSP reader thread ended for camera {self.camera_id}")
|
|
|
|
|
|
class HTTPSnapshotReader:
|
|
"""HTTP snapshot reader for periodic image capture."""
|
|
|
|
def __init__(self, camera_id: str, snapshot_url: str, interval_ms: int = 5000, max_retries: int = 3):
|
|
self.camera_id = camera_id
|
|
self.snapshot_url = snapshot_url
|
|
self.interval_ms = interval_ms
|
|
self.max_retries = max_retries
|
|
self.stop_event = threading.Event()
|
|
self.thread = None
|
|
self.frame_callback: Optional[Callable] = None
|
|
|
|
def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
|
|
"""Set callback function to handle captured frames."""
|
|
self.frame_callback = callback
|
|
|
|
def start(self):
|
|
"""Start the snapshot reader thread."""
|
|
if self.thread and self.thread.is_alive():
|
|
logger.warning(f"Snapshot reader for {self.camera_id} already running")
|
|
return
|
|
|
|
self.stop_event.clear()
|
|
self.thread = threading.Thread(target=self._read_snapshots, daemon=True)
|
|
self.thread.start()
|
|
logger.info(f"Started snapshot reader for camera {self.camera_id}")
|
|
|
|
def stop(self):
|
|
"""Stop the snapshot reader thread."""
|
|
self.stop_event.set()
|
|
if self.thread:
|
|
self.thread.join(timeout=5.0)
|
|
logger.info(f"Stopped snapshot reader for camera {self.camera_id}")
|
|
|
|
def _read_snapshots(self):
|
|
"""Main snapshot reading loop."""
|
|
retries = 0
|
|
frame_count = 0
|
|
last_log_time = time.time()
|
|
interval_seconds = self.interval_ms / 1000.0
|
|
|
|
logger.info(f"Snapshot interval for camera {self.camera_id}: {interval_seconds}s")
|
|
|
|
try:
|
|
while not self.stop_event.is_set():
|
|
try:
|
|
start_time = time.time()
|
|
frame = self._fetch_snapshot()
|
|
|
|
if frame is None:
|
|
logger.warning(f"Failed to fetch snapshot for camera {self.camera_id}, retry {retries+1}/{self.max_retries}")
|
|
retries += 1
|
|
if retries > self.max_retries and self.max_retries != -1:
|
|
logger.error(f"Max retries reached for snapshot camera {self.camera_id}")
|
|
break
|
|
time.sleep(1)
|
|
continue
|
|
|
|
# Reset retry counter on successful fetch
|
|
retries = 0
|
|
frame_count += 1
|
|
|
|
# Call frame callback if set
|
|
if self.frame_callback:
|
|
self.frame_callback(self.camera_id, frame)
|
|
|
|
# Log progress every 30 seconds
|
|
current_time = time.time()
|
|
if current_time - last_log_time >= 30:
|
|
logger.info(f"Camera {self.camera_id}: {frame_count} snapshots processed")
|
|
last_log_time = current_time
|
|
|
|
# Wait for next interval, accounting for processing time
|
|
elapsed = time.time() - start_time
|
|
sleep_time = max(0, interval_seconds - elapsed)
|
|
if sleep_time > 0:
|
|
self.stop_event.wait(sleep_time)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error fetching snapshot for camera {self.camera_id}: {e}")
|
|
retries += 1
|
|
if retries > self.max_retries and self.max_retries != -1:
|
|
break
|
|
time.sleep(1)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fatal error in snapshot reader for camera {self.camera_id}: {e}")
|
|
finally:
|
|
logger.info(f"Snapshot reader thread ended for camera {self.camera_id}")
|
|
|
|
def _fetch_snapshot(self) -> Optional[np.ndarray]:
|
|
"""Fetch a single snapshot from HTTP URL."""
|
|
try:
|
|
# Parse URL to extract auth credentials if present
|
|
from urllib.parse import urlparse
|
|
parsed_url = urlparse(self.snapshot_url)
|
|
|
|
# Prepare headers with proper authentication
|
|
headers = {}
|
|
auth = None
|
|
|
|
if parsed_url.username and parsed_url.password:
|
|
# Use HTTP Basic Auth properly
|
|
from requests.auth import HTTPBasicAuth, HTTPDigestAuth
|
|
auth = HTTPBasicAuth(parsed_url.username, parsed_url.password)
|
|
|
|
# Reconstruct URL without credentials
|
|
clean_url = f"{parsed_url.scheme}://{parsed_url.hostname}"
|
|
if parsed_url.port:
|
|
clean_url += f":{parsed_url.port}"
|
|
clean_url += parsed_url.path
|
|
if parsed_url.query:
|
|
clean_url += f"?{parsed_url.query}"
|
|
|
|
# Try with Basic Auth first
|
|
response = requests.get(clean_url, auth=auth, timeout=10, headers=headers)
|
|
|
|
# If Basic Auth fails, try Digest Auth (common for IP cameras)
|
|
if response.status_code == 401:
|
|
auth = HTTPDigestAuth(parsed_url.username, parsed_url.password)
|
|
response = requests.get(clean_url, auth=auth, timeout=10, headers=headers)
|
|
else:
|
|
# No auth in URL, use as-is
|
|
response = requests.get(self.snapshot_url, timeout=10, headers=headers)
|
|
|
|
if response.status_code == 200:
|
|
# Convert bytes to numpy array
|
|
image_array = np.frombuffer(response.content, np.uint8)
|
|
# Decode as image
|
|
frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
|
|
return frame
|
|
else:
|
|
logger.warning(f"HTTP {response.status_code} from {self.snapshot_url}")
|
|
return None
|
|
except requests.RequestException as e:
|
|
logger.error(f"Request error fetching snapshot: {e}")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"Error decoding snapshot: {e}")
|
|
return None
|
|
|
|
|
|
def fetch_snapshot(url: str) -> Optional[np.ndarray]:
|
|
"""Standalone function to fetch a snapshot (for compatibility)."""
|
|
try:
|
|
# Parse URL to extract auth credentials if present
|
|
from urllib.parse import urlparse
|
|
parsed_url = urlparse(url)
|
|
|
|
auth = None
|
|
if parsed_url.username and parsed_url.password:
|
|
# Use HTTP Basic Auth properly
|
|
from requests.auth import HTTPBasicAuth, HTTPDigestAuth
|
|
auth = HTTPBasicAuth(parsed_url.username, parsed_url.password)
|
|
|
|
# Reconstruct URL without credentials
|
|
clean_url = f"{parsed_url.scheme}://{parsed_url.hostname}"
|
|
if parsed_url.port:
|
|
clean_url += f":{parsed_url.port}"
|
|
clean_url += parsed_url.path
|
|
if parsed_url.query:
|
|
clean_url += f"?{parsed_url.query}"
|
|
|
|
# Try with Basic Auth first
|
|
response = requests.get(clean_url, auth=auth, timeout=10)
|
|
|
|
# If Basic Auth fails, try Digest Auth (common for IP cameras)
|
|
if response.status_code == 401:
|
|
auth = HTTPDigestAuth(parsed_url.username, parsed_url.password)
|
|
response = requests.get(clean_url, auth=auth, timeout=10)
|
|
else:
|
|
# No auth in URL, use as-is
|
|
response = requests.get(url, timeout=10)
|
|
|
|
if response.status_code == 200:
|
|
image_array = np.frombuffer(response.content, np.uint8)
|
|
frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
|
|
return frame
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"Error fetching snapshot from {url}: {e}")
|
|
return None |