gpu: Defer reads from default framebuffer when needed.

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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 675 matching lines @@
       GLenum target,
       GLint level,
       GLint xoffset,
       GLint yoffset,
       GLsizei width,
       GLsizei height,
       GLenum format,
       GLsizei imageSize,
       const void * data);
 
-  // Wrapper for CopyTexImage2D.
-  void DoCopyTexImage2D(
-      GLenum target,
-      GLint level,
-      GLenum internal_format,
-      GLint x,
-      GLint y,
-      GLsizei width,
-      GLsizei height,
-      GLint border);
-
-  // Wrapper for CopyTexSubImage2D.
-  void DoCopyTexSubImage2D(
-      GLenum target,
-      GLint level,
-      GLint xoffset,
-      GLint yoffset,
-      GLint x,
-      GLint y,
-      GLsizei width,
-      GLsizei height);
-
   // Wrapper for TexImage2D commands.
   error::Error DoTexImage2D(
       GLenum target,
       GLint level,
       GLenum internal_format,
       GLsizei width,
       GLsizei height,
       GLint border,
       GLenum format,
       GLenum type,
@@ skipping 280 matching lines @@
   // Wrapper for glBindRenderbuffer since we need to track the current targets.
   void DoBindRenderbuffer(GLenum target, GLuint renderbuffer);
 
   // Wrapper for glBindTexture since we need to track the current targets.
   void DoBindTexture(GLenum target, GLuint texture);
 
   // Wrapper for glBindVertexArrayOES
   void DoBindVertexArrayOES(GLuint array);
   void EmulateVertexArrayState();
 
-  // Wrapper for glBlitFramebufferEXT.
-  void DoBlitFramebufferEXT(
-      GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-      GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-      GLbitfield mask, GLenum filter);
-
   // Wrapper for glBufferData.
   void DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
@@ skipping 368 matching lines @@
   const FeatureInfo::Workarounds& workarounds() const {
     return feature_info_->workarounds();
   }
 
   bool ShouldDeferDraws() {
     return !offscreen_target_frame_buffer_.get() &&
            state_.bound_draw_framebuffer == NULL &&
            surface_->DeferDraws();
   }
 
+  bool ShouldDeferReads() {
+    return !offscreen_target_frame_buffer_.get() &&
+           state_.bound_read_framebuffer == NULL &&
+           surface_->DeferDraws();
+  }
+
   void ForceCompileShaderIfPending(ShaderManager::ShaderInfo* info);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
@@ skipping 1695 matching lines @@
   if (offscreen_resolved_color_texture_.get())
     offscreen_resolved_color_texture_->Destroy();
   offscreen_resolved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
 
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleResizeCHROMIUM(
     uint32 immediate_data_size, const gles2::ResizeCHROMIUM& c) {
-  if (ShouldDeferDraws())
+  if (!offscreen_target_frame_buffer_.get() && surface_->DeferDraws())

[piman, 2012/11/30 01:52:12]

Note here: ResizeCHROMIUM resizes the default FBO regardless of what is bound,
hence this change.

     return error::kDeferCommandUntilLater;
 
   GLuint width = static_cast<GLuint>(c.width);
   GLuint height = static_cast<GLuint>(c.height);
   TRACE_EVENT2("gpu", "glResizeChromium", "width", width, "height", height);
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && \
     !defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
   // Make sure that we are done drawing to the back buffer before resizing.
   glFinish();
 #endif
@@ skipping 1355 matching lines @@
       break;
     case GL_RENDERBUFFER_HEIGHT:
       *params = renderbuffer->height();
       break;
     default:
       glGetRenderbufferParameterivEXT(target, pname, params);
       break;
   }
 }
 
