Provide isAudioEnabled flag to control audio unit.

webrtc/modules/audio_device/ios/audio_device_ios.mm

 /*
  *  Copyright (c) 2012 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 43 matching lines @@
     }                                          \
   } while (0)
 
 
 // Hardcoded delay estimates based on real measurements.
 // TODO(henrika): these value is not used in combination with built-in AEC.
 // Can most likely be removed.
 const UInt16 kFixedPlayoutDelayEstimate = 30;
 const UInt16 kFixedRecordDelayEstimate = 30;
 
+enum AudioDeviceMessageType : uint32_t {
+  kMessageTypeInterruptionBegin,
+  kMessageTypeInterruptionEnd,
+  kMessageTypeValidRouteChange,
+  kMessageTypeCanPlayOrRecordChange,
+  kMessageTypeSampleRateChange,
+};
+
 using ios::CheckAndLogError;
 
 #if !defined(NDEBUG)
 // Helper method that logs essential device information strings.
 static void LogDeviceInfo() {
   LOG(LS_INFO) << "LogDeviceInfo";
   @autoreleasepool {
     LOG(LS_INFO) << " system name: " << ios::GetSystemName();
     LOG(LS_INFO) << " system version 1(2): " << ios::GetSystemVersionAsString();
     LOG(LS_INFO) << " system version 2(2): " << ios::GetSystemVersion();
     LOG(LS_INFO) << " device type: " << ios::GetDeviceType();
     LOG(LS_INFO) << " device name: " << ios::GetDeviceName();
     LOG(LS_INFO) << " process name: " << ios::GetProcessName();
     LOG(LS_INFO) << " process ID: " << ios::GetProcessID();
     LOG(LS_INFO) << " OS version: " << ios::GetOSVersionString();
     LOG(LS_INFO) << " processing cores: " << ios::GetProcessorCount();
 #if defined(__IPHONE_9_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_9_0
     LOG(LS_INFO) << " low power mode: " << ios::GetLowPowerModeEnabled();
 #endif
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
-    : async_invoker_(new rtc::AsyncInvoker()),
-      audio_device_buffer_(nullptr),
+    : audio_device_buffer_(nullptr),
       audio_unit_(nullptr),
       recording_(0),
       playing_(0),
       initialized_(false),
       rec_is_initialized_(false),
       play_is_initialized_(false),
-      is_interrupted_(false) {
+      is_interrupted_(false),
+      has_configured_session_(false) {
   LOGI() << "ctor" << ios::GetCurrentThreadDescription();
   thread_ = rtc::Thread::Current();
   audio_session_observer_ =
       [[RTCAudioSessionDelegateAdapter alloc] initWithObserver:this];
 }
 
 AudioDeviceIOS::~AudioDeviceIOS() {
   LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
   audio_session_observer_ = nil;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 204 matching lines @@
 
 int AudioDeviceIOS::GetRecordAudioParameters(AudioParameters* params) const {
   LOGI() << "GetRecordAudioParameters";
   RTC_DCHECK(record_parameters_.is_valid());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   *params = record_parameters_;
   return 0;
 }
 
 void AudioDeviceIOS::OnInterruptionBegin() {
-  RTC_DCHECK(async_invoker_);
   RTC_DCHECK(thread_);
-  if (thread_->IsCurrent()) {
-    HandleInterruptionBegin();
-    return;
-  }
-  async_invoker_->AsyncInvoke<void>(
-      thread_,
-      rtc::Bind(&webrtc::AudioDeviceIOS::HandleInterruptionBegin, this));
+  thread_->Post(this, kMessageTypeInterruptionBegin);
 }
 
 void AudioDeviceIOS::OnInterruptionEnd() {
-  RTC_DCHECK(async_invoker_);
   RTC_DCHECK(thread_);
-  if (thread_->IsCurrent()) {
-    HandleInterruptionEnd();
-    return;
-  }
-  async_invoker_->AsyncInvoke<void>(
-      thread_,
-      rtc::Bind(&webrtc::AudioDeviceIOS::HandleInterruptionEnd, this));
+  thread_->Post(this, kMessageTypeInterruptionEnd);
 }
 
 void AudioDeviceIOS::OnValidRouteChange() {
-  RTC_DCHECK(async_invoker_);
   RTC_DCHECK(thread_);
-  if (thread_->IsCurrent()) {
-    HandleValidRouteChange();
-    return;
-  }
-  async_invoker_->AsyncInvoke<void>(
-      thread_,
-      rtc::Bind(&webrtc::AudioDeviceIOS::HandleValidRouteChange, this));
+  thread_->Post(this, kMessageTypeValidRouteChange);
 }
 
-void AudioDeviceIOS::OnConfiguredForWebRTC() {
-  RTC_DCHECK(async_invoker_);
+void AudioDeviceIOS::OnCanPlayOrRecordChange(bool can_play_or_record) {
   RTC_DCHECK(thread_);
-  if (thread_->IsCurrent()) {
-    HandleValidRouteChange();
-    return;
-  }
-  async_invoker_->AsyncInvoke<void>(
-      thread_,
-      rtc::Bind(&webrtc::AudioDeviceIOS::HandleConfiguredForWebRTC, this));
+  thread_->Post(this, kMessageTypeCanPlayOrRecordChange,
+                new rtc::TypedMessageData<bool>(can_play_or_record));
 }
 
 OSStatus AudioDeviceIOS::OnDeliverRecordedData(
     AudioUnitRenderActionFlags* flags,
     const AudioTimeStamp* time_stamp,
     UInt32 bus_number,
     UInt32 num_frames,
     AudioBufferList* /* io_data */) {
   OSStatus result = noErr;
   // Simply return if recording is not enabled.
   if (!rtc::AtomicOps::AcquireLoad(&recording_))
     return result;
 
   size_t frames_per_buffer = record_parameters_.frames_per_buffer();
   if (num_frames != frames_per_buffer) {
     // We have seen short bursts (1-2 frames) where |in_number_frames| changes.
     // Add a log to keep track of longer sequences if that should ever happen.
     // Also return since calling AudioUnitRender in this state will only result
     // in kAudio_ParamError (-50) anyhow.
     RTCLogWarning(@"Expected %u frames but got %u",
                   static_cast<unsigned int>(frames_per_buffer),
                   static_cast<unsigned int>(num_frames));
+
+    RTCAudioSession *session = [RTCAudioSession sharedInstance];
+    RTCLogWarning(@"Session:\n %@", session);
     return result;
   }
 
   // Obtain the recorded audio samples by initiating a rendering cycle.
   // Since it happens on the input bus, the |io_data| parameter is a reference
   // to the preallocated audio buffer list that the audio unit renders into.
   // We can make the audio unit provide a buffer instead in io_data, but we
   // currently just use our own.
   // TODO(henrika): should error handling be improved?
   AudioBufferList* io_data = &audio_record_buffer_list_;
@@ skipping 42 matching lines @@
   }
   // Read decoded 16-bit PCM samples from WebRTC (using a size that matches
   // the native I/O audio unit) to a preallocated intermediate buffer and
   // copy the result to the audio buffer in the |io_data| destination.
   int8_t* source = playout_audio_buffer_.get();
   fine_audio_buffer_->GetPlayoutData(source);
   memcpy(destination, source, size_in_bytes);
   return noErr;
 }
 
