Optimized Texture::Update() function.

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 <utility>
 
 #include "base/bits.h"
@@ skipping 110 matching lines @@
   DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
   DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
 }
 
 Texture::Texture(GLuint service_id)
     : mailbox_manager_(NULL),
       memory_tracking_ref_(NULL),
       service_id_(service_id),
       cleared_(true),
       num_uncleared_mips_(0),
+      num_npot_faces_(0),
+      num_complete_faces_(0),
+      num_incomplete_mips_(0),
       target_(0),
       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
       mag_filter_(GL_LINEAR),
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
@@ skipping 181 matching lines @@
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const Texture::LevelInfo& info1 = level_infos_[ii][0];
     GLsizei width = info1.width;
     GLsizei height = info1.height;
     GLsizei depth = info1.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                GLES2Util::IndexToGLFaceTarget(ii);
-    int num_mips =
-        TextureManager::ComputeMipMapCount(target_, width, height, depth);
+
+    const int num_mips = num_mip_levels_[ii];
     for (int level = 1; 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,
                    info1.internal_format,
                    width,
                    height,
@@ skipping 10 matching lines @@
 
 void Texture::SetTarget(
     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;
   level_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     level_infos_[ii].resize(max_levels);
   }
+  num_mip_levels_.resize(num_faces);
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     immutable_ = true;
   }
   Update(feature_info);
@@ skipping 26 matching lines @@
         (info.type != first.type) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
         info.image.get()) {
       return false;
     }
   }
   return true;
 }
 
+bool Texture::TextureIsNPOT(GLsizei width,
+                            GLsizei height,
+                            GLsizei depth) {
+  return (GLES2Util::IsNPOT(width) ||
+          GLES2Util::IsNPOT(height) ||
+          GLES2Util::IsNPOT(depth));
+}
+
+bool Texture::TextureFaceComplete(const Texture::LevelInfo& first_face,
+                                  size_t face_index,
+                                  GLenum target,
+                                  GLenum internal_format,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth,
+                                  GLenum format,
+                                  GLenum type) {
+  bool complete = (target != 0 && depth == 1);
+  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,
+                                 GLenum target,
+                                 GLint level,
+                                 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);

[vmiura, 2014/10/07 00:13:03]

Do we need to handle the case of width/height/depth == 0?

[David Yen, 2014/10/09 20:20:16]

That check is already done before this function is called, but technically it
would be more correct if we checked in here I suppose... although that would add
an extra branch.

Another way to look at it is that we are assuming level0_face is a proper face
at least.

+
+    complete &= (width == mip_width &&
+                 height == mip_height &&
+                 depth == mip_depth &&
+                 internal_format == level0_face.internal_format &&
+                 format == level0_face.format &&
+                 type == level0_face.type);
+  }
+  return complete;
+}
+
 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[face_index].size());
   Texture::LevelInfo& info =
       level_infos_[face_index][level];
   UpdateMipCleared(&info, cleared);
@@ skipping 89 matching lines @@
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
             level_infos_[face_index].size());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
   DCHECK_GE(depth, 0);
   Texture::LevelInfo& info =
       level_infos_[face_index][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) {
+      // Calculate the mip level count.
+      num_mip_levels_[face_index] = 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;
+
+      // Update number of complete faces.
+      const Texture::LevelInfo& first_face = level_infos_[0][0];
+      for (size_t i = face_index; i < level_infos_.size(); ++i) {

[vmiura, 2014/10/07 00:13:03]

I think this compares face 0 to itself, so I think we could skip most of that.

Initially I guess a face is incomplete, so I wonder if this code will count
faces that are initialized to invalid values correctly, i.e when
prev_face_status == new_face_status == false.

[David Yen, 2014/10/09 20:20:16]

No longer relevant, using dirty bit now.

+        bool prev_face_status = TextureFaceComplete(first_face,
+                                             face_index,
+                                             info.target,
+                                             info.internal_format,
+                                             info.width,
+                                             info.height,
+                                             info.depth,
+                                             info.format,
+                                             info.type);
+        bool new_face_status = TextureFaceComplete(first_face,
+                                            face_index,
+                                            target,
+                                            internal_format,
+                                            width,
+                                            height,
+                                            depth,
+                                            format,
+                                            type);
+        if (prev_face_status != new_face_status)
+          num_complete_faces_ += new_face_status ? 1 : -1;
+
+        // Only need to validate all faces if the first face is changing.
+        if (face_index != 0)
+          break;
+      }
+    }
+
+    // Update incomplete mip counter.
+    const Texture::LevelInfo& level0_face = level_infos_[face_index][0];
+    const GLsizei num_mip_levels = num_mip_levels_[face_index];

[vmiura, 2014/10/07 00:13:03]