-void GLES2DecoderImpl::DoBlitFramebufferEXT(
-    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-    GLbitfield mask, GLenum filter) {
+error::Error GLES2DecoderImpl::HandleBlitFramebufferEXT(
+    uint32 immediate_data_size, const gles2::BlitFramebufferEXT& c) {
+  if (ShouldDeferDraws() || ShouldDeferReads())
+    return error::kDeferCommandUntilLater;
+  GLint srcX0 = static_cast<GLint>(c.srcX0);
+  GLint srcY0 = static_cast<GLint>(c.srcY0);
+  GLint srcX1 = static_cast<GLint>(c.srcX1);
+  GLint srcY1 = static_cast<GLint>(c.srcY1);
+  GLint dstX0 = static_cast<GLint>(c.dstX0);
+  GLint dstY0 = static_cast<GLint>(c.dstY0);
+  GLint dstX1 = static_cast<GLint>(c.dstX1);
+  GLint dstY1 = static_cast<GLint>(c.dstY1);
+  GLbitfield mask = static_cast<GLbitfield>(c.mask);
+  GLenum filter = static_cast<GLenum>(c.filter);
+  if (!validators_->blit_filter.IsValid(filter)) {
+    SetGLErrorInvalidEnum("glBlitFramebufferEXT", filter, "filter");
+    return error::kNoError;
+  }
   if (!features().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
                "glBlitFramebufferEXT", "function not available");
   }
   glDisable(GL_SCISSOR_TEST);
   if (IsAngle()) {
     glBlitFramebufferANGLE(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   } else {
     glBlitFramebufferEXT(
         srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   }
   EnableDisable(GL_SCISSOR_TEST, state_.enable_flags.scissor_test);
   UNSHIPPED_TRACE_EVENT_INSTANT1("test_gpu", "DoBlit", "width", srcX1 - srcX0);
+  return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorageMultisample(
     GLenum target, GLsizei samples, GLenum internalformat,
     GLsizei width, GLsizei height) {
   if (!features().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
                "glRenderbufferStorageMultisampleEXT", "function not available");
     return;
   }
@@ skipping 1754 matching lines @@
 
   state_.vertex_attrib_manager->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(
     uint32 immediate_data_size, const gles2::ReadPixels& c) {
+  if (ShouldDeferReads())
+    return error::kDeferCommandUntilLater;
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
@@ skipping 1157 matching lines @@
     start = 0;
   }
   GLint end = start + range;
   if (end > sourceRange) {
     range -= end - sourceRange;
   }
   *out_start = start;
   *out_range = range;
 }
 
-void GLES2DecoderImpl::DoCopyTexImage2D(
-    GLenum target,
-    GLint level,
-    GLenum internal_format,
-    GLint x,
-    GLint y,
-    GLsizei width,
-    GLsizei height,
-    GLint border) {
+error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
+    uint32 immediate_data_size, const gles2::CopyTexImage2D& c) {
+  if (ShouldDeferReads())
+    return error::kDeferCommandUntilLater;
+  GLenum target = static_cast<GLenum>(c.target);
+  GLint level = static_cast<GLint>(c.level);
+  GLenum internal_format = static_cast<GLenum>(c.internalformat);
+  GLint x = static_cast<GLint>(c.x);
+  GLint y = static_cast<GLint>(c.y);
+  GLsizei width = static_cast<GLsizei>(c.width);
+  GLsizei height = static_cast<GLsizei>(c.height);
+  GLint border = static_cast<GLint>(c.border);
+  if (!validators_->texture_target.IsValid(target)) {
+    SetGLErrorInvalidEnum("glCopyTexImage2D", target, "target");
+    return error::kNoError;
+  }
+  if (!validators_->texture_internal_format.IsValid(internal_format)) {
+    SetGLErrorInvalidEnum("glCopyTexImage2D", internal_format,
+    "internalformat");
+    return error::kNoError;
+  }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "width < 0");
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
+    return error::kNoError;
+  }
+  if (!validators_->texture_border.IsValid(border)) {
+    SetGLError(
+        GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
+    return error::kNoError;
+  }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "unknown texture for target");
-    return;
+    return error::kNoError;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "texture is immutable");
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
-    return;
+    return error::kNoError;
   }
   if (!ValidateTextureParameters(
       "glCopyTexImage2D", target, internal_format, GL_UNSIGNED_BYTE, level)) {
-    return;
+    return error::kNoError;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
     SetGLError(GL_INVALID_OPERATION, "glCopyTexImage2D", "incompatible format");
-    return;
+    return error::kNoError;
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glCopyImage2D", "can not be used with depth or stencil textures");
-    return;
+    return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid("glCopyTexImage2D")) {
-    return;
+    return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
   if (info->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
@@ skipping 11 matching lines @@
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the texture.
     if (!ClearLevel(
         info->service_id(), info->target(),
         target, level, internal_format, GL_UNSIGNED_BYTE, width, height,
         info->IsImmutable())) {
       SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D", "dimensions too big");
-      return;
+      return error::kNoError;
     }
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
     glCopyTexImage2D(target, level, internal_format,
                      copyX, copyY, copyWidth, copyHeight, border);
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         info, target, level, internal_format, width, height, 1,
         border, internal_format, GL_UNSIGNED_BYTE, true);
   }
