Fix WebGL 2 texture renderability check.

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 407 matching lines @@
 }
 
 Texture::FaceInfo::~FaceInfo() {
 }
 
 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
   if (target_ == 0)
     return CAN_RENDER_ALWAYS;
 
   if (target_ != GL_TEXTURE_EXTERNAL_OES) {
-    if (face_infos_.empty()) {
+    if (face_infos_.empty() ||
+        static_cast<size_t>(base_level_) >= face_infos_[0].level_infos.size()) {
       return CAN_RENDER_NEVER;
     }
-
-    const Texture::LevelInfo& first_face = face_infos_[0].level_infos[0];
+    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())
@@ skipping 82 matching lines @@
   mailbox_manager_ = mailbox_manager;
 }
 
 bool Texture::MarkMipmapsGenerated(
     const FeatureInfo* feature_info) {
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
-    const Texture::LevelInfo& level0_info = face_info.level_infos[0];
+    const Texture::LevelInfo& level0_info = face_info.level_infos[base_level_];
     GLsizei width = level0_info.width;
     GLsizei height = level0_info.height;
     GLsizei depth = level0_info.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                GLES2Util::IndexToGLFaceTarget(ii);
 
     const GLsizei num_mips = face_info.num_mip_levels;
-    for (GLsizei level = 1; level < num_mips; ++level) {
+    for (GLsizei level = base_level_ + 1;
+         level < base_level_ + num_mips; ++level) {
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = std::max(1, depth >> 1);
       SetLevelInfo(feature_info, target, level, level0_info.internal_format,
                    width, height, depth, level0_info.border, level0_info.format,
                    level0_info.type, gfx::Rect(width, height));
     }
   }
 
   return true;
@@ skipping 79 matching lines @@
   if (face_index != 0) {
     complete &= (width == first_face.width &&
                  height == first_face.height &&
                  internal_format == first_face.internal_format &&
                  format == first_face.format &&
                  type == first_face.type);
   }
   return complete;
 }
 
