Tile Compression

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 611 matching lines @@
   info.border = border;
   info.format = format;
   info.type = type;
   info.image = 0;
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
+  UpdateLevelInfo(info, feature_info, level, cleared);
+}
+
+void Texture::SetCompressedLevelInfo(const FeatureInfo* feature_info,
+                                     GLenum target,
+                                     GLint level,
+                                     GLenum internal_format,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLsizei depth,
+                                     GLint border,
+                                     GLsizei image_size,
+                                     bool cleared) {
+  size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
+  DCHECK_GE(level, 0);
+  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);
+  DCHECK_EQ(border, 0);
+  Texture::LevelInfo& info = face_infos_[face_index].level_infos[level];
+  info.target = target;
+  info.level = level;
+  info.internal_format = internal_format;
+  info.width = width;
+  info.height = height;
+  info.depth = depth;
+  info.border = border;
+  // TODO(peterp): Compressed formats only have the internal format and no type,
+  // but we could potentially have a lookup table to figure that out.
+  // In practice it seems to work ok to always treat compressed formats as
+  // RGBA + UNSIGNED_BYTE through.
+  info.format = GL_RGBA;
+  info.type = GL_UNSIGNED_BYTE;
+  info.image = 0;
+
+  estimated_size_ -= info.estimated_size;
+  info.estimated_size = image_size;
+  estimated_size_ += info.estimated_size;
+
+  UpdateLevelInfo(info, feature_info, level, cleared);
+}
+
+void Texture::UpdateLevelInfo(Texture::LevelInfo& info,
+                              const FeatureInfo* feature_info,
+                              GLint level,
+                              bool cleared) {
   UpdateMipCleared(&info, cleared);
   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.
     IncAllFramebufferStateChangeCount();
@@ skipping 595 matching lines @@
                         width,
                         height,
                         depth,
                         border,
                         format,
                         type,
                         cleared);
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
 }
 
+void TextureManager::SetCompressedLevelInfo(TextureRef* ref,
+                                            GLenum target,
+                                            GLint level,
+                                            GLenum internal_format,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLint border,
+                                            GLsizei image_size,
+                                            bool cleared) {
+  DCHECK(ref);
+  Texture* texture = ref->texture();
+
+  texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
+  texture->SetCompressedLevelInfo(feature_info_.get(), target, level,
+                                  internal_format, width, height, depth, border,
+                                  image_size, cleared);
+  texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
+}
+
 Texture* TextureManager::Produce(TextureRef* ref) {
   DCHECK(ref);
   return ref->texture();
 }
 
 TextureRef* TextureManager::Consume(
     GLuint client_id,
     Texture* texture) {
   DCHECK(client_id);
   scoped_refptr<TextureRef> ref(new TextureRef(this, client_id, texture));
@@ skipping 449 matching lines @@
   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glTexImage2D");
   if (error == GL_NO_ERROR) {
     SetLevelInfo(
         texture_ref,
         args.target, args.level, args.internal_format, args.width, args.height,
         1, args.border, args.format, args.type, args.pixels != NULL);
     texture_state->tex_image_2d_failed = false;
   }
 }
 
+bool TextureManager::ValidateCompressedTexImage2D(
+    ContextState* state,
+    const char* function_name,
+    const DoCompressedTexImage2DArguments& args,
+    TextureRef** texture_ref) {
+  ErrorState* error_state = state->GetErrorState();
+  const Validators* validators = feature_info_->validators();
+  if (!validators->texture_target.IsValid(args.target)) {
+    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(error_state, function_name,
+                                         args.target, "target");
+    return false;
+  }
+  if (!validators->compressed_texture_format.IsValid(args.internal_format)) {
+    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
+        error_state, function_name, args.internal_format, "internal_format");
+    return false;
+  }
+  if (!ValidForTarget(args.target, args.level, args.width, args.height, 1) ||
+      args.border != 0) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
+                            "dimensions out of range");
+    return false;
+  }
+
+  if (!GLES2Util::IsValidCompressedImageSize(
+          args.level, args.width, args.height, args.internal_format)) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
+                            "width or height invalid for level");
+    return false;
+  }
+  int bytes_required = 0;
+  if (!GLES2Util::ComputeCompressedImageSize(
+          args.width, args.height, args.internal_format, &bytes_required) ||
+      args.image_size != static_cast<GLsizei>(bytes_required)) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_VALUE, function_name,
+                            "size is not correct for dimension");
+    return false;
+  }
+
+  TextureRef* local_texture_ref = GetTextureInfoForTarget(state, args.target);
+  if (!local_texture_ref) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
+                            "unknown texture for target");
+    return false;
+  }
+  if (local_texture_ref->texture()->IsImmutable()) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_INVALID_OPERATION, function_name,
+                            "texture is immutable");
+    return false;
+  }
+
+  // TODO - verify that using the managed vs unmanaged does not matter.
+  // They both use the same MemoryTracker, and this call just re-routes
+  // to it.
+  if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(args.image_size)) {
+    ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, "glTexImage2D",
+                            "out of memory");
+    return false;
+  }
+
+  // Write the TextureReference since this is valid.
+  *texture_ref = local_texture_ref;
+  return true;
+}
+
 ScopedTextureUploadTimer::ScopedTextureUploadTimer(
     DecoderTextureState* texture_state)
     : texture_state_(texture_state),
       begin_time_(base::TimeTicks::HighResNow()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu