Tile Compression

gpu/command_buffer/service/async_pixel_transfer_manager_share_group.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_share_group.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 184 matching lines @@
 
 // Class which holds async pixel transfers state.
 // The texture_id is accessed by either thread, but everything
 // else accessed only on the main thread.
 class TransferStateInternal
     : public base::RefCountedThreadSafe<TransferStateInternal> {
  public:
   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() &&
            pending_upload_task_->TaskIsInProgress();
   }
 
   void BindTransfer() {
     TRACE_EVENT2("gpu", "BindAsyncTransfer",
                  "width", define_params_.width,
                  "height", define_params_.height);
@@ skipping 51 matching lines @@
         this,
         tex_params,
         mem_params,
         texture_upload_stats));
     transfer_message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(
             &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>;
 
   virtual ~TransferStateInternal() {
   }
 
   void PerformAsyncTexImage2D(
       AsyncTexImage2DParams tex_params,
       AsyncMemoryParams mem_params,
       scoped_refptr<AsyncPixelTransferUploadStats> texture_upload_stats) {
@@ skipping 61 matching lines @@
                       data);
       TRACE_EVENT_SYNTHETIC_DELAY_END("gpu.AsyncTexImage");
     }
 
     if (texture_upload_stats.get()) {
       texture_upload_stats->AddUpload(base::TimeTicks::HighResNow() -
                                       begin_time);
     }
   }
 
+  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
   // during BindCompletedAsyncTransfers().
   base::Closure bind_callback_;
 };
 
 }  // namespace
 
 class AsyncPixelTransferDelegateShareGroup
     : public AsyncPixelTransferDelegate,
       public base::SupportsWeakPtr<AsyncPixelTransferDelegateShareGroup> {
  public:
   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(); }
 
   // 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:
   // A raw pointer is safe because the SharedState is owned by the Manager,
   // which owns this Delegate.
   AsyncPixelTransferManagerShareGroup::SharedState* shared_state_;
   scoped_refptr<TransferStateInternal> state_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPixelTransferDelegateShareGroup);
 };
 
 AsyncPixelTransferDelegateShareGroup::AsyncPixelTransferDelegateShareGroup(
     AsyncPixelTransferManagerShareGroup::SharedState* shared_state,
     GLuint texture_id,
     const AsyncTexImage2DParams& define_params)
     : 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();
 }
 
 bool AsyncPixelTransferDelegateShareGroup::TransferIsInProgress() {
   return state_->TransferIsInProgress();
 }
 
 void AsyncPixelTransferDelegateShareGroup::WaitForTransferCompletion() {
@@ skipping 38 matching lines @@
                "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_->ScheduleAsyncTexSubImage2D(
       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) {}
 
 AsyncPixelTransferManagerShareGroup::SharedState::~SharedState() {}
 
 AsyncPixelTransferManagerShareGroup::AsyncPixelTransferManagerShareGroup(
     gfx::GLContext* context) {
   g_transfer_thread.Pointer()->InitializeOnMainThread(context);
 }
@@ skipping 66 matching lines @@
 }
 
 AsyncPixelTransferDelegate*
 AsyncPixelTransferManagerShareGroup::CreatePixelTransferDelegateImpl(
     gles2::TextureRef* ref,
     const AsyncTexImage2DParams& define_params) {
   return new AsyncPixelTransferDelegateShareGroup(
       &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