+void AudioDeviceIOS::OnSampleRateChange(float sample_rate) {
+  RTC_DCHECK(thread_);
+  thread_->Post(this, kMessageTypeSampleRateChange,
+                new rtc::TypedMessageData<float>(sample_rate));
+}
+
+void AudioDeviceIOS::OnMessage(rtc::Message *msg) {

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

nice!

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

Acknowledged.

+  switch (msg->message_id) {
+    case kMessageTypeInterruptionBegin:
+      HandleInterruptionBegin();
+      break;
+    case kMessageTypeInterruptionEnd:
+      HandleInterruptionEnd();
+      break;
+    case kMessageTypeValidRouteChange:
+      HandleValidRouteChange();
+      break;
+    case kMessageTypeCanPlayOrRecordChange: {
+      rtc::TypedMessageData<bool>* data =
+          static_cast<rtc::TypedMessageData<bool>*>(msg->pdata);
+      HandleCanPlayOrRecordChange(data->data());
+      delete data;
+      break;
+    }
+    case kMessageTypeSampleRateChange: {
+      rtc::TypedMessageData<float>* data =
+          static_cast<rtc::TypedMessageData<float>*>(msg->pdata);
+      HandleSampleRateChange(data->data());
+      delete data;
+      break;
+    }
+  }
+}
+
 void AudioDeviceIOS::HandleInterruptionBegin() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   RTCLog(@"Stopping the audio unit due to interruption begin.");
   if (!audio_unit_->Stop()) {
     RTCLogError(@"Failed to stop the audio unit.");
   }
   is_interrupted_ = true;
 }
 
 void AudioDeviceIOS::HandleInterruptionEnd() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   RTCLog(@"Starting the audio unit due to interruption end.");
   if (!audio_unit_->Start()) {
     RTCLogError(@"Failed to start the audio unit.");
   }
   is_interrupted_ = false;
 }
 
 void AudioDeviceIOS::HandleValidRouteChange() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
