Usage

[thewh1teagle]

Hey
I'm trying to use this library for echo cancellation like this example in aec-rs crate:
https://github.com/thewh1teagle/aec-rs/blob/main/examples/wav.rs
But I don't understand how to use it that way.

I tried the following but it doesn't cancel the echo

/*
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/rec.wav
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/echo.wav
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/voice.wav
cargo run --example wav rec.wav echo.wav cancelled.wav
*/

use hound;
use webrtc_audio_processing::*;

const SAMPLE_RATE: f64 = 16_000.0; // 16kHz
const FRAMES_PER_BUFFER: u32 = 480; // 10ms per buffer

fn create_processor() -> Result<Processor, Box<dyn std::error::Error>> {
    let mut processor = Processor::new(&InitializationConfig {
        num_capture_channels: 1,
        num_render_channels: 1,
        ..InitializationConfig::default()
    })?;

    let config = Config {
        echo_cancellation: Some(EchoCancellation {
            suppression_level: EchoCancellationSuppressionLevel::High,
            stream_delay_ms: Some(0),
            enable_delay_agnostic: false,
            enable_extended_filter: false,
        }),
        enable_high_pass_filter: false,
        ..Config::default()
    };
    processor.set_config(config);

    Ok(processor)
}

fn main() {
    let rec_path = std::env::args().nth(1).expect("Please specify echo path");
    let echo_path = std::env::args().nth(2).expect("Please specify rec path");
    let out_path = std::env::args().nth(3).expect("Please specify out path");

    // Read echo samples
    let mut reader = hound::WavReader::open(echo_path).unwrap();
    let echo_samples: Vec<f32> = reader.samples::<i16>()
        .map(|s| s.unwrap() as f32 / i16::MAX as f32)  // Convert i16 to f32 (normalize)
        .collect();

    // Read recorded samples
    let mut reader = hound::WavReader::open(rec_path).unwrap();
    let rec_samples: Vec<f32> = reader.samples::<i16>()
        .map(|s| s.unwrap() as f32 / i16::MAX as f32)  // Convert i16 to f32 (normalize)
        .collect();

    let mut processor = create_processor().unwrap();

    let frame_size = FRAMES_PER_BUFFER as usize;

    // Prepare output WAV writer
    let spec = hound::WavSpec {
        channels: 1,
        sample_rate: SAMPLE_RATE as u32,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };
    let mut writer = hound::WavWriter::create(&out_path, spec).unwrap();

    let mut output_samples = Vec::new();
    let mut input_frame = vec![0f32; frame_size];
    let mut reference_frame = vec![0f32; frame_size];

    // Process samples frame by frame
    for i in (0..rec_samples.len()).step_by(frame_size) {
        let end = usize::min(i + frame_size, rec_samples.len());

        // Fill frames with input and reference samples
        input_frame[..end - i].copy_from_slice(&rec_samples[i..end]);
        reference_frame[..end - i].copy_from_slice(&echo_samples[i..end]);

        // Apply echo cancellation using webrtc-audio-processing
        processor.process_capture_frame(&mut input_frame).unwrap();
        processor.process_render_frame(&mut reference_frame).unwrap();

        // Convert the output back to i16 and write to the output file
        for &sample in &input_frame {
            writer.write_sample((sample * i16::MAX as f32) as i16).unwrap();
        }

        // Add to output_samples
        output_samples.extend_from_slice(&input_frame);
    }

    println!("Created {}", out_path);
}

[jeffrafter]

This is a late reply but there are a couple of things wrong in your example (at least as far as I understand it).

1. You always want to process the render frame before processing the capture frame. The processor needs to know about rendered audio and will cancel it from captured audio (i.e. the microphone).
2. In your example cargo run line I am not sure what audio you are actually trying to use, but I think things might be backward.
3. I'm not sure why by your stream delay of 0 wasn't working for me, changing it to adaptive helped

Here is an updated version (that is not perfect):

/*
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/rec.wav
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/echo.wav
wget https://github.com/thewh1teagle/aec-rs/releases/download/audio-files/voice.wav
cargo init
cargo add hound
cargo add webrtc-audio-processing --features "bundled"
cargo run --example wav voice.wav rec.wav cancelled.wav
*/

use hound;
use webrtc_audio_processing::*;

const SAMPLE_RATE: f64 = 16_000.0; // 16kHz

fn create_processor() -> Result<Processor, Box<dyn std::error::Error>> {
    let mut processor = Processor::new(&InitializationConfig {
        num_capture_channels: 1,
        num_render_channels: 1,
        ..InitializationConfig::default()
    })?;

    let config = Config {
        echo_cancellation: Some(EchoCancellation {
            suppression_level: EchoCancellationSuppressionLevel::High,
            stream_delay_ms: None,
            enable_delay_agnostic: true,
            enable_extended_filter: true,
        }),
        enable_high_pass_filter: true,
        ..Config::default()
    };
    processor.set_config(config);

    Ok(processor)
}

fn main() {
    // This is the clean voice sample voice.wav "I have a message..." - i.e., your system audio output
    let voice_path = std::env::args().nth(1).expect("Please specify voice path");
    // This is the recorded sample rec.wav with "Hello Hello Hello" and echo "I have a message...", i.e., your microphone input
    // with echo from the system audio output
    let rec_path = std::env::args().nth(2).expect("Please specify rec path");
    // This is output with the echo cancelled, you should only hear "Hello Hello Hello"
    let out_path = std::env::args().nth(3).expect("Please specify out path");

    let mut reader = hound::WavReader::open(voice_path).unwrap();
    let voice_samples: Vec<f32> = reader
        .samples::<i16>()
        .map(|s| s.unwrap() as f32 / i16::MAX as f32) // Convert i16 to f32 (normalize)
        .collect();

    let mut reader = hound::WavReader::open(rec_path).unwrap();
    let rec_samples: Vec<f32> = reader
        .samples::<i16>()
        .map(|s| s.unwrap() as f32 / i16::MAX as f32) // Convert i16 to f32 (normalize)
        .collect();

    let mut processor = create_processor().unwrap();

    let frame_size = webrtc_audio_processing::NUM_SAMPLES_PER_FRAME as usize;

    // Prepare output WAV writer
    let spec = hound::WavSpec {
        channels: 1,
        sample_rate: SAMPLE_RATE as u32,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };
    let mut writer = hound::WavWriter::create(&out_path, spec).unwrap();

    let mut output_samples = Vec::new();
    let mut render_frame = vec![0f32; frame_size];
    let mut capture_frame = vec![0f32; frame_size];

    // Process samples frame by frame
    for i in (0..rec_samples.len()).step_by(frame_size) {
        let end = usize::min(i + frame_size, rec_samples.len());

        // Fill frames with input and reference samples
        capture_frame[..end - i].copy_from_slice(&rec_samples[i..end]);
        render_frame[..end - i].copy_from_slice(&voice_samples[i..end]);

        // Apply echo cancellation using webrtc-audio-processing
        processor.process_render_frame(&mut render_frame).unwrap();
        processor.process_capture_frame(&mut capture_frame).unwrap();

        // Convert the output back to i16 and write to the output file
        for &sample in &capture_frame {
            writer
                .write_sample((sample * i16::MAX as f32) as i16)
                .unwrap();
        }

        // Add to output_samples
        output_samples.extend_from_slice(&capture_frame);
    }

    println!("Created {}", out_path);
}