Workaround for Intel 6xxx clear to 0/1 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 1443 matching lines @@
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear*()
   error::Error DoClear(GLbitfield mask);
+  void DoClearColor(GLclampf red,
+                    GLclampf green,
+                    GLclampf blue,
+                    GLclampf alpha);
   void DoClearBufferiv(GLenum buffer,
                        GLint drawbuffer,
                        const volatile GLint* value);
   void DoClearBufferuiv(GLenum buffer,
                         GLint drawbuffer,
                         const volatile GLuint* value);
   void DoClearBufferfv(GLenum buffer,
                        GLint drawbuffer,
                        const volatile GLfloat* value);
   void DoClearBufferfi(
@@ skipping 1127 matching lines @@
       decoder_->should_use_native_gmb_for_backbuffer_ &&
       !decoder_->offscreen_buffer_should_have_alpha_ &&
       decoder_->ChromiumImageNeedsRGBEmulation() &&
       decoder_->workarounds()
           .disable_multisampling_color_mask_usage;
   if (alpha_channel_needs_clear) {
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT,
                          decoder_->offscreen_target_frame_buffer_->id());
     decoder_->state_.SetDeviceColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
     decoder->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
-    glClearColor(0, 0, 0, 1);
+    decoder_->DoClearColor(0, 0, 0, 1);
     glClear(GL_COLOR_BUFFER_BIT);
     decoder_->RestoreClearState();
   }
 
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,
                        decoder_->offscreen_target_frame_buffer_->id());
   GLuint targetid;
   if (internal) {
     if (!decoder_->offscreen_resolved_frame_buffer_.get()) {
       decoder_->offscreen_resolved_frame_buffer_.reset(
@@ skipping 231 matching lines @@
   bool needs_clear_for_rgb_emulation =
       !decoder_->offscreen_buffer_should_have_alpha_ &&
       decoder_->ChromiumImageNeedsRGBEmulation();
   if (zero || needs_clear_for_rgb_emulation) {
     GLuint fbo;
     glGenFramebuffersEXT(1, &fbo);
     {
       ScopedFramebufferBinder binder(decoder_, fbo);
       glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, Target(),
                                 id(), 0);
-      glClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
+      decoder_->DoClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
       decoder_->state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
       glClear(GL_COLOR_BUFFER_BIT);
       decoder_->RestoreClearState();
     }
     glDeleteFramebuffersEXT(1, &fbo);
   }
   return true;
 }
 
@@ skipping 72 matching lines @@
   bool alpha_channel_needs_clear =
       (format == GL_RGBA || format == GL_RGBA8) &&
       !decoder_->offscreen_buffer_should_have_alpha_;
   if (alpha_channel_needs_clear) {
     GLuint fbo;
     glGenFramebuffersEXT(1, &fbo);
     {
       ScopedFramebufferBinder binder(decoder_, fbo);
       glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                    GL_RENDERBUFFER, id_);
-      glClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
+      decoder_->DoClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
       decoder_->state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
       glClear(GL_COLOR_BUFFER_BIT);
       decoder_->RestoreClearState();
     }
     glDeleteFramebuffersEXT(1, &fbo);
   }
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
@@ skipping 629 matching lines @@
   // because the system already clears the buffer before each draw. Proper
   // fix might be setting the scissor clip properly before initialize. See
   // crbug.com/259023 for details.
   call_gl_clear = surface_->GetHandle();
 #endif
   if (call_gl_clear) {
     // On configs where we report no alpha, if the underlying surface has
     // alpha, clear the surface alpha to 1.0 to be correct on ReadPixels/etc.
     bool clear_alpha = back_buffer_color_format_ == GL_RGB && alpha_bits > 0;
     if (clear_alpha) {
-      glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+      DoClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     }
 
     // Clear the backbuffer.
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
     // Restore alpha clear value if we changed it.
     if (clear_alpha) {
-      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+      DoClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     }
   }
 
   supports_post_sub_buffer_ = surface->SupportsPostSubBuffer();
   if (workarounds()
           .disable_post_sub_buffers_for_onscreen_surfaces &&
       !surface->IsOffscreen())
     supports_post_sub_buffer_ = false;
 
   supports_swap_buffers_with_bounds_ = surface->SupportsSwapBuffersWithBounds();
@@ skipping 728 matching lines @@
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     Framebuffer* framebuffer,
     GLenum target,
     GLenum gl_error,
     const char* func_name) {
   if (!framebuffer) {
     if (surfaceless_)
       return false;
     if (backbuffer_needs_clear_bits_) {
-      glClearColor(0, 0, 0, BackBufferAlphaClearColor());
+      DoClearColor(0, 0, 0, BackBufferAlphaClearColor());
       state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glClearStencil(0);
       state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
       state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
       glClearDepth(1.0f);
       state_.SetDeviceDepthMask(GL_TRUE);
       state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
       bool reset_draw_buffer = false;
       if ((backbuffer_needs_clear_bits_ & GL_COLOR_BUFFER_BIT) != 0 &&
           back_buffer_draw_buffer_ == GL_NONE) {
@@ skipping 727 matching lines @@
   if (offscreen_target_frame_buffer_->CheckStatus() !=
       GL_FRAMEBUFFER_COMPLETE) {
       LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                  << "because offscreen FBO was incomplete.";
     return false;
   }
 
   // Clear the target frame buffer.
   {
     ScopedFramebufferBinder binder(this, offscreen_target_frame_buffer_->id());
-    glClearColor(0, 0, 0, BackBufferAlphaClearColor());
+    DoClearColor(0, 0, 0, BackBufferAlphaClearColor());
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glClearStencil(0);
     state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
     state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
     glClearDepth(0);
     state_.SetDeviceDepthMask(GL_TRUE);
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     RestoreClearState();
   }
@@ skipping 2250 matching lines @@
             "can't be called on integer buffers");
         return error::kNoError;
       }
     }
     AdjustDrawBuffers();
     glClear(mask);
   }
   return error::kNoError;
 }
 
