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");
+  DCHECK(!target_);

[piman, 2014/09/04 19:11:10]

I don't think we (currently) raise an error if the client binds the image to 2
textures. Should we return false instead if target_ is set?
Do we need consistency between the image types?

[reveman, 2014/09/04 20:12:44]

Ah, right. We should probably add some unit tests for binding the image to
multiple textures if we want to keep supporting that. I'll do that in a separate
patch.

I made this return false if the target is different. Similar to EGL version.
That means binding of image to multiple textures is limited to the same target
for this implementation. Maybe we can improve that if necessary by changing the
Will/DidUseTexImage API.

+  target_ = target;
+
+  // Defer DoBindTexImage if not currently in use.
+  if (!in_use_) {
+    need_do_bind_tex_image_ = true;
+    return true;
+  }
+
+  DoBindTexImage(target);
+  return true;
+}
+
+void GLImageMemory::ReleaseTexImage(unsigned target) {
+  DCHECK_EQ(target_, target);
+  target_ = 0;
+}
+
+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;
+
+  // The caller can handle this copy more efficiently using general GPU-to-GPU
+  // code if image is bound to a texture and data has been uploaded to it.
+  if (target_ && !need_do_bind_tex_image_)
+    return false;

[reveman, 2014/09/04 20:12:44]

I prefer to remove this as there's not really a way we can know from here that
the caller is interested in copying the data from a texture that this image is
currently bound to. We can revisit this later if it becomes a use case we need
to support efficiently. For now we assume that the client is not interested in
using the image both for sampling and and copying out of.

+
+  DCHECK(memory_);
+  glTexImage2D(target,
+               0,  // mip level
+               TextureFormat(internalformat_),
+               size_.width(),
+               size_.height(),
+               0,  // border
+               DataFormat(internalformat_),
+               DataType(internalformat_),
+               memory_);
+
+  return true;
+}
+
+void GLImageMemory::WillUseTexImage() {
+  DCHECK(!in_use_);
+  in_use_ = true;
+
+  if (!need_do_bind_tex_image_)
+    return;
+
+  DCHECK(target_);
+  DoBindTexImage(target_);
+}
+
+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(need_do_bind_tex_image_);
+  need_do_bind_tex_image_ = false;
 
   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