Support copying a partial rectangle region from the compositing surface on Aura and GTK.

content/common/gpu/client/gl_helper.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 "content/common/gpu/client/gl_helper.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
 using WebKit::WebGLId;
 using WebKit::WebGraphicsContext3D;
 
 namespace {
 
 const char kGLHelperThreadName[] = "GLHelperThread";
 
@@ skipping 217 matching lines @@
   ~CopyTextureToImpl() {
     CancelRequests();
     DeleteContextForThread();
   }
 
   void InitBuffer();
   void InitProgram();
 
   void CopyTextureTo(WebGLId src_texture,
                      const gfx::Size& src_size,
+                     const gfx::Rect& src_subrect,
                      const gfx::Size& dst_size,
                      unsigned char* out,
                      const base::Callback<void(bool)>& callback);
  private:
   // A single request to CopyTextureTo.
   // Thread-safety notes: the main thread creates instances of this class. The
   // main thread can cancel the request, before it's handled by the helper
   // thread, by resetting the texture and pixels fields. Alternatively, the
   // thread marks that it handles the request by resetting the pixels field
   // (meaning it guarantees that the callback with be called).
@@ skipping 21 matching lines @@
     // Locks access to below members, which can be accessed on any thread.
     base::Lock lock;
     WebGLId texture;
     unsigned char* pixels;
 
    private:
     friend class base::RefCountedThreadSafe<Request>;
     ~Request() {}
   };
 
-  // Returns the id of a framebuffer that
+  // Copies the block of pixels specified with |src_subrect| from |src_texture|,
+  // scales it to |dst_size|, writes it into a texture, and returns its ID.
+  // |src_size| is the size of |src_texture|.
   WebGLId ScaleTexture(WebGLId src_texture,
-                               const gfx::Size& src_size,
-                               const gfx::Size& dst_size);
+                       const gfx::Size& src_size,
+                       const gfx::Rect& src_subrect,
+                       const gfx::Size& dst_size);
 
   // Deletes the context for GLHelperThread.
   void DeleteContextForThread();
   static void ReadBackFramebuffer(scoped_refptr<Request> request,
                                   WebGraphicsContext3D* context,
                                   scoped_refptr<base::TaskRunner> reply_loop);
   static void ReadBackFramebufferComplete(scoped_refptr<Request> request,
                                           bool result);
   void FinishRequest(scoped_refptr<Request> request);
   void CancelRequests();
@@ skipping 16 matching lines @@
   ScopedProgram program_;
   // The buffer that holds the vertices and the texture coordinates data for
   // drawing a quad.
   ScopedBuffer vertex_attributes_buffer_;
   // The location of the position in the program.
   WebKit::WGC3Dint position_location_;
   // The location of the texture coordinate in the program.
   WebKit::WGC3Dint texcoord_location_;
   // The location of the source texture in the program.
   WebKit::WGC3Dint texture_location_;
+  // The location of the texture coordinate of the sub-rectangle in the program.
+  WebKit::WGC3Dint src_subrect_location_;
   std::queue<scoped_refptr<Request> > request_queue_;
 };
 
 const WebKit::WGC3Dfloat GLHelper::CopyTextureToImpl::kVertexAttributes[] = {
   -1.0f, -1.0f, 0.0f, 0.0f,
   1.0f, -1.0f, 1.0f, 0.0f,
   -1.0f, 1.0f, 0.0f, 1.0f,
   1.0f, 1.0f, 1.0f, 1.0f,
 };
 
 const WebKit::WGC3Dchar GLHelper::CopyTextureToImpl::kCopyVertexShader[] =
     "attribute vec2 a_position;"
     "attribute vec2 a_texcoord;"
     "varying vec2 v_texcoord;"
     "void main() {"
     "  gl_Position = vec4(a_position, 0.0, 1.0);"
     "  v_texcoord = a_texcoord;"
     "}";
 
 const WebKit::WGC3Dchar GLHelper::CopyTextureToImpl::kCopyFragmentShader[] =
     "precision mediump float;"
     "varying vec2 v_texcoord;"
+    "uniform vec4 src_subrect;"
     "uniform sampler2D s_texture;"
     "void main() {"
-    "  gl_FragColor = texture2D(s_texture, v_texcoord);"
+    "  gl_FragColor = texture2D(s_texture,"
+    "                           src_subrect.xy + v_texcoord * src_subrect.zw);"

[piman, 2012/07/26 00:04:51]

It would be better to do the UV transformation in the vertex shader.
If you do it in the fragment shader, you pay for it at each pixel, whereas if
you do it in the vertex shader, then you only pay it for each vertex (i.e. 4
times total).

[mazda, 2012/07/26 02:20:04]

