Improved error handling in iOS ADM to avoid race during init

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.
  */
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 #include "webrtc/modules/utility/include/helpers_ios.h"
 
 namespace webrtc {
 
+// Protects |g_audio_session_users|.
+static rtc::GlobalLockPod g_lock;
+
+// Counts number of users (=instances of this object) who needs an active
+// audio session. This variable is used to ensure that we only activate an audio
+// session for the first user and deactivate it for the last.
+// Member is static to ensure that the value is counted for all instances
+// and not per instance.
+static int g_audio_session_users GUARDED_BY(g_lock) = 0;
+
 #define LOGI() LOG(LS_INFO) << "AudioDeviceIOS::"
 
 #define LOG_AND_RETURN_IF_ERROR(error, message) \
   do {                                          \
     OSStatus err = error;                       \
     if (err) {                                  \
       LOG(LS_ERROR) << message << ": " << err;  \
       return false;                             \
     }                                           \
   } while (0)
@@ skipping 32 matching lines @@
 // Number of bytes per audio sample for 16-bit signed integer representation.
 const UInt32 kBytesPerSample = 2;
 // 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;
 
 using ios::CheckAndLogError;
 
+// Verifies that the current audio session supports input audio and that the
+// required category and mode are enabled.
+static bool VerifyAudioSession(AVAudioSession* session) {
+  LOG(LS_INFO) << "VerifyAudioSession";
+  // Ensure that the device currently supports audio input.
+  if (!session.isInputAvailable) {
+    LOG(LS_ERROR) << "No audio input path is available!";
+    return false;
+  }
+
+  // Ensure that the required category and mode are actually activated.
+  if (![session.category isEqualToString:AVAudioSessionCategoryPlayAndRecord]) {
+    LOG(LS_ERROR)
+        << "Failed to set category to AVAudioSessionCategoryPlayAndRecord";
+    return false;
+  }
+  if (![session.mode isEqualToString:AVAudioSessionModeVoiceChat]) {
+    LOG(LS_ERROR) << "Failed to set mode to AVAudioSessionModeVoiceChat";
+    return false;
+  }
+  return true;
+}
+
 // Activates an audio session suitable for full duplex VoIP sessions when
 // |activate| is true. Also sets the preferred sample rate and IO buffer
 // duration. Deactivates an active audio session if |activate| is set to false.
-static void ActivateAudioSession(AVAudioSession* session, bool activate) {
+static bool ActivateAudioSession(AVAudioSession* session, bool activate)
+    EXCLUSIVE_LOCKS_REQUIRED(g_lock) {
   LOG(LS_INFO) << "ActivateAudioSession(" << activate << ")";
   @autoreleasepool {
     NSError* error = nil;
     BOOL success = NO;
 
     if (!activate) {
       // Deactivate the audio session using an extra option and then return.
       // AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation is used to
       // ensure that other audio sessions that were interrupted by our session
       // can return to their active state. It is recommended for VoIP apps to
       // use this option.
       success = [session
             setActive:NO
           withOptions:AVAudioSessionSetActiveOptionNotifyOthersOnDeactivation
                 error:&error];
-      RTC_DCHECK(CheckAndLogError(success, error));
-      return;
+      return CheckAndLogError(success, error);
     }
 
     // Go ahead and active our own audio session since |activate| is true.
     // Use a category which supports simultaneous recording and playback.
     // By default, using this category implies that our app’s audio is
     // nonmixable, hence activating the session will interrupt any other
     // audio sessions which are also nonmixable.
     if (session.category != AVAudioSessionCategoryPlayAndRecord) {
       error = nil;
       success = [session setCategory:AVAudioSessionCategoryPlayAndRecord
@@ skipping 11 matching lines @@
 
     // Set the session's sample rate or the hardware sample rate.
     // It is essential that we use the same sample rate as stream format
     // to ensure that the I/O unit does not have to do sample rate conversion.
     error = nil;
     success =
         [session setPreferredSampleRate:kPreferredSampleRate error:&error];
     RTC_DCHECK(CheckAndLogError(success, error));
 
     // Set the preferred audio I/O buffer duration, in seconds.
-    // TODO(henrika): add more comments here.
     error = nil;
     success = [session setPreferredIOBufferDuration:kPreferredIOBufferDuration
                                               error:&error];
     RTC_DCHECK(CheckAndLogError(success, error));
 
     // Activate the audio session. Activation can fail if another active audio
     // session (e.g. phone call) has higher priority than ours.
     error = nil;
     success = [session setActive:YES error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
-    RTC_CHECK(session.isInputAvailable) << "No input path is available!";
+    if (!CheckAndLogError(success, error)) {
+      return false;
+    }
 
-    // Ensure that category and mode are actually activated.
-    RTC_DCHECK(
-        [session.category isEqualToString:AVAudioSessionCategoryPlayAndRecord]);
-    RTC_DCHECK([session.mode isEqualToString:AVAudioSessionModeVoiceChat]);
+    // Ensure that the active audio session has the correct category and mode.
+    if (!VerifyAudioSession(session)) {
+      LOG(LS_ERROR) << "Failed to verify audio session category and mode";
+      return false;
+    }
 
     // Try to set the preferred number of hardware audio channels. These calls
     // must be done after setting the audio session’s category and mode and
     // activating the session.
     // We try to use mono in both directions to save resources and format
     // conversions in the audio unit. Some devices does only support stereo;
     // e.g. wired headset on iPhone 6.
     // TODO(henrika): add support for stereo if needed.
     error = nil;
     success =
         [session setPreferredInputNumberOfChannels:kPreferredNumberOfChannels
                                              error:&error];
     RTC_DCHECK(CheckAndLogError(success, error));
     error = nil;
     success =
         [session setPreferredOutputNumberOfChannels:kPreferredNumberOfChannels
                                               error:&error];
     RTC_DCHECK(CheckAndLogError(success, error));
+    return true;
   }
 }
 
+// An application can create more than one ADM and start audio streaming
+// for all of them. It is essential that we only activate the app's audio
+// session once (for the first one) and deactivate it once (for the last).
+static bool ActivateAudioSessionWithLock() {

[pbos-webrtc, 2015/11/20 12:29:50]

Don't need WithLock in the name here.

[henrika_webrtc, 2015/11/20 12:53:48]

Acknowledged.

+  LOGI() << "ActivateAudioSessionWithLock";
+  rtc::GlobalLockScope ls(&g_lock);
+  if (g_audio_session_users == 0) {
+    // The system provides an audio session object upon launch of an
+    // application. However, we must initialize the session in order to
+    // handle interruptions. Implicit initialization occurs when obtaining
+    // a reference to the AVAudioSession object.
+    AVAudioSession* session = [AVAudioSession sharedInstance];
+    // Try to activate the audio session and ask for a set of preferred audio
+    // parameters.
+    if (!ActivateAudioSession(session, true)) {
+      LOG(LS_ERROR) << "Failed to activate the audio session";
+      return false;
+    }
+    LOG(LS_INFO) << "The audio session is now activated";
+  }
+  ++g_audio_session_users;
+  LOG(LS_INFO) << "Number of audio session users: " << g_audio_session_users;
+  return true;
+}
+
+// If more than one object is using the audio session, ensure that only the
+// last object deactivates. Apple recommends: "activate your audio session
+// only as needed and deactivate it when you are not using audio".
+static bool DeactivateAudioSessionWithLock() {

[pbos-webrtc, 2015/11/20 12:29:50]

Same here

[henrika_webrtc, 2015/11/20 12:53:48]

Acknowledged.

+  LOGI() << "DeactivateAudioSessionWithLock";
+  rtc::GlobalLockScope ls(&g_lock);
+  if (g_audio_session_users == 1) {
+    AVAudioSession* session = [AVAudioSession sharedInstance];
+    if (!ActivateAudioSession(session, false)) {
+      LOG(LS_ERROR) << "Failed to deactivate the audio session";
+      return false;
+    }
+    LOG(LS_INFO) << "Our audio session is now deactivated";
+  }
+  --g_audio_session_users;
+  LOG(LS_INFO) << "Number of audio session users: " << g_audio_session_users;
+  return true;
+}
+
 #if !defined(NDEBUG)
 // Helper method for printing out an AudioStreamBasicDescription structure.
 static void LogABSD(AudioStreamBasicDescription absd) {
   char formatIDString[5];
   UInt32 formatID = CFSwapInt32HostToBig(absd.mFormatID);
   bcopy(&formatID, formatIDString, 4);
   formatIDString[4] = '\0';
   LOG(LS_INFO) << "LogABSD";
   LOG(LS_INFO) << " sample rate: " << absd.mSampleRate;
   LOG(LS_INFO) << " format ID: " << formatIDString;
@@ skipping 25 matching lines @@
       playing_(0),
       initialized_(false),
       rec_is_initialized_(false),
       play_is_initialized_(false),
       audio_interruption_observer_(nullptr),
       route_change_observer_(nullptr) {
   LOGI() << "ctor" << ios::GetCurrentThreadDescription();
 }
 
 AudioDeviceIOS::~AudioDeviceIOS() {
-  LOGI() << "~dtor";
+  LOGI() << "~dtor" << ios::GetCurrentThreadDescription();
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
 void AudioDeviceIOS::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
   LOGI() << "AttachAudioBuffer";
   RTC_DCHECK(audioBuffer);
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   audio_device_buffer_ = audioBuffer;
 }
@@ skipping 21 matching lines @@
   initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::Terminate() {
   LOGI() << "Terminate";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!initialized_) {
     return 0;
   }
-  ShutdownPlayOrRecord();
+  StopPlayout();
+  StopRecording();
   initialized_ = false;
+  {

[pbos-webrtc, 2015/11/20 12:29:50]

mismatched {, this can't compile

[henrika_webrtc, 2015/11/20 12:53:48]

Ooops. Fixed.

+    rtc::GlobalLockScope ls(&g_lock);
+    if (g_audio_session_users != 0) {
+      LOG(LS_WARNING) << "Object is destructed with an active audio session";
+    }
+    RTC_DCHECK_GE(g_audio_session_users, 0);
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitPlayout() {
   LOGI() << "InitPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!play_is_initialized_);
   RTC_DCHECK(!playing_);
   if (!rec_is_initialized_) {
     if (!InitPlayOrRecord()) {
-      LOG_F(LS_ERROR) << "InitPlayOrRecord failed!";
+      LOG_F(LS_ERROR) << "InitPlayOrRecord failed for InitPlayout!";
       return -1;
     }
   }
   play_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitRecording() {
   LOGI() << "InitRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!rec_is_initialized_);
   RTC_DCHECK(!recording_);
   if (!play_is_initialized_) {
     if (!InitPlayOrRecord()) {
-      LOG_F(LS_ERROR) << "InitPlayOrRecord failed!";
+      LOG_F(LS_ERROR) << "InitPlayOrRecord failed for InitRecording!";
       return -1;
     }
   }
   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_) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
-      LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result;
+      LOG_F(LS_ERROR) << "AudioOutputUnitStart failed for StartPlayout: "
+                      << result;
       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_) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
-      LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result;
+      LOG_F(LS_ERROR) << "AudioOutputUnitStart failed for StartRecording: "
+                      << result;
       return -1;
     }
+    LOG(LS_INFO) << "Voice-Processing I/O audio unit is now started";

[pbos-webrtc, 2015/11/20 12:29:50]

stopped?

[henrika_webrtc, 2015/11/20 12:53:48]

No, started. Maybe I am missing something but the comment is correct.

   }
   rtc::AtomicOps::ReleaseStore(&recording_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopRecording() {
   LOGI() << "StopRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!rec_is_initialized_ || !recording_) {
     return 0;
@@ skipping 285 matching lines @@
   record_audio_buffer_.reset(new SInt8[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::SetupAndInitializeVoiceProcessingAudioUnit() {
   LOGI() << "SetupAndInitializeVoiceProcessingAudioUnit";
-  RTC_DCHECK(!vpio_unit_);
+  RTC_DCHECK(!vpio_unit_) << "VoiceProcessingIO audio unit already exists";
   // Create an audio component description to identify the Voice-Processing
   // I/O audio unit.
   AudioComponentDescription vpio_unit_description;
   vpio_unit_description.componentType = kAudioUnitType_Output;
   vpio_unit_description.componentSubType = kAudioUnitSubType_VoiceProcessingIO;
   vpio_unit_description.componentManufacturer = kAudioUnitManufacturer_Apple;
   vpio_unit_description.componentFlags = 0;
   vpio_unit_description.componentFlagsMask = 0;
   // Obtain an audio unit instance given the description.
   AudioComponent found_vpio_unit_ref =
       AudioComponentFindNext(nullptr, &vpio_unit_description);
 
   // Create a Voice-Processing IO audio unit.
-  LOG_AND_RETURN_IF_ERROR(
-      AudioComponentInstanceNew(found_vpio_unit_ref, &vpio_unit_),
-      "Failed to create a VoiceProcessingIO audio unit");
+  OSStatus result = noErr;
+  result = AudioComponentInstanceNew(found_vpio_unit_ref, &vpio_unit_);
+  if (result != noErr) {
+    vpio_unit_ = nullptr;
+    LOG(LS_ERROR) << "AudioComponentInstanceNew failed: " << result;
+    return false;
+  }
 
   // A VP I/O unit's bus 1 connects to input hardware (microphone). Enable
   // input on the input scope of the input element.
   AudioUnitElement input_bus = 1;
   UInt32 enable_input = 1;
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioOutputUnitProperty_EnableIO,
-                           kAudioUnitScope_Input, input_bus, &enable_input,
-                           sizeof(enable_input)),
-      "Failed to enable input on input scope of input element");
+  result = AudioUnitSetProperty(vpio_unit_, kAudioOutputUnitProperty_EnableIO,
+                                kAudioUnitScope_Input, input_bus, &enable_input,
+                                sizeof(enable_input));
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR) << "Failed to enable input on input scope of input element: "
+                  << result;
+    return false;
+  }
 
   // A VP I/O unit's bus 0 connects to output hardware (speaker). Enable
   // output on the output scope of the output element.
   AudioUnitElement output_bus = 0;
   UInt32 enable_output = 1;
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioOutputUnitProperty_EnableIO,
-                           kAudioUnitScope_Output, output_bus, &enable_output,
-                           sizeof(enable_output)),
-      "Failed to enable output on output scope of output element");
+  result = AudioUnitSetProperty(vpio_unit_, kAudioOutputUnitProperty_EnableIO,
+                                kAudioUnitScope_Output, output_bus,
+                                &enable_output, sizeof(enable_output));
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR)
+        << "Failed to enable output on output scope of output element: "
+        << result;
+    return false;
+  }
 
   // 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 application_format = {0};
   UInt32 size = sizeof(application_format);
   RTC_DCHECK_EQ(playout_parameters_.sample_rate(),
                 record_parameters_.sample_rate());
   RTC_DCHECK_EQ(1, kPreferredNumberOfChannels);
   application_format.mSampleRate = playout_parameters_.sample_rate();
   application_format.mFormatID = kAudioFormatLinearPCM;
   application_format.mFormatFlags =
       kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
   application_format.mBytesPerPacket = kBytesPerSample;
   application_format.mFramesPerPacket = 1;  // uncompressed
   application_format.mBytesPerFrame = kBytesPerSample;
   application_format.mChannelsPerFrame = kPreferredNumberOfChannels;
   application_format.mBitsPerChannel = 8 * kBytesPerSample;
   // Store the new format.
   application_format_ = application_format;
 #if !defined(NDEBUG)
   LogABSD(application_format_);
 #endif
 
   // Set the application format on the output scope of the input element/bus.
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Output, input_bus,
-                           &application_format, size),
-      "Failed to set application format on output scope of input element");
+  result = AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_StreamFormat,
+                                kAudioUnitScope_Output, input_bus,
+                                &application_format, size);
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR)
+        << "Failed to set application format on output scope of input bus: "
+        << result;
+    return false;
+  }
 
   // Set the application format on the input scope of the output element/bus.
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_StreamFormat,
-                           kAudioUnitScope_Input, output_bus,
-                           &application_format, size),
-      "Failed to set application format on input scope of output element");
+  result = AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_StreamFormat,
+                                kAudioUnitScope_Input, output_bus,
+                                &application_format, size);
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR)
+        << "Failed to set application format on input scope of output bus: "
+        << result;
+    return false;
+  }
 
   // Specify the callback function that provides audio samples to the audio
   // unit.
   AURenderCallbackStruct render_callback;
   render_callback.inputProc = GetPlayoutData;
   render_callback.inputProcRefCon = this;
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_SetRenderCallback,
-                           kAudioUnitScope_Input, output_bus, &render_callback,
-                           sizeof(render_callback)),
-      "Failed to specify the render callback on the output element");
+  result = AudioUnitSetProperty(
+      vpio_unit_, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
+      output_bus, &render_callback, sizeof(render_callback));
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR) << "Failed to specify the render callback on the output bus: "
+                  << result;
+    return false;
+  }
 
   // Disable AU buffer allocation for the recorder, we allocate our own.
   // TODO(henrika): not sure that it actually saves resource to make this call.
   UInt32 flag = 0;
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_ShouldAllocateBuffer,
-                           kAudioUnitScope_Output, input_bus, &flag,
-                           sizeof(flag)),
-      "Failed to disable buffer allocation on the input element");
+  result = AudioUnitSetProperty(
+      vpio_unit_, kAudioUnitProperty_ShouldAllocateBuffer,
+      kAudioUnitScope_Output, input_bus, &flag, sizeof(flag));
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR) << "Failed to disable buffer allocation on the input bus: "
+                  << result;
+  }
 
   // Specify the callback to be called by the I/O thread to us when input audio
   // is available. The recorded samples can then be obtained by calling the
   // AudioUnitRender() method.
   AURenderCallbackStruct input_callback;
   input_callback.inputProc = RecordedDataIsAvailable;
   input_callback.inputProcRefCon = this;
