""" 音乐播放器 -> 直播间 UI 音乐状态同步 通过 Windows 10/11 的 SMTC（System Media Transport Controls）读取当前媒体会话， 并推送到 BGI 直播间 Web 服务。默认偏向网易云音乐，但可在 config/config.json 的 music_monitor 节点或命令行中配置目标播放器。 播放状态判断（参考 now-playing-service/NeteaseMusicService.cs）： - 优先用 Windows 音频会话的峰值音量(volume>0 = Playing)，最贴近"是否真在出声" - volume=0 但 UIA 进度最近 1.5s 内变化 → 仍视为 Playing（静音播放/拖进度条场景） - 否则 Paused 封面防闪： - 只在 SMTC 缩略图 hash 变化时才重写 music_cover.jpg（原子 tmp→replace） - 同一 hash 不重写文件，前端不会因文件变化触发 reload - 标题/歌手来自 cloudmusic 窗口标题（已稳定，不改） """ import argparse import asyncio import hashlib import ctypes import json import os import re import subprocess import sys import time import traceback from pathlib import Path from typing import Any APP_DIR = Path(__file__).resolve().parent if str(APP_DIR) not in sys.path: sys.path.insert(0, str(APP_DIR)) import aiohttp import winrt.windows.media.control as wmc import winrt.windows.storage.streams as streams try: import uiautomation as uia except Exception: uia = None # pycaw: 读取 Windows 音频会话峰值音量（参考 now-playing-service 的 CSCore.AudioMeterInformation） try: from pycaw.pycaw import AudioUtilities # type: ignore _PYCAW_OK = True except Exception: _PYCAW_OK = False from core.runtime_paths import CONFIG_DIR, DATA_DIR, WEB_DIR, ensure_runtime_dirs ensure_runtime_dirs() CONFIG_FILE = CONFIG_DIR / "config.json" MUSIC_FILE = DATA_DIR / "music_state.json" COVER_FILE = WEB_DIR / "music_cover.jpg" DEFAULT_TARGETS = [ "网易云音乐", "Netease", "CloudMusic", "cloudmusic", "YesPlayMusic", "Listen1", "QQMusic", "qqmusic", "spotify", ] DEFAULT_MONITOR_CONFIG = { "platform": "netease", "targets": ["网易云音乐", "Netease", "CloudMusic", "cloudmusic"], "allow_all": False, "interval_sec": 1.0, "holdover_ms": 1500, "prefer_playing": True, "keep_last_when_none": True, "cover_enabled": True, "auto_resume_enabled": False, "auto_resume_interval_sec": 3, "auto_resume_stall_sec": 10, "extra_filter": "", } def load_monitor_config() -> dict[str, Any]: cfg = dict(DEFAULT_MONITOR_CONFIG) if CONFIG_FILE.exists(): try: data = json.loads(CONFIG_FILE.read_text(encoding="utf-8")) if isinstance(data.get("music_monitor"), dict): cfg.update(data["music_monitor"]) except Exception: pass targets = cfg.get("targets") or [] if isinstance(targets, str): targets = [x.strip() for x in targets.replace("，", ",").split(",") if x.strip()] extra = str(cfg.get("extra_filter", "")).strip() if extra: targets.append(extra) cfg["targets"] = [str(x).strip() for x in targets if str(x).strip()] return cfg def session_identity(session) -> str: display = getattr(session, "source_app_display_name", "") or "" aumid = getattr(session, "source_app_user_model_id", "") or "" return f"{display} {aumid}".strip() def is_target_app(session, targets: list[str], allow_all: bool) -> bool: if allow_all or not targets: return True combined = session_identity(session).lower() return any(target.lower() in combined for target in targets) def playback_status_int(session) -> int: try: return int(session.get_playback_info().playback_status) except Exception: return 0 def is_playing(session) -> bool: return playback_status_int(session) == 4 async def choose_session(mgr, cfg: dict[str, Any]): """从全部媒体会话中选择最合适的目标会话。""" targets = cfg.get("targets", []) allow_all = bool(cfg.get("allow_all", False)) prefer_playing = bool(cfg.get("prefer_playing", True)) sessions = list(mgr.get_sessions()) candidates = [s for s in sessions if is_target_app(s, targets, allow_all)] if not candidates: current = mgr.get_current_session() if current and is_target_app(current, targets, allow_all): candidates = [current] if not candidates: return None # 当前系统媒体会话通常最能代表用户正在操作的播放器；优先选择它， # 避免网易云残留多个 SMTC 会话时反复读到已停止更新的旧会话。 current = mgr.get_current_session() if current and current in candidates and (not prefer_playing or is_playing(current)): return current if prefer_playing: playing = [s for s in candidates if is_playing(s)] if playing: return playing[0] if current and current in candidates: return current return candidates[0] async def read_thumbnail(thumb_ref): if thumb_ref is None: return None try: stream = await thumb_ref.open_read_async() size = stream.size if size <= 0 or size > 5 * 1024 * 1024: return None buffer = streams.Buffer(size) await stream.read_async(buffer, size, streams.InputStreamOptions.READ_AHEAD) data = bytes(buffer) return data if len(data) > 100 else None except Exception: return None def write_cover_atomic(data: bytes, previous_hash: str = "") -> tuple[str, str]: cover_hash = hashlib.md5(data).hexdigest() if cover_hash == previous_hash and COVER_FILE.exists(): return "/music_cover.jpg", cover_hash COVER_FILE.parent.mkdir(parents=True, exist_ok=True) tmp = COVER_FILE.with_suffix(".tmp") tmp.write_bytes(data) tmp.replace(COVER_FILE) return "/music_cover.jpg", cover_hash def parse_time_to_seconds(text: str) -> int | None: parts = str(text).strip().split(":") if len(parts) not in (2, 3): return None try: nums = [int(x) for x in parts] except ValueError: return None if any(x < 0 for x in nums) or nums[-1] >= 60: return None if len(nums) == 2: return nums[0] * 60 + nums[1] if nums[1] >= 60: return None return nums[0] * 3600 + nums[1] * 60 + nums[2] def parse_progress_text(text: str) -> tuple[int, int] | None: cleaned = str(text).replace(" ", "") m = re.search(r"(\d{1,2}:\d{2}(?::\d{2})?)\s*[/|／｜]\s*(\d{1,2}:\d{2}(?::\d{2})?)", cleaned) if not m: return None current = parse_time_to_seconds(m.group(1)) total = parse_time_to_seconds(m.group(2)) if current is None or total is None or total <= 0 or current > total + 2: return None return max(0, current), max(0, total) def _cloudmusic_pids() -> list[int]: if not hasattr(ctypes, "windll"): return [] try: output = subprocess.check_output( ["tasklist", "/FI", "IMAGENAME eq cloudmusic.exe", "/FO", "CSV", "/NH"], text=True, encoding="gbk", errors="ignore", creationflags=0x08000000, ) pids = [] for line in output.splitlines(): parts = [p.strip().strip('"') for p in line.split(",")] if len(parts) >= 2 and parts[0].lower() == "cloudmusic.exe": try: pids.append(int(parts[1])) except ValueError: pass return pids except Exception: return [] def _window_titles_by_pids(pids: list[int]) -> list[str]: if not pids or not hasattr(ctypes, "windll"): return [] titles = [] user32 = ctypes.windll.user32 EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p) def enum_proc(hwnd, lparam): try: if not user32.IsWindowVisible(hwnd): return True pid = ctypes.c_ulong() user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid)) if pid.value not in pids: return True length = user32.GetWindowTextLengthW(hwnd) if length <= 0: return True buf = ctypes.create_unicode_buffer(length + 1) user32.GetWindowTextW(hwnd, buf, length + 1) title = (buf.value or "").strip() if title: titles.append(title) except Exception: pass return True try: user32.EnumWindows(EnumWindowsProc(enum_proc), 0) except Exception: pass return titles def read_netease_window_title() -> str: """参考 now-playing-service：从 cloudmusic 进程窗口标题取“歌名 - 歌手”。""" for title in _window_titles_by_pids(_cloudmusic_pids()): if " - " in title and "MediaPlayer" not in title: return title.replace("/", " / ").strip() return "" def read_netease_progress_uia() -> tuple[int, int] | None: """参考 now-playing-service：只在 cloudmusic 播放窗口子树中解析 MM:SS / MM:SS。""" if uia is None: return None try: pids = set(_cloudmusic_pids()) root = uia.GetRootControl() for win in root.GetChildren(): try: pid = int(getattr(win, "ProcessId", 0) or 0) name = (getattr(win, "Name", "") or "") if pids and pid not in pids: continue if " - " not in name and "cloudmusic" not in (getattr(win, "ClassName", "") or "").lower(): continue stack = list(win.GetChildren()) deadline = time.time() + 0.3 while stack and time.time() < deadline: ctrl = stack.pop(0) text_value = (getattr(ctrl, "Name", "") or "").strip() parsed = parse_progress_text(text_value) if parsed: return parsed try: stack.extend(ctrl.GetChildren()) except Exception: pass except Exception: continue except Exception: return None return None _LAST_NETEASE_TITLE = "" _LAST_NETEASE_AT = 0.0 _LAST_PROGRESS_SECONDS = -1 _LAST_PROGRESS_CHANGE_AT = 0.0 _LAST_VOLUME_PEAK = 0.0 _LAST_PLAYING = False _LAST_COVER_HASH = "" _LAST_COVER_SOURCE = "" _COVER_CACHE: dict[str, tuple[str, str]] = {} _COVER_TASKS: dict[str, asyncio.Task] = {} _SMTC_DISABLED_UNTIL = 0.0 _LAST_AUTO_RESUME_AT = 0.0 _AUTO_RESUME_TRACK_KEY = "" _AUTO_RESUME_LAST_PROGRESS = -1.0 _AUTO_RESUME_LAST_PROGRESS_AT = 0.0 _AUTO_RESUME_PAUSED_SINCE = 0.0 _AUTO_RESUME_FAILURES = 0 async def get_target_smtc_session(cfg: dict[str, Any]): mgr = await wmc.GlobalSystemMediaTransportControlsSessionManager.request_async() return await choose_session(mgr, cfg) async def try_resume_playback(cfg: dict[str, Any], force: bool = False) -> bool: """通过 SMTC 尝试恢复播放；暂停/停滞时允许重复发送播放命令。""" global _SMTC_DISABLED_UNTIL if time.time() < _SMTC_DISABLED_UNTIL: return False async def _inner() -> bool: session = await get_target_smtc_session(cfg) if session is None: return False if is_playing(session) and not force: return False result = await session.try_play_async() return bool(result) def _run(): return asyncio.run(_inner()) try: return await asyncio.wait_for(asyncio.to_thread(_run), timeout=2.5) except Exception: _SMTC_DISABLED_UNTIL = time.time() + 5 return False async def maybe_auto_resume(info: dict[str, Any] | None, cfg: dict[str, Any]) -> str: """定期恢复明确暂停，也检测“状态为播放但进度长时间不动”的假播放。""" global _LAST_AUTO_RESUME_AT, _AUTO_RESUME_TRACK_KEY global _AUTO_RESUME_LAST_PROGRESS, _AUTO_RESUME_LAST_PROGRESS_AT global _AUTO_RESUME_PAUSED_SINCE, _AUTO_RESUME_FAILURES if not bool(cfg.get("auto_resume_enabled", False)): return "" if info is None or not info.get("title"): _AUTO_RESUME_TRACK_KEY = "" _AUTO_RESUME_LAST_PROGRESS = -1.0 _AUTO_RESUME_LAST_PROGRESS_AT = 0.0 _AUTO_RESUME_PAUSED_SINCE = 0.0 _AUTO_RESUME_FAILURES = 0 return "" now = time.time() title = str(info.get("title") or "").strip() artist = str(info.get("artist") or "").strip() track_key = f"{title}\n{artist}" progress = max(0.0, float(info.get("progress") or 0)) duration = max(0.0, float(info.get("duration") or 0)) playing = bool(info.get("playing")) if track_key != _AUTO_RESUME_TRACK_KEY: _AUTO_RESUME_TRACK_KEY = track_key _AUTO_RESUME_LAST_PROGRESS = progress _AUTO_RESUME_LAST_PROGRESS_AT = now _AUTO_RESUME_PAUSED_SINCE = 0.0 if playing else now _AUTO_RESUME_FAILURES = 0 return "" if playing: _AUTO_RESUME_PAUSED_SINCE = 0.0 elif not _AUTO_RESUME_PAUSED_SINCE: _AUTO_RESUME_PAUSED_SINCE = now if abs(progress - _AUTO_RESUME_LAST_PROGRESS) >= 0.5: _AUTO_RESUME_LAST_PROGRESS = progress _AUTO_RESUME_LAST_PROGRESS_AT = now _AUTO_RESUME_FAILURES = 0 return "" interval_sec = max(1.0, float(cfg.get("auto_resume_interval_sec", 3) or 3)) stall_sec = max(interval_sec, float(cfg.get("auto_resume_stall_sec", 10) or 10)) stalled = ( playing and progress > 0 and (duration <= 0 or progress < max(0, duration - 2)) and now - _AUTO_RESUME_LAST_PROGRESS_AT >= stall_sec ) if playing and not stalled: return "" if now - _LAST_AUTO_RESUME_AT < interval_sec: return "" _LAST_AUTO_RESUME_AT = now # 明确暂停也强制发送 try_play，避免 SMTC 状态缓存或会话切换导致第一次命令被吞掉。 resumed = await try_resume_playback(cfg, force=True) if resumed: _AUTO_RESUME_LAST_PROGRESS_AT = now _AUTO_RESUME_FAILURES = 0 return "stalled" if stalled else "paused" _AUTO_RESUME_FAILURES += 1 # 连续恢复失败时缩短 SMTC 禁用窗口，下一轮重新获取会话并继续尝试。 if _AUTO_RESUME_FAILURES >= 2: global _SMTC_DISABLED_UNTIL _SMTC_DISABLED_UNTIL = min(_SMTC_DISABLED_UNTIL, now + 1) return "" async def read_smtc_snapshot(cfg: dict[str, Any]) -> dict[str, Any] | None: """在隔离线程里读取 SMTC，避免 WinRT 偶发卡死拖住 MusicMonitor 主循环。""" global _SMTC_DISABLED_UNTIL if time.time() < _SMTC_DISABLED_UNTIL: return None async def _inner(): session = await get_target_smtc_session(cfg) if session is None: return None props = await session.try_get_media_properties_async() playback = session.get_playback_info() timeline = session.get_timeline_properties() thumb_data = None if bool(cfg.get("cover_enabled", True)): thumb_data = await read_thumbnail(props.thumbnail) return { "title": props.title or "", "artist": props.artist or "", "duration": max(0, timeline.end_time.total_seconds()), "progress": max(0, timeline.position.total_seconds()), "playing": int(playback.playback_status) == 4, "source": session_identity(session) or "smtc", "thumb_data": thumb_data, } def _run(): return asyncio.run(_inner()) try: return await asyncio.wait_for(asyncio.to_thread(_run), timeout=2.5) except Exception: _SMTC_DISABLED_UNTIL = time.time() + 5 return None def _get_cloudmusic_audio_peak() -> float: """参考 now-playing-service: 累加 cloudmusic 所有音频会话的峰值音量。 volume>0 = 真在出声 = Playing。pycaw 不可用时返回 -1 表示未知。""" if not _PYCAW_OK: return -1.0 try: from pycaw.pycaw import IAudioMeterInformation # type: ignore total = 0.0 sessions = AudioUtilities.GetAllSessions() for sess in sessions: try: proc = getattr(sess, "Process", None) if proc is None: continue # pycaw 的 Process.name 是方法不是属性, 要调用 name_attr = getattr(proc, "name", None) if callable(name_attr): pname = name_attr() else: pname = str(name_attr or "") pname = (pname or "").lower() if "cloudmusic" in pname: meter = sess._ctl.QueryInterface(IAudioMeterInformation) total += meter.GetPeakValue() except Exception: continue return total except Exception: return -1.0 def _decide_playing(volume_peak: float, progress_changed_recently: bool, holdover_sec: float) -> bool: """参考 now-playing-service: volume>0 → Playing; volume=0 但进度最近变化 → Playing; 否则保持/暂停。""" global _LAST_PLAYING if volume_peak > 0.00001: _LAST_PLAYING = True return True if volume_peak < 0: # pycaw 不可用，回退到进度判断 if progress_changed_recently: _LAST_PLAYING = True return True _LAST_PLAYING = False return False # volume=0 if progress_changed_recently: # 进度在动但没声音 → 静音播放，仍算 Playing _LAST_PLAYING = True return True _LAST_PLAYING = False return False def _split_title_artist(window_title: str) -> tuple[str, str]: title = (window_title or "").strip() if " - " in title: song, artist = title.split(" - ", 1) return song.strip() or title, artist.strip() return title, "" import websockets as _ws_mod def fiber_store_extract_js() -> str: return r''' function _ensureStore() { try { if (window._reduxStore) return true; const rootEl = document.querySelector('#root'); const root = window._fiberRoot || (rootEl && rootEl._reactRootContainer && rootEl._reactRootContainer._internalRoot); if (!root) return false; let queue = [root.current || root]; let visited = 0; while (queue.length > 0) { let node = queue.shift(); if (!node) continue; visited++; if (visited > 20000) break; if (node.memoizedProps && node.memoizedProps.store) { window._reduxStore = node.memoizedProps.store; return true; } if (node.stateNode && node.stateNode.store) { window._reduxStore = node.stateNode.store; return true; } let child = node.child; while (child) { queue.push(child); child = child.sibling; } } return false; } catch(err) { return false; } } ''' async def get_cdp_ws_url(port: int = 9222) -> str: try: async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=1.2)) as session: async with session.get(f"http://127.0.0.1:{port}/json") as resp: if resp.status != 200: return "" targets = await resp.json(content_type=None) for target in targets: text = (str(target.get("url", "")) + " " + str(target.get("title", ""))).lower() if target.get("type") == "page" and target.get("webSocketDebuggerUrl") and ("orpheus" in text or "music.163.com" in text): return target.get("webSocketDebuggerUrl", "") for target in targets: if target.get("type") == "page" and target.get("webSocketDebuggerUrl"): return target.get("webSocketDebuggerUrl", "") except Exception: return "" return "" async def read_netease_cdp_state(cfg: dict[str, Any], previous_hash: str = "") -> dict[str, Any] | None: """通过 CDP 读网易云 Redux 状态。只取 title/artist/progress/duration/picUrl， 不取 playing（playing 交给音量峰值判断）。""" port = int(((cfg.get("request_player") or {}).get("cdp_port", 9222)) or 9222) ws_url = await get_cdp_ws_url(port) if not ws_url: return None script = fiber_store_extract_js() + r''' (function(){ if(!_ensureStore()) return null; const state = window._reduxStore.getState(); const playing = state.playing || {}; const list = (state.playingList && state.playingList.curPlayingList) || []; const id = playing.resourceTrackId || playing.onlineResourceId || playing.resourceId || playing.trackId; function normId(x){ return x == null ? '' : String(x); } let item = null; if(id) item = list.find(x => normId(x.id || x.trackId || x.resourceId) === normId(id)); if(!item && list.length === 1) item = list[0]; const track = (item && (item.track || item.resource || item)) || {}; const artists = track.artists || track.ar || item?.artists || item?.ar || []; let artist = ''; if(Array.isArray(artists)) artist = artists.map(a => a && a.name ? a.name : '').filter(Boolean).join('/'); else if(typeof artists === 'string') artist = artists; const album = track.album || track.al || item?.album || item?.al || {}; const picUrl = album.picUrl || album.blurPicUrl || track.picUrl || item?.picUrl || ''; const durationMs = Number(track.duration || track.dt || item?.duration || item?.dt || 0); const positionMs = Number(playing.position || playing.currentTime || playing.progress || 0); return { id: normId(id || item?.id || track.id), title: track.name || item?.name || '', artist: artist || '', picUrl: picUrl || '', duration: durationMs > 10000 ? durationMs / 1000 : durationMs, progress: positionMs > 10000 ? positionMs / 1000 : positionMs, }; })() ''' try: async with _ws_mod.connect(ws_url, open_timeout=1.5, close_timeout=0.5) as ws: await ws.send(json.dumps({ "id": 1, "method": "Runtime.evaluate", "params": {"expression": script, "returnByValue": True, "awaitPromise": True}, })) deadline = time.time() + 2 while time.time() < deadline: raw = await asyncio.wait_for(ws.recv(), timeout=max(0.1, deadline - time.time())) msg = json.loads(raw) if msg.get("id") != 1: continue value = (((msg.get("result") or {}).get("result") or {}).get("value")) if isinstance(value, dict) and (value.get("title") or value.get("id")): return value return None except Exception: return None return None async def download_cover_url(pic_url: str, previous_hash: str = "") -> tuple[str, str]: global _LAST_COVER_SOURCE if not pic_url: return "", previous_hash if pic_url.startswith("http://"): pic_url = "https://" + pic_url[7:] if pic_url == _LAST_COVER_SOURCE and previous_hash and COVER_FILE.exists(): return "/music_cover.jpg", previous_hash try: async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=3)) as session: async with session.get(pic_url) as resp: if resp.status != 200: return "", previous_hash data = await resp.read() if data: cover_url, cover_hash = write_cover_atomic(data, previous_hash) _LAST_COVER_SOURCE = pic_url return cover_url, cover_hash except Exception: return "", previous_hash return "", previous_hash def cover_cache_key(title: str, artist: str) -> str: return re.sub(r"\s+", " ", f"{title} - {artist}".strip().lower()) async def fetch_cover_task(key: str, title: str, artist: str): """后台补封面：失败也不能影响 MusicMonitor 主循环。""" try: keyword = " ".join(x for x in [title, artist] if x).strip() if not keyword: return headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "Referer": "https://music.163.com/", "Content-Type": "application/x-www-form-urlencoded", "Cookie": "os=pc; appver=2.9.8;", "X-Real-IP": "118.88.88.88", "X-Forwarded-For": "118.88.88.88", } async with aiohttp.ClientSession(headers=headers, timeout=aiohttp.ClientTimeout(total=4)) as session: async with session.post( "https://music.163.com/api/search/get/web", data={"s": keyword, "type": "1", "limit": "1", "offset": "0"}, ) as resp: result = await resp.json(content_type=None) songs = ((result.get("result") or {}).get("songs") or []) if not songs: return album = songs[0].get("album") or {} pic_url = album.get("picUrl") or album.get("blurPicUrl") or "" if not pic_url: return if pic_url.startswith("http://"): pic_url = "https://" + pic_url[7:] async with session.get(pic_url) as img_resp: if img_resp.status != 200: return data = await img_resp.read() if data: _COVER_CACHE[key] = write_cover_atomic(data) except Exception: pass finally: _COVER_TASKS.pop(key, None) def apply_cached_or_schedule_cover(info: dict[str, Any], cfg: dict[str, Any]): if not bool(cfg.get("cover_enabled", True)): return key = cover_cache_key(info.get("title", ""), info.get("artist", "")) if not key: return cached = _COVER_CACHE.get(key) if cached: info["cover"], info["cover_hash"] = cached return task = _COVER_TASKS.get(key) if task is None or task.done(): try: _COVER_TASKS[key] = asyncio.create_task(fetch_cover_task(key, info.get("title", ""), info.get("artist", ""))) except RuntimeError: pass def apply_netease_window_fallback(info: dict[str, Any], cfg: dict[str, Any]) -> dict[str, Any]: """用窗口标题修正歌曲名/艺人，用音量峰值+进度变化判断播放状态。 参考 now-playing-service/NeteaseMusicService.cs。""" global _LAST_NETEASE_TITLE, _LAST_NETEASE_AT, _LAST_PROGRESS_SECONDS, _LAST_PROGRESS_CHANGE_AT holdover = max(0, int(cfg.get("holdover_ms", 1500))) / 1000 win_title = read_netease_window_title() now = time.time() if win_title: _LAST_NETEASE_TITLE = win_title _LAST_NETEASE_AT = now elif _LAST_NETEASE_TITLE and now - _LAST_NETEASE_AT <= holdover: win_title = _LAST_NETEASE_TITLE if win_title: title, artist = _split_title_artist(win_title) if title: info["title"] = title if artist: info["artist"] = artist info["source"] = "cloudmusic.window" # 进度 parsed = read_netease_progress_uia() if parsed: progress, duration = parsed info["progress"] = progress info["duration"] = duration if progress != _LAST_PROGRESS_SECONDS: _LAST_PROGRESS_SECONDS = progress _LAST_PROGRESS_CHANGE_AT = now progress_changed_recently = (now - _LAST_PROGRESS_CHANGE_AT) <= holdover # 播放状态：音量峰值优先，进度兜底 volume_peak = _get_cloudmusic_audio_peak() info["playing"] = _decide_playing(volume_peak, progress_changed_recently, holdover) return info async def get_media_info(cfg: dict[str, Any], previous_cover_hash: str = ""): """网易云已开启 SMTC 后：优先信任 SMTC 的标题、封面、播放状态；CDP/窗口标题只做兜底。""" is_netease = any("cloudmusic" in str(t).lower() for t in cfg.get("targets", [])) smtc = await read_smtc_snapshot(cfg) info = { "title": "", "artist": "", "duration": 0, "progress": 0, "playing": False, "cover": "", "cover_hash": previous_cover_hash, "source": "smtc", "updated_at": time.time(), } cover_url = "" cover_hash = previous_cover_hash if smtc is not None: info["title"] = smtc.get("title", "") info["artist"] = smtc.get("artist", "") info["duration"] = float(smtc.get("duration") or 0) info["progress"] = float(smtc.get("progress") or 0) info["source"] = smtc.get("source") or "smtc" info["playing"] = bool(smtc.get("playing")) thumb_data = smtc.get("thumb_data") if thumb_data: cover_url, cover_hash = write_cover_atomic(thumb_data, previous_cover_hash) if is_netease: # SMTC 现在是主数据源；如果 SMTC 某些字段缺失，再用 CDP/窗口标题补齐。 # 现在网易云已开启 SMTC，音乐显示主链路不再碰 CDP/WebSocket，避免卡主循环。 # 如果 SMTC 暂时没给标题，再用窗口标题兜底；封面则保留上一轮，不再网络下载。 if not info.get("title"): info = apply_netease_window_fallback(info, cfg) if not info.get("title"): return None elif smtc is None: return None # 封面绝不因为某一轮没读到就清空，避免前台闪烁。 if cover_url: info["cover"] = cover_url elif previous_cover_hash and COVER_FILE.exists(): info["cover"] = "/music_cover.jpg" else: # SMTC/窗口标题没有封面时，按“歌名 + 歌手”异步补封面；成功后下一轮自动显示。 apply_cached_or_schedule_cover(info, cfg) if not info.get("cover"): info["cover"] = "" info["cover_hash"] = info.get("cover_hash") or cover_hash return info def default_state() -> dict[str, Any]: return { "playing": False, "current": { "title": "暂无歌曲", "artist": "未接入音乐源", "cover": "", "duration": 0, "progress": 0, "source": "", }, "playlist": [], "requests": [], "monitor": {"online": False, "source": ""}, } def load_state() -> dict[str, Any]: if MUSIC_FILE.exists(): try: state = json.loads(MUSIC_FILE.read_text(encoding="utf-8")) if isinstance(state, dict): return state except Exception: pass return default_state() async def save_state(state: dict[str, Any]): MUSIC_FILE.parent.mkdir(parents=True, exist_ok=True) tmp = MUSIC_FILE.with_suffix(".tmp") tmp.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8") tmp.replace(MUSIC_FILE) async def post_state(state: dict[str, Any], api_url: str) -> bool: try: async with aiohttp.ClientSession() as session: async with session.post(api_url, json=state) as resp: return resp.status == 200 except Exception: return False async def run_monitor(port: int, interval: float | None = None, cli_targets=None, allow_all: bool | None = None): api_url = f"http://localhost:{port}/api/music" state = load_state() last_info_time = 0.0 print(f"[MusicMonitor] start api={api_url}", flush=True) while True: cfg = load_monitor_config() if interval is not None: cfg["interval_sec"] = interval if cli_targets: cfg["targets"] = cli_targets if allow_all is not None: cfg["allow_all"] = allow_all sleep_sec = max(0.3, float(cfg.get("interval_sec", 1.0))) holdover_sec = max(0, int(cfg.get("holdover_ms", 1500))) / 1000 keep_last = bool(cfg.get("keep_last_when_none", True)) try: previous_cover_hash = ((state.get("current") or {}).get("cover_hash") or "") info = await get_media_info(cfg, previous_cover_hash) now = time.time() resume_reason = await maybe_auto_resume(info, cfg) if info is not None else "" if resume_reason: info["playing"] = True reason_text = "进度停滞" if resume_reason == "stalled" else "检测到暂停" print(f"[MusicMonitor] auto resume playback ({reason_text})", flush=True) if info is None: monitor = state.setdefault("monitor", {}) monitor["online"] = False monitor["updated_at"] = now monitor["source"] = "" monitor["platform"] = cfg.get("platform", "") monitor["targets"] = cfg.get("targets", []) monitor["allow_all"] = bool(cfg.get("allow_all", False)) within_holdover = bool(last_info_time) and now - last_info_time <= holdover_sec if keep_last and within_holdover: # SMTC 偶发丢一帧时短暂保留，避免页面闪烁。 pass else: # 超过保留时间后不能继续把旧歌曲伪装成“已暂停”。 # 仅清理播放器状态，保留点歌队列等独立数据。 empty = default_state() state["playing"] = False state["current"] = empty["current"] if not keep_last: state["playlist"] = [] else: last_info_time = now state["playing"] = info["playing"] prev_cover = (state.get("current") or {}).get("cover", "") prev_cover_hash = (state.get("current") or {}).get("cover_hash", "") # 封面: 新值优先, 空值保留旧值(防闪) new_cover = info.get("cover", "") or prev_cover new_cover_hash = info.get("cover_hash", "") or prev_cover_hash # 如果异步封面任务刚完成，本轮 info 可能尚未带 cover；这里再查一次缓存。 if not new_cover: cached = _COVER_CACHE.get(cover_cache_key(info.get("title", ""), info.get("artist", ""))) if cached: new_cover, new_cover_hash = cached state["current"] = { "title": info["title"], "artist": info["artist"], "cover": new_cover, "cover_hash": new_cover_hash, "duration": info["duration"], "progress": info["progress"], "source": info["source"], } state["monitor"] = { "online": True, "source": info["source"], "platform": cfg.get("platform", ""), "updated_at": info["updated_at"], "targets": cfg.get("targets", []), "allow_all": bool(cfg.get("allow_all", False)), } ok = await post_state(state, api_url) if not ok: await save_state(state) cur = state.get("current") or {} print(f"[MusicMonitor] {cur.get('title', '')} - {cur.get('artist', '')} " f"({cur.get('progress', 0):.0f}s/{cur.get('duration', 0):.0f}s) " f"playing={state.get('playing')} source={cur.get('source', '')}", flush=True) except Exception as e: print(f"[MusicMonitor] error: {e}", flush=True) traceback.print_exc() await asyncio.sleep(sleep_sec) if __name__ == "__main__": parser = argparse.ArgumentParser(description="BGI 直播间音乐状态同步") parser.add_argument("--port", type=int, default=8086, help="本地 Web 服务端口号") parser.add_argument("--interval", type=float, default=None, help="轮询间隔（秒），默认读取 config/config.json") parser.add_argument("--allow-all", action="store_true", help="允许同步任意媒体会话（适合网页版播放器）") parser.add_argument("--filter", default="", help="额外过滤关键字，匹配 source_app_display_name/aumid") args = parser.parse_args() targets = None if args.filter: cfg = load_monitor_config() targets = list(cfg.get("targets", [])) + [args.filter] asyncio.run(run_monitor(args.port, args.interval, targets, True if args.allow_all else None))