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 #include "ui/gl/gl_surface.h"
6
7 #include "base/debug/trace_event.h"
8 #include "base/logging.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop/message_loop.h"
11 #include "ui/gfx/native_widget_types.h"
12 #include "ui/gfx/x/x11_types.h"
13 #include "ui/gl/gl_bindings.h"
14 #include "ui/gl/gl_implementation.h"
15 #include "ui/gl/gl_surface_egl.h"
16 #include "ui/gl/gl_surface_glx.h"
17 #include "ui/gl/gl_surface_osmesa.h"
18 #include "ui/gl/gl_surface_stub.h"
19
20 namespace gfx {
21
22 // This OSMesa GL surface can use XLib to swap the contents of the buffer to a
23 // view.
24 class NativeViewGLSurfaceOSMesa : public GLSurfaceOSMesa {
25 public:
26 explicit NativeViewGLSurfaceOSMesa(gfx::AcceleratedWidget window);
27
28 static bool InitializeOneOff();
29
30 // Implement a subset of GLSurface.
31 virtual bool Initialize() OVERRIDE;
32 virtual void Destroy() OVERRIDE;
33 virtual bool Resize(const gfx::Size& new_size) OVERRIDE;
34 virtual bool IsOffscreen() OVERRIDE;
35 virtual bool SwapBuffers() OVERRIDE;
36 virtual bool SupportsPostSubBuffer() OVERRIDE;
37 virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
38
39 protected:
40 virtual ~NativeViewGLSurfaceOSMesa();
41
42 private:
43 Display* xdisplay_;
44 GC window_graphics_context_;
45 gfx::AcceleratedWidget window_;
46 GC pixmap_graphics_context_;
47 Pixmap pixmap_;
48
49 DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceOSMesa);
50 };
51
InitializeOneOffInternal()52 bool GLSurface::InitializeOneOffInternal() {
53 switch (GetGLImplementation()) {
54 case kGLImplementationDesktopGL:
55 if (!GLSurfaceGLX::InitializeOneOff()) {
56 LOG(ERROR) << "GLSurfaceGLX::InitializeOneOff failed.";
57 return false;
58 }
59 break;
60 case kGLImplementationOSMesaGL:
61 if (!NativeViewGLSurfaceOSMesa::InitializeOneOff()) {
62 LOG(ERROR) << "NativeViewGLSurfaceOSMesa::InitializeOneOff failed.";
63 return false;
64 }
65 break;
66 case kGLImplementationEGLGLES2:
67 if (!GLSurfaceEGL::InitializeOneOff()) {
68 LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
69 return false;
70 }
71 break;
72 default:
73 break;
74 }
75
76 return true;
77 }
78
NativeViewGLSurfaceOSMesa(gfx::AcceleratedWidget window)79 NativeViewGLSurfaceOSMesa::NativeViewGLSurfaceOSMesa(
80 gfx::AcceleratedWidget window)
81 : GLSurfaceOSMesa(OSMesaSurfaceFormatBGRA, gfx::Size(1, 1)),
82 xdisplay_(gfx::GetXDisplay()),
83 window_graphics_context_(0),
84 window_(window),
85 pixmap_graphics_context_(0),
86 pixmap_(0) {
87 DCHECK(xdisplay_);
88 DCHECK(window_);
89 }
90
91 // static
InitializeOneOff()92 bool NativeViewGLSurfaceOSMesa::InitializeOneOff() {
93 static bool initialized = false;
94 if (initialized)
95 return true;
96
97 if (!gfx::GetXDisplay()) {
98 LOG(ERROR) << "XOpenDisplay failed.";
99 return false;
100 }
101
102 initialized = true;
103 return true;
104 }
105
Initialize()106 bool NativeViewGLSurfaceOSMesa::Initialize() {
107 if (!GLSurfaceOSMesa::Initialize())
108 return false;
109
110 window_graphics_context_ = XCreateGC(xdisplay_, window_, 0, NULL);
111 if (!window_graphics_context_) {
112 LOG(ERROR) << "XCreateGC failed.";
113 Destroy();
114 return false;
115 }
116
117 return true;
118 }
119
Destroy()120 void NativeViewGLSurfaceOSMesa::Destroy() {
121 if (pixmap_graphics_context_) {
122 XFreeGC(xdisplay_, pixmap_graphics_context_);
123 pixmap_graphics_context_ = NULL;
124 }
125
126 if (pixmap_) {
127 XFreePixmap(xdisplay_, pixmap_);
128 pixmap_ = 0;
129 }
130
131 if (window_graphics_context_) {
132 XFreeGC(xdisplay_, window_graphics_context_);
133 window_graphics_context_ = NULL;
134 }
135
136 XSync(xdisplay_, False);
137 }
138
Resize(const gfx::Size & new_size)139 bool NativeViewGLSurfaceOSMesa::Resize(const gfx::Size& new_size) {
140 if (!GLSurfaceOSMesa::Resize(new_size))
141 return false;
142
143 XWindowAttributes attributes;
144 if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
145 LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
146 return false;
147 }
148
149 // Destroy the previous pixmap and graphics context.
150 if (pixmap_graphics_context_) {
151 XFreeGC(xdisplay_, pixmap_graphics_context_);
152 pixmap_graphics_context_ = NULL;
153 }
154 if (pixmap_) {
155 XFreePixmap(xdisplay_, pixmap_);
156 pixmap_ = 0;
157 }
158
159 // Recreate a pixmap to hold the frame.
160 pixmap_ = XCreatePixmap(xdisplay_,
161 window_,
162 new_size.width(),
163 new_size.height(),
164 attributes.depth);
165 if (!pixmap_) {
166 LOG(ERROR) << "XCreatePixmap failed.";
167 return false;
168 }
169
170 // Recreate a graphics context for the pixmap.
171 pixmap_graphics_context_ = XCreateGC(xdisplay_, pixmap_, 0, NULL);
172 if (!pixmap_graphics_context_) {
173 LOG(ERROR) << "XCreateGC failed";
174 return false;
175 }
176
177 return true;
178 }
179
IsOffscreen()180 bool NativeViewGLSurfaceOSMesa::IsOffscreen() {
181 return false;
182 }
183
SwapBuffers()184 bool NativeViewGLSurfaceOSMesa::SwapBuffers() {
185 TRACE_EVENT2("gpu", "NativeViewGLSurfaceOSMesa:RealSwapBuffers",
186 "width", GetSize().width(),
187 "height", GetSize().height());
188
189 gfx::Size size = GetSize();
190
191 XWindowAttributes attributes;
192 if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
193 LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
194 return false;
195 }
196
197 // Copy the frame into the pixmap.
198 gfx::PutARGBImage(xdisplay_,
199 attributes.visual,
200 attributes.depth,
201 pixmap_,
202 pixmap_graphics_context_,
203 static_cast<const uint8*>(GetHandle()),
204 size.width(),
205 size.height());
206
207 // Copy the pixmap to the window.
208 XCopyArea(xdisplay_,
209 pixmap_,
210 window_,
211 window_graphics_context_,
212 0,
213 0,
214 size.width(),
215 size.height(),
216 0,
217 0);
218
219 return true;
220 }
221
SupportsPostSubBuffer()222 bool NativeViewGLSurfaceOSMesa::SupportsPostSubBuffer() {
223 return true;
224 }
225
PostSubBuffer(int x,int y,int width,int height)226 bool NativeViewGLSurfaceOSMesa::PostSubBuffer(
227 int x, int y, int width, int height) {
228 gfx::Size size = GetSize();
229
230 // Move (0,0) from lower-left to upper-left
231 y = size.height() - y - height;
232
233 XWindowAttributes attributes;
234 if (!XGetWindowAttributes(xdisplay_, window_, &attributes)) {
235 LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
236 return false;
237 }
238
239 // Copy the frame into the pixmap.
240 gfx::PutARGBImage(xdisplay_,
241 attributes.visual,
242 attributes.depth,
243 pixmap_,
244 pixmap_graphics_context_,
245 static_cast<const uint8*>(GetHandle()),
246 size.width(),
247 size.height(),
248 x,
249 y,
250 x,
251 y,
252 width,
253 height);
254
255 // Copy the pixmap to the window.
256 XCopyArea(xdisplay_,
257 pixmap_,
258 window_,
259 window_graphics_context_,
260 x,
261 y,
262 width,
263 height,
264 x,
265 y);
266
267 return true;
268 }
269
~NativeViewGLSurfaceOSMesa()270 NativeViewGLSurfaceOSMesa::~NativeViewGLSurfaceOSMesa() {
271 Destroy();
272 }
273
CreateViewGLSurface(gfx::AcceleratedWidget window)274 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
275 gfx::AcceleratedWidget window) {
276 TRACE_EVENT0("gpu", "GLSurface::CreateViewGLSurface");
277 switch (GetGLImplementation()) {
278 case kGLImplementationOSMesaGL: {
279 scoped_refptr<GLSurface> surface(
280 new NativeViewGLSurfaceOSMesa(window));
281 if (!surface->Initialize())
282 return NULL;
283
284 return surface;
285 }
286 case kGLImplementationDesktopGL: {
287 scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceGLX(window));
288 if (!surface->Initialize())
289 return NULL;
290
291 return surface;
292 }
293 case kGLImplementationEGLGLES2: {
294 DCHECK(window != gfx::kNullAcceleratedWidget);
295 scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceEGL(window));
296 if (!surface->Initialize())
297 return NULL;
298
299 return surface;
300 }
301 case kGLImplementationMockGL:
302 return new GLSurfaceStub;
303 default:
304 NOTREACHED();
305 return NULL;
306 }
307 }
308
CreateOffscreenGLSurface(const gfx::Size & size)309 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
310 const gfx::Size& size) {
311 TRACE_EVENT0("gpu", "GLSurface::CreateOffscreenGLSurface");
312 switch (GetGLImplementation()) {
313 case kGLImplementationOSMesaGL: {
314 scoped_refptr<GLSurface> surface(
315 new GLSurfaceOSMesa(OSMesaSurfaceFormatRGBA, size));
316 if (!surface->Initialize())
317 return NULL;
318
319 return surface;
320 }
321 case kGLImplementationDesktopGL: {
322 scoped_refptr<GLSurface> surface(new PbufferGLSurfaceGLX(size));
323 if (!surface->Initialize())
324 return NULL;
325
326 return surface;
327 }
328 case kGLImplementationEGLGLES2: {
329 scoped_refptr<GLSurface> surface(new PbufferGLSurfaceEGL(size));
330 if (!surface->Initialize())
331 return NULL;
332
333 return surface;
334 }
335 case kGLImplementationMockGL:
336 return new GLSurfaceStub;
337 default:
338 NOTREACHED();
339 return NULL;
340 }
341 }
342
GetPlatformDefaultEGLNativeDisplay()343 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
344 return gfx::GetXDisplay();
345 }
346
347 } // namespace gfx
348