Files
LFMusic/src-tauri/src/uac/engine.rs
T
2026-09-28 00:20:16 +08:00

1020 lines
37 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! M4-3:UAC isochronous 传输引擎(设计参考 Flick `uac2/android_direct.rs`,简化重构)。
//!
//! 架构:
//! - 解码线程(player.rs)-- PCM 字节 --> 环形缓冲 -- USB 线程取走 --> iso OUT 直写 DAC
//! - 单一 USB 线程跑 `libusb_handle_events`,同时驱动 OUT slot 轮转与 feedback IN 消费
//! - 异步端点:DAC 自报 MCLK(feedback EP),帧率 = fb 值(HS 16.16 / FS 10.10),逐微帧
//! 按 fpf(frames per microframe)小数累加分配包长 → 逐样本 bit-perfect 且不 drift
//! - underrun:提交全零包保时钟,计数并上报
//!
//! 生命周期:`start_engine` 在调用线程完成时钟设置/claim/alt 切换后派生 USB 线程
//! (DeviceHandle 移交进 Arc 共享,同步控制传输与 handle_events 并发是 libusb 文档保证的安全模式)。
//! `stop()` 置位后 USB 线程取消在途传输、alt 0、release 接口、退出。
use libusb1_sys::constants::{
LIBUSB_TRANSFER_CANCELLED, LIBUSB_TRANSFER_COMPLETED, LIBUSB_TRANSFER_ERROR,
LIBUSB_TRANSFER_NO_DEVICE, LIBUSB_TRANSFER_OVERFLOW, LIBUSB_TRANSFER_STALL,
LIBUSB_TRANSFER_TIMED_OUT,
};
use libusb1_sys::libusb_transfer;
use rusb::{DeviceHandle, UsbContext};
use std::sync::atomic::{AtomicBool, AtomicI32, AtomicU64, Ordering};
use std::sync::{Arc, Condvar, Mutex};
use std::time::Duration;
const USB_DIR_IN: u8 = 0x80;
const USB_TYPE_CLASS: u8 = 0x20;
const USB_RECIP_INTERFACE: u8 = 0x01;
const UAC2_REQUEST_SET_CUR: u8 = 0x01;
const UAC2_REQUEST_GET_CUR: u8 = 0x81;
const UAC2_CLOCK_SOURCE_SAM_FREQ_CONTROL: u16 = 0x0100;
#[allow(dead_code)] // UAC2 协议常量,预留(音量走 UAC2_FU_VOLUME_CONTROL)
const UAC2_FEATURE_UNIT: u8 = 0x06;
#[allow(dead_code)]
const UAC2_FU_MUTE_CONTROL: u16 = 0x0100;
const UAC2_FU_VOLUME_CONTROL: u16 = 0x0200;
/// 每个 URB 装多少个 iso 包(对齐 Flick `IsoPacketScheduler::packets_per_transfer`:
/// HS 125µs → 4000/125 = 32;FS ≥1ms → 16)。
///
/// 整块提交的收益:`libusb_submit_transfer` 从 **~8000 次/秒降到 ~250 次/秒**,
/// 主机控制器一次拿到整段时间片原子调度,用户态偶发卡顿不会再在包与包之间
/// 留下声洞(这是与 Flick 在传输层唯一的结构性差异)。
const PACKETS_PER_TRANSFER_HS: usize = 32;
const PACKETS_PER_TRANSFER_FS: usize = 16;
/// 在途 URB 数(Flick `ANDROID_USB_TRANSFER_QUEUE_DEPTH = 4`):
/// 4 × 32 = 128 包 = **16ms** 排队深度,用户态卡 16ms 内都不出声洞。
const OUT_SLOTS: usize = 4;
const FB_SLOTS: usize = 4;
/// 环形缓冲容量(字节):≈ 1s 的 192k/32bit 立体声
const RING_CAP: usize = 1536 * 1024;
/// 起播前预缓冲目标(字节)
const PRIME_BYTES: usize = 256 * 1024;
// ---------------------------------------------------------------------------
// 环形缓冲(Mutex + Condvar,MVP 够用;音频路径每次 memcpy ≤ 包长)
// ---------------------------------------------------------------------------
struct RingState {
buf: Vec<u8>,
read: usize,
write: usize,
used: usize,
}
#[derive(Clone)]
pub struct RingBuffer {
state: Arc<(Mutex<RingState>, Condvar)>,
closed: Arc<AtomicBool>,
}
impl RingBuffer {
fn new(cap: usize) -> Self {
Self {
state: Arc::new((
Mutex::new(RingState { buf: vec![0u8; cap], read: 0, write: 0, used: 0 }),
Condvar::new(),
)),
closed: Arc::new(AtomicBool::new(false)),
}
}
/// 生产者:写满阻塞。返回 false = 缓冲已关闭
pub fn write_all(&self, mut data: &[u8]) -> bool {
let (lock, cv) = &*self.state;
let mut st = lock.lock().unwrap();
while !data.is_empty() {
if self.closed.load(Ordering::Relaxed) {
return false;
}
if st.used == st.buf.len() {
// 满等消费者(2ms 轮询粒度即可,underrun 由引擎侧兜底)
let (g, _t) = cv.wait_timeout(st, Duration::from_millis(2)).unwrap();
st = g;
continue;
}
let write_at = st.write;
let contiguous = st.buf.len() - write_at;
let free = st.buf.len() - st.used;
let n = data.len().min(contiguous).min(free);
st.buf[write_at..write_at + n].copy_from_slice(&data[..n]);
st.write = (write_at + n) % st.buf.len();
st.used += n;
data = &data[n..];
cv.notify_all();
}
true
}
/// 消费者:读走最多 `out.len()` 字节,返回实际读取数(0 = 空)。
/// 必须跨读回绕处拼满——只读连续区会让 `got < want` 被误判成 underrun 并零填充,
/// 在 44.1k/96k 这类包长(40/48/56B 轮转)下读指针必然失对齐,每转一圈断一次。
pub fn read_up_to(&self, out: &mut [u8]) -> usize {
let (lock, cv) = &*self.state;
let mut st = lock.lock().unwrap();
if st.used == 0 {
return 0;
}
let mut total = 0usize;
while total < out.len() && st.used > 0 {
let read_at = st.read;
let contiguous = st.buf.len() - read_at;
let n = (out.len() - total).min(st.used).min(contiguous);
out[total..total + n].copy_from_slice(&st.buf[read_at..read_at + n]);
st.read = (read_at + n) % st.buf.len();
st.used -= n;
total += n;
}
cv.notify_all();
total
}
pub fn used(&self) -> usize {
self.state.0.lock().unwrap().used
}
pub fn close(&self) {
self.closed.store(true, Ordering::Relaxed);
self.state.1.notify_all();
}
}
// ---------------------------------------------------------------------------
// 引擎配置与状态
// ---------------------------------------------------------------------------
#[derive(Clone, Debug)]
pub struct EngineConfig {
pub control_interface: u8,
pub streaming_interface: u8,
pub alt_setting: u8,
pub endpoint_address: u8,
pub max_packet_bytes: u16,
/// 显式 feedback IN EP(如 0x81);None = 非 async 端点
pub feedback_address: Option<u8>,
/// clock source 实体(UAC2;None = UAC1)
pub clock_entity: Option<u8>,
/// feature unit 实体(硬件音量用)
pub feature_unit: Option<u8>,
pub sample_rate: u32,
pub channels: u8,
/// PCM 子槽字节数 2/3/4
pub subslot_size: u8,
}
/// 引擎运行状态(前端可见)
#[derive(Debug)]
pub struct EngineState {
pub playing: AtomicBool,
/// 已解码帧数(解码线程推进,用于进度)
pub decoded_frames: AtomicU64,
/// 已提交帧数
pub sent_frames: AtomicU64,
pub underruns: AtomicU64,
/// 当前 fpf × 1000(反馈实测帧率/微帧;i32 传 f32)
pub fpf_milli: AtomicI32,
/// 0=none 1=prime 2=play 3=end 4=stopped 5=error
pub phase: AtomicI32,
/// 解码端已完成(EOF/出错)——USB 线程见缓冲排空后自然收尾
pub decoder_done: AtomicBool,
/// 暂停:USB 线程照常提交静音包(保 DAC 时钟),解码端冻结(ring 满阻塞)
pub paused: AtomicBool,
pub fatal: Mutex<Option<String>>,
}
impl EngineState {
fn new() -> Self {
Self {
playing: AtomicBool::new(false),
decoded_frames: AtomicU64::new(0),
sent_frames: AtomicU64::new(0),
underruns: AtomicU64::new(0),
fpf_milli: AtomicI32::new(0),
phase: AtomicI32::new(0),
decoder_done: AtomicBool::new(false),
paused: AtomicBool::new(false),
fatal: Mutex::new(None),
}
}
pub fn error(&self) -> Option<String> {
self.fatal.lock().unwrap().clone()
}
}
pub struct EngineHandle {
pub stop: Arc<AtomicBool>,
pub state: Arc<EngineState>,
pub ring: RingBuffer,
pub handle: Arc<DeviceHandle<rusb::Context>>,
/// libusb context 必须比 handle 活得久(rusb 不会自动保活)
_context: Arc<rusb::Context>,
pub config: EngineConfig,
pub join: Option<std::thread::JoinHandle<()>>,
}
impl EngineHandle {
pub fn request_stop(&self) {
self.stop.store(true, Ordering::Relaxed);
self.ring.close();
}
}
// ---------------------------------------------------------------------------
// libusb iso slot(1 包/transfer)
// ---------------------------------------------------------------------------
struct SlotShared {
status: Mutex<Option<i32>>,
}
struct SlotUserData {
shared: Arc<SlotShared>,
buffer: Vec<u8>,
}
struct IsoSlot {
transfer: std::ptr::NonNull<libusb_transfer>,
user_data: *mut SlotUserData,
shared: Arc<SlotShared>,
in_flight: bool,
}
unsafe impl Send for IsoSlot {}
impl IsoSlot {
/// `n_packets` = 本 URB 含几个 iso 包;`buffer_size` = 所有包数据的总缓冲
fn new(n_packets: usize, buffer_size: usize) -> Result<Self, String> {
let shared = Arc::new(SlotShared { status: Mutex::new(None) });
let user_data = Box::into_raw(Box::new(SlotUserData {
shared: shared.clone(),
buffer: vec![0u8; buffer_size],
}));
let transfer = unsafe { libusb1_sys::libusb_alloc_transfer(n_packets as i32) };
let Some(ptr) = std::ptr::NonNull::new(transfer) else {
unsafe { drop(Box::from_raw(user_data)) };
return Err("libusb_alloc_transfer 失败".into());
};
Ok(Self { transfer: ptr, user_data, shared, in_flight: false })
}
/// 提交整个 URB:`lens` 是每个 iso 包的字节长度(数据已按顺序写进内部缓冲)。
/// `transfer->length` = 各包之和,内核按 `iso_packet_desc[i].length` 逐包切分。
unsafe fn submit(
&mut self,
handle: &DeviceHandle<impl UsbContext>,
endpoint: u8,
lens: &[usize],
) -> Result<(), String> {
if lens.is_empty() {
return Ok(());
}
let ud = &mut *self.user_data;
*ud.shared.status.lock().unwrap() = None;
let total: i32 = lens.iter().sum::<usize>() as i32;
let t = self.transfer.as_mut();
libusb1_sys::libusb_fill_iso_transfer(
t,
handle.as_raw(),
endpoint,
ud.buffer.as_mut_ptr(),
total,
lens.len() as i32,
iso_callback,
self.user_data.cast(),
0, // iso 不超时(超时反而制造停顿;靠 stop 标志取消)
);
let base = t.iso_packet_desc.as_mut_ptr();
for (i, &l) in lens.iter().enumerate() {
(*base.add(i)).length = l as u32;
}
let rc = libusb1_sys::libusb_submit_transfer(self.transfer.as_ptr());
if rc != 0 {
return Err(format!("libusb_submit_transfer({endpoint:#04x}) = {rc}"));
}
self.in_flight = true;
Ok(())
}
fn take_status(&mut self) -> Option<i32> {
self.shared.status.lock().unwrap().take()
}
/// 取内部缓冲引用(填充数据用)
fn buffer_mut(&mut self) -> &mut [u8] {
unsafe { &mut (*self.user_data).buffer }
}
unsafe fn cancel(&mut self) {
if self.in_flight {
let _ = libusb1_sys::libusb_cancel_transfer(self.transfer.as_ptr());
}
}
fn free(&mut self) {
if !self.in_flight {
unsafe {
libusb1_sys::libusb_free_transfer(self.transfer.as_ptr());
drop(Box::from_raw(self.user_data));
}
}
}
}
extern "system" fn iso_callback(transfer: *mut libusb_transfer) {
let t = unsafe { &*transfer };
let ud = unsafe { &*(t.user_data as *mut SlotUserData) };
let mut status = ud.shared.status.lock().unwrap();
*status = Some(t.status as i32);
}
fn status_label(s: i32) -> &'static str {
match s {
LIBUSB_TRANSFER_COMPLETED => "completed",
LIBUSB_TRANSFER_CANCELLED => "cancelled",
LIBUSB_TRANSFER_NO_DEVICE => "no-device",
LIBUSB_TRANSFER_ERROR => "error",
LIBUSB_TRANSFER_TIMED_OUT => "timeout",
LIBUSB_TRANSFER_STALL => "stall",
LIBUSB_TRANSFER_OVERFLOW => "overflow",
_ => "other",
}
}
// ---------------------------------------------------------------------------
// 时钟 / 音量(引擎启动前 + 播放中经共享 handle)
// ---------------------------------------------------------------------------
/// Flick `ANDROID_USB_CLOCK_SETTLE_DELAY_MS_DEFAULT`:SET_CUR 后要等固件/PLL
/// 生效再读回,立刻 GET_CUR 会读到旧值。
const CLOCK_SETTLE_MS: u64 = 20;
const CLOCK_SET_ATTEMPTS: u32 = 3;
/// 读回 clock 当前采样率(UAC2 SAM_FREQ GET_CUR)。
fn read_clock_rate(
handle: &DeviceHandle<impl UsbContext>,
control_if: u8,
clock_id: u8,
) -> Result<u32, String> {
let windex = ((clock_id as u16) << 8) | control_if as u16;
let mut buf = [0u8; 4];
let n = handle
.read_control(
USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, // 0xA1
UAC2_REQUEST_GET_CUR,
UAC2_CLOCK_SOURCE_SAM_FREQ_CONTROL,
windex,
&mut buf,
Duration::from_secs(1),
)
.map_err(|e| format!("GET_CUR(采样率) 失败: {e}"))?;
if n != 4 {
return Err(format!("GET_CUR(采样率) 返回 {n} 字节"));
}
Ok(u32::from_le_bytes(buf))
}
/// SET_CUR 设置采样率 → settle → GET_CUR 校验,未确认则重试(与 Flick
/// `apply_sampling_frequency` 同口径)。SET_CUR 始终无条件下发:本固件
/// GET_CUR 会回显写入值,不能当作"时钟已切换"的证据。
pub fn set_clock_rate(
handle: &DeviceHandle<impl UsbContext>,
control_if: u8,
clock_id: u8,
rate: u32,
) -> Result<u32, String> {
let windex = ((clock_id as u16) << 8) | control_if as u16;
let data = rate.to_le_bytes();
let mut last_err = format!("SET_CUR(采样率 {rate}) 未执行");
for attempt in 1..=CLOCK_SET_ATTEMPTS {
match handle.write_control(
USB_TYPE_CLASS | USB_RECIP_INTERFACE, // 0x21
UAC2_REQUEST_SET_CUR,
UAC2_CLOCK_SOURCE_SAM_FREQ_CONTROL,
windex,
&data,
Duration::from_secs(1),
) {
Ok(_) => {}
Err(e) => {
last_err = format!("SET_CUR(采样率 {rate}) 失败: {e}");
std::thread::sleep(Duration::from_millis(CLOCK_SETTLE_MS));
continue;
}
}
std::thread::sleep(Duration::from_millis(CLOCK_SETTLE_MS));
match read_clock_rate(handle, control_if, clock_id) {
Ok(reported) => {
if reported == rate {
return Ok(reported);
}
last_err = format!("时钟校验失败:请求 {rate},设备报 {reported}");
}
Err(e) => last_err = e,
}
if attempt < CLOCK_SET_ATTEMPTS {
println!(
"[uac-engine] 时钟 SET_CUR 第 {attempt}/{CLOCK_SET_ATTEMPTS} 次未确认({last_err}),重试"
);
std::thread::sleep(Duration::from_millis(CLOCK_SETTLE_MS));
}
}
Err(last_err)
}
/// 硬件音量:读 FU VOLUME GET_RANGE,按百分比设置(signed 16bit,单位无关)
pub fn set_hardware_volume(
handle: &DeviceHandle<impl UsbContext>,
control_if: u8,
fu_id: u8,
percent: f32,
) -> Result<i16, String> {
let windex = ((fu_id as u16) << 8) | control_if as u16;
let mut buf = [0u8; 2 + 6 * 64];
let n = handle
.read_control(
USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
0x02, // GET_RANGE
UAC2_FU_VOLUME_CONTROL,
windex,
&mut buf,
Duration::from_secs(1),
)
.map_err(|e| format!("音量 GET_RANGE 失败: {e}"))?;
if n < 8 {
return Err(format!("音量 GET_RANGE 响应过短: {n}"));
}
let count = u16::from_le_bytes([buf[0], buf[1]]) as usize;
if count == 0 {
return Err("音量 GET_RANGE 零子区间".into());
}
let min = i16::from_le_bytes([buf[2], buf[3]]);
let max = i16::from_le_bytes([buf[2 + 6], buf[3 + 6]]);
let pct = percent.clamp(0.0, 1.0);
let value = (min as f32 + (max as i32 - min as i32) as f32 * pct) as i16;
handle
.write_control(
USB_TYPE_CLASS | USB_RECIP_INTERFACE,
UAC2_REQUEST_SET_CUR,
UAC2_FU_VOLUME_CONTROL,
windex,
&value.to_le_bytes(),
Duration::from_secs(1),
)
.map_err(|e| format!("音量 SET_CUR 失败: {e}"))?;
Ok(value)
}
// ---------------------------------------------------------------------------
// 引擎启动
// ---------------------------------------------------------------------------
pub fn start_engine(
context: Arc<rusb::Context>,
handle: Arc<DeviceHandle<rusb::Context>>,
cfg: EngineConfig,
) -> Result<EngineHandle, String> {
// ---- 1. claim 流接口 + 控制接口(时钟/音量请求走控制接口) ----
handle
.claim_interface(cfg.control_interface)
.map_err(|e| format!("claim 控制接口 {} 失败: {e}", cfg.control_interface))?;
handle
.claim_interface(cfg.streaming_interface)
.map_err(|e| format!("claim 流接口 {} 失败: {e}", cfg.streaming_interface))?;
// ---- 2. 复位 alt 0 → 设时钟 → 切 alt → alt 生效后复验时钟 ----
handle
.set_alternate_setting(cfg.streaming_interface, 0)
.map_err(|e| format!("复位 alt 0 失败: {e}"))?;
std::thread::sleep(Duration::from_millis(100));
if let Some(clock_id) = cfg.clock_entity {
let reported = set_clock_rate(&handle, cfg.control_interface, clock_id, cfg.sample_rate)?;
println!("[uac-engine] 时钟 {reported}Hz 已锁定并校验");
}
handle
.set_alternate_setting(cfg.streaming_interface, cfg.alt_setting)
.map_err(|e| format!("切换 alt {} 失败: {e}", cfg.alt_setting))?;
std::thread::sleep(Duration::from_millis(50));
// 切 alt 会把时钟打回默认值(Flick android_direct 明确处理了这一条:
// "DAC clock drifted after alt-setting change"),而本固件 GET_CUR 会回显
// 写入值、读回"成功"并不可信——所以无条件在 alt 生效后重设一次。
if let Some(clock_id) = cfg.clock_entity {
if let Ok(post) = read_clock_rate(&handle, cfg.control_interface, clock_id) {
if post != cfg.sample_rate {
println!(
"[uac-engine] alt{} 切换后时钟漂移:{post}Hz ≠ {}Hz,已重设",
cfg.alt_setting, cfg.sample_rate
);
}
}
set_clock_rate(&handle, cfg.control_interface, clock_id, cfg.sample_rate)?;
}
// ---- 3. 清 halt ----
let _ = handle.clear_halt(cfg.endpoint_address);
if let Some(fb) = cfg.feedback_address {
let _ = handle.clear_halt(fb);
}
// ---- 4. 速度与微帧周期(HS=125µs/8000,FS 及以下=1ms/1000) ----
let speed = handle.device().speed();
let high_speed = matches!(
speed,
rusb::Speed::High | rusb::Speed::Super | rusb::Speed::SuperPlus
);
let microframes_per_sec: u32 = if high_speed { 8000 } else { 1000 };
let fb_shift: u32 = if high_speed { 16 } else { 10 };
let fb_bytes: usize = if high_speed { 4 } else { 3 };
println!(
"[uac-engine] speed={speed:?} high_speed={high_speed} alt={} rate={} ch={} subslot={}",
cfg.alt_setting, cfg.sample_rate, cfg.channels, cfg.subslot_size
);
let bytes_per_frame = cfg.channels as usize * cfg.subslot_size as usize;
if bytes_per_frame == 0 || bytes_per_frame > cfg.max_packet_bytes as usize {
return Err(format!(
"非法帧长: ch={} subslot={} maxPacket={}",
cfg.channels, cfg.subslot_size, cfg.max_packet_bytes
));
}
let base_fpf = cfg.sample_rate as f64 / microframes_per_sec as f64;
if base_fpf * bytes_per_frame as f64 > cfg.max_packet_bytes as f64 {
return Err(format!(
"带宽不足: {base_fpf}帧/微帧 × {bytes_per_frame}B > maxPacket {}",
cfg.max_packet_bytes
));
}
// ---- 5. 组装引擎句柄与线程 ----
let state = Arc::new(EngineState::new());
let ring = RingBuffer::new(RING_CAP);
let stop = Arc::new(AtomicBool::new(false));
let shared_handle = handle;
let join = {
let state = state.clone();
let ring = ring.clone();
let stop = stop.clone();
let handle = shared_handle.clone();
let context2 = context.clone();
let cfg2 = cfg.clone();
std::thread::Builder::new()
.name("uac-usb".into())
.spawn(move || usb_loop(handle, context2, cfg2, ring, state, stop, base_fpf, fb_shift, fb_bytes))
.map_err(|e| format!("派生 USB 线程失败: {e}"))?
};
Ok(EngineHandle {
stop,
state,
ring,
handle: shared_handle,
_context: context,
config: cfg,
join: Some(join),
})
}
/// USB 主循环:handle_events 驱动 OUT 轮转 + feedback 消费
#[allow(clippy::too_many_arguments)]
fn usb_loop(
handle: Arc<DeviceHandle<rusb::Context>>,
context: Arc<rusb::Context>,
cfg: EngineConfig,
ring: RingBuffer,
state: Arc<EngineState>,
stop: Arc<AtomicBool>,
base_fpf: f64,
fb_shift: u32,
fb_bytes: usize,
) {
state.phase.store(1, Ordering::Relaxed); // prime
println!("[uac-engine] 等待预缓冲 {} 字节…", PRIME_BYTES);
while !stop.load(Ordering::Relaxed) {
if ring.used() >= PRIME_BYTES {
break;
}
// 解码端已收尾但剩余不足一整个预缓冲(起播点靠近曲尾 / 短音频):
// 继续等只会永远卡在 prime,这里按现有数据直接起播
if state.decoder_done.load(Ordering::Relaxed) && ring.used() > 0 {
break;
}
std::thread::sleep(Duration::from_millis(5));
}
if stop.load(Ordering::Relaxed) {
finish_loop(&handle, &cfg, &state);
return;
}
let mut out_slots: Vec<IsoSlot> = Vec::with_capacity(OUT_SLOTS);
let mut fb_slots: Vec<IsoSlot> = Vec::with_capacity(FB_SLOTS);
let max_packet = cfg.max_packet_bytes as usize;
// 每个 URB 装几个 iso 包(fb_bytes: 4=HS 125µs / 3=FS 1ms)
let packets_per_transfer = if fb_bytes == 4 {
PACKETS_PER_TRANSFER_HS
} else {
PACKETS_PER_TRANSFER_FS
};
let out_buffer = packets_per_transfer * max_packet;
println!(
"[uac-engine] URB 批量: {OUT_SLOTS} 个 × {packets_per_transfer} 包(排队深度 {}ms)",
OUT_SLOTS * packets_per_transfer * 1000 / (if fb_bytes == 4 { 8000 } else { 1000 })
);
for _ in 0..OUT_SLOTS {
match IsoSlot::new(packets_per_transfer, out_buffer) {
Ok(s) => out_slots.push(s),
Err(e) => {
set_fatal(&state, e);
finish_loop(&handle, &cfg, &state);
return;
}
}
}
if cfg.feedback_address.is_some() {
for _ in 0..FB_SLOTS {
// feedback 包很小(3/4B),缓冲取 max(fb_bytes, 4);单包 URB
match IsoSlot::new(1, fb_bytes.max(4)) {
Ok(s) => fb_slots.push(s),
Err(e) => {
set_fatal(&state, e);
finish_loop(&handle, &cfg, &state);
return;
}
}
}
}
// 首轮提交 feedback 读
if let Some(fb_ep) = cfg.feedback_address {
for slot in fb_slots.iter_mut() {
unsafe {
if let Err(e) = slot.submit(&handle, fb_ep, &[fb_bytes]) {
set_fatal(&state, format!("feedback 提交失败: {e}"));
finish_loop(&handle, &cfg, &state);
return;
}
}
}
}
// 帧率分配器
let mut carry = 0.0f64;
let mut fpf = base_fpf;
let mut _fb_samples = 0u64; // 采纳计数(调试观测用,暂不读取)
let mut fb_ema = base_fpf;
// 拆流前淡出窗口:HS 125µs/包 → 24 包 ≈ 3ms;FS 1ms/包 → 4 包 ≈ 4ms
let mut fade = Fade::new(if fb_bytes == 4 { 24 } else { 4 });
state.playing.store(true, Ordering::Relaxed);
state.phase.store(2, Ordering::Relaxed); // play
println!("[uac-engine] iso 流启动");
// 首轮提交 OUT
for slot in out_slots.iter_mut() {
if let Err(e) = fill_and_submit(
slot, &handle, &cfg, &ring, &state, &mut carry, &mut fpf, base_fpf, &mut fade,
packets_per_transfer,
) {
set_fatal(&state, e);
break;
}
}
let mut fatal: Option<String> = None;
while fatal.is_none() {
if stop.load(Ordering::Relaxed) {
// 手动停止/切歌:先把正在送的音频斜坡到 0,再收尾,
// 否则取消在途 URB + 切 alt0 会在满幅处硬切出一声 pop
fade.trigger();
if fade.done() {
break;
}
} else if state.decoder_done.load(Ordering::Relaxed) && ring.used() == 0 {
break;
}
if let Err(e) = context.handle_events(Some(Duration::from_millis(50))) {
fatal = Some(format!("handle_events: {e}"));
break;
}
// 注意:**本线程是实时线程,禁止周期性 println/eprintln**——
// 打日志会被 logcat 拖住,实测一次卡 2.4ms、少提交 106 帧。
// 诊断信息一律攒到收尾一次性打(见下方 fb 采纳统计)。
// feedback 完成 → 更新 fpf
if let Some(fb_ep) = cfg.feedback_address {
for slot in fb_slots.iter_mut() {
let Some(status) = slot.take_status() else { continue };
slot.in_flight = false;
if status != LIBUSB_TRANSFER_COMPLETED {
if status == LIBUSB_TRANSFER_NO_DEVICE {
fatal = Some("USB DAC 已断开".into());
break;
}
// feedback 单次失败容忍(stall 等),继续重交
state.underruns.fetch_add(0, Ordering::Relaxed);
} else {
let buf = slot.buffer_mut();
let raw = if fb_bytes == 4 {
u32::from_le_bytes([buf[0], buf[1], buf[2], buf[3]]) as f64
} else {
(u32::from_le_bytes([0, buf[0], buf[1], buf[2]]) >> 8) as f64
};
let measured = raw / (1u64 << fb_shift) as f64;
// 合理性:±3% 以内才采纳(async DAC 真实波动仅 ±ppm 级;
// 曾用 ±20% 导致偶发坏读数把 EMA 带偏 → 包长错 → 突然静音)
if measured > base_fpf * 0.97 && measured < base_fpf * 1.03 {
_fb_samples += 1;
fb_ema = if fb_ema == base_fpf {
measured
} else {
fb_ema + (measured - fb_ema) * 0.1
};
fpf = fb_ema;
state
.fpf_milli
.store((fpf * 1000.0) as i32, Ordering::Relaxed);
}
}
unsafe {
if let Err(e) = slot.submit(&handle, fb_ep, &[fb_bytes]) {
fatal = Some(format!("feedback 重交失败: {e}"));
break;
}
}
}
}
if fatal.is_some() {
break;
}
// OUT 完成 → 回填重交
for slot in out_slots.iter_mut() {
let Some(status) = slot.take_status() else { continue };
slot.in_flight = false;
match status {
LIBUSB_TRANSFER_COMPLETED => {}
LIBUSB_TRANSFER_CANCELLED => continue,
LIBUSB_TRANSFER_NO_DEVICE => {
fatal = Some("USB DAC 已断开".into());
break;
}
other => {
fatal = Some(format!("iso OUT 状态异常: {}({other})", status_label(other)));
break;
}
}
if let Err(e) = fill_and_submit(
slot, &handle, &cfg, &ring, &state, &mut carry, &mut fpf, base_fpf, &mut fade,
packets_per_transfer,
) {
fatal = Some(e);
break;
}
}
}
let had_fatal = fatal.is_some();
if let Some(e) = fatal {
set_fatal(&state, e);
}
state.playing.store(false, Ordering::Relaxed);
state.phase.store(if stop.load(Ordering::Relaxed) { 4 } else { 3 }, Ordering::Relaxed);
// 淡出包已经在途:先让它们**真正发完**再取消,否则 cancel 会把淡出也切掉
if !had_fatal {
let fade_deadline = std::time::Instant::now() + Duration::from_millis(40);
loop {
if !out_slots.iter().any(|s| s.in_flight)
|| std::time::Instant::now() >= fade_deadline
{
break;
}
let _ = context.handle_events(Some(Duration::from_millis(2)));
for slot in out_slots.iter_mut() {
if slot.in_flight && slot.take_status().is_some() {
slot.in_flight = false;
}
}
}
}
// 取消在途传输 → 等 CANCELLED → 释放 slot(transfer/buffer)
for slot in out_slots.iter_mut().chain(fb_slots.iter_mut()) {
unsafe { slot.cancel() };
}
let deadline = std::time::Instant::now() + Duration::from_millis(300);
while std::time::Instant::now() < deadline {
let mut any_in_flight = false;
for slot in out_slots.iter_mut().chain(fb_slots.iter_mut()) {
if slot.in_flight {
if slot.take_status().is_some() {
slot.in_flight = false;
} else {
any_in_flight = true;
}
}
}
if !any_in_flight {
break;
}
let _ = context.handle_events(Some(Duration::from_millis(20)));
}
for slot in out_slots.iter_mut().chain(fb_slots.iter_mut()) {
slot.free();
}
finish_loop(&handle, &cfg, &state);
println!("[uac-engine] USB 线程退出");
}
/// 拆流前的淡出:把正在送的样本斜坡到 0 再 cancel,否则 DAC 收到最后一个
/// 满幅包后被立刻切掉(alt0/取消在途 URB),会 pop 一声——切歌和播完都有。
struct Fade {
/// 本次淡出的总包数(HS 125µs/包,24 ≈ 3ms;FS 1ms/包,4 ≈ 4ms)
total: u32,
triggered: bool,
left: u32,
/// 已经送出过全零包(可以收尾了)
zeroed: bool,
}
impl Fade {
fn new(total: u32) -> Self {
Self { total: total.max(1), triggered: false, left: 0, zeroed: false }
}
/// 进入淡出(只触发一次)
fn trigger(&mut self) {
if self.triggered {
return;
}
self.triggered = true;
self.left = self.total;
self.zeroed = false;
}
/// 最后一个全零包已经交出去了 → 可以收尾
fn done(&self) -> bool {
self.triggered && self.zeroed
}
/// 取本包增益并推进斜坡:left=total 时 1.0,线性降到 0 后保持 0
fn step(&mut self) -> f32 {
if !self.triggered {
return 1.0;
}
if self.left == 0 {
self.zeroed = true;
return 0.0;
}
let g = self.left as f32 / self.total as f32;
self.left -= 1;
g
}
}
/// 按增益对 PCM 缓冲做线性缩放(16/24/32bit LE 有符号,按 subslot 对齐)
fn fade_buffer(buf: &mut [u8], gain: f32, subslot: u8, channels: u8) {
if gain >= 1.0 {
return;
}
if gain <= 0.0 {
for b in buf.iter_mut() {
*b = 0;
}
return;
}
let ss = subslot as usize;
let bpf = ss * channels as usize;
if ss == 0 || bpf == 0 {
return;
}
let bits = ss * 8;
for frame in buf.chunks_exact_mut(bpf) {
for sample in frame.chunks_exact_mut(ss) {
let mut v: i64 = 0;
for (i, b) in sample.iter().enumerate() {
v |= (*b as i64) << (8 * i);
}
if v & (1i64 << (bits - 1)) != 0 {
v |= -1i64 << bits; // 符号扩展
}
let scaled = (v as f64 * gain as f64).round() as i64;
for (i, b) in sample.iter_mut().enumerate() {
*b = ((scaled >> (8 * i)) & 0xff) as u8;
}
}
}
}
/// 从环形缓冲取数据,一次性填满**整个 URB**(`n_packets` 个 iso 包)并提交。
/// 与 Flick 同口径:一个 URB 覆盖一段时间片,`submit_transfer` 次数降到 1/n,
/// 主机控制器可原子调度整块时间片。
#[allow(clippy::too_many_arguments)]
fn fill_and_submit(
slot: &mut IsoSlot,
handle: &DeviceHandle<rusb::Context>,
cfg: &EngineConfig,
ring: &RingBuffer,
state: &Arc<EngineState>,
carry: &mut f64,
fpf: &mut f64,
base_fpf: f64,
fade: &mut Fade,
n_packets: usize,
) -> Result<(), String> {
// 反馈漂移保护:fpf 跑飞则回退标称值(下轮 feedback 再修正)
let f = *fpf;
if !(base_fpf * 0.5..=base_fpf * 1.5).contains(&f) {
*fpf = base_fpf;
}
let bpf = cfg.channels as usize * cfg.subslot_size as usize;
let max_frames = cfg.max_packet_bytes as usize / bpf;
if bpf == 0 || max_frames == 0 || n_packets == 0 {
return Err("非法帧长/包数".into());
}
// 逐包算长度:carry 跨包累积,与原来"每微帧一次"的算法等价
let mut lens = Vec::with_capacity(n_packets);
let mut want = 0usize;
for _ in 0..n_packets {
*carry += *fpf;
let mut frames = *carry as u64;
*carry -= frames as f64;
frames = frames.min(max_frames as u64).max(1);
let l = frames as usize * bpf;
lens.push(l);
want += l;
}
let per_packet = want / n_packets;
// 曲尾:缓冲剩余撑不满整个淡出窗口(按单包折算)→ 开始斜坡
if !fade.triggered
&& state.decoder_done.load(Ordering::Relaxed)
&& ring.used() <= per_packet.saturating_mul(fade.total as usize)
{
fade.trigger();
}
let buf = slot.buffer_mut();
if state.paused.load(Ordering::Relaxed) {
// 暂停:静音保时钟;解码端因 ring 停滞自然冻结
for b in buf[..want].iter_mut() {
*b = 0;
}
} else {
let got = ring.read_up_to(&mut buf[..want]);
if got < want {
state.underruns.fetch_add(1, Ordering::Relaxed);
for b in buf[got..want].iter_mut() {
*b = 0;
}
}
}
// 淡出增益**按微帧包**推进(一个 URB 内部也能走完整条斜坡,
// 24 包 < 32 包,所以斜坡一定在本 URB 内完成)
let mut off = 0usize;
for &l in &lens {
let g = fade.step();
if g < 1.0 {
fade_buffer(&mut buf[off..off + l], g, cfg.subslot_size, cfg.channels);
}
off += l;
}
state.sent_frames.fetch_add((want / bpf) as u64, Ordering::Relaxed);
unsafe { slot.submit(handle, cfg.endpoint_address, &lens) }
}
fn set_fatal(state: &Arc<EngineState>, e: String) {
eprintln!("[uac-engine] 致命错误: {e}");
*state.fatal.lock().unwrap() = Some(e);
state.phase.store(5, Ordering::Relaxed);
}
/// 收尾:取消在途传输 → 等 CANCELLED → alt 0 → release → 显式重挂内核驱动
fn finish_loop(handle: &DeviceHandle<rusb::Context>, cfg: &EngineConfig, state: &Arc<EngineState>) {
// 注意:slot 生命周期在 usb_loop 栈上,此处只能通过 handle 做设备级复位;
// 取消逻辑由 usb_loop 结束前处理(cancel + drain),这里做接口复位。
let _ = handle.set_alternate_setting(cfg.streaming_interface, 0);
for ifn in [cfg.streaming_interface, cfg.control_interface] {
let _ = handle.release_interface(ifn);
// auto_detach 模式下 libusb 会自动重挂内核驱动;这里显式补一次(已挂会 Busy,忽略),
// 目的:让 Android 系统 USB 音频(snd-usb-audio)尽早恢复
match handle.attach_kernel_driver(ifn) {
Ok(()) => println!("[uac-engine] 内核驱动已重挂 if{ifn}(系统音频恢复)"),
Err(rusb::Error::Busy) => {}
Err(rusb::Error::NotSupported) => {}
Err(e) => println!("[uac-engine] 重挂内核驱动 if{ifn}: {e}"),
}
}
println!(
"[uac-engine] 已释放接口(sent={} underruns={})",
state.sent_frames.load(Ordering::Relaxed),
state.underruns.load(Ordering::Relaxed),
);
}