Add RGB565 Texture readback support in 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 121 matching lines @@
                                   uint32 sync_point) {
     return helper_->ConsumeMailboxToTexture(mailbox, sync_point);
   }
 
   void CropScaleReadbackAndCleanTexture(
       WebGLId src_texture,
       const gfx::Size& src_size,
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       unsigned char* out,
+      bool readback_config_rgb565,
       const base::Callback<void(bool)>& callback,
       GLHelper::ScalerQuality quality);
 
   void ReadbackTextureSync(WebGLId texture,
                            const gfx::Rect& src_rect,
                            unsigned char* out);
 
   // Reads back bytes from the currently bound frame buffer.
   // Note that dst_size is specified in bytes, not pixels.
   void ReadbackAsync(
       const gfx::Size& dst_size,
       int32 bytes_per_row,     // generally dst_size.width() * 4
       int32 row_stride_bytes,  // generally dst_size.width() * 4
       unsigned char* out,
+      bool readback_config_rgb565,
       const base::Callback<void(bool)>& callback);
 
   void ReadbackPlane(TextureFrameBufferPair* source,
                      const scoped_refptr<media::VideoFrame>& target,
                      int plane,
                      int size_shift,
                      const gfx::Rect& dst_subrect,
                      const base::Callback<void(bool)>& callback);
 
   blink::WebGLId CopyAndScaleTexture(WebGLId texture,
@@ skipping 132 matching lines @@
 
   // 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::Rect& src_subrect,
                        const gfx::Size& dst_size,
                        bool vertically_flip_texture,
                        bool swizzle,
+                       bool  readback_config_rgb565,

[no sievers, 2014/01/07 16:26:02]

nit: two spaces

[sivag, 2014/01/09 14:51:50]

DOne.

                        GLHelper::ScalerQuality quality);
 
   static void nullcallback(bool success) {}
-  void ReadbackDone(Request *request);
+  void ReadbackDone(Request *request,int bytes_per_pixel);

[no sievers, 2014/01/07 16:26:02]

nit: space after comma missing

[sivag, 2014/01/09 14:51:50]

Done.

   void FinishRequest(Request* request, bool result);
   void CancelRequests();
 
   static const float kRGBtoYColorWeights[];
   static const float kRGBtoUColorWeights[];
   static const float kRGBtoVColorWeights[];
 
   WebGraphicsContext3D* context_;
   gpu::ContextSupport* context_support_;
   GLHelper* helper_;
@@ skipping 22 matching lines @@
                                     swizzle);
 }
 
 WebGLId GLHelper::CopyTextureToImpl::ScaleTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     bool swizzle,
+    bool  readback_config_rgb565,

[no sievers, 2014/01/07 16:26:02]

nit: two spaces

[sivag, 2014/01/09 14:51:50]

Done

     GLHelper::ScalerQuality quality) {
   scoped_ptr<ScalerInterface> scaler(
       helper_->CreateScaler(quality,
                             src_size,
                             src_subrect,
                             dst_size,
                             vertically_flip_texture,
                             swizzle));
 
   WebGLId dst_texture = context_->createTexture();
   {
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, dst_texture);
-    context_->texImage2D(GL_TEXTURE_2D,
-                         0,
-                         GL_RGBA,
-                         dst_size.width(),
-                         dst_size.height(),
-                         0,
-                         GL_RGBA,
-                         GL_UNSIGNED_BYTE,
-                         NULL);
-  }
+    if(readback_config_rgb565){

[no sievers, 2014/01/07 16:26:02]

nit: space missing

[sivag, 2014/01/09 14:51:50]

Done.

+      context_->texImage2D(GL_TEXTURE_2D,
+                           0,
+                           GL_RGB,
+                           dst_size.width(),
+                           dst_size.height(),
+                           0,
+                           GL_RGB,
+                           GL_UNSIGNED_SHORT_5_6_5,
+                           NULL);
+    }else{

[no sievers, 2014/01/07 16:26:02]

nit: spaces missing

[sivag, 2014/01/09 14:51:50]

Done.

+      context_->texImage2D(GL_TEXTURE_2D,
+                           0,
+                           GL_RGBA,
+                           dst_size.width(),
+                           dst_size.height(),
+                           0,
+                           GL_RGBA,
+                           GL_UNSIGNED_BYTE,
+                           NULL);
+    }
+}
   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,
