gpu: Add CopyTexImage function to GLImage API.

ui/gl/gl_image_memory.cc

 // Copyright 2014 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 "ui/gl/gl_image_memory.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 52 matching lines @@
       NOTREACHED();
       return 0;
   }
 }
 
 }  // namespace
 
 GLImageMemory::GLImageMemory(const gfx::Size& size, unsigned internalformat)
     : memory_(NULL),
       size_(size),
-      internalformat_(internalformat)
+      internalformat_(internalformat),
+      in_use_(false),
+      target_(0),
+      need_do_bind_tex_image_(false)
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
       ,
       egl_texture_id_(0u),
       egl_image_(EGL_NO_IMAGE_KHR)
 #endif
 {
 }
 
 GLImageMemory::~GLImageMemory() {
@@ skipping 31 matching lines @@
   }
 #endif
   memory_ = NULL;
 }
 
 gfx::Size GLImageMemory::GetSize() {
   return size_;
 }
 
 bool GLImageMemory::BindTexImage(unsigned target) {
-  TRACE_EVENT0("gpu", "GLImageMemory::BindTexImage");
+  target_ = target;
+
+  // Defer DoBindTexImage if not currently in use.
+  if (!in_use_) {
+    need_do_bind_tex_image_ = true;
+    return true;
+  }
+
+  DoBindTexImage(target);
+  need_do_bind_tex_image_ = false;

[piman, 2014/09/04 17:32:54]

nit: move this to DoBindTexImage and save a line. (conceptually, it makes sense
that DoBindTexImage resets the state).

[reveman, 2014/09/04 18:57:43]

Done.

+  return true;
+}
+
+bool GLImageMemory::CopyTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageMemory::CopyTexImage");
+
+  // GL_TEXTURE_EXTERNAL_OES is not a supported CopyTexImage target.
+  if (target == GL_TEXTURE_EXTERNAL_OES)
+    return false;
+
+  DCHECK(memory_);
+  glTexImage2D(target,
+               0,  // mip level
+               TextureFormat(internalformat_),
+               size_.width(),
+               size_.height(),
+               0,  // border
+               DataFormat(internalformat_),
+               DataType(internalformat_),
+               memory_);

[piman, 2014/09/04 17:32:54]

If the data was already uploaded to the source texture, a GPU->GPU copy will be
more efficient than a new upload. Is there a way to detect this? E.g. if
need_do_bind_tex_image_ is false, fail the copy, so that the calling code will
fallback.

BTW, why do we need the copy in the first place?

[reveman, 2014/09/04 18:57:43]

Good point. I made this work by tracking if the image is bound to a texture
using |target_| and in that case only upload directly to destination texture if
need_do_bind_tex_image_ is set.
You mean instead of just using the image for zero-copy? This alternative
one-copy approach is useful for 2 reasons:

1. Easier synchronization if images are used in a fixed sequence in a staging
pool as we only have to worry about the copy operations completing on the GPU.
Doesn't matter in the software case but useful with SurfaceTextures where the
synchronization mechanism is not exactly what we want.

2. Gives us control over the amount of staging resources and zero-copy buffers
that are used. On some systems it might be too expensive to use one zero-copy
buffer for each tile resource. ie. file descriptor limits on Android. In the
software case, it's shared memory objects and having a shared memory backing for
each tile texture is not really an option. This allows us to use a number of
images as staging buffers for uploads, similar to async uploads but this gives
us much better control over the amount of staging memory.

+
+  return true;
+}
+
+void GLImageMemory::WillUseTexImage() {
+  DCHECK(!in_use_);
+  in_use_ = true;
+
+  if (!need_do_bind_tex_image_)
+    return;
+
+  DoBindTexImage(target_);
+  need_do_bind_tex_image_ = false;
+}
+
+void GLImageMemory::DidUseTexImage() {
+  DCHECK(in_use_);
+  in_use_ = false;
+}
+
+bool GLImageMemory::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                         int z_order,
+                                         OverlayTransform transform,
+                                         const Rect& bounds_rect,
+                                         const RectF& crop_rect) {
+  return false;
+}
+
+bool GLImageMemory::HasValidFormat() const {
+  return ValidFormat(internalformat_);
+}
+
+size_t GLImageMemory::Bytes() const {
+  return size_.GetArea() * BytesPerPixel(internalformat_);
+}
+
+void GLImageMemory::DoBindTexImage(unsigned target) {
+  TRACE_EVENT0("gpu", "GLImageMemory::DoBindTexImage");
 
   DCHECK(memory_);
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     if (egl_image_ == EGL_NO_IMAGE_KHR) {
       DCHECK_EQ(0u, egl_texture_id_);
       glGenTextures(1, &egl_texture_id_);
 
       {
@@ skipping 33 matching lines @@
                       0,  // y-offset
                       size_.width(),
                       size_.height(),
                       DataFormat(internalformat_),
                       DataType(internalformat_),
                       memory_);
     }
 
     glEGLImageTargetTexture2DOES(target, egl_image_);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
-
-    return true;
+    return;
   }
 #endif
 
   DCHECK_NE(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), target);
   glTexImage2D(target,
                0,  // mip level
                TextureFormat(internalformat_),
                size_.width(),
                size_.height(),
                0,  // border
                DataFormat(internalformat_),
                DataType(internalformat_),
                memory_);
-
-  return true;
-}
-
-bool GLImageMemory::HasValidFormat() const {
-  return ValidFormat(internalformat_);
-}
-
-size_t GLImageMemory::Bytes() const {
-  return size_.GetArea() * BytesPerPixel(internalformat_);
-}
-
-bool GLImageMemory::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                         int z_order,
-                                         OverlayTransform transform,
-                                         const Rect& bounds_rect,
-                                         const RectF& crop_rect) {
-  return false;
 }
 
 }  // namespace gfx