Use AudioClock to determine when audio playback has ended.

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 79 matching lines @@
 }
 
 void AudioRendererImpl::StartRendering_Locked() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPlaying);
   DCHECK(!sink_playing_);
   DCHECK_NE(algorithm_->playback_rate(), 0);
   lock_.AssertAcquired();
 
-  earliest_end_time_ = now_cb_.Run();
   sink_playing_ = true;
 
   base::AutoUnlock auto_unlock(lock_);
   sink_->Play();
 }
 
 void AudioRendererImpl::StopRendering() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(rendering_);
@@ skipping 61 matching lines @@
     DCHECK(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
 
     // Flush() may have been called while underflowed/not fully buffered.
     if (buffering_state_ != BUFFERING_HAVE_NOTHING)
       SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
 
-    earliest_end_time_ = now_cb_.Run();
     splicer_->Reset();
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
 
   // Changes in buffering state are always posted. Flush callback must only be
   // run after buffering state has been set back to nothing.
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&flush_cb_));
 }
@@ skipping 381 matching lines @@
     // Mute audio by returning 0 when not playing.
     if (state_ != kPlaying) {
       audio_clock_->WroteSilence(requested_frames, delay_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.
+    //   4) We've played all known audio data sent to hardware
     //
     // We use the following conditions to determine underflow:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We have NOT received an end of stream buffer
     //   3) We are in the kPlaying state
     //
     // Otherwise the buffer has data we can send to the device.
     const base::TimeDelta media_timestamp_before_filling =
         audio_clock_->CurrentMediaTimestamp();
     if (algorithm_->frames_buffered() > 0) {
       frames_written = algorithm_->FillBuffer(audio_bus, requested_frames);
       audio_clock_->WroteAudio(
           frames_written, delay_frames, playback_rate, algorithm_->GetTime());
     }
     audio_clock_->WroteSilence(requested_frames - frames_written, delay_frames);
 
     if (frames_written == 0) {
-      const base::TimeTicks now = now_cb_.Run();
-
       if (received_end_of_stream_ && !rendered_end_of_stream_ &&
-          now >= earliest_end_time_) {
+          audio_clock_->CurrentMediaTimestamp() ==
+              audio_clock_->last_endpoint_timestamp()) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       } else if (!received_end_of_stream_ && state_ == kPlaying) {
         if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
           algorithm_->IncreaseQueueCapacity();
           SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
         }
-      } else {
-        // We can't write any data this cycle. For example, we may have
-        // sent all available data to the audio device while not reaching
-        // |earliest_end_time_|.
       }
     }
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
     // We only want to execute |time_cb_| if time has progressed and we haven't
     // signaled end of stream yet.
     if (media_timestamp_before_filling !=
             audio_clock_->CurrentMediaTimestamp() &&
         !rendered_end_of_stream_) {
       time_cb = base::Bind(time_cb_,
                            audio_clock_->CurrentMediaTimestamp(),
                            audio_clock_->last_endpoint_timestamp());
     }
-
-    if (frames_written > 0) {
-      UpdateEarliestEndTime_Locked(
-          frames_written, playback_delay, now_cb_.Run());
-    }
   }
 
   if (!time_cb.is_null())
     task_runner_->PostTask(FROM_HERE, time_cb);
 
   DCHECK_LE(frames_written, requested_frames);
   return frames_written;
 }
 
-void AudioRendererImpl::UpdateEarliestEndTime_Locked(
-    int frames_filled, const base::TimeDelta& playback_delay,
-    const base::TimeTicks& time_now) {
-  DCHECK_GT(frames_filled, 0);
-
-  base::TimeDelta predicted_play_time = base::TimeDelta::FromMicroseconds(
-      static_cast<float>(frames_filled) * base::Time::kMicrosecondsPerSecond /
-      audio_parameters_.sample_rate());
-
-  lock_.AssertAcquired();
-  earliest_end_time_ = std::max(
-      earliest_end_time_, time_now + playback_delay + predicted_play_time);
-}
-
 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
   // OnRenderError() should be removed and the audio stack handle errors without
   // notifying clients. See http://crbug.com/234708 for details.
   HistogramRendererEvent(RENDER_ERROR);
   error_cb_.Run(PIPELINE_ERROR_DECODE);
 }
 
 void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
@@ skipping 53 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