Reset TexImage2D base level to workaround Intel mac driver bug

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 304 matching lines @@
                                            bool enforce_internal_framebuffer,
                                            bool internal);
   ~ScopedResolvedFramebufferBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
   bool resolve_and_bind_;
   DISALLOW_COPY_AND_ASSIGN(ScopedResolvedFramebufferBinder);
 };
 
+// Reset a texture's base level and restore it after calling
+// texImage2D

[qiankun, 2017/04/26 04:16:20]

Merge line 325 and 326.

[yizhou.jiang, 2017/04/27 04:23:22]

Done.

+class ScopedTextureBaseLevelResetter {
+ public:
+  explicit ScopedTextureBaseLevelResetter(
+      TextureRef* texture_ref,
+      scoped_refptr<gpu::gles2::FeatureInfo> feature_info);
+  ~ScopedTextureBaseLevelResetter();
+
+ private:
+  TextureRef* texture_ref_;
+  scoped_refptr<gpu::gles2::FeatureInfo> feature_info_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedTextureBaseLevelResetter);
+};
+
 // Encapsulates an OpenGL texture.
 class BackTexture {
  public:
   explicit BackTexture(GLES2DecoderImpl* decoder);
   ~BackTexture();
 
   // Create a new render texture.
   void Create();
 
   // Set the initial size and format of a render texture or resize it.
@@ skipping 325 matching lines @@
                              GLint dstX1,
                              GLint dstY1,
                              GLbitfield mask,
                              GLenum filter);
 
   PathManager* path_manager() { return group_->path_manager(); }
 
  private:
   friend class ScopedFramebufferBinder;
   friend class ScopedResolvedFramebufferBinder;
+  friend class ScopedTextureBaseLevelResetter;
   friend class BackFramebuffer;
   friend class BackRenderbuffer;
   friend class BackTexture;
 
   enum FramebufferOperation {
     kFramebufferDiscard,
     kFramebufferInvalidate,
     kFramebufferInvalidateSub
   };
 
@@ skipping 1899 matching lines @@
   glBindFramebufferEXT(GL_FRAMEBUFFER, id);
   decoder->OnFboChanged();
 }
 
 ScopedFramebufferBinder::~ScopedFramebufferBinder() {
   ScopedGLErrorSuppressor suppressor(
       "ScopedFramebufferBinder::dtor", decoder_->GetErrorState());
   decoder_->RestoreCurrentFramebufferBindings();
 }
 
