OpenSL ES stability improvements

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/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_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__)
 #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
 #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 #define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__)
 #define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
 
@@ skipping 11 matching lines @@
 OpenSLESPlayer::OpenSLESPlayer(AudioManager* audio_manager)
     : audio_parameters_(audio_manager->GetPlayoutAudioParameters()),
       audio_device_buffer_(NULL),
       initialized_(false),
       playing_(false),
       bytes_per_buffer_(0),
       buffer_index_(0),
       engine_(nullptr),
       player_(nullptr),
       simple_buffer_queue_(nullptr),
-      volume_(nullptr) {
+      volume_(nullptr),
+      last_play_time_(0) {
   ALOGD("ctor%s", GetThreadInfo().c_str());
   // Use native audio output parameters provided by the audio manager and
   // define the PCM format structure.
   pcm_format_ = CreatePCMConfiguration(audio_parameters_.channels(),
                                        audio_parameters_.sample_rate(),
                                        audio_parameters_.bits_per_sample());
   // Detach from this thread since we want to use the checker to verify calls
   // from the internal  audio thread.
   thread_checker_opensles_.DetachFromThread();
 }
@@ skipping 28 matching lines @@
 
 int OpenSLESPlayer::InitPlayout() {
   ALOGD("InitPlayout%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(!initialized_);
   RTC_DCHECK(!playing_);
   CreateEngine();
   CreateMix();
   initialized_ = true;
   buffer_index_ = 0;
+  last_play_time_ = rtc::Time();
   return 0;
 }
 
 int OpenSLESPlayer::StartPlayout() {
   ALOGD("StartPlayout%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!playing_);
   // The number of lower latency audio players is limited, hence we create the
   // audio player in Start() and destroy it in Stop().
@@ skipping 118 matching lines @@
     RTC_CHECK(false) << "Unsupported number of channels: "
                      << format.numChannels;
   return format;
 }
 
 void OpenSLESPlayer::AllocateDataBuffers() {
   ALOGD("AllocateDataBuffers");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(!simple_buffer_queue_);
   RTC_CHECK(audio_device_buffer_);
-  bytes_per_buffer_ = audio_parameters_.GetBytesPerBuffer();
+  // Don't use the lowest possible size as native buffer size. Instead,
+  // use 10ms to better match the frame size that WebRTC uses. It will result
+  // in a reduced risk for audio glitches and also in a more "clean" sequence
+  // of callbacks from the OpenSL ES thread in to WebRTC when asking for audio
+  // to render.
+  ALOGD("lowest possible buffer size: %" PRIuS,
+      audio_parameters_.GetBytesPerBuffer());
+  bytes_per_buffer_ = audio_parameters_.GetBytesPerFrame() *
+      audio_parameters_.frames_per_10ms_buffer();
+  RTC_DCHECK_GT(bytes_per_buffer_, audio_parameters_.GetBytesPerBuffer());
   ALOGD("native buffer size: %" PRIuS, bytes_per_buffer_);
   // Create a modified audio buffer class which allows us to ask for any number
   // of samples (and not only multiple of 10ms) to match the native OpenSL ES
   // buffer size.
   fine_buffer_.reset(new FineAudioBuffer(audio_device_buffer_,
                                          bytes_per_buffer_,
                                          audio_parameters_.sample_rate()));
   // Each buffer must be of this size to avoid unnecessary memcpy while caching
   // data between successive callbacks.
   const size_t required_buffer_size =
@@ skipping 164 matching lines @@
   RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
   SLuint32 state = GetPlayState();
   if (state != SL_PLAYSTATE_PLAYING) {
     ALOGW("Buffer callback in non-playing state!");
     return;
   }
   EnqueuePlayoutData();
 }
 
 void OpenSLESPlayer::EnqueuePlayoutData() {
+  // Check delta time between two successive callbacks and provide a warning
+  // if it becomes very large.
+  // TODO(henrika): using 100ms as upper limit but this value is rather random.
+  const uint32_t current_time = rtc::Time();
+  const uint32_t diff = current_time - last_play_time_;
+  if (diff > 100) {
+    ALOGW("Bad OpenSL ES playout timing, dT=%u [ms]", diff);
+  }
+  last_play_time_ = current_time;
   // 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.
   SLint8* audio_ptr = audio_buffers_[buffer_index_].get();
   fine_buffer_->GetPlayoutData(audio_ptr);
   // Enqueue the decoded audio buffer for playback.
   SLresult err =
       (*simple_buffer_queue_)
           ->Enqueue(simple_buffer_queue_, audio_ptr, bytes_per_buffer_);
   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