Remember input processing params after reinit

Author: Pehrsons

src/backend/mod.rs

@@ -2536,6 +2536,7 @@ struct CoreStreamData<'ctx> {
     // Info of the I/O devices.
     input_device: device_info,
     output_device: device_info,
+    input_processing_params: InputProcessingParams,
     input_buffer_manager: Option<BufferManager>,
     // Listeners indicating what system events are monitored.
     default_input_listener: Option<device_property_listener>,
@@ -2574,6 +2575,7 @@ impl<'ctx> Default for CoreStreamData<'ctx> {
             output_unit: ptr::null_mut(),
             input_device: device_info::default(),
             output_device: device_info::default(),
+            input_processing_params: InputProcessingParams::NONE,
             input_buffer_manager: None,
             default_input_listener: None,
             default_output_listener: None,
@@ -2618,6 +2620,7 @@ impl<'ctx> CoreStreamData<'ctx> {
             output_unit: ptr::null_mut(),
             input_device: in_dev,
             output_device: out_dev,
+            input_processing_params: InputProcessingParams::NONE,
             input_buffer_manager: None,
             default_input_listener: None,
             default_output_listener: None,
@@ -3439,12 +3442,14 @@ impl<'ctx> CoreStreamData<'ctx> {
                 );
             }
 
-            // Always initiate to not use input processing.
+            // Always try to remember the applied input processing params. If they cannot
+            // be applied in the new device pair, we notify the client of an error and it
+            // will have to open a new stream.
             if let Err(r) =
-                set_input_processing_params(self.input_unit, InputProcessingParams::NONE)
+                set_input_processing_params(self.input_unit, self.input_processing_params)
             {
                 cubeb_log!(
-                    "({:p}) Failed to enable bypass of voiceprocessing. Error: {}",
+                    "({:p}) Failed to set params of voiceprocessing. Error: {}",
                     self.stm_ptr,
                     r
                 );
@@ -4323,6 +4328,7 @@ impl<'ctx> StreamOps for AudioUnitStream<'ctx> {
             self as *const AudioUnitStream,
             params
         );
+        self.core_stream_data.input_processing_params = params;
         Ok(())
     }
     #[cfg(target_os = "ios")]

src/backend/tests/interfaces.rs

@@ -1061,6 +1061,65 @@ fn test_ops_duplex_voice_stream_set_input_processing_params_before_start() {
     );
 }
 
+#[test]
+fn test_ops_duplex_voice_stream_set_input_processing_params_before_start_with_reinit() {
+    test_default_duplex_voice_stream_operation(
+        "duplex voice stream: processing before start",
+        |stream| {
+            let params: ffi::cubeb_input_processing_params =
+                ffi::CUBEB_INPUT_PROCESSING_PARAM_ECHO_CANCELLATION
+                    | ffi::CUBEB_INPUT_PROCESSING_PARAM_NOISE_SUPPRESSION
+                    | ffi::CUBEB_INPUT_PROCESSING_PARAM_AUTOMATIC_GAIN_CONTROL;
+            assert_eq!(
+                unsafe { OPS.stream_set_input_processing_params.unwrap()(stream, params) },
+                ffi::CUBEB_OK
+            );
+            assert_eq!(unsafe { OPS.stream_start.unwrap()(stream) }, ffi::CUBEB_OK);
+
+            // Hacky cast, but testing this here was simplest for now.
+            let stm = unsafe { &mut *(stream as *mut AudioUnitStream) };
+            stm.reinit_async();
+            let queue = stm.queue.clone();
+            let mut params_after_reinit: ffi::cubeb_input_processing_params =
+                ffi::CUBEB_INPUT_PROCESSING_PARAM_NONE;
+            queue.run_sync(|| {
+                let mut params: ffi::cubeb_input_processing_params =
+                    ffi::CUBEB_INPUT_PROCESSING_PARAM_NONE;
+                let mut agc: u32 = 0;
+                let r = audio_unit_get_property(
+                    stm.core_stream_data.input_unit,
+                    kAUVoiceIOProperty_VoiceProcessingEnableAGC,
+                    kAudioUnitScope_Global,
+                    AU_IN_BUS,
+                    &mut agc,
+                    &mut mem::size_of::<u32>(),
+                );
+                assert_eq!(r, NO_ERR);
+                if agc == 1 {
+                    params = params | ffi::CUBEB_INPUT_PROCESSING_PARAM_AUTOMATIC_GAIN_CONTROL;
+                }
+                let mut bypass: u32 = 0;
+                let r = audio_unit_get_property(
+                    stm.core_stream_data.input_unit,
+                    kAUVoiceIOProperty_BypassVoiceProcessing,
+                    kAudioUnitScope_Global,
+                    AU_IN_BUS,
+                    &mut bypass,
+                    &mut mem::size_of::<u32>(),
+                );
+                assert_eq!(r, NO_ERR);
+                if bypass == 0 {
+                    params = params
+                        | ffi::CUBEB_INPUT_PROCESSING_PARAM_ECHO_CANCELLATION
+                        | ffi::CUBEB_INPUT_PROCESSING_PARAM_NOISE_SUPPRESSION;
+                }
+                params_after_reinit = params;
+            });
+            assert_eq!(params, params_after_reinit);
+        },
+    );
+}
+
 #[test]
 fn test_ops_duplex_voice_stream_set_input_processing_params_after_start() {
     test_default_duplex_voice_stream_operation(