Improving GestureNav screenshotting performance - Part 1 - gl_helper

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 <string>
 
 #include "base/bind.h"
@@ skipping 123 matching lines @@
                                  uint32 sync_point) {
     return helper_->ConsumeMailboxToTexture(mailbox, sync_point);
   }
 
   void CropScaleReadbackAndCleanTexture(
       GLuint src_texture,
       const gfx::Size& src_size,
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       unsigned char* out,
-      const SkColorType color_type,
+      const SkColorType out_color_type,
       const base::Callback<void(bool)>& callback,
       GLHelper::ScalerQuality quality);
 
   void ReadbackTextureSync(GLuint texture,
                            const gfx::Rect& src_rect,
                            unsigned char* out,
                            SkColorType format);
 
   void ReadbackTextureAsync(GLuint texture,
                             const gfx::Size& dst_size,
@@ skipping 157 matching lines @@
   // |src_size| is the size of |src_texture|.
   GLuint ScaleTexture(GLuint src_texture,
                       const gfx::Size& src_size,
                       const gfx::Rect& src_subrect,
                       const gfx::Size& dst_size,
                       bool vertically_flip_texture,
                       bool swizzle,
                       SkColorType color_type,
                       GLHelper::ScalerQuality quality);
 
+  // Converts each four consecutive pixels of the source texture into one pixel
+  // in the result texture with each pixel channel representing the grayscale
+  // color of one of the four original pixels:
+  // R1B1G1A1 R2B2G2A2 R3B3G3A3 R4G4B4A4 -> X1X2X3X4
+  GLuint TransformTextureToGrayscale(GLuint src_texture,
+                                     const gfx::Size& src_size,
+                                     const gfx::Rect& src_subrect,
+                                     bool swizzle);
+
   static void nullcallback(bool success) {}
   void ReadbackDone(Request *request, int bytes_per_pixel);
   void FinishRequest(Request* request, bool result);
   void CancelRequests();
 
   static const float kRGBtoYColorWeights[];
   static const float kRGBtoUColorWeights[];
   static const float kRGBtoVColorWeights[];
+  static const float kRGBtoGrayscaleColorWeights[];
 
   GLES2Interface* gl_;
   gpu::ContextSupport* context_support_;
   GLHelper* helper_;
 
   // A scoped flush that will ensure all resource deletions are flushed when
   // this object is destroyed. Must be declared before other Scoped* fields.
   ScopedFlush flush_;
 
   std::queue<Request*> request_queue_;
@@ skipping 60 matching lines @@
                     dst_size.height(),
                     0,
                     format,
                     type,
                     NULL);
   }
   scaler->Scale(src_texture, dst_texture);
   return dst_texture;
 }
 