If num_mip_levels changes, for example decreasing, I'm not sure we're correctly
updating num_incomplete_mips_.

[David Yen, 2014/10/09 20:20:16]

No longer relevant, using dirty bit now.

+    for (GLsizei i = static_cast<GLsizei>(level); i < num_mip_levels; ++i) {
+      bool prev_mip_status = TextureMipComplete(level0_face,
+                                                info.target,
+                                                i,
+                                                info.internal_format,
+                                                info.width,
+                                                info.height,
+                                                info.depth,
+                                                info.format,
+                                                info.type);
+      bool new_mip_status = TextureMipComplete(level0_face,
+                                               target,
+                                               i,
+                                               internal_format,
+                                               width,
+                                               height,
+                                               depth,
+                                               format,
+                                               type);
+      if (prev_mip_status != new_mip_status)
+        num_incomplete_mips_ += new_mip_status ? -1 : 1;

[vmiura, 2014/10/07 00:13:03]

As above, I'm not sure we will count correctly when initial state is incomplete,
and new state is incomplete.

[David Yen, 2014/10/09 20:20:16]

No longer relevant, using dirty bit now.

+
+      // Only need to validate all faces if the first face is changing.
+      if (face_index != 0)
+        break;
+    }
+  }
+
   info.target = target;
   info.level = level;
   info.internal_format = internal_format;
   info.width = width;
   info.height = height;
   info.depth = depth;
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
@@ skipping 164 matching lines @@
     default:
       NOTREACHED();
       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;
+  npot_ = (target_ == GL_TEXTURE_EXTERNAL_OES) || (num_npot_faces_ > 0);
 
   if (level_infos_.empty()) {
     texture_complete_ = false;
     cube_complete_ = false;
     return;
   }
 
-  // checks that the first mip of any face is npot.
-  for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
-    const Texture::LevelInfo& info = level_infos_[ii][0];
-    if (GLES2Util::IsNPOT(info.width) ||
-        GLES2Util::IsNPOT(info.height) ||
-        GLES2Util::IsNPOT(info.depth)) {
-      npot_ = true;
-      break;
-    }
-  }
-
   // Update texture_complete and cube_complete status.
   const Texture::LevelInfo& first_face = level_infos_[0][0];
-  int levels_needed = TextureManager::ComputeMipMapCount(
-      target_, first_face.width, first_face.height, first_face.depth);
+  int levels_needed = num_mip_levels_[0];
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (level_infos_.size() == 6) &&
-                   (first_face.width == first_face.height);
+                   (first_face.width == first_face.height) &&
+                   (num_complete_faces_ == 6);
 
   if (first_face.width == 0 || first_face.height == 0) {
     texture_complete_ = false;
-  }
-  if (first_face.type == GL_FLOAT &&
-      !feature_info->feature_flags().enable_texture_float_linear &&
-      (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
-       mag_filter_ != GL_NEAREST)) {
+  } else if (first_face.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_face.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;
-  }
-  for (size_t ii = 0;
-       ii < level_infos_.size() && (cube_complete_ || texture_complete_);
-       ++ii) {
-    const Texture::LevelInfo& level0 = level_infos_[ii][0];
-    if (level0.target == 0 ||
-        level0.width != first_face.width ||
-        level0.height != first_face.height ||
-        level0.depth != 1 ||
-        level0.internal_format != first_face.internal_format ||
-        level0.format != first_face.format ||
-        level0.type != first_face.type) {
-      cube_complete_ = false;
-    }
-    // Get level0 dimensions
-    GLsizei width = level0.width;
-    GLsizei height = level0.height;
-    GLsizei depth = level0.depth;
-    for (GLint jj = 1; jj < levels_needed; ++jj) {
-      // compute required size for mip.
-      width = std::max(1, width >> 1);
-      height = std::max(1, height >> 1);
-      depth = std::max(1, depth >> 1);
-      const Texture::LevelInfo& info = level_infos_[ii][jj];
-      if (info.target == 0 ||
-          info.width != width ||
-          info.height != height ||
-          info.depth != depth ||
-          info.internal_format != level0.internal_format ||
-          info.format != level0.format ||
-          info.type != level0.type) {
-        texture_complete_ = false;
-        break;
-      }
-    }
+  } else if (num_incomplete_mips_ > 0) {
+    texture_complete_ = false;
   }
 }
 
 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
   if (cleared_) {
     return true;
   }
 
   const Texture::LevelInfo& first_face = level_infos_[0][0];
-  int levels_needed = TextureManager::ComputeMipMapCount(
-      target_, first_face.width, first_face.height, first_face.depth);
+  int levels_needed = num_mip_levels_[0];
 
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
       Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
@@ skipping 811 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu