Fix ReadPixels from float fbo buffer in ES2/WebGL1.

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 1265 matching lines @@
   bool SetCapabilityState(GLenum cap, bool enabled);
 
   // Infer color encoding from internalformat
   static GLint GetColorEncodingFromInternalFormat(GLenum internalformat);
 
   // Check that the currently bound read framebuffer's color image
   // isn't the target texture of the glCopyTex{Sub}Image2D.
   bool FormsTextureCopyingFeedbackLoop(TextureRef* texture, GLint level);
 
   // Check if a framebuffer meets our requirements.
+  // Generates |gl_error| if the framebuffer is incomplete.
   bool CheckFramebufferValid(
       Framebuffer* framebuffer,
       GLenum target,
       bool clear_uncleared_images,
+      GLenum gl_error,
       const char* func_name);
 
   bool CheckBoundDrawFramebufferValid(
       bool clear_uncleared_images, const char* func_name);
-  bool CheckBoundReadFramebufferValid(const char* func_name);
+  // Generates |gl_error| if the bound read fbo is incomplete.
+  bool CheckBoundReadFramebufferValid(const char* func_name, GLenum gl_error);
 
   // Checks if the current program exists and is valid. If not generates the
   // appropriate GL error.  Returns true if the current program is in a usable
   // state.
   bool CheckCurrentProgram(const char* function_name);
 
   // Checks if the current program exists and is valid and that location is not
   // -1. If the current program is not valid generates the appropriate GL
   // error. Returns true if the current program is in a usable state and
   // location is not -1.
@@ skipping 2412 matching lines @@
         framebuffer_state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   }
   OnFboChanged();
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     Framebuffer* framebuffer,
     GLenum target,
     bool clear_uncleared_images,
+    GLenum gl_error,
     const char* func_name) {
   if (!framebuffer) {
     if (surfaceless_)
       return false;
     if (backbuffer_needs_clear_bits_ && clear_uncleared_images) {
       glClearColor(0, 0, 0, BackBufferHasAlpha() ? 0 : 1.f);
       state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glClearStencil(0);
       state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
       state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
@@ skipping 19 matching lines @@
     }
     return true;
   }
 
   if (framebuffer_manager()->IsComplete(framebuffer)) {
     return true;
   }
 
   GLenum completeness = framebuffer->IsPossiblyComplete(feature_info_.get());
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_FRAMEBUFFER_OPERATION, func_name, "framebuffer incomplete");
+    LOCAL_SET_GL_ERROR(gl_error, func_name, "framebuffer incomplete");
     return false;
   }
 
   // Are all the attachments cleared?
   if (clear_uncleared_images &&
       (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
        texture_manager()->HaveUnclearedMips())) {
     if (!framebuffer->IsCleared()) {
       // Can we clear them?
       if (framebuffer->GetStatus(texture_manager(), target) !=
           GL_FRAMEBUFFER_COMPLETE) {
         LOCAL_SET_GL_ERROR(
-            GL_INVALID_FRAMEBUFFER_OPERATION, func_name,
-            "framebuffer incomplete (clear)");
+            gl_error, func_name, "framebuffer incomplete (clear)");
         return false;
       }
       ClearUnclearedAttachments(target, framebuffer);
     }
   }
 
   if (!framebuffer_manager()->IsComplete(framebuffer)) {
     if (framebuffer->GetStatus(texture_manager(), target) !=
         GL_FRAMEBUFFER_COMPLETE) {
       LOCAL_SET_GL_ERROR(
-          GL_INVALID_FRAMEBUFFER_OPERATION, func_name,
-          "framebuffer incomplete (check)");
+          gl_error, func_name, "framebuffer incomplete (check)");
       return false;
     }
     framebuffer_manager()->MarkAsComplete(framebuffer);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckBoundDrawFramebufferValid(
     bool clear_uncleared_images, const char* func_name) {
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(
-      framebuffer, target, clear_uncleared_images, func_name);
+      framebuffer, target, clear_uncleared_images,
+      GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
   if (valid && !features().chromium_framebuffer_multisample)
     OnUseFramebuffer();
   return valid;
 }
 
