Provide isAudioEnabled flag to control audio unit.

webrtc/modules/audio_device/ios/voice_processing_audio_unit.mm

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 157 matching lines @@
   state_ = kUninitialized;
   return true;
 }
 
 VoiceProcessingAudioUnit::State VoiceProcessingAudioUnit::GetState() const {
   return state_;
 }
 
 bool VoiceProcessingAudioUnit::Initialize(Float64 sample_rate) {
   RTC_DCHECK_GE(state_, kUninitialized);
-  RTCLog(@"Initializing audio unit.");
+  RTCLog(@"Initializing audio unit with sample rate: %f", sample_rate);
 
   OSStatus result = noErr;
   AudioStreamBasicDescription format = GetFormat(sample_rate);
   UInt32 size = sizeof(format);
 #if !defined(NDEBUG)
   LogStreamDescription(format);
 #endif
 
   // Set the format on the output scope of the input element/bus.
   result =
@@ skipping 32 matching lines @@
     ++failed_initalize_attempts;
     if (failed_initalize_attempts == kMaxNumberOfAudioUnitInitializeAttempts) {
       // Max number of initialization attempts exceeded, hence abort.
       RTCLogError(@"Too many initialization attempts.");
       return false;
     }
     RTCLog(@"Pause 100ms and try audio unit initialization again...");
     [NSThread sleepForTimeInterval:0.1f];
     result = AudioUnitInitialize(vpio_unit_);
   }
