Remember input mute state after reinit

Author: Pehrsons

src/backend/mod.rs

@@ -285,7 +285,26 @@ fn get_volume(unit: AudioUnit) -> Result<f32> {
 
 fn set_input_mute(unit: AudioUnit, mute: bool) -> Result<()> {
     assert!(!unit.is_null());
-    let mute: UInt32 = mute.into();
+    let mute: u32 = mute.into();
+    let mut old_mute: u32 = 0;
+    let r = audio_unit_get_property(
+        unit,
+        kAUVoiceIOProperty_MuteOutput,
+        kAudioUnitScope_Global,
+        AU_IN_BUS,
+        &mut old_mute,
+        &mut mem::size_of::<u32>(),
+    );
+    if r != NO_ERR {
+        cubeb_log!(
+            "AudioUnitGetProperty/kAUVoiceIOProperty_MuteOutput rv={}",
+            r
+        );
+        return Err(Error::error());
+    }
+    if old_mute == mute {
+        return Ok(());
+    }
     let r = audio_unit_set_property(
         unit,
         kAUVoiceIOProperty_MuteOutput,
@@ -2536,6 +2555,7 @@ struct CoreStreamData<'ctx> {
     input_device: device_info,
     output_device: device_info,
     input_processing_params: InputProcessingParams,
+    input_mute: bool,
     input_buffer_manager: Option<BufferManager>,
     // Listeners indicating what system events are monitored.
     default_input_listener: Option<device_property_listener>,
@@ -2575,6 +2595,7 @@ impl<'ctx> Default for CoreStreamData<'ctx> {
             input_device: device_info::default(),
             output_device: device_info::default(),
             input_processing_params: InputProcessingParams::NONE,
+            input_mute: false,
             input_buffer_manager: None,
             default_input_listener: None,
             default_output_listener: None,
@@ -2620,6 +2641,7 @@ impl<'ctx> CoreStreamData<'ctx> {
             input_device: in_dev,
             output_device: out_dev,
             input_processing_params: InputProcessingParams::NONE,
+            input_mute: false,
             input_buffer_manager: None,
             default_input_listener: None,
             default_output_listener: None,
@@ -3441,6 +3463,18 @@ impl<'ctx> CoreStreamData<'ctx> {
                 );
             }
 
+            // Always try to remember the applied input mute state. If it cannot be applied
+            // to 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_mute(self.input_unit, self.input_mute) {
+                cubeb_log!(
+                    "({:p}) Failed to set mute state of voiceprocessing. Error: {}",
+                    self.stm_ptr,
+                    r
+                );
+                return Err(r);
+            }
+
             // 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.
@@ -4287,6 +4321,7 @@ impl<'ctx> StreamOps for AudioUnitStream<'ctx> {
             self as *const AudioUnitStream,
             mute
         );
+        self.core_stream_data.input_mute = mute;
         Ok(())
     }
     fn set_input_processing_params(&mut self, params: InputProcessingParams) -> Result<()> {

src/backend/tests/interfaces.rs

@@ -1018,6 +1018,54 @@ fn test_ops_duplex_voice_stream_set_input_mute() {
     });
 }
 
+#[test]
+fn test_ops_duplex_voice_stream_set_input_mute_before_start() {
+    test_default_duplex_voice_stream_operation(
+        "duplex voice stream: mute before start",
+        |stream| {
+            assert_eq!(
+                unsafe { OPS.stream_set_input_mute.unwrap()(stream, 1) },
+                ffi::CUBEB_OK
+            );
+            assert_eq!(unsafe { OPS.stream_start.unwrap()(stream) }, ffi::CUBEB_OK);
+        },
+    );
+}
+
+#[test]
+fn test_ops_duplex_voice_stream_set_input_mute_before_start_with_reinit() {
+    test_default_duplex_voice_stream_operation(
+        "duplex voice stream: mute before start with reinit",
+        |stream| {
+            assert_eq!(
+                unsafe { OPS.stream_set_input_mute.unwrap()(stream, 1) },
+                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 mute_after_reinit = false;
+            queue.run_sync(|| {
+                let mut mute: u32 = 0;
+                let r = audio_unit_get_property(
+                    stm.core_stream_data.input_unit,
+                    kAUVoiceIOProperty_MuteOutput,
+                    kAudioUnitScope_Global,
+                    AU_IN_BUS,
+                    &mut mute,
+                    &mut mem::size_of::<u32>(),
+                );
+                assert_eq!(r, NO_ERR);
+                mute_after_reinit = mute == 1;
+            });
+            assert_eq!(mute_after_reinit, true);
+        },
+    );
+}
+
 #[test]
 fn test_ops_duplex_voice_stream_set_input_mute_after_start() {
     test_default_duplex_voice_stream_operation("duplex voice stream: mute after start", |stream| {