+ScopedTextureBaseLevelResetter::ScopedTextureBaseLevelResetter(
+    TextureRef* texture_ref,
+    scoped_refptr<gpu::gles2::FeatureInfo> feature_info)
+    : texture_ref_(texture_ref), feature_info_(feature_info) {
+  if (texture_ref_ &&

[qiankun, 2017/04/26 04:16:19]

Isn't texture_ref_ always non-null? You can just pass in "GLint base_level" and
"bool reset_base_level" (a flag indicating if do the resetting or not).

[yizhou.jiang, 2017/04/27 04:23:22]

Done.

+      feature_info_->workarounds().reset_teximage2d_base_level) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+  }
+}
+
+ScopedTextureBaseLevelResetter::~ScopedTextureBaseLevelResetter() {
+  if (texture_ref_ &&
+      feature_info_->workarounds().reset_teximage2d_base_level) {
+    Texture* texture = texture_ref_->texture();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL,
+                    texture->base_level());
+  }
+}
+
 ScopedResolvedFramebufferBinder::ScopedResolvedFramebufferBinder(
     GLES2DecoderImpl* decoder, bool enforce_internal_framebuffer, bool internal)
     : decoder_(decoder) {
   resolve_and_bind_ = (
       decoder_->offscreen_target_frame_buffer_.get() &&
       decoder_->IsOffscreenBufferMultisampled() &&
       (!decoder_->framebuffer_state_.bound_read_framebuffer.get() ||
        enforce_internal_framebuffer));
   if (!resolve_and_bind_)
     return;
@@ skipping 3683 matching lines @@
   // chain is properly generated from the base level.
   bool texture_zero_level_set = false;
   GLenum type = 0;
   GLenum internal_format = 0;
   GLenum format = 0;
   if (workarounds().set_zero_level_before_generating_mipmap &&
       target == GL_TEXTURE_2D) {
     if (base_level != 0 &&
         !tex->GetLevelType(target, 0, &type, &internal_format) &&
         tex->GetLevelType(target, tex->base_level(), &type, &internal_format)) {
+      ScopedTextureBaseLevelResetter baseLevelResetter(texture_ref,
+                                                       feature_info_);
       format = TextureManager::ExtractFormatFromStorageFormat(internal_format);
       glTexImage2D(target, 0, internal_format, 1, 1, 0, format, type, nullptr);
       texture_zero_level_set = true;
     }
   }
 
   bool enable_srgb = 0;
   if (target == GL_TEXTURE_2D) {
     tex->GetLevelType(target, tex->base_level(), &type, &internal_format);
     enable_srgb = GLES2Util::GetColorEncodingFromInternalFormat(
@@ skipping 15 matching lines @@
       glGenerateMipmapEXT(target);
     }
   } else {
     glGenerateMipmapEXT(target);
   }
 
   if (texture_zero_level_set) {
     // This may have some unwanted side effects, but we expect command buffer
     // validation to prevent you from doing anything weird with the texture
     // after this, like calling texSubImage2D sucessfully.
+    ScopedTextureBaseLevelResetter baseLevelResetter(texture_ref,
+                                                     feature_info_);
     glTexImage2D(target, 0, internal_format, 0, 0, 0, format, type, nullptr);
   }
 
   if (workarounds().set_texture_filter_before_generating_mipmap) {
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
                     texture_ref->texture()->min_filter());
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glGenerateMipmap");
   if (error == GL_NO_ERROR) {
     texture_manager()->MarkMipmapsGenerated(texture_ref);
@@ skipping 7417 matching lines @@
   if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
     std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
         state_, *format_info, width, height, depth, image_size, data);
     if (!decompressed_data) {
       MarkContextLost(error::kGuilty);
       group_->LoseContexts(error::kInnocent);
       return error::kLostContext;
     }
     state_.PushTextureDecompressionUnpackState();
     if (dimension == ContextState::k2D) {
+      ScopedTextureBaseLevelResetter baseLevelResetter(texture_ref,
+                                                       feature_info_);
       glTexImage2D(target, level, format_info->decompressed_internal_format,
                    width, height, border, format_info->decompressed_format,
                    format_info->decompressed_type, decompressed_data.get());
     } else {
       glTexImage3D(
           target, level, format_info->decompressed_internal_format,
           width, height, depth, border, format_info->decompressed_format,
           format_info->decompressed_type, decompressed_data.get());
     }
     state_.RestoreUnpackState();
@@ skipping 621 matching lines @@
 
   if (src.x() != x || src.y() != y ||
       src.width() != width || src.height() != height) {
     {
       // Add extra scope to destroy zero and the object it owns right
       // after its usage.
       // some part was clipped so clear the rect.
 
       std::unique_ptr<char[]> zero(new char[pixels_size]);
       memset(zero.get(), 0, pixels_size);
+
+      ScopedTextureBaseLevelResetter baseLevelResetter(texture_ref,
+                                                       feature_info_);
       glTexImage2D(target, level, final_internal_format, width, height, border,
                    format, type, zero.get());
     }
 
     if (!src.IsEmpty()) {
       GLint destX = src.x() - x;
       GLint destY = src.y() - y;
       if (requires_luma_blit) {
         copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
             this, texture->service_id(), texture->target(), target, format,
@@ skipping 2456 matching lines @@
   }
 
   // Resize the destination texture to the dimensions of the source texture.
   if (!dest_level_defined || dest_width != source_width ||
       dest_height != source_height ||
       dest_internal_format != internal_format ||
       dest_type_previous != dest_type) {
     // Ensure that the glTexImage2D succeeds.
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
     glBindTexture(dest_binding_target, dest_texture->service_id());
+    ScopedTextureBaseLevelResetter baseLevelResetter(dest_texture_ref,
+                                                     feature_info_);
     glTexImage2D(dest_target, dest_level,
                  TextureManager::AdjustTexInternalFormat(feature_info_.get(),
                                                          internal_format),
                  source_width, source_height, 0,
                  TextureManager::AdjustTexFormat(feature_info_.get(), format),
                  dest_type, nullptr);
     GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
     if (error != GL_NO_ERROR) {
       RestoreCurrentTextureBindings(&state_, dest_binding_target);
       return;
@@ skipping 427 matching lines @@
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
   DoCopyTexImageIfNeeded(source_texture, source_texture->target());
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
-  glTexImage2D(dest_texture->target(), 0, GL_RGBA, source_width, source_height,
-               0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  {
+    ScopedTextureBaseLevelResetter baseLevelResetter(dest_texture_ref,
+                                                     feature_info_);
+    glTexImage2D(dest_texture->target(), 0, GL_RGBA, source_width,
+                 source_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  }
   GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
   if (error != GL_NO_ERROR) {
     RestoreCurrentTextureBindings(&state_, dest_texture->target());
     return;
   }
 
   texture_manager()->SetLevelInfo(
       dest_texture_ref, dest_texture->target(), 0, GL_RGBA, source_width,
       source_height, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       gfx::Rect(source_width, source_height));
@@ skipping 2292 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu