Skip to main content

active_call/media/
denoiser.rs

1use 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    /// Flipped once the call is answered; denoising only runs after that.
17    /// One relaxed atomic load per frame — no per-frame channel access.
18    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
37/// Watches the session event channel and flips `answered` on the
38/// `SessionEvent::Answer` broadcast — the same signal the ASR client's
39/// `start_when_answer` gating uses. Must be called from a tokio context.
40/// Lagged receivers enable denoise too (the Answer event may have been
41/// among the skipped ones), matching the ASR wait helper's semantics.
42pub 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        // Only denoise after the call is answered; before that (ringing,
64        // early media) pass frames through untouched. One relaxed load per
65        // frame — the answer watcher owns all event-channel access.
66        if !self.answered.load(Ordering::Relaxed) {
67            return Ok(());
68        }
69
70        // If empty frame, nothing to do
71        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            // Process the current frame
103            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        // Not answered yet: frame passes through byte-identical — no
154        // resampling, no allocation, no denoising.
155        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        // After the answer the frame is denoised: it goes through the
168        // 16k->48k->16k resampling round trip and comes back at the same
169        // length, PCM format preserved.
170        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            // Wait until the watcher processes the event.
193            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}