+void GLES2DecoderImpl::DoClearColor(GLclampf red,
+                                    GLclampf green,
+                                    GLclampf blue,
+                                    GLclampf alpha) {
+  if (workarounds().clear_to_boundary_values_is_broken &&
+      (1 == red || 0 == red) && (1 == green || 0 == green) &&
+      (1 == blue || 0 == blue) && (1 == alpha || 0 == alpha)) {
+    if (1 == alpha)
+      alpha = 2;
+    else
+      alpha = -1;
+  }
+  glClearColor(red, green, blue, alpha);
+}
+
 void GLES2DecoderImpl::DoClearBufferiv(GLenum buffer,
                                        GLint drawbuffer,
                                        const volatile GLint* value) {
   const char* func_name = "glClearBufferiv";
   if (!CheckBoundDrawFramebufferValid(func_name))
     return;
   ApplyDirtyState();
 
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
@@ skipping 218 matching lines @@
 
     cleared_int_renderbuffers = true;
   }
 
   GLbitfield clear_bits = 0;
   bool reset_draw_buffers = false;
   if (framebuffer->HasUnclearedColorAttachments()) {
     // We should always use alpha == 0 here, because 1) some draw buffers may
     // have alpha and some may not; 2) we won't have the same situation as the
     // back buffer where alpha channel exists but is not requested.
-    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    DoClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     clear_bits |= GL_COLOR_BUFFER_BIT;
 
     if (SupportsDrawBuffers()) {
       reset_draw_buffers =
           framebuffer->PrepareDrawBuffersForClearingUninitializedAttachments();
     }
   }
 
   if (framebuffer->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT)) {
@@ skipping 34 matching lines @@
       glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, service_id);
     }
   }
 
   framebuffer_manager()->MarkAttachmentsAsCleared(
       framebuffer, renderbuffer_manager(), texture_manager());
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
   framebuffer_state_.clear_state_dirty = true;
-  glClearColor(
-      state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
-      state_.color_clear_alpha);
+  DoClearColor(state_.color_clear_red, state_.color_clear_green,
+               state_.color_clear_blue, state_.color_clear_alpha);
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
   gfx::Vector2d scissor_offset = GetBoundFramebufferDrawOffset();
   glScissor(state_.scissor_x + scissor_offset.x(),
             state_.scissor_y + scissor_offset.y(), state_.scissor_width,
             state_.scissor_height);
 }
 
@@ skipping 938 matching lines @@
   glGetBooleanv(GL_SCISSOR_TEST, &scissor_enabled);
   if (scissor_enabled)
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
 
   GLboolean color_mask[4] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE};
   glGetBooleanv(GL_COLOR_WRITEMASK, color_mask);
   state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
   GLfloat clear_color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
   glGetFloatv(GL_COLOR_CLEAR_VALUE, clear_color);
-  glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
+  DoClearColor(1.0f, 0.0f, 1.0f, 1.0f);
 
   // Clear the buffer to the desired key color.
   glClear(GL_COLOR_BUFFER_BIT);
 
   // Blit from the multisample buffer to a standard texture.
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER, validation_fbo_multisample_);
   glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, validation_fbo_);
 
   BlitFramebufferHelper(
       0, 0, 1, 1, 0, 0, 1, 1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
   // Read a pixel from the buffer.
   glBindFramebufferEXT(GL_FRAMEBUFFER, validation_fbo_);
 
   unsigned char pixel[3] = {0, 0, 0};
   glReadPixels(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &pixel);
 
   // Detach the renderbuffer.
   glBindFramebufferEXT(GL_FRAMEBUFFER, validation_fbo_multisample_);
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
       GL_RENDERBUFFER, 0);
 
   // Restore cached state.
   if (scissor_enabled)
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
 
   state_.SetDeviceColorMask(
       color_mask[0], color_mask[1], color_mask[2], color_mask[3]);
-  glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
+  DoClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
   glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, draw_framebuffer);
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER, read_framebuffer);
 
   // Return true if the pixel matched the desired key color.
   return (pixel[0] == 0xFF &&
       pixel[1] == 0x00 &&
       pixel[2] == 0xFF);
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorage(
@@ skipping 6882 matching lines @@
           MarkContextLost(error::kUnknown);
           group_->LoseContexts(error::kUnknown);
           return;
         }
 
         // Clear the offscreen color texture.
         // TODO(piman): Is this still necessary?
         {
           ScopedFramebufferBinder binder(this,
                                          offscreen_saved_frame_buffer_->id());
-          glClearColor(0, 0, 0, BackBufferAlphaClearColor());
+          DoClearColor(0, 0, 0, BackBufferAlphaClearColor());
           state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
           state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
           glClear(GL_COLOR_BUFFER_BIT);
           RestoreClearState();
         }
       }
     }
 
     if (offscreen_size_.width() == 0 || offscreen_size_.height() == 0)
       return;
@@ skipping 4137 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