Updating texture validation to account for sampler objects in ES3

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 53 matching lines @@
   bool can_render_;
   bool can_render_to_;
   bool npot_;
 
   // Since we will be hashing this signature structure, the padding must be
   // zero initialized. Although the C++11 specifications specify that this is
   // true, we will use a constructor with a memset to further enforce it instead
   // of relying on compilers adhering to this deep dark corner specification.
   TextureSignature(GLenum target,
                    GLint level,
-                   GLenum min_filter,
-                   GLenum mag_filter,
-                   GLenum wrap_r,
-                   GLenum wrap_s,
-                   GLenum wrap_t,
+                   const SamplerState& sampler_state,
                    GLenum usage,
                    GLenum internal_format,
-                   GLenum compare_func,
-                   GLenum compare_mode,
                    GLsizei width,
                    GLsizei height,
                    GLsizei depth,
-                   GLfloat max_lod,
-                   GLfloat min_lod,
                    GLint base_level,
                    GLint border,
                    GLint max_level,
                    GLenum format,
                    GLenum type,
                    bool has_image,
                    bool can_render,
                    bool can_render_to,
                    bool npot) {
     memset(this, 0, sizeof(TextureSignature));
     target_ = target;
     level_ = level;
-    min_filter_ = min_filter;
-    mag_filter_ = mag_filter;
-    wrap_r_ = wrap_r;
-    wrap_s_ = wrap_s;
-    wrap_t_ = wrap_t;
+    min_filter_ = sampler_state.min_filter;
+    mag_filter_ = sampler_state.mag_filter;
+    wrap_r_ = sampler_state.wrap_r;
+    wrap_s_ = sampler_state.wrap_s;
+    wrap_t_ = sampler_state.wrap_t;
     usage_ = usage;
     internal_format_ = internal_format;
-    compare_func_ = compare_func;
-    compare_mode_ = compare_mode;
+    compare_func_ = sampler_state.compare_func;
+    compare_mode_ = sampler_state.compare_mode;
     width_ = width;
     height_ = height;
     depth_ = depth;
-    max_lod_ = max_lod;
-    min_lod_ = min_lod;
+    max_lod_ = sampler_state.max_lod;
+    min_lod_ = sampler_state.min_lod;
     base_level_ = base_level;
     border_ = border;
     max_level_ = max_level;
     format_ = format;
     type_ = type;
     has_image_ = has_image;
     can_render_ = can_render;
     can_render_to_ = can_render_to;
     npot_ = npot;
   }
@@ skipping 158 matching lines @@
 TextureManager::~TextureManager() {
   for (unsigned int i = 0; i < destruction_observers_.size(); i++)
     destruction_observers_[i]->OnTextureManagerDestroying(this);
 
   DCHECK(textures_.empty());
 
   // If this triggers, that means something is keeping a reference to
   // a Texture belonging to this.
   CHECK_EQ(texture_count_, 0u);
 
-  DCHECK_EQ(0, num_unrenderable_textures_);
   DCHECK_EQ(0, num_unsafe_textures_);
   DCHECK_EQ(0, num_uncleared_mips_);
   DCHECK_EQ(0, num_images_);
 
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
@@ skipping 11 matching lines @@
 
 Texture::Texture(GLuint service_id)
     : mailbox_manager_(NULL),
       memory_tracking_ref_(NULL),
       service_id_(service_id),
       owned_service_id_(service_id),
       cleared_(true),
       num_uncleared_mips_(0),
       num_npot_faces_(0),
       target_(0),
-      min_filter_(GL_NEAREST_MIPMAP_LINEAR),
-      mag_filter_(GL_LINEAR),
-      wrap_r_(GL_REPEAT),
-      wrap_s_(GL_REPEAT),
-      wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
-      compare_func_(GL_LEQUAL),
-      compare_mode_(GL_NONE),
-      max_lod_(1000.0f),
-      min_lod_(-1000.0f),
       base_level_(0),
       max_level_(1000),
       max_level_set_(-1),
       texture_complete_(false),
       texture_mips_dirty_(false),
       cube_complete_(false),
       texture_level0_dirty_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
@@ skipping 90 matching lines @@
     }
     const Texture::LevelInfo& first_face =
         face_infos_[0].level_infos[base_level_];
     if (first_face.width == 0 ||
         first_face.height == 0 ||
         first_face.depth == 0) {
       return CAN_RENDER_NEVER;
     }
   }
 
-  bool needs_mips = NeedsMips();
-  if (needs_mips) {
-    if (!texture_complete())
-      return CAN_RENDER_NEVER;
-  }
-
   if (target_ == GL_TEXTURE_CUBE_MAP && !cube_complete())
     return CAN_RENDER_NEVER;
 
-  bool is_npot_compatible = !needs_mips &&
-      wrap_s_ == GL_CLAMP_TO_EDGE &&
-      wrap_t_ == GL_CLAMP_TO_EDGE;
-
-  if (!is_npot_compatible) {
-    if (target_ == GL_TEXTURE_RECTANGLE_ARB)
-      return CAN_RENDER_NEVER;
-    else if (npot())
-      return CAN_RENDER_ONLY_IF_NPOT;
-  }
-
-  return CAN_RENDER_ALWAYS;
+  // Texture may be renderable, but it depends on the sampler it's used with,
+  // the context that's using it, and the extensions available.
+  return CAN_RENDER_NEEDS_VALIDATION;
 }
 
 bool Texture::CanRender(const FeatureInfo* feature_info) const {
+  return CanRenderWithSampler(feature_info, sampler_state());
+}
+
+bool Texture::CanRenderWithSampler(const FeatureInfo* feature_info,
+                                   const SamplerState& sampler_state) const {
   switch (can_render_condition_) {
     case CAN_RENDER_ALWAYS:
       return true;
     case CAN_RENDER_NEVER:
       return false;
-    case CAN_RENDER_ONLY_IF_NPOT:
+    case CAN_RENDER_NEEDS_VALIDATION:
       break;
   }
-  return feature_info->feature_flags().npot_ok;
+
+  bool needs_mips = sampler_state.min_filter != GL_NEAREST &&
+                    sampler_state.min_filter != GL_LINEAR;
+  if (needs_mips) {
+    if (static_cast<size_t>(base_level_) >= face_infos_[0].level_infos.size())
+      return false;
+
+    const Texture::LevelInfo& first_level =
+        face_infos_[0].level_infos[base_level_];
+
+    if (!texture_complete()) {
+      return false;
+    } else if (first_level.type == GL_FLOAT &&
+        !feature_info->feature_flags().enable_texture_float_linear &&
+        (sampler_state.min_filter != GL_NEAREST_MIPMAP_NEAREST ||
+         sampler_state.mag_filter != GL_NEAREST)) {
+      return false;
+    } else if (first_level.type == GL_HALF_FLOAT_OES &&
+        !feature_info->feature_flags().enable_texture_half_float_linear &&
+        (sampler_state.min_filter != GL_NEAREST_MIPMAP_NEAREST ||
+         sampler_state.mag_filter != GL_NEAREST)) {
+      return false;
+    }
+  }
+
+  if (!feature_info->IsES3Enabled()) {
+    bool is_npot_compatible = !needs_mips &&
+        sampler_state.wrap_s == GL_CLAMP_TO_EDGE &&
+        sampler_state.wrap_t == GL_CLAMP_TO_EDGE;
+
+    if (!is_npot_compatible) {
+      if (target_ == GL_TEXTURE_RECTANGLE_ARB)
+        return false;
+      else if (npot())
+        return feature_info->feature_flags().npot_ok;
+    }
+  }
+
+  return true;
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
 
   const Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
 
   TextureSignature signature_data(target,
                                   level,
-                                  min_filter_,
-                                  mag_filter_,
-                                  wrap_r_,
-                                  wrap_s_,
-                                  wrap_t_,
+                                  sampler_state_,
                                   usage_,
                                   info.internal_format,
-                                  compare_func_,
-                                  compare_mode_,
                                   info.width,
                                   info.height,
                                   info.depth,
-                                  max_lod_,
-                                  min_lod_,
                                   base_level_,
                                   info.border,
                                   max_level_,
                                   info.format,
                                   info.type,
                                   info.image.get() != NULL,
                                   CanRender(feature_info),
                                   CanRenderTo(),
                                   npot_);
 
@@ skipping 36 matching lines @@
     const FeatureInfo* feature_info, GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   face_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     face_infos_[ii].level_infos.resize(max_levels);
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
-    min_filter_ = GL_LINEAR;
-    wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
+    sampler_state_.min_filter = GL_LINEAR;
+    sampler_state_.wrap_s = sampler_state_.wrap_t = GL_CLAMP_TO_EDGE;
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     immutable_ = true;
   }
   Update(feature_info);
   UpdateCanRenderCondition();
 }
 
 bool Texture::CanGenerateMipmaps(
@@ skipping 163 matching lines @@
   bool cleared = info->cleared_rect == gfx::Rect(info->width, info->height);
   if (cleared == was_cleared)
     return;
   int delta = cleared ? -1 : +1;
   num_uncleared_mips_ += delta;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateUnclearedMips(delta);
 }
 
 void Texture::UpdateCanRenderCondition() {
-  CanRenderCondition can_render_condition = GetCanRenderCondition();
-  if (can_render_condition_ == can_render_condition)
-    return;
-  for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
-    (*it)->manager()->UpdateCanRenderCondition(can_render_condition_,
-                                               can_render_condition);
-  can_render_condition_ = can_render_condition;
+  can_render_condition_ = GetCanRenderCondition();
 }
 
 void Texture::UpdateHasImages() {
   if (face_infos_.empty())
     return;
 
   bool has_images = false;
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     for (size_t jj = 0; jj < face_infos_[ii].level_infos.size(); ++jj) {
       const Texture::LevelInfo& info = face_infos_[ii].level_infos[jj];
@@ skipping 218 matching lines @@
     case GL_TEXTURE_MIN_LOD:
     case GL_TEXTURE_MAX_LOD:
       {
         GLfloat fparam = static_cast<GLfloat>(param);
         return SetParameterf(feature_info, pname, fparam);
       }
     case GL_TEXTURE_MIN_FILTER:
       if (!feature_info->validators()->texture_min_filter_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      min_filter_ = param;
+      sampler_state_.min_filter = param;
       break;
     case GL_TEXTURE_MAG_FILTER:
       if (!feature_info->validators()->texture_mag_filter_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      mag_filter_ = param;
+      sampler_state_.mag_filter = param;
       break;
     case GL_TEXTURE_WRAP_R:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      wrap_r_ = param;
+      sampler_state_.wrap_r = param;
       break;
     case GL_TEXTURE_WRAP_S:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      wrap_s_ = param;
+      sampler_state_.wrap_s = param;
       break;
     case GL_TEXTURE_WRAP_T:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      wrap_t_ = param;
+      sampler_state_.wrap_t = param;
       break;
     case GL_TEXTURE_COMPARE_FUNC:
       if (!feature_info->validators()->texture_compare_func.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      compare_func_ = param;
+      sampler_state_.compare_func = param;
       break;
     case GL_TEXTURE_COMPARE_MODE:
       if (!feature_info->validators()->texture_compare_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
-      compare_mode_ = param;
+      sampler_state_.compare_mode = param;
       break;
     case GL_TEXTURE_BASE_LEVEL:
       if (param < 0) {
         return GL_INVALID_VALUE;
       }
       UpdateBaseLevel(param);
       break;
     case GL_TEXTURE_MAX_LEVEL:
       if (param < 0) {
         return GL_INVALID_VALUE;
@@ skipping 32 matching lines @@
     case GL_TEXTURE_COMPARE_FUNC:
     case GL_TEXTURE_COMPARE_MODE:
     case GL_TEXTURE_BASE_LEVEL:
     case GL_TEXTURE_MAX_LEVEL:
     case GL_TEXTURE_USAGE_ANGLE:
       {
         GLint iparam = static_cast<GLint>(param);
         return SetParameteri(feature_info, pname, iparam);
       }
     case GL_TEXTURE_MIN_LOD:
-      min_lod_ = param;
+      sampler_state_.min_lod = param;
       break;
     case GL_TEXTURE_MAX_LOD:
-      max_lod_ = param;
+      sampler_state_.max_lod = param;
       break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (param < 1.f) {
         return GL_INVALID_VALUE;
       }
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
@@ skipping 18 matching lines @@
   const GLsizei levels_needed = first_face.num_mip_levels;
 
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (face_infos_.size() == 6) &&
                    (first_level.width == first_level.height) &&
                    (first_level.width > 0);
 
   if (first_level.width == 0 || first_level.height == 0) {
     texture_complete_ = false;
-  } else if (first_level.type == GL_FLOAT &&
-      !feature_info->feature_flags().enable_texture_float_linear &&
-      (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
-       mag_filter_ != GL_NEAREST)) {
-    texture_complete_ = false;
-  } else if (first_level.type == GL_HALF_FLOAT_OES &&
-             !feature_info->feature_flags().enable_texture_half_float_linear &&
-             (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
-              mag_filter_ != GL_NEAREST)) {
-    texture_complete_ = false;
   }
 
   bool texture_level0_complete = true;
   if (cube_complete_ && texture_level0_dirty_) {
     for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
       const Texture::LevelInfo& face_base_level =
           face_infos_[ii].level_infos[base_level_];
       if (!TextureFaceComplete(first_level,
                                ii,
                                face_base_level.target,
@@ skipping 300 matching lines @@
       max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       max_3d_levels_(ComputeMipMapCount(GL_TEXTURE_3D,
                                         // Same as GL_TEXTURE_2D_ARRAY
                                         max_3d_texture_size,
                                         max_3d_texture_size,
                                         max_3d_texture_size)),
       use_default_textures_(use_default_textures),
-      num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       num_images_(0),
       texture_count_(0),
       have_context_(true),
       current_service_id_generation_(0) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
 }
@@ skipping 267 matching lines @@
     textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(TextureRef* ref) {
   Texture* texture = ref->texture();
   ++texture_count_;
   num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->SafeToRenderFrom())
     ++num_unsafe_textures_;
-  if (!texture->CanRender(feature_info_.get()))
-    ++num_unrenderable_textures_;
   if (texture->HasImages())
     ++num_images_;
 }
 
 void TextureManager::StopTracking(TextureRef* ref) {
   if (ref->num_observers()) {
     for (unsigned int i = 0; i < destruction_observers_.size(); i++) {
       destruction_observers_[i]->OnTextureRefDestroying(ref);
     }
     DCHECK_EQ(ref->num_observers(), 0);
   }
 
   Texture* texture = ref->texture();
 
   --texture_count_;
   if (texture->HasImages()) {
     DCHECK_NE(0, num_images_);
     --num_images_;
   }
-  if (!texture->CanRender(feature_info_.get())) {
-    DCHECK_NE(0, num_unrenderable_textures_);
-    --num_unrenderable_textures_;
-  }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
 }
 
 MemoryTypeTracker* TextureManager::GetMemTracker() {
   return memory_type_tracker_.get();
@@ skipping 47 matching lines @@
 void TextureManager::UpdateSafeToRenderFrom(int delta) {
   num_unsafe_textures_ += delta;
   DCHECK_GE(num_unsafe_textures_, 0);
 }
 
 void TextureManager::UpdateUnclearedMips(int delta) {
   num_uncleared_mips_ += delta;
   DCHECK_GE(num_uncleared_mips_, 0);
 }
 
-void TextureManager::UpdateCanRenderCondition(
-    Texture::CanRenderCondition old_condition,
-    Texture::CanRenderCondition new_condition) {
-  if (old_condition == Texture::CAN_RENDER_NEVER ||
-      (old_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
-       !feature_info_->feature_flags().npot_ok)) {
-    DCHECK_GT(num_unrenderable_textures_, 0);
-    --num_unrenderable_textures_;
-  }
-  if (new_condition == Texture::CAN_RENDER_NEVER ||
-      (new_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
-       !feature_info_->feature_flags().npot_ok))
-    ++num_unrenderable_textures_;
-}
-
 void TextureManager::UpdateNumImages(int delta) {
   num_images_ += delta;
   DCHECK_GE(num_images_, 0);
 }
 
 void TextureManager::IncFramebufferStateChangeCount() {
   if (framebuffer_manager_)
     framebuffer_manager_->IncFramebufferStateChangeCount();
 }
 
@@ skipping 809 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu