Implemented end-of-stream callback for media::PipelineImpl.

media/filters/audio_renderer_base.cc

 // Copyright (c) 2009 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_base.h"
 
 #include <algorithm>
 
 #include "media/base/filter_host.h"
 #include "media/filters/audio_renderer_algorithm_ola.h"
 
 namespace media {
 
 AudioRendererBase::AudioRendererBase()
     : state_(kUninitialized),
+      recieved_end_of_stream_(false),
+      rendered_end_of_stream_(false),
       pending_reads_(0) {
 }
 
 AudioRendererBase::~AudioRendererBase() {
   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
 }
 
 void AudioRendererBase::Play(FilterCallback* callback) {
@@ skipping 28 matching lines @@
 
 void AudioRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK_EQ(0u, pending_reads_) << "Pending reads should have completed";
   state_ = kSeeking;
   seek_callback_.reset(callback);
 
   // Throw away everything and schedule our reads.
   last_fill_buffer_time_ = base::TimeDelta();
+  recieved_end_of_stream_ = false;
+  rendered_end_of_stream_ = false;
 
   // |algorithm_| will request more reads.
   algorithm_->FlushBuffers();
 }
 
 void AudioRendererBase::Initialize(AudioDecoder* decoder,
                                    FilterCallback* callback) {
   DCHECK(decoder);
   DCHECK(callback);
   DCHECK_EQ(kUninitialized, state_);
@@ skipping 33 matching lines @@
                          sample_rate,
                          sample_bits,
                          GetPlaybackRate(),
                          cb);
 
   // Finally, execute the start callback.
   state_ = kPaused;
   callback->Run();
 }
 
+bool AudioRendererBase::HasEnded() {
+  AutoLock auto_lock(lock_);
+  if (rendered_end_of_stream_) {
+    DCHECK(algorithm_->IsQueueEmpty())
+        << "Audio queue should be empty if we have rendered end of stream";
+  }
+  return recieved_end_of_stream_ && rendered_end_of_stream_;
+}
+
 void AudioRendererBase::OnReadComplete(Buffer* buffer_in) {
   AutoLock auto_lock(lock_);
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying);
   DCHECK_GT(pending_reads_, 0u);
   --pending_reads_;
 
   // Don't enqueue an end-of-stream buffer because it has no data.
-  if (!buffer_in->IsEndOfStream()) {
+  if (buffer_in->IsEndOfStream()) {
+    recieved_end_of_stream_ = true;
+  } else {
     // Note: Calling this may schedule more reads.
     algorithm_->EnqueueBuffer(buffer_in);
   }
 
   // Check for our preroll complete condition.
   if (state_ == kSeeking) {
     DCHECK(seek_callback_.get());
-    if (algorithm_->IsQueueFull() || buffer_in->IsEndOfStream()) {
+    if (algorithm_->IsQueueFull() || recieved_end_of_stream_) {
       // Transition into paused whether we have data in |algorithm_| or not.
       // FillBuffer() will play silence if there's nothing to fill.
       state_ = kPaused;
       seek_callback_->Run();
       seek_callback_.reset();
     }
   } else if (state_ == kPaused && pending_reads_ == 0) {
     // No more pending reads!  We're now officially "paused".
     if (pause_callback_.get()) {
       pause_callback_->Run();
@@ skipping 24 matching lines @@
       return dest_written;
     }
 
     // Save a local copy of last fill buffer time and reset the member.
     last_fill_buffer_time = last_fill_buffer_time_;
     last_fill_buffer_time_ = base::TimeDelta();
 
     // Do the fill.
     dest_written = algorithm_->FillBuffer(dest, dest_len);
 
+    // Check if we finally reached end of stream by emptying |algorithm_|.
+    if (recieved_end_of_stream_ && algorithm_->IsQueueEmpty()) {
+      if (!rendered_end_of_stream_) {
+        rendered_end_of_stream_ = true;
+        host()->NotifyEnded();
+      }
+    }
+
     // Get the current time.
     last_fill_buffer_time_ = algorithm_->GetTime();
   }
 
   // Update the pipeline's time if it was set last time.
   if (last_fill_buffer_time.InMicroseconds() > 0 &&
       last_fill_buffer_time != last_fill_buffer_time_) {
     // Adjust the |last_fill_buffer_time| with the playback delay.
     // TODO(hclam): If there is a playback delay, the pipeline would not be
     // updated with a correct timestamp when the stream is played at the very
@@ skipping 30 matching lines @@
 
 void AudioRendererBase::SetPlaybackRate(float playback_rate) {
   algorithm_->set_playback_rate(playback_rate);
 }
 
 float AudioRendererBase::GetPlaybackRate() {
   return algorithm_->playback_rate();
 }
 
 }  // namespace media