<video> decode in hardware!

media/base/filters.h

 // Copyright (c) 2011 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.
 
 // Filters are connected in a strongly typed manner, with downstream filters
 // always reading data from upstream filters.  Upstream filters have no clue
 // who is actually reading from them, and return the results via callbacks.
 //
 //                         DemuxerStream(Video) <- VideoDecoder <- VideoRenderer
 // DataSource <- Demuxer <
@@ skipping 44 matching lines @@
 // there will be assertions at compile time if they do not match.
 enum Preload {
   NONE,
   METADATA,
   AUTO,
 };
 
 // Used for completing asynchronous methods.
 typedef base::Callback<void(PipelineStatus)> FilterStatusCB;
 
-// This function copies |*cb|, calls Reset() on |*cb|, and then calls Run()
-// on the copy. This is used in the common case where you need to clear
+// These functions copy |*cb|, call Reset() on |*cb|, and then call Run()
+// on the copy.  This is used in the common case where you need to clear
 // a callback member variable before running the callback.
 MEDIA_EXPORT void ResetAndRunCB(FilterStatusCB* cb, PipelineStatus status);
 MEDIA_EXPORT void ResetAndRunCB(base::Closure* cb);
 
 // Used for updating pipeline statistics.
 typedef base::Callback<void(const PipelineStatistics&)> StatisticsCallback;
 
 class MEDIA_EXPORT Filter : public base::RefCountedThreadSafe<Filter> {
  public:
   Filter();
 
   // Sets the private member |host_|. This is the first method called by
   // the FilterHost after a filter is created.  The host holds a strong
   // reference to the filter.  The reference held by the host is guaranteed
   // to be released before the host object is destroyed by the pipeline.
   virtual void set_host(FilterHost* host);
 
+  // Clear |host_| to signal abandonment.  Must be called after set_host() and
+  // before any state-changing method below.
+  virtual void clear_host();
+
   virtual FilterHost* host();
 
   // The pipeline has resumed playback.  Filters can continue requesting reads.
   // Filters may implement this method if they need to respond to this call.
   // TODO(boliu): Check that callback is not NULL in subclasses.
   virtual void Play(const base::Closure& callback);
 
   // The pipeline has paused playback.  Filters should stop buffer exchange.
   // Filters may implement this method if they need to respond to this call.
   // TODO(boliu): Check that callback is not NULL in subclasses.
@@ skipping 63 matching lines @@
   // Notify the DataSource of the bitrate of the media.
   // Values of |bitrate| <= 0 are invalid and should be ignored.
   virtual void SetBitrate(int bitrate) = 0;
 };
 
 class MEDIA_EXPORT VideoDecoder : public Filter {
  public:
   // Initialize a VideoDecoder with the given DemuxerStream, executing the
   // callback upon completion.
   // stats_callback is used to update global pipeline statistics.
-  //
-  // TODO(scherkus): switch to PipelineStatus callback.
-  virtual void Initialize(DemuxerStream* stream, const base::Closure& callback,
+  virtual void Initialize(DemuxerStream* stream,
+                          const PipelineStatusCB& callback,
                           const StatisticsCallback& stats_callback) = 0;
 
   // Request a frame to be decoded and returned via the provided callback.
   // Only one read may be in flight at any given time.
   //
   // Implementations guarantee that the callback will not be called from within
   // this method.
   //
   // Frames will be non-NULL yet may be end of stream frames.
   typedef base::Callback<void(scoped_refptr<VideoFrame>)> ReadCB;
@@ skipping 88 matching lines @@
 
   // Resumes playback after underflow occurs.
   // |buffer_more_audio| is set to true if you want to increase the size of the
   // decoded audio buffer.
   virtual void ResumeAfterUnderflow(bool buffer_more_audio) = 0;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_FILTERS_H_