Tile Compression

gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc

Index: gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
diff --git a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
index b6506bfb584677296d77f3d71cfc7caf3d18e62b..b5545812cd7ed54695674778d6e5271cfb57bc0a 100644
--- a/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
+++ b/gpu/command_buffer/service/async_pixel_transfer_manager_share_group.cc
@@ -202,6 +202,9 @@ class TransferStateInternal
   TransferStateInternal(GLuint texture_id,
                         const AsyncTexImage2DParams& define_params)
       : texture_id_(texture_id), define_params_(define_params) {}
+  TransferStateInternal(GLuint texture_id,
+                        const AsyncCompressedTexImage2DParams& define_params)
+      : texture_id_(texture_id), compressed_define_params_(define_params) {}
 
   bool TransferIsInProgress() {
     return pending_upload_task_.get() &&
@@ -273,6 +276,37 @@ class TransferStateInternal
             &PendingTask::BindAndRun, pending_upload_task_, texture_id_));
   }
 
+  void ScheduleAsyncCompressedTexImage2D(
+      const AsyncCompressedTexImage2DParams tex_params,
+      const AsyncMemoryParams mem_params,
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats,
+      const base::Closure& bind_callback) {
+    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
+    pending_upload_task_ = new PendingTask(
+        base::Bind(&TransferStateInternal::PerformAsyncCompressedTexImage2D,
+                   this, tex_params, mem_params, texture_upload_stats));
+    transfer_message_loop_proxy()->PostTask(
+        FROM_HERE, base::Bind(&PendingTask::BindAndRun, pending_upload_task_,
+                              texture_id_));
+
+    // Save the late bind callback, so we can notify the client when it is
+    // bound.
+    bind_callback_ = bind_callback;
+  }
+
+  void ScheduleAsyncCompressedTexSubImage2D(
+      AsyncCompressedTexSubImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+    TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("gpu.AsyncTexImage");
+    pending_upload_task_ = new PendingTask(
+        base::Bind(&TransferStateInternal::PerformAsyncCompressedTexSubImage2D,
+                   this, tex_params, mem_params, texture_upload_stats));
+    transfer_message_loop_proxy()->PostTask(
+        FROM_HERE, base::Bind(&PendingTask::BindAndRun, pending_upload_task_,
+                              texture_id_));
+  }
+
  private:
   friend class base::RefCountedThreadSafe<TransferStateInternal>;
 
@@ -354,12 +388,73 @@ class TransferStateInternal
     }
   }
 
+  void PerformAsyncCompressedTexImage2D(
+      AsyncCompressedTexImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+    TRACE_EVENT2("gpu", "PerformAsyncCompressedTexImage", "width",
+                 tex_params.width, "height", tex_params.height);
+    DCHECK_EQ(0, tex_params.level);
+
+    base::TimeTicks begin_time;
+    if (texture_upload_stats.get())
+      begin_time = base::TimeTicks::HighResNow();
+
+    void* data = mem_params.GetDataAddress();
+
+    {
+      TRACE_EVENT0("gpu", "glCompressedTexImage2D");
+      glCompressedTexImage2D(GL_TEXTURE_2D, 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");
+    }
+
+    if (texture_upload_stats.get()) {
+      texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
+                                      begin_time);
+    }
+  }
+
+  void PerformAsyncCompressedTexSubImage2D(
+      AsyncCompressedTexSubImage2DParams tex_params,
+      AsyncMemoryParams mem_params,
+      scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
+    TRACE_EVENT2("gpu", "PerformAsyncCompressedTexSubImage2D", "width",
+                 tex_params.width, "height", tex_params.height);
+    DCHECK_EQ(0, tex_params.level);
+
+    base::TimeTicks begin_time;
+    if (texture_upload_stats.get())
+      begin_time = base::TimeTicks::HighResNow();
+
+    void* data = mem_params.GetDataAddress();
+
+    {
+      TRACE_EVENT0("gpu", "glCompressedTexSubImage2D");
+      glCompressedTexSubImage2D(GL_TEXTURE_2D, 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");
+    }
+
+    if (texture_upload_stats.get()) {
+      texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
+                                      begin_time);
+    }
+  }
+
   scoped_refptr<PendingTask> pending_upload_task_;
 
   GLuint texture_id_;
 
   // Definition params for texture that needs binding.
