gpu: Add support for GLX_EXT_texture_from_pixmap extension.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 31 matching lines @@
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "ui/gl/gl_context.h"
+#if defined(USE_X11)
+#include "ui/gl/gl_context_glx.h"
+#endif
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
+#if defined(USE_X11)
+#include "ui/gl/gl_surface_glx.h"
+#endif
 #if defined(OS_MACOSX)
 #include "ui/surface/io_surface_support_mac.h"
 #endif
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
 namespace gpu {
 namespace gles2 {
@@ skipping 686 matching lines @@
     GLenum internal_format);
 
   // Wrapper for TexStorage2DEXT.
   void DoTexStorage2DEXT(
     GLenum target,
     GLint levels,
     GLenum internal_format,
     GLsizei width,
     GLsizei height);
 
+  // Wrapper for TexImagePixmap2DCHROMIUM.
+  void DoTexImagePixmap2DCHROMIUM(
+    GLenum target,
+    GLuint pixmap_id);
+
   void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoConsumeTextureCHROMIUM(GLenum target, const GLbyte* key);
 
   // Creates a ProgramInfo for the given program.
   ProgramManager::ProgramInfo* CreateProgramInfo(
       GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgramInfo(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
@@ skipping 548 matching lines @@
   // the tracing system.
   void UpdateBackbufferMemoryAccounting();
 
   // Returns true if the context was just lost due to e.g. GL_ARB_robustness.
   bool WasContextLost();
 
 #if defined(OS_MACOSX)
   void ReleaseIOSurfaceForTexture(GLuint texture_id);
 #endif
 
+#if defined(USE_X11)
+  void ReleaseGLXPixmapForTexture(GLuint texture_id);
+#endif
+
   // Validates the combination of texture parameters. For example validates that
   // for a given format the specific type, level and targets are valid.
   // Synthesizes the correct GL error if invalid. Returns true if valid.
   bool ValidateTextureParameters(
       const char* function_name,
       GLenum target, GLenum format, GLenum type, GLint level);
 
   bool ValidateCompressedTexDimensions(
       const char* function_name,
       GLint level, GLsizei width, GLsizei height, GLenum format);
@@ skipping 204 matching lines @@
 
   bool compile_shader_always_succeeds_;
 
   bool disable_workarounds_;
 
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
 
+#if defined(USE_X11)
+  typedef std::map<
+      GLuint, scoped_refptr<gfx::GLSurface> > TextureToPixmapGLSurfaceMap;
+  TextureToPixmapGLSurfaceMap texture_to_pixmap_gl_surface_map_;

[greggman, 2012/06/13 00:15:51]

What happens if I use this texture from another context? The mapping only exists
in this context.

+#endif
+
   typedef std::vector<GLES2DecoderImpl*> ChildList;
   ChildList children_;
 
   scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
 
   // Cached values of the currently assigned viewport dimensions.
   GLint viewport_x_, viewport_y_;
   GLsizei viewport_width_, viewport_height_;
   GLsizei viewport_max_width_, viewport_max_height_;
 
@@ skipping 939 matching lines @@
       }
       GLuint service_id = texture->service_id();
       if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
 #if defined(OS_MACOSX)
       if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
         ReleaseIOSurfaceForTexture(service_id);
       }
 #endif
+#if defined(USE_X11)
+      ReleaseGLXPixmapForTexture(service_id);
+#endif
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
   if (!context_.get() || !context_->MakeCurrent(surface_.get()))
     return false;
@@ skipping 330 matching lines @@
   offscreen_resolved_frame_buffer_.reset();
   offscreen_resolved_color_texture_.reset();
 
 #if defined(OS_MACOSX)
   for (TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.begin();
        it != texture_to_io_surface_map_.end(); ++it) {
     CFRelease(it->second);
   }
   texture_to_io_surface_map_.clear();
 #endif
+
+#if defined(USE_X11)
+  for (TextureToPixmapGLSurfaceMap::iterator it =
+         texture_to_pixmap_gl_surface_map_.begin();
+       it != texture_to_pixmap_gl_surface_map_.end(); ++it) {
+    scoped_refptr<gfx::GLSurface> pixmap_gl_surface = it->second;
+    glXReleaseTexImageEXT(
+        static_cast<gfx::GLContextGLX*>(GetGLContext())->display(),

[piman, 2012/06/12 23:15:38]

This is not a safe cast when based only on USE_X11: what about EGL?

+        reinterpret_cast<GLXDrawable>(pixmap_gl_surface->GetHandle()),
+        GLX_FRONT_LEFT_EXT);
+  }
+  texture_to_pixmap_gl_surface_map_.clear();
+#endif
 }
 
 void GLES2DecoderImpl::SetSurface(
     const scoped_refptr<gfx::GLSurface>& surface) {
   DCHECK(context_->IsCurrent(NULL));
   DCHECK(surface_.get());
   surface_ = surface;
   RestoreCurrentFramebufferBindings();
 }
 
