Improved audio buffer handling for iOS

webrtc/modules/audio_device/android/opensles_player.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #include "webrtc/modules/audio_device/android/opensles_player.h"
 
 #include <android/log.h>
 
+#include "webrtc/base/array_view.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 
 #define TAG "OpenSLESPlayer"
 #define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
@@ skipping 177 matching lines @@
   // buffer size. The native buffer size corresponds to the
   // PROPERTY_OUTPUT_FRAMES_PER_BUFFER property which is the number of audio
   // frames that the HAL (Hardware Abstraction Layer) buffer can hold. It is
   // recommended to construct audio buffers so that they contain an exact
   // multiple of this number. If so, callbacks will occur at regular intervals,
   // which reduces jitter.
   const size_t buffer_size_in_bytes = audio_parameters_.GetBytesPerBuffer();
   ALOGD("native buffer size: %" PRIuS, buffer_size_in_bytes);
   ALOGD("native buffer size in ms: %.2f",
         audio_parameters_.GetBufferSizeInMilliseconds());
-  fine_audio_buffer_.reset(
-      new FineAudioBuffer(audio_device_buffer_, buffer_size_in_bytes,
-                          audio_parameters_.sample_rate()));
+  fine_audio_buffer_.reset(new FineAudioBuffer(audio_device_buffer_,
+                                               audio_parameters_.sample_rate(),
+                                               2 * buffer_size_in_bytes));
   // Allocated memory for audio buffers.
   for (int i = 0; i < kNumOfOpenSLESBuffers; ++i) {
     audio_buffers_[i].reset(new SLint8[buffer_size_in_bytes]);
   }
 }
 
 bool OpenSLESPlayer::ObtainEngineInterface() {
   ALOGD("ObtainEngineInterface");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (engine_)
@@ skipping 166 matching lines @@
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     // Avoid aquiring real audio data from WebRTC and fill the buffer with
     // zeros instead. Used to prime the buffer with silence and to avoid asking
     // for audio data from two different threads.
     memset(audio_ptr, 0, audio_parameters_.GetBytesPerBuffer());
   } else {
     RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
     // Read audio data from the WebRTC source using the FineAudioBuffer object
     // to adjust for differences in buffer size between WebRTC (10ms) and native
     // OpenSL ES.
-    fine_audio_buffer_->GetPlayoutData(audio_ptr);
+    fine_audio_buffer_->GetPlayoutData(rtc::ArrayView<SLint8>(
+        audio_ptr, audio_parameters_.GetBytesPerBuffer()));
   }
   // Enqueue the decoded audio buffer for playback.
   SLresult err = (*simple_buffer_queue_)
                      ->Enqueue(simple_buffer_queue_, audio_ptr,
                                audio_parameters_.GetBytesPerBuffer());
   if (SL_RESULT_SUCCESS != err) {
     ALOGE("Enqueue failed: %d", err);
   }
   buffer_index_ = (buffer_index_ + 1) % kNumOfOpenSLESBuffers;
 }
 
 SLuint32 OpenSLESPlayer::GetPlayState() const {
   RTC_DCHECK(player_);
   SLuint32 state;
   SLresult err = (*player_)->GetPlayState(player_, &state);
   if (SL_RESULT_SUCCESS != err) {
     ALOGE("GetPlayState failed: %d", err);
   }
   return state;
 }
 
 }  // namespace webrtc