Pipeline_Impl was modified to properly render a stream that has video but no ...

media/base/pipeline_impl.h

 // Copyright (c) 2006-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.
 
 // Implementation of Pipeline.
 
 #ifndef MEDIA_BASE_PIPELINE_IMPL_H_
 #define MEDIA_BASE_PIPELINE_IMPL_H_
 
 #include <string>
 #include <vector>
+#include <set>
 
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "base/time.h"
 #include "media/base/pipeline.h"
 
 namespace media {
 
 class FilterHostImpl;
@@ skipping 14 matching lines @@
   virtual base::TimeDelta GetDuration() const;
   virtual base::TimeDelta GetBufferedTime() const;
   virtual int64 GetTotalBytes() const;
   virtual int64 GetBufferedBytes()const;
   virtual void GetVideoSize(size_t* width_out, size_t* height_out) const;
   virtual float GetVolume() const;
   virtual float GetPlaybackRate() const;
   virtual base::TimeDelta GetTime() const;
   virtual base::TimeDelta GetInterpolatedTime() const;
   virtual PipelineError GetError() const;
+  virtual bool IsRendered(const std::string& major_mime_type) const;
 
   // Impementation of Pipeline methods.
   virtual bool Start(FilterFactory* filter_factory,
                      const std::string& url,
                      Callback1<bool>::Type* init_complete_callback);
   virtual void Stop();
   virtual void SetPlaybackRate(float rate);
   virtual void Seek(base::TimeDelta time);
   virtual void SetVolume(float volume);
 
@@ skipping 19 matching lines @@
   void SetBufferedBytes(int64 buffered_bytes);
   void SetVideoSize(size_t width, size_t height);
   void SetTime(base::TimeDelta time);
   void InternalSetPlaybackRate(float rate);
 
   // Sets the error to the new error code only if the current error state is
   // PIPELINE_OK. Returns true if error set, otherwise leaves current error
   // alone, and returns false.
   bool InternalSetError(PipelineError error);
 
+  // Method called by the |pipeline_thread_| to insert a mime type into
+  // the |rendered_mime_types_| set.
+  void InsertRenderedMimeType(const std::string& major_mime_type);
+
   // Holds a ref counted reference to the PipelineThread object associated
   // with this pipeline.  Prior to the call to the Start method, this member
   // will be NULL, since no thread is running.
   scoped_refptr<PipelineThread> pipeline_thread_;
 
   // After calling Start, if all of the required filters are created and
   // initialized, this member will be set to true by the pipeline thread.
   bool initialized_;
 
   // Duration of the media in microseconds.  Set by a FilterHostImpl object on
@@ skipping 41 matching lines @@
   // Internal system timer at last time the SetTime method was called.  Used to
   // compute interpolated time.
   base::TimeTicks ticks_at_last_set_time_;
 
   // Status of the pipeline.  Initialized to PIPELINE_OK which indicates that
   // the pipeline is operating correctly. Any other value indicates that the
   // pipeline is stopped or is stopping.  Clients can call the Stop method to
   // reset the pipeline state, and restore this to PIPELINE_OK.
   PipelineError error_;
 
+  // Vector of major mime types that have been rendered by this pipeline.
+  typedef std::set<std::string> RenderedMimeTypesSet;
+  RenderedMimeTypesSet rendered_mime_types_;
+
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 
 // The PipelineThread contains most of the logic involved with running the
 // media pipeline.  Filters are created and called on a dedicated thread owned
 // by this object.
 class PipelineThread : public base::RefCountedThreadSafe<PipelineThread>,
                        public MessageLoop::DestructionObserver {
  public:
@@ skipping 41 matching lines @@
   // Implementation of MessageLoop::DestructionObserver.  StartTask registers
   // this class as a destruction observer on the thread's message loop.
   // It is used to destroy the list of FilterHosts
   // (and thus destroy the associated filters) when all tasks have been
   // processed and the message loop has been quit.
   virtual void WillDestroyCurrentMessageLoop();
 
   friend class base::RefCountedThreadSafe<PipelineThread>;
   virtual ~PipelineThread();
 
+  // Simple method used to make sure the pipeline is running normally.
+  bool PipelineOk() { return PIPELINE_OK == pipeline_->error_; }
+
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the PipelineThread's
   // message loop.  For example, the Start method posts a task to call the
   // StartTask message on the pipeline thread.
   void StartTask(FilterFactory* filter_factory,
                  const std::string& url,
                  Callback1<bool>::Type* init_complete_callback);
   void StopTask();
   void SetPlaybackRateTask(float rate);
   void SeekTask(base::TimeDelta time);
   void SetVolumeTask(float volume);
   void SetTimeTask();
   void InitializationCompleteTask(FilterHostImpl* FilterHost);
 
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
   // Calls the Stop method on every filter in the pipeline
   void StopFilters();
 
-  // Examines the demuxer filter output streams.  If one contains video then
-  // returns true.
-  bool HasVideo() const;
-
   // The following template funcions make use of the fact that media filter
   // derived interfaces are self-describing in the sense that they all contain
   // the static method filter_type() which returns a FilterType enum that
   // uniquely identifies the filer's interface.  In addition, filters that are
   // specific to audio or video also support a static method major_mime_type()
   // which returns a string of "audio/" or "video/".
 
-  // Uses the FilterFactory to create a new filter of the NewFilter class, and
+  // Uses the FilterFactory to create a new filter of the Filter class, and
   // initiaializes it using the Source object.  The source may be another filter
   // or it could be a string in the case of a DataSource.
   //
   // The CreateFilter method actually does much more than simply creating the
   // filter.  It creates the FilterHostImpl object, creates the filter using
   // the filter factory, calls the MediaFilter::SetHost method on the filter,
   // and then calls the filter's type-specific Initialize(source) method to
   // initialize the filter.  It then runs the thread's message loop and waits
   // until one of the following occurs:
   //  1. The filter calls FilterHost::InitializationComplete()
   //  2. A filter calls FilterHost::Error()
   //  3. The client calls Pipeline::Stop()
-  template <class NewFilter, class Source>
-  bool CreateFilter(FilterFactory* filter_factory,
-                    Source source,
-                    const MediaFormat* source_media_format);
+  //
+  // Callers can optionally use the returned Filter for further processing,
+  // but since the call already placed the filter in the list of filter hosts,
+  // callers can ignore the return value.  In any case, if this function can
+  // not create and initailze the speified Filter, then this method will return
+  // with |pipeline_->error_| != PIPELINE_OK.
+  template <class Filter, class Source>
+  scoped_refptr<Filter> CreateFilter(FilterFactory* filter_factory,
+                                     Source source,
+                                     const MediaFormat* source_media_format);
+
+  // Creates a Filter and initilizes it with the given |source|.  If a Filter
+  // could not be created or an error occurred, this metod returns NULL and the
+  // pipeline's |error_| member will contain a specific error code.  Note that
+  // the Source could be a filter or a DemuxerStream, but it must support the
+  // GetMediaFormat() method.
+  template <class Filter, class Source>
+  scoped_refptr<Filter> CreateFilter(FilterFactory* filter_factory,
+                                     Source* source) {
+    return CreateFilter<Filter, Source*>(filter_factory,
+                                         source,
+                                         source->GetMediaFormat());
+  }
 
   // Creates a DataSource (the first filter in a pipeline), and initializes it
   // with the specified URL.
-  bool CreateDataSource(FilterFactory* filter_factory,
-                        const std::string& url);
+  scoped_refptr<DataSource> CreateDataSource(FilterFactory* filter_factory,
+                                             const std::string& url);
 
-  // Examines the list of existing filters to find a Source, then creates a
-  // NewFilter, and initializes it with the Source filter.
-  template <class NewFilter, class Source>
-  bool CreateAndConnect(FilterFactory* filter_factory);
-
-  // Creates and initiaializes a decoder.
-  template <class Decoder>
-  bool CreateDecoder(FilterFactory* filter_factory);
+  // If the |demuxer| contains a stream that matches Decoder::major_media_type()
+  // this method creates and initializes the specified Decoder and Renderer.
+  // Callers should examine the |pipeline_->error_| member to see if there was
+  // an error duing the call.  The lack of the specified stream does not
+  // constitute an error, and no Decoder or Renderer will be created if the
+  // data stream does not exist in the |demuxer|.  If a stream is rendered, then
+  // this method will call |pipeline_|->InsertRenderedMimeType() to add the
+  // mime type to the set of rendered major mime types for the pipeline.
+  template <class Decoder, class Renderer>
+  void Render(FilterFactory* filter_factory, Demuxer* demuxer);
 
   // Examine the list of existing filters to find one that supports the
-  // specified Filter interface. If one exists, the specified Filter interface
-  // is returned otherwise the method retuns NULL.
+  // specified Filter interface. If one exists, the |filter_out| will contain
+  // the filter, |*filer_out| will be NULL.

[scherkus (not reviewing), 2009/03/06 18:52:20]

typo on filter_out

   template <class Filter>
-  Filter* GetFilter() const;
-
-  // Simple function that returns true if the specified MediaFormat object
-  // has a mime type that matches the major_mime_type.  Examples of major mime
-  // types are "audio/" and "video/"
-  bool IsMajorMimeType(const MediaFormat* media_format,
-                       const std::string& major_mime_type) const;
+  void GetFilter(scoped_refptr<Filter>* filter_out) const;
 
   // Pointer to the pipeline that owns this PipelineThread.
   PipelineImpl* const pipeline_;
 
   // The actual thread.
   base::Thread thread_;
 
   // Used to avoid scheduling multiple time update tasks.  If this member is
   // true then a task that will call the SetTimeTask() method is in the message
   // loop's queue.
@@ skipping 10 matching lines @@
   // Vector of FilterHostImpl objects that contian the filters for the pipeline.
   typedef std::vector<FilterHostImpl*> FilterHostVector;
   FilterHostVector filter_hosts_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineThread);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_