Merge 21611 - Implemented proper pausethenseek behaviour for the media pipeli...

media/base/pipeline_impl.h

 // Copyright (c) 2008-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/filter_host.h"
 #include "media/base/pipeline.h"
 
 namespace media {
 
 
 // PipelineImpl runs the media pipeline.  Filters are created and called on the
 // message loop injected into this object. PipelineImpl works like a state
-// machine to perform asynchronous initialization. Initialization is done in
-// multiple passes by InitializeTask(). In each pass a different filter is
-// created and chained with a previously created filter.
+// machine to perform asynchronous initialization, pausing, seeking and playing.
 //
 // Here's a state diagram that describes the lifetime of this object.
 //
-// [ *Created ] -> [ InitDataSource ] -> [ InitDemuxer ] ->
-// [ InitAudioDecoder ] -> [ InitAudioRenderer ] ->
-// [ InitVideoDecoder ] -> [ InitVideoRenderer ] -> [ Started ]
-//        |                    |                         |
-//        .-> [ Error ]        .->      [ Stopped ]    <-.
+//   [ *Created ]
+//         | Start()
+//         V
+//   [ InitXXX (for each filter) ]
+//         |
+//         V
+//   [ Seeking (for each filter) ] <----------------------.
+//         |                                              |
+//         V                                              |
+//   [ Starting (for each filter) ]                       |
+//         |                                              |
+//         V      Seek()                                  |
+//   [ Started ] --------> [ Pausing (for each filter) ] -'
 //
-// Initialization is a series of state transitions from "Created" to
-// "Started". If any error happens during initialization, this object will
-// transition to the "Error" state from any state. If Stop() is called during
-// initialization, this object will transition to "Stopped" state.
+//
+//                  SetError()
+//   [ Any State ] -------------> [ Error ]
+//         |          Stop()
+//         '--------------------> [ Stopped ]
+//
+// Initialization is a series of state transitions from "Created" through each
+// filter initialization state.  When all filter initialization states have
+// completed, we are implicitly in a "Paused" state.  At that point we simulate
+// a Seek() to the beginning of the media to give filters a chance to preroll.
+// From then on the normal Seek() transitions are carried out and we start
+// playing the media.
+//
+// If any error ever happens, this object will transition to the "Error" state
+// from any state. If Stop() is ever called, this object will transition to
+// "Stopped" state.
 class PipelineImpl : public Pipeline, public FilterHost {
  public:
   explicit PipelineImpl(MessageLoop* message_loop);
 
   // Pipeline implementation.
   virtual bool Start(FilterFactory* filter_factory,
                      const std::string& uri,
                      PipelineCallback* start_callback);
   virtual void Stop(PipelineCallback* stop_callback);
   virtual void Seek(base::TimeDelta time, PipelineCallback* seek_callback);
   virtual bool IsRunning() const;
   virtual bool IsInitialized() const;
   virtual bool IsRendered(const std::string& major_mime_type) const;
   virtual float GetPlaybackRate() const;
   virtual void SetPlaybackRate(float playback_rate);
   virtual float GetVolume() const;
   virtual void SetVolume(float volume);
   virtual base::TimeDelta GetCurrentTime() const;
   virtual base::TimeDelta GetBufferedTime() const;
   virtual base::TimeDelta GetDuration() const;
   virtual int64 GetBufferedBytes() const;
   virtual int64 GetTotalBytes() const;
   virtual void GetVideoSize(size_t* width_out, size_t* height_out) const;
   virtual PipelineError GetError() const;
 
  private:
+  // Pipeline states, as described above.
+  enum State {
+    kCreated,
+    kInitDataSource,
+    kInitDemuxer,
+    kInitAudioDecoder,
+    kInitAudioRenderer,
+    kInitVideoDecoder,
+    kInitVideoRenderer,
+    kPausing,
+    kSeeking,
+    kStarting,
+    kStarted,
+    kStopped,
+    kError,
+  };
+
   virtual ~PipelineImpl();
 
   // Reset the state of the pipeline object to the initial state.  This method
   // is used by the constructor, and the Stop() method.
   void ResetState();
 
   // Simple method used to make sure the pipeline is running normally.
   bool IsPipelineOk();
 
   // Helper method to tell whether we are in the state of initializing.
   bool IsPipelineInitializing();
 
+  // Returns true if the given state is one that transitions to the started
+  // state.
+  static bool StateTransitionsToStarted(State state);
+
+  // Given the current state, returns the next state.
+  static State FindNextState(State current);
+
   // FilterHost implementation.
   virtual void SetError(PipelineError error);
   virtual base::TimeDelta GetTime() const;
   virtual void SetTime(base::TimeDelta time);
   virtual void SetDuration(base::TimeDelta duration);
   virtual void SetBufferedTime(base::TimeDelta buffered_time);
   virtual void SetTotalBytes(int64 total_bytes);
   virtual void SetBufferedBytes(int64 buffered_bytes);
   virtual void SetVideoSize(size_t width, size_t height);
 
   // Method called during initialization to insert a mime type into the
   // |rendered_mime_types_| set.
   void InsertRenderedMimeType(const std::string& major_mime_type);
 
   // Method called during initialization to determine if we rendered anything.
   bool HasRenderedMimeTypes() const;
 
-  // Callback executed by filters upon completing initialization and seeking.
+  // Callback executed by filters upon completing initialization.
   void OnFilterInitialize();
-  void OnFilterSeek();
+
+  // Callback executed by filters upon completing Play(), Pause() or Seek().
+  void OnFilterStateTransition();
 
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the PipelineInternal's
   // message loop.
   void StartTask(FilterFactory* filter_factory,
                  const std::string& url,
                  PipelineCallback* start_callback);
 
   // InitializeTask() performs initialization in multiple passes. It is executed
   // as a result of calling Start() or InitializationComplete() that advances
@@ skipping 11 matching lines @@
 
   // Carries out notifying filters that the playback rate has changed.
   void PlaybackRateChangedTask(float playback_rate);
 
   // Carries out notifying filters that the volume has changed.
   void VolumeChangedTask(float volume);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
   void SeekTask(base::TimeDelta time, PipelineCallback* seek_callback);
 
+  // Carries out advancing to the next filter during Play()/Pause()/Seek().
+  void FilterStateTransitionTask();
+
   // Internal methods used in the implementation of the pipeline thread.  All
   // of these methods are only called on the pipeline thread.
 
   // The following template functions 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 filter'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/".
   //
@@ skipping 98 matching lines @@
   PipelineError error_;
 
   // Vector of major mime types that have been rendered by this pipeline.
   typedef std::set<std::string> RenderedMimeTypesSet;
   RenderedMimeTypesSet rendered_mime_types_;
 
   // The following data members are only accessed by tasks posted to
   // |message_loop_|.
 
   // Member that tracks the current state.
-  enum State {
-    kCreated,
-    kInitDataSource,
-    kInitDemuxer,
-    kInitAudioDecoder,
-    kInitAudioRenderer,
-    kInitVideoDecoder,
-    kInitVideoRenderer,
-    kStarted,
-    kStopped,
-    kError,
-  };
   State state_;
 
+  // For kPausing, kSeeking and kStarting, we need to track how many filters
+  // have completed transitioning to the destination state.  When
+  // |remaining_transitions_| reaches 0 the pipeline can transition out
+  // of the current state.
+  size_t remaining_transitions_;
+
+  // For kSeeking we need to remember where we're seeking between filter
+  // replies.
+  base::TimeDelta seek_timestamp_;
+
   // Filter factory as passed in by Start().
   scoped_refptr<FilterFactory> filter_factory_;
 
   // URL for the data source as passed in by Start().
   std::string url_;
 
   // Callbacks for various pipeline operations.
-  scoped_ptr<PipelineCallback> start_callback_;
   scoped_ptr<PipelineCallback> seek_callback_;
   scoped_ptr<PipelineCallback> stop_callback_;
 
   // Vector of our filters and map maintaining the relationship between the
   // FilterType and the filter itself.
   typedef std::vector<scoped_refptr<MediaFilter> > FilterVector;
   FilterVector filters_;
 
   typedef std::map<FilterType, scoped_refptr<MediaFilter> > FilterTypeMap;
   FilterTypeMap filter_types_;
 
   // Vector of threads owned by the pipeline and being used by filters.
   typedef std::vector<base::Thread*> FilterThreadVector;
   FilterThreadVector filter_threads_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_PIPELINE_IMPL_H_