Support GL_OES_EGL_image_external

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2011 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/texture_manager.h"
 #include "base/bits.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/GLES2/gles2_command_buffer.h"
 
 namespace gpu {
 namespace gles2 {
 
 static GLsizei ComputeMipMapCount(
     GLsizei width, GLsizei height, GLsizei depth) {
   return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
 }
 
 static size_t GLTargetToFaceIndex(GLenum target) {
   switch (target) {
     case GL_TEXTURE_2D:
+    case GL_TEXTURE_EXTERNAL_OES:
       return 0;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       return 0;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       return 1;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       return 2;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       return 3;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
@@ skipping 102 matching lines @@
                    info1.format,
                    info1.type);
     }
   }
   return true;
 }
 
 bool TextureManager::TextureInfo::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
-      level_infos_.empty() || IsDeleted()) {
+      level_infos_.empty() || IsDeleted() ||
+      target_ == GL_TEXTURE_EXTERNAL_OES) {
     return false;
   }
   const TextureInfo::LevelInfo& first = level_infos_[0][0];
   // TODO(gman): Check internal_format, format and type.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
     if ((!info.valid) ||
         (info.width != first.width) ||
         (info.height != first.height) ||
         (info.depth != 1) ||
@@ skipping 96 matching lines @@
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::SetParameter(
     const FeatureInfo* feature_info, GLenum pname, GLint param) {
   DCHECK(feature_info);
+
+  if (target_ == GL_TEXTURE_EXTERNAL_OES) {
+    if (pname == GL_TEXTURE_MIN_FILTER &&
+        (param != GL_NEAREST && param != GL_LINEAR))
+      return false;
+    if ((pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T) &&
+        param != GL_CLAMP_TO_EDGE)
+      return false;
+  }
+
   switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
       if (!feature_info->validators()->texture_min_filter_mode.IsValid(param)) {
         return false;
       }
       min_filter_ = param;
       break;
     case GL_TEXTURE_MAG_FILTER:
       if (!feature_info->validators()->texture_mag_filter_mode.IsValid(param)) {
         return false;
@@ skipping 112 matching lines @@
                                      max_texture_size,
                                      max_texture_size)),
       max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       black_2d_texture_id_(0),
       black_cube_texture_id_(0) {
 }
 
-bool TextureManager::Initialize() {
+bool TextureManager::Initialize(const FeatureInfo* feature_info) {
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
   // resources and all contexts that share resource share the same default
   // texture.
 
   // Make default textures and texture for replacing non-renderable textures.
   GLuint ids[4];
   glGenTextures(arraysize(ids), ids);
   static uint8 black[] = {0, 0, 0, 255};
   for (int ii = 0; ii < 2; ++ii) {
@@ skipping 18 matching lines @@
   SetInfoTarget(default_texture_cube_map_, GL_TEXTURE_CUBE_MAP);
   for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
     default_texture_cube_map_->SetLevelInfo(
       &temp_feature_info, GLES2Util::IndexToGLFaceTarget(ii),
       0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE);
   }
 
   black_2d_texture_id_ = ids[0];
   black_cube_texture_id_ = ids[2];
 
+  if (feature_info->feature_flags().oes_egl_image_external) {
+    GLuint external_ids[2];
+    glGenTextures(arraysize(external_ids), external_ids);
+    glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
+    default_texture_external_oes_ = TextureInfo::Ref(
+        new TextureInfo(external_ids[0]));
+    SetInfoTarget(default_texture_external_oes_, GL_TEXTURE_EXTERNAL_OES);
+    default_texture_external_oes_->SetLevelInfo(
+        &temp_feature_info, GL_TEXTURE_EXTERNAL_OES, 0,
+        GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE);
+    default_texture_external_oes_->SetParameter(feature_info,
+                                                GL_TEXTURE_MIN_FILTER,
+                                                GL_LINEAR);
+    default_texture_external_oes_->SetParameter(feature_info,
+                                                GL_TEXTURE_WRAP_S,
+                                                GL_CLAMP_TO_EDGE);
+    default_texture_external_oes_->SetParameter(feature_info,
+                                                GL_TEXTURE_WRAP_T,
+                                                GL_CLAMP_TO_EDGE);
+
+    // Sampling a texture not associated with any EGLImage sibling will return
+    // black values according to the spec.
+    black_oes_external_texture_id_ = external_ids[1];
+  }
+
   return true;
 }
 
 bool TextureManager::ValidForTarget(
     const FeatureInfo* feature_info,
     GLenum target, GLint level,
     GLsizei width, GLsizei height, GLsizei depth) {
   GLsizei max_size = MaxSizeForTarget(target);
   return level >= 0 &&
          width >= 0 &&
@@ skipping 108 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu