Move VideoRenderer out of Filter heirarchy.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/callback_util.h"
 #include "media/base/clock.h"
-#include "media/base/composite_filter.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 PipelineStatusNotification::PipelineStatusNotification()
@@ skipping 25 matching lines @@
 
 media::PipelineStatus PipelineStatusNotification::status() {
   base::AutoLock auto_lock(lock_);
   DCHECK(notified_);
   return status_;
 }
 
 struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder;
   scoped_refptr<VideoDecoder> video_decoder;
-  scoped_refptr<VideoRenderer> video_renderer;
-  scoped_refptr<CompositeFilter> composite;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop->message_loop_proxy()),
       media_log_(media_log),
       clock_(new Clock(&base::Time::Now)),
       waiting_for_clock_update_(false),
       state_(kCreated),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
@@ skipping 102 matching lines @@
     return;
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_ && !tearing_down_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::VolumeChangedTask, this, volume));
   }
 }
 
-TimeDelta Pipeline::GetCurrentTime() const {
+TimeDelta Pipeline::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
-  return GetCurrentTime_Locked();
-}
-
-TimeDelta Pipeline::GetCurrentTime_Locked() const {
-  lock_.AssertAcquired();
   return clock_->Elapsed();
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() {
   base::AutoLock auto_lock(lock_);
   Ranges<TimeDelta> time_ranges;
   for (size_t i = 0; i < buffered_time_ranges_.size(); ++i) {
     time_ranges.Add(buffered_time_ranges_.start(i),
                     buffered_time_ranges_.end(i));
   }
@@ skipping 165 matching lines @@
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::ErrorChangedTask, this, error));
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
-TimeDelta Pipeline::GetTime() const {
-  DCHECK(IsRunning());
-  return GetCurrentTime();
-}
-
-TimeDelta Pipeline::GetDuration() const {
-  DCHECK(IsRunning());
-  return GetMediaDuration();
-}
-
 void Pipeline::OnAudioDisabled() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::AudioDisabledTask, this));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
 }
 
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK(time <= max_time);
@@ skipping 65 matching lines @@
   return time_offset;
 }
 
 void Pipeline::DoPause(const base::Closure& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   scoped_ptr<std::queue<ClosureFunc> > closures(new std::queue<ClosureFunc>);
 
   if (audio_renderer_)
     closures->push(base::Bind(&AudioRenderer::Pause, audio_renderer_));
 
-  if (pipeline_filter_)
-    closures->push(base::Bind(&Filter::Pause, pipeline_filter_));
+  if (video_renderer_)
+    closures->push(base::Bind(&VideoRenderer::Pause, video_renderer_));
 
   RunInSeries(closures.Pass(), done_cb);
 }
 
 void Pipeline::DoFlush(const base::Closure& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   scoped_ptr<std::queue<ClosureFunc> > closures(new std::queue<ClosureFunc>);
 
   if (audio_renderer_)
     closures->push(base::Bind(&AudioRenderer::Flush, audio_renderer_));
 
-  if (pipeline_filter_)
-    closures->push(base::Bind(&Filter::Flush, pipeline_filter_));
+  if (video_renderer_)
+    closures->push(base::Bind(&VideoRenderer::Flush, video_renderer_));
 
   RunInParallel(closures.Pass(), done_cb);
 }
 
 void Pipeline::DoPlay(const base::Closure& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   scoped_ptr<std::queue<ClosureFunc> > closures(new std::queue<ClosureFunc>);
 
   if (audio_renderer_)
     closures->push(base::Bind(&AudioRenderer::Play, audio_renderer_));
 
-  if (pipeline_filter_)
-    closures->push(base::Bind(&Filter::Play, pipeline_filter_));
+  if (video_renderer_)
+    closures->push(base::Bind(&VideoRenderer::Play, video_renderer_));
 
   RunInSeries(closures.Pass(), done_cb);
 }
 
 void Pipeline::DoStop(const base::Closure& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   scoped_ptr<std::queue<ClosureFunc> > closures(new std::queue<ClosureFunc>);
 
   if (demuxer_)
     closures->push(base::Bind(&Demuxer::Stop, demuxer_));
 
   if (audio_renderer_)
     closures->push(base::Bind(&AudioRenderer::Stop, audio_renderer_));
 
-  if (pipeline_filter_)
-    closures->push(base::Bind(&Filter::Stop, pipeline_filter_));
+  if (video_renderer_)
+    closures->push(base::Bind(&VideoRenderer::Stop, video_renderer_));
 
   RunInSeries(closures.Pass(), done_cb);
 }
 
 void Pipeline::AddBufferedByteRange(int64 start, int64 end) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
   buffered_byte_ranges_.Add(start, end);
   did_loading_progress_ = true;
 }
 
 void Pipeline::AddBufferedTimeRange(base::TimeDelta start,
                                     base::TimeDelta end) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
   buffered_time_ranges_.Add(start, end);
   did_loading_progress_ = true;
 }
 
