media: recycle buffers/direct rendering etc. (third patch)

media/filters/video_renderer_base.h

 // Copyright (c) 2010 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.
 
 // VideoRendererBase creates its own thread for the sole purpose of timing frame
 // presentation.  It handles reading from the decoder and stores the results in
 // a queue of decoded frames, calling OnFrameAvailable() on subclasses to notify
 // when a frame is ready to display.
 //
 // The media filter methods Initialize(), Stop(), SetPlaybackRate() and Seek()
@@ skipping 89 matching lines @@
   int width() { return width_; }
   int height() { return height_; }
   VideoFrame::Format surface_format() { return surface_format_; }
   VideoFrame::SurfaceType surface_type() { return surface_type_; }
 
   // TODO(jiesun): move this to gles_video_render.cc.
   inline bool uses_egl_image() {
     return surface_type_ == media::VideoFrame::TYPE_EGL_IMAGE;
   }
 
+  void ReadInput(scoped_refptr<VideoFrame> frame);
+
  private:
   // Callback from video decoder to deliver decoded video frames and decrements
   // |pending_reads_|.
   void OnFillBufferDone(scoped_refptr<VideoFrame> frame);
 
   // Helper method that schedules an asynchronous read from the decoder and
   // increments |pending_reads_|.
   //
   // Safe to call from any thread.
   void ScheduleRead_Locked();
 
+  // Helper function to finished "flush" operation
+  void OnFlushDone();
+
   // Helper method that flushes all video frame in "ready queue" including
   // current frame into "done queue".
   void FlushBuffers();
 
   // Calculates the duration to sleep for based on |current_frame_|'s timestamp,
   // the next frame timestamp (may be NULL), and the provided playback rate.
   //
   // We don't use |playback_rate_| to avoid locking.
   base::TimeDelta CalculateSleepDuration(VideoFrame* next_frame,
                                          float playback_rate);
@@ skipping 12 matching lines @@
   // OnFrameAvailable() was called.
   typedef std::deque< scoped_refptr<VideoFrame> > VideoFrameQueue;
   VideoFrameQueue frames_queue_ready_;
   VideoFrameQueue frames_queue_done_;
   scoped_refptr<VideoFrame> current_frame_;
 
   // Used to signal |thread_| as frames are added to |frames_|.  Rule of thumb:
   // always check |state_| to see if it was set to STOPPED after waking up!
   ConditionVariable frame_available_;
 
+  // State transition Diagram of this class:
+  //       [kUninitialized] -------> [kError]
+  //              |
+  //              | Initialize()
+  //              V        All frames returned
+  //   +------[kFlushed]<----------------------[kFlushing]
+  //   |          | Seek() or upon                  ^
+  //   |          V got first frame                 |
+  //   |      [kSeeking]                            | Flush()
+  //   |          |                                 |
+  //   |          V Got enough frames               |
+  //   |      [kPrerolled]---------------------->[kPaused]
+  //   |          |                Pause()          ^
+  //   |          V Play()                          |
+  //   |       [kPlaying]---------------------------|
+  //   |          |                Pause()          ^
+  //   |          V Receive EOF frame.              | Pause()
+  //   |       [kEnded]-----------------------------+
+  //   |                                            ^
+  //   |                                            |
+  //   +-----> [kStopped]                   [Any state other than]
+  //                                        [kUninitialized/kError]
+
   // Simple state tracking variable.
   enum State {
     kUninitialized,
+    kPrerolled,
     kPaused,
     kFlushing,
+    kFlushed,
     kSeeking,
     kPlaying,
     kEnded,
     kStopped,
     kError,
   };
   State state_;
 
   // Video thread handle.
   PlatformThreadHandle thread_;
 
   // Previous time returned from the pipeline.
   base::TimeDelta previous_time_;
 
-  // Keeps track of our pending reads.  We *must* have no pending reads before
-  // executing the pause callback, otherwise we breach the contract that all
-  // filters are idling.
-  //
-  // We use size_t since we compare against std::deque::size().
-  size_t pending_reads_;
+  // Keeps track of our pending buffers. We *must* have no pending reads
+  // before executing the flush callback; We decrement it each time we receive
+  // a buffer and increment it each time we send a buffer out. therefore if
+  // decoder provides buffer, |pending_reads_| is always non-positive and if
+  // renderer provides buffer, |pending_reads_| is always non-negative.
+  int pending_reads_;
   bool pending_paint_;
 
   float playback_rate_;
 
   // Filter callbacks.
   scoped_ptr<FilterCallback> flush_callback_;
   scoped_ptr<FilterCallback> seek_callback_;
 
   base::TimeDelta seek_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VIDEO_RENDERER_BASE_H_