1020 lines
37 KiB
Rust
1020 lines
37 KiB
Rust
//! 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),
|
||
);
|
||
}
|