ui/gl/gl_surface_x11.cc

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