+    bool readback_config_rgb565,
     const base::Callback<void(bool)>& callback) {

[no sievers, 2014/01/07 16:26:02]

Can you add a check for GL_IMPLEMENTATION_COLOR_READ_FORMAT like you do below
here and fail this with a logged error if 565 is not supported?

[sivag, 2014/01/09 14:51:50]

Is this needed as we are already doing the check and failing it
in the begining of copyfromcomposiitingsurface( in
renderer_widget_host_view_anddroid.cc

   Request* request = new Request(dst_size,
                                  bytes_per_row,
                                  row_stride_bytes,
                                  out,
                                  callback);
   request_queue_.push(request);
   request->buffer = context_->createBuffer();
+  int bytes_per_pixel = readback_config_rgb565 ? 2 : 4;
   context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                        request->buffer);
   context_->bufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                       4 * dst_size.GetArea(),
+                       bytes_per_pixel * dst_size.GetArea(),
                        NULL,
                        GL_STREAM_READ);
-
   request->query = context_->createQueryEXT();
   context_->beginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM,
                           request->query);
-  context_->readPixels(0, 0, dst_size.width(), dst_size.height(),
+  if(readback_config_rgb565){

[no sievers, 2014/01/07 16:26:02]

nit: space missing in between ')' and '{'

[sivag, 2014/01/09 14:51:50]

Done.

+    context_->readPixels(0, 0, dst_size.width(), dst_size.height(),
+                       GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);

[no sievers, 2014/01/07 16:26:02]

nit: indent here and in 425. 

[sivag, 2014/01/09 14:51:50]

Done.

+  }else{
+    context_->readPixels(0, 0, dst_size.width(), dst_size.height(),
                        GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+  }
   context_->endQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
   context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
   context_support_->SignalQuery(
       request->query,
-      base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(), request));
+      base::Bind(&CopyTextureToImpl::ReadbackDone, AsWeakPtr(),
+                 request, bytes_per_pixel));
 }
-
-
 void GLHelper::CopyTextureToImpl::CropScaleReadbackAndCleanTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
+    bool readback_config_rgb565,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
   WebGLId texture = ScaleTexture(src_texture,
                                  src_size,
                                  src_subrect,
                                  dst_size,
                                  true,
 #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
                                  true,
 #else
                                  false,
 #endif
+                                 readback_config_rgb565,
                                  quality);
   ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(context_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                  GL_COLOR_ATTACHMENT0,
                                  GL_TEXTURE_2D,
                                  texture,
                                  0);
+  int bytes_per_pixel = readback_config_rgb565 ? 2 : 4;
   ReadbackAsync(dst_size,
-                dst_size.width() * 4,
-                dst_size.width() * 4,
+                dst_size.width() * bytes_per_pixel,
+                dst_size.width() * bytes_per_pixel,
                 out,
+                readback_config_rgb565,
                 callback);
   context_->deleteTexture(texture);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackTextureSync(
     WebGLId texture,
     const gfx::Rect& src_rect,
     unsigned char* out) {
   ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(context_,
@@ skipping 18 matching lines @@
     const gfx::Size& src_size,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     GLHelper::ScalerQuality quality) {
   return ScaleTexture(src_texture,
                       src_size,
                       gfx::Rect(src_size),
                       dst_size,
                       vertically_flip_texture,
                       false,
+                      false,
                       quality);
 }
 
-void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request) {
+void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request,
+                                               int bytes_per_pixel) {
   TRACE_EVENT0("mirror",
                "GLHelper::CopyTextureToImpl::CheckReadbackFramebufferComplete");
   finished_request->done = true;
 
   // We process transfer requests in the order they were received, regardless
   // of the order we get the callbacks in.
   while (!request_queue_.empty()) {
     Request* request = request_queue_.front();
     if (!request->done) {
       break;
     }
 
     bool result = false;
     if (request->buffer != 0) {
       context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                            request->buffer);
       unsigned char* data = static_cast<unsigned char *>(
           context_->mapBufferCHROMIUM(
               GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
       if (data) {
         result = true;
-        if (request->bytes_per_row == request->size.width() * 4 &&
+        if (request->bytes_per_row == request->size.width() * bytes_per_pixel &&
             request->bytes_per_row == request->row_stride_bytes) {
-          memcpy(request->pixels, data, request->size.GetArea() * 4);
+          memcpy(request->pixels, data,
+                 request->size.GetArea() * bytes_per_pixel);
         } else {
           unsigned char* out = request->pixels;
           for (int y = 0; y < request->size.height(); y++) {
             memcpy(out, data, request->bytes_per_row);
             out += request->row_stride_bytes;
-            data += request->size.width() * 4;
+            data += request->size.width() * bytes_per_pixel;
           }
         }
         context_->unmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
       }
       context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
     }
 
     FinishRequest(request, result);
   }
 }
@@ skipping 31 matching lines @@
 
 GLHelper::~GLHelper() {
 }
 
 void GLHelper::CropScaleReadbackAndCleanTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
+    bool readback_config_rgb565,
     const base::Callback<void(bool)>& callback) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->CropScaleReadbackAndCleanTexture(
       src_texture,
       src_size,
       src_subrect,
       dst_size,
       out,
+      readback_config_rgb565,
       callback,
       GLHelper::SCALER_QUALITY_FAST);
 }
 
 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,