-bool Texture::TextureMipComplete(const Texture::LevelInfo& level0_face,
+bool Texture::TextureMipComplete(const Texture::LevelInfo& base_level_face,
                                  GLenum target,
-                                 GLint level,
+                                 GLint level_diff,
                                  GLenum internal_format,
                                  GLsizei width,
                                  GLsizei height,
                                  GLsizei depth,
                                  GLenum format,
                                  GLenum type) {
   bool complete = (target != 0);
-  if (level != 0) {
-    const GLsizei mip_width = std::max(1, level0_face.width >> level);
-    const GLsizei mip_height = std::max(1, level0_face.height >> level);
-    const GLsizei mip_depth = std::max(1, level0_face.depth >> level);
+  if (level_diff > 0) {
+    const GLsizei mip_width = std::max(1, base_level_face.width >> level_diff);
+    const GLsizei mip_height =
+        std::max(1, base_level_face.height >> level_diff);
+    const GLsizei mip_depth = std::max(1, base_level_face.depth >> level_diff);
 
     complete &= (width == mip_width &&
                  height == mip_height &&
                  depth == mip_depth &&
-                 internal_format == level0_face.internal_format &&
-                 format == level0_face.format &&
-                 type == level0_face.type);
+                 internal_format == base_level_face.internal_format &&
+                 format == base_level_face.format &&
+                 type == base_level_face.type);
   }
   return complete;
 }
 
 void Texture::SetLevelClearedRect(GLenum target,
                                   GLint level,
                                   const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
@@ skipping 91 matching lines @@
   int delta = has_images ? +1 : -1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateNumImages(delta);
 }
 
 void Texture::IncAllFramebufferStateChangeCount() {
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->IncFramebufferStateChangeCount();
 }
 
+void Texture::UpdateBaseLevel(GLint base_level) {
+  if (base_level_ == base_level)
+    return;
+  base_level_ = base_level;
+
+  UpdateNumMipLevels();
+}
+
+void Texture::UpdateMaxLevel(GLint max_level) {
+  if (max_level_ == max_level)
+    return;
+  max_level_ = max_level;
+
+  UpdateNumMipLevels();
+}
+
+void Texture::UpdateNumMipLevels() {
+  if (face_infos_.empty())
+    return;
+
+  for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
+    Texture::FaceInfo& face_info = face_infos_[ii];
+    if (static_cast<size_t>(base_level_) >= face_info.level_infos.size())
+      continue;
+    const Texture::LevelInfo& info = face_info.level_infos[base_level_];
+    face_info.num_mip_levels =  std::min(

[piman, 2015/10/22 01:18:36]

nit: 2 spaces before std::min (should be 1).

[Zhenyao Mo, 2015/10/22 01:43:20]

Done.

+        std::max(0, max_level_ - base_level_ + 1),
+        TextureManager::ComputeMipMapCount(
+            target_, info.width, info.height, info.depth));
+  }
+
+  // mipmap-completeness needs to be re-evaluated.
+  texture_mips_dirty_ = true;
+}
+
 void Texture::SetLevelInfo(const FeatureInfo* feature_info,
                            GLenum target,
                            GLint level,
                            GLenum internal_format,
                            GLsizei width,
                            GLsizei height,
                            GLsizei depth,
                            GLint border,
                            GLenum format,
                            GLenum type,
@@ skipping 13 matching lines @@
   // Update counters only if any attributes have changed. Counters are
   // comparisons between the old and new values so it must be done before any
   // assignment has been done to the LevelInfo.
   if (info.target != target ||
       info.internal_format != internal_format ||
       info.width != width ||
       info.height != height ||
       info.depth != depth ||
       info.format != format ||
       info.type != type) {
-    if (level == 0) {
+    if (level == base_level_) {
       // Calculate the mip level count.
-      face_infos_[face_index].num_mip_levels =
-        TextureManager::ComputeMipMapCount(target_, width, height, depth);
+      face_infos_[face_index].num_mip_levels = std::min(
+          std::max(0, max_level_ - base_level_ + 1),
+          TextureManager::ComputeMipMapCount(target_, width, height, depth));
 
       // Update NPOT face count for the first level.
       bool prev_npot = TextureIsNPOT(info.width, info.height, info.depth);
       bool now_npot = TextureIsNPOT(width, height, depth);
       if (prev_npot != now_npot)
         num_npot_faces_ += now_npot ? 1 : -1;
 
       // Signify that level 0 has been changed, so they need to be reverified.
       texture_level0_dirty_ = true;
     }
 
     // Signify that at least one of the mips has changed.
     texture_mips_dirty_ = true;
   }
 
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
 
   UpdateMipCleared(&info, width, height, cleared_rect);
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
-      width, height, 1, format, type, 4, &info.estimated_size, NULL, NULL);
+      width, height, depth, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
   UpdateCleared();
   UpdateCanRenderCondition();
   UpdateHasImages();
   if (IsAttachedToFramebuffer()) {
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
@@ skipping 127 matching lines @@
     case GL_TEXTURE_COMPARE_MODE:
       if (!feature_info->validators()->texture_compare_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       compare_mode_ = param;
       break;
     case GL_TEXTURE_BASE_LEVEL:
       if (param < 0) {
         return GL_INVALID_VALUE;
       }
-      base_level_ = param;
+      UpdateBaseLevel(param);
       break;
     case GL_TEXTURE_MAX_LEVEL:
       if (param < 0) {
         return GL_INVALID_VALUE;
       }
-      max_level_ = param;
+      UpdateMaxLevel(param);
       break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (param < 1) {
         return GL_INVALID_VALUE;
       }
       break;
     case GL_TEXTURE_USAGE_ANGLE:
       if (!feature_info->validators()->texture_usage.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
@@ skipping 42 matching lines @@
       return GL_INVALID_ENUM;
   }
   return GL_NO_ERROR;
 }
 
 void Texture::Update(const FeatureInfo* feature_info) {
   // Update npot status.
   // Assume GL_TEXTURE_EXTERNAL_OES textures are npot, all others
   npot_ = (target_ == GL_TEXTURE_EXTERNAL_OES) || (num_npot_faces_ > 0);
 
-  if (face_infos_.empty()) {
+  if (face_infos_.empty() ||
+      static_cast<size_t>(base_level_) >= face_infos_[0].level_infos.size()) {
     texture_complete_ = false;
     cube_complete_ = false;
     return;
   }
 
   // Update texture_complete and cube_complete status.
   const Texture::FaceInfo& first_face = face_infos_[0];
-  const Texture::LevelInfo& first_level = first_face.level_infos[0];
+  const Texture::LevelInfo& first_level = first_face.level_infos[base_level_];
   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);
 
   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;
   }
 
   if (cube_complete_ && texture_level0_dirty_) {
     texture_level0_complete_ = true;
     for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
-      const Texture::LevelInfo& level0 = face_infos_[ii].level_infos[0];
+      const Texture::LevelInfo& face_base_level =
+          face_infos_[ii].level_infos[base_level_];
       if (!TextureFaceComplete(first_level,
                                ii,
-                               level0.target,
-                               level0.internal_format,
-                               level0.width,
-                               level0.height,
-                               level0.depth,
-                               level0.format,
-                               level0.type)) {
+                               face_base_level.target,
+                               face_base_level.internal_format,
+                               face_base_level.width,
+                               face_base_level.height,
+                               face_base_level.depth,
+                               face_base_level.format,
+                               face_base_level.type)) {
         texture_level0_complete_ = false;
         break;
       }
     }
     texture_level0_dirty_ = false;
   }
   cube_complete_ &= texture_level0_complete_;
 
   if (texture_complete_ && texture_mips_dirty_) {
     texture_mips_complete_ = true;
     for (size_t ii = 0;
          ii < face_infos_.size() && texture_mips_complete_;
          ++ii) {
       const Texture::FaceInfo& face_info = face_infos_[ii];
-      const Texture::LevelInfo& level0 = face_info.level_infos[0];
+      const Texture::LevelInfo& base_level_info =
+          face_info.level_infos[base_level_];
       for (GLsizei jj = 1; jj < levels_needed; ++jj) {
-        const Texture::LevelInfo& level_info = face_infos_[ii].level_infos[jj];
-        if (!TextureMipComplete(level0,
+        const Texture::LevelInfo& level_info =
+            face_infos_[ii].level_infos[base_level_ + jj];
+        if (!TextureMipComplete(base_level_info,
                                 level_info.target,
-                                jj,
+                                jj,  // level - base_level_
                                 level_info.internal_format,
                                 level_info.width,
                                 level_info.height,
                                 level_info.depth,
                                 level_info.format,
                                 level_info.type)) {
           texture_mips_complete_ = false;
           break;
         }
       }
     }
     texture_mips_dirty_ = false;
   }
   texture_complete_ &= texture_mips_complete_;
 }
 
 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
   if (cleared_) {
     return true;
   }
 
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
-    for (GLint jj = 0; jj < face_info.num_mip_levels; ++jj) {
+    for (GLint jj = base_level_;
+         jj < base_level_ + face_info.num_mip_levels; ++jj) {
       const Texture::LevelInfo& info = face_info.level_infos[jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
   }
   UpdateSafeToRenderFrom(true);
   return true;
 }
 
 gfx::Rect Texture::GetLevelClearedRect(GLenum target, GLint level) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return gfx::Rect();
   }
 
   const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
 
   return info.cleared_rect;
 }
 
 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
+      level < base_level_ ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
 
   const Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
 
   return info.cleared_rect == gfx::Rect(info.width, info.height);
 }
 
 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
   if (texture_max_anisotropy_initialized_)
     return;
   texture_max_anisotropy_initialized_ = true;
   GLfloat params[] = { 1.0f };
   glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
 }
 
 bool Texture::ClearLevel(
     GLES2Decoder* decoder, GLenum target, GLint level) {
   DCHECK(decoder);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   if (face_index >= face_infos_.size() ||
+      level < base_level_ ||
       level >= static_cast<GLint>(face_infos_[face_index].level_infos.size())) {
     return true;
   }
 
   Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
 
   DCHECK(target == info.target);
 
   if (info.target == 0 ||
       info.cleared_rect == gfx::Rect(info.width, info.height) ||
@@ skipping 962 matching lines @@
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
 
   // Dump all sub-levels held by the texture. They will appear below the main
   // gl/textures/client_X/texture_Y dump.
   ref->texture()->DumpLevelMemory(pmd, memory_tracker_->ClientTracingId(),
                                   dump_name);
 }
 
 }  // namespace gles2
 }  // namespace gpu