细节调整
This commit is contained in:
1 parent
bccd21fde5
commit
79bded1cd2
25 files changed
+2655
-494
No files matched your search
@@ -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())
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
});
|
||||
}
|
||||
Reference in new issue
Block a user