gpu: Change qualcomm work-around.

ui/gl/async_pixel_transfer_delegate_android.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 "ui/gl/async_pixel_transfer_delegate_android.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 34 matching lines @@
   }
   while ((glerror = glGetError()) != GL_NO_ERROR) {
      LOG(ERROR) << "Async transfer OpenGL error at "
                 << file << ":" << line << " " << glerror;
      success = false;
   }
   return success;
 }
 #define CHECK_GL() CheckErrors(__FILE__, __LINE__)
 
+// Regular glTexImage2D call.
+void DoTexImage2D(const AsyncTexImage2DParams& tex_params, void* data) {
+  glTexImage2D(
+      GL_TEXTURE_2D, tex_params.level, tex_params.internal_format,
+      tex_params.width, tex_params.height,
+      tex_params.border, tex_params.format, tex_params.type, data);
+}
+
+// Regular glTexSubImage2D call.
+void DoTexSubImage2D(const AsyncTexSubImage2DParams& tex_params, void* data) {
+  glTexSubImage2D(
+      GL_TEXTURE_2D, tex_params.level,
+      tex_params.xoffset, tex_params.yoffset,
+      tex_params.width, tex_params.height,
+      tex_params.format, tex_params.type, data);
+}
+
+// Full glTexSubImage2D call, from glTexImage2D params.
+void DoFullTexSubImage2D(const AsyncTexImage2DParams& tex_params, void* data) {
+  glTexSubImage2D(
+      GL_TEXTURE_2D, tex_params.level,
+      0, 0, tex_params.width, tex_params.height,
+      tex_params.format, tex_params.type, data);
+}
+
+
 // We duplicate shared memory to avoid use-after-free issues. This could also
 // be solved by ref-counting something, or with a destruction callback. There
 // wasn't an obvious hook or ref-counted container, so for now we dup/mmap.
 SharedMemory* DuplicateSharedMemory(SharedMemory* shared_memory, uint32 size) {
   // Duplicate the handle.
   SharedMemoryHandle duped_shared_memory_handle;
   if (!shared_memory->ShareToProcess(
       base::GetCurrentProcessHandle(),
       &duped_shared_memory_handle)) {
     CHECK(false); // Diagnosing a crash.
@@ skipping 66 matching lines @@
 } // namespace
 
 // Class which holds async pixel transfers state (EGLImage).
 // The EGLImage is accessed by either thread, but everything
 // else accessed only on the main thread.
 class TransferStateInternal
     : public base::RefCountedThreadSafe<TransferStateInternal> {
  public:
   explicit TransferStateInternal(GLuint texture_id,
                                  bool wait_for_uploads,
-                                 bool wait_for_egl_images)
+                                 bool use_image_preserved)
       : texture_id_(texture_id),
         thread_texture_id_(0),
         needs_late_bind_(false),
         transfer_in_progress_(false),
         egl_image_(EGL_NO_IMAGE_KHR),
         wait_for_uploads_(wait_for_uploads),
-        wait_for_egl_images_(wait_for_egl_images) {
+        use_image_preserved_(use_image_preserved) {
     static const AsyncTexImage2DParams zero_params = {0, 0, 0, 0, 0, 0, 0, 0};
     late_bind_define_params_ = zero_params;
   }
 
   // Implement AsyncPixelTransferState:
   bool TransferIsInProgress() {
     return transfer_in_progress_;
   }
 
   void BindTransfer(AsyncTexImage2DParams* bound_params) {
@@ skipping 21 matching lines @@
   void CreateEglImage(GLuint texture_id) {
     TRACE_EVENT0("gpu", "eglCreateImageKHR");
     DCHECK(texture_id);
     DCHECK_EQ(egl_image_, EGL_NO_IMAGE_KHR);
 
     EGLDisplay egl_display = eglGetCurrentDisplay();
     EGLContext egl_context = eglGetCurrentContext();
     EGLenum egl_target = EGL_GL_TEXTURE_2D_KHR;
     EGLClientBuffer egl_buffer =
         reinterpret_cast<EGLClientBuffer>(texture_id);
+
+    EGLint image_preserved = use_image_preserved_ ? EGL_TRUE : EGL_FALSE;
     EGLint egl_attrib_list[] = {
-        EGL_GL_TEXTURE_LEVEL_KHR, 0,         // mip-level to reference.
-        EGL_IMAGE_PRESERVED_KHR, EGL_FALSE,  // throw away texture data.
+        EGL_GL_TEXTURE_LEVEL_KHR, 0, // mip-level.
+        EGL_IMAGE_PRESERVED_KHR, image_preserved,
         EGL_NONE
     };
     egl_image_ = eglCreateImageKHR(
         egl_display,
         egl_context,
         egl_target,
         egl_buffer,
         egl_attrib_list);
 
     DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_);
   }
 
   void CreateEglImageOnUploadThread() {
     CreateEglImage(thread_texture_id_);
   }
 
   void CreateEglImageOnMainThreadIfNeeded() {
     if (egl_image_ == EGL_NO_IMAGE_KHR)
       CreateEglImage(texture_id_);
   }
 
-  void WaitOnEglImageCreation() {
-    // On Qualcomm, we need to wait on egl image creation before
-    // doing the first upload (or the texture remains black).
-    // A fence after image creation didn't always work, but glFinish
-    // seems to always work, and this only happens on the upload thread.
-    if (wait_for_egl_images_) {
-      TRACE_EVENT0("gpu", "glFinish");
-      glFinish();
-    }
-  }
-
   void WaitForLastUpload() {
     // This glFinish is just a safe-guard for if uploads have some
     // GPU action that needs to occur. We could use fences and try
     // to do this less often. However, on older drivers fences are
     // not always reliable (eg. Mali-400 just blocks forever).
     if (wait_for_uploads_) {
       TRACE_EVENT0("gpu", "glFinish");
       glFinish();
     }
   }
@@ skipping 36 matching lines @@
   // It would be nice if we could just create a new EGLImage for
   // every upload, but I found that didn't work, so this stores
   // one for the lifetime of the texture.
   EGLImageKHR egl_image_;
 
   // Time spent performing last transfer.
   base::TimeDelta last_transfer_time_;
 
   // Customize when we block on fences (these are work-arounds).
   bool wait_for_uploads_;
-  bool wait_for_egl_images_;
+  bool use_image_preserved_;
 };
 
 // Android needs thread-safe ref-counting, so this just wraps
 // an internal thread-safe ref-counted state object.
 class AsyncTransferStateAndroid : public AsyncPixelTransferState {
  public:
   explicit AsyncTransferStateAndroid(GLuint texture_id,
                                      bool wait_for_uploads,
-                                     bool wait_for_egl_images)
+                                     bool use_image_preserved)
       : internal_(new TransferStateInternal(texture_id,
                                             wait_for_uploads,
-                                            wait_for_egl_images)) {
+                                            use_image_preserved)) {
   }
   virtual ~AsyncTransferStateAndroid() {}
   virtual bool TransferIsInProgress() {
       return internal_->TransferIsInProgress();
   }
   virtual void BindTransfer(AsyncTexImage2DParams* bound_params) {
       internal_->BindTransfer(bound_params);
   }
   scoped_refptr<TransferStateInternal> internal_;
 };
