media: Remove FilterCollection.

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/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
-#include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
+#include "media/base/media_switches.h"
 #include "media/base/renderer.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 Pipeline::Pipeline(
@@ skipping 21 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Pipeline must be destroyed on same thread that created it";
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
-void Pipeline::Start(scoped_ptr<FilterCollection> collection,
+void Pipeline::Start(Demuxer* demuxer,
+                     scoped_ptr<Renderer> renderer,
                      const base::Closure& ended_cb,
                      const PipelineStatusCB& error_cb,
                      const PipelineStatusCB& seek_cb,
                      const PipelineMetadataCB& metadata_cb,
                      const BufferingStateCB& buffering_state_cb,
-                     const base::Closure& duration_change_cb) {
+                     const base::Closure& duration_change_cb,
+                     const AddTextTrackCB& add_text_track_cb) {
   DCHECK(!ended_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK(!seek_cb.is_null());
   DCHECK(!metadata_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
 
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
   running_ = true;
 
-  filter_collection_ = collection.Pass();
+  demuxer_ = demuxer;
+  renderer_ = renderer.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = seek_cb;
   metadata_cb_ = metadata_cb;
   buffering_state_cb_ = buffering_state_cb;
   duration_change_cb_ = duration_change_cb;
+  add_text_track_cb_ = add_text_track_cb;
 
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&Pipeline::StartTask, weak_factory_.GetWeakPtr()));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   DVLOG(2) << __FUNCTION__;
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Pipeline::StopTask, weak_factory_.GetWeakPtr(), stop_cb));
@@ skipping 126 matching lines @@
   DCHECK(stop_cb_.is_null())
       << "State transitions don't happen when stopping";
   DCHECK_EQ(status_, PIPELINE_OK)
       << "State transitions don't happen when there's an error: " << status_;
 
   switch (state_) {
     case kCreated:
       return kInitDemuxer;
 
     case kInitDemuxer:
-      if (demuxer_->GetStream(DemuxerStream::AUDIO) ||
-          demuxer_->GetStream(DemuxerStream::VIDEO)) {
-        return kInitRenderer;
-      }
-      return kPlaying;
+      return kInitRenderer;
 
     case kInitRenderer:
     case kSeeking:
       return kPlaying;
 
     case kPlaying:
     case kStopping:
     case kStopped:
       break;
   }
@@ skipping 84 matching lines @@
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitRenderer:
       return InitializeRenderer(done_cb);
 
     case kPlaying:
-      // Finish initial start sequence the first time we enter the playing
-      // state.
+      // Report metadata the first time we enter the playing state.
       if (!is_initialized_) {
-        if (!renderer_) {
-          ErrorChangedTask(PIPELINE_ERROR_COULD_NOT_RENDER);
-          return;
-        }
-
         is_initialized_ = true;
-
-        {
-          PipelineMetadata metadata;
-          metadata.has_audio = renderer_->HasAudio();
-          metadata.has_video = renderer_->HasVideo();
-          metadata.timeline_offset = demuxer_->GetTimelineOffset();
-          DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
-          if (stream) {
-            metadata.natural_size =
-                stream->video_decoder_config().natural_size();
-            metadata.video_rotation = stream->video_rotation();
-          }
-          metadata_cb_.Run(metadata);
-        }
+        ReportMetadata();
       }
 
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 
       renderer_->StartPlayingFrom(start_timestamp_);
 
       if (text_renderer_)
         text_renderer_->StartPlaying();
 
       PlaybackRateChangedTask(GetPlaybackRate());
@@ skipping 66 matching lines @@
   DCHECK_EQ(state_, kStopping);
   DCHECK(!renderer_);
   DCHECK(!text_renderer_);
 
   {
     base::AutoLock auto_lock(lock_);
     running_ = false;
   }
 
   SetState(kStopped);
