Add readback path for CopyTextureCHROMIUM

gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.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_copy_texture_chromium.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 599 matching lines @@
                         source_y, source_width, source_height);
   }
 
   decoder->RestoreTextureState(source_id);
   decoder->RestoreTextureState(dest_id);
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreFramebufferBindings();
 }
 
+// Convert RGBA/UNSIGNED_BYTE source to RGB/UNSIGNED_BYTE destination.
+void convertToRGB(const uint8_t* source,
+                  uint8_t* destination,
+                  unsigned length) {
+  for (unsigned i = 0; i < length; ++i) {
+    destination[0] = source[0];
+    destination[1] = source[1];
+    destination[2] = source[2];
+    source += 4;
+    destination += 3;
+  }
+}
+
+// Convert RGBA/UNSIGNED_BYTE source to RGB/FLOAT destination.
+void convertToRGBFloat(const uint8_t* source,
+                       float* destination,
+                       unsigned length) {
+  const float scaleFactor = 1.0f / 255.0f;
+  for (unsigned i = 0; i < length; ++i) {
+    destination[0] = source[0] * scaleFactor;
+    destination[1] = source[1] * scaleFactor;
+    destination[2] = source[2] * scaleFactor;
+    source += 4;
+    destination += 3;
+  }
+}
+
+void DoReadbackAndTexImage2D(const gpu::gles2::GLES2Decoder* decoder,
+                             GLenum source_target,
+                             GLuint source_id,
+                             GLint source_level,
+                             GLenum dest_target,
+                             GLuint dest_id,
+                             GLint dest_level,
+                             GLenum dest_internal_format,
+                             GLsizei width,
+                             GLsizei height,
+                             GLuint framebuffer) {
+  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), source_target);
+  GLenum dest_binding_target =
+      gpu::gles2::GLES2Util::GLFaceTargetToTextureTarget(dest_target);
+  DCHECK(dest_binding_target == GL_TEXTURE_2D ||
+         dest_binding_target == GL_TEXTURE_CUBE_MAP);
+  DCHECK(source_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+  if (BindFramebufferTexture2D(source_target, source_id, source_level,
+                               framebuffer)) {
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[width * height * 4]);
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buf.get());

[Zhenyao Mo, 2017/03/20 17:05:40]

It would be really beneficial to explore the path of reading back to a
PIXEL_PACK_BUFFER.  Also, on desktop GL, you can directly read to a
RGB/UNSIGNED_BYTE buffer or FLOAT buffer. On ES, you can probably use
MapBufferRange to directly change PIXEL_PACK_BUFFER from RGBA to RGB; for
floats, you probably can create a PIXEL_UNPACK_BUFFER and map it, and directly
write to it.

This could be a significant perf gain for these formats, but could you write
some simple tests (repeatedly uploading textures to these formats) to measure
the perf difference, so we have confidence that what we implement is optimal?

[qiankun, 2017/03/21 08:47:13]

This is a good suggestion. Thanks! I did experiment. This method works. 
What kinds of test are in your mind, gl_tests or webgl tests? Should I add these
tests into this CL or just do some perf comparison locally? What the perf
difference should I measure, readback to client memory vs. readback to pbo?

[qiankun, 2017/03/29 09:00:10]

I did some experiments by running
src/third_party/WebKit/PerformanceTests/Canvas/upload-canvas-2d-to-texture.html
on some formats supported in WebGL 2.0. Here are the result on Linux with
GeForce GTX 750, GL_VERSION=4.5.0 NVIDIA 364.19. The number means how many
texImage2D calls can be done in 1 second. The larger, the better.
Performance comparsion for readback path
------------------------------------------------------------------------
                                                 SRGB8_ALPHA8   RGB9_E5
Current_CPU_path_in_Blink:                            46           20
Readback_to_client_memory_in_command_buffer:          275          18
Readback_to_pbo_in_command_buffer:                    508          47
------------------------------------------------------------------------
From the above table, we know readback path with pbo has the best performance.


