One more test and aec3 access from config

Author: jacksongoode

examples/aec-configs/config.json5

@@ -1,7 +1,4 @@
 {
-  num_capture_channels: 1,
-  num_render_channels: 2,
-
   config: {
     echo_canceller: {
       Full: {

examples/config_karaoke.rs

@@ -28,9 +28,7 @@ struct Args {
 #[derive(Debug, Deserialize)]
 #[serde(default)]
 struct AppConfig {
-    #[serde(default = "default_channels")]
     num_capture_channels: u16,
-    #[serde(default = "default_channels")]
     num_render_channels: u16,
     #[serde(default)]
     config: Config,
@@ -41,8 +39,8 @@ struct AppConfig {
 impl Default for AppConfig {
     fn default() -> Self {
         Self {
-            num_capture_channels: default_channels(),
-            num_render_channels: default_channels(),
+            num_capture_channels: 1,
+            num_render_channels: 1,
             config: Config::default(),
             aec3: EchoCanceller3Config::default(),
         }
@@ -61,10 +59,6 @@ impl AppConfig {
     }
 }
 
-fn default_channels() -> u16 {
-    1
-}
-
 fn create_processor(config: &AppConfig) -> Result<Processor, Error> {
     let mut processor = Processor::with_aec3_config(
         &InitializationConfig {

src/config.rs

@@ -368,6 +368,10 @@ pub struct Config {
     /// Toggles reporting of selected fields in [`Stats`].
     #[serde(default)]
     pub reporting: ReportingConfig,
+
+    /// Fine-grained AEC3 configuration parameters.
+    #[serde(default)]
+    pub aec3_config: Option<EchoCanceller3Config>,
 }
 
 impl From<Config> for ffi::AudioProcessing_Config {

src/lib.rs

@@ -394,6 +394,7 @@ mod tests {
         }
     }
 
+    /// A context to put abstracted methods commonly reused for tests.
     struct TestContext {
         processor: Processor,
         num_samples: usize,
@@ -441,6 +442,7 @@ mod tests {
             final_erl - initial_erl
         }
 
+        /// Warm up the AEC and then measure ERL
         fn measure_steady_state_performance(
             &mut self,
             render_frame: &[f32],
@@ -456,7 +458,7 @@ mod tests {
                 warmup_iterations,
             );
 
-            // Measure steady state
+            // Measure steady state and sum up the ERL reduction
             let mut total_reduction = 0.0;
             for _ in 0..measurement_count {
                 let mut test_capture = capture_frame.clone();
@@ -608,9 +610,7 @@ mod tests {
     /// Measures baseline echo cancellation performance using industry metrics.
     ///
     /// Uses a pure sine wave to create ideal test conditions. Verifies the AEC
-    /// achieves at least 18dB Echo Return Loss Enhancement (ERLE)
-    ///
-    /// Most echo cancellers are able to apply 18 to 35 dB ERLE.
+    /// achieves at least 18dB ERL.
     #[test]
     fn test_echo_cancellation_effectiveness() {
         let mut context = TestContext::new(1);
@@ -635,7 +635,6 @@ mod tests {
 
     /// Verifies that different AEC configurations produce measurably different results.
     ///
-    /// Compares Mobile vs Full modes under realistic conditions (noise + attenuation).
     /// These modes should have distinct echo cancellation behaviors by design.
     #[test]
     fn test_aec3_configuration_impact() {
@@ -663,11 +662,80 @@ mod tests {
         );
     }
 
+    /// Verifies that unique AEC configurations produce measurably different results.
+    ///
+    /// This test is used to verify that a AEC3 configuration will apply and output
+    /// different results (in this case, 4dB of ERL).
+    #[test]
+    fn test_aec3_configuration_tuning() {
+        // Strong suppression configuration
+        let strong_config = Config {
+            echo_canceller: Some(EchoCanceller::default()),
+            aec3_config: Some(EchoCanceller3Config {
+                suppressor: Suppressor {
+                    dominant_nearend_detection: DominantNearendDetection {
+                        enr_threshold: 0.75,
+                        snr_threshold: 20.0,
+                        ..Default::default()
+                    },
+                    high_bands_suppression: HighBandsSuppression {
+                        enr_threshold: 0.8,
+                        max_gain_during_echo: 0.3,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        // Light suppression configuration
+        let light_config = Config {
+            echo_canceller: Some(EchoCanceller::default()),
+            aec3_config: Some(EchoCanceller3Config {
+                suppressor: Suppressor {
+                    dominant_nearend_detection: DominantNearendDetection {
+                        enr_threshold: 0.25,
+                        snr_threshold: 30.0,
+                        ..Default::default()
+                    },
+                    high_bands_suppression: HighBandsSuppression {
+                        enr_threshold: 1.2,
+                        max_gain_during_echo: 0.8,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        let mut context = TestContext::new(2);
+        let render_frame = context.generate_sine_frame(440.0);
+
+        // Test strong suppression
+        context.processor.set_config(strong_config);
+        let strong_reduction = context.measure_steady_state_performance(&render_frame, 50, 10);
+
+        // Test light suppression
+        context.processor.set_config(light_config);
+        let light_reduction = context.measure_steady_state_performance(&render_frame, 50, 10);
+
+        // Verify the configurations produce measurably different results
+        assert!(
+            strong_reduction > light_reduction + 3.0,
+            "Strong suppression ({:.1} dB) should achieve at least 3dB more reduction than light suppression ({:.1} dB)",
+            strong_reduction,
+            light_reduction
+        );
+    }
+
     /// Validates AEC configuration state management across processing modes.
     ///
     /// Tests that AEC metrics and behavior remain consistent when switching
-    /// between different modes (Full vs Mobile). Ensures configuration changes
-    /// are properly applied and maintained during audio processing.
+    /// between different modes (Full vs Mobile).
     #[test]
     fn test_aec3_configuration_behavior() {
         let mut context = TestContext::new(2);

webrtc-audio-processing-sys/src/lib.rs

@@ -233,7 +233,7 @@ mod tests {
     fn test_config_bindings_coverage() {
         use std::collections::HashSet;
 
-        // Helper to normalize field names into groups
+        // Helper to normalize field names into groups - very ugly
         fn normalize_group_name(field: &str) -> Option<String> {
             let field = field.trim_matches(|c: char| c == '{' || c == '}' || c == ',' || c == ' ');
             if field.is_empty()
@@ -243,6 +243,7 @@ mod tests {
             }
 
             // Handle special cases and normalize the field name
+            // There might be some easier way to do this.
             let group = if field.contains("echo_audibility") {
                 "echo_audibility"
             } else if field.contains("render_levels") {
@@ -278,10 +279,6 @@ mod tests {
             }
         }
 
-        // Debug output
-        println!("Debug representation:\n{:#?}", config);
-        println!("Found groups: {:?}", found_groups);
-
         // Define expected groups based on C++ header
         let expected_groups = [
             "buffering",