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 UI_GL_GL_SURFACE_H_
6#define UI_GL_GL_SURFACE_H_
7
8#include <string>
9
10#include "base/memory/ref_counted.h"
11#include "build/build_config.h"
12#include "ui/gfx/native_widget_types.h"
13#include "ui/gfx/overlay_transform.h"
14#include "ui/gfx/rect.h"
15#include "ui/gfx/rect_f.h"
16#include "ui/gfx/size.h"
17#include "ui/gl/gl_export.h"
18#include "ui/gl/gl_implementation.h"
19
20namespace gfx {
21
22class GLContext;
23class GLImage;
24class VSyncProvider;
25
26// Encapsulates a surface that can be rendered to with GL, hiding platform
27// specific management.
28class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
29 public:
30  GLSurface();
31
32  // (Re)create the surface. TODO(apatrick): This is an ugly hack to allow the
33  // EGL surface associated to be recreated without destroying the associated
34  // context. The implementation of this function for other GLSurface derived
35  // classes is in a pending changelist.
36  virtual bool Initialize();
37
38  // Destroys the surface.
39  virtual void Destroy() = 0;
40
41  virtual bool Resize(const gfx::Size& size);
42
43  // Recreate the surface without changing the size.
44  virtual bool Recreate();
45
46  // Unschedule the GpuScheduler and return true to abort the processing of
47  // a GL draw call to this surface and defer it until the GpuScheduler is
48  // rescheduled.
49  virtual bool DeferDraws();
50
51  // Returns true if this surface is offscreen.
52  virtual bool IsOffscreen() = 0;
53
54  // Swaps front and back buffers. This has no effect for off-screen
55  // contexts.
56  virtual bool SwapBuffers() = 0;
57
58  // Get the size of the surface.
59  virtual gfx::Size GetSize() = 0;
60
61  // Get the underlying platform specific surface "handle".
62  virtual void* GetHandle() = 0;
63
64  // Returns whether or not the surface supports PostSubBuffer.
65  virtual bool SupportsPostSubBuffer();
66
67  // Returns the internal frame buffer object name if the surface is backed by
68  // FBO. Otherwise returns 0.
69  virtual unsigned int GetBackingFrameBufferObject();
70
71  // Copy part of the backbuffer to the frontbuffer.
72  virtual bool PostSubBuffer(int x, int y, int width, int height);
73
74  // Initialize GL bindings.
75  static bool InitializeOneOff();
76
77  // Unit tests should call these instead of InitializeOneOff() to set up
78  // GL bindings appropriate for tests.
79  static void InitializeOneOffForTests();
80  static void InitializeOneOffWithMockBindingsForTests();
81  static void InitializeDynamicMockBindingsForTests(GLContext* context);
82
83  // Called after a context is made current with this surface. Returns false
84  // on error.
85  virtual bool OnMakeCurrent(GLContext* context);
86
87  // Used for explicit buffer management.
88  virtual bool SetBackbufferAllocation(bool allocated);
89  virtual void SetFrontbufferAllocation(bool allocated);
90
91  // Get a handle used to share the surface with another process. Returns null
92  // if this is not possible.
93  virtual void* GetShareHandle();
94
95  // Get the platform specific display on which this surface resides, if
96  // available.
97  virtual void* GetDisplay();
98
99  // Get the platfrom specific configuration for this surface, if available.
100  virtual void* GetConfig();
101
102  // Get the GL pixel format of the surface, if available.
103  virtual unsigned GetFormat();
104
105  // Get access to a helper providing time of recent refresh and period
106  // of screen refresh. If unavailable, returns NULL.
107  virtual VSyncProvider* GetVSyncProvider();
108
109  // Schedule an overlay plane to be shown at swap time.
110  // |z_order| specifies the stacking order of the plane relative to the
111  // main framebuffer located at index 0. For the case where there is no
112  // main framebuffer, overlays may be scheduled at 0, taking its place.
113  // |transform| specifies how the buffer is to be transformed during
114  // composition.
115  // |image| to be presented by the overlay.
116  // |bounds_rect| specify where it is supposed to be on the screen in pixels.
117  // |crop_rect| specifies the region within the buffer to be placed inside
118  // |bounds_rect|.
119  virtual bool ScheduleOverlayPlane(int z_order,
120                                    OverlayTransform transform,
121                                    GLImage* image,
122                                    const Rect& bounds_rect,
123                                    const RectF& crop_rect);
124
125  virtual bool IsSurfaceless() const;
126
127  // Create a GL surface that renders directly to a view.
128  static scoped_refptr<GLSurface> CreateViewGLSurface(
129      gfx::AcceleratedWidget window);
130
131  // Create a GL surface used for offscreen rendering.
132  static scoped_refptr<GLSurface> CreateOffscreenGLSurface(
133      const gfx::Size& size);
134
135  static GLSurface* GetCurrent();
136
137 protected:
138  virtual ~GLSurface();
139  static bool InitializeOneOffImplementation(GLImplementation impl,
140                                             bool fallback_to_osmesa,
141                                             bool gpu_service_logging,
142                                             bool disable_gl_drawing);
143  static bool InitializeOneOffInternal();
144  static void SetCurrent(GLSurface* surface);
145
146  static bool ExtensionsContain(const char* extensions, const char* name);
147
148 private:
149  friend class base::RefCounted<GLSurface>;
150  friend class GLContext;
151
152  DISALLOW_COPY_AND_ASSIGN(GLSurface);
153};
154
155// Implementation of GLSurface that forwards all calls through to another
156// GLSurface.
157class GL_EXPORT GLSurfaceAdapter : public GLSurface {
158 public:
159  explicit GLSurfaceAdapter(GLSurface* surface);
160
161  virtual bool Initialize() OVERRIDE;
162  virtual void Destroy() OVERRIDE;
163  virtual bool Resize(const gfx::Size& size) OVERRIDE;
164  virtual bool Recreate() OVERRIDE;
165  virtual bool DeferDraws() OVERRIDE;
166  virtual bool IsOffscreen() OVERRIDE;
167  virtual bool SwapBuffers() OVERRIDE;
168  virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
169  virtual bool SupportsPostSubBuffer() OVERRIDE;
170  virtual gfx::Size GetSize() OVERRIDE;
171  virtual void* GetHandle() OVERRIDE;
172  virtual unsigned int GetBackingFrameBufferObject() OVERRIDE;
173  virtual bool OnMakeCurrent(GLContext* context) OVERRIDE;
174  virtual bool SetBackbufferAllocation(bool allocated) OVERRIDE;
175  virtual void SetFrontbufferAllocation(bool allocated) OVERRIDE;
176  virtual void* GetShareHandle() OVERRIDE;
177  virtual void* GetDisplay() OVERRIDE;
178  virtual void* GetConfig() OVERRIDE;
179  virtual unsigned GetFormat() OVERRIDE;
180  virtual VSyncProvider* GetVSyncProvider() OVERRIDE;
181  virtual bool ScheduleOverlayPlane(int z_order,
182                                    OverlayTransform transform,
183                                    GLImage* image,
184                                    const Rect& bounds_rect,
185                                    const RectF& crop_rect) OVERRIDE;
186  virtual bool IsSurfaceless() const OVERRIDE;
187
188  GLSurface* surface() const { return surface_.get(); }
189
190 protected:
191  virtual ~GLSurfaceAdapter();
192
193 private:
194  scoped_refptr<GLSurface> surface_;
195
196  DISALLOW_COPY_AND_ASSIGN(GLSurfaceAdapter);
197};
198
199}  // namespace gfx
200
201#endif  // UI_GL_GL_SURFACE_H_
202