-  filter_collection_.reset();
   demuxer_ = NULL;
 
   // If we stop during initialization/seeking we want to run |seek_cb_|
   // followed by |stop_cb_| so we don't leave outstanding callbacks around.
   if (!seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(status_);
     error_cb_.Reset();
   }
   if (!stop_cb_.is_null()) {
     error_cb_.Reset();
@@ skipping 29 matching lines @@
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
 void Pipeline::StartTask() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
-  text_renderer_ = filter_collection_->GetTextRenderer();
-
+  text_renderer_ = CreateTextRenderer();
   if (text_renderer_) {
     text_renderer_->Initialize(
         base::Bind(&Pipeline::OnTextRendererEnded, weak_factory_.GetWeakPtr()));
   }
 
   StateTransitionTask(PIPELINE_OK);
 }
 
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 10 matching lines @@
 
     return;
   }
 
   stop_cb_ = stop_cb;
 
   // We may already be stopping due to a runtime error.
   if (state_ == kStopping)
     return;
 
-  PipelineStatistics stats = GetStatistics();
-  if (renderer_ && renderer_->HasVideo() && stats.video_frames_decoded > 0)
-    UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount", stats.video_frames_dropped);
+  // Do not report statistics if the pipeline is not fully initialized.
+  if (state_ == kSeeking || state_ == kPlaying) {
+    PipelineStatistics stats = GetStatistics();
+    if (renderer_->HasVideo() && stats.video_frames_decoded > 0) {
+      UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount",
+                           stats.video_frames_dropped);
+    }
+  }
 
   SetState(kStopping);
   pending_callbacks_.reset();
   DoStop(base::Bind(&Pipeline::OnStopCompleted, weak_factory_.GetWeakPtr()));
 }
 
 void Pipeline::ErrorChangedTask(PipelineStatus error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
@@ skipping 89 matching lines @@
   if (renderer_ && !renderer_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_renderer_ended_)
     return;
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
+scoped_ptr<TextRenderer> Pipeline::CreateTextRenderer() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  if (!cmd_line->HasSwitch(switches::kEnableInbandTextTracks))
+    return scoped_ptr<media::TextRenderer>();
+
+  return scoped_ptr<media::TextRenderer>(new media::TextRenderer(
+      task_runner_,
+      base::Bind(&Pipeline::OnAddTextTrack, weak_factory_.GetWeakPtr())));
+}
+
 void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
                                  const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
   // is added (http://crbug.com/321446).
-  text_renderer_->AddTextStream(text_stream, config);
+  if (text_renderer_)
+    text_renderer_->AddTextStream(text_stream, config);
 }
 
 void Pipeline::RemoveTextStreamTask(DemuxerStream* text_stream) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  text_renderer_->RemoveTextStream(text_stream);
+  if (text_renderer_)
+    text_renderer_->RemoveTextStream(text_stream);
+}
+
+void Pipeline::OnAddTextTrack(const TextTrackConfig& config,
+                              const AddTextTrackDoneCB& done_cb) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  add_text_track_cb_.Run(config, done_cb);
 }
 
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-
-  demuxer_ = filter_collection_->GetDemuxer();
   demuxer_->Initialize(this, done_cb, text_renderer_);
 }
 
 void Pipeline::InitializeRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  renderer_ = filter_collection_->GetRenderer();
+  if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
+      !demuxer_->GetStream(DemuxerStream::VIDEO)) {
+    renderer_.reset();
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(done_cb, PIPELINE_ERROR_COULD_NOT_RENDER));
+    return;
+  }
 
   base::WeakPtr<Pipeline> weak_this = weak_factory_.GetWeakPtr();
   renderer_->Initialize(
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, weak_this),
       base::Bind(&Pipeline::OnRendererEnded, weak_this),
       base::Bind(&Pipeline::OnError, weak_this),
       base::Bind(&Pipeline::BufferingStateChanged, weak_this),
       base::Bind(&Pipeline::GetMediaDuration, base::Unretained(this)));
 }
 
+void Pipeline::ReportMetadata() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  PipelineMetadata metadata;
+  metadata.has_audio = renderer_->HasAudio();
+  metadata.has_video = renderer_->HasVideo();
+  metadata.timeline_offset = demuxer_->GetTimelineOffset();
+  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  if (stream) {
+    metadata.natural_size = stream->video_decoder_config().natural_size();
+    metadata.video_rotation = stream->video_rotation();
+  }
+  metadata_cb_.Run(metadata);
+}
+
 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media