AudioTransport::NeedMorePlayData is no longer called from different threads using OpenSL ES on Andr…

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.
  */
 
@@ skipping 102 matching lines @@
   }
   // The number of lower latency audio players is limited, hence we create the
   // audio player in Start() and destroy it in Stop().
   CreateAudioPlayer();
   // Fill up audio buffers to avoid initial glitch and to ensure that playback
   // starts when mode is later changed to SL_PLAYSTATE_PLAYING.
   // TODO(henrika): we can save some delay by only making one call to
   // EnqueuePlayoutData. Most likely not worth the risk of adding a glitch.
   last_play_time_ = rtc::Time();
   for (int i = 0; i < kNumOfOpenSLESBuffers; ++i) {
-    EnqueuePlayoutData();
+    EnqueuePlayoutData(true);
   }
   // Start streaming data by setting the play state to SL_PLAYSTATE_PLAYING.
   // For a player object, when the object is in the SL_PLAYSTATE_PLAYING
   // state, adding buffers will implicitly start playback.
   RETURN_ON_ERROR((*player_)->SetPlayState(player_, SL_PLAYSTATE_PLAYING), -1);
   playing_ = (GetPlayState() == SL_PLAYSTATE_PLAYING);
   RTC_DCHECK(playing_);
   return 0;
 }
 
@@ skipping 235 matching lines @@
   stream->FillBufferQueue();
 }
 
 void OpenSLESPlayer::FillBufferQueue() {
   RTC_DCHECK(thread_checker_opensles_.CalledOnValidThread());
   SLuint32 state = GetPlayState();
   if (state != SL_PLAYSTATE_PLAYING) {
     ALOGW("Buffer callback in non-playing state!");
     return;
   }
-  EnqueuePlayoutData();
+  EnqueuePlayoutData(false);
 }
 
-void OpenSLESPlayer::EnqueuePlayoutData() {
+void OpenSLESPlayer::EnqueuePlayoutData(bool silence) {
   // Check delta time between two successive callbacks and provide a warning
   // if it becomes very large.
   // TODO(henrika): using 150ms 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 > 150) {
     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_audio_buffer_->GetPlayoutData(audio_ptr);
+  if (silence) {
+    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);
+  }
   // 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