Stop enqueueing data to output audio device if consecutive empty buffers are received

media/audio/android/opensles_output.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/android/opensles_output.h"
 
 #include "base/logging.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/android/audio_manager_android.h"
 
 #define LOG_ON_FAILURE_AND_RETURN(op, ...)      \
   do {                                          \
     SLresult err = (op);                        \
     if (err != SL_RESULT_SUCCESS) {             \
       DLOG(ERROR) << #op << " failed: " << err; \
       return __VA_ARGS__;                       \
     }                                           \
   } while (0)
 
 namespace media {
 
+// Threshold for consecutive number of empty buffers to let the player enter
+// idle state.
+// TODO(qinmin): change this threshold to count the number of frames.
+static const int kEmptyBufferThreasholdForIdleMode = 2;
+
 OpenSLESOutputStream::OpenSLESOutputStream(AudioManagerAndroid* manager,
                                            const AudioParameters& params,
                                            SLint32 stream_type)
     : audio_manager_(manager),
       stream_type_(stream_type),
       callback_(NULL),
       player_(NULL),
       simple_buffer_queue_(NULL),
       active_buffer_index_(0),
       buffer_size_bytes_(0),
       started_(false),
       muted_(false),
-      volume_(1.0) {
+      volume_(1.0),
+      consecutive_empty_buffer_count_(0),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      weak_factory_(this) {
   DVLOG(2) << "OpenSLESOutputStream::OpenSLESOutputStream("
            << "stream_type=" << stream_type << ")";
   format_.formatType = SL_DATAFORMAT_PCM;
   format_.numChannels = static_cast<SLuint32>(params.channels());
   // Provides sampling rate in milliHertz to OpenSLES.
   format_.samplesPerSec = static_cast<SLuint32>(params.sample_rate() * 1000);
   format_.bitsPerSample = params.bits_per_sample();
   format_.containerSize = params.bits_per_sample();
   format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
   if (format_.numChannels == 1)
     format_.channelMask = SL_SPEAKER_FRONT_CENTER;
   else if (format_.numChannels == 2)
     format_.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
   else
     NOTREACHED() << "Unsupported number of channels: " << format_.numChannels;
 
   buffer_size_bytes_ = params.GetBytesPerBuffer();
   audio_bus_ = AudioBus::Create(params);
 
   memset(&audio_data_, 0, sizeof(audio_data_));
+  weak_this_ = weak_factory_.GetWeakPtr();
+  audio_timestamp_helper_.reset(new AudioTimestampHelper(params.sample_rate()));
 }
 
 OpenSLESOutputStream::~OpenSLESOutputStream() {
   DVLOG(2) << "OpenSLESOutputStream::~OpenSLESOutputStream()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!engine_object_.Get());
   DCHECK(!player_object_.Get());
   DCHECK(!output_mixer_.Get());
   DCHECK(!player_);
   DCHECK(!simple_buffer_queue_);
@@ skipping 23 matching lines @@
   DCHECK(simple_buffer_queue_);
   if (started_)
     return;
 
   base::AutoLock lock(lock_);
   DCHECK(callback_ == NULL || callback_ == callback);
   callback_ = callback;
 
   // Avoid start-up glitches by filling up one buffer queue before starting
   // the stream.
-  FillBufferQueueNoLock();
+  FillBufferQueueNoLock(false);
 
   // 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.
   LOG_ON_FAILURE_AND_RETURN(
       (*player_)->SetPlayState(player_, SL_PLAYSTATE_PLAYING));
 
   started_ = true;
 }
 
@@ skipping 18 matching lines @@
   // Verify that the buffer queue is in fact cleared as it should.
   SLAndroidSimpleBufferQueueState buffer_queue_state;
   LOG_ON_FAILURE_AND_RETURN((*simple_buffer_queue_)->GetState(
       simple_buffer_queue_, &buffer_queue_state));
   DCHECK_EQ(0u, buffer_queue_state.count);
   DCHECK_EQ(0u, buffer_queue_state.index);
 #endif
 
   callback_ = NULL;
   started_ = false;
+  CancelIdleCheck();
+  consecutive_empty_buffer_count_ = 0;
 }
 
 void OpenSLESOutputStream::Close() {
   DVLOG(2) << "OpenSLESOutputStream::Close()";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Stop the stream if it is still playing.
   Stop();
   {
     // Destroy the buffer queue player object and invalidate all associated
@@ skipping 13 matching lines @@
   }
 
   audio_manager_->ReleaseOutputStream(this);
 }
 
 void OpenSLESOutputStream::SetVolume(double volume) {
   DVLOG(2) << "OpenSLESOutputStream::SetVolume(" << volume << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
 
   double volume_override = 0;
-  if (audio_manager_->HasOutputVolumeOverride(&volume_override)) {
+  if (audio_manager_->HasOutputVolumeOverride(&volume_override))
     volume = volume_override;
-  }
 
   float volume_float = static_cast<float>(volume);
-  if (volume_float < 0.0f || volume_float > 1.0f) {
+  if (volume_float < 0.0f || volume_float > 1.0f)
     return;
-  }
   volume_ = volume_float;
 }
 
 void OpenSLESOutputStream::GetVolume(double* volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
   *volume = static_cast<double>(volume_);
 }
 
 void OpenSLESOutputStream::SetMute(bool muted) {
   DVLOG(2) << "OpenSLESOutputStream::SetMute(" << muted << ")";
@@ skipping 124 matching lines @@
     HandleError(err);
     return;
   }
   if (state != SL_PLAYSTATE_PLAYING) {
     DLOG(WARNING) << "Received callback in non-playing state";
     return;
   }
 
   // Fill up one buffer in the queue by asking the registered source for
   // data using the OnMoreData() callback.
-  FillBufferQueueNoLock();
+  FillBufferQueueNoLock(false);
 }
 
