ui/gl/gl_image_glx.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 extern "C" {
   6 #include <X11/Xlib.h>
   7 }
   8
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "ui/gl/gl_bindings.h"
  12 #include "ui/gl/gl_image_glx.h"
  13 #include "ui/gl/gl_surface_glx.h"
  14
  15 namespace gfx {
  16
  17 namespace {
  18
  19 bool ValidFormat(unsigned internalformat) {
  20   switch (internalformat) {
  21     case GL_RGB:
  22     case GL_RGBA:
  23       return true;
  24     default:
  25       return false;
  26   }
  27 }
  28
  29 int TextureFormat(unsigned internalformat) {
  30   switch (internalformat) {
  31     case GL_RGB:
  32       return GLX_TEXTURE_FORMAT_RGB_EXT;
  33     case GL_RGBA:
  34       return GLX_TEXTURE_FORMAT_RGBA_EXT;
  35     default:
  36       NOTREACHED();
  37       return 0;
  38   }
  39 }
  40
  41 int BindToTextureFormat(unsigned internalformat) {
  42   switch (internalformat) {
  43     case GL_RGB:
  44       return GLX_BIND_TO_TEXTURE_RGB_EXT;
  45     case GL_RGBA:
  46       return GLX_BIND_TO_TEXTURE_RGBA_EXT;
  47     default:
  48       NOTREACHED();
  49       return 0;
  50   }
  51 }
  52
  53 unsigned PixmapDepth(unsigned internalformat) {
  54   switch (internalformat) {
  55     case GL_RGBA:
  56       return 32u;
  57     case GL_RGB:
  58       return 24u;
  59     default:
  60       NOTREACHED();
  61       return 0u;
  62   }
  63 }
  64
  65 bool ActualPixmapGeometry(XID pixmap, gfx::Size* size, unsigned* depth) {
  66   XID root_return;
  67   int x_return;
  68   int y_return;
  69   unsigned width_return;
  70   unsigned height_return;
  71   unsigned border_width_return;
  72   unsigned depth_return;
  73   if (!XGetGeometry(gfx::GetXDisplay(),
  74                     pixmap,
  75                     &root_return,
  76                     &x_return,
  77                     &y_return,
  78                     &width_return,
  79                     &height_return,
  80                     &border_width_return,
  81                     &depth_return))
  82     return false;
  83
  84   if (size)
  85     *size = gfx::Size(width_return, height_return);
  86   if (depth)
  87     *depth = depth_return;
  88   return true;
  89 }
  90
  91 unsigned ActualPixmapDepth(XID pixmap) {
  92   unsigned depth;
  93   if (!ActualPixmapGeometry(pixmap, NULL, &depth))
  94     return -1;
  95
  96   return depth;
  97 }
  98
  99 gfx::Size ActualPixmapSize(XID pixmap) {
 100   gfx::Size size;
 101   if (!ActualPixmapGeometry(pixmap, &size, NULL))
 102     return gfx::Size();
 103
 104   return size;
 105 }
 106
 107 }  // namespace anonymous
 108
 109 GLImageGLX::GLImageGLX(const gfx::Size& size, unsigned internalformat)
 110     : glx_pixmap_(0), size_(size), internalformat_(internalformat) {
 111 }
 112
 113 GLImageGLX::~GLImageGLX() {
 114   DCHECK_EQ(0u, glx_pixmap_);
 115 }
 116
 117 bool GLImageGLX::Initialize(XID pixmap) {
 118   if (!GLSurfaceGLX::IsTextureFromPixmapSupported()) {
 119     DVLOG(0) << "GLX_EXT_texture_from_pixmap not supported.";
 120     return false;
 121   }
 122
 123   if (!ValidFormat(internalformat_)) {
 124     DVLOG(0) << "Invalid format: " << internalformat_;
 125     return false;
 126   }
 127
 128   DCHECK_EQ(PixmapDepth(internalformat_), ActualPixmapDepth(pixmap));
 129   DCHECK_EQ(size_.ToString(), ActualPixmapSize(pixmap).ToString());
 130
 131   int config_attribs[] = {
 132       GLX_DRAWABLE_TYPE,                    GLX_PIXMAP_BIT,
 133       GLX_BIND_TO_TEXTURE_TARGETS_EXT,      GLX_TEXTURE_2D_EXT,
 134       BindToTextureFormat(internalformat_), GL_TRUE,
 135       0};
 136   int num_elements = 0;
 137   gfx::XScopedPtr<GLXFBConfig> config(
 138       glXChooseFBConfig(gfx::GetXDisplay(), DefaultScreen(gfx::GetXDisplay()),
 139                         config_attribs, &num_elements));
 140   if (!config.get()) {
 141     DVLOG(0) << "glXChooseFBConfig failed.";
 142     return false;
 143   }
 144   if (!num_elements) {
 145     DVLOG(0) << "glXChooseFBConfig returned 0 elements.";
 146     return false;
 147   }
 148
 149   int pixmap_attribs[] = {GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
 150                           GLX_TEXTURE_FORMAT_EXT,
 151                           TextureFormat(internalformat_), 0};
 152   glx_pixmap_ = glXCreatePixmap(
 153       gfx::GetXDisplay(), *config.get(), pixmap, pixmap_attribs);
 154   if (!glx_pixmap_) {
 155     DVLOG(0) << "glXCreatePixmap failed.";
 156     return false;
 157   }
 158
 159   return true;
 160 }
 161
 162 void GLImageGLX::Destroy(bool have_context) {
 163   if (glx_pixmap_) {
 164     glXDestroyGLXPixmap(gfx::GetXDisplay(), glx_pixmap_);
 165     glx_pixmap_ = 0;
 166   }
 167 }
 168
 169 gfx::Size GLImageGLX::GetSize() { return size_; }
 170
 171 bool GLImageGLX::BindTexImage(unsigned target) {
 172   if (!glx_pixmap_)
 173     return false;
 174
 175   // Requires TEXTURE_2D target.
 176   if (target != GL_TEXTURE_2D)
 177     return false;
 178
 179   glXBindTexImageEXT(gfx::GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT, 0);
 180   return true;
 181 }
 182
 183 void GLImageGLX::ReleaseTexImage(unsigned target) {
 184   DCHECK_NE(0u, glx_pixmap_);
 185   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), target);
 186
 187   glXReleaseTexImageEXT(gfx::GetXDisplay(), glx_pixmap_, GLX_FRONT_LEFT_EXT);
 188 }
 189
 190 bool GLImageGLX::CopyTexImage(unsigned target) {
 191   return false;
 192 }
 193
 194 bool GLImageGLX::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
 195                                       int z_order,
 196                                       OverlayTransform transform,
 197                                       const Rect& bounds_rect,
 198                                       const RectF& crop_rect) {
 199   return false;
 200 }
 201
 202 }  // namespace gfx