-  RTCLog(@"Voice Processing I/O unit is now initialized.");
+  if (result == noErr) {
+    RTCLog(@"Voice Processing I/O unit is now initialized.");
+  }
   state_ = kInitialized;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Start() {
   RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Starting audio unit.");
 
-  OSStatus result = AudioOutputUnitStart(vpio_unit_);
+  OSStatus result =

[henrika_webrtc, 2016/05/04 12:33:07]

Perhaps a comment regarding why we need this listener.

Apple states "Listen for this property when you do care what the hardware sample
rate is and you want to match your audio processing to the hardware sample rate
(this is the typical case).

The Audio Unit will send you a notification when the hardware sample rate
changes. Your application will need to stop rendering, reconfigure any
processing being done for the new sample rate, then start rendering again. The
sample rate change will be on the Output scope of Bus 0.

Your application should check the rate when called and only do any
reconfiguration when the new rate is different from the current rate. When the
sample rates differ, stop rendering, reconfiguring your audio processing to the
new sample rate and then restart."

[tkchin_webrtc, 2016/05/05 23:23:28]

Removing these changes for now. Will address BT issues separately.

[henrika_webrtc, 2016/05/06 11:22:17]

Acknowledged.

+      AudioUnitAddPropertyListener(vpio_unit_, kAudioUnitProperty_SampleRate,
+                                   OnSampleRateChange, this);
+  if (result != noErr) {
+    RTCLogError(@"Failed to add sample rate listener. Error=%ld.",
+                (long)result);
+  }
+
+  result = AudioOutputUnitStart(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to start audio unit. Error=%ld", (long)result);
     return false;
+  } else {
+    RTCLog(@"Started audio unit");
   }
   state_ = kStarted;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Stop() {
   RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Stopping audio unit.");
 
   OSStatus result = AudioOutputUnitStop(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to stop audio unit. Error=%ld", (long)result);
     return false;
+  } else {
+    RTCLog(@"Stopped audio unit");
   }
+
+  result =

[henrika_webrtc, 2016/05/04 12:33:07]

Do we need a check that it is disabled at close?

[tkchin_webrtc, 2016/05/05 23:23:28]

Removing these changes for now. Will address BT issues separately.

[henrika_webrtc, 2016/05/06 11:22:16]

Acknowledged.

+      AudioUnitRemovePropertyListenerWithUserData(vpio_unit_,
+                                                  kAudioUnitProperty_SampleRate,
+                                                  OnSampleRateChange, this);
+  if (result != noErr) {
+    RTCLogError(@"Failed to remove sample rate listener. Error=%ld.",
+                (long)result);
+  }
+
   state_ = kInitialized;
   return true;
 }
 
 bool VoiceProcessingAudioUnit::Uninitialize() {
   RTC_DCHECK_GE(state_, kUninitialized);
   RTCLog(@"Unintializing audio unit.");
 
   OSStatus result = AudioUnitUninitialize(vpio_unit_);
   if (result != noErr) {
     RTCLogError(@"Failed to uninitialize audio unit. Error=%ld", (long)result);
     return false;
+  } else {
+    RTCLog(@"Uninitialized audio unit.");
   }
   return true;
 }
 
 OSStatus VoiceProcessingAudioUnit::Render(AudioUnitRenderActionFlags* flags,
                                           const AudioTimeStamp* time_stamp,
                                           UInt32 output_bus_number,
                                           UInt32 num_frames,
                                           AudioBufferList* io_data) {
   RTC_DCHECK(vpio_unit_) << "Init() not called.";
@@ skipping 25 matching lines @@
     const AudioTimeStamp* time_stamp,
     UInt32 bus_number,
     UInt32 num_frames,
     AudioBufferList* io_data) {
   VoiceProcessingAudioUnit* audio_unit =
       static_cast<VoiceProcessingAudioUnit*>(in_ref_con);
   return audio_unit->NotifyDeliverRecordedData(flags, time_stamp, bus_number,
                                                num_frames, io_data);
 }
 
+void VoiceProcessingAudioUnit::OnSampleRateChange(

[henrika_webrtc, 2016/05/04 12:33:07]

Can we now get this callback and the routing change callback?
Conflicts?

[tkchin_webrtc, 2016/05/05 23:23:28]

There shouldn't be conflicts - we are always using the sample rate from the
audio session.

[henrika_webrtc, 2016/05/06 11:22:17]

Acknowledged.

+    void* in_ref_con,
+    AudioUnit audio_unit,
+    AudioUnitPropertyID property_id,
+    AudioUnitScope scope,
+    AudioUnitElement element) {
+  VoiceProcessingAudioUnit* vp_unit =
+      static_cast<VoiceProcessingAudioUnit*>(in_ref_con);
+  vp_unit->NotifySampleRateChange(audio_unit, property_id, scope, element);
+}
+
 OSStatus VoiceProcessingAudioUnit::NotifyGetPlayoutData(
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* time_stamp,
     UInt32 bus_number,
     UInt32 num_frames,
     AudioBufferList* io_data) {
   return observer_->OnGetPlayoutData(flags, time_stamp, bus_number, num_frames,
                                      io_data);
 }
 
 OSStatus VoiceProcessingAudioUnit::NotifyDeliverRecordedData(
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* time_stamp,
     UInt32 bus_number,
     UInt32 num_frames,
     AudioBufferList* io_data) {
   return observer_->OnDeliverRecordedData(flags, time_stamp, bus_number,
                                           num_frames, io_data);
 }
 
+void VoiceProcessingAudioUnit::NotifySampleRateChange(
+    AudioUnit audio_unit,
+    AudioUnitPropertyID property_id,
+    AudioUnitScope scope,
+    AudioUnitElement element) {
+  RTC_DCHECK_EQ(audio_unit, vpio_unit_);
+  RTC_DCHECK_EQ(property_id, kAudioUnitProperty_SampleRate);
+  // We only care about the output.

[henrika_webrtc, 2016/05/04 12:33:07]

Have you really been able to trigger callback on other scope/bus?

[tkchin_webrtc, 2016/05/05 23:23:28]

Nope. But just in case.

[henrika_webrtc, 2016/05/06 11:22:17]

Acknowledged.

+  if (scope != kAudioUnitScope_Output || element != kOutputBus) {
+    return;
+  }
+  Float64 sample_rate = 0;
+  UInt32 sample_rate_size = sizeof(Float64);
+  OSStatus status = AudioUnitGetProperty(audio_unit,
+                                         kAudioUnitProperty_SampleRate,
+                                         kAudioUnitScope_Output,
+                                         kOutputBus,
+                                         &sample_rate,
+                                         &sample_rate_size);
+  if (status != noErr) {
+    RTCLogError(@"Failed to get sample rate. Error=%ld.", (long)status);
+    return;
+  }
+  observer_->OnSampleRateChange(sample_rate);
+}
+
 AudioStreamBasicDescription VoiceProcessingAudioUnit::GetFormat(
     Float64 sample_rate) const {
   // Set the application formats for input and output:
   // - use same format in both directions
   // - avoid resampling in the I/O unit by using the hardware sample rate
   // - linear PCM => noncompressed audio data format with one frame per packet
   // - no need to specify interleaving since only mono is supported
   AudioStreamBasicDescription format = {0};
   RTC_DCHECK_EQ(1, kRTCAudioSessionPreferredNumberOfChannels);
   format.mSampleRate = sample_rate;
@@ skipping 25 matching lines @@
     OSStatus result = AudioComponentInstanceDispose(vpio_unit_);
     if (result != noErr) {
       RTCLogError(@"AudioComponentInstanceDispose failed. Error=%ld.",
                   (long)result);
     }
     vpio_unit_ = nullptr;
   }
 }
 
 }  // namespace webrtc