Refactor AVAudioSession intialization code.

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"
 
+#import "webrtc/base/objc/RTCLogging.h"
 #import "webrtc/modules/audio_device/ios/objc/RTCAudioSession.h"
+#import "webrtc/modules/audio_device/ios/objc/RTCAudioSessionConfiguration.h"
 
 namespace webrtc {
 
 #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)
 
 #define LOG_IF_ERROR(error, message)           \
   do {                                         \
     OSStatus err = error;                      \
     if (err) {                                 \
       LOG(LS_ERROR) << message << ": " << err; \
     }                                          \
   } while (0)
 
-// Preferred hardware sample rate (unit is in Hertz). The client sample rate
-// will be set to this value as well to avoid resampling the the audio unit's
-// format converter. Note that, some devices, e.g. BT headsets, only supports
-// 8000Hz as native sample rate.
-const double kHighPerformanceSampleRate = 48000.0;
-// A lower sample rate will be used for devices with only one core
-// (e.g. iPhone 4). The goal is to reduce the CPU load of the application.
-const double kLowComplexitySampleRate = 16000.0;
-// Use a hardware I/O buffer size (unit is in seconds) that matches the 10ms
-// size used by WebRTC. The exact actual size will differ between devices.
-// Example: using 48kHz on iPhone 6 results in a native buffer size of
-// ~10.6667ms or 512 audio frames per buffer. The FineAudioBuffer instance will
-// take care of any buffering required to convert between native buffers and
-// buffers used by WebRTC. It is beneficial for the performance if the native
-// size is as close to 10ms as possible since it results in "clean" callback
-// sequence without bursts of callbacks back to back.
-const double kHighPerformanceIOBufferDuration = 0.01;
-// Use a larger buffer size on devices with only one core (e.g. iPhone 4).
-// It will result in a lower CPU consumption at the cost of a larger latency.
-// The size of 60ms is based on instrumentation that shows a significant
-// reduction in CPU load compared with 10ms on low-end devices.
-// TODO(henrika): monitor this size and determine if it should be modified.
-const double kLowComplexityIOBufferDuration = 0.06;
-// Try to use mono to save resources. Also avoids channel format conversion
-// in the I/O audio unit. Initial tests have shown that it is possible to use
-// mono natively for built-in microphones and for BT headsets but not for
-// wired headsets. Wired headsets only support stereo as native channel format
-// but it is a low cost operation to do a format conversion to mono in the
-// audio unit. Hence, we will not hit a RTC_CHECK in
-// VerifyAudioParametersForActiveAudioSession() for a mismatch between the
-// preferred number of channels and the actual number of channels.
-const int kPreferredNumberOfChannels = 1;
+
 // 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;
 // Calls to AudioUnitInitialize() can fail if called back-to-back on different
 // ADM instances. A fall-back solution is to allow multiple sequential calls
 // with as small delay between each. This factor sets the max number of allowed
 // initialization attempts.
 const int kMaxNumberOfAudioUnitInitializeAttempts = 5;
 
 using ios::CheckAndLogError;
 
-// Return the preferred sample rate given number of CPU cores. Use highest
-// possible if the CPU has more than one core.
-static double GetPreferredSampleRate() {
-  return (ios::GetProcessorCount() > 1) ? kHighPerformanceSampleRate
-                                        : kLowComplexitySampleRate;
-}
-
-// Return the preferred I/O buffer size given number of CPU cores. Use smallest
-// possible if the CPU has more than one core.
-static double GetPreferredIOBufferDuration() {
-  return (ios::GetProcessorCount() > 1) ? kHighPerformanceIOBufferDuration
-                                        : kLowComplexityIOBufferDuration;
-}
-
-// Verifies that the current audio session supports input audio and that the
-// required category and mode are enabled.
-static bool VerifyAudioSession(RTCAudioSession* session) {
-  LOG(LS_INFO) << "VerifyAudioSession";
-  // Ensure that the device currently supports audio input.
-  if (!session.inputAvailable) {
-    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 bool ActivateAudioSession(RTCAudioSession* session, bool activate) {
-  LOG(LS_INFO) << "ActivateAudioSession(" << activate << ")";
-
-  NSError* error = nil;
-  BOOL success = NO;
-
-  [session lockForConfiguration];
-  if (!activate) {
-    success = [session setActive:NO
-                           error:&error];
-    [session unlockForConfiguration];
-    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
-                       withOptions:AVAudioSessionCategoryOptionAllowBluetooth
-                             error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
-  }
-
-  // Specify mode for two-way voice communication (e.g. VoIP).
-  if (session.mode != AVAudioSessionModeVoiceChat) {
-    error = nil;
-    success = [session setMode:AVAudioSessionModeVoiceChat error:&error];
-    RTC_DCHECK(CheckAndLogError(success, error));
-  }
-
-  // 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:GetPreferredSampleRate() error:&error];
-  RTC_DCHECK(CheckAndLogError(success, error));
-
-  // Set the preferred audio I/O buffer duration, in seconds.
-  error = nil;
-  success = [session setPreferredIOBufferDuration:GetPreferredIOBufferDuration()
-                                            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];
-  if (!CheckAndLogError(success, error)) {
-    [session unlockForConfiguration];
-    return false;
-  }
-
-  // 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";
-    [session unlockForConfiguration];
-    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));
-  [session unlockForConfiguration];
-  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 ActivateAudioSession() {
-  LOGI() << "ActivateAudioSession";
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  return ActivateAudioSession(session, 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 DeactivateAudioSession() {
-  LOGI() << "DeactivateAudioSession";
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  return ActivateAudioSession(session, false);
-}
-
 #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 55 matching lines @@
 int32_t AudioDeviceIOS::Init() {
   LOGI() << "Init";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (initialized_) {
     return 0;
   }
 #if !defined(NDEBUG)
   LogDeviceInfo();
 #endif
   // Store the preferred sample rate and preferred number of channels already
-  // here. They have not been set and confirmed yet since ActivateAudioSession()
+  // here. They have not been set and confirmed yet since configureForWebRTC
   // is not called until audio is about to start. However, it makes sense to
   // store the parameters now and then verify at a later stage.
-  playout_parameters_.reset(GetPreferredSampleRate(),
-                            kPreferredNumberOfChannels);
-  record_parameters_.reset(GetPreferredSampleRate(),
-                           kPreferredNumberOfChannels);
+  RTCAudioSessionConfiguration* config =
+      [RTCAudioSessionConfiguration webRTCConfiguration];
+  playout_parameters_.reset(config.sampleRate,
+                            config.outputNumberOfChannels);
+  record_parameters_.reset(config.sampleRate,
+                           config.inputNumberOfChannels);
   // Ensure that the audio device buffer (ADB) knows about the internal audio
   // parameters. Note that, even if we are unable to get a mono audio session,
   // we will always tell the I/O audio unit to do a channel format conversion
   // to guarantee mono on the "input side" of the audio unit.
   UpdateAudioDeviceBuffer();
   initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::Terminate() {
@@ skipping 333 matching lines @@
   LOG(LS_INFO) << " IO buffer duration: " << session.IOBufferDuration;
   LOG(LS_INFO) << " output channels: " << session.outputNumberOfChannels;
   LOG(LS_INFO) << " input channels: " << session.inputNumberOfChannels;
   LOG(LS_INFO) << " output latency: " << session.outputLatency;
   LOG(LS_INFO) << " input latency: " << session.inputLatency;
 
   // Log a warning message for the case when we are unable to set the preferred
   // hardware sample rate but continue and use the non-ideal sample rate after
   // reinitializing the audio parameters. Most BT headsets only support 8kHz or
   // 16kHz.
-  if (session.sampleRate != GetPreferredSampleRate()) {
+  RTCAudioSessionConfiguration* webRTCConfig =
+      [RTCAudioSessionConfiguration webRTCConfiguration];
+  if (session.sampleRate != webRTCConfig.sampleRate) {
     LOG(LS_WARNING) << "Unable to set the preferred sample rate";
   }
 
   // At this stage, we also know the exact IO buffer duration and can add
   // that info to the existing audio parameters where it is converted into
   // number of audio frames.
   // Example: IO buffer size = 0.008 seconds <=> 128 audio frames at 16kHz.
   // Hence, 128 is the size we expect to see in upcoming render callbacks.
   playout_parameters_.reset(session.sampleRate, playout_parameters_.channels(),
                             session.IOBufferDuration);
@@ skipping 97 matching lines @@
 
   // 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);
+  RTC_DCHECK_EQ(1, kRTCAudioSessionPreferredNumberOfChannels);
   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.mChannelsPerFrame =
+      kRTCAudioSessionPreferredNumberOfChannels;
   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.
   result = AudioUnitSetProperty(vpio_unit_, kAudioUnitProperty_StreamFormat,
                                 kAudioUnitScope_Output, input_bus,
@@ skipping 117 matching lines @@
 
   // Start rendering audio using the new format.
   LOG_AND_RETURN_IF_ERROR(AudioOutputUnitStart(vpio_unit_),
                           "Failed to start the Voice-Processing I/O unit");
   LOG(LS_INFO) << "Voice-Processing I/O unit is now restarted";
   return true;
 }
 
 bool AudioDeviceIOS::InitPlayOrRecord() {
   LOGI() << "InitPlayOrRecord";
-  // Activate the audio session if not already activated.
-  if (!ActivateAudioSession()) {
+
+  // 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];
     return false;
   }
 
-  // Ensure that the active audio session has the correct category and mode.
-  RTCAudioSession* session = [RTCAudioSession sharedInstance];
-  if (!VerifyAudioSession(session)) {
-    DeactivateAudioSession();
-    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.
-    DeactivateAudioSession();
+    [session setActive:NO error:nil];
+    [session unlockForConfiguration];
     return false;
   }
+  [session unlockForConfiguration];
   return true;
 }
 
 void AudioDeviceIOS::ShutdownPlayOrRecord() {
   LOGI() << "ShutdownPlayOrRecord";
   // 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;
     }
     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.
-  DeactivateAudioSession();
+  RTCAudioSession* session = [RTCAudioSession sharedInstance];
+  [session lockForConfiguration];
+  [session setActive:NO error:nil];
+  [session unlockForConfiguration];
 }
 
 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;
@@ skipping 91 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