[Command Buffer] emulate SRGB color format for BlitFramebuffer in OpenGL

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 26 matching lines @@
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_stream_texture_image.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.h"
 #include "gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_tex_image.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h"
+#include "gpu/command_buffer/service/gles2_cmd_srgb_converter.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/gpu_state_tracer.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/path_manager.h"
@@ skipping 2007 matching lines @@
   // Whether a texture backed by a Chromium Image needs to emulate GL_RGB format
   // using GL_RGBA and glColorMask.
   bool ChromiumImageNeedsRGBEmulation();
 
   // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
   // equivalent functions reset shared state.
   void ClearScheduleCALayerState();
 
   bool InitializeCopyTexImageBlitter(const char* function_name);
   bool InitializeCopyTextureCHROMIUM(const char* function_name);
+  bool InitializeSRGBDecoder(const char* function_name);
+  bool InitializeSRGBEncoder(const char* function_name);
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
@@ skipping 171 matching lines @@
   // Forces the backbuffer to use native GMBs rather than a TEXTURE_2D texture.
   bool should_use_native_gmb_for_backbuffer_;
 
   // Log extra info.
   bool service_logging_;
 
   std::unique_ptr<ApplyFramebufferAttachmentCMAAINTELResourceManager>
       apply_framebuffer_attachment_cmaa_intel_;
   std::unique_ptr<CopyTexImageResourceManager> copy_tex_image_blit_;
   std::unique_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
+  std::unique_ptr<SRGBConverter> srgb_converter_;
   std::unique_ptr<ClearFramebufferResourceManager> clear_framebuffer_blit_;
 
   // Cached values of the currently assigned viewport dimensions.
   GLsizei viewport_max_width_;
   GLsizei viewport_max_height_;
 
   // Command buffer stats.
   base::TimeDelta total_processing_commands_time_;
 
   // States related to each manager.
@@ skipping 1944 matching lines @@
       GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* draw_framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(
       draw_framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
 
   target = features().chromium_framebuffer_multisample ?
       GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
   Framebuffer* read_framebuffer = GetFramebufferInfoForTarget(target);
   valid = valid && CheckFramebufferValid(
       read_framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
-
-  if (valid && feature_info_->feature_flags().desktop_srgb_support) {
-    bool enable_framebuffer_srgb =
-        (draw_framebuffer && draw_framebuffer->HasSRGBAttachments()) ||
-        (read_framebuffer && read_framebuffer->HasSRGBAttachments());
-    state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
-  }
-
   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 281 matching lines @@
     if (copy_tex_image_blit_.get()) {
       copy_tex_image_blit_->Destroy();
       copy_tex_image_blit_.reset();
     }
 
     if (copy_texture_CHROMIUM_.get()) {
       copy_texture_CHROMIUM_->Destroy();
       copy_texture_CHROMIUM_.reset();
     }
 
+    if (srgb_converter_.get()) {
+      srgb_converter_->Destroy();
+      srgb_converter_.reset();
+    }
+
     clear_framebuffer_blit_.reset();
 
     if (state_.current_program.get()) {
       program_manager()->UnuseProgram(shader_manager(),
                                       state_.current_program.get());
     }
 
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
@@ skipping 72 matching lines @@
   // Current program must be cleared after calling ProgramManager::UnuseProgram.
   // Otherwise, we can leak objects. http://crbug.com/258772.
   // state_.current_program must be reset before group_ is reset because
   // the later deletes the ProgramManager object that referred by
   // state_.current_program object.
   state_.current_program = NULL;
 
   apply_framebuffer_attachment_cmaa_intel_.reset();
   copy_tex_image_blit_.reset();
   copy_texture_CHROMIUM_.reset();
+  srgb_converter_.reset();
   clear_framebuffer_blit_.reset();
 
   if (query_manager_.get()) {
     query_manager_->Destroy(have_context);
     query_manager_.reset();
   }
 
   if (vertex_array_manager_ .get()) {
     vertex_array_manager_->Destroy(have_context);
     vertex_array_manager_.reset();
@@ skipping 2877 matching lines @@
   }
 
   GLsizei read_buffer_samples = GetBoundFramebufferSamples(GL_READ_FRAMEBUFFER);
   if (read_buffer_samples > 0 &&
       (srcX0 != dstX0 || srcY0 != dstY0 || srcX1 != dstX1 || srcY1 != dstY1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "src framebuffer is multisampled, but src/dst regions are different");
     return;
   }
 
-  GLenum src_format = GetBoundReadFramebufferInternalFormat();
+  GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   GLenum src_type = GetBoundReadFramebufferTextureType();
 
+  bool read_buffer_has_srgb =
+      GetColorEncodingFromInternalFormat(src_internal_format) == GL_SRGB;
+  bool draw_buffers_has_srgb = false;
   if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
-    bool is_src_signed_int = GLES2Util::IsSignedIntegerFormat(src_format);
-    bool is_src_unsigned_int = GLES2Util::IsUnsignedIntegerFormat(src_format);
+    bool is_src_signed_int =
+        GLES2Util::IsSignedIntegerFormat(src_internal_format);
+    bool is_src_unsigned_int =
+        GLES2Util::IsUnsignedIntegerFormat(src_internal_format);
     DCHECK(!is_src_signed_int || !is_src_unsigned_int);
 
     if ((is_src_signed_int || is_src_unsigned_int) && filter == GL_LINEAR) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                          "invalid filter for integer format");
       return;
     }
 
     GLenum src_sized_format =
