Implement GLHelperReadbackSupport for GLHelper usage.

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"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
+#include "content/common/gpu/client/gl_helper_readback_support.h"
 #include "content/common/gpu/client/gl_helper_scaling.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
@@ skipping 143 matching lines @@
       const gfx::Rect& src_subrect,
       const gfx::Size& dst_size,
       const gfx::Rect& dst_subrect,
       bool flip_vertically,
       bool use_mrt);
 
   // Returns the maximum number of draw buffers available,
   // 0 if GL_EXT_draw_buffers is not available.
   GLint MaxDrawBuffers() const { return max_draw_buffers_; }
 
+  bool IsReadbackConfigSupported(SkBitmap::Config bitmap_config);
+
  private:
   // A single request to CropScaleReadbackAndCleanTexture.
   // 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).
   // In either case, the callback must be called exactly once, and the texture
   // must be deleted by the main thread gl.
   struct Request {
     Request(const gfx::Size& size_,
@@ skipping 143 matching lines @@
                                     swizzle);
 }
 
 GLuint GLHelper::CopyTextureToImpl::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,
-    SkBitmap::Config config,
+    SkBitmap::Config bitmap_config,
     GLHelper::ScalerQuality quality) {
+  if (!IsReadbackConfigSupported(bitmap_config))
+    return 0;
 
-  bool format_support = ((config == SkBitmap::kRGB_565_Config) ||
-                         (config == SkBitmap::kARGB_8888_Config));
-  if (!format_support) {
-    DCHECK(format_support);
-    return 0;
-  }
   scoped_ptr<ScalerInterface> scaler(
       helper_->CreateScaler(quality,
                             src_size,
                             src_subrect,
                             dst_size,
                             vertically_flip_texture,
                             swizzle));
   GLuint dst_texture = 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;
   gl_->GenTextures(1, &dst_texture);
   {
     ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
-    switch (config) {
+    switch (bitmap_config) {
       case SkBitmap::kARGB_8888_Config:
         // Do nothing params already set.
         break;
       case SkBitmap::kRGB_565_Config:
         format = GL_RGB;
         type = GL_UNSIGNED_SHORT_5_6_5;
         break;
       default:
         NOTREACHED();
         break;
@@ skipping 10 matching lines @@
   }
   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 SkBitmap::Config config,
+    const SkBitmap::Config bitmap_config,
     const base::Callback<void(bool)>& callback) {
-  bool format_support = ((config == SkBitmap::kRGB_565_Config) ||
-                         (config == SkBitmap::kARGB_8888_Config));
-  if (!format_support) {
-    DCHECK(format_support);
+  if (!IsReadbackConfigSupported(bitmap_config)) {
     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;
 
-  switch (config) {
+  switch (bitmap_config) {
     case SkBitmap::kARGB_8888_Config:
       // Do nothing params already set.
       break;
     case SkBitmap::kRGB_565_Config:
       format = GL_RGB;
       type = GL_UNSIGNED_SHORT_5_6_5;
       bytes_per_pixel = 2;
       break;
     default:
       NOTREACHED();
@@ skipping 25 matching lines @@
 }
 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 SkBitmap::Config bitmap_config,
     const base::Callback<void(bool)>& callback,
     GLHelper::ScalerQuality quality) {
-  bool format_support = ((bitmap_config == SkBitmap::kRGB_565_Config) ||
-                         (bitmap_config == SkBitmap::kARGB_8888_Config));
-  if (!format_support) {
-    DCHECK(format_support);
+  if (!IsReadbackConfigSupported(bitmap_config)) {
     callback.Run(false);
     return;
   }
   GLuint texture = ScaleTexture(src_texture,
                                 src_size,
                                 src_subrect,
                                 dst_size,
                                 true,
 #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
                                 true,
@@ skipping 26 matching lines @@
   }
   ReadbackAsync(dst_size,
                 dst_size.width() * bytes_per_pixel,
                 dst_size.width() * bytes_per_pixel,
                 out,
                 bitmap_config,
                 callback);
   gl_->DeleteTextures(1, &texture);
 }
 
-void GLHelper::CopyTextureToImpl::ReadbackTextureSync(GLuint texture,
-                                                      const gfx::Rect& src_rect,
-                                                      unsigned char* out,
-                                                      SkBitmap::Config config) {
-  DCHECK((config == SkBitmap::kRGB_565_Config) ||
-         (config == SkBitmap::kARGB_8888_Config));
+void GLHelper::CopyTextureToImpl::ReadbackTextureSync(
+    GLuint texture,
+    const gfx::Rect& src_rect,
+    unsigned char* out,
+    SkBitmap::Config bitmap_config) {
+  if (!IsReadbackConfigSupported(bitmap_config))
+    return;
+
   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);
-  GLenum format = (config == SkBitmap::kRGB_565_Config) ?
-                  GL_RGB :
-                  GL_RGBA;
-  GLenum type = (config == SkBitmap::kRGB_565_Config) ?
-                GL_UNSIGNED_SHORT_5_6_5 :
-                GL_UNSIGNED_BYTE;
+  GLenum format =
+      (bitmap_config == SkBitmap::kRGB_565_Config) ? GL_RGB : GL_RGBA;
+  GLenum type = (bitmap_config == SkBitmap::kRGB_565_Config)
+                    ? GL_UNSIGNED_SHORT_5_6_5
+                    : GL_UNSIGNED_BYTE;
   gl_->ReadPixels(src_rect.x(),
                   src_rect.y(),
                   src_rect.width(),
                   src_rect.height(),
                   format,
                   type,
                   out);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
     GLuint texture,
     const gfx::Size& dst_size,
     unsigned char* out,
-    SkBitmap::Config config,
+    SkBitmap::Config bitmap_config,
     const base::Callback<void(bool)>& callback) {
-  // Only ARGB888 and RGB565 supported as of now.
-  bool format_support = ((config == SkBitmap::kRGB_565_Config) ||
-                         (config == SkBitmap::kARGB_8888_Config));
-  if (!format_support) {
-    DCHECK(format_support);
+  if (!IsReadbackConfigSupported(bitmap_config))
     return;
-  }
+
   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 = (config == SkBitmap::kRGB_565_Config) ? 2 : 4;
+  int bytes_per_pixel = (bitmap_config == SkBitmap::kRGB_565_Config) ? 2 : 4;
   ReadbackAsync(dst_size,
                 dst_size.width() * bytes_per_pixel,
                 dst_size.width() * bytes_per_pixel,
                 out,
-                config,
+                bitmap_config,
                 callback);
 }
 
 GLuint GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
     GLuint src_texture,
     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,
                       SkBitmap::kARGB_8888_Config,
                       quality);
 }
 
+bool GLHelper::CopyTextureToImpl::IsReadbackConfigSupported(
+    SkBitmap::Config bitmap_config) {
+  if (!helper_) {
+    DCHECK(helper_);
+    return false;
+  }
+  return helper_->IsReadbackConfigSupported(bitmap_config);
+}
+
 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();
@@ skipping 48 matching lines @@
 void GLHelper::CopyTextureToImpl::CancelRequests() {
   while (!request_queue_.empty()) {
     Request* request = request_queue_.front();
     FinishRequest(request, false);
   }
 }
 
 GLHelper::GLHelper(GLES2Interface* gl, gpu::ContextSupport* context_support)
     : gl_(gl),
       context_support_(context_support),
-      initialized_565_format_check_(false),
-      support_565_format_(false) {}
+      readback_support_(new GLHelperReadbackSupport(gl, this)) {}
 
 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 SkBitmap::Config config,
@@ skipping 202 matching lines @@
                          rect.width(),
                          rect.height());
 }
 
 void GLHelper::CopyTextureFullImage(GLuint texture, const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
   gl_->CopyTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGB, 0, 0, size.width(), size.height(), 0);
 }
 
-bool GLHelper::CanUseRgb565Readback() {
-  if(initialized_565_format_check_){
-    return support_565_format_;
-  }
-  const int kTestSize = 64;
-  GLuint dst_texture = 0u;
-  gl_->GenTextures(1, &dst_texture);
-  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, dst_texture);
-  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  gl_->TexImage2D(GL_TEXTURE_2D,
-                  0,
-                  GL_RGB,
-                  kTestSize,
-                  kTestSize,
-                  0,
-                  GL_RGB,
-                  GL_UNSIGNED_SHORT_5_6_5,
-                  NULL);
-  ScopedFramebuffer dst_framebuffer(gl_);
-  ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
-                                                             dst_framebuffer);
-  gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
-                            GL_COLOR_ATTACHMENT0,
-                            GL_TEXTURE_2D,
-                            dst_texture,
-                            0);
-  GLint  ext_format = 0, ext_type = 0;
-  gl_->GetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &ext_format);
-  gl_->GetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &ext_type);
-  gl_->DeleteTextures(1, &dst_texture);
-  if ((ext_format == GL_RGB) && (ext_type == GL_UNSIGNED_SHORT_5_6_5)) {
-    support_565_format_ = true;
-  }
-  initialized_565_format_check_ = true;
-  return support_565_format_;
-}
-
 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) {
   gl_->BindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
   size_t offset = target->stride(plane) * (dst_subrect.y() >> size_shift) +
       (dst_subrect.x() >> size_shift);
@@ skipping 255 matching lines @@
       &v_,
       target,
       media::VideoFrame::kVPlane,
       1,
       dst_subrect_,
       base::Bind(&CallbackKeepingVideoFrameAlive, target, callback));
   gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
   media::LetterboxYUV(target, dst_subrect_);
 }
 
+bool GLHelper::IsReadbackConfigSupported(SkBitmap::Config texture_format) {
+  DCHECK(readback_support_.get());
+  return readback_support_.get()->IsReadbackConfigSupported(texture_format);
+}
+
 ReadbackYUVInterface* GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV(
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const gfx::Rect& dst_subrect,
     bool flip_vertically,
     bool use_mrt) {
   helper_->InitScalerImpl();
   if (max_draw_buffers_ >= 2 && use_mrt) {
@@ skipping 30 matching lines @@
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
                                                           src_size,
                                                           src_subrect,
                                                           dst_size,
                                                           dst_subrect,
                                                           flip_vertically,
                                                           use_mrt);
 }
 
 }  // namespace content