332 lines
13 KiB
Python
332 lines
13 KiB
Python
"""声呐视频：后台处理 ``BIOMASS_SONAR_VIDEO_DIR`` 中的**当前最新**视频文件。
|
||
|
||
支持 MP4、MKV、MOV。MP4/MOV 在录制中缺少 ``moov`` atom，须等录完才能处理；
|
||
MKV 的元数据写在文件头，录制中即可读取，无需等待。
|
||
|
||
每次轮询取目录中 **mtime 最新** 的文件；当其 **(path, size)** 变化时，用 ffmpeg
|
||
``-sseof`` 截取**最后 N 秒**（默认 60，见 ``BIOMASS_SONAR_VIDEO_SLICE_SEC``），再对该
|
||
切片做光流 overlay → H.264 转码并原子替换发布。``GET /api/v1/biomass/sonar/video/``
|
||
立即返回最近成功发布的 URL。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import datetime
|
||
import subprocess
|
||
import time
|
||
from pathlib import Path
|
||
from typing import Optional, Tuple
|
||
|
||
from loguru import logger
|
||
|
||
from app.compat import to_thread
|
||
from app.services.action_watch import iter_mp4
|
||
from app.services.measure import transcode_src_to_h264_dst
|
||
from app.services.sonar_optical_flow import run_sonar_optical_flow_overlay
|
||
from app.services.video_slice import _get_ffmpeg_path
|
||
from app.settings import Settings
|
||
|
||
DEFAULT_CLIENT_ID = "default"
|
||
|
||
# --- published state (read by GET endpoint) ---
|
||
_published_url: str = ""
|
||
_published_lock = asyncio.Lock()
|
||
|
||
|
||
def _public_media_url(settings: Settings, basename: str) -> str:
|
||
base = settings.public_base_url.rstrip("/")
|
||
return f"{base}/media/{basename}"
|
||
|
||
|
||
def _safe_sonar_media_basename(raw: str) -> str:
|
||
n = (raw or "").strip()
|
||
if not n:
|
||
return "biomass_sonar.mp4"
|
||
return Path(n).name or "biomass_sonar.mp4"
|
||
|
||
|
||
# Formats that store metadata at the start → readable while recording
|
||
_STREAMING_SUFFIXES = frozenset({".mkv", ".ts", ".webm"})
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Probe: is the video file ready to process?
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _is_ready_to_process(path: Path) -> bool:
|
||
"""MKV/TS/WebM are always readable (metadata at start); MP4/MOV need moov at end."""
|
||
if path.suffix.lower() in _STREAMING_SUFFIXES:
|
||
return path.is_file() and path.stat().st_size > 0
|
||
return _probe_moov_readable(path)
|
||
|
||
|
||
def _probe_moov_readable(path: Path) -> bool:
|
||
"""Quick check via ffprobe (fallback cv2): does the MP4/MOV have a moov atom?"""
|
||
try:
|
||
r = subprocess.run(
|
||
["ffprobe", "-v", "error", "-show_entries", "format=duration",
|
||
"-of", "default=noprint_wrappers=1:nokey=1", str(path)],
|
||
capture_output=True, timeout=5,
|
||
)
|
||
if r.returncode == 0 and r.stdout.strip():
|
||
return True
|
||
logger.debug("[sonar-watch] ffprobe: moov missing: {}", path.name)
|
||
return False
|
||
except FileNotFoundError:
|
||
pass
|
||
except Exception as e:
|
||
logger.debug("[sonar-watch] ffprobe failed ({}), trying cv2", e)
|
||
|
||
try:
|
||
import cv2
|
||
cap = cv2.VideoCapture(str(path))
|
||
ok = cap.isOpened() and cap.get(cv2.CAP_PROP_FRAME_COUNT) > 0
|
||
cap.release()
|
||
if not ok:
|
||
logger.debug("[sonar-watch] cv2: unreadable: {}", path.name)
|
||
return ok
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _extract_tail_slice(src: Path, slice_out: Path, duration_sec: float) -> bool:
|
||
"""Extract last ``duration_sec`` seconds with ``ffmpeg -sseof`` + stream copy.
|
||
|
||
For growing MKV files ``ffprobe`` often returns ``N/A`` for duration, so we
|
||
always attempt ``-sseof`` first (ffmpeg clamps to file start when the file is
|
||
shorter than the requested window). Only when ``-sseof`` fails do we fall
|
||
back to a plain ``-c copy`` of the entire file.
|
||
"""
|
||
slice_out.parent.mkdir(parents=True, exist_ok=True)
|
||
slice_out.unlink(missing_ok=True)
|
||
if not src.is_file() or src.stat().st_size <= 0:
|
||
return False
|
||
|
||
ffmpeg = _get_ffmpeg_path()
|
||
sec = float(duration_sec)
|
||
|
||
# --- primary: -sseof (works on growing MKV even when duration is unknown) ---
|
||
sseof_cmd = [
|
||
ffmpeg, "-y", "-hide_banner", "-loglevel", "error",
|
||
"-sseof", f"-{sec}",
|
||
"-i", str(src),
|
||
"-t", str(sec),
|
||
"-c", "copy",
|
||
"-avoid_negative_ts", "make_zero",
|
||
str(slice_out),
|
||
]
|
||
try:
|
||
r = subprocess.run(sseof_cmd, capture_output=True, text=True, timeout=600)
|
||
if r.returncode == 0 and slice_out.is_file() and slice_out.stat().st_size > 0:
|
||
logger.debug("[sonar-watch] tail slice ok (-sseof {:.0f}s): {} -> {}",
|
||
sec, src.name, slice_out.name)
|
||
return True
|
||
except Exception as e:
|
||
logger.debug("[sonar-watch] tail slice -sseof error: {} ({})", src.name, e)
|
||
|
||
# --- fallback: copy entire file (source shorter than window or -sseof unsupported) ---
|
||
slice_out.unlink(missing_ok=True)
|
||
copy_cmd = [
|
||
ffmpeg, "-y", "-hide_banner", "-loglevel", "error",
|
||
"-i", str(src),
|
||
"-c", "copy",
|
||
str(slice_out),
|
||
]
|
||
try:
|
||
r = subprocess.run(copy_cmd, capture_output=True, text=True, timeout=600)
|
||
if r.returncode == 0 and slice_out.is_file() and slice_out.stat().st_size > 0:
|
||
logger.debug("[sonar-watch] tail slice ok (full copy fallback): {} -> {}",
|
||
src.name, slice_out.name)
|
||
return True
|
||
except Exception as e:
|
||
logger.warning("[sonar-watch] tail slice fallback error: {} ({})", src.name, e)
|
||
|
||
logger.warning("[sonar-watch] tail slice failed for {} | stderr={}",
|
||
src.name, (r.stderr or "")[:500])
|
||
slice_out.unlink(missing_ok=True)
|
||
return False
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Publish pipeline: tail slice → optical flow (optional) → H.264 transcode → atomic replace
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def _publish_video(
|
||
src: Path,
|
||
media_root: Path,
|
||
dst_stem: str,
|
||
settings: Settings,
|
||
) -> Optional[Path]:
|
||
"""Extract tail slice → optical-flow → H.264 transcode → verify → save.
|
||
|
||
Every output file gets a unique timestamp so successive cycles never
|
||
overwrite each other:
|
||
|
||
* ``<dst_stem>_optical_flow_<ts>.mp4`` — optical-flow overlay (kept)
|
||
* ``<dst_stem>_<ts>.mp4`` — final H.264 output (kept, published)
|
||
|
||
Returns the path of the published file, or ``None`` on failure.
|
||
"""
|
||
src_size_mb = src.stat().st_size / (1024 * 1024) if src.is_file() else 0
|
||
slice_sec = float(settings.biomass_sonar_video_slice_sec)
|
||
logger.info(
|
||
"[sonar-watch] processing: {} ({:.1f} MB), slice_sec={:.0f}, optical_flow={}",
|
||
src.name, src_size_mb, slice_sec, settings.biomass_sonar_optical_flow,
|
||
)
|
||
t0 = time.monotonic()
|
||
|
||
ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
|
||
slice_tmp = media_root / f"{dst_stem}_tail_slice.mkv"
|
||
slice_tmp.unlink(missing_ok=True)
|
||
tmp = media_root / f"{dst_stem}_tmp.mp4"
|
||
tmp.unlink(missing_ok=True)
|
||
|
||
try:
|
||
slice_ok = await to_thread(_extract_tail_slice, src, slice_tmp, slice_sec)
|
||
if not slice_ok:
|
||
logger.warning("[sonar-watch] tail extract failed, skip publish: {}", src.name)
|
||
return None
|
||
|
||
transcode_src = slice_tmp
|
||
if settings.biomass_sonar_optical_flow:
|
||
flow_dst = media_root / f"{dst_stem}_optical_flow_{ts}.mp4"
|
||
flow_tmp = media_root / f"{dst_stem}_flow_tmp.mp4"
|
||
flow_tmp.unlink(missing_ok=True)
|
||
flow_ok = await to_thread(
|
||
run_sonar_optical_flow_overlay, slice_tmp, flow_tmp, settings,
|
||
)
|
||
if flow_ok and flow_tmp.is_file() and flow_tmp.stat().st_size > 0:
|
||
flow_tmp.replace(flow_dst)
|
||
transcode_src = flow_dst
|
||
logger.info("[sonar-watch] optical flow saved: {} ({:.1f} MB)",
|
||
flow_dst.name,
|
||
flow_dst.stat().st_size / (1024 * 1024))
|
||
else:
|
||
flow_tmp.unlink(missing_ok=True)
|
||
logger.warning("[sonar-watch] optical flow failed, transcoding raw slice: {}", src.name)
|
||
|
||
ok = await to_thread(transcode_src_to_h264_dst, transcode_src, tmp)
|
||
if not (ok and tmp.is_file() and tmp.stat().st_size > 0):
|
||
tmp.unlink(missing_ok=True)
|
||
logger.warning("[sonar-watch] transcode failed for {}", src.name)
|
||
return None
|
||
|
||
if not _probe_moov_readable(tmp):
|
||
logger.warning("[sonar-watch] transcoded file not playable, discarding: {}", src.name)
|
||
tmp.unlink(missing_ok=True)
|
||
return None
|
||
|
||
dst = media_root / f"{dst_stem}_{ts}.mp4"
|
||
tmp.replace(dst)
|
||
elapsed = time.monotonic() - t0
|
||
dst_mb = dst.stat().st_size / (1024 * 1024)
|
||
logger.info("[sonar-watch] published in {:.1f}s: {} -> {} ({:.1f} MB)",
|
||
elapsed, src.name, dst.name, dst_mb)
|
||
return dst
|
||
except Exception:
|
||
logger.exception("[sonar-watch] publish exception for {}", src.name)
|
||
tmp.unlink(missing_ok=True)
|
||
return None
|
||
finally:
|
||
slice_tmp.unlink(missing_ok=True)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Background watcher loop (started from lifespan, like action_watch)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def run_sonar_video_watch_loop(settings: Settings) -> None:
|
||
"""Poll ``BIOMASS_SONAR_VIDEO_DIR``, follow the **latest** file by mtime.
|
||
|
||
When that file's ``(resolved_path, size)`` changes and the file is ready to read,
|
||
extract tail slice → publish. Each published video gets a unique timestamped
|
||
filename; the GET endpoint always returns the most recent one.
|
||
"""
|
||
global _published_url
|
||
|
||
d = settings.biomass_sonar_video_dir
|
||
if d is None:
|
||
logger.info("[sonar-watch] BIOMASS_SONAR_VIDEO_DIR not set, sonar watch disabled")
|
||
return
|
||
|
||
poll = max(1.0, settings.biomass_sonar_video_poll_interval)
|
||
|
||
basename = _safe_sonar_media_basename(settings.biomass_sonar_video_media_name)
|
||
dst_stem = Path(basename).stem # e.g. "biomass_sonar"
|
||
media_root = settings.media_root
|
||
media_root.mkdir(parents=True, exist_ok=True)
|
||
|
||
# Seed published URL from the newest existing published file in media_root
|
||
existing = sorted(
|
||
media_root.glob(f"{dst_stem}_*.mp4"),
|
||
key=lambda p: p.stat().st_mtime,
|
||
)
|
||
# Exclude intermediates (_tmp, _flow_tmp, _optical_flow_, _tail_slice)
|
||
existing = [
|
||
p for p in existing
|
||
if not any(tag in p.stem for tag in ("_tmp", "_flow_tmp", "_optical_flow_", "_tail_slice"))
|
||
]
|
||
if existing:
|
||
seed = existing[-1]
|
||
async with _published_lock:
|
||
_published_url = _public_media_url(settings, seed.name)
|
||
logger.info("[sonar-watch] seeded from existing: {}", _published_url)
|
||
|
||
last_published_key: Optional[Tuple[str, int]] = None
|
||
|
||
logger.info("[sonar-watch] watching {} (poll={:.0f}s, recursive={})",
|
||
d, poll, settings.biomass_sonar_video_recursive)
|
||
|
||
while True:
|
||
try:
|
||
if d.is_dir():
|
||
all_videos = iter_mp4(d, settings.biomass_sonar_video_recursive)
|
||
if all_videos:
|
||
latest = max(all_videos, key=lambda p: p.stat().st_mtime)
|
||
try:
|
||
rp = str(latest.resolve())
|
||
sz = latest.stat().st_size
|
||
except OSError:
|
||
await asyncio.sleep(poll)
|
||
continue
|
||
|
||
if sz > 0 and last_published_key != (rp, sz):
|
||
ready = await to_thread(_is_ready_to_process, latest)
|
||
if ready:
|
||
published = await _publish_video(
|
||
latest, media_root, dst_stem, settings,
|
||
)
|
||
if published is not None:
|
||
async with _published_lock:
|
||
_published_url = _public_media_url(
|
||
settings, published.name,
|
||
)
|
||
last_published_key = (rp, sz)
|
||
else:
|
||
logger.debug(
|
||
"[sonar-watch] {} not ready yet (still recording?), waiting",
|
||
latest.name,
|
||
)
|
||
|
||
except asyncio.CancelledError:
|
||
raise
|
||
except Exception:
|
||
logger.exception("[sonar-watch] unexpected error in watch loop")
|
||
|
||
await asyncio.sleep(poll)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# GET endpoint helper (called from biomass router, no change to API contract)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def get_sonar_video_public_url(
|
||
settings: Settings,
|
||
_client_id: str = DEFAULT_CLIENT_ID,
|
||
) -> str:
|
||
"""Return the URL of the latest successfully published sonar video, or ``""``."""
|
||
async with _published_lock:
|
||
return _published_url
|