-        GLES2Util::ConvertToSizedFormat(src_format, src_type);
+        GLES2Util::ConvertToSizedFormat(src_internal_format, src_type);
     for (uint32_t ii = 0; ii < group_->max_draw_buffers(); ++ii) {
       GLenum dst_format = GetBoundColorDrawBufferInternalFormat(
           static_cast<GLint>(ii));
       GLenum dst_type = GetBoundColorDrawBufferType(static_cast<GLint>(ii));
       if (dst_format == 0)
         continue;
+      if (GetColorEncodingFromInternalFormat(dst_format) == GL_SRGB)
+        draw_buffers_has_srgb = true;
       if (read_buffer_samples > 0 &&
           (src_sized_format !=
            GLES2Util::ConvertToSizedFormat(dst_format, dst_type))) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                            "src and dst formats differ for color");
         return;
       }
       bool is_dst_signed_int = GLES2Util::IsSignedIntegerFormat(dst_format);
       bool is_dst_unsigned_int = GLES2Util::IsUnsignedIntegerFormat(dst_format);
       DCHECK(!is_dst_signed_int || !is_dst_unsigned_int);
@@ skipping 16 matching lines @@
     if ((GetBoundFramebufferDepthFormat(GL_READ_FRAMEBUFFER) !=
          GetBoundFramebufferDepthFormat(GL_DRAW_FRAMEBUFFER)) ||
         (GetBoundFramebufferStencilFormat(GL_READ_FRAMEBUFFER) !=
          GetBoundFramebufferStencilFormat(GL_DRAW_FRAMEBUFFER))) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                          "src and dst formats differ for depth/stencil");
       return;
     }
   }
 
