[Command buffer] workaround the framebuffer completeness bug for Intel Mac

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 1413 matching lines @@
   // Wrapper for glBlitFramebufferCHROMIUM.
   void DoBlitFramebufferCHROMIUM(
       GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
       GLbitfield mask, GLenum filter);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
+  // A workaround to adjust read buffer and draw buffers to GL_NONE
+  // if the specified read buffer or draw buffers have no image attached.

[Zhenyao Mo, 2016/11/14 19:42:24]

have missing images.

[yunchao, 2016/11/15 16:21:59]

Done.

+  // Return false if read buffer has no image or all of the draw buffers
+  // have no image. Then we can generate INVALID_OPERATION or return directly
+  // in the callers accordingly.
+  bool AdjustColorBufferAttachmentsIfNecessary(
+    bool read, bool draw);
+
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear*()
   error::Error DoClear(GLbitfield mask);
   void DoClearBufferiv(GLenum buffer,
                        GLint drawbuffer,
                        const volatile GLint* value);
   void DoClearBufferuiv(GLenum buffer,
                         GLint drawbuffer,
@@ skipping 5762 matching lines @@
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glDeleteProgram", "unknown program");
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::DoClear(GLbitfield mask) {
   const char* func_name = "glClear";
   DCHECK(!ShouldDeferDraws());
+  if (mask & GL_COLOR_BUFFER_BIT &&

[Zhenyao Mo, 2016/11/14 19:42:24]

(mask & GL_COLOR_BUFFER_BIT) != 0

[yunchao, 2016/11/15 16:21:59]

Done.

+      workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true))
+      return error::kNoError;
+  }
   if (CheckBoundDrawFramebufferValid(func_name)) {
     ApplyDirtyState();
     if (workarounds().gl_clear_broken) {
       if (!BoundFramebufferHasDepthAttachment())
         mask &= ~GL_DEPTH_BUFFER_BIT;
       if (!BoundFramebufferHasStencilAttachment())
         mask &= ~GL_STENCIL_BUFFER_BIT;
       ClearFramebufferForWorkaround(mask);
       return error::kNoError;
     }
@@ skipping 299 matching lines @@
       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);
   glScissor(state_.scissor_x, state_.scissor_y, state_.scissor_width,
             state_.scissor_height);
 }
 
+bool GLES2DecoderImpl::AdjustColorBufferAttachmentsIfNecessary(
+    bool read, bool draw) {
+  DCHECK(workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty);
+  if (read) {
+    const Framebuffer* framebuffer =
+        GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+    if (framebuffer &&
+        framebuffer->ReadBufferHasNoImage() &&
+        framebuffer->ColorBuffersHaveImage()) {
+      glReadBuffer(GL_NONE);
+      return false;
+    }
+  } else {
+    GLsizei num = 0;
+    GLenum buf[8];
+    for (int i = 0; i < 8; ++i)
+      buf[i] = GL_NONE;
+    const Framebuffer* framebuffer =
+        GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+    if (framebuffer &&
+        framebuffer->DrawBuffersHaveNoImage(num, buf) &&
+        framebuffer->ColorBuffersHaveImage()) {
+      glDrawBuffersARB(8, buf);
+    }
+    if (num == 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
   GLenum completeness = framebuffer->IsPossiblyComplete(feature_info_.get());
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     return completeness;
   }
+
+  bool has_image = true;
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (target == GL_READ_FRAMEBUFFER) {
+      has_image = AdjustColorBufferAttachmentsIfNecessary(true, false);
+    } else {
+      has_image = AdjustColorBufferAttachmentsIfNecessary(false, true);
+    }
+    if (!has_image) {
+      return GL_FRAMEBUFFER_COMPLETE;
+    }
+  }
+
   return framebuffer->GetStatus(texture_manager(), target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   DoFramebufferTexture2DCommon(
     "glFramebufferTexture2D", target, attachment,
     textarget, client_texture_id, level, 0);
 }
@@ skipping 270 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoBlitFramebufferCHROMIUM(
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
     GLbitfield mask, GLenum filter) {
   const char* func_name = "glBlitFramebufferCHROMIUM";
   DCHECK(!ShouldDeferReads() && !ShouldDeferDraws());
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      (mask & GL_COLOR_BUFFER_BIT) != 0 &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      return;
+    }
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return;
+    }
+  }
   if (!CheckBoundFramebufferValid(func_name)) {
     return;
   }
 
   if (GetBoundFramebufferSamples(GL_DRAW_FRAMEBUFFER) > 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                        "destination framebuffer is multisampled");
     return;
   }
 
@@ skipping 1954 matching lines @@
     return error::kNoError;
   }
   if (count < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      return error::kNoError;
+    }
+  }
   if (!CheckBoundDrawFramebufferValid(function_name)) {

[Zhenyao Mo, 2016/11/14 19:42:24]

All this same code is right above CheckBoundDrawFramebufferValid or
CheckBoundFramebufferValid.  It looks to me that the workaround should just be
part of that function, so we don't have to repeat ourselves all over the places.

[yunchao, 2016/11/15 16:21:59]

Done. 

It is a little different in Clear and ClearBuffer*, so, still handle it like
this in the callers for these functions. 

     return error::kNoError;
   }
   // We have to check this here because the prototype for glDrawArrays
   // is GLint not GLsizei.
   if (first < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "first < 0");
     return error::kNoError;
   }
 
   if (feature_info_->IsWebGL2OrES3Context()) {
@@ skipping 143 matching lines @@
   if (primcount < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "primcount < 0");
     return error::kNoError;
   }
   Buffer* element_array_buffer = buffer_manager()->RequestBufferAccess(
       &state_, GL_ELEMENT_ARRAY_BUFFER, function_name);
   if (!element_array_buffer) {
     return error::kNoError;
   }
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(false, true)) {
+      return error::kNoError;
+    }
+  }
   if (!CheckBoundDrawFramebufferValid(function_name)) {
     return error::kNoError;
   }
 
   if (state_.bound_transform_feedback.get() &&
       state_.bound_transform_feedback->active() &&
       !state_.bound_transform_feedback->paused()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
         "transformfeedback is active and not paused");
     return error::kNoError;
@@ skipping 1205 matching lines @@
 
   if (!validators_->read_pixel_format.IsValid(format)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, format, "format");
     return error::kNoError;
   }
   if (!validators_->read_pixel_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM(func_name, type, "type");
     return error::kNoError;
   }
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return error::kNoError;
+    }
+  }
+
   if (!CheckBoundReadFramebufferValid(
           func_name, GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return error::kNoError;
   }
   GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   if (src_internal_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, "no valid color image");
     return error::kNoError;
   }
   std::vector<GLenum> accepted_formats;
@@ skipping 2613 matching lines @@
         GL_INVALID_OPERATION, func_name, "texture is immutable");
     return;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, func_name, "dimensions out of range");
     return;
   }
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return;
+    }
+  }
+
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
@@ skipping 227 matching lines @@
   Texture* texture = texture_ref->texture();
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &type, &internal_format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return;
+    }
+  }
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
@@ skipping 96 matching lines @@
   Texture* texture = texture_ref->texture();
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!texture->GetLevelType(target, level, &type, &internal_format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, zoffset, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
+  if (workarounds().adjust_framebuffer_complete_status &&
+      SupportsDrawBuffers() &&
+      framebuffer_state_.clear_state_dirty) {
+    if (!AdjustColorBufferAttachmentsIfNecessary(true, false)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
+          "no valid color image");
+      return;
+    }
+  }
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFramebufferInternalFormat();
   GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
@@ skipping 4654 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