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 67 matching lines @@
 }
 
 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_ms_;
+  base::TimeDelta delay = next_read_time_ - base::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 = base::TimeDelta();
+    next_read_time_ = base::Time::Now();

[DaleCurtis, 2013/01/17 00:10:51]

I'd save base::Time::Now() from the first call instead of calling it twice. This
still seems like it might be prone to cycles. Have you tried logging how
frequently callbacks fall behind?

[justinlin, 2013/01/17 22:21:05]

Done. Updated this: delay should be set to the buffer duration (i.e. we'll just
schedule it at normal time if we're really behind).

Yea, I put logging to see how often this happens and it's pretty much almost
always behind by a little. Roughly ~200us due to posttask's imprecision and
~400us-ish for the time in the audio conversions.

+  }
+
   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