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 306 matching lines @@
                                            bool enforce_internal_framebuffer,
                                            bool internal);
   ~ScopedResolvedFramebufferBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
   bool resolve_and_bind_;
   DISALLOW_COPY_AND_ASSIGN(ScopedResolvedFramebufferBinder);
 };
 
+// Reset the base level of the texture currently bound to the
+// texture target and restore it after calling texImage2D.
+class ScopedTextureBaseLevelResetter {
+ public:
+  explicit ScopedTextureBaseLevelResetter(GLenum target,

[Zhenyao Mo, 2017/06/09 21:28:06]

nit: no need for explicit because you have three args not one.

+                                          GLint base_level,
+                                          bool reset_base_level)
+      : target_(target),
+        base_level_(base_level),
+        reset_base_level_(reset_base_level) {
+    DCHECK(target_ == GL_TEXTURE_2D);
+    if (reset_base_level_) {

[Zhenyao Mo, 2017/06/09 21:28:06]

&& base_level

+      glTexParameteri(target_, GL_TEXTURE_BASE_LEVEL, 0);
+    }
+  }
+
+  ~ScopedTextureBaseLevelResetter() {
+    if (reset_base_level_) {

[Zhenyao Mo, 2017/06/09 21:28:06]

&& base_level

+      glTexParameteri(target_, GL_TEXTURE_BASE_LEVEL, base_level_);
+    }
+  }
+
+ private:
+  GLenum target_;
+  GLint base_level_;
+  bool reset_base_level_;
+  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 306 matching lines @@
                              GLint srcY0,
                              GLint srcX1,
                              GLint srcY1,
                              GLint dstX0,
                              GLint dstY0,
                              GLint dstX1,
                              GLint dstY1,
                              GLbitfield mask,
                              GLenum filter);
 
+  void TexImage2DHelper(GLenum target,
+                        GLint level,
+                        GLenum internal_format,
+                        GLsizei width,
+                        GLsizei height,
+                        GLint border,
+                        GLenum format,
+                        GLenum type,
+                        const void* pixels,
+                        GLint base_level,
+                        bool reset_base_level);
+
   PathManager* path_manager() { return group_->path_manager(); }
 
  private:
   friend class ScopedFramebufferBinder;
   friend class ScopedResolvedFramebufferBinder;
+  friend class ScopedTextureBaseLevelResetter;

[Zhenyao Mo, 2017/06/09 21:28:06]

Why this needs to be a friend?

   friend class BackFramebuffer;
   friend class BackRenderbuffer;
   friend class BackTexture;
 
   enum FramebufferOperation {
     kFramebufferDiscard,
     kFramebufferInvalidate,
     kFramebufferInvalidateSub
   };
 
@@ skipping 5569 matching lines @@
   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)) {
       format = TextureManager::ExtractFormatFromStorageFormat(internal_format);
-      glTexImage2D(target, 0, internal_format, 1, 1, 0, format, type, nullptr);
+      TexImage2DHelper(target, 0, internal_format, 1, 1, 0, format, type,
+                       nullptr, base_level,
+                       workarounds().reset_teximage2d_base_level);
       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(
                       internal_format) == GL_SRGB;
   }
@@ skipping 13 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.
-    glTexImage2D(target, 0, internal_format, 0, 0, 0, format, type, nullptr);
+    TexImage2DHelper(target, 0, internal_format, 0, 0, 0, format, type, nullptr,
+                     base_level, workarounds().reset_teximage2d_base_level);
   }
 
   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 2116 matching lines @@
   } else if (feature_info_->feature_flags().angle_framebuffer_multisample) {
     // This is ES2 only.
     glBlitFramebufferANGLE(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   } else {
     glBlitFramebufferEXT(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   }
 }
 
+void GLES2DecoderImpl::TexImage2DHelper(GLenum target,
+                                        GLint level,
+                                        GLenum internal_format,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLint border,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void* pixels,
+                                        GLint base_level,
+                                        bool reset_base_level) {
+  ScopedTextureBaseLevelResetter baseLevelResetter(target, base_level,
+                                                   reset_base_level);
+  glTexImage2D(target, level, internal_format, width, height, 0, format, type,
+               pixels);
+}
+
 bool GLES2DecoderImpl::ValidateRenderbufferStorageMultisample(
     GLsizei samples,
     GLenum internalformat,
     GLsizei width,
     GLsizei height) {
   if (samples > renderbuffer_manager()->max_samples()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glRenderbufferStorageMultisample", "samples too large");
     return false;
@@ skipping 5329 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) {
-      glTexImage2D(target, level, format_info->decompressed_internal_format,
-                   width, height, border, format_info->decompressed_format,
-                   format_info->decompressed_type, decompressed_data.get());
+      TexImage2DHelper(target, level, format_info->decompressed_internal_format,
+                       width, height, border, format_info->decompressed_format,
+                       format_info->decompressed_type, decompressed_data.get(),
+                       texture->base_level(),
+                       workarounds().reset_teximage2d_base_level);
     } 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();
   } else {
     if (dimension == ContextState::k2D) {
       glCompressedTexImage2D(target, level, internal_format, width, height,
@@ skipping 618 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);
-      glTexImage2D(target, level, final_internal_format, width, height, border,
-                   format, type, zero.get());
+      TexImage2DHelper(target, level, final_internal_format, width, height,
+                       border, format, type, zero.get(), texture->base_level(),
+                       workarounds().reset_teximage2d_base_level);
     }
 
     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,
             type, level, destX, destY, 0,
             src.x(), src.y(), src.width(), src.height(),
@@ skipping 2426 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());
-    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);
+    TexImage2DHelper(
+        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, dest_texture->base_level(),
+        workarounds().reset_teximage2d_base_level);
     GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
     if (error != GL_NO_ERROR) {
       RestoreCurrentTextureBindings(&state_, dest_binding_target,
                                     state_.active_texture_unit);
       return;
     }
 
     texture_manager()->SetLevelInfo(dest_texture_ref, dest_target, dest_level,
                                     internal_format, source_width,
                                     source_height, 1, 0, format, dest_type,
@@ skipping 423 matching lines @@
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
   DoBindOrCopyTexImageIfNeeded(source_texture, source_texture->target(), 0);
 
   // 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);
+  TexImage2DHelper(dest_texture->target(), 0, GL_RGBA, source_width,
+                   source_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr,
+                   dest_texture->base_level(),
+                   workarounds().reset_teximage2d_base_level);
   GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
   if (error != GL_NO_ERROR) {
     RestoreCurrentTextureBindings(&state_, dest_texture->target(),
                                   state_.active_texture_unit);
     return;
   }
 
   texture_manager()->SetLevelInfo(
       dest_texture_ref, dest_texture->target(), 0, GL_RGBA, source_width,
       source_height, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
@@ skipping 2365 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