Adds low complexity audio mode for single core CPUs

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 34 matching lines @@
     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 kPreferredSampleRate = 48000.0;
+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 kPreferredIOBufferDuration = 0.01;
+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;
 
-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;
   }
@@ skipping 46 matching lines @@
     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:kPreferredSampleRate error:&error];
+      [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:kPreferredIOBufferDuration
+  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;
@@ skipping 65 matching lines @@
 }
 
 // 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: " << 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();
+    LOG(LS_INFO) << " low power mode: " << ios::GetLowPowerModeEnabled();
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
     : audio_device_buffer_(nullptr),
       vpio_unit_(nullptr),
       recording_(0),
       playing_(0),
       initialized_(false),
@@ skipping 23 matching lines @@
   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()
   // 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(kPreferredSampleRate, kPreferredNumberOfChannels);
-  record_parameters_.reset(kPreferredSampleRate, kPreferredNumberOfChannels);
+  playout_parameters_.reset(GetPreferredSampleRate(),
+                            kPreferredNumberOfChannels);
+  record_parameters_.reset(GetPreferredSampleRate(),
+                           kPreferredNumberOfChannels);
   // 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 != kPreferredSampleRate) {
+  if (session.sampleRate != GetPreferredSampleRate()) {
     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 405 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