-bool GLES2DecoderImpl::CheckBoundReadFramebufferValid(const char* func_name) {
+bool GLES2DecoderImpl::CheckBoundReadFramebufferValid(
+    const char* func_name, GLenum gl_error) {
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
-  bool valid = CheckFramebufferValid(framebuffer, target, true, func_name);
+  bool valid = CheckFramebufferValid(
+      framebuffer, target, true, gl_error, func_name);
   return valid;
 }
 
 GLint GLES2DecoderImpl::GetColorEncodingFromInternalFormat(
     GLenum internalformat) {
   switch (internalformat) {
     case GL_SRGB_EXT:
     case GL_SRGB_ALPHA_EXT:
     case GL_SRGB8:
     case GL_SRGB8_ALPHA8:
@@ skipping 1419 matching lines @@
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glGenerateMipmap");
   if (error == GL_NO_ERROR) {
     texture_manager()->MarkMipmapsGenerated(texture_ref);
   }
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
+  switch (pname) {
+    case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
+    case GL_IMPLEMENTATION_COLOR_READ_TYPE:
+      // They are not supported on Desktop GL until 4.1, but could be exposed
+      // through GL_OES_read_format extension. However, a conflicting extension
+      // GL_ARB_ES2_compatibility specifies an error case when requested on
+      // integer/floating point buffers.
+      // To simpify the handling, we just query and check for GL errors. If an
+      // GL error occur, we fall back to our internal implementation.
+      *num_written = 1;
+      if (!CheckBoundReadFramebufferValid("glGetIntegerv",
+                                          GL_INVALID_OPERATION)) {
+        if (params) {
+          *params = 0;
+        }
+        return true;
+      }
+      if (params) {
+        ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::GetHelper",
+                                           GetErrorState());
+        glGetIntegerv(pname, params);
+        if (glGetError() != GL_NO_ERROR) {
+          if (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT) {
+            *params = GLES2Util::GetGLReadPixelsImplementationFormat(
+                GetBoundReadFrameBufferInternalFormat(),
+                GetBoundReadFrameBufferTextureType(),
+                feature_info_->feature_flags().ext_read_format_bgra);
+          } else {
+            *params = GLES2Util::GetGLReadPixelsImplementationType(
+                GetBoundReadFrameBufferInternalFormat(),
+                GetBoundReadFrameBufferTextureType());
+          }
+        }
+        if (*params == GL_HALF_FLOAT &&
+            (feature_info_->context_type() == CONTEXT_TYPE_WEBGL1 ||
+             feature_info_->context_type() == CONTEXT_TYPE_OPENGLES2)) {
+          *params = GL_HALF_FLOAT_OES;
+        }
+      }
+      return true;
+    default:
+      break;
+  }
+
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (pname) {
-      case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-        *num_written = 1;
-        // Return the GL implementation's preferred format and (see below type)
-        // if we have the GL extension that exposes this. This allows the GPU
-        // client to use the implementation's preferred format for glReadPixels
-        // for optimisation.
-        //
-        // A conflicting extension (GL_ARB_ES2_compatibility) specifies an error
-        // case when requested on integer/floating point buffers but which is
-        // acceptable on GLES2 and with the GL_OES_read_format extension.
-        //
-        // Therefore if an error occurs we swallow the error and use the
-        // internal implementation.
-        if (params) {
-          if (context_->HasExtension("GL_OES_read_format")) {
-            ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::GetHelper",
-                                               GetErrorState());
-            glGetIntegerv(pname, params);
-            if (glGetError() == GL_NO_ERROR)
-              return true;
-          }
-          *params = GLES2Util::GetGLReadPixelsImplementationFormat(
-              GetBoundReadFrameBufferInternalFormat(),
-              GetBoundReadFrameBufferTextureType(),
-              feature_info_->feature_flags().ext_read_format_bgra);
-        }
-        return true;
-      case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-        *num_written = 1;
-        if (params) {
-          if (context_->HasExtension("GL_OES_read_format")) {
-            ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::GetHelper",
-                                               GetErrorState());
-            glGetIntegerv(pname, params);
-            if (glGetError() == GL_NO_ERROR)
-              return true;
-          }
-          *params = GLES2Util::GetGLReadPixelsImplementationType(
-              GetBoundReadFrameBufferInternalFormat(),
-              GetBoundReadFrameBufferTextureType());
-        }
-        return true;
       case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_fragment_uniform_vectors();
         }
         return true;
       case GL_MAX_VARYING_VECTORS:
         *num_written = 1;
         if (params) {
           *params = group_->max_varying_vectors();
@@ skipping 1355 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) {
   DCHECK(!ShouldDeferReads() && !ShouldDeferDraws());
 
   if (!CheckBoundDrawFramebufferValid(true, "glBlitFramebufferCHROMIUM") ||
-      !CheckBoundReadFramebufferValid("glBlitFramebufferCHROMIUM")) {
+      !CheckBoundReadFramebufferValid("glBlitFramebufferCHROMIUM",
+                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
   BlitFramebufferHelper(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
 }
 
@@ skipping 2769 matching lines @@
 
   if (!validators_->read_pixel_format.IsValid(format)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadPixels", format, "format");
     return error::kNoError;
   }
   if (!validators_->read_pixel_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadPixels", type, "type");
     return error::kNoError;
   }
 
-  if (!CheckBoundReadFramebufferValid("glReadPixels")) {
+  if (!CheckBoundReadFramebufferValid("glReadPixels",
+                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return error::kNoError;
   }
   GLenum src_internal_format = GetBoundReadFrameBufferInternalFormat();
   if (src_internal_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
         "no valid color image");
     return error::kNoError;
   }
   std::vector<GLenum> accepted_formats;
   std::vector<GLenum> accepted_types;
@@ skipping 33 matching lines @@
       break;
     default:
       accepted_formats.push_back(GL_RGBA);
       {
         GLenum src_type = GetBoundReadFrameBufferTextureType();
         switch (src_type) {
           case GL_HALF_FLOAT:
           case GL_HALF_FLOAT_OES:
           case GL_FLOAT:
           case GL_UNSIGNED_INT_10F_11F_11F_REV:
-            if (!feature_info_->IsES3Enabled()) {
-              accepted_types.push_back(GL_UNSIGNED_BYTE);
-            } else {
-              accepted_types.push_back(GL_FLOAT);
-            }
+            accepted_types.push_back(GL_FLOAT);
             break;
           default:
             accepted_types.push_back(GL_UNSIGNED_BYTE);
             break;
         }
       }
       break;
   }
   if (!feature_info_->IsWebGLContext()) {
     accepted_formats.push_back(GL_BGRA_EXT);
@@ skipping 17 matching lines @@
     if (format == static_cast<GLenum>(preferred_format) &&
         type == static_cast<GLenum>(preferred_type)) {
       format_type_acceptable = true;
     }
   }
   if (!format_type_acceptable) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
         "format and type incompatible with the current read framebuffer");
     return error::kNoError;
   }
+  if (type == GL_HALF_FLOAT_OES &&
+      !(feature_info_->gl_version_info().is_es2)) {
+    type = GL_HALF_FLOAT;
+  }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   int32_t max_x;
   int32_t max_y;
   if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y)) {
@@ skipping 2100 matching lines @@
         GL_INVALID_OPERATION, "glCopyTexImage2D", "texture is immutable");
     return;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
     return;
   }
 
-  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D")) {
+  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D",
+                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   if (read_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopyTexImage2D",
         "no valid color image");
     return;
   }
 
@@ skipping 178 matching lines @@
   GLenum type = 0;
   GLenum format = 0;
   if (!texture->GetLevelType(target, level, &type, &format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
 
-  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D")) {
+  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D",
+                                      GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   if (read_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopyTexImage2D",
         "no valid color image");
     return;
   }
   // Check we have compatible formats.
@@ skipping 4495 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