-  // Don't do anything if we're interrupted.
-  if (is_interrupted_) {
-    return;
-  }
-
-  // Only restart audio for a valid route change if the session sample rate
-  // has changed.
   RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  const double current_sample_rate = playout_parameters_.sample_rate();
-  const double session_sample_rate = session.sampleRate;
-  if (current_sample_rate != session_sample_rate) {
-    RTCLog(@"Route changed caused sample rate to change from %f to %f. "
-           "Restarting audio unit.", current_sample_rate, session_sample_rate);
-    if (!RestartAudioUnit(session_sample_rate)) {
-      RTCLogError(@"Audio restart failed.");
-    }
-  }
+  HandleSampleRateChange(session.sampleRate);
 }
 
-void AudioDeviceIOS::HandleConfiguredForWebRTC() {
+void AudioDeviceIOS::HandleCanPlayOrRecordChange(bool can_play_or_record) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTCLog(@"Handling CanPlayOrRecordChange to %d", can_play_or_record);
 
   // If we're not initialized we don't need to do anything. Audio unit will
   // be initialized on initialization.
   if (!rec_is_initialized_ && !play_is_initialized_)
     return;
 
   // If we're initialized, we must have an audio unit.
   RTC_DCHECK(audio_unit_);
 
-  // Use configured audio session's settings to set up audio device buffer.
-  // TODO(tkchin): Use RTCAudioSessionConfiguration to pick up settings and
-  // pass it along.
-  SetupAudioBuffersForActiveAudioSession();
+  bool should_initialize_audio_unit = false;
+  bool should_uninitialize_audio_unit = false;
+  bool should_start_audio_unit = false;
+  bool should_stop_audio_unit = false;
 
-  // Initialize the audio unit. This will affect any existing audio playback.
-  if (!audio_unit_->Initialize(playout_parameters_.sample_rate())) {
-    RTCLogError(@"Failed to initialize audio unit after configuration.");
+  switch (audio_unit_->GetState()) {
+    case VoiceProcessingAudioUnit::kInitRequired:
+      RTC_NOTREACHED();
+      break;
+    case VoiceProcessingAudioUnit::kUninitialized:
+      should_initialize_audio_unit = can_play_or_record;
+      should_start_audio_unit = should_initialize_audio_unit &&
+          (playing_ || recording_);
+      break;
+    case VoiceProcessingAudioUnit::kInitialized:
+      should_start_audio_unit = can_play_or_record && (playing_ || recording_);
+      should_uninitialize_audio_unit = !can_play_or_record;
+      break;
+    case VoiceProcessingAudioUnit::kStarted:
+      RTC_DCHECK(playing_ || recording_);
+      should_stop_audio_unit = !can_play_or_record;
+      should_uninitialize_audio_unit = should_stop_audio_unit;
+      break;
+  }
+
+  if (should_initialize_audio_unit) {
+    RTCLog(@"Initializing audio unit for CanPlayOrRecordChange");
+    // Mad hack: Sometimes the audio session is already active because the app

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

Wow. Do you have a case where you can reliably test that this approach works?

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

Yup. With my BT headset. I'm backing out the change for now though to
investigate other approaches separately. I'd rather get the rest of this in
first to address crashes.

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

Acknowledged.

+    // activated it. In this condition, the audio session reports an inaccurate
+    // IOBufferDuration until the audio unit is started, but this causes audio
+    // artifacts. To work around it, deactivate it forcibly and reactivate it.
+    // This only works if the app has only activated the session once.
+    RTCAudioSession *session = [RTCAudioSession sharedInstance];
+    BOOL refreshAudioSession = session.isActive;
+    if (refreshAudioSession) {
+      [session lockForConfiguration];
+      [session setActive:NO error:nil];
+      [session unlockForConfiguration];
+    }
+    ConfigureAudioSession();
+    if (refreshAudioSession) {
+      [session lockForConfiguration];
+      [session setActive:YES error:nil];
+      [session unlockForConfiguration];
+    }
+    SetupAudioBuffersForActiveAudioSession();
+    if (!audio_unit_->Initialize(playout_parameters_.sample_rate())) {
+      RTCLogError(@"Failed to initialize audio unit.");
+      return;
+    }
+  }
+
+  if (should_start_audio_unit) {
+    RTCLog(@"Starting audio unit for CanPlayOrRecordChange");
+    if (!audio_unit_->Start()) {
+      RTCLogError(@"Failed to start audio unit.");
+      return;
+    }
+  }
+
+  if (should_stop_audio_unit) {
+    RTCLog(@"Stopping audio unit for CanPlayOrRecordChange");
+    if (!audio_unit_->Stop()) {
+      RTCLogError(@"Failed to stop audio unit.");
+      return;
+    }
+  }
+
+  if (should_uninitialize_audio_unit) {
+    RTCLog(@"Uninitializing audio unit for CanPlayOrRecordChange");
+    audio_unit_->Uninitialize();
+    UnconfigureAudioSession();
+  }
+}
+
+void AudioDeviceIOS::HandleSampleRateChange(float sample_rate) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Don't do anything if we're interrupted.
+  if (is_interrupted_) {
     return;
   }
 
-  // If we haven't started playing or recording there's nothing more to do.
-  if (!playing_ && !recording_)
-    return;
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  const double session_sample_rate = session.sampleRate;
+  const NSTimeInterval session_buffer_duration = session.IOBufferDuration;
+  const size_t session_frames_per_buffer =
+      static_cast<size_t>(session_sample_rate * session_buffer_duration + .5);
+  const double current_sample_rate = playout_parameters_.sample_rate();
+  const size_t current_frames_per_buffer =
+      playout_parameters_.frames_per_buffer();
+  RTCLog(@"Handling playout sample rate change to: %f\n"
+          "  Session sample rate: %f frames_per_buffer: %lu\n"
+          "  ADM sample rate: %f frames_per_buffer: %lu",
+         sample_rate,
+         session_sample_rate, (unsigned long)session_frames_per_buffer,
+         current_sample_rate, (unsigned long)current_frames_per_buffer);;
 
-  // We are in a play or record state, start the audio unit.
-  if (!audio_unit_->Start()) {
-    RTCLogError(@"Failed to start audio unit after configuration.");
-    return;
+  if (current_sample_rate != session_sample_rate ||
+      current_frames_per_buffer != session_frames_per_buffer) {
+    RTCLog(@"Restarting audio unit due to frames per buffer change.");
+    if (!RestartAudioUnit(sample_rate)) {
+      RTCLogError(@"Audio restart failed.");
+    }
   }
 }
 
 void AudioDeviceIOS::UpdateAudioDeviceBuffer() {
   LOGI() << "UpdateAudioDevicebuffer";
   // AttachAudioBuffer() is called at construction by the main class but check
   // just in case.
   RTC_DCHECK(audio_device_buffer_) << "AttachAudioBuffer must be called first";
   // Inform the audio device buffer (ADB) about the new audio format.
   audio_device_buffer_->SetPlayoutSampleRate(playout_parameters_.sample_rate());
@@ skipping 58 matching lines @@
                << required_playout_buffer_size;
   playout_audio_buffer_.reset(new SInt8[required_playout_buffer_size]);
 
   // Allocate AudioBuffers to be used as storage for the received audio.
   // The AudioBufferList structure works as a placeholder for the
   // AudioBuffer structure, which holds a pointer to the actual data buffer
   // in |record_audio_buffer_|. Recorded audio will be rendered into this memory
   // at each input callback when calling AudioUnitRender().
   const int data_byte_size = record_parameters_.GetBytesPerBuffer();
   record_audio_buffer_.reset(new SInt8[data_byte_size]);
+  memset(record_audio_buffer_.get(), 0, data_byte_size);
   audio_record_buffer_list_.mNumberBuffers = 1;
   AudioBuffer* audio_buffer = &audio_record_buffer_list_.mBuffers[0];
   audio_buffer->mNumberChannels = record_parameters_.channels();
   audio_buffer->mDataByteSize = data_byte_size;
   audio_buffer->mData = record_audio_buffer_.get();
 }
 
 bool AudioDeviceIOS::CreateAudioUnit() {
   RTC_DCHECK(!audio_unit_);
 
@@ skipping 36 matching lines @@
   // Restart the audio unit.
   if (!audio_unit_->Start()) {
     RTCLogError(@"Failed to start audio unit.");
     return false;
   }
   RTCLog(@"Successfully restarted audio unit.");
 
   return true;
 }
 
+void AudioDeviceIOS::ConfigureAudioSession() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTCLog(@"Configuring audio session.");
+  if (has_configured_session_) {
+    RTCLogWarning(@"Audio session already configured.");
+    return;
+  }
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  [session lockForConfiguration];
+  [session configureWebRTCSession:nil];
+  [session unlockForConfiguration];
+  has_configured_session_ = true;
+  RTCLog(@"Configured audio session.");
+}
+
+void AudioDeviceIOS::UnconfigureAudioSession() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTCLog(@"Unconfiguring audio session.");
+  if (!has_configured_session_) {
+    RTCLogWarning(@"Audio session already unconfigured.");
+    return;
+  }
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  [session lockForConfiguration];
+  [session unconfigureWebRTCSession:nil];
+  [session unlockForConfiguration];
+  has_configured_session_ = false;
+  RTCLog(@"Unconfigured audio session.");
+}
+
 bool AudioDeviceIOS::InitPlayOrRecord() {
   LOGI() << "InitPlayOrRecord";
 
+  // There should be no audio unit at this point.
   if (!CreateAudioUnit()) {
     return false;
   }
 
   RTCAudioSession* session = [RTCAudioSession sharedInstance];
   // Subscribe to audio session events.
   [session pushDelegate:audio_session_observer_];
 
   // Lock the session to make configuration changes.
   [session lockForConfiguration];
   NSError* error = nil;
   if (![session beginWebRTCSession:&error]) {
     [session unlockForConfiguration];
     RTCLogError(@"Failed to begin WebRTC session: %@",
                 error.localizedDescription);
     return false;
   }
 
-  // If we are already configured properly, we can initialize the audio unit.
-  if (session.isConfiguredForWebRTC) {
-    [session unlockForConfiguration];
+  // If we are ready to play or record, initialize the audio unit.
+  if (session.canPlayOrRecord) {
+    ConfigureAudioSession();
     SetupAudioBuffersForActiveAudioSession();
-    // Audio session has been marked ready for WebRTC so we can initialize the
-    // audio unit now.
     audio_unit_->Initialize(playout_parameters_.sample_rate());
-    return true;
   }
 
   // Release the lock.
   [session unlockForConfiguration];
 
   return true;
 }
 
 void AudioDeviceIOS::ShutdownPlayOrRecord() {
   LOGI() << "ShutdownPlayOrRecord";
 
   // Close and delete the voice-processing I/O unit.
-  if (audio_unit_) {
-    audio_unit_.reset();
-  }
+  audio_unit_.reset();
 
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   // Remove audio session notification observers.
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
   [session removeDelegate:audio_session_observer_];
 
   // All I/O should be stopped or paused prior to deactivating the audio
   // session, hence we deactivate as last action.
   [session lockForConfiguration];
+  UnconfigureAudioSession();
   [session endWebRTCSession:nil];
   [session unlockForConfiguration];
 }
 
 }  // namespace webrtc