| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_idle.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/debug/trace_event.h" | |
| 9 #include "base/lazy_instance.h" | |
| 10 #include "gpu/command_buffer/service/safe_shared_memory_pool.h" | |
| 11 #include "ui/gl/scoped_binders.h" | |
| 12 | |
| 13 namespace gpu { | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 base::LazyInstance<SafeSharedMemoryPool> g_safe_shared_memory_pool = | |
| 18 LAZY_INSTANCE_INITIALIZER; | |
| 19 | |
| 20 SafeSharedMemoryPool* safe_shared_memory_pool() { | |
| 21 return g_safe_shared_memory_pool.Pointer(); | |
| 22 } | |
| 23 | |
| 24 static uint64 g_next_pixel_transfer_state_id = 1; | |
| 25 | |
| 26 class AsyncPixelTransferStateImpl : public AsyncPixelTransferState { | |
| 27 public: | |
| 28 typedef base::Callback<void(GLuint)> TransferCallback; | |
| 29 | |
| 30 explicit AsyncPixelTransferStateImpl(GLuint texture_id) | |
| 31 : id_(g_next_pixel_transfer_state_id++), | |
| 32 texture_id_(texture_id), | |
| 33 transfer_in_progress_(false) { | |
| 34 } | |
| 35 | |
| 36 // Implement AsyncPixelTransferState: | |
| 37 virtual bool TransferIsInProgress() OVERRIDE { | |
| 38 return transfer_in_progress_; | |
| 39 } | |
| 40 | |
| 41 uint64 id() const { return id_; } | |
| 42 | |
| 43 void set_transfer_in_progress(bool transfer_in_progress) { | |
| 44 transfer_in_progress_ = transfer_in_progress; | |
| 45 } | |
| 46 | |
| 47 void PerformTransfer(const TransferCallback& callback) { | |
| 48 DCHECK(texture_id_); | |
| 49 DCHECK(transfer_in_progress_); | |
| 50 callback.Run(texture_id_); | |
| 51 transfer_in_progress_ = false; | |
| 52 } | |
| 53 | |
| 54 private: | |
| 55 virtual ~AsyncPixelTransferStateImpl() {} | |
| 56 | |
| 57 uint64 id_; | |
| 58 GLuint texture_id_; | |
| 59 bool transfer_in_progress_; | |
| 60 }; | |
| 61 | |
| 62 } // namespace | |
| 63 | |
| 64 AsyncPixelTransferDelegateIdle::Task::Task( | |
| 65 uint64 transfer_id, const base::Closure& task) | |
| 66 : transfer_id(transfer_id), | |
| 67 task(task) { | |
| 68 } | |
| 69 | |
| 70 AsyncPixelTransferDelegateIdle::Task::~Task() {} | |
| 71 | |
| 72 AsyncPixelTransferDelegateIdle::AsyncPixelTransferDelegateIdle() | |
| 73 : texture_upload_count_(0) { | |
| 74 } | |
| 75 | |
| 76 AsyncPixelTransferDelegateIdle::~AsyncPixelTransferDelegateIdle() {} | |
| 77 | |
| 78 AsyncPixelTransferState* AsyncPixelTransferDelegateIdle:: | |
| 79 CreatePixelTransferState(GLuint texture_id, | |
| 80 const AsyncTexImage2DParams& define_params) { | |
| 81 return new AsyncPixelTransferStateImpl(texture_id); | |
| 82 } | |
| 83 | |
| 84 void AsyncPixelTransferDelegateIdle::BindCompletedAsyncTransfers() { | |
| 85 // Everything is already bound. | |
| 86 } | |
| 87 | |
| 88 void AsyncPixelTransferDelegateIdle::AsyncNotifyCompletion( | |
| 89 const AsyncMemoryParams& mem_params, | |
| 90 const CompletionCallback& callback) { | |
| 91 if (tasks_.empty()) { | |
| 92 callback.Run(mem_params); | |
| 93 return; | |
| 94 } | |
| 95 | |
| 96 tasks_.push_back( | |
| 97 Task(0, // 0 transfer_id for notification tasks. | |
| 98 base::Bind( | |
| 99 &AsyncPixelTransferDelegateIdle::PerformNotifyCompletion, | |
| 100 AsWeakPtr(), | |
| 101 mem_params, | |
| 102 base::Owned(new ScopedSafeSharedMemory( | |
| 103 safe_shared_memory_pool(), | |
| 104 mem_params.shared_memory, | |
| 105 mem_params.shm_size)), | |
| 106 callback))); | |
| 107 } | |
| 108 | |
| 109 void AsyncPixelTransferDelegateIdle::AsyncTexImage2D( | |
| 110 AsyncPixelTransferState* transfer_state, | |
| 111 const AsyncTexImage2DParams& tex_params, | |
| 112 const AsyncMemoryParams& mem_params, | |
| 113 const base::Closure& bind_callback) { | |
| 114 AsyncPixelTransferStateImpl* state = | |
| 115 static_cast<AsyncPixelTransferStateImpl*>(transfer_state); | |
| 116 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); | |
| 117 DCHECK(mem_params.shared_memory); | |
| 118 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, | |
| 119 mem_params.shm_size); | |
| 120 DCHECK(state); | |
| 121 | |
| 122 tasks_.push_back( | |
| 123 Task(state->id(), | |
| 124 base::Bind( | |
| 125 &AsyncPixelTransferStateImpl::PerformTransfer, | |
| 126 base::AsWeakPtr(state), | |
| 127 base::Bind( | |
| 128 &AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D, | |
| 129 AsWeakPtr(), | |
| 130 tex_params, | |
| 131 mem_params, | |
| 132 bind_callback, | |
| 133 base::Owned(new ScopedSafeSharedMemory( | |
| 134 safe_shared_memory_pool(), | |
| 135 mem_params.shared_memory, | |
| 136 mem_params.shm_size)))))); | |
| 137 | |
| 138 state->set_transfer_in_progress(true); | |
| 139 } | |
| 140 | |
| 141 void AsyncPixelTransferDelegateIdle::AsyncTexSubImage2D( | |
| 142 AsyncPixelTransferState* transfer_state, | |
| 143 const AsyncTexSubImage2DParams& tex_params, | |
| 144 const AsyncMemoryParams& mem_params) { | |
| 145 AsyncPixelTransferStateImpl* state = | |
| 146 static_cast<AsyncPixelTransferStateImpl*>(transfer_state); | |
| 147 DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), tex_params.target); | |
| 148 DCHECK(mem_params.shared_memory); | |
| 149 DCHECK_LE(mem_params.shm_data_offset + mem_params.shm_data_size, | |
| 150 mem_params.shm_size); | |
| 151 DCHECK(state); | |
| 152 | |
| 153 tasks_.push_back( | |
| 154 Task(state->id(), | |
| 155 base::Bind( | |
| 156 &AsyncPixelTransferStateImpl::PerformTransfer, | |
| 157 base::AsWeakPtr(state), | |
| 158 base::Bind( | |
| 159 &AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D, | |
| 160 AsWeakPtr(), | |
| 161 tex_params, | |
| 162 mem_params, | |
| 163 base::Owned(new ScopedSafeSharedMemory( | |
| 164 safe_shared_memory_pool(), | |
| 165 mem_params.shared_memory, | |
| 166 mem_params.shm_size)))))); | |
| 167 | |
| 168 state->set_transfer_in_progress(true); | |
| 169 } | |
| 170 | |
| 171 void AsyncPixelTransferDelegateIdle::WaitForTransferCompletion( | |
| 172 AsyncPixelTransferState* transfer_state) { | |
| 173 AsyncPixelTransferStateImpl* state = | |
| 174 static_cast<AsyncPixelTransferStateImpl*>(transfer_state); | |
| 175 DCHECK(state); | |
| 176 | |
| 177 for (std::list<Task>::iterator iter = tasks_.begin(); | |
| 178 iter != tasks_.end(); ++iter) { | |
| 179 if (iter->transfer_id != state->id()) | |
| 180 continue; | |
| 181 | |
| 182 (*iter).task.Run(); | |
| 183 tasks_.erase(iter); | |
| 184 break; | |
| 185 } | |
| 186 | |
| 187 ProcessNotificationTasks(); | |
| 188 } | |
| 189 | |
| 190 uint32 AsyncPixelTransferDelegateIdle::GetTextureUploadCount() { | |
| 191 return texture_upload_count_; | |
| 192 } | |
| 193 | |
| 194 base::TimeDelta AsyncPixelTransferDelegateIdle::GetTotalTextureUploadTime() { | |
| 195 return total_texture_upload_time_; | |
| 196 } | |
| 197 | |
| 198 void AsyncPixelTransferDelegateIdle::ProcessMorePendingTransfers() { | |
| 199 if (tasks_.empty()) | |
| 200 return; | |
| 201 | |
| 202 // First task should always be a pixel transfer task. | |
| 203 DCHECK(tasks_.front().transfer_id); | |
| 204 tasks_.front().task.Run(); | |
| 205 tasks_.pop_front(); | |
| 206 | |
| 207 ProcessNotificationTasks(); | |
| 208 } | |
| 209 | |
| 210 bool AsyncPixelTransferDelegateIdle::NeedsProcessMorePendingTransfers() { | |
| 211 return !tasks_.empty(); | |
| 212 } | |
| 213 | |
| 214 void AsyncPixelTransferDelegateIdle::ProcessNotificationTasks() { | |
| 215 while (!tasks_.empty()) { | |
| 216 // Stop when we reach a pixel transfer task. | |
| 217 if (tasks_.front().transfer_id) | |
| 218 return; | |
| 219 | |
| 220 tasks_.front().task.Run(); | |
| 221 tasks_.pop_front(); | |
| 222 } | |
| 223 } | |
| 224 | |
| 225 void AsyncPixelTransferDelegateIdle::PerformNotifyCompletion( | |
| 226 AsyncMemoryParams mem_params, | |
| 227 ScopedSafeSharedMemory* safe_shared_memory, | |
| 228 const CompletionCallback& callback) { | |
| 229 TRACE_EVENT0("gpu", "PerformNotifyCompletion"); | |
| 230 AsyncMemoryParams safe_mem_params = mem_params; | |
| 231 safe_mem_params.shared_memory = safe_shared_memory->shared_memory(); | |
| 232 callback.Run(safe_mem_params); | |
| 233 } | |
| 234 | |
| 235 void AsyncPixelTransferDelegateIdle::PerformAsyncTexImage2D( | |
| 236 AsyncTexImage2DParams tex_params, | |
| 237 AsyncMemoryParams mem_params, | |
| 238 const base::Closure& bind_callback, | |
| 239 ScopedSafeSharedMemory* safe_shared_memory, | |
| 240 GLuint texture_id) { | |
| 241 TRACE_EVENT2("gpu", "PerformAsyncTexImage2D", | |
| 242 "width", tex_params.width, | |
| 243 "height", tex_params.height); | |
| 244 | |
| 245 void* data = GetAddress(safe_shared_memory, mem_params); | |
| 246 | |
| 247 gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id); | |
| 248 | |
| 249 { | |
| 250 TRACE_EVENT0("gpu", "glTexImage2D"); | |
| 251 glTexImage2D( | |
| 252 tex_params.target, | |
| 253 tex_params.level, | |
| 254 tex_params.internal_format, | |
| 255 tex_params.width, | |
| 256 tex_params.height, | |
| 257 tex_params.border, | |
| 258 tex_params.format, | |
| 259 tex_params.type, | |
| 260 data); | |
| 261 } | |
| 262 | |
| 263 // The texture is already fully bound so just call it now. | |
| 264 bind_callback.Run(); | |
| 265 } | |
| 266 | |
| 267 void AsyncPixelTransferDelegateIdle::PerformAsyncTexSubImage2D( | |
| 268 AsyncTexSubImage2DParams tex_params, | |
| 269 AsyncMemoryParams mem_params, | |
| 270 ScopedSafeSharedMemory* safe_shared_memory, | |
| 271 GLuint texture_id) { | |
| 272 TRACE_EVENT2("gpu", "PerformAsyncTexSubImage2D", | |
| 273 "width", tex_params.width, | |
| 274 "height", tex_params.height); | |
| 275 | |
| 276 void* data = GetAddress(safe_shared_memory, mem_params); | |
| 277 | |
| 278 base::TimeTicks begin_time(base::TimeTicks::HighResNow()); | |
| 279 gfx::ScopedTextureBinder texture_binder(tex_params.target, texture_id); | |
| 280 | |
| 281 { | |
| 282 TRACE_EVENT0("gpu", "glTexSubImage2D"); | |
| 283 glTexSubImage2D( | |
| 284 tex_params.target, | |
| 285 tex_params.level, | |
| 286 tex_params.xoffset, | |
| 287 tex_params.yoffset, | |
| 288 tex_params.width, | |
| 289 tex_params.height, | |
| 290 tex_params.format, | |
| 291 tex_params.type, | |
| 292 data); | |
| 293 } | |
| 294 | |
| 295 texture_upload_count_++; | |
| 296 total_texture_upload_time_ += base::TimeTicks::HighResNow() - begin_time; | |
| 297 } | |
| 298 | |
| 299 } // namespace gpu | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 16325018:
GPU: Factory produces APTManagers instead of APTDelegates (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src