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);
 
+  WebGLId CopyTo565Texture(const gfx::Size& dst_size);
+
   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,
+      int readback_factor,
       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 135 matching lines @@
   // |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,
                        GLHelper::ScalerQuality quality);
 
   static void nullcallback(bool success) {}
-  void ReadbackDone(Request *request);
+  void ReadbackDone(Request *request,int readback_factor);
   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 43 matching lines @@
     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);
-  }
+}
   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,
+    int readback_factor,

[hubbe, 2013/12/26 21:41:49]

readback_factor is redundant and not well named.
Just do something like:
int bytes_per_pixel = readback_config_rgb565 ? 2 : 4;
inside the function instead.

     const base::Callback<void(bool)>& callback) {
   Request* request = new Request(dst_size,
                                  bytes_per_row,
                                  row_stride_bytes,
                                  out,
                                  callback);
   request_queue_.push(request);
   request->buffer = context_->createBuffer();
   context_->bindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
                        request->buffer);
   context_->bufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                       4 * dst_size.GetArea(),
+                       readback_factor * 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){
+    context_->readPixels(0, 0, dst_size.width(), dst_size.height(),
+                       GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
+  }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, readback_factor));
 }
-
-
+WebGLId GLHelper::CopyTextureToImpl::CopyTo565Texture(const gfx::Size& dst_size)
+{
+  //Using copy to texture

[hubbe, 2013/12/26 21:41:49]

Nit: Space after //

+  WebGLId dst_rgb_565_texture = context_->createTexture();
+  {
+    ScopedTextureBinder<GL_TEXTURE_2D> rgb_texture_binder(context_,
+                                                          dst_rgb_565_texture);
+    context_->texImage2D(GL_TEXTURE_2D,
+                         0,
+                         GL_RGB,
+                         dst_size.width(),
+                         dst_size.height(),
+                         0,
+                         GL_RGB,
+                         GL_UNSIGNED_SHORT_5_6_5,
+                         NULL);
+    context_->copyTexSubImage2D(GL_TEXTURE_2D, 0,
+                                0, 0,
+                                0, 0,
+                                dst_size.width(), dst_size.height());
+  }
+  return dst_rgb_565_texture;
+}
 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
                                  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 readback_factor = 0;

[hubbe, 2013/12/26 21:41:49]

readback_factor -> bytes_per_pixel

+  if(readback_config_rgb565){
+    readback_factor = 2;
+  }else{
+    readback_factor = 4;
+  }
+  WebGLId dst_rgb_565_texture = 0;
+  if(readback_config_rgb565){
+    dst_rgb_565_texture = CopyTo565Texture(dst_size);

[hubbe, 2013/12/26 21:41:49]

It would (probably) be faster to have the scaler write into a 565 texture
directly instead of scaling and then copying.

+    ScopedTextureBinder<GL_TEXTURE_2D> rgb_texture_binder(context_,
+                                                          dst_rgb_565_texture);
+    context_->framebufferTexture2D(GL_FRAMEBUFFER,
+                                   GL_COLOR_ATTACHMENT0,
+                                   GL_TEXTURE_2D,
+                                   dst_rgb_565_texture,
+                                   0);
+    //Check format of read after binding with fbo.

[hubbe, 2013/12/26 21:41:49]

Space after //

+    int ext_format, ext_type;
+    context_->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &ext_format);
+    context_->getIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &ext_type);
+    if((ext_format != GL_RGB) || (ext_type != GL_UNSIGNED_SHORT_5_6_5)){

[hubbe, 2013/12/26 21:41:49]

This is the wrong place to detect this.
This detection should happen long before this function is ever called.
Also, we need to make sure that we can render into/copy to 565 textures before
calling CopyTo565Texure, right?

I suggest that we add a function like: CanUseRgb565Readback() that does the
testing, so that the caller can check if 565 readback is supporting before
decinging to use the "readback_config_rgb565" parameter.

PS: There is an alternate way to do this that is *always* supported on GLES2:
You create a shader that outputs RGBA pixels, but in fact puts one 565 pixel
into the "RG" components and another 565 pixel into the "BA" components. Then
you read out RGBA as usual, but what you get is actually 565. Because RGBA
rendering and readback is guaranteed by GLES2, this should work everywhere.
However, it will fail if the precision of the shaders is less than 8 bits per
channel.

This is essentially how the YUV readback works.

+      LOG(ERROR)<<"Readbackformat rgb565  not supported";

[hubbe, 2013/12/26 21:41:49]

NIT: space around <<

+      context_->deleteTexture(texture);
+      context_->deleteTexture(dst_rgb_565_texture);
+      callback.Run(false);
+      return;
+    }
+  }
   ReadbackAsync(dst_size,
-                dst_size.width() * 4,
-                dst_size.width() * 4,
+                dst_size.width() * readback_factor,
+                dst_size.width() * readback_factor,
                 out,
+                readback_config_rgb565,
+                readback_factor,
                 callback);
   context_->deleteTexture(texture);
+  if(readback_config_rgb565){
+    context_->deleteTexture(dst_rgb_565_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_,
                                                              dst_framebuffer);
   ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
@@ skipping 19 matching lines @@
     GLHelper::ScalerQuality quality) {
   return ScaleTexture(src_texture,
                       src_size,
                       gfx::Rect(src_size),
                       dst_size,
                       vertically_flip_texture,
                       false,
                       quality);
 }
 
-void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request) {
+void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request,
+                                               int read_factor) {
   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() * read_factor &&
             request->bytes_per_row == request->row_stride_bytes) {
-          memcpy(request->pixels, data, request->size.GetArea() * 4);
+          memcpy(request->pixels, data, request->size.GetArea() * read_factor);
         } 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() * read_factor;
           }
         }
         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 165 matching lines @@
     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,
+      4,
       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