11use parking_lot:: Mutex ;
22use rustfft:: { num_complex:: Complex , Fft , FftPlanner } ;
3+ use std:: sync:: atomic:: { AtomicBool , AtomicU32 , Ordering } ;
34use std:: sync:: Arc ;
45
56/// 每次 FFT 的样本数
@@ -12,19 +13,29 @@ const MAX_FREQ: f32 = 2000.0;
1213/// 环形缓冲区最大样本数
1314const MAX_BUFFER_SIZE : usize = 8192 ;
1415
15- /// FFT 频谱分析器,接收单声道样本并输出频谱数据
16+ /// FFT 频谱分析器,接收交织双声道样本并输出频谱数据
1617pub 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 工作缓冲区
2940struct 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}
0 commit comments