Performance comparison for readback path and GPU-GPU path
------------------------------------------------------------------------
          Current_CPU_path_in_Blink     GPU-GPU_path_in_command_buffer
RGBA8UI:             49                               4530  
RGBA32F:             33                               1632
RGB32F:              32                               1553
RGB565:              52                               4730
------------------------------------------------------------------------
From the above table, we know GPU-GPU path is much faster than GPU-CPU-GPU path.


About the benchmark, do you prefer we add tests for more formats under
src/third_party/WebKit/PerformanceTests/Canvas/ or port the tests to
Khronos/WebGL?

+    glBindTexture(dest_binding_target, dest_id);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(dest_binding_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(dest_binding_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    GLenum format = GL_RGBA;
+    GLenum type = GL_UNSIGNED_BYTE;
+    switch (dest_internal_format) {
+      case GL_RGB9_E5: {
+        format = GL_RGB;
+        type = GL_FLOAT;
+        std::unique_ptr<float[]> data(new float[width * height * 3]);
+        convertToRGBFloat(buf.get(), data.get(), width * height);
+        glTexImage2D(dest_target, dest_level, dest_internal_format, width,
+                     height, 0, format, type, data.get());
+        break;
+      }
+      case GL_RGB5_A1:
+        glTexImage2D(dest_target, dest_level, dest_internal_format, width,
+                     height, 0, format, type, buf.get());
+        break;
+      case GL_SRGB_EXT:
+      case GL_SRGB8: {
+        format = GL_RGB;
+        std::unique_ptr<uint8_t[]> data(new uint8_t[width * height * 3]);
+        convertToRGB(buf.get(), data.get(), width * height);
+        glTexImage2D(dest_target, dest_level, dest_internal_format, width,
+                     height, 0, format, type, data.get());
+        break;
+      }
+      case GL_SRGB_ALPHA_EXT:
+      case GL_SRGB8_ALPHA8:
+        glTexImage2D(dest_target, dest_level, dest_internal_format, width,
+                     height, 0, format, type, buf.get());
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  decoder->RestoreTextureState(source_id);
+  decoder->RestoreTextureState(dest_id);
+  decoder->RestoreTextureUnitBindings(0);
+  decoder->RestoreActiveTexture();
+  decoder->RestoreFramebufferBindings();
+}
+
+void DoReadbackAndTexSubImage2D(const gpu::gles2::GLES2Decoder* decoder,
+                                GLenum source_target,
+                                GLuint source_id,
+                                GLint source_level,
+                                GLenum dest_target,
+                                GLuint dest_id,
+                                GLint dest_level,
+                                GLenum dest_internal_format,
+                                GLint xoffset,
+                                GLint yoffset,
+                                GLsizei width,
+                                GLsizei height,
+                                GLuint framebuffer) {
+  DCHECK(source_target == GL_TEXTURE_2D ||
+         source_target == GL_TEXTURE_RECTANGLE_ARB);
+  GLenum dest_binding_target =
+      gpu::gles2::GLES2Util::GLFaceTargetToTextureTarget(dest_target);
+  DCHECK(dest_binding_target == GL_TEXTURE_2D ||
+         dest_binding_target == GL_TEXTURE_CUBE_MAP);
+  DCHECK(source_level == 0 || decoder->GetFeatureInfo()->IsES3Capable());
+  if (BindFramebufferTexture2D(source_target, source_id, source_level,
+                               framebuffer)) {
+    std::unique_ptr<uint8_t[]> buf(new uint8_t[width * height * 4]);
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buf.get());
+    glBindTexture(dest_binding_target, dest_id);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(dest_binding_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(dest_binding_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(dest_binding_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    GLenum format = GL_RGBA;
+    GLenum type = GL_UNSIGNED_BYTE;
+    switch (dest_internal_format) {
+      case GL_RGB9_E5: {
+        format = GL_RGB;
+        type = GL_FLOAT;
+        std::unique_ptr<float[]> data(new float[width * height * 3]);
+        convertToRGBFloat(buf.get(), data.get(), width * height);
+        glTexSubImage2D(dest_target, dest_level, xoffset, yoffset, width,
+                        height, format, type, data.get());
+        break;
+      }
+      case GL_RGB5_A1:
+        glTexSubImage2D(dest_target, dest_level, xoffset, yoffset, width,
+                        height, format, type, buf.get());
+        break;
+      case GL_SRGB_EXT:
+      case GL_SRGB8: {
+        format = GL_RGB;
+        std::unique_ptr<uint8_t[]> data(new uint8_t[width * height * 3]);
+        convertToRGB(buf.get(), data.get(), width * height);
+        glTexSubImage2D(dest_target, dest_level, xoffset, yoffset, width,
+                        height, format, type, data.get());
+        break;
+      }
+      case GL_SRGB_ALPHA_EXT:
+      case GL_SRGB8_ALPHA8:
+        glTexSubImage2D(dest_target, dest_level, xoffset, yoffset, width,
+                        height, format, type, buf.get());
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  decoder->RestoreTextureState(source_id);
+  decoder->RestoreTextureState(dest_id);
+  decoder->RestoreTextureUnitBindings(0);
+  decoder->RestoreActiveTexture();
+  decoder->RestoreFramebufferBindings();
+}
+
 }  // namespace
 
 namespace gpu {
 namespace gles2 {
 
 CopyTextureCHROMIUMResourceManager::CopyTextureCHROMIUMResourceManager()
     : initialized_(false),
       nv_egl_stream_consumer_external_(false),
       vertex_shaders_(kNumVertexShaders, 0u),
       fragment_shaders_(kNumFragmentShaders, 0u),
@@ skipping 98 matching lines @@
                      width, height, framebuffer_);
     return;
   }
 
   // Draw to level 0 of an intermediate GL_TEXTURE_2D texture.
   GLuint dest_texture = dest_id;
   GLuint intermediate_texture = 0;
   GLint original_dest_level = dest_level;
   GLenum original_dest_target = dest_target;
   GLenum original_internal_format = dest_internal_format;
-  if (method == DRAW_AND_COPY) {
+  if (method == DRAW_AND_COPY || method == DRAW_AND_READBACK) {
     GLenum adjusted_internal_format =
-        getIntermediateFormat(dest_internal_format);
+        method == DRAW_AND_READBACK
+            ? GL_RGBA
+            : getIntermediateFormat(dest_internal_format);
     dest_target = GL_TEXTURE_2D;
     glGenTextures(1, &intermediate_texture);
     glBindTexture(dest_target, intermediate_texture);
     GLenum format = TextureManager::ExtractFormatFromStorageFormat(
         adjusted_internal_format);
     GLenum type =
         TextureManager::ExtractTypeFromStorageFormat(adjusted_internal_format);
 
     glTexImage2D(dest_target, 0, adjusted_internal_format, width, height, 0,
                  format, type, nullptr);
     dest_texture = intermediate_texture;
     dest_level = 0;
     dest_internal_format = adjusted_internal_format;
   }
   // Use kIdentityMatrix if no transform passed in.
   DoCopyTextureWithTransform(
       decoder, source_target, source_id, source_level, source_internal_format,
       dest_target, dest_texture, dest_level, dest_internal_format, width,
       height, flip_y, premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
 
-  if (method == DRAW_AND_COPY) {
+  if (method == DRAW_AND_COPY || method == DRAW_AND_READBACK) {
     source_level = 0;
-    DoCopyTexImage2D(decoder, dest_target, intermediate_texture, source_level,
-                     original_dest_target, dest_id, original_dest_level,
-                     original_internal_format, width, height, framebuffer_);
+    if (method == DRAW_AND_COPY) {
+      DoCopyTexImage2D(decoder, dest_target, intermediate_texture, source_level,
+                       original_dest_target, dest_id, original_dest_level,
+                       original_internal_format, width, height, framebuffer_);
+    } else if (method == DRAW_AND_READBACK) {
+      DoReadbackAndTexImage2D(decoder, dest_target, intermediate_texture,
+                              source_level, original_dest_target, dest_id,
+                              original_dest_level, original_internal_format,
+                              width, height, framebuffer_);
+    }
     glDeleteTextures(1, &intermediate_texture);
   }
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopySubTexture(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
     GLint source_level,
     GLenum source_internal_format,
@@ skipping 22 matching lines @@
     return;
   }
 
   // Draw to level 0 of an intermediate GL_TEXTURE_2D texture.
   GLint dest_xoffset = xoffset;
   GLint dest_yoffset = yoffset;
   GLuint dest_texture = dest_id;
   GLint original_dest_level = dest_level;
   GLenum original_dest_target = dest_target;
   GLuint intermediate_texture = 0;
-  if (method == DRAW_AND_COPY) {
+  GLenum original_internal_format = dest_internal_format;
+  if (method == DRAW_AND_COPY || method == DRAW_AND_READBACK) {
     GLenum adjusted_internal_format =
-        getIntermediateFormat(dest_internal_format);
+        method == DRAW_AND_READBACK
+            ? GL_RGBA
+            : getIntermediateFormat(dest_internal_format);
     dest_target = GL_TEXTURE_2D;
     glGenTextures(1, &intermediate_texture);
     glBindTexture(dest_target, intermediate_texture);
     GLenum format = TextureManager::ExtractFormatFromStorageFormat(
         adjusted_internal_format);
     GLenum type =
         TextureManager::ExtractTypeFromStorageFormat(adjusted_internal_format);
 
     glTexImage2D(dest_target, 0, adjusted_internal_format, width, height, 0,
                  format, type, nullptr);
     dest_texture = intermediate_texture;
     dest_level = 0;
     dest_internal_format = adjusted_internal_format;
     dest_xoffset = 0;
     dest_yoffset = 0;
     dest_width = width;
     dest_height = height;
   }
 
   DoCopySubTextureWithTransform(
       decoder, source_target, source_id, source_level, source_internal_format,
       dest_target, dest_texture, dest_level, dest_internal_format, dest_xoffset,
       dest_yoffset, x, y, width, height, dest_width, dest_height, source_width,
       source_height, flip_y, premultiply_alpha, unpremultiply_alpha,
       kIdentityMatrix);
 
-  if (method == DRAW_AND_COPY) {
+  if (method == DRAW_AND_COPY || method == DRAW_AND_READBACK) {
     source_level = 0;
-    DoCopyTexSubImage2D(decoder, dest_target, intermediate_texture,
-                        source_level, original_dest_target, dest_id,
-                        original_dest_level, xoffset, yoffset, 0, 0, width,
-                        height, framebuffer_);
+    if (method == DRAW_AND_COPY) {
+      DoCopyTexSubImage2D(decoder, dest_target, intermediate_texture,
+                          source_level, original_dest_target, dest_id,
+                          original_dest_level, xoffset, yoffset, 0, 0, width,
+                          height, framebuffer_);
+    } else if (method == DRAW_AND_READBACK) {
+      DoReadbackAndTexSubImage2D(decoder, dest_target, intermediate_texture,
+                                 source_level, original_dest_target, dest_id,
+                                 original_dest_level, original_internal_format,
+                                 xoffset, yoffset, width, height, framebuffer_);
+    }
     glDeleteTextures(1, &intermediate_texture);
   }
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopySubTextureWithTransform(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
     GLint source_level,
     GLenum source_internal_format,
@@ skipping 280 matching lines @@
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 }  // namespace gles2
 }  // namespace gpu