Tile Compression

gpu/command_buffer/service/async_pixel_transfer_manager_idle.cc

 // Copyright 2013 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/async_pixel_transfer_manager_idle.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
+#include "base/synchronization/waitable_event.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace gpu {
 
 namespace {
 
 static uint64 g_next_pixel_transfer_state_id = 1;
 
+static const uint64 kNotificationTask = 0;
+static const uint64 kSuspendTask = 1;
+
+uint64 NextPixelTransferStateId() {
+  g_next_pixel_transfer_state_id++;
+  switch (g_next_pixel_transfer_state_id) {
+    case kNotificationTask:
+    case kSuspendTask:
+      return NextPixelTransferStateId();
+    default:
+      return g_next_pixel_transfer_state_id;
+  }
+}
+
 void PerformNotifyCompletion(
     AsyncMemoryParams mem_params,
     scoped_refptr<AsyncPixelTransferCompletionObserver> observer) {
   TRACE_EVENT0("gpu", "PerformNotifyCompletion");
   observer->DidComplete(mem_params);
 }
 
 }  // namespace
 
 // Class which handles async pixel transfers in a platform
 // independent way.
 class AsyncPixelTransferDelegateIdle
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateIdle> {
  public:
   AsyncPixelTransferDelegateIdle(
       AsyncPixelTransferManagerIdle::SharedState* state,
       GLuint texture_id,
       const AsyncTexImage2DParams& define_params);
+  AsyncPixelTransferDelegateIdle(
+      AsyncPixelTransferManagerIdle::SharedState* state,
+      GLuint texture_id,
+      const AsyncCompressedTexImage2DParams& define_params);
   ~AsyncPixelTransferDelegateIdle() override;
 
   // Implement AsyncPixelTransferDelegate:
   void AsyncTexImage2D(const AsyncTexImage2DParams& tex_params,
                        const AsyncMemoryParams& mem_params,
                        const base::Closure& bind_callback) override;
   void AsyncTexSubImage2D(const AsyncTexSubImage2DParams& tex_params,
                           const AsyncMemoryParams& mem_params) override;
+  void AsyncCompressedTexImage2D(
+      const AsyncCompressedTexImage2DParams& tex_params,
+      const AsyncMemoryParams& mem_params,
+      const base::Closure& bind_callback) override;
+  void AsyncCompressedTexSubImage2D(
+      const AsyncCompressedTexSubImage2DParams& tex_params,
+      const AsyncMemoryParams& mem_params) override;
   bool TransferIsInProgress() override;
   void WaitForTransferCompletion() override;
 
  private:
   void PerformAsyncTexImage2D(AsyncTexImage2DParams tex_params,
                               AsyncMemoryParams mem_params,
                               const base::Closure& bind_callback);
   void PerformAsyncTexSubImage2D(AsyncTexSubImage2DParams tex_params,
                                  AsyncMemoryParams mem_params);
+  void PerformAsyncCompressedTexImage2D(
+      AsyncCompressedTexImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      const base::Closure& bind_callback);
+  void PerformAsyncCompressedTexSubImage2D(
+      AsyncCompressedTexSubImage2DParams tex_params,
+      AsyncMemoryParams mem_params);
 
   uint64 id_;
   GLuint texture_id_;
   bool transfer_in_progress_;
-  AsyncTexImage2DParams define_params_;
+  union {
+    AsyncTexImage2DParams define_params_;
+    AsyncCompressedTexImage2DParams compressed_define_params_;
+  };
 
   // Safe to hold a raw pointer because SharedState is owned by the Manager
   // which owns the Delegate.
   AsyncPixelTransferManagerIdle::SharedState* shared_state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateIdle);
 };
 
 AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle(
     AsyncPixelTransferManagerIdle::SharedState* shared_state,
     GLuint texture_id,
     const AsyncTexImage2DParams& define_params)
-    : id_(g_next_pixel_transfer_state_id++),
+    : id_(NextPixelTransferStateId()),
       texture_id_(texture_id),
       transfer_in_progress_(false),
       define_params_(define_params),
       shared_state_(shared_state) {}
 
+AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle(
+    AsyncPixelTransferManagerIdle::SharedState* shared_state,
+    GLuint texture_id,
+    const AsyncCompressedTexImage2DParams& define_params)
+    : id_(NextPixelTransferStateId()),
+      texture_id_(texture_id),
+      transfer_in_progress_(false),
+      compressed_define_params_(define_params),
+      shared_state_(shared_state) {
+}
+
 AsyncPixelTransferDelegateIdle::~AsyncPixelTransferDelegateIdle() {}
 
 void AsyncPixelTransferDelegateIdle::AsyncTexImage2D(
     const AsyncTexImage2DParams& tex_params,
     const AsyncMemoryParams& mem_params,
     const base::Closure& bind_callback) {
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
 
   shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
@@ skipping 18 matching lines @@
       id_,
       this,
       base::Bind(&AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D,
                  AsWeakPtr(),
                  tex_params,
                  mem_params)));
 
   transfer_in_progress_ = true;
 }
 