@@ skipping 100 matching lines @@
 }
 
 AsyncPixelTransferDelegateAndroid::~AsyncPixelTransferDelegateAndroid() {
 }
 
 AsyncPixelTransferState*
     AsyncPixelTransferDelegateAndroid::
         CreateRawPixelTransferState(GLuint texture_id) {
 
   // We can't wait on uploads on imagination (it can take 200ms+).
+  // In practice, they are complete when the CPU glSubTexImage2D completes.
   bool wait_for_uploads = !is_imagination_;
 
-  // We need to wait for EGLImage creation on Qualcomm.
-  bool wait_for_egl_images = is_qualcomm_;
+  // Qualcomm has a race when using image_preserved=FALSE,
+  // which can result in black textures even after the first upload.
+  // Since using FALSE is mainly for performance (to avoid layout changes),
+  // but Qualcomm itself doesn't seem to get any performance benefit,
+  // we just using image_preservedd=TRUE on Qualcomm as a work-around.
+  bool use_image_preserved = is_qualcomm_ || is_imagination_;
 
   return static_cast<AsyncPixelTransferState*>(
       new AsyncTransferStateAndroid(texture_id,
                                     wait_for_uploads,
-                                    wait_for_egl_images));
+                                    use_image_preserved));
 }
 
 namespace {
 // Dummy function to measure completion on
 // the upload thread.
 void NoOp() {}
 } // namespace
 
 void AsyncPixelTransferDelegateAndroid::AsyncNotifyCompletion(
       const base::Closure& task) {
@@ skipping 138 matching lines @@
 
   void* data = GetAddress(shared_memory, shared_memory_data_offset);
   {
     TRACE_EVENT0("gpu", "glTexImage2D no data");
     glGenTextures(1, &state->thread_texture_id_);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
 
     SetGlParametersForEglImageTexture();
 
-    // Allocate first, so we can create the EGLImage without
-    // EGL_IMAGE_PRESERVED, which can be costly.
-    glTexImage2D(
-        GL_TEXTURE_2D,
-        tex_params.level,
-        tex_params.internal_format,
-        tex_params.width,
-        tex_params.height,
-        tex_params.border,
-        tex_params.format,
-        tex_params.type,
-        NULL);
+    // If we need to use image_preserved, we pass the data with
+    // the allocation. Otherwise we use a NULL allocation to
+    // try to avoid any costs associated with creating the EGLImage.
+    if (state->use_image_preserved_)
+       DoTexImage2D(tex_params, data);
+    else
+       DoTexImage2D(tex_params, NULL);
   }
 
   state->CreateEglImageOnUploadThread();
-  state->WaitOnEglImageCreation();
 
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D with data");
-    glTexSubImage2D(
-        GL_TEXTURE_2D,
-        tex_params.level,
-        0,
-        0,
-        tex_params.width,
-        tex_params.height,
-        tex_params.format,
-        tex_params.type,
-        data);
+
+    // If we didn't use image_preserved, we haven't uploaded
+    // the data yet, so we do this with a full texSubImage.
+    if (!state->use_image_preserved_)
+      DoFullTexSubImage2D(tex_params, data);
   }
 
   state->WaitForLastUpload();
   DCHECK(CHECK_GL());
 }
 
 void AsyncPixelTransferDelegateAndroid::PerformAsyncTexSubImage2D(
     TransferStateInternal* state,
     AsyncTexSubImage2DParams tex_params,
     base::SharedMemory* shared_memory,
     uint32 shared_memory_data_offset) {
   TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D",
                "width", tex_params.width,
                "height", tex_params.height);
 
   DCHECK(state);
   DCHECK_NE(EGL_NO_IMAGE_KHR, state->egl_image_);
   DCHECK_EQ(0, tex_params.level);
 