+  return error::kNoError;
 }
 
-void GLES2DecoderImpl::DoCopyTexSubImage2D(
-    GLenum target,
-    GLint level,
-    GLint xoffset,
-    GLint yoffset,
-    GLint x,
-    GLint y,
-    GLsizei width,
-    GLsizei height) {
+
+error::Error GLES2DecoderImpl::HandleCopyTexSubImage2D(
+    uint32 immediate_data_size, const gles2::CopyTexSubImage2D& c) {
+  if (ShouldDeferReads())
+    return error::kDeferCommandUntilLater;
+  GLenum target = static_cast<GLenum>(c.target);
+  GLint level = static_cast<GLint>(c.level);
+  GLint xoffset = static_cast<GLint>(c.xoffset);
+  GLint yoffset = static_cast<GLint>(c.yoffset);
+  GLint x = static_cast<GLint>(c.x);
+  GLint y = static_cast<GLint>(c.y);
+  GLsizei width = static_cast<GLsizei>(c.width);
+  GLsizei height = static_cast<GLsizei>(c.height);
+  if (!validators_->texture_target.IsValid(target)) {
+    SetGLErrorInvalidEnum("glCopyTexSubImage2D", target, "target");
+    return error::kNoError;
+  }
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "width < 0");
+    return error::kNoError;
+  }
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D", "height < 0");
+    return error::kNoError;
+  }
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexSubImage2D", "unknown texture for target");
-    return;
+    return error::kNoError;
   }
   GLenum type = 0;
   GLenum format = 0;
   if (!info->GetLevelType(target, level, &type, &format) ||
       !info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTexSubImage2D", "bad dimensions.");
-    return;
+    return error::kNoError;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(format);
 
   if (!channels_needed ||
       (channels_needed & channels_exist) != channels_needed) {
     SetGLError(
         GL_INVALID_OPERATION, "glCopyTexSubImage2D", "incompatible format");
-    return;
+    return error::kNoError;
   }
 
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glCopySubImage2D", "can not be used with depth or stencil textures");
-    return;
+    return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid("glCopyTexSubImage2D")) {
-    return;
+    return error::kNoError;
   }
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
     SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D", "dimensions too big");
-    return;
+    return error::kNoError;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSizes(
         width, height, format, type, state_.unpack_alignment, &pixels_size,
         NULL, NULL)) {
       SetGLError(
           GL_INVALID_VALUE, "glCopyTexSubImage2D", "dimensions too large");
-      return;
+      return error::kNoError;
     }
     scoped_array<char> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
     GLint dx = copyX - x;
     GLint dy = copyY - y;
     GLint destX = xoffset + dx;
     GLint destY = yoffset + dy;
     glCopyTexSubImage2D(target, level,
                         destX, destY, copyX, copyY,
                         copyWidth, copyHeight);
   }
+  return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
@@ skipping 1690 matching lines @@
   gpu_trace_stack_.pop();
 }
 
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu