Switch to using media::TimeSource inside media::RendererImpl.

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>
 
@@ skipping 43 matching lines @@
                                                  set_decryptor_ready_cb)),
       hardware_config_(hardware_config),
       playback_rate_(0),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
-      last_timestamp_update_(kNoTimestamp()),
       weak_factory_(this) {
   audio_buffer_stream_->set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
   audio_buffer_stream_->set_config_change_observer(base::Bind(
       &AudioRendererImpl::OnConfigChange, weak_factory_.GetWeakPtr()));
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 67 matching lines @@
 void AudioRendererImpl::SetMediaTime(base::TimeDelta time) {
   DVLOG(1) << __FUNCTION__ << "(" << time.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!rendering_);
   DCHECK_EQ(state_, kFlushed);
 
   start_timestamp_ = time;
   ended_timestamp_ = kInfiniteDuration();
+  last_render_ticks_ = base::TimeTicks();
   audio_clock_.reset(new AudioClock(time, audio_parameters_.sample_rate()));
 }
 
 base::TimeDelta AudioRendererImpl::CurrentMediaTime() {
   DVLOG(2) << __FUNCTION__;
-  DCHECK(task_runner_->BelongsToCurrentThread());
 
-  // TODO(scherkus): Finish implementing when ready to switch Pipeline to using
-  // TimeSource http://crbug.com/370634
-  NOTIMPLEMENTED();
+  base::AutoLock auto_lock(lock_);
+  return audio_clock_->front_timestamp();

[xhwang, 2014/09/08 22:56:06]

Add a comment that since this is updated pretty frequently, we don't need
interpolation? Is there any lower bound on the update frequency we can rely on?

[scherkus (not reviewing), 2014/09/09 18:17:18]

Done.

+}
 
-  return base::TimeDelta();
+base::TimeDelta AudioRendererImpl::ApproximateCurrentMediaTime() {
+  DVLOG(2) << __FUNCTION__;
+
+  base::AutoLock auto_lock(lock_);
+  if (last_render_ticks_.is_null())
+    return audio_clock_->front_timestamp();
+
+  return audio_clock_->TimestampSinceWriting(base::TimeTicks::Now() -
+                                             last_render_ticks_);
 }
 
 TimeSource* AudioRendererImpl::GetTimeSource() {
   return this;
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 23 matching lines @@
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock auto_lock(lock_);
 
     DCHECK_EQ(state_, kFlushed);
     DCHECK(!flush_cb_.is_null());
 
-    audio_clock_.reset();
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
-    last_timestamp_update_ = kNoTimestamp();
 
     // Flush() may have been called while underflowed/not fully buffered.
     if (buffering_state_ != BUFFERING_HAVE_NOTHING)
       SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
 
     splicer_->Reset();
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
@@ skipping 13 matching lines @@
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
 
   ChangeState_Locked(kPlaying);
   AttemptRead_Locked();
 }
 
 void AudioRendererImpl::Initialize(DemuxerStream* stream,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
-                                   const TimeCB& time_cb,
                                    const BufferingStateCB& buffering_state_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
-  DCHECK(!time_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   DCHECK(sink_.get());
 
   state_ = kInitializing;
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
-  time_cb_ = time_cb;
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
 
   expecting_config_changes_ = stream->SupportsConfigChanges();
   if (!expecting_config_changes_) {
     // The actual buffer size is controlled via the size of the AudioBus
     // provided to Render(), so just choose something reasonable here for looks.
     int buffer_size = stream->audio_decoder_config().samples_per_second() / 100;
     audio_parameters_.Reset(
@@ skipping 266 matching lines @@
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
   const int requested_frames = audio_bus->frames();
   base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
       audio_delay_milliseconds);
   const int delay_frames = static_cast<int>(playback_delay.InSecondsF() *
                                             audio_parameters_.sample_rate());
   int frames_written = 0;
   {
     base::AutoLock auto_lock(lock_);
+    last_render_ticks_ = base::TimeTicks::Now();
 
     // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
     if (!algorithm_) {
       audio_clock_->WroteAudio(
           0, requested_frames, delay_frames, playback_rate_);
       return 0;
     }
 
     if (playback_rate_ == 0) {
       audio_clock_->WroteAudio(
@@ skipping 50 matching lines @@
                              requested_frames,
                              delay_frames,
                              playback_rate_);
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
-    if (last_timestamp_update_ != audio_clock_->front_timestamp()) {
-      // Since |max_time| uses linear interpolation, only provide an upper bound
-      // that is for audio data at the same playback rate. Failing to do so can
-      // make time jump backwards when the linear interpolated time advances
-      // past buffered regions of audio at different rates.
-      last_timestamp_update_ = audio_clock_->front_timestamp();
-      base::TimeDelta max_time =
-          last_timestamp_update_ +
-          audio_clock_->contiguous_audio_data_buffered_at_same_rate();
-      task_runner_->PostTask(
-          FROM_HERE, base::Bind(time_cb_, last_timestamp_update_, max_time));
-
-      if (last_timestamp_update_ >= ended_timestamp_ &&
-          !rendered_end_of_stream_) {
-        rendered_end_of_stream_ = true;
-        task_runner_->PostTask(FROM_HERE, ended_cb_);
-      }
+    if (audio_clock_->front_timestamp() >= ended_timestamp_ &&
+        !rendered_end_of_stream_) {
+      rendered_end_of_stream_ = true;
+      task_runner_->PostTask(FROM_HERE, ended_cb_);
     }
   }
 
   DCHECK_LE(frames_written, requested_frames);
   return frames_written;
 }
 
 void AudioRendererImpl::OnRenderError() {
   // UMA data tells us this happens ~0.01% of the time. Trigger an error instead
   // of trying to gracefully fall back to a fake sink. It's very likely
@@ skipping 62 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media