+    bool readback_config_rgb565,
     const base::Callback<void(bool)>& callback) {
   WebGLId mailbox_texture = ConsumeMailboxToTexture(src_mailbox, sync_point);
   CropScaleReadbackAndCleanTexture(
-      mailbox_texture, src_size, src_subrect, dst_size, out, callback);
+      mailbox_texture, src_size, src_subrect, dst_size, out,
+      readback_config_rgb565,
+      callback);
   context_->deleteTexture(mailbox_texture);
 }
 
 void GLHelper::ReadbackTextureSync(blink::WebGLId texture,
                                    const gfx::Rect& src_rect,
                                    unsigned char* out) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->ReadbackTextureSync(texture,
                                              src_rect,
                                              out);
@@ skipping 149 matching lines @@
 }
 
 void GLHelper::CopyTextureFullImage(blink::WebGLId texture,
                                     const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->copyTexImage2D(GL_TEXTURE_2D, 0,
                            GL_RGB,
                            0, 0,
                            size.width(), size.height(), 0);
 }
-
+bool GLHelper::CanUseRgb565Readback() {
+  const int test_size = 100;

[no sievers, 2014/01/07 16:26:02]

Can you use something power of two? 

[sivag, 2014/01/09 14:51:50]

Done.

+  WebGLId dst_texture = context_->createTexture();
+  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, dst_texture);
+  context_->texImage2D(GL_TEXTURE_2D,

[no sievers, 2014/01/07 16:26:02]

nit: indent

[sivag, 2014/01/09 14:51:50]

Done.

+                      0,
+                      GL_RGB,
+                      test_size,
+                      test_size,
+                      0,
+                      GL_RGB,
+                      GL_UNSIGNED_SHORT_5_6_5,
+                      NULL);

[no sievers, 2014/01/07 16:26:02]

The texture is incomplete because the default min_filter is
NEAREST_MIPMAP_LINEAR but you didn't define mipmaps.

I'd just set MIN_/MAG_FILTER to linear (and also set WRAP_S/_T to CLAMP_TO_EDGE)
here.

[sivag, 2014/01/09 14:51:50]

Done.

+  ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
+  ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(context_,
+                                                             dst_framebuffer);
+  context_->framebufferTexture2D(GL_FRAMEBUFFER,
+                                 GL_COLOR_ATTACHMENT0,
+                                 GL_TEXTURE_2D,
+                                 dst_texture,
+                                 0);
+  int ext_format, ext_type;
+  context_->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &ext_format);
+  context_->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &ext_type);
+  context_->deleteTexture(dst_texture);
+  return ((ext_format == GL_RGB) && (ext_type == GL_UNSIGNED_SHORT_5_6_5));
+}
 void GLHelper::CopyTextureToImpl::ReadbackPlane(
     TextureFrameBufferPair* source,
     const scoped_refptr<media::VideoFrame>& target,
     int plane,
     int size_shift,
     const gfx::Rect& dst_subrect,
     const base::Callback<void(bool)>& callback) {
   context_->bindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
   size_t offset = target->stride(plane) * (dst_subrect.y() >> size_shift) +
       (dst_subrect.x() >> size_shift);
   ReadbackAsync(
       source->size(),
       dst_subrect.width() >> size_shift,
       target->stride(plane),
       target->data(plane) + offset,
+      false,
       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[] = {
@@ skipping 298 matching lines @@
       quality,
       src_size,
       src_subrect,
       dst_size,
       dst_subrect,
       flip_vertically,
       use_mrt);
 }
 
 }  // namespace content