-void Pipeline::SetNaturalVideoSize(const gfx::Size& size) {
+void Pipeline::OnNaturalVideoSizeChanged(const gfx::Size& size) {
   DCHECK(IsRunning());
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       size.width(), size.height()));
 
   base::AutoLock auto_lock(lock_);
   natural_size_ = size;
 }
 
-void Pipeline::NotifyEnded() {
+void Pipeline::OnRendererEnded() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::NotifyEndedTask, this));
+      &Pipeline::OnRendererEndedTask, this));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 }
 
 // Called from any thread.
 void Pipeline::OnFilterInitialize(PipelineStatus status) {
   // Continue the initialize task by proceeding to the next stage.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::InitializeTask, this, status));
 }
 
@@ skipping 36 matching lines @@
                          const PipelineStatusCB& start_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(kCreated, state_);
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = start_cb;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
-  pipeline_init_state_->composite = new CompositeFilter(message_loop_);
-  pipeline_init_state_->composite->SetHost(this);
 
   SetState(kInitDemuxer);
   InitializeDemuxer();
 }
 
 // Main initialization method called on the pipeline thread.  This code attempts
 // to use the specified filter factory to build a pipeline.
 // Initialization step performed in this method depends on current state of this
 // object, indicated by |state_|.  After each step of initialization, this
 // object transits to the next stage.  It starts by creating a Demuxer, and then
@@ skipping 69 matching lines @@
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || !(HasAudio() || HasVideo())) {
       SetError(PIPELINE_ERROR_COULD_NOT_RENDER);
       return;
     }
 
-    // Clear the collection of filters.
-    filter_collection_->Clear();
-
-    pipeline_filter_ = pipeline_init_state_->composite;
-
-    // Clear init state since we're done initializing.
+    // Clear initialization state now that we're done.
+    filter_collection_.reset();
     pipeline_init_state_.reset();
 
     // Initialization was successful, we are now considered paused, so it's safe
     // to set the initial playback rate and volume.
     PlaybackRateChangedTask(GetPlaybackRate());
     VolumeChangedTask(GetVolume());
 
     // Fire a seek request to get the renderers to preroll. We can skip a seek
     // here as the demuxer should be at the start of the stream.
     seek_pending_ = true;
@@ skipping 78 matching lines @@
     pending_playback_rate_ = playback_rate;
     playback_rate_change_pending_ = true;
     return;
   }
 
   {
     base::AutoLock auto_lock(lock_);
     clock_->SetPlaybackRate(playback_rate);
   }
 
-  // Notify |pipeline_filter_| if it has been initialized. If initialization
-  // hasn't completed yet, the playback rate will be set when initialization
-  // completes.
-  if (pipeline_filter_) {
+  // These will get set after initialization completes in case playback rate is
+  // set prior to initialization.
+  if (demuxer_)
     demuxer_->SetPlaybackRate(playback_rate);
-    pipeline_filter_->SetPlaybackRate(playback_rate);
-
-    if (audio_renderer_)
-      audio_renderer_->SetPlaybackRate(playback_rate_);
-  }
+  if (audio_renderer_)
+    audio_renderer_->SetPlaybackRate(playback_rate_);
+  if (video_renderer_)
+    video_renderer_->SetPlaybackRate(playback_rate_);
 }
 
 void Pipeline::VolumeChangedTask(float volume) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!running_ || tearing_down_)
     return;
 
   if (audio_renderer_)
     audio_renderer_->SetVolume(volume);
 }
@@ skipping 27 matching lines @@
 
   // Kick off seeking!
   {
     base::AutoLock auto_lock(lock_);
     if (clock_->IsPlaying())
       clock_->Pause();
   }
   DoPause(base::Bind(&Pipeline::OnFilterStateTransition, this));
 }
 
-void Pipeline::NotifyEndedTask() {
+void Pipeline::OnRendererEndedTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // We can only end if we were actually playing.
   if (state_ != kStarted) {
     return;
   }
 
   DCHECK(audio_renderer_ || video_renderer_);
 
   // Make sure every extant renderer has ended.
@@ skipping 146 matching lines @@
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 void Pipeline::FinishDestroyingFiltersTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineStopped());
 
