950 lines
39 KiB
Python
950 lines
39 KiB
Python
"""全局分析管理器（单例）
|
||
|
||
阶段2：每路摄像头在独立子进程中运行 CameraPipeline；YOLO 推理可选走
|
||
主进程 InferenceProcessPool（共享 GPU/模型内存）。事件经 Queue → EventBridge 写库。
|
||
"""
|
||
import json
|
||
import logging
|
||
import multiprocessing as mp
|
||
import threading
|
||
import time
|
||
import uuid
|
||
|
||
from app.analysis.pipeline import CameraPipeline
|
||
from app.analysis.motion import MotionDetector
|
||
from app.analysis.worker_pool import DetectorWorkerPool
|
||
from app.analysis.process_worker import pipeline_process_main, PipelineProcessHandle
|
||
from app.analysis.event_bridge import get_event_bridge
|
||
|
||
logger = logging.getLogger("analysis.manager")
|
||
|
||
|
||
def _snapshot_storage_paths():
|
||
"""主进程解析报警快照目录，注入子进程（子进程不可 import GlobalUtils）。"""
|
||
import os
|
||
from framework.settings import BASE_DIR
|
||
from app.utils.GlobalUtils import g_config
|
||
static_dir = os.path.join(str(BASE_DIR), "static")
|
||
alarm_dir = getattr(g_config, "storageAlarmDir", "") or os.path.join(static_dir, "storage", "alarm")
|
||
return alarm_dir, static_dir
|
||
|
||
|
||
def _algorithm_to_spec(a, target_labels=None):
|
||
labels = a.labels
|
||
if isinstance(labels, str):
|
||
try:
|
||
labels = json.loads(labels)
|
||
except Exception:
|
||
labels = []
|
||
return {
|
||
"id": a.id,
|
||
"name": a.name,
|
||
"inference_engine": a.inference_engine,
|
||
"model_file": a.model_file,
|
||
"labels": labels,
|
||
"input_width": a.input_width,
|
||
"input_height": a.input_height,
|
||
"conf_threshold": a.conf_threshold,
|
||
"iou_threshold": a.iou_threshold,
|
||
"algorithm_type": a.algorithm_type,
|
||
"task_type": getattr(a, "task_type", "detect"),
|
||
"device": getattr(a, "device", "cpu"),
|
||
"target_labels": sorted(set(target_labels or [])),
|
||
}
|
||
|
||
|
||
def _biz_algo_to_zone_dict(ba):
|
||
from app.utils.Credentials import decrypt_credential
|
||
labels = ba.target_labels or '[]'
|
||
try:
|
||
labels_list = json.loads(labels) if isinstance(labels, str) else labels
|
||
except Exception:
|
||
labels_list = []
|
||
llm_cfg = None
|
||
if ba.llm_id and ba.llm:
|
||
llm_cfg = {
|
||
"id": ba.llm_id,
|
||
"api_url": ba.llm.api_url,
|
||
"api_key": decrypt_credential(ba.llm.api_key),
|
||
"model_name": ba.llm.model_name,
|
||
"timeout": ba.llm.timeout,
|
||
"inference_tool": ba.llm.inference_tool or "OpenAI",
|
||
}
|
||
return {
|
||
"id": ba.id,
|
||
"name": ba.name or "",
|
||
"flow_type": ba.flow_type,
|
||
"small_model_id": ba.small_model_id,
|
||
"detector_model_id": ba.detector_model_id,
|
||
"target_labels": labels_list,
|
||
"llm_id": ba.llm_id,
|
||
"llm_prompt": ba.llm_prompt or "",
|
||
"llm_validate": ba.llm_validate or "",
|
||
"post_process": ba.post_process or "AREA",
|
||
"ref_angle": float(getattr(ba, "ref_angle", 90.0) or 90.0),
|
||
"angle_tolerance": float(getattr(ba, "angle_tolerance", 45.0) or 45.0),
|
||
"forward_count_threshold": int(getattr(ba, "forward_count_threshold", 0) or 0),
|
||
"reverse_count_threshold": int(getattr(ba, "reverse_count_threshold", 0) or 0),
|
||
"llm": llm_cfg,
|
||
}
|
||
|
||
|
||
class AnalysisManager(object):
|
||
_instance = None
|
||
_instance_lock = threading.Lock()
|
||
|
||
def __new__(cls, *args, **kwargs):
|
||
if cls._instance is None:
|
||
with cls._instance_lock:
|
||
if cls._instance is None:
|
||
cls._instance = super(AnalysisManager, cls).__new__(cls)
|
||
cls._instance._initialized = False
|
||
return cls._instance
|
||
|
||
def __init__(self):
|
||
if getattr(self, "_initialized", False):
|
||
return
|
||
self._initialized = True
|
||
self._pipelines = {} # stream_id -> handle dict
|
||
self._lock = threading.RLock()
|
||
self._worker_pool = DetectorWorkerPool()
|
||
self._mp_ctx = mp.get_context("spawn")
|
||
self._status_manager = self._mp_ctx.Manager()
|
||
self._status_dict = self._status_manager.dict()
|
||
self._infer_req_q = self._mp_ctx.Queue(maxsize=128)
|
||
# Never reuse a consumer queue after terminating a camera process:
|
||
# multiprocessing.Queue's read lock can remain acquired on Windows.
|
||
self._infer_routes = {}
|
||
self._infer_routes_lock = threading.Lock()
|
||
self._disabled_algos = set()
|
||
self._infer_forwarder_running = True
|
||
self._infer_forwarder = threading.Thread(
|
||
target=self._inference_forwarder_loop, name="infer-forwarder", daemon=True)
|
||
self._infer_forwarder.start()
|
||
get_event_bridge()
|
||
self._configure_from_settings()
|
||
|
||
def _use_multiprocess(self):
|
||
try:
|
||
from app.utils.GlobalUtils import g_config
|
||
mode = int(getattr(g_config, "analysisProcessMode", 1))
|
||
return mode >= 1
|
||
except Exception:
|
||
return True
|
||
|
||
def _use_shared_inference(self):
|
||
try:
|
||
from app.utils.GlobalUtils import g_config
|
||
return bool(getattr(g_config, "analysisSharedInference", True))
|
||
except Exception:
|
||
return True
|
||
|
||
def set_inference_config(self, shared=None, workers=None):
|
||
"""热更新推理配置（不持久化）。
|
||
- shared: 切换共享推理开关；切换后需重启所有运行中的 pipeline
|
||
- workers: 调整共享推理 worker 数；调整后重启 inference_pool
|
||
返回 (ok, msg)
|
||
"""
|
||
from app.utils.GlobalUtils import g_config
|
||
old_shared = self._use_shared_inference()
|
||
old_workers = int(getattr(g_config, "analysisInferenceWorkers", 2))
|
||
shared_changed = False
|
||
workers_changed = False
|
||
if shared is not None:
|
||
try:
|
||
new_shared = bool(int(shared))
|
||
except Exception:
|
||
new_shared = old_shared
|
||
if new_shared != old_shared:
|
||
g_config.analysisSharedInference = new_shared
|
||
shared_changed = True
|
||
if workers is not None:
|
||
try:
|
||
new_workers = max(1, min(32, int(workers)))
|
||
except Exception:
|
||
new_workers = old_workers
|
||
if new_workers != old_workers:
|
||
g_config.analysisInferenceWorkers = new_workers
|
||
workers_changed = True
|
||
# 重启推理池（worker 数变了，或从非共享切到共享）
|
||
if workers_changed or (shared_changed and self._use_shared_inference()):
|
||
try:
|
||
from app.analysis.inference_pool import shutdown_inference_pool, get_inference_pool
|
||
shutdown_inference_pool()
|
||
if self._use_shared_inference():
|
||
get_inference_pool() # 会按新 worker 数重建
|
||
except Exception as e:
|
||
logger.warning("重启推理池失败: %s" % str(e))
|
||
# shared 切换后重启所有运行中的 pipeline，让新模式生效
|
||
if shared_changed:
|
||
with self._lock:
|
||
sids = list(self._pipelines.keys())
|
||
for sid in sids:
|
||
try:
|
||
from app.models import StreamModel as _SM
|
||
s = _SM.objects.get(id=sid)
|
||
self.stop(sid)
|
||
self.start(s)
|
||
except Exception as e:
|
||
logger.warning("shared 切换重启 pipeline sid=%s 失败: %s" % (sid, str(e)))
|
||
if not shared_changed and not workers_changed:
|
||
return True, "配置未变化"
|
||
return True, "配置已热生效"
|
||
|
||
def set_algo_instance_enabled(self, algo_id, enabled):
|
||
"""设置业务算法的实例化开关（内存，重启丢失）。立即生效，无需重启 pipeline。"""
|
||
try:
|
||
aid = int(algo_id)
|
||
except Exception:
|
||
return False, "invalid algorithm_id"
|
||
with self._lock:
|
||
if enabled:
|
||
self._disabled_algos.discard(aid)
|
||
else:
|
||
self._disabled_algos.add(aid)
|
||
return True, "ok"
|
||
|
||
def is_algo_instance_enabled(self, algo_id):
|
||
try:
|
||
aid = int(algo_id)
|
||
except Exception:
|
||
return True
|
||
return aid not in self._disabled_algos
|
||
|
||
def get_disabled_algos(self):
|
||
with self._lock:
|
||
return set(self._disabled_algos)
|
||
|
||
def restart_algo_instance(self, algo_id):
|
||
"""重启使用指定算法的所有 pipeline（重新加载引擎）。
|
||
algo_id 是小模型 AlgorithmModel.id。
|
||
"""
|
||
try:
|
||
aid = int(algo_id)
|
||
except Exception:
|
||
return False, "invalid algorithm_id"
|
||
with self._lock:
|
||
sids = []
|
||
for sid, item in list(self._pipelines.items()):
|
||
algo_ids = item.get("algorithm_ids") or []
|
||
if aid in algo_ids:
|
||
sids.append(sid)
|
||
if not sids:
|
||
return True, "没有运行中的 pipeline 使用该算法"
|
||
restarted = 0
|
||
for sid in sids:
|
||
try:
|
||
from app.models import StreamModel as _SM
|
||
s = _SM.objects.get(id=sid)
|
||
self.stop(sid)
|
||
self.start(s)
|
||
restarted += 1
|
||
except Exception as e:
|
||
logger.warning("restart_algo_instance sid=%s 失败: %s" % (sid, str(e)))
|
||
return True, "已重启 %d 路 pipeline" % restarted
|
||
|
||
def restart_inference_pool(self):
|
||
"""重启整个推理池（清除所有 worker 子进程内的引擎缓存）。"""
|
||
try:
|
||
from app.analysis.inference_pool import shutdown_inference_pool, get_inference_pool
|
||
shutdown_inference_pool()
|
||
if self._use_shared_inference():
|
||
get_inference_pool()
|
||
return True, "推理池已重启，所有引擎缓存已清除"
|
||
except Exception as e:
|
||
return False, str(e)
|
||
|
||
def _inference_forwarder_loop(self):
|
||
from app.analysis.inference_pool import get_inference_pool
|
||
import queue as _q
|
||
while self._infer_forwarder_running:
|
||
try:
|
||
msg = self._infer_req_q.get(timeout=0.5)
|
||
except _q.Empty:
|
||
continue
|
||
if msg is None:
|
||
break
|
||
req_id = msg.get("req_id")
|
||
channel = msg.get("response_channel")
|
||
with self._infer_routes_lock:
|
||
if channel not in self._infer_routes:
|
||
continue # The originating pipeline has already stopped.
|
||
try:
|
||
jpeg = msg.get("jpeg")
|
||
algo = msg.get("algorithm") or {}
|
||
# 禁用实例化的算法直接返回空结果，跳过推理
|
||
algo_id = algo.get("id", 0)
|
||
try:
|
||
if algo_id and int(algo_id) in self._disabled_algos:
|
||
self._send_inference_response(channel, {"req_id": req_id, "ok": True, "detections": []})
|
||
continue
|
||
except Exception:
|
||
pass
|
||
# 直接透传 JPEG bytes 给推理池，避免主进程 imdecode + imencode 双重编解码，
|
||
# 消除主进程 GIL 占用（解码在 worker 子进程内完成）。
|
||
pool = get_inference_pool() # Config changes may replace the pool.
|
||
dets = pool.detect_jpeg(jpeg, algo, timeout=30.0, raise_errors=True)
|
||
self._send_inference_response(channel, {"req_id": req_id, "ok": True, "detections": dets})
|
||
except Exception as e:
|
||
logger.warning("推理转发失败: %s", e)
|
||
try:
|
||
self._send_inference_response(channel, {"req_id": req_id, "ok": False, "error": str(e)})
|
||
except Exception:
|
||
pass
|
||
|
||
def _send_inference_response(self, channel, response):
|
||
with self._infer_routes_lock:
|
||
response_queue = self._infer_routes.get(channel)
|
||
if response_queue is not None:
|
||
response_queue.put(response, timeout=1.0)
|
||
|
||
def _close_inference_channel(self, item):
|
||
with self._infer_routes_lock:
|
||
response_queue = self._infer_routes.pop(item.get("response_channel"), None)
|
||
if response_queue is not None:
|
||
response_queue.cancel_join_thread()
|
||
response_queue.close()
|
||
|
||
def _configure_from_settings(self):
|
||
try:
|
||
from app.models import AlgorithmModel
|
||
default = AlgorithmModel.objects.filter(is_default=1, state=1).first()
|
||
if default:
|
||
self._default_algorithm = default
|
||
self._target_fps = 5
|
||
return
|
||
except Exception as e:
|
||
logger.warning("AnalysisManager 读取默认 AlgorithmModel 失败: %s" % str(e))
|
||
try:
|
||
from app.utils.GlobalUtils import g_config
|
||
self._target_fps = int(getattr(g_config, "analysisTargetFps", 5))
|
||
except Exception:
|
||
self._target_fps = 5
|
||
self._default_algorithm = None
|
||
|
||
@staticmethod
|
||
def build_rtsp_url(stream):
|
||
try:
|
||
from app.utils.GlobalUtils import g_config
|
||
ip = getattr(g_config, "externalHost", "127.0.0.1") or "127.0.0.1"
|
||
if ip == "0.0.0.0":
|
||
ip = "127.0.0.1"
|
||
port = getattr(g_config, "mediaRtspPort", 10554)
|
||
app = getattr(stream, "app", "live") or "live"
|
||
name = getattr(stream, "name", getattr(stream, "code", "stream")) or "stream"
|
||
return "rtsp://%s:%s/%s/%s" % (ip, int(port), app, name)
|
||
except Exception as e:
|
||
logger.warning("build_rtsp_url 失败: %s" % str(e))
|
||
return ""
|
||
|
||
@staticmethod
|
||
def _zone_analyze_fps(interval_sec, detect_frames):
|
||
interval = max(0.1, float(interval_sec or 1))
|
||
frames = max(1, int(detect_frames or 1))
|
||
return float(frames) / interval
|
||
|
||
@staticmethod
|
||
def _compute_analyze_fps(stream_id, fallback=None):
|
||
"""取该摄像头所有启用布控中最高的算法分析频率（帧/秒）"""
|
||
try:
|
||
from app.models import ZoneModel
|
||
qs = ZoneModel.objects.filter(stream_id=stream_id, state=1)
|
||
max_fps = 0.0
|
||
for z in qs:
|
||
max_fps = max(max_fps, AnalysisManager._zone_analyze_fps(
|
||
getattr(z, "detect_interval_sec", 1),
|
||
getattr(z, "detect_frames", 1),
|
||
))
|
||
if max_fps > 0:
|
||
return max_fps
|
||
except Exception as e:
|
||
logger.warning("_compute_analyze_fps err stream=%s: %s" % (stream_id, str(e)))
|
||
if fallback is not None and fallback > 0:
|
||
return float(fallback)
|
||
return 1.0
|
||
|
||
@staticmethod
|
||
def _load_zones(stream_id, active_only=True, zone_id=None):
|
||
try:
|
||
from app.models import ZoneModel
|
||
qs = ZoneModel.objects.filter(stream_id=stream_id)
|
||
if active_only:
|
||
qs = qs.filter(state=1)
|
||
if zone_id is not None:
|
||
qs = qs.filter(id=int(zone_id))
|
||
qs = qs.prefetch_related(
|
||
'algorithms', 'algorithms__small_model', 'algorithms__detector_model', 'algorithms__llm')
|
||
zones = []
|
||
for z in qs:
|
||
try:
|
||
coords = json.loads(z.coordinates)
|
||
except Exception:
|
||
coords = []
|
||
# LINE_CROSS 警戒线端点（归一化坐标 JSON）
|
||
line_a = None
|
||
line_b = None
|
||
try:
|
||
la = getattr(z, "line_a", "") or ""
|
||
if la:
|
||
line_a = json.loads(la)
|
||
lb = getattr(z, "line_b", "") or ""
|
||
if lb:
|
||
line_b = json.loads(lb)
|
||
except Exception:
|
||
line_a = line_b = None
|
||
biz_list = []
|
||
biz_ids = []
|
||
small_ids = set()
|
||
for ba in z.algorithms.filter(state=1):
|
||
biz_ids.append(ba.id)
|
||
biz_list.append(_biz_algo_to_zone_dict(ba))
|
||
if int(ba.flow_type or 0) == 4:
|
||
if ba.detector_model_id:
|
||
small_ids.add(ba.detector_model_id)
|
||
elif ba.small_model_id:
|
||
small_ids.add(ba.small_model_id)
|
||
interval = max(0.1, float(getattr(z, "detect_interval_sec", 1) or 1))
|
||
frames = max(1, int(getattr(z, "detect_frames", 1) or 1))
|
||
zones.append({
|
||
"id": z.id,
|
||
"name": z.name,
|
||
"coords": coords,
|
||
"is_required": z.is_required,
|
||
"loiter_threshold": z.loiter_threshold,
|
||
"detect_interval_sec": interval,
|
||
"detect_frames": frames,
|
||
"alarm_repeat_sec": max(0.0, float(getattr(z, "alarm_repeat_sec", 30) or 0)),
|
||
"color": z.color or "#169F85",
|
||
"line_a": line_a,
|
||
"line_b": line_b,
|
||
"density_threshold": int(getattr(z, "density_threshold", 0) or 0),
|
||
"algorithm_ids": biz_ids,
|
||
"biz_algorithms": biz_list,
|
||
"small_model_ids": sorted(small_ids),
|
||
})
|
||
return zones
|
||
except Exception as e:
|
||
logger.warning("加载 Zone 失败 stream=%s: %s" % (stream_id, str(e)))
|
||
return []
|
||
|
||
def _resolve_algorithms_for_stream(self, stream):
|
||
try:
|
||
from app.models import ZoneModel, AlgorithmModel
|
||
algos = []
|
||
seen = set()
|
||
for z in ZoneModel.objects.filter(stream_id=stream.id, state=1).prefetch_related(
|
||
'algorithms__small_model', 'algorithms__detector_model'):
|
||
for ba in z.algorithms.filter(state=1):
|
||
if int(ba.flow_type or 0) == 4:
|
||
det = ba.detector_model
|
||
if det and det.state == 1 and det.id not in seen:
|
||
seen.add(det.id)
|
||
algos.append(det)
|
||
continue
|
||
sm = ba.small_model
|
||
if sm and sm.state == 1 and sm.id not in seen:
|
||
seen.add(sm.id)
|
||
algos.append(sm)
|
||
sa = getattr(stream, "algorithm", None)
|
||
if sa is not None and sa.state == 1 and sa.id not in seen:
|
||
seen.add(sa.id)
|
||
algos.append(sa)
|
||
if not algos:
|
||
d = AlgorithmModel.objects.filter(is_default=1, state=1).first()
|
||
if d:
|
||
algos.append(d)
|
||
return algos
|
||
except Exception as e:
|
||
logger.warning("_resolve_algorithms_for_stream err: %s" % str(e))
|
||
return []
|
||
|
||
def _fallback_engine_from_config(self):
|
||
try:
|
||
from app.utils.GlobalUtils import g_config
|
||
model_path = getattr(g_config, "analysisDetectorModel", "") or ""
|
||
if not model_path:
|
||
return None
|
||
labels = getattr(g_config, "analysisDetectorLabels", [])
|
||
if isinstance(labels, str):
|
||
labels = [x.strip() for x in labels.split(",") if x.strip()]
|
||
conf = float(getattr(g_config, "analysisConfThreshold", 0.4))
|
||
from app.analysis.engines.onnx_engine import OnnxEngine
|
||
eng = OnnxEngine(model_path=model_path, labels=labels, conf_threshold=conf)
|
||
if eng.load():
|
||
return eng
|
||
except Exception as e:
|
||
logger.warning("config fallback engine err: %s" % str(e))
|
||
return None
|
||
|
||
def _start_process(self, stream, url, zones, algos, detectors_legacy=None,
|
||
preview_only=False, analyze_fps_override=None):
|
||
sid = stream.id
|
||
self._status_dict.pop(str(sid), None)
|
||
event_queue = self._mp_ctx.Queue(maxsize=256)
|
||
cmd_queue = self._mp_ctx.Queue(maxsize=16)
|
||
bridge = get_event_bridge()
|
||
bridge.register_queue(event_queue)
|
||
|
||
target_by_model = {}
|
||
for zone in zones:
|
||
for rule in zone.get("biz_algorithms") or []:
|
||
model_id = rule.get("detector_model_id") if int(rule.get("flow_type") or 0) == 4 else rule.get("small_model_id")
|
||
if model_id:
|
||
target_by_model.setdefault(int(model_id), set()).update(rule.get("target_labels") or [])
|
||
algo_specs = [_algorithm_to_spec(a, target_by_model.get(int(a.id), set())) for a in algos]
|
||
analyze_fps = (float(analyze_fps_override) if analyze_fps_override is not None
|
||
else self._compute_analyze_fps(sid, fallback=self._target_fps))
|
||
storage_alarm_dir, static_dir = _snapshot_storage_paths()
|
||
response_channel = uuid.uuid4().hex
|
||
infer_resp_q = self._mp_ctx.Queue(maxsize=128)
|
||
with self._infer_routes_lock:
|
||
self._infer_routes[response_channel] = infer_resp_q
|
||
config = {
|
||
"stream_id": sid,
|
||
"stream_code": getattr(stream, "code", str(sid)),
|
||
"rtsp_url": url,
|
||
"target_fps": self._target_fps,
|
||
"analyze_fps": analyze_fps,
|
||
"zones": zones,
|
||
"algorithms": algo_specs,
|
||
"use_shared_inference": self._use_shared_inference(),
|
||
"storage_alarm_dir": storage_alarm_dir,
|
||
"static_dir": static_dir,
|
||
"response_channel": response_channel,
|
||
"preview_only": bool(preview_only),
|
||
}
|
||
proc = self._mp_ctx.Process(
|
||
target=pipeline_process_main,
|
||
args=(config, event_queue, cmd_queue, self._status_dict,
|
||
self._infer_req_q, infer_resp_q),
|
||
name="pipeline-%s" % sid,
|
||
daemon=True,
|
||
)
|
||
try:
|
||
proc.start()
|
||
except Exception:
|
||
self._close_inference_channel({"response_channel": response_channel})
|
||
bridge.unregister_queue(event_queue)
|
||
raise
|
||
handle = PipelineProcessHandle(sid, proc, event_queue, cmd_queue, self._status_dict)
|
||
self._pipelines[sid] = {
|
||
"handle": handle,
|
||
"process": proc,
|
||
"event_queue": event_queue,
|
||
"mode": "process",
|
||
"running": True,
|
||
"pipeline": None,
|
||
"thread": None,
|
||
"algorithm_ids": sorted([a.id for a in algos]),
|
||
"preview_only": bool(preview_only),
|
||
"response_channel": response_channel,
|
||
"analyze_fps": analyze_fps,
|
||
}
|
||
return True, "started (process)"
|
||
|
||
def _start_thread(self, stream, url, zones, algos, preview_only=False,
|
||
analyze_fps_override=None):
|
||
sid = stream.id
|
||
detectors = []
|
||
algo_names = []
|
||
for a in algos:
|
||
labels = set()
|
||
for z in zones:
|
||
for rule in z.get("biz_algorithms") or []:
|
||
model_id = (rule.get("detector_model_id") if int(rule.get("flow_type") or 0) == 4
|
||
else rule.get("small_model_id"))
|
||
if int(model_id or 0) == int(a.id):
|
||
labels.update(rule.get("target_labels") or [])
|
||
eng = self._worker_pool.get_detector(_algorithm_to_spec(a, labels))
|
||
if eng:
|
||
detectors.append({"algorithm_id": a.id, "algorithm_name": a.name,
|
||
"engine": eng, "target_labels": sorted(labels)})
|
||
algo_names.append(a.name)
|
||
if not algos:
|
||
eng = self._fallback_engine_from_config()
|
||
if eng:
|
||
detectors.append({"algorithm_id": 0, "algorithm_name": "config-fallback", "engine": eng})
|
||
algo_names.append("config-fallback")
|
||
|
||
motion = MotionDetector()
|
||
analyze_fps = (float(analyze_fps_override) if analyze_fps_override is not None
|
||
else self._compute_analyze_fps(sid, fallback=self._target_fps))
|
||
storage_alarm_dir, static_dir = _snapshot_storage_paths()
|
||
pipeline = CameraPipeline(
|
||
stream_id=sid,
|
||
stream_code=getattr(stream, "code", str(sid)),
|
||
rtsp_url=url,
|
||
detectors=detectors,
|
||
motion=motion,
|
||
target_fps=self._target_fps,
|
||
analyze_fps=analyze_fps,
|
||
on_event=self._on_event,
|
||
on_track_snapshot=self._on_track_snapshot,
|
||
on_preview=lambda payload: get_event_bridge()._on_preview(payload),
|
||
alarm_enabled=not bool(preview_only),
|
||
zone_polygons=zones,
|
||
storage_alarm_dir=storage_alarm_dir,
|
||
static_dir=static_dir,
|
||
)
|
||
pipeline._algorithm_name = ", ".join(algo_names) if algo_names else "motion-only"
|
||
t = threading.Thread(target=pipeline.run, name="pipeline-%s" % sid, daemon=True)
|
||
self._pipelines[sid] = {
|
||
"pipeline": pipeline,
|
||
"thread": t,
|
||
"running": True,
|
||
"mode": "thread",
|
||
"algorithm_ids": sorted([a.id for a in algos]),
|
||
"preview_only": bool(preview_only),
|
||
"analyze_fps": analyze_fps,
|
||
}
|
||
t.start()
|
||
return True, "started (thread)"
|
||
|
||
def start(self, stream):
|
||
from monitor_runtime.licensing import require_license
|
||
require_license()
|
||
sid = stream.id
|
||
with self._lock:
|
||
item = self._pipelines.get(sid)
|
||
if item and item.get("running"):
|
||
alive = True
|
||
if item.get("mode") == "process":
|
||
proc = item.get("process")
|
||
alive = proc is not None and proc.is_alive()
|
||
else:
|
||
th = item.get("thread")
|
||
alive = th is not None and th.is_alive()
|
||
if alive:
|
||
if not item.get("preview_only"):
|
||
return True, "already running"
|
||
# 正式启动接管由预览创建的临时管线。
|
||
self.stop(sid)
|
||
item = None
|
||
# 僵尸条目：进程/线程已退出但未清理
|
||
try:
|
||
if item.get("mode") == "process":
|
||
self._close_inference_channel(item)
|
||
eq = item.get("event_queue")
|
||
if eq:
|
||
get_event_bridge().unregister_queue(eq)
|
||
else:
|
||
pipe = item.get("pipeline")
|
||
if pipe:
|
||
pipe.stop()
|
||
except Exception:
|
||
pass
|
||
self._pipelines.pop(sid, None)
|
||
url = self.build_rtsp_url(stream)
|
||
if not url:
|
||
return False, "no rtsp url"
|
||
algos = self._resolve_algorithms_for_stream(stream)
|
||
zones = self._load_zones(sid)
|
||
if self._use_multiprocess():
|
||
ok, msg = self._start_process(stream, url, zones, algos)
|
||
else:
|
||
ok, msg = self._start_thread(stream, url, zones, algos)
|
||
if ok:
|
||
time.sleep(0.35)
|
||
if not self.is_running(sid):
|
||
self._purge_pipeline(sid)
|
||
return False, "analysis subprocess exited (check OpenCV / RTSP / log)"
|
||
return ok, msg
|
||
|
||
def start_preview(self, zone):
|
||
"""确保所选布控有检测管线；停用布控使用不写报警的临时管线。"""
|
||
from monitor_runtime.licensing import require_license
|
||
require_license()
|
||
stream = zone.stream
|
||
sid = stream.id
|
||
with self._lock:
|
||
item = self._pipelines.get(sid)
|
||
if self._is_pipeline_alive(item):
|
||
if not item.get("preview_only") and "preview_restore_fps" not in item:
|
||
base_fps = float(item.get("analyze_fps") or self._compute_analyze_fps(sid, 1))
|
||
item["preview_restore_fps"] = base_fps
|
||
boosted_fps = max(5.0, base_fps)
|
||
if item.get("mode") == "process" and item.get("handle"):
|
||
item["handle"].set_analyze_fps(boosted_fps)
|
||
elif item.get("pipeline"):
|
||
item["pipeline"].set_analyze_fps(boosted_fps)
|
||
return True, "preview" if item.get("preview_only") else "formal"
|
||
if item:
|
||
self._purge_pipeline(sid)
|
||
algos = []
|
||
seen = set()
|
||
for ba in zone.algorithms.filter(state=1).select_related("small_model", "detector_model"):
|
||
model = ba.detector_model if int(ba.flow_type or 0) == 4 else ba.small_model
|
||
if model and model.state == 1 and model.id not in seen:
|
||
seen.add(model.id)
|
||
algos.append(model)
|
||
if not algos:
|
||
return False, "布控未绑定可用的小模型"
|
||
zones = self._load_zones(sid, active_only=False, zone_id=zone.id)
|
||
url = self.build_rtsp_url(stream)
|
||
if not url:
|
||
return False, "no rtsp url"
|
||
fps = max(5.0, self._zone_analyze_fps(zone.detect_interval_sec, zone.detect_frames))
|
||
if self._use_multiprocess():
|
||
ok, msg = self._start_process(stream, url, zones, algos,
|
||
preview_only=True, analyze_fps_override=fps)
|
||
else:
|
||
ok, msg = self._start_thread(stream, url, zones, algos,
|
||
preview_only=True, analyze_fps_override=fps)
|
||
if ok:
|
||
time.sleep(0.35)
|
||
if not self.is_running(sid):
|
||
self._purge_pipeline(sid)
|
||
return False, "预览分析子进程启动失败，请检查视频流或模型日志"
|
||
return ok, msg
|
||
|
||
def stop_preview(self, stream_id):
|
||
"""只释放预览创建的管线，不影响正式布控。"""
|
||
with self._lock:
|
||
item = self._pipelines.get(int(stream_id))
|
||
if not item:
|
||
return False
|
||
if not item.get("preview_only"):
|
||
restore_fps = item.pop("preview_restore_fps", None)
|
||
if restore_fps is not None:
|
||
if item.get("mode") == "process" and item.get("handle"):
|
||
item["handle"].set_analyze_fps(restore_fps)
|
||
elif item.get("pipeline"):
|
||
item["pipeline"].set_analyze_fps(restore_fps)
|
||
return False
|
||
self.stop(int(stream_id))
|
||
get_event_bridge().clear_preview(int(stream_id))
|
||
return True
|
||
|
||
def preview_mode(self, stream_id):
|
||
with self._lock:
|
||
item = self._pipelines.get(int(stream_id))
|
||
if not self._is_pipeline_alive(item):
|
||
return "stopped"
|
||
return "preview" if item.get("preview_only") else "formal"
|
||
|
||
def stop(self, stream_id):
|
||
with self._lock:
|
||
item = self._pipelines.get(stream_id)
|
||
if not item:
|
||
return False, "not running"
|
||
if item.get("mode") == "process":
|
||
handle = item.get("handle")
|
||
if handle:
|
||
handle.stop()
|
||
self._close_inference_channel(item)
|
||
eq = item.get("event_queue")
|
||
if eq:
|
||
get_event_bridge().unregister_queue(eq)
|
||
else:
|
||
item["pipeline"].stop()
|
||
item["thread"].join(timeout=3)
|
||
item["running"] = False
|
||
self._pipelines.pop(stream_id, None)
|
||
return True, "stopped"
|
||
|
||
def is_running(self, stream_id):
|
||
with self._lock:
|
||
item = self._pipelines.get(stream_id)
|
||
return self._is_pipeline_alive(item)
|
||
|
||
def _is_pipeline_alive(self, item):
|
||
if not item or not item.get("running"):
|
||
return False
|
||
if item.get("mode") == "process":
|
||
proc = item.get("process")
|
||
return proc is not None and proc.is_alive()
|
||
th = item.get("thread")
|
||
if th is not None and not th.is_alive():
|
||
return False
|
||
pipe = item.get("pipeline")
|
||
if pipe is not None and not getattr(pipe, "_running", False):
|
||
return False
|
||
return True
|
||
|
||
def _purge_pipeline(self, stream_id):
|
||
item = self._pipelines.pop(stream_id, None)
|
||
if not item:
|
||
return
|
||
try:
|
||
if item.get("mode") == "process":
|
||
eq = item.get("event_queue")
|
||
if eq:
|
||
get_event_bridge().unregister_queue(eq)
|
||
handle = item.get("handle")
|
||
if handle:
|
||
try:
|
||
handle.stop(timeout=1)
|
||
except Exception:
|
||
pass
|
||
self._close_inference_channel(item)
|
||
else:
|
||
pipe = item.get("pipeline")
|
||
if pipe:
|
||
try:
|
||
pipe.stop()
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
def list_running(self):
|
||
with self._lock:
|
||
alive = []
|
||
for sid, item in list(self._pipelines.items()):
|
||
if self._is_pipeline_alive(item) and not item.get("preview_only"):
|
||
alive.append(sid)
|
||
elif not self._is_pipeline_alive(item):
|
||
self._purge_pipeline(sid)
|
||
return alive
|
||
|
||
def _enrich_pipeline_status(self, stream_id, info):
|
||
"""补充流健康状态与摄像头名称（不自动启停分析）。"""
|
||
if not info:
|
||
return info
|
||
try:
|
||
from app.models import StreamModel
|
||
s = StreamModel.objects.filter(id=stream_id).first()
|
||
if s:
|
||
info["stream_name"] = s.nickname or s.name or ("#%s" % stream_id)
|
||
except Exception:
|
||
pass
|
||
health = info.get("stream_health") or "ok"
|
||
stalled = float(info.get("stalled_sec") or 0)
|
||
fps = float(info.get("analysis_fps") or 0)
|
||
if health == "ok" and fps <= 0 and stalled >= 20:
|
||
info["stream_health"] = "stalled"
|
||
health = "stalled"
|
||
info["healthy"] = health == "ok" and (
|
||
info.get("analysis_health") == "running" if "analysis_health" in info else fps > 0.05)
|
||
if not info.get("active_zone_ids") and self.is_running(stream_id):
|
||
try:
|
||
zones = self._load_zones(stream_id)
|
||
info["active_zone_ids"] = sorted([int(z["id"]) for z in zones if z.get("id") is not None])
|
||
except Exception:
|
||
info["active_zone_ids"] = []
|
||
return info
|
||
|
||
def get_pipeline_info(self, stream_id):
|
||
with self._lock:
|
||
item = self._pipelines.get(stream_id)
|
||
if not item:
|
||
return None
|
||
if item.get("mode") == "process":
|
||
handle = item.get("handle")
|
||
if handle:
|
||
st = handle.status()
|
||
if st:
|
||
return self._enrich_pipeline_status(stream_id, st)
|
||
alive = self.is_running(stream_id)
|
||
return self._enrich_pipeline_status(stream_id, {
|
||
"stream_id": stream_id,
|
||
"running": alive,
|
||
"stream_health": "connecting" if alive else "stopped",
|
||
"analysis_fps": 0.0,
|
||
"stalled_sec": 0,
|
||
})
|
||
pipe = item.get("pipeline")
|
||
if not pipe:
|
||
return None
|
||
try:
|
||
return self._enrich_pipeline_status(stream_id, pipe.status())
|
||
except Exception as e:
|
||
logger.warning("get_pipeline_info err: %s" % str(e))
|
||
return self._enrich_pipeline_status(stream_id, {
|
||
"stream_id": stream_id,
|
||
"running": False,
|
||
"stream_health": "stalled",
|
||
"analysis_fps": 0.0,
|
||
"stalled_sec": 0,
|
||
})
|
||
|
||
def reload_zones(self, stream_id):
|
||
with self._lock:
|
||
item = self._pipelines.get(stream_id)
|
||
if not item:
|
||
return False
|
||
zones = self._load_zones(stream_id)
|
||
analyze_fps = self._compute_analyze_fps(stream_id, fallback=self._target_fps)
|
||
new_small_ids = sorted({sid for z in zones for sid in z.get("small_model_ids", []) if sid})
|
||
cur_algo_ids = sorted(item.get("algorithm_ids") or [])
|
||
if item.get("mode") == "process":
|
||
if new_small_ids != cur_algo_ids:
|
||
handle = item.get("handle")
|
||
if handle:
|
||
handle.stop()
|
||
eq = item.get("event_queue")
|
||
if eq:
|
||
get_event_bridge().unregister_queue(eq)
|
||
self._pipelines.pop(stream_id, None)
|
||
try:
|
||
from app.models import StreamModel as _SM
|
||
s = _SM.objects.get(id=stream_id)
|
||
self.start(s)
|
||
except Exception as e:
|
||
logger.warning("reload_zones 重启失败 stream=%s: %s" % (stream_id, str(e)))
|
||
else:
|
||
handle = item.get("handle")
|
||
if handle:
|
||
handle.reload_zones(zones, analyze_fps=analyze_fps)
|
||
return True
|
||
pipe = item.get("pipeline")
|
||
if not pipe:
|
||
return False
|
||
if hasattr(pipe, "set_zone_polygons"):
|
||
pipe.set_zone_polygons(zones)
|
||
else:
|
||
pipe.zone_polygons = zones
|
||
pipe.set_analyze_fps(analyze_fps)
|
||
pipe.reset_zone_runtime_state()
|
||
if new_small_ids != cur_algo_ids:
|
||
pipe.stop()
|
||
item["running"] = False
|
||
try:
|
||
item["thread"].join(timeout=3)
|
||
except Exception:
|
||
pass
|
||
self._pipelines.pop(stream_id, None)
|
||
try:
|
||
from app.models import StreamModel as _SM
|
||
s = _SM.objects.get(id=stream_id)
|
||
self.start(s)
|
||
except Exception as e:
|
||
logger.warning("reload_zones 重启失败 stream=%s: %s" % (stream_id, str(e)))
|
||
return True
|
||
|
||
def _on_event(self, event):
|
||
try:
|
||
from app.services.alarm_service import write_alarm, ALARM_EVENT_TYPES
|
||
etype = event.get("type", "")
|
||
if etype in ALARM_EVENT_TYPES:
|
||
write_alarm(event)
|
||
except Exception as e:
|
||
logger.exception("事件处理失败: %s ev=%s" % (str(e), str(event)[:200]))
|
||
|
||
def _on_track_snapshot(self, stream_id, frame_index, active, has_motion):
|
||
# 已停用：不再写追踪快照
|
||
pass
|
||
|
||
@staticmethod
|
||
def _severity_for(event):
|
||
t = event.get("type")
|
||
if t in ("loiter", "cross_camera"):
|
||
return 1
|
||
if t in ("entered_zone", "left_zone", "object_start"):
|
||
return 2
|
||
return 3
|
||
|
||
def shutdown_analysis():
|
||
"""Stop existing resources without constructing a new pool."""
|
||
instance = AnalysisManager._instance
|
||
if instance and getattr(instance, '_initialized', False):
|
||
for sid in list(instance._pipelines):
|
||
instance.stop(sid)
|
||
instance._infer_forwarder_running = False
|
||
instance._infer_forwarder.join(timeout=3)
|
||
from app.analysis.inference_pool import shutdown_inference_pool
|
||
shutdown_inference_pool()
|
||
instance._status_manager.shutdown()
|
||
instance._initialized = False
|
||
AnalysisManager._instance = None
|