use crate::event::{EventReceiver, SessionEvent};
use crate::media::{AudioFrame, PcmBuf, Sample, Samples, processor::Processor};
use anyhow::Result;
use audio_codec::BoxedResampler;
use nnnoiseless::DenoiseState;
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use tokio::sync::broadcast::error::RecvError;
pub struct NoiseReducer {
resampler_target: BoxedResampler,
resampler_source: BoxedResampler,
denoiser: Box<DenoiseState<'static>>,
answered: Arc<AtomicBool>,
}
impl NoiseReducer {
pub fn new(input_sample_rate: usize, answered: Arc<AtomicBool>) -> Self {
let resampler48k =
BoxedResampler::new(48000, input_sample_rate).expect("invalid sample rate");
let resampler16k =
BoxedResampler::new(input_sample_rate, 48000).expect("invalid sample rate");
let denoiser = DenoiseState::new();
Self {
resampler_target: resampler48k,
resampler_source: resampler16k,
denoiser,
answered,
}
}
}
pub fn spawn_answer_watcher(mut event_rx: EventReceiver, answered: Arc<AtomicBool>) {
tokio::spawn(async move {
loop {
match event_rx.recv().await {
Ok(SessionEvent::Answer { .. }) => {
answered.store(true, Ordering::Relaxed);
break;
}
Err(RecvError::Lagged(_)) => {
answered.store(true, Ordering::Relaxed);
break;
}
Err(RecvError::Closed) => break,
Ok(_) => {}
}
}
});
}
impl Processor for NoiseReducer {
fn process_frame(&mut self, frame: &mut AudioFrame) -> Result<()> {
if !self.answered.load(Ordering::Relaxed) {
return Ok(());
}
if frame.samples.is_empty() {
return Ok(());
}
let samples = match &frame.samples {
Samples::PCM { samples } => samples,
_ => return Ok(()),
};
let samples = self.resampler_source.resample(samples);
let input_size = samples.len();
let output_padding_size = input_size + DenoiseState::FRAME_SIZE;
let mut output_buf = vec![0.0; output_padding_size];
let input_f32: Vec<f32> = samples.iter().map(|&s| s.into()).collect();
let mut offset = 0;
let mut buf;
while offset < input_size {
let remaining_size = input_size - offset;
let chunk_len = remaining_size.min(DenoiseState::FRAME_SIZE);
let end_offset = offset + chunk_len;
let input_chunk = if chunk_len < DenoiseState::FRAME_SIZE {
buf = vec![0.0; DenoiseState::FRAME_SIZE];
buf[..chunk_len].copy_from_slice(&input_f32[offset..end_offset]);
&buf
} else {
&input_f32[offset..end_offset]
};
self.denoiser.process_frame(
&mut output_buf[offset..offset + DenoiseState::FRAME_SIZE],
&input_chunk,
);
offset += chunk_len;
}
let samples = output_buf[..input_size]
.iter()
.map(|&s| s as Sample)
.collect::<PcmBuf>();
frame.samples = Samples::PCM {
samples: self.resampler_target.resample(&samples),
};
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn noise_reducer(answered: bool) -> NoiseReducer {
NoiseReducer::new(16000, Arc::new(AtomicBool::new(answered)))
}
fn make_frame() -> AudioFrame {
AudioFrame {
track_id: "test-track".to_string(),
samples: Samples::PCM {
samples: vec![100i16; 320],
},
sample_rate: 16000,
channels: 1,
..Default::default()
}
}
#[test]
fn skips_frames_until_answered() {
let mut reducer = noise_reducer(false);
let mut frame = make_frame();
let before = match &frame.samples {
Samples::PCM { samples } => samples.clone(),
_ => panic!("expected pcm"),
};
reducer.process_frame(&mut frame).unwrap();
match &frame.samples {
Samples::PCM { samples } => assert_eq!(*samples, before),
_ => panic!("expected pcm"),
}
}
#[test]
fn denoises_after_answered() {
let mut reducer = noise_reducer(true);
let mut frame = make_frame();
reducer.process_frame(&mut frame).unwrap();
match &frame.samples {
Samples::PCM { samples } => assert_eq!(samples.len(), 320),
_ => panic!("expected pcm"),
}
}
#[test]
fn answer_watcher_flips_flag() {
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
let (tx, rx) = tokio::sync::broadcast::channel(64);
let flag = Arc::new(AtomicBool::new(false));
spawn_answer_watcher(rx, flag.clone());
assert!(!flag.load(Ordering::Relaxed));
tx.send(SessionEvent::Answer {
track_id: "test-track".to_string(),
timestamp: 0,
sdp: "v=0".to_string(),
refer: None,
})
.unwrap();
for _ in 0..100 {
if flag.load(Ordering::Relaxed) {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
assert!(flag.load(Ordering::Relaxed));
});
}
}