-  // Clear filter references.
   audio_renderer_ = NULL;
   video_renderer_ = NULL;
   demuxer_ = NULL;
 
-  pipeline_filter_ = NULL;
-
   if (error_caused_teardown_ && !IsPipelineOk() && !error_cb_.is_null())
     error_cb_.Run(status_);
 
   if (stop_pending_) {
     stop_pending_ = false;
     ResetState();
     // Notify the client that stopping has finished.
     base::ResetAndReturn(&stop_cb_).Run();
   }
 
@@ skipping 102 matching lines @@
   if (!audio_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   audio_renderer_->Initialize(
       decoder,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
       base::Bind(&Pipeline::OnAudioTimeUpdate, this),
-      base::Bind(&Pipeline::NotifyEnded, this),
+      base::Bind(&Pipeline::OnRendererEnded, this),
       base::Bind(&Pipeline::OnAudioDisabled, this),
       base::Bind(&Pipeline::SetError, this));
   return true;
 }
 
 bool Pipeline::InitializeVideoRenderer(
     const scoped_refptr<VideoDecoder>& decoder) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineOk());
 
   if (!decoder)
     return false;
 
-  filter_collection_->SelectVideoRenderer(
-      &pipeline_init_state_->video_renderer);
-  if (!pipeline_init_state_->video_renderer) {
+  filter_collection_->SelectVideoRenderer(&video_renderer_);
+  if (!video_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
-  pipeline_init_state_->composite->AddFilter(
-      pipeline_init_state_->video_renderer);
-
-  pipeline_init_state_->video_renderer->Initialize(
+  video_renderer_->Initialize(
       decoder,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this),
-      base::Bind(&Pipeline::OnVideoTimeUpdate, this));
-
-  video_renderer_ = pipeline_init_state_->video_renderer;
+      base::Bind(&Pipeline::OnVideoTimeUpdate, this),
+      base::Bind(&Pipeline::OnNaturalVideoSizeChanged, this),
+      base::Bind(&Pipeline::OnRendererEnded, this),
+      base::Bind(&Pipeline::SetError, this),
+      base::Bind(&Pipeline::GetMediaTime, this),
+      base::Bind(&Pipeline::GetMediaDuration, this));
   return true;
 }
 
 void Pipeline::TearDownPipeline() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(kStopped, state_);
 
   DCHECK(!tearing_down_ ||  // Teardown on Stop().
          (tearing_down_ && error_caused_teardown_) ||  // Teardown on error.
          (tearing_down_ && stop_pending_));  // Stop during teardown by error.
@@ skipping 10 matching lines @@
       message_loop_->PostTask(FROM_HERE, base::Bind(
           &Pipeline::FinishDestroyingFiltersTask, this));
       break;
 
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
     case kInitVideoRenderer:
       // Make it look like initialization was successful.
-      pipeline_filter_ = pipeline_init_state_->composite;
+      filter_collection_.reset();
       pipeline_init_state_.reset();
-      filter_collection_.reset();
 
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
 
       FinishInitialization();
       break;
 
     case kPausing:
     case kSeeking:
     case kFlushing:
@@ skipping 30 matching lines @@
   scoped_ptr<std::queue<PipelineStatusCBFunc> > status_cbs(
       new std::queue<PipelineStatusCBFunc>());
 
   if (!skip_demuxer_seek)
     status_cbs->push(base::Bind(&Demuxer::Seek, demuxer_, seek_timestamp));
 
   if (audio_renderer_)
     status_cbs->push(base::Bind(
         &AudioRenderer::Seek, audio_renderer_, seek_timestamp));
 
-  if (pipeline_filter_)
+  if (video_renderer_)
     status_cbs->push(base::Bind(
-        &Filter::Seek, pipeline_filter_, seek_timestamp));
+        &VideoRenderer::Seek, video_renderer_, seek_timestamp));
 
   RunInSeriesWithStatus(status_cbs.Pass(), base::Bind(
       &Pipeline::ReportStatus, this, done_cb));
 }
 
 void Pipeline::OnAudioUnderflow() {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::OnAudioUnderflow, this));
     return;
   }
 
   if (state_ != kStarted)
     return;
 
   if (audio_renderer_)
     audio_renderer_->ResumeAfterUnderflow(true);
 }
 
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media