active_call/media/
denoiser.rs1use crate::event::{EventReceiver, SessionEvent};
2use crate::media::{AudioFrame, PcmBuf, Sample, Samples, processor::Processor};
3use anyhow::Result;
4use audio_codec::BoxedResampler;
5use nnnoiseless::DenoiseState;
6use std::sync::{
7 Arc,
8 atomic::{AtomicBool, Ordering},
9};
10use tokio::sync::broadcast::error::RecvError;
11
12pub struct NoiseReducer {
13 resampler_target: BoxedResampler,
14 resampler_source: BoxedResampler,
15 denoiser: Box<DenoiseState<'static>>,
16 answered: Arc<AtomicBool>,
19}
20
21impl NoiseReducer {
22 pub fn new(input_sample_rate: usize, answered: Arc<AtomicBool>) -> Self {
23 let resampler48k =
24 BoxedResampler::new(48000, input_sample_rate).expect("invalid sample rate");
25 let resampler16k =
26 BoxedResampler::new(input_sample_rate, 48000).expect("invalid sample rate");
27 let denoiser = DenoiseState::new();
28 Self {
29 resampler_target: resampler48k,
30 resampler_source: resampler16k,
31 denoiser,
32 answered,
33 }
34 }
35}
36
37pub fn spawn_answer_watcher(mut event_rx: EventReceiver, answered: Arc<AtomicBool>) {
43 tokio::spawn(async move {
44 loop {
45 match event_rx.recv().await {
46 Ok(SessionEvent::Answer { .. }) => {
47 answered.store(true, Ordering::Relaxed);
48 break;
49 }
50 Err(RecvError::Lagged(_)) => {
51 answered.store(true, Ordering::Relaxed);
52 break;
53 }
54 Err(RecvError::Closed) => break,
55 Ok(_) => {}
56 }
57 }
58 });
59}
60
61impl Processor for NoiseReducer {
62 fn process_frame(&mut self, frame: &mut AudioFrame) -> Result<()> {
63 if !self.answered.load(Ordering::Relaxed) {
67 return Ok(());
68 }
69
70 if frame.samples.is_empty() {
72 return Ok(());
73 }
74
75 let samples = match &frame.samples {
76 Samples::PCM { samples } => samples,
77 _ => return Ok(()),
78 };
79 let samples = self.resampler_source.resample(samples);
80 let input_size = samples.len();
81
82 let output_padding_size = input_size + DenoiseState::FRAME_SIZE;
83 let mut output_buf = vec![0.0; output_padding_size];
84 let input_f32: Vec<f32> = samples.iter().map(|&s| s.into()).collect();
85
86 let mut offset = 0;
87 let mut buf;
88
89 while offset < input_size {
90 let remaining_size = input_size - offset;
91 let chunk_len = remaining_size.min(DenoiseState::FRAME_SIZE);
92 let end_offset = offset + chunk_len;
93
94 let input_chunk = if chunk_len < DenoiseState::FRAME_SIZE {
95 buf = vec![0.0; DenoiseState::FRAME_SIZE];
96 buf[..chunk_len].copy_from_slice(&input_f32[offset..end_offset]);
97 &buf
98 } else {
99 &input_f32[offset..end_offset]
100 };
101
102 self.denoiser.process_frame(
104 &mut output_buf[offset..offset + DenoiseState::FRAME_SIZE],
105 &input_chunk,
106 );
107
108 offset += chunk_len;
109 }
110
111 let samples = output_buf[..input_size]
112 .iter()
113 .map(|&s| s as Sample)
114 .collect::<PcmBuf>();
115
116 frame.samples = Samples::PCM {
117 samples: self.resampler_target.resample(&samples),
118 };
119
120 Ok(())
121 }
122}
123
124#[cfg(test)]
125mod tests {
126 use super::*;
127
128 fn noise_reducer(answered: bool) -> NoiseReducer {
129 NoiseReducer::new(16000, Arc::new(AtomicBool::new(answered)))
130 }
131
132 fn make_frame() -> AudioFrame {
133 AudioFrame {
134 track_id: "test-track".to_string(),
135 samples: Samples::PCM {
136 samples: vec![100i16; 320],
137 },
138 sample_rate: 16000,
139 channels: 1,
140 ..Default::default()
141 }
142 }
143
144 #[test]
145 fn skips_frames_until_answered() {
146 let mut reducer = noise_reducer(false);
147 let mut frame = make_frame();
148 let before = match &frame.samples {
149 Samples::PCM { samples } => samples.clone(),
150 _ => panic!("expected pcm"),
151 };
152
153 reducer.process_frame(&mut frame).unwrap();
156 match &frame.samples {
157 Samples::PCM { samples } => assert_eq!(*samples, before),
158 _ => panic!("expected pcm"),
159 }
160 }
161
162 #[test]
163 fn denoises_after_answered() {
164 let mut reducer = noise_reducer(true);
165 let mut frame = make_frame();
166 reducer.process_frame(&mut frame).unwrap();
167 match &frame.samples {
171 Samples::PCM { samples } => assert_eq!(samples.len(), 320),
172 _ => panic!("expected pcm"),
173 }
174 }
175
176 #[test]
177 fn answer_watcher_flips_flag() {
178 let rt = tokio::runtime::Runtime::new().unwrap();
179 rt.block_on(async {
180 let (tx, rx) = tokio::sync::broadcast::channel(64);
181 let flag = Arc::new(AtomicBool::new(false));
182 spawn_answer_watcher(rx, flag.clone());
183 assert!(!flag.load(Ordering::Relaxed));
184
185 tx.send(SessionEvent::Answer {
186 track_id: "test-track".to_string(),
187 timestamp: 0,
188 sdp: "v=0".to_string(),
189 refer: None,
190 })
191 .unwrap();
192 for _ in 0..100 {
194 if flag.load(Ordering::Relaxed) {
195 break;
196 }
197 tokio::time::sleep(std::time::Duration::from_millis(10)).await;
198 }
199 assert!(flag.load(Ordering::Relaxed));
200 });
201 }
202}