Improved audio buffer handling for iOS

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.
  */
 
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
 #include "webrtc/modules/audio_device/ios/audio_device_ios.h"
 
 #include <cmath>
 
+#include "webrtc/base/array_view.h"
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 #include "webrtc/sdk/objc/Framework/Classes/helpers.h"
 
@@ skipping 34 matching lines @@
 enum AudioDeviceMessageType : uint32_t {
   kMessageTypeInterruptionBegin,
   kMessageTypeInterruptionEnd,
   kMessageTypeValidRouteChange,
   kMessageTypeCanPlayOrRecordChange,
 };
 
 using ios::CheckAndLogError;
 
 #if !defined(NDEBUG)
+// Returns true when the code runs on a device simulator.
+static bool DeviceIsSimulator() {
+  return ios::GetDeviceName() == "x86_64";
+}
+
 // 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) && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) \
     && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_9_0
     LOG(LS_INFO) << " low power mode: " << ios::GetLowPowerModeEnabled();
 #endif
+#if TARGET_IPHONE_SIMULATOR
+    LOG(LS_INFO) << " TARGET_IPHONE_SIMULATOR is defined";
+#endif
+    LOG(LS_INFO) << " DeviceIsSimulator: " << DeviceIsSimulator();
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
     : audio_device_buffer_(nullptr),
       audio_unit_(nullptr),
       recording_(0),
       playing_(0),
       initialized_(false),
@@ skipping 289 matching lines @@
   }
 
   // Get a pointer to the recorded audio and send it to the WebRTC ADB.
   // Use the FineAudioBuffer instance to convert between native buffer size
   // and the 10ms buffer size used by WebRTC.
   AudioBuffer* audio_buffer = &io_data->mBuffers[0];
   const size_t size_in_bytes = audio_buffer->mDataByteSize;
   RTC_CHECK_EQ(size_in_bytes / VoiceProcessingAudioUnit::kBytesPerSample,
                num_frames);
   int8_t* data = static_cast<int8_t*>(audio_buffer->mData);
-  fine_audio_buffer_->DeliverRecordedData(data, size_in_bytes,
+  fine_audio_buffer_->DeliverRecordedData(rtc::ArrayView<const int8_t>(data, size_in_bytes),
                                           kFixedPlayoutDelayEstimate,
                                           kFixedRecordDelayEstimate);
   return noErr;
 }
 
 OSStatus AudioDeviceIOS::OnGetPlayoutData(AudioUnitRenderActionFlags* flags,
                                           const AudioTimeStamp* time_stamp,
                                           UInt32 bus_number,
                                           UInt32 num_frames,
                                           AudioBufferList* io_data) {
   // Verify 16-bit, noninterleaved mono PCM signal format.
   RTC_DCHECK_EQ(1, io_data->mNumberBuffers);
   AudioBuffer* audio_buffer = &io_data->mBuffers[0];
   RTC_DCHECK_EQ(1, audio_buffer->mNumberChannels);
   // Get pointer to internal audio buffer to which new audio data shall be
   // written.
   const size_t size_in_bytes = audio_buffer->mDataByteSize;
   RTC_CHECK_EQ(size_in_bytes / VoiceProcessingAudioUnit::kBytesPerSample,
                num_frames);
   int8_t* destination = reinterpret_cast<int8_t*>(audio_buffer->mData);
   // Produce silence and give audio unit a hint about it if playout is not
   // activated.
   if (!rtc::AtomicOps::AcquireLoad(&playing_)) {
     *flags |= kAudioUnitRenderAction_OutputIsSilence;
     memset(destination, 0, size_in_bytes);
     return noErr;
   }
-  // Produce silence and log a warning message for the case when Core Audio is
-  // asking for an invalid number of audio frames. I don't expect this to happen
-  // but it is done as a safety measure to avoid bad audio if such as case would
-  // ever be triggered e.g. in combination with BT devices.
-  const size_t frames_per_buffer = playout_parameters_.frames_per_buffer();
-  if (num_frames != frames_per_buffer) {
-    RTCLogWarning(@"Expected %u frames but got %u",
-                  static_cast<unsigned int>(frames_per_buffer),
-                  static_cast<unsigned int>(num_frames));
-    *flags |= kAudioUnitRenderAction_OutputIsSilence;
-    memset(destination, 0, size_in_bytes);
-    return noErr;
-  }
 
   // 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);
+  // the native I/O audio unit) and copy the result to the audio buffer in the
+  // |io_data| destination.
+  fine_audio_buffer_->GetPlayoutData(rtc::ArrayView<int8_t>(destination, size_in_bytes));
   return noErr;
 }
 
 void AudioDeviceIOS::OnMessage(rtc::Message *msg) {
   switch (msg->message_id) {
     case kMessageTypeInterruptionBegin:
       HandleInterruptionBegin();
       break;
     case kMessageTypeInterruptionEnd:
       HandleInterruptionEnd();
@@ skipping 169 matching lines @@
   LOG(LS_INFO) << " bytes per I/O buffer: "
                << playout_parameters_.GetBytesPerBuffer();
   RTC_DCHECK_EQ(playout_parameters_.GetBytesPerBuffer(),
                 record_parameters_.GetBytesPerBuffer());
 
   // Update the ADB parameters since the sample rate might have changed.
   UpdateAudioDeviceBuffer();
 
   // Create a modified audio buffer class which allows us to ask for,
   // or deliver, any number of samples (and not only multiple of 10ms) to match
-  // the native audio unit buffer size.
+  // the native audio unit buffer size. Use a reasonable capacity to avoid
+  // reallocations while audio is played to reduce risk of glitches.
   RTC_DCHECK(audio_device_buffer_);
-  const size_t buffer_size_in_bytes = playout_parameters_.GetBytesPerBuffer();
+  const size_t capacity_in_bytes = 2 * playout_parameters_.GetBytesPerBuffer();
   fine_audio_buffer_.reset(new FineAudioBuffer(
-      audio_device_buffer_, buffer_size_in_bytes,
-      playout_parameters_.sample_rate()));
-  playout_audio_buffer_.reset(new SInt8[buffer_size_in_bytes]);
+      audio_device_buffer_, playout_parameters_.sample_rate(), capacity_in_bytes));
 
   // 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;
@@ skipping 185 matching lines @@
 
   // 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