Add GL_TEXTURE_EXTERNAL_OES as supported texture target for CHROMIUM_map_image.

ui/gl/gl_image_shm.cc

 // Copyright 2013 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 "ui/gl/gl_image_shm.h"
 
 #include "base/debug/trace_event.h"
 #include "base/process/process_handle.h"
-#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_surface_egl.h"

[reveman, 2014/03/17 01:13:38]

why is gl_bindings.h not enough?

 
 namespace gfx {
 
 namespace {
 
 bool ValidFormat(unsigned internalformat) {
   switch (internalformat) {
     case GL_BGRA8_EXT:
     case GL_RGBA8_OES:
       return true;
@@ skipping 37 matching lines @@
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 }  // namespace
 
 GLImageShm::GLImageShm(gfx::Size size, unsigned internalformat)
     : size_(size),
-      internalformat_(internalformat) {
-}
+      internalformat_(internalformat),
+      external_texture_id_(0),
+      egl_image_(EGL_NO_IMAGE_KHR) {}
 
 GLImageShm::~GLImageShm() {
   Destroy();
 }
 
 bool GLImageShm::Initialize(gfx::GpuMemoryBufferHandle buffer) {
   if (!ValidFormat(internalformat_)) {
     DVLOG(0) << "Invalid format: " << internalformat_;
     return false;
   }
 
   if (!base::SharedMemory::IsHandleValid(buffer.handle))
     return false;
 
   base::SharedMemory shared_memory(buffer.handle, true);
 
   // Duplicate the handle.
   base::SharedMemoryHandle duped_shared_memory_handle;
   if (!shared_memory.ShareToProcess(base::GetCurrentProcessHandle(),
                                     &duped_shared_memory_handle)) {
     DVLOG(0) << "Failed to duplicate shared memory handle.";
     return false;
   }
 
   shared_memory_.reset(
       new base::SharedMemory(duped_shared_memory_handle, true));
   return true;
 }
 
-void GLImageShm::Destroy() {
+void GLImageShm::CreateTexture2D() {
+  glGenTextures(1, &external_texture_id_);
+  glBindTexture(GL_TEXTURE_2D, external_texture_id_);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }
 
+bool GLImageShm::CreateEGLImage() {
+  EGLint egl_attrib_list[] = {EGL_GL_TEXTURE_LEVEL_KHR, 0,  // mip-level.
+                              EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+  egl_image_ =
+      eglCreateImageKHR(eglGetCurrentDisplay(),
+                        eglGetCurrentContext(),
+                        EGL_GL_TEXTURE_2D_KHR,
+                        reinterpret_cast<EGLClientBuffer>(external_texture_id_),
+                        egl_attrib_list);
+  if (egl_image_ == EGL_NO_IMAGE_KHR) {
+    EGLint error = eglGetError();
+    LOG(ERROR) << "Error creating EGLImage: " << error;
+    return false;
+  }
+  return true;
+}
+
+void GLImageShm::ReleaseEGLImageandTexture() {
+  if (egl_image_ != EGL_NO_IMAGE_KHR)
+    eglDestroyImageKHR(eglGetCurrentDisplay(), egl_image_);
+  if (external_texture_id_)
+    glDeleteTextures(1, &external_texture_id_);
+}
+
+void GLImageShm::Destroy() { ReleaseEGLImageandTexture(); }
+
 gfx::Size GLImageShm::GetSize() {
   return size_;
 }
 
 bool GLImageShm::BindTexImage(unsigned target) {
   TRACE_EVENT0("gpu", "GLImageShm::BindTexImage");
   DCHECK(shared_memory_);
   DCHECK(ValidFormat(internalformat_));
 
   size_t size = size_.GetArea() * BytesPerPixel(internalformat_);
   DCHECK(!shared_memory_->memory());
   if (!shared_memory_->Map(size)) {
     DVLOG(0) << "Failed to map shared memory.";
     return false;
   }
 
-  DCHECK(shared_memory_->memory());
-  glTexImage2D(target,
-               0,  // mip level
-               TextureFormat(internalformat_),
-               size_.width(),
-               size_.height(),
-               0,  // border
-               DataFormat(internalformat_),
-               DataType(internalformat_),
-               shared_memory_->memory());
+  if (target != GL_TEXTURE_EXTERNAL_OES) {
+    DCHECK(shared_memory_->memory());
+    glTexImage2D(target,
+                 0,  // mip level
+                 TextureFormat(internalformat_),
+                 size_.width(),
+                 size_.height(),
+                 0,  // border
+                 DataFormat(internalformat_),
+                 DataType(internalformat_),
+                 shared_memory_->memory());
+  } else {
+    // Save current GL state.
+    GLint current_texture_id = 0;
+    glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &current_texture_id);

[reveman, 2014/03/15 14:08:45]

EXTERNAL_OES binding is not the state you're changing. It's the TEXTURE_2D
binding you're changing.

[reveman, 2014/03/17 01:13:38]

Also, use ScopedTextureBinder here instead.

+    CreateTexture2D();
 
+    DCHECK(shared_memory_->memory());
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,  // mip level
+                 TextureFormat(internalformat_),
+                 size_.width(),
+                 size_.height(),
+                 0,  // border
+                 DataFormat(internalformat_),
+                 DataType(internalformat_),
+                 shared_memory_->memory());
+
+    if (!CreateEGLImage()) {
+      shared_memory_->Unmap();
+      return false;
+    }
+    glBindTexture(GL_TEXTURE_2D, external_texture_id_);
+    glEGLImageTargetTexture2DOES(target, egl_image_);
+
+    // Restore GL State and release.
+    ReleaseEGLImageandTexture();

[reveman, 2014/03/15 14:08:45]

what's the point of having egl_image_ and external_texture_id_ members if the
lifetime of them doesn't go beyond this function?

You can reuse the egl image and the external texture id if you use
glTexSubImage2D. If not already, please look at
http://www.khronos.org/registry/egl/extensions/KHR/EGL_KHR_gl_image.txt to
understand how this extension works.

[reveman, 2014/03/17 01:13:38]

Don't get hung up on reusing the egl image though. I'd like to keep this as
clean and simple as possible. If calling TexImage2D and re-creating the egl
image with each bind is cleaner, then do that. I'm pretty sure you still have to
keep the egl image and texture around as members though. Binding the egl image
to a texture and then destroying the egl image doesn't seem right.

+    glBindTexture(target, current_texture_id);
+  }
   shared_memory_->Unmap();
   return true;
 }
 
 void GLImageShm::ReleaseTexImage(unsigned target) {
 }
 
 void GLImageShm::WillUseTexImage() {
 }
 
 void GLImageShm::DidUseTexImage() {
 }
 
 }  // namespace gfx