+void AsyncPixelTransferDelegateIdle::AsyncCompressedTexImage2D(
+    const AsyncCompressedTexImage2DParams& tex_params,
+    const AsyncMemoryParams& mem_params,
+    const base::Closure& bind_callback) {
+  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
+  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
+
+  shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
+      id_, this,
+      base::Bind(
+          &AsyncPixelTransferDelegateIdle::PerformAsyncCompressedTexImage2D,
+          AsWeakPtr(), tex_params, mem_params, bind_callback)));
+
+  transfer_in_progress_ = true;
+}
+
+void AsyncPixelTransferDelegateIdle::AsyncCompressedTexSubImage2D(
+    const AsyncCompressedTexSubImage2DParams& tex_params,
+    const AsyncMemoryParams& mem_params) {
+  TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
+  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
+
+  shared_state_->tasks.push_back(AsyncPixelTransferManagerIdle::Task(
+      id_, this,
+      base::Bind(
+          &AsyncPixelTransferDelegateIdle::PerformAsyncCompressedTexSubImage2D,
+          AsWeakPtr(), tex_params, mem_params)));
+
+  transfer_in_progress_ = true;
+}
+
 bool  AsyncPixelTransferDelegateIdle::TransferIsInProgress() {
   return transfer_in_progress_;
 }
 
 void AsyncPixelTransferDelegateIdle::WaitForTransferCompletion() {
   for (std::list<AsyncPixelTransferManagerIdle::Task>::iterator iter =
            shared_state_->tasks.begin();
        iter != shared_state_->tasks.end();
        ++iter) {
     if (iter->transfer_id != id_)
@@ skipping 89 matching lines @@
         data);
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
   transfer_in_progress_ = false;
   shared_state_->texture_upload_count++;
   shared_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time;
 }
 