-  state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
-  BlitFramebufferHelper(
-      srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-  state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
+  bool enable_srgb = read_buffer_has_srgb || draw_buffers_has_srgb;

[yunchao, 2016/08/29 14:33:47]

We need to traverse the read buffer and draw buffers to handle the TODO below: 
drawBuffers have srgb images, as well as non-srgb images during bliting. 

That patch is also ready, but it is a little tricky to cover all corner cases.
Moreover, there is no test cases to cover this feature and expose potential
errors. So I would like you to review the main part at first. 

+  bool same_size = (abs(srcX1 - srcX0) == abs(dstX1 - dstX0)) &&
+                   (abs(srcY1 - srcY0) == abs(dstY1 - dstY0));
+  if (!enable_srgb ||
+      !feature_info_->feature_flags().desktop_srgb_support ||
+      !feature_info_->gl_version_info().is_desktop_core_profile ||

[Zhenyao Mo, 2016/08/29 23:36:50]

why core profile here?

[yunchao, 2016/08/31 09:18:44]

Removed them already.

+      (read_buffer_has_srgb && draw_buffers_has_srgb && same_size) ||

[Zhenyao Mo, 2016/08/29 23:36:50]

Why same_size here?

[yunchao, 2016/08/31 09:18:44]

When we blit a read buffer with srgb color format to draw buffers with srgb
color format, if the size of src region is not the same as the size of the dst
region, we need to filter. You know, srgb is non-linear, filtering against srgb
color format is not correct (See qiankun's conformance test for generateMipmap
against srgb: https://github.com/KhronosGroup/WebGL/pull/1951). 

In this situation, we need to convert srgb to linear, then blit and filter,
finally, convert linear to srgb. 

However, if the src region is exactly the same size with the dst region, we can
blit srgb read buffer to srgb draw buffers directly without filtering.  

[Zhenyao Mo, 2016/09/01 19:28:33]

Our purpose is to emulate ES3 sRGB behavior, which GL 4.4 is the same, but older
version isn't, they didn't perform decoding when read from sRGB formats.  So
even with the same size, you will still need to do some emulation.

[yunchao, 2016/09/02 14:11:16]

Yes, you are correct. I thought that if the size was the same (It was common in
real case), we can disable framebuffer_srgb_ and blit-ed directly without any
decode/encode. It would be an performance optimization. Unfortunately, the
underlying driver may do encode during bliting even framebuffer_srgb_ flag was
false, so it would get wrong result. 
The latest patchset removes this line, and always do encode/decode by emulation.

+      gl_version_info().IsAtLeastGL(4, 4)) {
+    if (enable_srgb && gl_version_info().IsAtLeastGL(4, 4)) {
+      state_.EnableDisableFramebufferSRGB(enable_srgb);
+    }
+
+    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);

[Zhenyao Mo, 2016/08/29 23:39:59]

This is a nasty situation. We define the CHROMIUM version of blitframebuffer
extension as no SCISSOR_TEST, whereas the ES3 version should have SCISSOR_TEST. 
If you add a conformance test to verify SCISSOR_TEST and BlitFramebuffer, you
will have to fix here also, i.e., branch out into CHROMIUM extension behavior
and ES3 behavior,

[yunchao, 2016/08/31 09:18:44]

That's true. The GLES spec says that blitFramebuffer should do scissor test per
fragment operation. 
The original code has the same problem too. Seems that current CTS doesn't cover
this feature. I will write conformance test and revisit this later. I have added
a TODO for it.

+    BlitFramebufferHelper(
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
+    return;
+  }
+
+  // emulate srgb for desktop core profile when GL version < 4.4
+  // TODO(yunchao): Need to handle this situation:
+  // There are multiple draw buffers. Some of them are srgb image.
+  // The others are not.
+  GLenum target = features().chromium_framebuffer_multisample ?
+      GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
+  Framebuffer* draw_framebuffer = GetFramebufferInfoForTarget(target);
+
+  target = features().chromium_framebuffer_multisample ?
+      GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
+  Framebuffer* read_framebuffer = GetFramebufferInfoForTarget(target);

[Zhenyao Mo, 2016/08/29 23:36:50]

You should just use GetBoundReadFramebufferServiceId() and
GetBoundDrawFramebufferServiceId(). The latter needs to be added though.

[yunchao, 2016/08/31 09:18:44]

Done.

+
+  if (read_buffer_has_srgb) {
+    state_.EnableDisableFramebufferSRGB(false);
+    if (!InitializeSRGBDecoder(func_name)) {
+      return;
+    }
+    srgb_converter_->SRGBToLinear(this, srcX0, srcY0, srcX1, srcY1,
+                                  dstX0, dstY0, dstX1, dstY1,
+                                  mask, filter,
+                                  GetBoundReadFramebufferSize(),
+                                  read_framebuffer->service_id(),
+                                  src_internal_format,
+                                  draw_framebuffer->service_id(),
+                                  GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
+  }
+
+  if (draw_buffers_has_srgb) {
+    state_.EnableDisableFramebufferSRGB(false);
+    if (!InitializeSRGBEncoder(func_name)) {
+      return;
+    }
+    srgb_converter_->LinearToSRGB(this, srcX0, srcY0, srcX1, srcY1,
+                                  dstX0, dstY0, dstX1, dstY1,
+                                  mask, filter,
+                                  GetBoundReadFramebufferSize(),
+                                  read_framebuffer->service_id(),
+                                  src_internal_format,
+                                  draw_framebuffer->service_id(),
+                                  GL_SRGB8_ALPHA8,
+                                  GL_RGBA, GL_UNSIGNED_BYTE);
+  }
+}
+
+bool GLES2DecoderImpl::InitializeSRGBDecoder(
+    const char* function_name) {
+  if (!srgb_converter_.get()) {
+    LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
+    srgb_converter_.reset(
+        new SRGBConverter(feature_info_.get()));
+    srgb_converter_->InitializeSRGBDecoder(this);
+    if (LOCAL_PEEK_GL_ERROR(function_name) != GL_NO_ERROR)
+      return false;
+  }
+  return true;
+}
+
+bool GLES2DecoderImpl::InitializeSRGBEncoder(
+    const char* function_name) {
+  if (!srgb_converter_.get()) {
+    LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
+    srgb_converter_.reset(
+        new SRGBConverter(feature_info_.get()));
+    srgb_converter_->InitializeSRGBEncoder(this);
+    if (LOCAL_PEEK_GL_ERROR(function_name) != GL_NO_ERROR)
+      return false;
+  }
+  return true;
 }
 
 void GLES2DecoderImpl::EnsureRenderbufferBound() {
   if (!state_.bound_renderbuffer_valid) {
     state_.bound_renderbuffer_valid = true;
     glBindRenderbufferEXT(GL_RENDERBUFFER,
                           state_.bound_renderbuffer.get()
                               ? state_.bound_renderbuffer->service_id()
                               : 0);
   }
@@ skipping 10134 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