Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

improve(audio): reuse pristine denoiser states on first render

vedanthd23dd5a39eec
diff --git a/crates/audio/examples/voice-startup-benchmark.rs b/crates/audio/examples/voice-startup-benchmark.rs
new file mode 100644
index 000000000..4c5459f6e
--- /dev/null
+++ b/crates/audio/examples/voice-startup-benchmark.rs
@@ -0,0 +1,91 @@
+use cap_audio::{AudioSampleSource, VoiceEnhancer, VoiceProfile};
+use std::{
+ collections::hash_map::DefaultHasher,
+ error::Error,
+ hash::{Hash, Hasher},
+ hint::black_box,
+ time::Instant,
+};
+
+struct Source {
+ samples: Vec<f32>,
+ channels: u16,
+}
+impl AudioSampleSource for Source {
+ fn channels(&self) -> u16 {
+ self.channels
+ }
+ fn sample_count(&self) -> usize {
+ self.samples.len() / usize::from(self.channels)
+ }
+ fn sample(&self, index: usize) -> Option<&f32> {
+ self.samples.get(index)
+ }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+ ffmpeg::init()?;
+ println!("channels,profile,case,frames,sample,elapsed_ms,fingerprint");
+ for channels in [1, 2] {
+ let source = Source {
+ channels,
+ samples: (0..96_000 * usize::from(channels))
+ .map(|index| {
+ let seed = (index as u32)
+ .wrapping_mul(1_664_525)
+ .wrapping_add(1_013_904_223);
+ let time = (index / usize::from(channels)) as f32 / 48_000.0;
+ (std::f32::consts::TAU * 180.0 * time).sin() * 0.12
+ + (seed as f64 / u32::MAX as f64 * 0.04 - 0.02) as f32
+ })
+ .collect(),
+ };
+ for profile in [false, true] {
+ let create = || {
+ if profile {
+ VoiceEnhancer::with_settings(channels, 0.9, VoiceProfile::default())
+ } else {
+ VoiceEnhancer::new(channels)
+ }
+ };
+ for (case, frames) in [
+ ("startup", 1),
+ ("startup", 1_024),
+ ("startup", 4_096),
+ ("startup", 24_000),
+ ("seek", 4_096),
+ ("fresh-seek", 4_096),
+ ] {
+ for sample in 0..28 {
+ let mut prepared = (case == "seek").then(|| {
+ let mut enhancer = create();
+ black_box(enhancer.render(&source, 0, 4_096));
+ enhancer
+ });
+ let started = Instant::now();
+ let mut enhancer = prepared.take().unwrap_or_else(create);
+ let audio = black_box(enhancer.render(
+ black_box(&source),
+ if case.ends_with("seek") { 48_000 } else { 0 },
+ frames,
+ ));
+ let elapsed_ms = started.elapsed().as_secs_f64() * 1_000.0;
+ assert_eq!(audio.samples().len(), frames * usize::from(channels));
+ let mut hash = DefaultHasher::new();
+ for value in audio.samples() {
+ value.to_bits().hash(&mut hash);
+ }
+ enhancer.speech_frames().hash(&mut hash);
+ if sample >= 3 {
+ println!(
+ "{channels},{profile},{case},{frames},{},{elapsed_ms:.6},{}",
+ sample - 3,
+ hash.finish()
+ );
+ }
+ }
+ }
+ }
+ }
+ Ok(())
+}
diff --git a/crates/audio/src/voice.rs b/crates/audio/src/voice.rs
index f4013c418..049002b16 100644
--- a/crates/audio/src/voice.rs
+++ b/crates/audio/src/voice.rs
@@ -111,7 +111,9 @@ impl VoiceEnhancer {
self.pending_start = self.next_input;
self.pending.clear();
self.previous.fill(0.0);
- self.states = (0..channels).map(|_| DenoiseState::new()).collect();
+ if self.expected_start.is_some() {
+ self.states = (0..channels).map(|_| DenoiseState::new()).collect();
+ }
self.speech_frames = 0;
self.leveler = self.profile.and_then(|profile| {
VoiceFilter::new(channels as u16, &profile.filter(channels as u16))
@@ -319,6 +321,70 @@ mod tests {
assert_eq!(after_seek.samples(), fresh.samples());
}
+ #[test]
+ fn initial_state_reuse_matches_forced_reset_after_empty_reads_and_seeks() {
+ ffmpeg::init().unwrap();
+ for channels in [1, 2] {
+ let source = signal(96_001, channels);
+ for profile in [false, true] {
+ let create = || {
+ if profile {
+ VoiceEnhancer::with_settings(channels, 0.9, VoiceProfile::default())
+ } else {
+ VoiceEnhancer::new(channels)
+ }
+ };
+ for start in [0, 27_017] {
+ for count in [1, 4_096] {
+ let mut actual = create();
+ let mut reference = create();
+ reference.expected_start = Some(usize::MAX);
+ for empty_start in [0, 50_000] {
+ assert!(actual.render(&source, empty_start, 0).samples().is_empty());
+ assert!(
+ reference
+ .render(&source, empty_start, 0)
+ .samples()
+ .is_empty()
+ );
+ }
+ let first = actual.render(&source, start, count);
+ let expected = reference.render(&source, start, count);
+ assert_eq!(
+ first
+ .samples()
+ .iter()
+ .map(|value| value.to_bits())
+ .collect::<Vec<_>>(),
+ expected
+ .samples()
+ .iter()
+ .map(|value| value.to_bits())
+ .collect::<Vec<_>>()
+ );
+ assert_eq!(actual.speech_frames(), reference.speech_frames());
+ let seek = actual.render(&source, 48_017, 997);
+ let mut fresh = create();
+ fresh.expected_start = Some(usize::MAX);
+ let expected = fresh.render(&source, 48_017, 997);
+ assert_eq!(
+ seek.samples()
+ .iter()
+ .map(|value| value.to_bits())
+ .collect::<Vec<_>>(),
+ expected
+ .samples()
+ .iter()
+ .map(|value| value.to_bits())
+ .collect::<Vec<_>>()
+ );
+ assert_eq!(actual.speech_frames(), fresh.speech_frames());
+ }
+ }
+ }
+ }
+ }
+
#[test]
fn leveling_preserves_chunk_boundaries_timing_and_peak_headroom() {
ffmpeg::init().unwrap();