细节调整

This commit is contained in:
zhongluofeng committed 2026-09-23 18:29:20 +08:00
1 parent bccd21fde5
commit 79bded1cd2
25 files changed
+2655 -494

No files matched your search

+496
View File
@@ -0,0 +1,496 @@
//! Rust 侧音频播放引擎:解码 + 输出都在后端完成,前端只发命令、读状态。
//!
//! # 为什么要搬到 Rust(而不是继续用前端 `<audio>`)
//!
//! 前端播放时,Chromium 会为播放中的媒体元素自动注册一条系统媒体会话(SMTC),
//! 与 [`super::smtc`] 投递的原生会话并行 → Windows 媒体面板出现两条「媒体」。
//! 能关掉它的浏览器参数(`--disable-features=MediaSessionService`)会把本应用的
//! 其他 WebView 窗口一起弄死(见 smtc 模块注释),前端 `navigator.mediaSession`
//! 空桩又拦不住浏览器侧的注册。**主窗口只要不再持有 `<audio>`,就没有会话可注册**,
//! 于是不需要任何浏览器参数,其他窗口也恢复原状。
//!
//! # 线程模型
//!
//! - **调用方线程**(Tauri 命令):只做控制(play / pause / seek / stop / 音量)与状态查询,
//! 全部是原子操作或往通道发一条消息,绝不等待。
//! - **播放线程**(每个会话一条 std 线程):打开音源、探测格式、建输出流、解码填缓冲。
//! `cpal::Stream` 不是 `Send`,必须由它自己创建并持有,因此它随会话生灭。
//! - **音频回调线程**(cpal 内部):只做「出队 → 乘增益 → 转格式」,见 [`super::output`]。
//!
//! # 会话隔离
//!
//! [`Shared`] 是**每个会话一份**的:切歌时先把旧会话静音(立刻生效),再建新会话。
//! 若共用一份共享状态,旧线程还在写、新线程已经在读,会出现「两首歌混在一起」。
//!
//! # 暂停/定位的实现取舍
//!
//! 暂停**不清空缓冲**、也不停输出流,只让回调输出静音(见 output::fill):这样恢复播放
//! 是瞬时的,且不会因为反复启停声卡产生爆音。
//! 定位则清空缓冲并让解码器重新定位,位置计数同步跳到目标点。
use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU64, Ordering};
use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use serde::Serialize;
use specta::Type;
use symphonia::core::codecs::audio::AudioDecoderOptions;
use symphonia::core::errors::Error as SymphoniaError;
use symphonia::core::formats::{FormatOptions, FormatReader, SeekMode, SeekTo, TrackType};
use symphonia::core::formats::probe::Hint;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::units::Time;
use tauri::{AppHandle, Emitter};
use super::{output, source};
/// 播放缓冲上限(秒)。
///
/// 太小:解码抖动(网络流尤其)会来不及补数据 → 断音;
/// 太大:定位时要丢弃更多已解码数据,拖进度条的反应变慢。2 秒是这两者间的常见折中。
const BUFFER_SECONDS: f64 = 2.0;
/// 栈上临时帧数组的容量上限(源声道数超过它时多出的声道被忽略)。
const MAX_CHANNELS: usize = 8;
/// 单个会话的共享状态:解码线程写、音频回调读写、命令线程只读写原子量。
pub(crate) struct Shared {
/// 交错 f32 样本队列(生产 = 解码线程,消费 = 音频回调)
pub buf: Mutex<VecDeque<f32>>,
/// 已播放帧数:**播放位置以它为准**(只有音频回调会自增,定位时由解码线程重置)
pub frames_played: AtomicU64,
/// 源采样率(Hz)
pub rate: AtomicU32,
/// 源声道数
pub src_channels: AtomicU16,
/// 设备输出声道数([`output::build`] 写入)
pub out_channels: AtomicU16,
/// 是否处于播放态(false = 回调输出静音且不消费队列)
pub playing: AtomicBool,
pub muted: AtomicBool,
/// 目标音量(f32 的位表示)
pub volume: AtomicU32,
/// 当前增益(f32 的位表示;音量斜坡用,只有回调写)
pub gain: AtomicU32,
/// 已到达流末尾
pub finished: AtomicBool,
/// 输出流报错(设备被拔/被独占/驱动异常)
pub failed: AtomicBool,
}
impl Shared {
fn new(volume: f32, muted: bool) -> Self {
Self {
buf: Mutex::new(VecDeque::new()),
frames_played: AtomicU64::new(0),
rate: AtomicU32::new(0),
src_channels: AtomicU16::new(0),
out_channels: AtomicU16::new(0),
playing: AtomicBool::new(true),
muted: AtomicBool::new(muted),
volume: AtomicU32::new(volume.to_bits()),
// 起始增益等于目标音量:避免起播瞬间从 0 拉起来产生的淡入延迟
gain: AtomicU32::new(volume.to_bits()),
finished: AtomicBool::new(false),
failed: AtomicBool::new(false),
}
}
fn queue_len(&self) -> usize {
self.buf.lock().unwrap_or_else(|e| e.into_inner()).len()
}
}
/// 播放线程收到的控制消息。音量/静音/暂停走原子量,不进通道(不必串到解码线程)。
enum Control {
/// 定位到指定秒(精确定位由解码线程负责)
Seek(f64),
/// 结束会话(线程随即退出并丢弃输出流)
Stop,
}
/// 一次播放会话的句柄。
struct Session {
shared: Arc<Shared>,
ctrl: Sender<Control>,
handle: JoinHandle<()>,
}
/// 播放状态快照(返回前端)。进度用**拉取**而不是每帧推送:
/// 高频 emit 既费 IPC,又会在拖动进度条时和本地状态打架。
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct AudioState {
/// 是否存在有效会话(false = 已停止/无曲目)
pub active: bool,
pub playing: bool,
/// 当前播放位置(秒)
pub position_sec: f64,
/// 已解码待播的秒数
pub buffered_sec: f64,
/// 源采样率(Hz),0 = 尚未探测出来
pub sample_rate: u32,
pub finished: bool,
pub failed: bool,
}
/// 音频引擎:持有当前会话,并保留跨曲目生效的音量/静音。
pub struct AudioEngine {
/// 用 Arc 装:命令线程要能拿到会话去改状态,而结束会话时要能把它整体摘掉
session: Mutex<Option<Arc<Session>>>,
/// 音量与静音在切歌后沿用(用户在播放器或设置里调过之后不该被重置)
volume: AtomicU32,
muted: AtomicBool,
}
impl AudioEngine {
pub fn new() -> Self {
Self {
session: Mutex::new(None),
volume: AtomicU32::new(1.0f32.to_bits()),
muted: AtomicBool::new(false),
}
}
/// 开始播放一个音源。
///
/// `spec` 为本地绝对路径或流地址([`source::open`] 按 scheme 判定);
/// `start_sec` 用于「退出时的进度」续播。旧会话会先被静音并结束。
pub fn play(&self, app: &AppHandle, spec: String, start_sec: f64) -> Result<(), String> {
self.stop_current();
let shared = Arc::new(Shared::new(
f32::from_bits(self.volume.load(Ordering::Relaxed)),
self.muted.load(Ordering::Relaxed),
));
let (ctrl_tx, ctrl_rx) = mpsc::channel();
let thread_shared = shared.clone();
let thread_app = app.clone();
let handle = thread::Builder::new()
.name("music-audio".to_string())
.spawn(move || {
if let Err(e) = run_session(&thread_shared, &ctrl_rx, &thread_app, &spec, start_sec) {
crate::logger::log_error("music-audio", &format!("播放失败({spec}): {e}"));
let _ = thread_app.emit(crate::constants::events::MUSIC_AUDIO_ERROR, e);
}
})
.map_err(|e| format!("创建播放线程失败: {e}"))?;
*self.session.lock().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(Session {
shared,
ctrl: ctrl_tx,
handle,
}));
Ok(())
}
/// 暂停/恢复。走原子量,不进通道,因此是瞬时生效的。
pub fn set_playing(&self, playing: bool) {
if let Some(s) = self.current() {
s.shared.playing.store(playing, Ordering::SeqCst);
}
}
/// 定位到指定秒。
pub fn seek(&self, sec: f64) {
if let Some(s) = self.current() {
let _ = s.ctrl.send(Control::Seek(sec));
}
}
/// 停止播放并释放设备。
pub fn stop(&self) {
self.stop_current();
}
/// 设置音量与静音。目标值立即写入(回调在本块内斜坡过去,无爆音),
/// 同时记在引擎上供下一首沿用。
pub fn set_volume(&self, volume: f32, muted: bool) {
let volume = volume.clamp(0.0, 1.0);
self.volume.store(volume.to_bits(), Ordering::Relaxed);
self.muted.store(muted, Ordering::Relaxed);
if let Some(s) = self.current() {
s.shared.volume.store(volume.to_bits(), Ordering::Relaxed);
s.shared.muted.store(muted, Ordering::Relaxed);
}
}
pub fn state(&self) -> AudioState {
let Some(s) = self.current() else {
return AudioState {
active: false,
playing: false,
position_sec: 0.0,
buffered_sec: 0.0,
sample_rate: 0,
finished: false,
failed: false,
};
};
let rate = s.shared.rate.load(Ordering::Relaxed).max(1);
let ch = s.shared.src_channels.load(Ordering::Relaxed).max(1) as usize;
let frames = s.shared.frames_played.load(Ordering::Relaxed);
let queued = s.shared.queue_len();
AudioState {
active: true,
playing: s.shared.playing.load(Ordering::Relaxed),
position_sec: frames as f64 / rate as f64,
buffered_sec: queued as f64 / (rate as f64 * ch as f64),
sample_rate: s.shared.rate.load(Ordering::Relaxed),
finished: s.shared.finished.load(Ordering::Relaxed),
failed: s.shared.failed.load(Ordering::Relaxed),
}
}
fn current(&self) -> Option<Arc<Session>> {
self.session
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
/// 结束当前会话:**先静音**(立刻生效,避免它继续出声),再通知线程退出。
///
/// 只把会话从引擎里摘掉、不 join:调用方常在 Tauri 命令线程上,join 会把它卡住
/// 最长一个缓冲周期;线程收到 Stop 后自己收尾并丢弃输出流。会话 Arc 在这里
/// 释放后,JoinHandle 也随之丢弃,等于与线程解绑(detach),不会阻塞任何人。
fn stop_current(&self) {
let old = self.session.lock().unwrap_or_else(|e| e.into_inner()).take();
if let Some(old) = old {
old.shared.playing.store(false, Ordering::SeqCst);
// 让「已到末尾正在等缓冲放完」的等待立即退出,否则它要睡到自然结束
old.shared.finished.store(true, Ordering::SeqCst);
let _ = old.ctrl.send(Control::Stop);
}
}
}
impl Default for AudioEngine {
fn default() -> Self {
Self::new()
}
}
/// 播放线程主体:探测 → 建流 → 解码填缓冲,直到播完 / 被停止 / 出错。
fn run_session(
shared: &Arc<Shared>,
ctrl: &Receiver<Control>,
app: &AppHandle,
spec: &str,
start_sec: f64,
) -> Result<(), String> {
// ---------- 1) 打开音源并探测格式 ----------
let media_source = source::open(spec)?;
let mss = MediaSourceStream::new(media_source, Default::default());
// 扩展名能给探测器省不少事(本地文件尤其明显),流地址没有扩展名也无妨
let mut hint = Hint::new();
if let Some(ext) = extension_of(spec) {
hint.with_extension(&ext);
}
let mut format = symphonia::default::get_probe()
.probe(
&hint,
mss,
FormatOptions::default(),
MetadataOptions::default(),
)
.map_err(|e| format!("不支持的音频格式: {e}"))?;
let track = format
.default_track(TrackType::Audio)
.ok_or_else(|| "音频里没有可解码的轨道".to_string())?;
let params = track
.codec_params
.as_ref()
.and_then(|p| p.audio())
.ok_or_else(|| "音频轨道缺少编码参数".to_string())?;
// 采样率缺失时按 44.1k 兜底:宁可位置显示略有偏差,也不能让整首播不出来
let rate = params.sample_rate.unwrap_or(44100).max(1);
let src_ch = params
.channels
.as_ref()
.map(|c| c.count())
.unwrap_or(2)
.clamp(1, MAX_CHANNELS);
let mut decoder = symphonia::default::get_codecs()
.make_audio_decoder(params, &AudioDecoderOptions::default())
.map_err(|e| format!("不支持的音频编码: {e}"))?;
let track_id = track.id;
shared.rate.store(rate, Ordering::SeqCst);
shared.src_channels.store(src_ch as u16, Ordering::SeqCst);
// ---------- 2) 处理起始定位 ----------
let start_frames = (start_sec.max(0.0) * rate as f64).round() as u64;
shared.frames_played.store(start_frames, Ordering::SeqCst);
let mut produced = start_frames;
if start_sec > 0.0 {
seek_format(&mut *format, track_id, start_sec).map_err(|e| format!("续播定位失败: {e}"))?;
decoder.reset();
}
// ---------- 3) 建输出流 ----------
// 必须在**本线程**创建(cpal::Stream 不是 Send),并持有到会话结束
let _stream = output::build(shared)?;
// ---------- 4) 解码循环 ----------
let cap_samples = (rate as f64 * src_ch as f64 * BUFFER_SECONDS) as usize;
let mut samples: Vec<f32> = Vec::new();
let mut eof = false;
loop {
// 控制消息优先:停止要让线程尽快退出、定位要让缓冲尽快换内容
match ctrl.try_recv() {
Ok(Control::Stop) | Err(TryRecvError::Disconnected) => return Ok(()),
Ok(Control::Seek(sec)) => {
let target = sec.max(0.0);
// 顺序很关键:**先清缓冲、把位置计数挪到目标,再去定位**。
//
// 外网连 NAS 时 `format.seek()` 要等一次网络往返(几百毫秒到数秒)。
// 若等它返回再改状态,这段时间里旧缓冲还在出声、帧计数也还在往前走,
// 前端拉到的仍是旧位置 —— 表现就是「拖完进度条先闪回原处,再跳到目标」。
// 先清后定位 = 立刻静音 + 位置立刻到位,网络到了再从目标点出声。
let prev_frames = shared.frames_played.load(Ordering::SeqCst);
let frames = (target * rate as f64).round() as u64;
shared.buf.lock().unwrap_or_else(|e| e.into_inner()).clear();
shared.frames_played.store(frames, Ordering::SeqCst);
produced = frames;
match seek_format(&mut *format, track_id, target) {
Ok(()) => {
decoder.reset();
eof = false;
}
Err(e) => {
// 定位失败:位置计数必须还原,否则界面会停在一个根本没播到的地方。
// 缓冲已被清空,解码会从原位置继续,所以还原计数是对的。
shared.frames_played.store(prev_frames, Ordering::SeqCst);
produced = prev_frames;
crate::logger::log_warn(
"music-audio",
&format!("定位失败({target}s): {e}"),
);
}
}
continue;
}
Err(TryRecvError::Empty) => {}
}
if shared.failed.load(Ordering::Relaxed) {
return Err("音频输出设备异常(已断开或被其他程序独占)".to_string());
}
// 末尾:等缓冲真正放完再报结束,否则会把还没播完的一两秒当成播完
if eof {
if shared.frames_played.load(Ordering::Relaxed) >= produced {
shared.finished.store(true, Ordering::SeqCst);
// 播完就不该再显示「播放中」:状态查询据此立刻回到暂停态,
// 前端在收到事件、切下一首之前不会看到一个假的播放中状态。
shared.playing.store(false, Ordering::SeqCst);
let _ = app.emit(crate::constants::events::MUSIC_AUDIO_ENDED, ());
return Ok(());
}
thread::sleep(Duration::from_millis(20));
continue;
}
// 暂停时不继续填缓冲(否则一会就堆到上限,白占内存)
if !shared.playing.load(Ordering::Relaxed) {
thread::sleep(Duration::from_millis(10));
continue;
}
if shared.queue_len() >= cap_samples {
thread::sleep(Duration::from_millis(5));
continue;
}
let packet = match format.next_packet() {
Ok(Some(p)) => p,
// 正常读完:源读到 EOF 时读写器返回 None
Ok(None) => {
eof = true;
continue;
}
// 轨道表变化(链式 OGG 物理流):按结束处理
Err(SymphoniaError::ResetRequired) => {
eof = true;
continue;
}
// 文件被截断导致的提前结束:当播完处理,不弹错误
Err(SymphoniaError::IoError(ref e))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
eof = true;
continue;
}
// 其余 IO 错误**不能**当结束:那会把「网络断了 / 读超时」伪装成
// 「这首歌播完了」,前端随即自动切下一首,用户只会觉得莫名跳歌。
// 正常读完走的是 Ok(None),所以这里一律按失败上报(前端会弹错误)。
Err(e) => return Err(format!("读取音频流失败: {e}")),
};
if packet.track_id != track_id {
continue;
}
match decoder.decode(&packet) {
Ok(audio) => {
let n = audio.samples_interleaved();
if n == 0 {
continue;
}
samples.resize(n, 0.0);
audio.copy_to_slice_interleaved(&mut samples);
let frames = (samples.len() / src_ch) as u64;
shared
.buf
.lock()
.unwrap_or_else(|e| e.into_inner())
.extend(samples.iter().copied());
produced = produced.saturating_add(frames);
}
// 坏包跳过:单包解不出来不该让整首断掉
Err(SymphoniaError::DecodeError(_)) | Err(SymphoniaError::IoError(_)) => {}
Err(e) => return Err(format!("解码失败: {e}")),
}
}
}
/// 让容器定位到指定秒(精确模式:容器会把定位点之后、目标之前的帧解出来丢弃)。
///
/// `Time` 的字段是私有的,只能走 `try_new(秒, 纳秒)`;把亚秒部分用纳秒传进去,
/// 拖进度条才能落到毫秒级而不是整秒。
fn seek_format(format: &mut dyn FormatReader, track_id: u32, sec: f64) -> Result<(), String> {
let sec = sec.max(0.0);
let whole = sec.floor();
let nanos = (((sec - whole) * 1e9).round() as i64).clamp(0, 999_999_999) as u32;
let time = Time::try_new(whole as i64, nanos).ok_or_else(|| "定位时间非法".to_string())?;
format
.seek(
SeekMode::Accurate,
SeekTo::Time {
time,
track_id: Some(track_id),
},
)
.map(|_| ())
.map_err(|e| e.to_string())
}
/// 从路径/URL 里取扩展名(用于探测提示)。带 query 的流地址要先把 query 去掉。
fn extension_of(spec: &str) -> Option<String> {
let path = spec.split(['?', '#']).next().unwrap_or(spec);
let name = path.rsplit(['/', '\\']).next().unwrap_or(path);
let ext = name.rsplit_once('.')?.1;
if ext.is_empty() || ext.len() > 5 || !ext.chars().all(|c| c.is_ascii_alphanumeric()) {
return None;
}
Some(ext.to_ascii_lowercase())
}
+68
View File
@@ -0,0 +1,68 @@
//! Rust 侧音乐播放:解码与输出全在后端,前端只发命令、读状态。
//!
//! 模块分工:
//! - [`engine`]:会话生命周期、线程模型、播放/暂停/定位/音量的对外接口与状态快照
//! - [`source`]:音源字节流(本地文件 / 飞牛流代理,支持 Range 定位)
//! - [`output`]:cpal 输出流与音频回调(含声道映射、音量斜坡)
//!
//! 命令层只做参数转发,不含业务逻辑;状态查询走**拉取**而非高频事件推送。
mod engine;
mod output;
mod source;
pub use engine::{AudioEngine, AudioState};
use tauri::{AppHandle, State};
/// 开始播放一个音源。
///
/// `source`:本地绝对路径,或飞牛流地址(形如
/// `http://127.0.0.1:<port>/feiniu/stream?guid=...`,由前端按当前连接拼好 ——
/// 鉴权留在原有代理里,引擎不重复实现)。
/// `startSec`:起播位置,用于「恢复上次退出时的进度」。
#[tauri::command]
#[specta::specta]
pub fn music_audio_play(
app: AppHandle,
engine: State<'_, AudioEngine>,
source: String,
start_sec: f64,
) -> Result<(), String> {
engine.play(&app, source, start_sec)
}
/// 暂停 / 恢复。瞬时生效(只改一个原子标志)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_playing(engine: State<'_, AudioEngine>, playing: bool) {
engine.set_playing(playing);
}
/// 定位到指定秒。
#[tauri::command]
#[specta::specta]
pub fn music_audio_seek(engine: State<'_, AudioEngine>, sec: f64) {
engine.seek(sec);
}
/// 停止播放并释放音频设备。
#[tauri::command]
#[specta::specta]
pub fn music_audio_stop(engine: State<'_, AudioEngine>) {
engine.stop();
}
/// 设置音量与静音(跨曲目沿用)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_volume(engine: State<'_, AudioEngine>, volume: f32, muted: bool) {
engine.set_volume(volume, muted);
}
/// 读取播放状态快照(位置/缓冲/采样率/是否失败)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_state(engine: State<'_, AudioEngine>) -> AudioState {
engine.state()
}
+175
View File
@@ -0,0 +1,175 @@
//! cpal 输出流:把缓冲里的交错 f32 样本按设备格式喂给声卡。
//!
//! # 采样率策略(关系到音质)
//!
//! cpal 的 WASAPI **共享模式**输出带 `AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM |
//! AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY`,因此**可以用源采样率直接建流**,
//! 由 Windows 自己转换到设备混音格式。这样做的两个好处:
//!
//! 1. 不必自己引入重采样器,也就不会临时用一版质量不明的 SRC 把音质拉低;
//! 2. 与现状(WebView2 内部同样把音频交给共享模式输出)**同级**,不构成退步。
//!
//! 后续要做 bit-perfect(独占模式)时,只需把这里换成独占模式的 `IAudioClient`
//! 初始化:源采样率直出、绕过 Windows 混音器,届时**必须**要求源采样率与设备一致,
//! 否则要自己做高质量重采样。
//!
//! # 线程归属
//!
//! `cpal::Stream` 在 Windows 上不是 `Send`,**必须**在创建它的线程上持有与丢弃。
//! 因此本模块只提供 [`build`],由播放线程调用并把返回的流保存在自己内部。
use std::sync::atomic::Ordering;
use std::sync::Arc;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use super::engine::Shared;
/// 建立输出流并立即启动。**必须在播放线程上调用**(见模块注释的线程归属说明)。
pub fn build(shared: &Arc<Shared>) -> Result<cpal::Stream, String> {
let host = cpal::default_host();
let device = host
.default_output_device()
.ok_or_else(|| "没有可用的默认音频输出设备".to_string())?;
let supported = device
.default_output_config()
.map_err(|e| format!("读取默认输出配置失败: {e}"))?;
let sample_format = supported.sample_format();
let out_channels = supported.channels();
let rate = shared.rate.load(Ordering::Relaxed);
shared.out_channels.store(out_channels, Ordering::Relaxed);
// 声道数用**设备**的(AUTOCONVERTPCM 只保证采样率可任意,声道布局仍按设备来),
// 采样率用**源**的。解码出来的样本在 fill() 里做声道映射。
let config = cpal::StreamConfig {
channels: out_channels,
sample_rate: rate.into(),
buffer_size: cpal::BufferSize::Default,
};
let stream = match sample_format {
cpal::SampleFormat::F32 => build_typed::<f32>(&device, config, shared.clone()),
cpal::SampleFormat::I16 => build_typed::<i16>(&device, config, shared.clone()),
cpal::SampleFormat::I32 => build_typed::<i32>(&device, config, shared.clone()),
cpal::SampleFormat::U16 => build_typed::<u16>(&device, config, shared.clone()),
other => Err(format!("不支持的输出采样格式: {other:?}")),
}?;
stream
.play()
.map_err(|e| format!("启动音频输出失败: {e}"))?;
Ok(stream)
}
/// 按设备默认采样格式建流,回调里统一用 f32 计算、再转成设备格式输出。
fn build_typed<T>(
device: &cpal::Device,
config: cpal::StreamConfig,
shared: Arc<Shared>,
) -> Result<cpal::Stream, String>
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let err_shared = shared.clone();
device
.build_output_stream(
config,
move |data: &mut [T], _| fill(data, &shared),
move |e| {
// 设备被拔掉 / 被独占 / 驱动异常:只记日志并把会话标记为失败,
// 由引擎把错误转成前端提示。这里**不能** panic —— 它在音频线程上。
crate::logger::log_error("music-audio", &format!("音频输出流错误: {e}"));
err_shared.failed.store(true, Ordering::Relaxed);
},
None,
)
.map_err(|e| format!("创建音频输出流失败: {e}"))
}
/// 音频回调:把队列里的交错样本搬进设备缓冲。
///
/// 全程只做「出队 + 乘增益 + 转格式」,不加锁以外的任何分配/系统调用,
/// 以免在实时线程上引入不可控的延迟(会直接表现为爆音)。
fn fill<T>(data: &mut [T], shared: &Shared)
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let out_ch = shared.out_channels.load(Ordering::Relaxed) as usize;
let src_ch = shared.src_channels.load(Ordering::Relaxed) as usize;
// 尚未确定声道数(刚起会话)或异常值:先输出静音,不能除零
if out_ch == 0 || src_ch == 0 {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
// 暂停:输出静音但**不消费队列**,恢复播放时数据不丢
if !shared.playing.load(Ordering::Relaxed) {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
let target = if shared.muted.load(Ordering::Relaxed) {
0.0
} else {
f32::from_bits(shared.volume.load(Ordering::Relaxed))
};
let mut gain = f32::from_bits(shared.gain.load(Ordering::Relaxed));
let frames = data.len() / out_ch;
// 音量在本块内线性走到目标值:拖动音量滑块/切静音时不会有台阶式的爆音。
let step = if frames > 0 {
(target - gain) / frames as f32
} else {
0.0
};
let mut consumed: u64 = 0;
{
let mut queue = shared.buf.lock().unwrap_or_else(|e| e.into_inner());
for f in 0..frames {
gain += step;
let base = f * out_ch;
// 一帧源数据 = src_ch 个样本;不足一帧(解码没跟上)就整帧输出静音
let mut src = [0f32; 8];
let has_frame = queue.len() >= src_ch;
if has_frame {
for slot in src.iter_mut().take(src_ch.min(8)) {
*slot = queue.pop_front().unwrap_or(0.0);
}
consumed += 1;
}
for c in 0..out_ch {
let v = if !has_frame {
0.0
} else if out_ch == 1 && src_ch > 1 {
// 多声道 → 单声道:取平均,避免只留左声道
let n = src_ch.min(8);
src[..n].iter().sum::<f32>() / n as f32
} else if src_ch == 1 {
// 单声道 → 任意声道数:复制
src[0]
} else if c < src_ch.min(8) {
src[c]
} else {
// 源声道数少于设备声道数:多出来的声道填静音
0.0
};
data[base + c] = T::from_sample(v * gain);
}
}
}
if consumed > 0 {
shared.frames_played.fetch_add(consumed, Ordering::Relaxed);
}
shared.gain.store(gain.to_bits(), Ordering::Relaxed);
}
+179
View File
@@ -0,0 +1,179 @@
//! 音频字节源:给 symphonia 提供同步的 [`MediaSource`](`Read` + `Seek`)。
//!
//! 两类来源:
//! - **本地文件**:直接交给 `std::fs::File`(symphonia 已为它实现 `MediaSource`)。
//! - **飞牛流**:复用**现有的本地流代理** `http://127.0.0.1:<port>/feiniu/stream?guid=...`。
//! 代理已经处理好登录态 / Cookie / 安全码 / Range 透传,这里只按 Range 拉取即可。
//!
//! 为什么走本地代理而不让引擎直连 NAS:鉴权(连接选择、token、安全码)全在代理里,
//! 复制一份到引擎会立刻产生两套会漂移的逻辑;代理就在 localhost,额外一跳代价可忽略。
//!
//! # 为什么是同步 I/O
//!
//! `MediaSource` 要求 `Read + Seek`,即同步接口。整个播放线程是**独立的 std 线程**
//! (不是 tokio 运行时线程),因此这里用 `reqwest::blocking` 是安全的;若在 tokio
//! 运行时线程上调用会 panic,这一点在改动线程归属时必须留意。
use std::io::{self, Read, Seek, SeekFrom};
use std::time::Duration;
use symphonia::core::io::MediaSource;
/// NAS 流的超时策略:只在**连接**阶段设超时。
///
/// 音频是长时间连续读,一旦给整请求设 timeout,会在播到中途时被掐断(表现为
/// 「播一半突然断流」);而不设连接超时又会在服务器无响应时永久挂住播放线程。
///
/// # 已知限制:读阶段的卡死不设上限
///
/// 想给「连接建立后数据不再来」也加个上限,但 reqwest 的 `read_timeout` 只在**异步**
/// builder 上(blocking 侧没有),而总 timeout 又会掐断长音频。因此链路彻底卡死时
/// 解码线程会停在那次读上(界面表现为一直加载),要等 TCP 自身超时才会报错。
/// 真要兜住它,得在会话上加一个「位置长时间不前进」的看门狗,或让 HttpSource 自己能
/// 被从外部关闭 —— 目前没做。
const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
/// 按规格打开字节源:`http(s)://` 走网络协议,其余一律按本地文件路径处理。
pub fn open(spec: &str) -> Result<Box<dyn MediaSource>, String> {
if spec.starts_with("http://") || spec.starts_with("https://") {
Ok(Box::new(HttpSource::new(spec)?))
} else {
let file = std::fs::File::open(spec).map_err(|e| format!("打开本地音频失败({spec}): {e}"))?;
Ok(Box::new(file))
}
}
/// 走 HTTP 的流式音源,支持按 `Range` 定位。
pub struct HttpSource {
url: String,
client: reqwest::blocking::Client,
/// 已建立的响应体。定位后置空,下次读取时按新位置重新发 Range 请求。
body: Option<reqwest::blocking::Response>,
/// 当前读取位置(字节)
pos: u64,
/// 总字节数(服务端给出 Content-Range / Content-Length 时才有)
len: Option<u64>,
/// 服务端是否支持 Range。不支持时无法定位,引擎会退化为「只能从头顺序播」。
range_ok: bool,
}
impl HttpSource {
fn new(url: &str) -> Result<Self, String> {
let client = reqwest::blocking::Client::builder()
.connect_timeout(CONNECT_TIMEOUT)
.timeout(None)
.build()
.map_err(|e| format!("创建音频 HTTP 客户端失败: {e}"))?;
// 探测总长度与 Range 支持:只取 0-0 一个字节。
// 支持 Range 时服务端回 `206 Partial Content` + `Content-Range: bytes 0-0/<total>`;
// 不支持则回 `200` + `Content-Length`。两种情况都能拿到总长度。
let probe = client
.get(url)
.header(reqwest::header::RANGE, "bytes=0-0")
.send()
.map_err(|e| format!("音频源探测失败: {e}"))?;
let status = probe.status();
if !status.is_success() {
return Err(format!("音频源探测失败: HTTP {status}"));
}
let range_ok = status == reqwest::StatusCode::PARTIAL_CONTENT
|| probe
.headers()
.get(reqwest::header::ACCEPT_RANGES)
.is_some();
let len = parse_content_range_total(&probe)
.or_else(|| probe.content_length().map(|n| n.max(1)));
Ok(Self {
url: url.to_string(),
client,
body: None,
pos: 0,
len,
range_ok,
})
}
/// 打开(或按当前 `pos` 重开)响应体。
fn ensure_body(&mut self) -> io::Result<()> {
if self.body.is_some() {
return Ok(());
}
let mut req = self.client.get(&self.url);
if self.pos > 0 {
if !self.range_ok {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"音频源不支持 Range,无法定位",
));
}
req = req.header(reqwest::header::RANGE, format!("bytes={}-", self.pos));
}
let resp = req.send().map_err(to_io_err)?;
if !resp.status().is_success() {
return Err(io::Error::new(
io::ErrorKind::Other,
format!("音频流请求失败: HTTP {}", resp.status()),
));
}
self.body = Some(resp);
Ok(())
}
}
impl Read for HttpSource {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.ensure_body()?;
let body = self.body.as_mut().expect("ensure_body 已建立响应体");
let n = body.read(buf)?;
self.pos += n as u64;
Ok(n)
}
}
impl Seek for HttpSource {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
let target = match pos {
SeekFrom::Start(p) => p,
SeekFrom::End(off) => {
let len = self.len.ok_or_else(|| {
io::Error::new(io::ErrorKind::Unsupported, "总长度未知,无法从末尾定位")
})?;
(len as i64 + off).max(0) as u64
}
SeekFrom::Current(off) => (self.pos as i64 + off).max(0) as u64,
};
// 丢弃当前响应体,下次读取按新位置重发 Range —— 这样定位既不需要缓存整段音频,
// 也不会把已读过的字节再拉一遍。
self.body = None;
self.pos = target;
Ok(target)
}
}
impl MediaSource for HttpSource {
fn is_seekable(&self) -> bool {
self.range_ok
}
fn byte_len(&self) -> Option<u64> {
self.len
}
}
/// 解析 `Content-Range: bytes 0-0/12345` 里的总长度。
fn parse_content_range_total(resp: &reqwest::blocking::Response) -> Option<u64> {
let raw = resp.headers().get(reqwest::header::CONTENT_RANGE)?.to_str().ok()?;
let total = raw.rsplit('/').next()?.trim();
if total == "*" {
return None;
}
total.parse::<u64>().ok()
}
/// reqwest 的 `Error` → `io::Error`(symphonia 只认 io 错误)。
fn to_io_err(e: reqwest::Error) -> io::Error {
io::Error::new(io::ErrorKind::Other, e.to_string())
}
+13
View File
@@ -14,17 +14,30 @@
//! - [`runtime`]:Python 运行时探测与便携版安装
//! - [`bridge`]:桥接进程生命周期(spawn / JSON 协议 / ping / 停止)
//! - [`commands`]:Tauri 命令层
//! - [`smtc`]:Windows 系统媒体传输控件(原生,取代前端 navigator.mediaSession 元数据)
mod audio;
mod bridge;
mod commands;
mod feiniu;
mod runtime;
mod secrets;
mod smtc;
pub use audio::{
music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
music_audio_state, music_audio_stop, AudioEngine,
};
pub use feiniu::{
extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
};
pub use smtc::{
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position, SmtcController,
};
pub use commands::{
feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+393
View File
@@ -0,0 +1,393 @@
//! Windows 系统媒体传输控件(SMTC)集成。
//!
//! # 为什么不用前端的 `navigator.mediaSession`
//!
//! WebView2(Chromium 内核)确实会把 `navigator.mediaSession` 桥接到 Windows SMTC,
//! 但实测**只转发标题、歌手、播放状态与时长进度**:专辑(`AlbumTitle` / `AlbumArtist` /
//! `Subtitle` 全为空)与封面(同一首曲子缩略图时有时无)都不会送达;
//! 且会话挂在 WebView2 浏览器进程的 AUMID 上,系统面板只显示「未知应用」。
//! 因此这里改用原生 SMTC 直接投递全部字段:歌名、歌手、专辑、时长、进度、封面,
//! 并把系统侧的按钮(播放/暂停/上一首/下一首/停止)回传前端。
//!
//! # 与 WebView2 自动会话的关系(当前未解决,系统面板会同时出现两条「媒体」)
//!
//! Chromium 会为播放中的 `<audio>` 自动再注册一条 SMTC 会话,和本模块并行时
//! 系统面板会出现两条「媒体」。已排除的三条压制路径:
//!
//! - **前端把 `navigator.mediaSession` 置空**:无效。那条会话由浏览器进程按 WebContents
//! 的播放状态创建,**与页面碰不碰 mediaSession 无关**;JS 侧置空只是不再往会话里写
//! 元数据,拦不住它的注册。
//! - **`WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` 环境变量**(关掉 MediaSessionService):
//! 无效。本应用支持永久提权,而提权进程下 WebView2 会忽略所有 WEBVIEW2_* 环境变量
//! (微软文档 *Develop secure WebView2 apps → For an elevated host app*)。
//! - **`tauri.conf.json` 的 `additionalBrowserArgs`**:能关掉 Chromium 那条会话,但代价是
//! 把这个应用的其他窗口一起弄死——参数只落在主窗口,其余弹窗走 wry 默认参数,两者却
//! 共用同一个 EBWebView 用户数据目录。结果是托盘菜单/截图/剪贴板等窗口的页面**永远
//! 不执行 JS**(日志里没有任何 `xxx窗口启动` 记录),因而永远唤不出;启动也会偶发
//! 卡住一两分钟。
//!
//! 根治只能让主窗口不再持有 `<audio>`(播放搬到 Rust 侧):Chromium 无会话可注册,
//! 也就不需要任何浏览器参数。
//!
//! # 线程与套间
//!
//! `SystemMediaTransportControls` 通过
//! [`ISystemMediaTransportControlsInterop::GetForWindow`] 绑定到主窗口 HWND。
//! WinRT 对象要求所在线程已初始化 COM:主线程由 WebView2 完成初始化,而 tokio 工作线程
//! 没有,因此所有 SMTC 调用统一 `run_on_main_thread` 抛到主线程执行
//! (对象本身是 agile 的,跨线程只涉及调用点,不涉及状态迁移)。
//!
//! # 失败策略
//!
//! 系统媒体控件属于「锦上添花」:任何一步失败都只记日志,绝不影响播放本身。
use std::sync::Mutex;
use tauri::{AppHandle, Emitter, Manager};
use windows::core::{factory, HSTRING};
use windows::Foundation::{TimeSpan, TypedEventHandler};
use windows::Media::{
MediaPlaybackStatus, MediaPlaybackType, SystemMediaTransportControls,
SystemMediaTransportControlsButton, SystemMediaTransportControlsButtonPressedEventArgs,
SystemMediaTransportControlsTimelineProperties,
};
use windows::Storage::Streams::RandomAccessStreamReference;
use windows::Win32::Foundation::HWND;
use windows::Win32::System::WinRT::ISystemMediaTransportControlsInterop;
/// 系统媒体控件按钮事件名:前端监听它来执行播放/暂停/切歌/停止。
pub const SMTC_BUTTON_EVENT: &str = "music-smtc-button";
/// 100 纳秒 ticks/秒(WinRT `TimeSpan` 的单位)。
const TICKS_PER_SEC: f64 = 10_000_000.0;
/// SMTC 控制器:惰性绑定主窗口后缓存。
pub struct SmtcController {
ctrl: Mutex<Option<SystemMediaTransportControls>>,
}
impl SmtcController {
pub fn new() -> Self {
Self {
ctrl: Mutex::new(None),
}
}
}
impl Default for SmtcController {
fn default() -> Self {
Self::new()
}
}
/// 秒 → WinRT `TimeSpan`(100ns ticks),负数与非有限值按 0 处理。
fn ticks(sec: f64) -> TimeSpan {
let v = if sec.is_finite() && sec > 0.0 { sec } else { 0.0 };
TimeSpan {
Duration: (v * TICKS_PER_SEC) as i64,
}
}
/// 取(必要时创建)SMTC 控制器。**必须在主线程调用**。
fn ensure_controls(app: &AppHandle) -> Result<SystemMediaTransportControls, String> {
let state = app.state::<SmtcController>();
if let Some(c) = state
.ctrl
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
{
return Ok(c);
}
let window = app.get_webview_window("main").ok_or("主窗口不存在")?;
let hwnd = window.hwnd().map_err(|e| format!("取窗口句柄失败: {e}"))?;
let interop: ISystemMediaTransportControlsInterop =
factory::<SystemMediaTransportControls, ISystemMediaTransportControlsInterop>()
.map_err(|e| format!("取 SMTC 工厂失败: {e}"))?;
// SAFETY: HWND 来自当前进程的真实主窗口,且在调用期间保持有效。
let ctrl: SystemMediaTransportControls = unsafe {
interop
.GetForWindow(HWND(hwnd.0 as isize))
.map_err(|e| format!("SMTC GetForWindow 失败: {e}"))?
};
// 系统侧按钮 → 前端事件(事件可能从任意线程触发,emit 本身线程安全)。
// 注册失败**不**中断初始化:元数据/封面是主要目的,按钮是附加能力。
let emitter = app.clone();
let handler = TypedEventHandler::<
SystemMediaTransportControls,
SystemMediaTransportControlsButtonPressedEventArgs,
>::new(move |_, args| {
if let Some(args) = args.as_ref() {
if let Ok(button) = args.Button() {
let name = if button == SystemMediaTransportControlsButton::Play {
"play"
} else if button == SystemMediaTransportControlsButton::Pause {
"pause"
} else if button == SystemMediaTransportControlsButton::Next {
"next"
} else if button == SystemMediaTransportControlsButton::Previous {
"prev"
} else if button == SystemMediaTransportControlsButton::Stop {
"stop"
} else {
""
};
if !name.is_empty() {
let _ = emitter.emit(SMTC_BUTTON_EVENT, name);
}
}
}
Ok(())
});
if let Err(e) = ctrl.ButtonPressed(&handler) {
crate::logger::log_error("music", &format!("注册 SMTC 按钮事件失败(按钮不可用): {e}"));
}
// 启用按钮(不启用的话系统面板上的按钮是灰的)
let _ = ctrl.SetIsEnabled(true);
let _ = ctrl.SetIsPlayEnabled(true);
let _ = ctrl.SetIsPauseEnabled(true);
let _ = ctrl.SetIsStopEnabled(true);
let _ = ctrl.SetIsNextEnabled(true);
let _ = ctrl.SetIsPreviousEnabled(true);
*state.ctrl.lock().unwrap_or_else(|e| e.into_inner()) = Some(ctrl.clone());
crate::logger::log_info("music", "SMTC 已初始化(原生系统媒体控件已绑定主窗口)");
Ok(ctrl)
}
/// 把一次 SMTC 操作抛到主线程执行;失败只记日志。
fn on_main<F>(app: &AppHandle, what: &'static str, f: F)
where
F: FnOnce(&SystemMediaTransportControls) + Send + 'static,
{
let app = app.clone();
if let Err(e) = app.clone().run_on_main_thread(move || {
match ensure_controls(&app) {
Ok(ctrl) => f(&ctrl),
Err(e) => crate::logger::log_error("music", &format!("SMTC {what} 失败: {e}")),
}
}) {
crate::logger::log_error("music", &format!("SMTC {what} 投递主线程失败: {e}"));
}
}
/// 更新曲目信息:歌名 / 歌手 / 专辑 / 封面。
///
/// 封面**由我们自己下载字节**再写进内存流交给 SMTC:早先让系统按 URI 自行取图
/// (`RandomAccessStreamReference::CreateFromUri`)实测拿不到(本地代理地址与外链都静默失败),
/// 自取字节才能保证取到的是界面上显示的那张图。
///
/// `cover_url` 为空表示该曲目没有封面——此时必须清掉上一次的缩略图,
/// 否则换到无封面的曲子会继续显示上一首的封面。
#[tauri::command]
#[specta::specta]
pub async fn music_smtc_update_metadata(
app: AppHandle,
title: String,
artist: String,
album: String,
cover_url: Option<String>,
) {
// 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑
let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) {
Some(url) => {
let raw = download_cover(url).await;
// SMTC 的缩略图解码器不认 WebP(飞牛封面接口返回的就是 WebP),
// 必须转成 PNG/JPEG,否则 SetThumbnail 静默失败、面板上永远没有封面
let bytes = raw.as_deref().and_then(normalize_cover_format);
// 留痕便于定位「面板上没有封面」到底是没传地址、下载失败还是格式不支持
crate::logger::log_info(
"music",
&format!(
"SMTC 封面: {url} → {}",
match (&raw, &bytes) {
(None, _) => "下载失败".to_string(),
(Some(r), Some(b)) if r.len() == b.len() => format!("{} 字节", r.len()),
(Some(r), Some(b)) => format!("{} 字节 → 转码后 {} 字节", r.len(), b.len()),
(Some(r), None) => format!("{} 字节但无法解码为图片", r.len()),
}
),
);
bytes
}
None => {
crate::logger::log_info("music", "SMTC 封面: 该曲目未提供封面地址");
None
}
};
on_main(&app, "metadata", move |ctrl| {
apply_metadata(ctrl, &title, &artist, &album, cover.as_deref());
});
}
/// 把元数据与封面写进 SMTC(主线程执行)。
fn apply_metadata(
ctrl: &SystemMediaTransportControls,
title: &str,
artist: &str,
album: &str,
cover: Option<&[u8]>,
) {
let Ok(updater) = ctrl.DisplayUpdater() else {
return;
};
// ClearAll 会连元数据一起清,因此无封面时先清再整体重写(顺序不能颠倒)
if cover.is_none() {
let _ = updater.ClearAll();
}
let _ = updater.SetType(MediaPlaybackType::Music);
if let Ok(props) = updater.MusicProperties() {
let _ = props.SetTitle(&HSTRING::from(title));
let _ = props.SetArtist(&HSTRING::from(artist));
let _ = props.SetAlbumTitle(&HSTRING::from(album));
}
if let Some(bytes) = cover {
match stream_reference_from_bytes(bytes) {
Ok(reference) => {
let _ = updater.SetThumbnail(&reference);
}
Err(e) => crate::logger::log_error("music", &format!("设置 SMTC 封面失败: {e}")),
}
}
let _ = updater.Update();
}
/// 把封面字节统一成 SMTC 能解码的格式(PNG)。
///
/// Windows 系统媒体面板的缩略图解码器只认常见位图格式,**不认 WebP**——而飞牛封面接口
/// 返回的正是 WebP(`image/webp`)。不转码的话 `SetThumbnail` 会静默失败,
/// 表现就是「歌名/歌手/专辑都对,就是没有封面」。
/// 已经是 PNG/JPEG 时原样返回,避免无谓的重新编码。
fn normalize_cover_format(bytes: &[u8]) -> Option<Vec<u8>> {
use image::ImageFormat;
match image::guess_format(bytes) {
Ok(ImageFormat::Png) | Ok(ImageFormat::Jpeg) => Some(bytes.to_vec()),
Ok(other) => match image::load_from_memory(bytes) {
Ok(img) => {
let mut out = std::io::Cursor::new(Vec::new());
match img.write_to(&mut out, ImageFormat::Png) {
Ok(()) => Some(out.into_inner()),
Err(e) => {
crate::logger::log_error("music", &format!("封面转 PNG 失败({other:?}): {e}"));
None
}
}
}
Err(e) => {
crate::logger::log_error("music", &format!("封面解码失败({other:?}): {e}"));
None
}
},
Err(e) => {
crate::logger::log_error("music", &format!("无法识别封面格式: {e}"));
None
}
}
}
/// 下载封面图片字节;任何失败都返回 `None`(只记日志,不影响其余元数据)。
async fn download_cover(url: &str) -> Option<Vec<u8>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(10))
.build()
.ok()?;
let resp = match client
.get(url)
.header("User-Agent", "Thing/1.0")
.send()
.await
{
Ok(r) if r.status().is_success() => r,
Ok(r) => {
crate::logger::log_error("music", &format!("封面下载失败(HTTP {}): {url}", r.status()));
return None;
}
Err(e) => {
crate::logger::log_error("music", &format!("封面下载失败({e}): {url}"));
return None;
}
};
match resp.bytes().await {
Ok(b) if !b.is_empty() => Some(b.to_vec()),
Ok(_) => None,
Err(e) => {
crate::logger::log_error("music", &format!("封面读取失败({e}): {url}"));
None
}
}
}
/// 把图片字节写进内存流,并包装成 SMTC 需要的流引用。
fn stream_reference_from_bytes(bytes: &[u8]) -> Result<RandomAccessStreamReference, String> {
use windows::Storage::Streams::{DataWriter, InMemoryRandomAccessStream};
let stream = InMemoryRandomAccessStream::new().map_err(|e| format!("创建内存流失败: {e}"))?;
let output = stream
.GetOutputStreamAt(0)
.map_err(|e| format!("取输出流失败: {e}"))?;
let writer = DataWriter::CreateDataWriter(&output).map_err(|e| format!("创建写入器失败: {e}"))?;
writer
.WriteBytes(bytes)
.map_err(|e| format!("写入封面字节失败: {e}"))?;
// 内存流的异步写入会立刻完成,这里同步等待即可(get() 阻塞至完成)
writer
.StoreAsync()
.map_err(|e| format!("提交封面字节失败: {e}"))?
.get()
.map_err(|e| format!("提交封面字节失败: {e}"))?;
let _ = writer.FlushAsync();
// 读指针回到起点,否则 SMTC 会读到空数据
stream.Seek(0).map_err(|e| format!("复位流失败: {e}"))?;
RandomAccessStreamReference::CreateFromStream(&stream)
.map_err(|e| format!("创建流引用失败: {e}"))
}
/// 更新时长与当前进度(系统面板的进度条)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_position(app: AppHandle, position_sec: f64, duration_sec: f64) {
on_main(&app, "position", move |ctrl| {
let Ok(props) = SystemMediaTransportControlsTimelineProperties::new() else {
return;
};
let duration = ticks(duration_sec);
let _ = props.SetStartTime(ticks(0.0));
let _ = props.SetEndTime(duration);
let _ = props.SetMinSeekTime(ticks(0.0));
let _ = props.SetMaxSeekTime(duration);
let _ = props.SetPosition(ticks(position_sec.min(duration_sec)));
let _ = ctrl.UpdateTimelineProperties(&props);
});
}
/// 更新播放状态(系统面板据此显示播放/暂停按钮)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_playback_state(app: AppHandle, playing: bool) {
on_main(&app, "playback", move |ctrl| {
let status = if playing {
MediaPlaybackStatus::Playing
} else {
MediaPlaybackStatus::Paused
};
let _ = ctrl.SetPlaybackStatus(status);
});
}
/// 停止播放:清空曲目信息并从系统面板移除。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_clear(app: AppHandle) {
on_main(&app, "clear", move |ctrl| {
let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped);
if let Ok(updater) = ctrl.DisplayUpdater() {
let _ = updater.ClearAll();
let _ = updater.Update();
}
});
}