//! 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, read: usize, write: usize, used: usize, } #[derive(Clone)] pub struct RingBuffer { state: Arc<(Mutex, Condvar)>, closed: Arc, } 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, /// clock source 实体(UAC2;None = UAC1) pub clock_entity: Option, /// feature unit 实体(硬件音量用) pub feature_unit: Option, 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>, } 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 { self.fatal.lock().unwrap().clone() } } pub struct EngineHandle { pub stop: Arc, pub state: Arc, pub ring: RingBuffer, pub handle: Arc>, /// libusb context 必须比 handle 活得久(rusb 不会自动保活) _context: Arc, pub config: EngineConfig, pub join: Option>, } 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>, } struct SlotUserData { shared: Arc, buffer: Vec, } struct IsoSlot { transfer: std::ptr::NonNull, user_data: *mut SlotUserData, shared: Arc, 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 { 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, 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::() 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 { 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, control_if: u8, clock_id: u8, ) -> Result { 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, control_if: u8, clock_id: u8, rate: u32, ) -> Result { 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, control_if: u8, fu_id: u8, percent: f32, ) -> Result { 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, handle: Arc>, cfg: EngineConfig, ) -> Result { // ---- 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>, context: Arc, cfg: EngineConfig, ring: RingBuffer, state: Arc, stop: Arc, 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 = Vec::with_capacity(OUT_SLOTS); let mut fb_slots: Vec = 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 = 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, cfg: &EngineConfig, ring: &RingBuffer, state: &Arc, 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, 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, cfg: &EngineConfig, state: &Arc) { // 注意: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), ); }