-  LOG_AND_RETURN_IF_ERROR(
-      AudioUnitSetProperty(vpio_unit_,
-                           kAudioOutputUnitProperty_SetInputCallback,
-                           kAudioUnitScope_Global, input_bus, &input_callback,
-                           sizeof(input_callback)),
-      "Failed to specify the input callback on the input element");
+  result = AudioUnitSetProperty(vpio_unit_,
+                                kAudioOutputUnitProperty_SetInputCallback,
+                                kAudioUnitScope_Global, input_bus,
+                                &input_callback, sizeof(input_callback));
+  if (result != noErr) {
+    DisposeAudioUnit();
+    LOG(LS_ERROR) << "Failed to specify the input callback on the input bus: "
+                  << result;
+  }
 
   // Initialize the Voice-Processing I/O unit instance.
-  LOG_AND_RETURN_IF_ERROR(AudioUnitInitialize(vpio_unit_),
-                          "Failed to initialize the Voice-Processing I/O unit");
+  result = AudioUnitInitialize(vpio_unit_);
+  if (result != noErr) {
+    result = AudioUnitUninitialize(vpio_unit_);
+    if (result != noErr) {
+      LOG_F(LS_ERROR) << "AudioUnitUninitialize failed: " << result;
+    }
+    DisposeAudioUnit();
+    LOG(LS_ERROR) << "Failed to initialize the Voice-Processing I/O unit: "
+                  << result;
+    return false;
+  }
   return true;
 }
 
 bool AudioDeviceIOS::RestartAudioUnitWithNewFormat(float sample_rate) {
   LOGI() << "RestartAudioUnitWithNewFormat(sample_rate=" << sample_rate << ")";
   // Stop the active audio unit.
   LOG_AND_RETURN_IF_ERROR(AudioOutputUnitStop(vpio_unit_),
                           "Failed to stop the the Voice-Processing I/O unit");
 
   // The stream format is about to be changed and it requires that we first
@@ skipping 18 matching lines @@
                           "Failed to initialize the Voice-Processing I/O unit");
 
   // Start rendering audio using the new format.
   LOG_AND_RETURN_IF_ERROR(AudioOutputUnitStart(vpio_unit_),
                           "Failed to start the Voice-Processing I/O unit");
   return true;
 }
 
 bool AudioDeviceIOS::InitPlayOrRecord() {
   LOGI() << "InitPlayOrRecord";
+  // Activate the audio session if not already activated.
+  if (!ActivateAudioSessionWithLock()) {
+    return false;
+  }
+
+  // Ensure that the active audio session has the correct category and mode.
   AVAudioSession* session = [AVAudioSession sharedInstance];
-  // Activate the audio session and ask for a set of preferred audio parameters.
-  ActivateAudioSession(session, true);
+  if (!VerifyAudioSession(session)) {
+    DeactivateAudioSessionWithLock();
+    LOG(LS_ERROR) << "Failed to verify audio session category and mode";
+    return false;
+  }
 
   // Start observing audio session interruptions and route changes.
   RegisterNotificationObservers();
 
   // 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.
   if (!SetupAndInitializeVoiceProcessingAudioUnit()) {
+    // Reduce usage count for the audio session and possibly deactivate it if
+    // this object is the only user.
+    DeactivateAudioSessionWithLock();
     return false;
   }
   return true;
 }
 