-  AsyncTexImage2DParams define_params_;
+  union {
+    AsyncTexImage2DParams define_params_;
+    AsyncCompressedTexImage2DParams compressed_define_params_;
+  };
 
   // Callback to invoke when AsyncTexImage2D is complete
   // and the client can safely use the texture. This occurs
@@ -377,6 +472,10 @@ class AsyncPixelTransferDelegateShareGroup
       AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
       GLuint texture_id,
       const AsyncTexImage2DParams& define_params);
+  AsyncPixelTransferDelegateShareGroup(
+      AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
+      GLuint texture_id,
+      const AsyncCompressedTexImage2DParams& define_params);
   ~AsyncPixelTransferDelegateShareGroup() override;
 
   void BindTransfer() { state_->BindTransfer(); }
@@ -387,6 +486,13 @@ class AsyncPixelTransferDelegateShareGroup
                        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;
 
@@ -406,6 +512,14 @@ AsyncPixelTransferDelegateShareGroup::AsyncPixelTransferDelegateShareGroup(
     : shared_state_(shared_state),
       state_(new TransferStateInternal(texture_id, define_params)) {}
 
+AsyncPixelTransferDelegateShareGroup::AsyncPixelTransferDelegateShareGroup(
+    AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
+    GLuint texture_id,
+    const AsyncCompressedTexImage2DParams& define_params)
+    : shared_state_(shared_state),
+      state_(new TransferStateInternal(texture_id, define_params)) {
+}
+
 AsyncPixelTransferDelegateShareGroup::~AsyncPixelTransferDelegateShareGroup() {
   TRACE_EVENT0("gpu", " ~AsyncPixelTransferDelegateShareGroup");
   state_->CancelUpload();
@@ -464,6 +578,33 @@ void AsyncPixelTransferDelegateShareGroup::AsyncTexSubImage2D(
       tex_params, mem_params, shared_state_->texture_upload_stats);
 }
 
+void AsyncPixelTransferDelegateShareGroup::AsyncCompressedTexImage2D(
+    const AsyncCompressedTexImage2DParams& tex_params,
+    const AsyncMemoryParams& mem_params,
+    const base::Closure& bind_callback) {
+  DCHECK(!state_->TransferIsInProgress());
+  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
+  DCHECK_EQ(tex_params.level, 0);
+
+  shared_state_->pending_allocations.push_back(AsWeakPtr());
+  state_->ScheduleAsyncCompressedTexImage2D(tex_params, mem_params,
+                                            shared_state_->texture_upload_stats,
+                                            bind_callback);
+}
+
+void AsyncPixelTransferDelegateShareGroup::AsyncCompressedTexSubImage2D(
+    const AsyncCompressedTexSubImage2DParams& tex_params,
+    const AsyncMemoryParams& mem_params) {
+  TRACE_EVENT2("gpu", "AsyncCompressedTexSubImage2D", "width", tex_params.width,
+               "height", tex_params.height);
+  DCHECK(!state_->TransferIsInProgress());
+  DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target);
+  DCHECK_EQ(tex_params.level, 0);
+
+  state_->ScheduleAsyncCompressedTexSubImage2D(
+      tex_params, mem_params, shared_state_->texture_upload_stats);
+}
+
 AsyncPixelTransferManagerShareGroup::SharedState::SharedState()
     // TODO(reveman): Skip this if --enable-gpu-benchmarking is not present.
     : texture_upload_stats(new AsyncPixelTransferUploadStats) {}
@@ -550,4 +691,12 @@ AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
       &shared_state_, ref->service_id(), define_params);
 }
 
+AsyncPixelTransferDelegate*
+AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
+    gles2::TextureRef* ref,
+    const AsyncCompressedTexImage2DParams& define_params) {
+  return new AsyncPixelTransferDelegateShareGroup(
+      &shared_state_, ref->service_id(), define_params);
+}
+
 }  // namespace gpu