Introduce AudioClock to improve playback delay calculations.

media/filters/audio_renderer_impl.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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
+#include "media/filters/buffered_audio_tracker.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
 namespace {
 
 enum AudioRendererEvent {
   INITIALIZED,
   RENDER_ERROR,
   RENDER_EVENT_MAX = RENDER_ERROR,
@@ skipping 87 matching lines @@
 
 void AudioRendererImpl::DoPause_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (sink_playing_) {
     {
       base::AutoUnlock auto_unlock(lock_);
       sink_->Pause();
     }
+    buffered_audio_tracker_->AudioCallbackFired(0);
     sink_playing_ = false;
   }
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   DCHECK(flush_cb_.is_null());
@@ skipping 141 matching lines @@
     const AudioParameters& hw_params = hardware_config_->GetOutputConfig();
     audio_parameters_.Reset(hw_params.format(),
                             hw_params.channel_layout(),
                             hw_params.channels(),
                             hw_params.input_channels(),
                             hw_params.sample_rate(),
                             hw_params.bits_per_sample(),
                             hardware_config_->GetHighLatencyBufferSize());
   }
 
+  buffered_audio_tracker_.reset(
+      new BufferedAudioTracker(audio_parameters_.sample_rate()));
+
   audio_buffer_stream_.Initialize(
       stream,
       statistics_cb,
       base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 258 matching lines @@
   DCHECK_EQ(state_, kPrerolling);
   return buffer && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < preroll_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
   const int requested_frames = audio_bus->frames();
   base::TimeDelta current_time = kNoTimestamp();
   base::TimeDelta max_time = kNoTimestamp();
-  base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
-      audio_delay_milliseconds);
 
   int frames_written = 0;
   base::Closure underflow_cb;
   {
     base::AutoLock auto_lock(lock_);
 
+    // Convert milliseconds of delay into frames of delay.
+    buffered_audio_tracker_->AudioCallbackFired(static_cast<int>(
+        static_cast<float>(audio_delay_milliseconds) /
+        base::Time::kMillisecondsPerSecond * audio_parameters_.sample_rate()));
+
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
-    if (!algorithm_)
+    if (!algorithm_) {
+      buffered_audio_tracker_->WroteSilence(requested_frames);

[scherkus (not reviewing), 2014/04/29 17:22:06]

alternatively, we can delete buffered_audio_tracker_ and only (re)create it when
we know we're in steady state

I'm not too sure if we can assume that returning 0 frames is equivalent to
writing the requested amount of frames of silence ...

[DaleCurtis, 2014/04/29 17:55:54]

I don't think you need to track this. algorithm_ should only be NULL after
Stop() which means shutdown is imminent.

In general I think that assumption is sound, as it's what the AudioRendererMixer
will end up doing.

       return 0;
+    }
 
     float playback_rate = algorithm_->playback_rate();
-    if (playback_rate == 0)
+    if (playback_rate == 0) {
+      buffered_audio_tracker_->WroteSilence(requested_frames);
       return 0;
+    }
 
     // Mute audio by returning 0 when not playing.
-    if (state_ != kPlaying)
+    if (state_ != kPlaying) {
+      buffered_audio_tracker_->WroteSilence(requested_frames);
       return 0;
+    }
 
     // We use the following conditions to determine end of playback:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We received an end of stream buffer
     //   3) We haven't already signalled that we've ended
     //   4) Our estimated earliest end time has expired
     //
     // TODO(enal): we should replace (4) with a check that the browser has no
     // more audio data or at least use a delayed callback.
     //
@@ skipping 22 matching lines @@
         // |earliest_end_time_|.
       }
     }
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
-    // Adjust the delay according to playback rate.
-    base::TimeDelta adjusted_playback_delay = base::TimeDelta::FromMicroseconds(
-        ceil(playback_delay.InMicroseconds() * playback_rate));
+    // Update buffered audio stats.
+    base::TimeDelta playback_delay = buffered_audio_tracker_->BufferedTime();
+    if (frames_written > 0)
+      buffered_audio_tracker_->WroteAudio(frames_written, playback_rate);
+    if (frames_written < requested_frames)
+      buffered_audio_tracker_->WroteSilence(requested_frames - frames_written);
 
     // The |audio_time_buffered_| is the ending timestamp of the last frame
     // buffered at the audio device. |playback_delay| is the amount of time
     // buffered at the audio device. The current time can be computed by their
     // difference.
     if (audio_time_buffered_ != kNoTimestamp()) {
       base::TimeDelta previous_time = current_time_;
-      current_time_ = audio_time_buffered_ - adjusted_playback_delay;
+      current_time_ = audio_time_buffered_ - playback_delay;
 
       // Time can change in one of two ways:
       //   1) The time of the audio data at the audio device changed, or
       //   2) The playback delay value has changed
       //
       // We only want to set |current_time| (and thus execute |time_cb_|) if
       // time has progressed and we haven't signaled end of stream yet.
       //
       // Why? The current latency of the system results in getting the last call
       // to FillBuffer() later than we'd like, which delays firing the 'ended'
       // event, which delays the looping/trigging performance of short sound
       // effects.
       //
       // TODO(scherkus): revisit this and switch back to relying on playback
       // delay after we've revamped our audio IPC subsystem.
       if (current_time_ > previous_time && !rendered_end_of_stream_) {
         current_time = current_time_;
       }
     } else if (frames_written > 0) {
       // Nothing has been buffered yet, so use the first buffer's timestamp.
       DCHECK(time_before_filling != kNoTimestamp());
-      current_time_ = current_time =
-          time_before_filling - adjusted_playback_delay;
+      current_time_ = current_time = time_before_filling - playback_delay;
     }
 
     // The call to FillBuffer() on |algorithm_| has increased the amount of
     // buffered audio data. Update the new amount of time buffered.
     max_time = algorithm_->GetTime();
     audio_time_buffered_ = max_time;
 
     if (frames_written > 0) {
       UpdateEarliestEndTime_Locked(
           frames_written, playback_delay, now_cb_.Run());
@@ skipping 89 matching lines @@
   DCHECK(expecting_config_changes_);
   buffer_converter_->ResetTimestampState();
   // Drain flushed buffers from the converter so the AudioSplicer receives all
   // data ahead of any OnNewSpliceBuffer() calls.  Since discontinuities should
   // only appear after config changes, AddInput() should never fail here.
   while (buffer_converter_->HasNextBuffer())
     CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
 }
 
 }  // namespace media