src/content/common/gpu/media/rendering_helper.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_
   6 #define CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_
   7
   8 #include <map>
   9 #include <queue>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/cancelable_callback.h"
  14 #include "base/time/time.h"
  15 #include "base/timer/timer.h"
  16 #include "ui/gfx/geometry/rect.h"
  17 #include "ui/gfx/geometry/size.h"
  18 #include "ui/gl/gl_bindings.h"
  19 #include "ui/gl/gl_context.h"
  20 #include "ui/gl/gl_surface.h"
  21
  22 namespace base {
  23 class MessageLoop;
  24 class WaitableEvent;
  25 }
  26
  27 namespace content {
  28
  29 class VideoFrameTexture : public base::RefCounted<VideoFrameTexture> {
  30  public:
  31   uint32 texture_id() const { return texture_id_; }
  32   uint32 texture_target() const { return texture_target_; }
  33
  34   VideoFrameTexture(uint32 texture_target,
  35                     uint32 texture_id,
  36                     const base::Closure& no_longer_needed_cb);
  37
  38  private:
  39   friend class base::RefCounted<VideoFrameTexture>;
  40
  41   uint32 texture_target_;
  42   uint32 texture_id_;
  43   base::Closure no_longer_needed_cb_;
  44
  45   ~VideoFrameTexture();
  46 };
  47
  48 struct RenderingHelperParams {
  49   RenderingHelperParams();
  50   ~RenderingHelperParams();
  51
  52   // The rendering FPS.
  53   int rendering_fps;
  54
  55   // The desired size of each window. We play each stream in its own window
  56   // on the screen.
  57   std::vector<gfx::Size> window_sizes;
  58
  59   // The members below are only used for the thumbnail mode where all frames
  60   // are rendered in sequence onto one FBO for comparison/verification purposes.
  61
  62   // Whether the frames are rendered as scaled thumbnails within a
  63   // larger FBO that is in turn rendered to the window.
  64   bool render_as_thumbnails;
  65   // The size of the FBO containing all visible thumbnails.
  66   gfx::Size thumbnails_page_size;
  67   // The size of each thumbnail within the FBO.
  68   gfx::Size thumbnail_size;
  69 };
  70
  71 // Creates and draws textures used by the video decoder.
  72 // This class is not thread safe and thus all the methods of this class
  73 // (except for ctor/dtor) ensure they're being run on a single thread.
  74 class RenderingHelper {
  75  public:
  76
  77   RenderingHelper();
  78   ~RenderingHelper();
  79
  80   static bool InitializeOneOff();
  81
  82   // Create the render context and windows by the specified dimensions.
  83   void Initialize(const RenderingHelperParams& params,
  84                   base::WaitableEvent* done);
  85
  86   // Undo the effects of Initialize() and signal |*done|.
  87   void UnInitialize(base::WaitableEvent* done);
  88
  89   // Return a newly-created GLES2 texture id of the specified size, and
  90   // signal |*done|.
  91   void CreateTexture(uint32 texture_target,
  92                      uint32* texture_id,
  93                      const gfx::Size& size,
  94                      base::WaitableEvent* done);
  95
  96   // Render thumbnail in the |texture_id| to the FBO buffer using target
  97   // |texture_target|.
  98   void RenderThumbnail(uint32 texture_target, uint32 texture_id);
  99
 100   // Queues the |video_frame| for rendering.
 101   void QueueVideoFrame(size_t window_id,
 102                        scoped_refptr<VideoFrameTexture> video_frame);
 103
 104   // Flushes the pending frames. Notify the rendering_helper there won't be
 105   // more video frames.
 106   void Flush(size_t window_id);
 107
 108   // Delete |texture_id|.
 109   void DeleteTexture(uint32 texture_id);
 110
 111   // Get the platform specific handle to the OpenGL display.
 112   void* GetGLDisplay();
 113
 114   // Get the platform specific handle to the OpenGL context.
 115   void* GetGLContext();
 116
 117   // Get rendered thumbnails as RGB.
 118   // Sets alpha_solid to true if the alpha channel is entirely 0xff.
 119   void GetThumbnailsAsRGB(std::vector<unsigned char>* rgb,
 120                           bool* alpha_solid,
 121                           base::WaitableEvent* done);
 122
 123  private:
 124   struct RenderedVideo {
 125     // The rect on the screen where the video will be rendered.
 126     gfx::Rect render_area;
 127
 128     // True if the last (and the only one) frame in pending_frames has
 129     // been rendered. We keep the last remaining frame in pending_frames even
 130     // after it has been rendered, so that we have something to display if the
 131     // client is falling behind on providing us with new frames during
 132     // timer-driven playback.
 133     bool last_frame_rendered;
 134
 135     // True if there won't be any new video frames comming.
 136     bool is_flushing;
 137
 138     // The number of frames need to be dropped to catch up the rendering.
 139     int frames_to_drop;
 140
 141     // The video frames pending for rendering.
 142     std::queue<scoped_refptr<VideoFrameTexture> > pending_frames;
 143
 144     RenderedVideo();
 145     ~RenderedVideo();
 146   };
 147
 148   void Clear();
 149
 150   void RenderContent();
 151
 152   void LayoutRenderingAreas(const std::vector<gfx::Size>& window_sizes);
 153
 154   // Render |texture_id| to the current view port of the screen using target
 155   // |texture_target|.
 156   void RenderTexture(uint32 texture_target, uint32 texture_id);
 157
 158   base::MessageLoop* message_loop_;
 159
 160   scoped_refptr<gfx::GLContext> gl_context_;
 161   scoped_refptr<gfx::GLSurface> gl_surface_;
 162
 163   gfx::AcceleratedWidget window_;
 164
 165   gfx::Size screen_size_;
 166
 167   std::vector<RenderedVideo> videos_;
 168
 169   bool render_as_thumbnails_;
 170   int frame_count_;
 171   GLuint thumbnails_fbo_id_;
 172   GLuint thumbnails_texture_id_;
 173   gfx::Size thumbnails_fbo_size_;
 174   gfx::Size thumbnail_size_;
 175   GLuint program_;
 176   base::TimeDelta frame_duration_;
 177   base::TimeTicks scheduled_render_time_;
 178   base::CancelableClosure render_task_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(RenderingHelper);
 181 };
 182
 183 }  // namespace content
 184
 185 #endif  // CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_