-void OpenSLESOutputStream::FillBufferQueueNoLock() {
+void OpenSLESOutputStream::FillBufferQueueNoLock(bool in_idle_mode) {
   // Ensure that the calling thread has acquired the lock since it is not
   // done in this method.
   lock_.AssertAcquired();
 
   // Read data from the registered client source.
   // TODO(henrika): Investigate if it is possible to get a more accurate
   // delay estimation.
   const uint32 hardware_delay = buffer_size_bytes_;
-  int frames_filled = callback_->OnMoreData(
-      audio_bus_.get(), hardware_delay);
+  int frames_filled = callback_->OnMoreData(audio_bus_.get(), hardware_delay);
   if (frames_filled <= 0) {
     // Audio source is shutting down, or halted on error.
     return;
   }
 
+  // Skip enqueueing data if the output is empty to save power.
+  if (audio_bus_->AreFramesZero()) {
+    // TODO(qinmin): check if this variable overflows.
+    consecutive_empty_buffer_count_++;
+    if (consecutive_empty_buffer_count_ >= kEmptyBufferThreasholdForIdleMode) {
+      WaitingForAudio(in_idle_mode, frames_filled, base::TimeTicks::Now());
+      return;
+    }
+  } else {
+    consecutive_empty_buffer_count_ = 0;
+  }
+
   // Note: If the internal representation ever changes from 16-bit PCM to
   // raw float, the data must be clipped and sanitized since it may come
   // from an untrusted source such as NaCl.
   audio_bus_->Scale(muted_ ? 0.0f : volume_);
   audio_bus_->ToInterleaved(frames_filled,
                             format_.bitsPerSample / 8,
                             audio_data_[active_buffer_index_]);
 
   const int num_filled_bytes =
       frames_filled * audio_bus_->channels() * format_.bitsPerSample / 8;
   DCHECK_LE(static_cast<size_t>(num_filled_bytes), buffer_size_bytes_);
 
   // Enqueue the buffer for playback.
   SLresult err =
       (*simple_buffer_queue_)->Enqueue(simple_buffer_queue_,
                                        audio_data_[active_buffer_index_],
                                        num_filled_bytes);
   if (SL_RESULT_SUCCESS != err)
     HandleError(err);
 
   active_buffer_index_ = (active_buffer_index_ + 1) % kMaxNumOfBuffersInQueue;
 }
 
 void OpenSLESOutputStream::SetupAudioBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!audio_data_[0]);
-  for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
+  for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i)
     audio_data_[i] = new uint8[buffer_size_bytes_];
-  }
 }
 
 void OpenSLESOutputStream::ReleaseAudioBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (audio_data_[0]) {
     for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
       delete[] audio_data_[i];
       audio_data_[i] = NULL;
     }
   }
 }
 
 void OpenSLESOutputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Output error " << error;
   if (callback_)
     callback_->OnError(this);
+  CancelIdleCheck();
+}
+
+void OpenSLESOutputStream::CheckForIdle() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!idle_check_callback_.IsCancelled());
+
+  if (!started_)
+    return;
+  base::AutoLock lock(lock_);
+  FillBufferQueueNoLock(true);
+}
+
+void OpenSLESOutputStream::CancelIdleCheck() {
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&OpenSLESOutputStream::CancelIdleCheck, weak_this_));
+    return;
+  }
+  idle_check_callback_.Cancel();
+}
+
+void OpenSLESOutputStream::WaitingForAudio(
+    bool in_idle_mode, int frames_filled, base::TimeTicks idle_start_time) {
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&OpenSLESOutputStream::WaitingForAudio,
+                   weak_this_, in_idle_mode, frames_filled, idle_start_time));
+    return;
+  }
+
+  if (!in_idle_mode) {
+    audio_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
+    idle_start_time_ = idle_start_time;
+    idle_check_callback_.Reset(
+        base::Bind(&OpenSLESOutputStream::CheckForIdle, weak_this_));
+  }
+
+  audio_timestamp_helper_->AddFrames(frames_filled);
+  base::TimeDelta delay_to_next_read = audio_timestamp_helper_->GetTimestamp() +
+      (idle_start_time_ - base::TimeTicks::Now());
+  if (delay_to_next_read < base::TimeDelta())
+    delay_to_next_read = base::TimeDelta();
+  task_runner_->PostDelayedTask(
+      FROM_HERE,
+      idle_check_callback_.callback(),
+      delay_to_next_read);
 }
 
 }  // namespace media