@@ skipping 6130 matching lines @@
 
   if (!texture_manager()->Restore(info, definition.release())) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "invalid texture");
     return;
   }
 
   BindAndApplyTextureParameters(info);
 }
 
+#if defined(USE_X11)
+void GLES2DecoderImpl::ReleaseGLXPixmapForTexture(GLuint texture_id) {
+  TextureToPixmapGLSurfaceMap::iterator it =
+      texture_to_pixmap_gl_surface_map_.find(texture_id);
+  if (it != texture_to_pixmap_gl_surface_map_.end()) {
+    // Found a previous GLXPixmap bound to this texture; release it.
+    scoped_refptr<gfx::GLSurface> pixmap_gl_surface = it->second;
+    glXReleaseTexImageEXT(
+        static_cast<gfx::GLContextGLX*>(GetGLContext())->display(),
+        reinterpret_cast<GLXDrawable>(pixmap_gl_surface->GetHandle()),
+        GLX_FRONT_LEFT_EXT);
+    texture_to_pixmap_gl_surface_map_.erase(it);
+  }
+}
+#endif
+
+void GLES2DecoderImpl::DoTexImagePixmap2DCHROMIUM(
+    GLenum target, GLuint pixmap_id) {
+#if defined(USE_X11)
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationDesktopGL) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImageXPixmap2DCHROMIUM", "only supported on desktop GL");
+    return;
+  }
+
+  if (target != GL_TEXTURE_2D) {
+    // This might be supported in the future.
+    SetGLError(
+        GL_INVALID_OPERATION,
+        "glTexImagePixmap2DCHROMIUM", "requires TEXTURE_2D target");
+    return;
+  }
+
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImagePixmap2DCHROMIUM", "no texture bound");
+    return;
+  }
+  if (info == texture_manager()->GetDefaultTextureInfo(target)) {

[greggman, 2012/06/13 00:15:51]

Have you considered a new function

GetTextureInfoForTargetUnlessDefault 

to isolate this check?

+    // Maybe this is conceptually valid, but disallow it to avoid accidents.
+    SetGLError(GL_INVALID_OPERATION,
+               "glTexImagePixmap2DCHROMIUM", "can't bind default texture");
+    return;
+  }
+
+  if (pixmap_id) {
+    scoped_refptr<gfx::GLSurface> pixmap_gl_surface;
+
+    TextureToPixmapGLSurfaceMap::iterator it =
+        texture_to_pixmap_gl_surface_map_.find(info->service_id());
+    if (it == texture_to_pixmap_gl_surface_map_.end() ||
+          reinterpret_cast<XID>(it->second->GetShareHandle()) != pixmap_id) {
+      pixmap_gl_surface = new gfx::PixmapGLSurfaceGLX(pixmap_id);
+      if (!pixmap_gl_surface->Initialize()) {
+        SetGLError(GL_INVALID_OPERATION,
+                   "glTexImagePixmap2DCHROMIUM", "fail to create GLXPixmap "
+                   "from Pixmap with the given ID");
+        return;
+      }
+    } else {
+      pixmap_gl_surface = it->second;
+    }
+
+    // Release any GLXPixmap previously bound to this texture.
+    ReleaseGLXPixmapForTexture(info->service_id());
+
+    glXBindTexImageEXT(
+        static_cast<gfx::GLContextGLX*>(GetGLContext())->display(),
+        reinterpret_cast<GLXDrawable>(pixmap_gl_surface->GetHandle()),
+        GLX_FRONT_LEFT_EXT,
+        0);
+
+    texture_to_pixmap_gl_surface_map_.insert(
+        std::make_pair(info->service_id(), pixmap_gl_surface));
+
+    gfx::Size size = pixmap_gl_surface->GetSize();
+    texture_manager()->SetLevelInfo(

[greggman, 2012/06/13 00:15:51]

So mapping to a pix map magically sets the format and the type and puts in
GL_BGRA as internal format but GL_RGBA as format which is explicitly not allowed
in OpenGL ES.

What other issues does this bring up? Can I still call glTexImage2D on a
pixmapped texture and change the format? glGenerateMipmap? glCopyTexImage2D?
glCompressedTexImage2D?

If I call glDeleteTexture on a mapped texture what happens?

+        info, target, 0, GL_BGRA, size.width(), size.height(), 1, 0,
+        GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, true);
+  } else {
+    // Release any GLXPixmap previously bound to this texture.
+    ReleaseGLXPixmapForTexture(info->service_id());
+
+    texture_manager()->SetLevelCleared(info, GL_TEXTURE_2D, 0);
+  }
+#else
+  SetGLError(GL_INVALID_OPERATION,
+             "glTexImagePixmap2DCHROMIUM", "not supported");
+#endif
+}
+
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu