Support delayed AudioUnit initialization.

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 173 matching lines @@
   }
   rec_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartPlayout() {
   LOGI() << "StartPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(play_is_initialized_);
   RTC_DCHECK(!playing_);
-  fine_audio_buffer_->ResetPlayout();
-  if (!recording_) {
+  if (fine_audio_buffer_) {
+    fine_audio_buffer_->ResetPlayout();
+  }
+  if (!recording_ &&
+      audio_unit_->GetState() == VoiceProcessingAudioUnit::kInitialized) {
     if (!audio_unit_->Start()) {
       RTCLogError(@"StartPlayout failed to start audio unit.");
       return -1;
     }
     LOG(LS_INFO) << "Voice-Processing I/O audio unit is now started";
   }
   rtc::AtomicOps::ReleaseStore(&playing_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopPlayout() {
   LOGI() << "StopPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!play_is_initialized_ || !playing_) {
     return 0;
   }
   if (!recording_) {
     ShutdownPlayOrRecord();
   }
   play_is_initialized_ = false;
   rtc::AtomicOps::ReleaseStore(&playing_, 0);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartRecording() {
   LOGI() << "StartRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(rec_is_initialized_);
   RTC_DCHECK(!recording_);
-  fine_audio_buffer_->ResetRecord();
-  if (!playing_) {
+  if (fine_audio_buffer_) {
+    fine_audio_buffer_->ResetRecord();
+  }
+  if (!playing_ &&
+      audio_unit_->GetState() == VoiceProcessingAudioUnit::kInitialized) {
     if (!audio_unit_->Start()) {
       RTCLogError(@"StartRecording failed to start audio unit.");
       return -1;
     }
     LOG(LS_INFO) << "Voice-Processing I/O audio unit is now started";
   }
   rtc::AtomicOps::ReleaseStore(&recording_, 1);
   return 0;
 }
 
@@ skipping 103 matching lines @@
   RTC_DCHECK(thread_);
   if (thread_->IsCurrent()) {
     HandleValidRouteChange();
     return;
   }
   async_invoker_->AsyncInvoke<void>(
       thread_,
       rtc::Bind(&webrtc::AudioDeviceIOS::HandleValidRouteChange, this));
 }
 
+void AudioDeviceIOS::OnConfiguredForWebRTC() {
+  RTC_DCHECK(async_invoker_);
+  RTC_DCHECK(thread_);
+  if (thread_->IsCurrent()) {
+    HandleValidRouteChange();
+    return;
+  }
+  async_invoker_->AsyncInvoke<void>(
+      thread_,
+      rtc::Bind(&webrtc::AudioDeviceIOS::HandleConfiguredForWebRTC, this));
+}
+
 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;
@@ skipping 64 matching lines @@
   // 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::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.");
     }
   }
 }
 
+void AudioDeviceIOS::HandleConfiguredForWebRTC() {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+
+  // 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();
+
+  // 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.");
+    return;
+  }
+
+  // If we haven't started playing or recording there's nothing more to do.
+  if (!playing_ && !recording_)
+    return;
+
+  // 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;
+  }
+}
+
 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());
   audio_device_buffer_->SetPlayoutChannels(playout_parameters_.channels());
   audio_device_buffer_->SetRecordingSampleRate(
       record_parameters_.sample_rate());
@@ skipping 114 matching lines @@
     return false;
   }
   RTCLog(@"Successfully restarted audio unit.");
 
   return true;
 }
 
 bool AudioDeviceIOS::InitPlayOrRecord() {
   LOGI() << "InitPlayOrRecord";
 
-  // Use the correct audio session configuration for WebRTC.
-  // This will attempt to activate the audio session.
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  [session lockForConfiguration];
-  NSError* error = nil;
-  if (![session configureWebRTCSession:&error]) {
-    RTCLogError(@"Failed to configure WebRTC session: %@",
-                error.localizedDescription);
-    [session unlockForConfiguration];
+  if (!CreateAudioUnit()) {
     return false;
   }
 
-  // Start observing audio session interruptions and route changes.
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  // Subscribe to audio session events.
   [session pushDelegate:audio_session_observer_];
 
-  // Ensure that we got what what we asked for in our active audio session.
-  SetupAudioBuffersForActiveAudioSession();
-
-  // Create, setup and initialize a new Voice-Processing I/O unit.
-  // TODO(tkchin): Delay the initialization when needed.
-  if (!CreateAudioUnit() ||
-      !audio_unit_->Initialize(playout_parameters_.sample_rate())) {
-    [session setActive:NO error:nil];
+  // 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];
+    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_->Stop();
-    audio_unit_->Uninitialize();
     audio_unit_.reset();
   }
 
   // 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];
-  [session setActive:NO error:nil];
+  [session endWebRTCSession:nil];
   [session unlockForConfiguration];
 }
 
 }  // namespace webrtc