Fix VirtualAudioInputStream callback timing issues.

media/audio/virtual_audio_input_stream.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/virtual_audio_input_stream.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 41 matching lines @@
     base::MessageLoopProxy* message_loop) {
   return new VirtualAudioInputStream(manager, params, message_loop);
 }
 
 VirtualAudioInputStream::VirtualAudioInputStream(
     AudioManagerBase* manager, const AudioParameters& params,
     base::MessageLoopProxy* message_loop)
     : audio_manager_(manager),
       message_loop_(message_loop),
       callback_(NULL),
-      buffer_duration_ms_(base::TimeDelta::FromMilliseconds(
-          params.frames_per_buffer() * base::Time::kMillisecondsPerSecond /
+      buffer_duration_(base::TimeDelta::FromMicroseconds(
+          params.frames_per_buffer() * base::Time::kMicrosecondsPerSecond /
           static_cast<float>(params.sample_rate()))),
       buffer_(new uint8[params.GetBytesPerBuffer()]),
       params_(params),
       audio_bus_(AudioBus::Create(params_)),
       mixer_(params_, params_, false),
       num_attached_outputs_streams_(0) {
 }
 
 VirtualAudioInputStream::~VirtualAudioInputStream() {
   for (AudioConvertersMap::iterator it = converters_.begin();
        it != converters_.end(); ++it)
     delete it->second;
 
   DCHECK_EQ(0, num_attached_outputs_streams_);
 }
 
 bool VirtualAudioInputStream::Open() {
   memset(buffer_.get(), 0, params_.GetBytesPerBuffer());
   return true;
 }
 
 void VirtualAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   callback_ = callback;
+  next_read_time_ = base::Time::Now();
   on_more_data_cb_.Reset(base::Bind(&VirtualAudioInputStream::ReadAudio,
                                     base::Unretained(this)));
   audio_manager_->GetMessageLoop()->PostTask(FROM_HERE,
                                              on_more_data_cb_.callback());
 }
 
 void VirtualAudioInputStream::Stop() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   on_more_data_cb_.Cancel();
 }
@@ skipping 34 matching lines @@
   audio_bus_->ToInterleaved(params_.frames_per_buffer(),
                             params_.bits_per_sample() / 8,
                             buffer_.get());
 
   callback_->OnData(this,
                     buffer_.get(),
                     params_.GetBytesPerBuffer(),
                     params_.GetBytesPerBuffer(),
                     1.0);
 
+  // Need to account for time spent here due to renderer side mixing as well as
+  // the imprecision of PostDelayedTask.
+  next_read_time_ += buffer_duration_;
+  base::Time now = base::Time::Now();
+  base::TimeDelta delay = next_read_time_ - now;
+  if (delay < base::TimeDelta()) {
+    // Reset the next read time if we end up getting too far behind. We'll just
+    // slow down playback to avoid using up all the CPU.
+    delay = buffer_duration_;
+    next_read_time_ = now;
+  }
+
   message_loop_->PostDelayedTask(FROM_HERE,
                                  on_more_data_cb_.callback(),
-                                 buffer_duration_ms_);
+                                 delay);
 }
 
 void VirtualAudioInputStream::Close() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (callback_) {
     DCHECK(on_more_data_cb_.IsCancelled());
     callback_->OnClose(this);
     callback_ = NULL;
   }
   audio_manager_->ReleaseInputStream(this);
 }
 
 double VirtualAudioInputStream::GetMaxVolume() {
   return 1.0;
 }
 
 void VirtualAudioInputStream::SetVolume(double volume) {}
 
 double VirtualAudioInputStream::GetVolume() {
   return 1.0;
 }
 
 void VirtualAudioInputStream::SetAutomaticGainControl(bool enabled) {}
 
 bool VirtualAudioInputStream::GetAutomaticGainControl() {
   return false;
 }
 
 }  // namespace media