-  state->WaitOnEglImageCreation();
-
   void* data = GetAddress(shared_memory, shared_memory_data_offset);
 
   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   if (!state->thread_texture_id_) {
     TRACE_EVENT0("gpu", "glEGLImageTargetTexture2DOES");
     glGenTextures(1, &state->thread_texture_id_);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, state->egl_image_);
   } else {
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, state->thread_texture_id_);
   }
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
-    glTexSubImage2D(
-        GL_TEXTURE_2D,
-        tex_params.level,
-        tex_params.xoffset,
-        tex_params.yoffset,
-        tex_params.width,
-        tex_params.height,
-        tex_params.format,
-        tex_params.type,
-        data);
+    DoTexSubImage2D(tex_params, data);
   }
   state->WaitForLastUpload();
 
   DCHECK(CHECK_GL());
   state->last_transfer_time_ = base::TimeTicks::HighResNow() - begin_time;
 }
 
 
 namespace {
 bool IsPowerOfTwo (unsigned int x) {
   return ((x != 0) && !(x & (x - 1)));
 }
 
 bool IsMultipleOfEight(unsigned int x) {
   return (x & 7) == 0;
 }
 
 bool DimensionsSupportImgFastPath(int width, int height) {
   // Multiple of eight, but not a power of two.
   return IsMultipleOfEight(width) &&
          IsMultipleOfEight(height) &&
-         !IsPowerOfTwo(width) &&
-         !IsPowerOfTwo(height);
+         !(IsPowerOfTwo(width) &&
+           IsPowerOfTwo(height));
 }
 } // namespace
 
 // It is very difficult to stream uploads on Imagination GPUs:
 // - glTexImage2D defers a swizzle/stall until draw-time
 // - glTexSubImage2D will sleep for 16ms on a good day, and 100ms
 //   or longer if OpenGL is in heavy use by another thread.
 // The one combination that avoids these problems requires:
 // a.) Allocations/Uploads must occur on different threads/contexts.
 // b.) Texture size must be non-power-of-two.
@@ skipping 12 matching lines @@
     return false;
 
   // On imagination we allocate synchronously all the time, even
   // if the dimensions support fast uploads. This is for part a.)
   // above, so allocations occur on a different thread/context as uploads.
   void* data = GetAddress(mem_params.shared_memory, mem_params.shm_data_offset);
   SetGlParametersForEglImageTexture();
 
   {
     TRACE_EVENT0("gpu", "glTexImage2D with data");
-    glTexImage2D(
-        GL_TEXTURE_2D,
-        tex_params.level,
-        tex_params.internal_format,
-        tex_params.width,
-        tex_params.height,
-        tex_params.border,
-        tex_params.format,
-        tex_params.type,
-        data);
+    DoTexImage2D(tex_params, data);
   }
 
   // The allocation has already occured, so mark it as finished
   // and ready for binding.
   state->needs_late_bind_ = false;
   state->transfer_in_progress_ = false;
   state->late_bind_define_params_ = tex_params;
 
   // If the dimensions support fast async uploads, create the
   // EGLImage for future uploads. The late bind should not
@@ skipping 19 matching lines @@
   // normal async upload path for uploads.
   if (DimensionsSupportImgFastPath(tex_params.width, tex_params.height))
     return false;
 
   // Fall back on a synchronous stub as we don't have a known fast path.
   void* data = GetAddress(mem_params.shared_memory,
                           mem_params.shm_data_offset);
   base::TimeTicks begin_time(base::TimeTicks::HighResNow());
   {
     TRACE_EVENT0("gpu", "glTexSubImage2D");
-    glTexSubImage2D(
-        tex_params.target,
-        tex_params.level,
-        tex_params.xoffset,
-        tex_params.yoffset,
-        tex_params.width,
-        tex_params.height,
-        tex_params.format,
-        tex_params.type,
-        data);
+    DoTexSubImage2D(tex_params, data);
   }
   texture_upload_count_++;
   total_texture_upload_time_ += base::TimeTicks::HighResNow() - begin_time;
 
   DCHECK(CHECK_GL());
   return true;
 }
 
 }  // namespace gfx