Skip to content

Commit 3995aa8

Browse files
committed
优化双声道频谱按需计算
1 parent 3459a8f commit 3995aa8

7 files changed

Lines changed: 142 additions & 106 deletions

File tree

‎native/audio-engine/src/decoder.rs‎

Lines changed: 12 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -23,13 +23,10 @@ const AVERROR_EIO: i32 = sys::averror(libc::EIO);
2323

2424
/// 解码会话所需的资源(跨 seek 复用,避免重建 ffmpeg_audio 上下文)
2525
///
26-
/// 1-to-N 分发:同一帧零拷贝喂给两个重采样器
27-
/// - player_resampler: 48k stereo f32,给 rodio 播放
28-
/// - fft_resampler: 48k stereo f32,给 FFT 频谱分析
26+
/// 播放重采样器输出设备采样率的 stereo f32,FFT 按需复用这份 PCM
2927
pub struct DecoderData {
3028
reader: AudioReader,
3129
player_resampler: Resampler,
32-
fft_resampler: Resampler,
3330
/// 中断标志:仅网络源持有;本地 File 不会长时间阻塞,没必要绑
3431
/// 通过 shared.bind_interrupt 注入,外部 stop() 触发后 HttpRangeSource::read 会返回 Interrupted
3532
interrupt_flag: Option<Arc<AtomicBool>>,
@@ -38,7 +35,7 @@ pub struct DecoderData {
3835
impl DecoderData {
3936
/// 在已有 reader 上 seek,失败时调用方应回退到完整 load
4037
///
41-
/// seek 后两个重采样器要 flush 掉残留样本,否则播放/FFT 会带上上一段尾巴
38+
/// seek 后重采样器要 flush 掉残留样本,否则播放会带上上一段尾巴
4239
pub fn seek(&mut self, position_secs: f64) -> bool {
4340
if self
4441
.reader
@@ -48,7 +45,6 @@ impl DecoderData {
4845
return false;
4946
}
5047
let _ = self.player_resampler.flush();
51-
let _ = self.fft_resampler.flush();
5248
true
5349
}
5450

@@ -79,8 +75,7 @@ pub fn start_decode(
7975
) -> Result<(AudioMetadata, JoinHandle<DecoderData>)> {
8076
// 播放重采样目标 = 输出设备原生采样率
8177
let target_rate = shared.sample_rate();
82-
let (reader, player_resampler, fft_resampler, interrupt_flag) =
83-
open_source(source, target_rate)?;
78+
let (reader, player_resampler, interrupt_flag) = open_source(source, target_rate)?;
8479
if let Some(ref flag) = interrupt_flag {
8580
shared.bind_interrupt(Arc::clone(flag));
8681
}
@@ -125,7 +120,6 @@ pub fn start_decode(
125120
let data = DecoderData {
126121
reader,
127122
player_resampler,
128-
fft_resampler,
129123
interrupt_flag,
130124
};
131125

@@ -167,13 +161,11 @@ pub fn resume_decode(data: DecoderData, shared: Arc<Shared>) -> Result<JoinHandl
167161

168162
/// 根据 source 协议打开音频:http(s) 走 HttpRangeSource + 拿 cancel flag,其他走本地 File
169163
///
170-
/// `target_rate` 为播放重采样目标采样率(输出设备原生采样率);FFT 路径固定 48000
171-
///
172-
/// 返回 (reader, 播放重采样器, FFT 重采样器, cancel 标志)
164+
/// `target_rate` 为播放重采样目标采样率(输出设备原生采样率)
173165
fn open_source(
174166
source: &str,
175167
target_rate: u32,
176-
) -> Result<(AudioReader, Resampler, Resampler, Option<Arc<AtomicBool>>)> {
168+
) -> Result<(AudioReader, Resampler, Option<Arc<AtomicBool>>)> {
177169
let (reader, cancel) = if http_source::is_network_source(source) {
178170
let http = http_source::HttpRangeSource::new(source)?;
179171
let cancel = http.cancel_handle();
@@ -195,18 +187,10 @@ fn open_source(
195187
.build_resampler(player_opts)
196188
.with_context(|| "构建播放重采样器失败")?;
197189

198-
let fft_opts = ResampleOptions::new()
199-
.sample_rate(TARGET_SAMPLE_RATE as i32)
200-
.channels(2)
201-
.format::<f32>();
202-
let fft_resampler = reader
203-
.build_resampler(fft_opts)
204-
.with_context(|| "构建 FFT 重采样器失败")?;
205-
206-
Ok((reader, player_resampler, fft_resampler, cancel))
190+
Ok((reader, player_resampler, cancel))
207191
}
208192

209-
/// 核心解码循环:每帧解码一次,零拷贝分发到播放 + FFT 两个重采样器
193+
/// 核心解码循环:每帧解码一次并重采样到输出设备格式
210194
fn run_decoding_loop(data: &mut DecoderData, shared: &Shared) {
211195
// 响度归一化:有 ReplayGain 标签时用固定增益,否则用实时分析
212196
let has_replay_gain = (shared.normalization_gain() - 1.0).abs() > f32::EPSILON;
@@ -224,22 +208,15 @@ fn run_decoding_loop(data: &mut DecoderData, shared: &Shared) {
224208

225209
match data.reader.receive_frame() {
226210
Ok(Some(frame)) => {
227-
// 1-to-N:同一帧顺序喂两个重采样器
228211
if data.player_resampler.process::<f32>(Some(&frame)).is_err() {
229212
debug!("player resampler 处理失败,结束解码");
230213
shared.mark_decode_failed();
231214
return;
232215
}
233216
let mut player_samples = data.player_resampler.output_as::<f32>().to_vec();
234217

235-
if data.fft_resampler.process::<f32>(Some(&frame)).is_err() {
236-
debug!("fft resampler 处理失败,结束解码");
237-
return;
238-
}
239-
let fft_samples = data.fft_resampler.output_as::<f32>().to_vec();
240-
241218
// 重采样可能还在攒样本,本轮没出数据就跳过
242-
if player_samples.is_empty() && fft_samples.is_empty() {
219+
if player_samples.is_empty() {
243220
continue;
244221
}
245222
had_success = true;
@@ -257,22 +234,14 @@ fn run_decoding_loop(data: &mut DecoderData, shared: &Shared) {
257234
}
258235
}
259236

260-
shared.push(AudioChunk {
261-
player_samples,
262-
fft_samples,
263-
});
237+
shared.push(AudioChunk { player_samples });
264238
}
265239
Ok(None) | Err(AudioError::Eof) => {
266-
// EOF flush:把两个重采样器内部残留挤出来,否则最后几十毫秒丢
240+
// EOF flush:把重采样器内部残留挤出来,否则最后几十毫秒丢
267241
let _ = data.player_resampler.process::<f32>(None);
268-
let _ = data.fft_resampler.process::<f32>(None);
269242
let player_samples = data.player_resampler.output_as::<f32>().to_vec();
270-
let fft_samples = data.fft_resampler.output_as::<f32>().to_vec();
271-
if !player_samples.is_empty() || !fft_samples.is_empty() {
272-
shared.push(AudioChunk {
273-
player_samples,
274-
fft_samples,
275-
});
243+
if !player_samples.is_empty() {
244+
shared.push(AudioChunk { player_samples });
276245
}
277246
return;
278247
}

‎native/audio-engine/src/fft.rs‎

Lines changed: 107 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use parking_lot::Mutex;
22
use rustfft::{num_complex::Complex, Fft, FftPlanner};
3+
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
34
use std::sync::Arc;
45

56
/// 每次 FFT 的样本数
@@ -12,19 +13,29 @@ const MAX_FREQ: f32 = 2000.0;
1213
/// 环形缓冲区最大样本数
1314
const MAX_BUFFER_SIZE: usize = 8192;
1415

15-
/// FFT 频谱分析器,接收单声道样本并输出频谱数据
16+
/// FFT 频谱分析器,接收交织双声道样本并输出频谱数据
1617
pub struct FftAnalyzer {
17-
/// 双声道 f32 样本环形缓冲区(由播放线程写入)
18-
sample_buffer_l: Mutex<Vec<f32>>,
19-
sample_buffer_r: Mutex<Vec<f32>>,
18+
/// 双声道样本环形缓冲区(由播放线程写入)
19+
sample_buffer: Mutex<StereoSampleBuffer>,
2020
/// FFT 输入采样率
21-
sample_rate: u32,
21+
sample_rate: AtomicU32,
22+
/// 是否接收样本并执行频谱分析
23+
enabled: AtomicBool,
2224
/// 缓存的 FFT 计划(避免每次分析时重建)
2325
fft_plan: Arc<dyn Fft<f32>>,
26+
/// 预计算的 Hamming 窗,避免每次分析重复计算三角函数
27+
window: Vec<f32>,
2428
/// 预分配的 FFT 工作缓冲区(避免每次 analyze 分配)
2529
work: Mutex<FftWorkBuffers>,
2630
}
2731

32+
struct StereoSampleBuffer {
33+
left: Vec<f32>,
34+
right: Vec<f32>,
35+
write_pos: usize,
36+
len: usize,
37+
}
38+
2839
/// 预分配的 FFT 工作缓冲区
2940
struct FftWorkBuffers {
3041
windowed_l: Vec<Complex<f32>>,
@@ -37,12 +48,24 @@ impl FftAnalyzer {
3748
pub fn new(sample_rate: u32) -> Self {
3849
let mut planner = FftPlanner::<f32>::new();
3950
let fft_plan = planner.plan_fft_forward(FFT_SIZE);
51+
let window = (0..FFT_SIZE)
52+
.map(|i| {
53+
0.54 - 0.46
54+
* (2.0 * std::f32::consts::PI * i as f32 / (FFT_SIZE as f32 - 1.0)).cos()
55+
})
56+
.collect();
4057

4158
Self {
42-
sample_buffer_l: Mutex::new(Vec::with_capacity(MAX_BUFFER_SIZE)),
43-
sample_buffer_r: Mutex::new(Vec::with_capacity(MAX_BUFFER_SIZE)),
44-
sample_rate,
59+
sample_buffer: Mutex::new(StereoSampleBuffer {
60+
left: vec![0.0; MAX_BUFFER_SIZE],
61+
right: vec![0.0; MAX_BUFFER_SIZE],
62+
write_pos: 0,
63+
len: 0,
64+
}),
65+
sample_rate: AtomicU32::new(sample_rate),
66+
enabled: AtomicBool::new(false),
4567
fft_plan,
68+
window,
4669
work: Mutex::new(FftWorkBuffers {
4770
windowed_l: vec![Complex::new(0.0, 0.0); FFT_SIZE],
4871
windowed_r: vec![Complex::new(0.0, 0.0); FFT_SIZE],
@@ -54,28 +77,39 @@ impl FftAnalyzer {
5477

5578
/// 直接从交织立体声样本推入(由播放线程调用),一次遍历无需中间分配
5679
pub fn push_interleaved_samples(&self, interleaved: &[f32]) {
57-
let mut buf_l = self.sample_buffer_l.lock();
58-
let mut buf_r = self.sample_buffer_r.lock();
59-
let count = interleaved.len() / 2;
60-
buf_l.reserve(count);
61-
buf_r.reserve(count);
80+
let mut buffer = self.sample_buffer.lock();
6281
for pair in interleaved.chunks_exact(2) {
63-
buf_l.push(pair[0]);
64-
buf_r.push(pair[1]);
82+
let write_pos = buffer.write_pos;
83+
buffer.left[write_pos] = pair[0];
84+
buffer.right[write_pos] = pair[1];
85+
buffer.write_pos = (write_pos + 1) % MAX_BUFFER_SIZE;
86+
buffer.len = (buffer.len + 1).min(MAX_BUFFER_SIZE);
6587
}
66-
if buf_l.len() > MAX_BUFFER_SIZE {
67-
let drain_count = buf_l.len() - MAX_BUFFER_SIZE;
68-
buf_l.drain(..drain_count);
69-
buf_r.drain(..drain_count);
88+
}
89+
90+
/// 设置分析开关,启用时丢弃关闭前残留的数据
91+
pub fn set_enabled(&self, enabled: bool) {
92+
let was_enabled = self.enabled.swap(enabled, Ordering::Relaxed);
93+
if enabled && !was_enabled {
94+
self.reset();
7095
}
7196
}
7297

73-
/// 应用 Hamming 窗到样本上,将结果存储在 windowed 缓冲区中
74-
fn apply_window(&self, samples: &[f32], windowed: &mut [Complex<f32>]) {
75-
for (i, (&s, w)) in samples.iter().zip(windowed.iter_mut()).enumerate() {
76-
let ham = 0.54
77-
- 0.46 * (2.0 * std::f32::consts::PI * i as f32 / (FFT_SIZE as f32 - 1.0)).cos();
78-
*w = Complex::new(s * ham, 0.0);
98+
/// 是否启用频谱分析
99+
pub fn is_enabled(&self) -> bool {
100+
self.enabled.load(Ordering::Relaxed)
101+
}
102+
103+
/// 更新输入 PCM 采样率
104+
pub fn set_sample_rate(&self, sample_rate: u32) {
105+
self.sample_rate.store(sample_rate, Ordering::Relaxed);
106+
}
107+
108+
/// 应用预计算的 Hamming 窗
109+
fn apply_window(&self, samples: &[f32], start: usize, windowed: &mut [Complex<f32>]) {
110+
for (i, output) in windowed.iter_mut().enumerate() {
111+
let sample = samples[(start + i) % MAX_BUFFER_SIZE];
112+
*output = Complex::new(sample * self.window[i], 0.0);
79113
}
80114
}
81115

@@ -87,33 +121,29 @@ impl FftAnalyzer {
87121

88122
/// 计算频谱,返回左右声道 (ldata, rdata) 各 OUTPUT_BINS 个值,范围 [0.0, 1.0]
89123
pub fn analyze(&self) -> (Vec<f32>, Vec<f32>) {
90-
let buf_l = self.sample_buffer_l.lock();
91-
let buf_r = self.sample_buffer_r.lock();
92-
if buf_l.len() < FFT_SIZE {
124+
let buffer = self.sample_buffer.lock();
125+
if buffer.len < FFT_SIZE {
93126
return (vec![0.0; OUTPUT_BINS], vec![0.0; OUTPUT_BINS]);
94127
}
95128

96129
// 取最新的 FFT_SIZE 个样本
97-
let start = buf_l.len() - FFT_SIZE;
98-
let samples_l = &buf_l[start..];
99-
let samples_r = &buf_r[start..];
130+
let start = (buffer.write_pos + MAX_BUFFER_SIZE - FFT_SIZE) % MAX_BUFFER_SIZE;
100131

101132
let mut work = self.work.lock();
102133

103134
// 应用 Hamming 窗(复用预分配的 windowed 缓冲区)
104-
self.apply_window(samples_l, &mut work.windowed_l);
105-
self.apply_window(samples_r, &mut work.windowed_r);
135+
self.apply_window(&buffer.left, start, &mut work.windowed_l);
136+
self.apply_window(&buffer.right, start, &mut work.windowed_r);
106137

107138
// 释放 sample_buffer 锁(后续计算不需要它)
108-
drop(buf_l);
109-
drop(buf_r);
139+
drop(buffer);
110140

111141
// 执行 FFT(使用缓存的计划,原地处理)
112142
self.fft_plan.process(&mut work.windowed_l);
113143
self.fft_plan.process(&mut work.windowed_r);
114144

115145
// 将频率段映射到输出频段
116-
let freq_per_bin = self.sample_rate as f32 / FFT_SIZE as f32;
146+
let freq_per_bin = self.sample_rate.load(Ordering::Relaxed) as f32 / FFT_SIZE as f32;
117147
let min_bin = (MIN_FREQ / freq_per_bin).floor() as usize;
118148
let max_bin = ((MAX_FREQ / freq_per_bin).ceil() as usize).min(FFT_SIZE / 2);
119149

@@ -147,7 +177,10 @@ impl FftAnalyzer {
147177
sums.0 += work.windowed_l[j].norm() / FFT_SIZE as f32;
148178
sums.1 += work.windowed_r[j].norm() / FFT_SIZE as f32;
149179
}
150-
let avgs = (sums.0 / (bin_hi - bin_lo) as f32, sums.1 / (bin_hi - bin_lo) as f32);
180+
let avgs = (
181+
sums.0 / (bin_hi - bin_lo) as f32,
182+
sums.1 / (bin_hi - bin_lo) as f32,
183+
);
151184

152185
// 转为 dB 并归一化到 [0, 1]
153186
work.output_l[i] = self.to_normalized_db(avgs.0);
@@ -159,11 +192,42 @@ impl FftAnalyzer {
159192

160193
/// 重置样本缓冲区(例如 seek 时)
161194
pub fn reset(&self) {
162-
let mut buf_l = self.sample_buffer_l.lock();
163-
let mut buf_r = self.sample_buffer_r.lock();
164-
buf_l.clear();
165-
buf_r.clear();
166-
buf_l.shrink_to(MAX_BUFFER_SIZE);
167-
buf_r.shrink_to(MAX_BUFFER_SIZE);
195+
let mut buffer = self.sample_buffer.lock();
196+
buffer.write_pos = 0;
197+
buffer.len = 0;
198+
}
199+
}
200+
201+
#[cfg(test)]
202+
mod tests {
203+
use super::*;
204+
205+
#[test]
206+
fn interleaved_samples_wrap_without_mixing_channels() {
207+
let analyzer = FftAnalyzer::new(48_000);
208+
let samples: Vec<f32> = (0..MAX_BUFFER_SIZE + 16)
209+
.flat_map(|i| [i as f32, -(i as f32)])
210+
.collect();
211+
212+
analyzer.push_interleaved_samples(&samples);
213+
214+
let buffer = analyzer.sample_buffer.lock();
215+
assert_eq!(buffer.len, MAX_BUFFER_SIZE);
216+
assert_eq!(buffer.write_pos, 16);
217+
let latest = (buffer.write_pos + MAX_BUFFER_SIZE - 1) % MAX_BUFFER_SIZE;
218+
assert_eq!(buffer.left[latest], (MAX_BUFFER_SIZE + 15) as f32);
219+
assert_eq!(buffer.right[latest], -((MAX_BUFFER_SIZE + 15) as f32));
220+
}
221+
222+
#[test]
223+
fn reset_discards_buffered_samples() {
224+
let analyzer = FftAnalyzer::new(48_000);
225+
analyzer.push_interleaved_samples(&[0.5, -0.5, 0.25, -0.25]);
226+
227+
analyzer.reset();
228+
229+
let buffer = analyzer.sample_buffer.lock();
230+
assert_eq!(buffer.len, 0);
231+
assert_eq!(buffer.write_pos, 0);
168232
}
169233
}

‎native/audio-engine/src/lib.rs‎

Lines changed: 3 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -593,15 +593,9 @@ impl AudioPlayer {
593593
/// 获取 FFT 频谱数据(128 个频段,值域 0.0 ~ 1.0)
594594
#[napi]
595595
pub fn get_fft_data(&self) -> JsFftData {
596-
let (ldata, rdata) = self.inner
597-
.lock()
598-
.fft_data();
599-
let ldata = ldata.into_iter()
600-
.map(|v| v as f64)
601-
.collect();
602-
let rdata = rdata.into_iter()
603-
.map(|v| v as f64)
604-
.collect();
596+
let (ldata, rdata) = self.inner.lock().fft_data();
597+
let ldata = ldata.into_iter().map(|v| v as f64).collect();
598+
let rdata = rdata.into_iter().map(|v| v as f64).collect();
605599
JsFftData { ldata, rdata }
606600
}
607601

0 commit comments

Comments
 (0)