Support base level in texture manager

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 413 matching lines @@
 
 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
   if (target_ == 0)
     return CAN_RENDER_ALWAYS;
 
   if (target_ != GL_TEXTURE_EXTERNAL_OES) {
     if (face_infos_.empty()) {
       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 29 matching lines @@
   return feature_info->feature_flags().npot_ok;
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
-  DCHECK_GE(level, 0);
+  DCHECK_GE(level, base_level_);
   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,
@@ skipping 32 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_ + face_info.num_mip_levels;
+         ++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 107 matching lines @@
                  internal_format == level0_face.internal_format &&
                  format == level0_face.format &&
                  type == level0_face.type);
   }
   return complete;
 }
 
 void Texture::SetLevelClearedRect(GLenum target,
                                   GLint level,
                                   const gfx::Rect& cleared_rect) {
-  DCHECK_GE(level, 0);
+  DCHECK_GE(level, base_level_);
   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());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   UpdateMipCleared(&info, info.width, info.height, cleared_rect);
   UpdateCleared();
 }
 
 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
-  DCHECK_GE(level, 0);
+  DCHECK_GE(level, base_level_);
   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());
   Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
   UpdateMipCleared(&info, info.width, info.height,
                    cleared ? gfx::Rect(info.width, info.height) : gfx::Rect());
   UpdateCleared();
 }
 
@@ skipping 81 matching lines @@
                            GLenum target,
                            GLint level,
                            GLenum internal_format,
                            GLsizei width,
                            GLsizei height,
                            GLsizei depth,
                            GLint border,
                            GLenum format,
                            GLenum type,
                            const gfx::Rect& cleared_rect) {
-  DCHECK_GE(level, 0);
+  DCHECK_GE(level, base_level_);
   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());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
 
   // 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);
 
       // 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;
 
@@ skipping 36 matching lines @@
 bool Texture::ValidForTexture(
     GLint target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth) const {
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
-  if (level >= 0 && face_index < face_infos_.size() &&
+  if (level >= base_level_ && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     int32 max_x;
     int32 max_y;
     int32 max_z;
     return SafeAddInt32(xoffset, width, &max_x) &&
            SafeAddInt32(yoffset, height, &max_y) &&
            SafeAddInt32(zoffset, depth, &max_z) &&
            xoffset >= 0 &&
            yoffset >= 0 &&
            zoffset >= 0 &&
            max_x <= info.width &&
            max_y <= info.height &&
            max_z <= info.depth;
   }
   return false;
 }
 
 bool Texture::GetLevelSize(
     GLint target, GLint level,
     GLsizei* width, GLsizei* height, GLsizei* depth) const {
   DCHECK(width);
   DCHECK(height);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
-  if (level >= 0 && face_index < face_infos_.size() &&
+  if (level >= base_level_ && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     if (info.target != 0) {
       *width = info.width;
       *height = info.height;
       if (depth)
         *depth = info.depth;
       return true;
     }
   }
   return false;
 }
 
 bool Texture::GetLevelType(
     GLint target, GLint level, GLenum* type, GLenum* internal_format) const {
   DCHECK(type);
   DCHECK(internal_format);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
-  if (level >= 0 && face_index < face_infos_.size() &&
+  if (level >= base_level_ && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     if (info.target != 0) {
       *type = info.type;
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
@@ skipping 144 matching lines @@
   npot_ = (target_ == GL_TEXTURE_EXTERNAL_OES) || (num_npot_faces_ > 0);
 
   if (face_infos_.empty()) {
     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& level0 =
+          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)) {
         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];
-      for (GLsizei jj = 1; jj < levels_needed; ++jj) {
+      const Texture::LevelInfo& level0 = face_info.level_infos[base_level_];
+      for (GLsizei jj = base_level_ + 1;
+           jj < base_level_ + levels_needed;
+           ++jj) {
         const Texture::LevelInfo& level_info = face_infos_[ii].level_infos[jj];
         if (!TextureMipComplete(level0,
                                 level_info.target,
-                                jj,
+                                jj - 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;
@@ skipping 80 matching lines @@
   UpdateMipCleared(&info, info.width, info.height,
                    gfx::Rect(info.width, info.height));
   return true;
 }
 
 void Texture::SetLevelImage(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
-  DCHECK_GE(level, 0);
+  DCHECK_GE(level, base_level_);
   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());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
   UpdateCanRenderCondition();
   UpdateHasImages();
 
   // TODO(ericrk): Images may have complex sizing not accounted for by
   // |estimated_size_|, we should add logic here to update |estimated_size_|
   // based on the new GLImage. crbug.com/526298
 }
 
 gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
-  if (level >= 0 && face_index < face_infos_.size() &&
+  if (level >= base_level_ && face_index < face_infos_.size() &&
       static_cast<size_t>(level) < face_infos_[face_index].level_infos.size()) {
     const LevelInfo& info = face_infos_[face_index].level_infos[level];
     if (info.target != 0) {
       return info.image.get();
     }
   }
   return NULL;
 }
 
 void Texture::OnWillModifyPixels() {
@@ skipping 906 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