+GLuint GLHelper::CopyTextureToImpl::TransformTextureToGrayscale(
+    GLuint src_texture,
+    const gfx::Size& src_size,
+    const gfx::Rect& src_subrect,

[no sievers, 2014/07/15 19:31:49]

|src_subrect| is ignored below?

[mfomitchev, 2014/07/16 19:16:07]

Done.

+    bool swizzle) {
+  LOG(ERROR) << "GLHelper::CopyTextureToImpl::TransformTextureToGrayscale";
+
+  GLuint dst_texture = 1u;

[mfomitchev, 2014/07/11 20:21:33]

Should we set the id to 0 instead of 1 here? Does it matter?

[no sievers, 2014/07/15 19:31:49]

Yea I'd init to 0, it's what we do in other places.

[mfomitchev, 2014/07/16 19:16:06]

Done.

+  gl_->GenTextures(1, &dst_texture);
+  {
+    ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
+    gl_->TexImage2D(GL_TEXTURE_2D,
+                    0,
+                    GL_BGRA_EXT,
+                    src_size.width(),
+                    src_size.height(),

[no sievers, 2014/07/15 19:31:49]

This is the wrong size, shouldn't it be a fourth of it?

[mfomitchev, 2014/07/16 19:16:06]

Done.

+                    0,
+                    GL_BGRA_EXT,
+                    GL_UNSIGNED_BYTE,
+                    NULL);
+  }
+
+  helper_->InitScalerImpl();
+  scoped_ptr<ScalerInterface> grayscale_scaler(
+      helper_->scaler_impl_.get()->CreatePlanarScaler(
+          src_size,
+          gfx::Rect(0, 0, (src_size.width() + 3) & ~3, src_size.height()),
+          gfx::Size((src_size.width() + 3) / 4, src_size.height()),
+          false,
+          (swizzle == kSwizzleBGRA),
+          kRGBtoGrayscaleColorWeights));
+  grayscale_scaler->Scale(src_texture, dst_texture);
+  return dst_texture;
+}
+
 void GLHelper::CopyTextureToImpl::ReadbackAsync(
     const gfx::Size& dst_size,
     int32 bytes_per_row,
     int32 row_stride_bytes,
     unsigned char* out,
     const SkColorType color_type,
     ReadbackSwizzle swizzle,
     const base::Callback<void(bool)>& callback) {
-  if (!IsReadbackConfigSupported(color_type)) {
+  if (color_type != kAlpha_8_SkColorType &&
+      !IsReadbackConfigSupported(color_type)) {
     callback.Run(false);
     return;
   }
-  Request* request =
-      new Request(dst_size, bytes_per_row, row_stride_bytes, out, callback);
-  request_queue_.push(request);
-  request->buffer = 0u;
+
   // Start with ARGB8888 params as any other format which is not
   // supported is already asserted above.
   GLenum format = GL_RGBA, type = GL_UNSIGNED_BYTE;
   int bytes_per_pixel = 4;
 
+  gfx::Size readback_size = dst_size;
   switch (color_type) {
     case kN32_SkColorType:
       if (swizzle == kSwizzleBGRA)
         format = GL_BGRA_EXT;
       break;
     case kRGB_565_SkColorType:
       format = GL_RGB;
       type = GL_UNSIGNED_SHORT_5_6_5;
       bytes_per_pixel = 2;
       break;
+    case kAlpha_8_SkColorType:
+      // For readback purposes, treat the texture as BGRA of smaller size.
+      format = GL_BGRA_EXT;
+      bytes_per_pixel = 4;
+      readback_size.set_width((dst_size.width() + 3) / 4);
     default:
       NOTREACHED();
       break;
   }
+
+  Request* request = new Request(
+      readback_size, bytes_per_row, row_stride_bytes, out, callback);
+  request_queue_.push(request);
+  request->buffer = 0u;
   gl_->GenBuffers(1, &request->buffer);
   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, request->buffer);
   gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                  bytes_per_pixel * dst_size.GetArea(),
+                  bytes_per_pixel * readback_size.GetArea(),
                   NULL,
                   GL_STREAM_READ);
 
   request->query = 0u;
   gl_->GenQueriesEXT(1, &request->query);
   gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, request->query);
-  gl_->ReadPixels(0,
-                  0,
-                  dst_size.width(),
-                  dst_size.height(),
-                  format,
-                  type,
-                  NULL);
+  gl_->ReadPixels(
+      0, 0, readback_size.width(), readback_size.height(), format, type, NULL);
   gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
   gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
   context_support_->SignalQuery(
       request->query,
       base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(),
                  request, bytes_per_pixel));
 }
+
 void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
-    const SkColorType color_type,
+    const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
-  if (!IsReadbackConfigSupported(color_type)) {
+  if (out_color_type != kAlpha_8_SkColorType &&
+      !IsReadbackConfigSupported(out_color_type)) {
     callback.Run(false);
     return;
   }
-  GLuint texture = ScaleTexture(src_texture,
-                                src_size,
-                                src_subrect,
-                                dst_size,
-                                true,
+
+  bool swizzle =
 #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
-                                true,
+      true;
 #else
-                                false,
+      false;
 #endif
-                                color_type,
-                                quality);
+
+  GLuint texture =
+      ScaleTexture(src_texture,
+                   src_size,
+                   src_subrect,
+                   dst_size,
+                   true,
+                   swizzle,
+                   out_color_type == kAlpha_8_SkColorType ? kN32_SkColorType

[no sievers, 2014/07/15 19:31:49]

This seems wrong for Alpha_8. If you are using the native byte order
(kN32_SkColorType), doesn't that mean |swizzle| should be false?

[mfomitchev, 2014/07/16 19:16:06]

Done.

+                                                          : out_color_type,
+                   quality);
   DCHECK(texture);
+
+  if (out_color_type == kAlpha_8_SkColorType) {
+    texture =
+        TransformTextureToGrayscale(texture, src_size, src_subrect, swizzle);

[no sievers, 2014/07/15 19:31:49]

+hubbe to comment if this can be done in a single pass with the scaling above

[hubbe, 2014/07/15 21:05:56]

It can, iff quality is SCALER_QUALITY_FAST, search for "optimization:" below for
another example of this.

[mfomitchev, 2014/07/16 19:16:06]

Done. Also added vertically_flip_texture to EncodeTextureAsGrayscale to take
care of the  flip when we don't do scaling.

[mfomitchev, 2014/07/16 19:16:06]

Also fixed: the second arg should be dst_size, not src_size.

+
+    DCHECK(texture);
+  }
   ScopedFramebuffer dst_framebuffer(gl_);
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
                             GL_COLOR_ATTACHMENT0,
                             GL_TEXTURE_2D,
                             texture,
                             0);
   int bytes_per_pixel = 4;