-bool AudioDeviceIOS::ShutdownPlayOrRecord() {
+void AudioDeviceIOS::ShutdownPlayOrRecord() {
   LOGI() << "ShutdownPlayOrRecord";
-  // Remove audio session notification observers.
-  UnregisterNotificationObservers();
-
   // Close and delete the voice-processing I/O unit.
   OSStatus result = -1;
   if (nullptr != vpio_unit_) {
     result = AudioOutputUnitStop(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioOutputUnitStop failed: " << result;
     }
     result = AudioUnitUninitialize(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioUnitUninitialize failed: " << result;
     }
-    result = AudioComponentInstanceDispose(vpio_unit_);
-    if (result != noErr) {
-      LOG_F(LS_ERROR) << "AudioComponentInstanceDispose failed: " << result;
-    }
-    vpio_unit_ = nullptr;
+    DisposeAudioUnit();
   }
 
+  // Remove audio session notification observers.
+  UnregisterNotificationObservers();
+
   // All I/O should be stopped or paused prior to deactivating the audio
   // session, hence we deactivate as last action.
-  AVAudioSession* session = [AVAudioSession sharedInstance];
-  ActivateAudioSession(session, false);
-  return true;
+  DeactivateAudioSessionWithLock();
+}
+
+void AudioDeviceIOS::DisposeAudioUnit() {
+  if (nullptr == vpio_unit_)
+    return;
+  OSStatus result = AudioComponentInstanceDispose(vpio_unit_);
+  if (result != noErr) {
+    LOG(LS_ERROR) << "AudioComponentInstanceDispose failed:" << result;
+  }
+  vpio_unit_ = nullptr;
 }
 
 OSStatus AudioDeviceIOS::RecordedDataIsAvailable(
     void* in_ref_con,
     AudioUnitRenderActionFlags* io_action_flags,
     const AudioTimeStamp* in_time_stamp,
     UInt32 in_bus_number,
     UInt32 in_number_frames,
     AudioBufferList* io_data) {
   RTC_DCHECK_EQ(1u, in_bus_number);
@@ skipping 78 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.
   SInt8* source = playout_audio_buffer_.get();
   fine_audio_buffer_->GetPlayoutData(source);
   memcpy(destination, source, dataSizeInBytes);
   return noErr;
 }
 
 }  // namespace webrtc