Oh, that's right. Fixed.

     "}";
 
 void GLHelper::CopyTextureToImpl::InitBuffer() {
   ScopedBufferBinder<GL_ARRAY_BUFFER> buffer_binder(
       context_, vertex_attributes_buffer_);
   context_->bufferData(GL_ARRAY_BUFFER,
                        sizeof(kVertexAttributes),
                        kVertexAttributes,
                        GL_STATIC_DRAW);
 }
@@ skipping 13 matching lines @@
   WebKit::WGC3Dint link_status = 0;
   context_->getProgramiv(program_, GL_LINK_STATUS, &link_status);
   if (!link_status) {
     LOG(ERROR) << std::string(context_->getProgramInfoLog(program_).utf8());
     return;
   }
 
   position_location_ = context_->getAttribLocation(program_, "a_position");
   texcoord_location_ = context_->getAttribLocation(program_, "a_texcoord");
   texture_location_ = context_->getUniformLocation(program_, "s_texture");
+  src_subrect_location_ = context_->getUniformLocation(program_, "src_subrect");
 }
 
 WebGLId GLHelper::CopyTextureToImpl::ScaleTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
+    const gfx::Rect& src_subrect,
     const gfx::Size& dst_size) {
   WebGLId dst_texture = context_->createTexture();
   {
     ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
     ScopedFramebufferBinder<GL_DRAW_FRAMEBUFFER> framebuffer_binder(
         context_, dst_framebuffer);
     {
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
           context_, dst_texture);
       context_->texImage2D(GL_TEXTURE_2D,
@@ skipping 32 matching lines @@
     context_->vertexAttribPointer(texcoord_location_,
                                   2,
                                   GL_FLOAT,
                                   GL_FALSE,
                                   4 * sizeof(WebKit::WGC3Dfloat),
                                   offset);
     context_->enableVertexAttribArray(texcoord_location_);
 
     context_->uniform1i(texture_location_, 0);
 
+    // Convert |src_subrect| to texture coordinates.
+    GLfloat src_subrect_texcoord[] = {
+      static_cast<float>(src_subrect.x()) / src_size.width(),
+      static_cast<float>(src_subrect.y()) / src_size.height(),
+      static_cast<float>(src_subrect.width()) / src_size.width(),
+      static_cast<float>(src_subrect.height()) / src_size.height(),
+    };
+    context_->uniform4fv(src_subrect_location_, 1, src_subrect_texcoord);
+
     // Conduct texture mapping by drawing a quad composed of two triangles.
     context_->drawArrays(GL_TRIANGLE_STRIP, 0, 4);
   }
   return dst_texture;
 }
 
 void GLHelper::CopyTextureToImpl::DeleteContextForThread() {
   if (!context_for_thread_)
     return;
 
   g_gl_helper_thread.Pointer()->message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DeleteContext,
                  context_for_thread_));
   context_for_thread_ = NULL;
 }
 
 void GLHelper::CopyTextureToImpl::CopyTextureTo(
     WebGLId src_texture,
     const gfx::Size& src_size,
+    const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const base::Callback<void(bool)>& callback) {
   if (!context_for_thread_) {
     callback.Run(false);
     return;
   }
 
-  WebGLId texture = ScaleTexture(src_texture, src_size, dst_size);
+  WebGLId texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size);
   context_->flush();
   scoped_refptr<Request> request =
       new Request(this, texture, dst_size, out, callback);
   request_queue_.push(request);
 
   g_gl_helper_thread.Pointer()->message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(&ReadBackFramebuffer,
                  request,
                  context_for_thread_,
                  base::MessageLoopProxy::current()));
@@ skipping 127 matching lines @@
     event.Wait();
   }
 }
 
 WebGraphicsContext3D* GLHelper::context() const {
   return context_;
 }
 
 void GLHelper::CopyTextureTo(WebGLId src_texture,
                              const gfx::Size& src_size,
+                             const gfx::Rect& src_subrect,
                              const gfx::Size& dst_size,
                              unsigned char* out,
                              const base::Callback<void(bool)>& callback) {
   // Lazily initialize |copy_texture_to_impl_|
   if (!copy_texture_to_impl_.get())
     copy_texture_to_impl_.reset(new CopyTextureToImpl(context_,
                                                       context_for_thread_,
                                                       this));
 
   copy_texture_to_impl_->CopyTextureTo(src_texture,
                                        src_size,
+                                       src_subrect,
                                        dst_size,
                                        out,
                                        callback);
 }
 
 WebGLId GLHelper::CompileShaderFromSource(
     const WebKit::WGC3Dchar* source,
     WebKit::WGC3Denum type) {
   ScopedShader shader(context_, context_->createShader(type));
   context_->shaderSource(shader, source);
   context_->compileShader(shader);
   WebKit::WGC3Dint compile_status = 0;
   context_->getShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     LOG(ERROR) << std::string(context_->getShaderInfoLog(shader).utf8());
     return 0;
   }
   return shader.Detach();
 }
 
 }  // namespace content