-  switch (color_type) {
+  switch (out_color_type) {
     case kN32_SkColorType:
       // Do nothing params already set.
       break;
     case kRGB_565_SkColorType:
       bytes_per_pixel = 2;
       break;
+    case kAlpha_8_SkColorType:
+      bytes_per_pixel = 1;
+      break;
     default:
       NOTREACHED();
       break;
   }
   ReadbackAsync(dst_size,
                 dst_size.width() * bytes_per_pixel,
                 dst_size.width() * bytes_per_pixel,
                 out,
-                color_type,
+                out_color_type,
                 kSwizzleNone,
                 callback);
   gl_->DeleteTextures(1, &texture);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackTextureSync(
     GLuint texture,
     const gfx::Rect& src_rect,
     unsigned char* out,
     SkColorType color_type) {
@@ skipping 144 matching lines @@
       readback_support_(new GLHelperReadbackSupport(gl)) {}
 
 GLHelper::~GLHelper() {}
 
 void GLHelper::CropScaleReadbackAndCleanTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
-    const SkColorType color_type,
+    const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   InitCopyTextToImpl();
-  copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(
-      src_texture,
-      src_size,
-      src_subrect,
-      dst_size,
-      out,
-      color_type,
-      callback,
-      quality);
+  copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(src_texture,
+                                                          src_size,
+                                                          src_subrect,
+                                                          dst_size,
+                                                          out,
+                                                          out_color_type,
+                                                          callback,
+                                                          quality);
 }
 
 void GLHelper::CropScaleReadbackAndCleanMailbox(
     const gpu::Mailbox& src_mailbox,
     uint32 sync_point,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
-    const SkColorType color_type,
+    const SkColorType out_color_type,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   GLuint mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_point);
   CropScaleReadbackAndCleanTexture(
       mailbox_texture, src_size, src_subrect, dst_size, out,
-      color_type,
+      out_color_type,
       callback,
       quality);
   gl_->DeleteTextures(1, &mailbox_texture);
 }
 
 void GLHelper::ReadbackTextureSync(GLuint texture,
                                    const gfx::Rect& src_rect,
                                    unsigned char* out,
                                    SkColorType format) {
   InitCopyTextToImpl();
@@ skipping 197 matching lines @@
                 swizzle,
                 callback);
 }
 
 const float GLHelper::CopyTextureToImpl::kRGBtoYColorWeights[] = {
     0.257f, 0.504f, 0.098f, 0.0625f};
 const float GLHelper::CopyTextureToImpl::kRGBtoUColorWeights[] = {
     -0.148f, -0.291f, 0.439f, 0.5f};
 const float GLHelper::CopyTextureToImpl::kRGBtoVColorWeights[] = {
     0.439f, -0.368f, -0.071f, 0.5f};
+const float GLHelper::CopyTextureToImpl::kRGBtoGrayscaleColorWeights[] = {
+    0.213f, 0.715f, 0.072f, 0.0f};
 
 // YUV readback constructors. Initiates the main scaler pipeline and
 // one planar scaler for each of the Y, U and V planes.
 GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUVImpl(
     GLES2Interface* gl,
     CopyTextureToImpl* copy_impl,
     GLHelperScaling* scaler_impl,
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
@@ skipping 312 matching lines @@
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
                                                           src_size,
                                                           src_subrect,
                                                           dst_size,
                                                           dst_subrect,
                                                           flip_vertically,
                                                           use_mrt);
 }
 
 }  // namespace content