+void AsyncPixelTransferDelegateIdle::PerformAsyncCompressedTexImage2D(
+    AsyncCompressedTexImage2DParams tex_params,
+    AsyncMemoryParams mem_params,
+    const base::Closure& bind_callback) {
+  TRACE_EVENT2("gpu", "PerformAsyncCompressedTexImage2D", "width",
+               tex_params.width, "height", tex_params.height);
+
+  void* data = mem_params.GetDataAddress();
+
+  base::TimeTicks begin_time(base::TimeTicks::HighResNow());
+  gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
+
+  {
+    TRACE_EVENT0("gpu", "glCompressedTexImage2D");
+    glCompressedTexImage2D(tex_params.target, tex_params.level,
+                           tex_params.internal_format, tex_params.width,
+                           tex_params.height, tex_params.border,
+                           tex_params.image_size, data);
+  }
+
+  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
+  transfer_in_progress_ = false;
+  shared_state_->texture_upload_count++;
+  shared_state_->total_texture_upload_time +=
+      base::TimeTicks::HighResNow() - begin_time;
+
+  // The texture is already fully bound so just call it now.
+  bind_callback.Run();
+}
+
+void AsyncPixelTransferDelegateIdle::PerformAsyncCompressedTexSubImage2D(
+    AsyncCompressedTexSubImage2DParams tex_params,
+    AsyncMemoryParams mem_params) {
+  TRACE_EVENT2("gpu", "PerformAsyncCompressedTexSubImage2D", "width",
+               tex_params.width, "height", tex_params.height);
+
+  void* data = mem_params.GetDataAddress();
+
+  base::TimeTicks begin_time(base::TimeTicks::HighResNow());
+  gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id_);
+
+  // If it's a full texture update, use glCompressedTexImage2D as it's faster.
+  if (tex_params.xoffset == 0 && tex_params.yoffset == 0 &&
+      tex_params.target == compressed_define_params_.target &&
+      tex_params.level == compressed_define_params_.level &&
+      tex_params.width == compressed_define_params_.width &&
+      tex_params.height == compressed_define_params_.height) {
+    TRACE_EVENT0("gpu", "glCompressedTexImage2D");
+    glCompressedTexImage2D(
+        compressed_define_params_.target, compressed_define_params_.level,
+        compressed_define_params_.internal_format,
+        compressed_define_params_.width, compressed_define_params_.height,
+        compressed_define_params_.border, tex_params.image_size, data);
+  } else {
+    TRACE_EVENT0("gpu", "glCompressedTexSubImage2D");
+    glCompressedTexSubImage2D(tex_params.target, tex_params.level,
+                              tex_params.xoffset, tex_params.yoffset,
+                              tex_params.width, tex_params.height,
+                              tex_params.format, tex_params.image_size, data);
+  }
+
+  TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
+  transfer_in_progress_ = false;
+  shared_state_->texture_upload_count++;
+  shared_state_->total_texture_upload_time +=
+      base::TimeTicks::HighResNow() - begin_time;
+}
+
 AsyncPixelTransferManagerIdle::Task::Task(
     uint64 transfer_id,
     AsyncPixelTransferDelegate* delegate,
     const base::Closure& task)
     : transfer_id(transfer_id),
       delegate(delegate),
       task(task) {
 }
 
 AsyncPixelTransferManagerIdle::Task::~Task() {}
 
 AsyncPixelTransferManagerIdle::SharedState::SharedState()
     : texture_upload_count(0) {}
 
 AsyncPixelTransferManagerIdle::SharedState::~SharedState() {}
 
 void AsyncPixelTransferManagerIdle::SharedState::ProcessNotificationTasks() {
   while (!tasks.empty()) {
     // Stop when we reach a pixel transfer task.
-    if (tasks.front().transfer_id)
+    if (tasks.front().transfer_id > kSuspendTask)
       return;
 
     tasks.front().task.Run();
     tasks.pop_front();
   }
 }
 
 AsyncPixelTransferManagerIdle::AsyncPixelTransferManagerIdle()
   : shared_state_() {
 }
 
 AsyncPixelTransferManagerIdle::~AsyncPixelTransferManagerIdle() {}
 
 void AsyncPixelTransferManagerIdle::BindCompletedAsyncTransfers() {
   // Everything is already bound.
 }
 
 void AsyncPixelTransferManagerIdle::AsyncNotifyCompletion(
     const AsyncMemoryParams& mem_params,
     AsyncPixelTransferCompletionObserver* observer) {
   if (shared_state_.tasks.empty()) {
     observer->DidComplete(mem_params);
     return;
   }
 
   shared_state_.tasks.push_back(
-      Task(0,  // 0 transfer_id for notification tasks.
+      Task(kNotificationTask,
            NULL,
            base::Bind(
                &PerformNotifyCompletion,
                mem_params,
                make_scoped_refptr(observer))));
 }
 
 uint32 AsyncPixelTransferManagerIdle::GetTextureUploadCount() {
   return shared_state_.texture_upload_count;
 }
 
 base::TimeDelta AsyncPixelTransferManagerIdle::GetTotalTextureUploadTime() {
   return shared_state_.total_texture_upload_time;
 }
 
 void AsyncPixelTransferManagerIdle::ProcessMorePendingTransfers() {
   if (shared_state_.tasks.empty())
     return;
 
-  // First task should always be a pixel transfer task.
-  DCHECK(shared_state_.tasks.front().transfer_id);
+  // Suspend uploads until waitables have been signalled.
+  while (!suspend_waitables_.empty()) {
+    if (!suspend_waitables_.front()->IsSignaled())
+      return;
+    else
+      suspend_waitables_.erase(suspend_waitables_.begin());
+  }
+
+  // First task should always be a pixel transfer task or a suspend task.
+  DCHECK_NE(shared_state_.tasks.front().transfer_id, kNotificationTask);
   shared_state_.tasks.front().task.Run();
   shared_state_.tasks.pop_front();
 
   shared_state_.ProcessNotificationTasks();
 }
 
 bool AsyncPixelTransferManagerIdle::NeedsProcessMorePendingTransfers() {
   return !shared_state_.tasks.empty();
 }
 
 void AsyncPixelTransferManagerIdle::WaitAllAsyncTexImage2D() {
   if (shared_state_.tasks.empty())
     return;
 
   const Task& task = shared_state_.tasks.back();
   if (task.delegate)
     task.delegate->WaitForTransferCompletion();
 }
 
+void AsyncPixelTransferManagerIdle::DoSuspendUploads(
+    scoped_ptr<base::WaitableEvent> waitable) {
+  suspend_waitables_.push_back(waitable.release());
+}
+
+void AsyncPixelTransferManagerIdle::SuspendUploads(
+    base::WaitableEvent* waitable) {
+  shared_state_.tasks.push_back(
+      Task(kSuspendTask,
+           NULL,
+           base::Bind(&AsyncPixelTransferManagerIdle::DoSuspendUploads,
+                      base::Unretained(this),
+                      base::Passed(
+                          scoped_ptr<base::WaitableEvent>(waitable)))));
+}
+
+void AsyncPixelTransferManagerIdle::SignalWhenUploadsCompleted(
+    base::WaitableEvent* waitable) {
+  shared_state_.tasks.push_back(
+      Task(kNotificationTask,
+           NULL,
+           base::Bind(&base::WaitableEvent::Signal,
+                      // WaitableEvent owned by waiter.
+                      base::Unretained(waitable))));
+}
+
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateIdle(&shared_state_,
                                             ref->service_id(),
                                             define_params);
 }
 
+AsyncPixelTransferDelegate*
+AsyncPixelTransferManagerIdle::CreatePixelTransferDelegateImpl(
+    gles2::TextureRef* ref,
+    const AsyncCompressedTexImage2DParams& define_params) {
+  return new AsyncPixelTransferDelegateIdle(&shared_state_, ref->service_id(),
+                                            define_params);
+}
+
 }  // namespace gpu