| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "content/common/gpu/texture_image_transport_surface.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/command_line.h" | |
| 11 #include "content/common/gpu/gpu_channel.h" | |
| 12 #include "content/common/gpu/gpu_channel_manager.h" | |
| 13 #include "content/common/gpu/gpu_messages.h" | |
| 14 #include "content/common/gpu/sync_point_manager.h" | |
| 15 #include "content/public/common/content_switches.h" | |
| 16 #include "gpu/command_buffer/service/context_group.h" | |
| 17 #include "gpu/command_buffer/service/gpu_scheduler.h" | |
| 18 #include "gpu/command_buffer/service/mailbox_manager.h" | |
| 19 #include "ui/gl/scoped_binders.h" | |
| 20 | |
| 21 using gpu::gles2::ContextGroup; | |
| 22 using gpu::gles2::GLES2Decoder; | |
| 23 using gpu::gles2::MailboxManager; | |
| 24 using gpu::gles2::Texture; | |
| 25 using gpu::gles2::TextureManager; | |
| 26 using gpu::gles2::TextureRef; | |
| 27 using gpu::Mailbox; | |
| 28 | |
| 29 namespace content { | |
| 30 namespace { | |
| 31 | |
| 32 bool IsContextValid(ImageTransportHelper* helper) { | |
| 33 return helper->stub()->decoder()->GetGLContext()->IsCurrent(NULL); | |
| 34 } | |
| 35 | |
| 36 } // namespace | |
| 37 | |
| 38 TextureImageTransportSurface::TextureImageTransportSurface( | |
| 39 GpuChannelManager* manager, | |
| 40 GpuCommandBufferStub* stub, | |
| 41 const gfx::GLSurfaceHandle& handle) | |
| 42 : fbo_id_(0), | |
| 43 current_size_(1, 1), | |
| 44 scale_factor_(1.f), | |
| 45 stub_destroyed_(false), | |
| 46 backbuffer_suggested_allocation_(true), | |
| 47 frontbuffer_suggested_allocation_(true), | |
| 48 handle_(handle), | |
| 49 is_swap_buffers_pending_(false), | |
| 50 did_unschedule_(false) { | |
| 51 helper_.reset(new ImageTransportHelper(this, | |
| 52 manager, | |
| 53 stub, | |
| 54 gfx::kNullPluginWindow)); | |
| 55 } | |
| 56 | |
| 57 TextureImageTransportSurface::~TextureImageTransportSurface() { | |
| 58 DCHECK(stub_destroyed_); | |
| 59 Destroy(); | |
| 60 } | |
| 61 | |
| 62 bool TextureImageTransportSurface::Initialize() { | |
| 63 mailbox_manager_ = | |
| 64 helper_->stub()->decoder()->GetContextGroup()->mailbox_manager(); | |
| 65 | |
| 66 GpuChannelManager* manager = helper_->manager(); | |
| 67 surface_ = manager->GetDefaultOffscreenSurface(); | |
| 68 if (!surface_.get()) | |
| 69 return false; | |
| 70 | |
| 71 if (!helper_->Initialize()) | |
| 72 return false; | |
| 73 | |
| 74 GpuChannel* parent_channel = manager->LookupChannel(handle_.parent_client_id); | |
| 75 if (parent_channel) { | |
| 76 const base::CommandLine* command_line = | |
| 77 base::CommandLine::ForCurrentProcess(); | |
| 78 if (command_line->HasSwitch(switches::kUIPrioritizeInGpuProcess)) | |
| 79 helper_->SetPreemptByFlag(parent_channel->GetPreemptionFlag()); | |
| 80 } | |
| 81 | |
| 82 return true; | |
| 83 } | |
| 84 | |
| 85 void TextureImageTransportSurface::Destroy() { | |
| 86 if (surface_.get()) | |
| 87 surface_ = NULL; | |
| 88 | |
| 89 helper_->Destroy(); | |
| 90 } | |
| 91 | |
| 92 bool TextureImageTransportSurface::DeferDraws() { | |
| 93 // The command buffer hit a draw/clear command that could clobber the | |
| 94 // texture in use by the UI compositor. If a Swap is pending, abort | |
| 95 // processing of the command by returning true and unschedule until the Swap | |
| 96 // Ack arrives. | |
| 97 DCHECK(!did_unschedule_); | |
| 98 if (is_swap_buffers_pending_) { | |
| 99 did_unschedule_ = true; | |
| 100 helper_->SetScheduled(false); | |
| 101 return true; | |
| 102 } | |
| 103 return false; | |
| 104 } | |
| 105 | |
| 106 bool TextureImageTransportSurface::IsOffscreen() { | |
| 107 return true; | |
| 108 } | |
| 109 | |
| 110 unsigned int TextureImageTransportSurface::GetBackingFrameBufferObject() { | |
| 111 DCHECK(IsContextValid(helper_.get())); | |
| 112 if (!fbo_id_) { | |
| 113 glGenFramebuffersEXT(1, &fbo_id_); | |
| 114 glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_id_); | |
| 115 helper_->stub()->AddDestructionObserver(this); | |
| 116 CreateBackTexture(); | |
| 117 } | |
| 118 | |
| 119 return fbo_id_; | |
| 120 } | |
| 121 | |
| 122 bool TextureImageTransportSurface::SetBackbufferAllocation(bool allocation) { | |
| 123 DCHECK(!is_swap_buffers_pending_); | |
| 124 if (backbuffer_suggested_allocation_ == allocation) | |
| 125 return true; | |
| 126 backbuffer_suggested_allocation_ = allocation; | |
| 127 | |
| 128 if (backbuffer_suggested_allocation_) { | |
| 129 DCHECK(!backbuffer_.get()); | |
| 130 CreateBackTexture(); | |
| 131 } else { | |
| 132 ReleaseBackTexture(); | |
| 133 } | |
| 134 | |
| 135 return true; | |
| 136 } | |
| 137 | |
| 138 void TextureImageTransportSurface::SetFrontbufferAllocation(bool allocation) { | |
| 139 if (frontbuffer_suggested_allocation_ == allocation) | |
| 140 return; | |
| 141 frontbuffer_suggested_allocation_ = allocation; | |
| 142 | |
| 143 // If a swapbuffers is in flight, wait for the ack before releasing the front | |
| 144 // buffer: | |
| 145 // - we don't know yet which texture the browser will want to keep | |
| 146 // - we want to ensure we don't destroy a texture that is in flight before the | |
| 147 // browser got a reference on it. | |
| 148 if (!frontbuffer_suggested_allocation_ && | |
| 149 !is_swap_buffers_pending_ && | |
| 150 helper_->MakeCurrent()) { | |
| 151 ReleaseFrontTexture(); | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 void* TextureImageTransportSurface::GetShareHandle() { | |
| 156 return GetHandle(); | |
| 157 } | |
| 158 | |
| 159 void* TextureImageTransportSurface::GetDisplay() { | |
| 160 return surface_.get() ? surface_->GetDisplay() : NULL; | |
| 161 } | |
| 162 | |
| 163 void* TextureImageTransportSurface::GetConfig() { | |
| 164 return surface_.get() ? surface_->GetConfig() : NULL; | |
| 165 } | |
| 166 | |
| 167 void TextureImageTransportSurface::OnResize(gfx::Size size, | |
| 168 float scale_factor) { | |
| 169 DCHECK_GE(size.width(), 1); | |
| 170 DCHECK_GE(size.height(), 1); | |
| 171 current_size_ = size; | |
| 172 scale_factor_ = scale_factor; | |
| 173 if (backbuffer_suggested_allocation_) | |
| 174 CreateBackTexture(); | |
| 175 } | |
| 176 | |
| 177 void TextureImageTransportSurface::OnWillDestroyStub() { | |
| 178 bool have_context = IsContextValid(helper_.get()); | |
| 179 helper_->stub()->RemoveDestructionObserver(this); | |
| 180 | |
| 181 // We are losing the stub owning us, this is our last chance to clean up the | |
| 182 // resources we allocated in the stub's context. | |
| 183 if (have_context) { | |
| 184 ReleaseBackTexture(); | |
| 185 ReleaseFrontTexture(); | |
| 186 } else { | |
| 187 backbuffer_ = NULL; | |
| 188 back_mailbox_ = Mailbox(); | |
| 189 frontbuffer_ = NULL; | |
| 190 front_mailbox_ = Mailbox(); | |
| 191 } | |
| 192 | |
| 193 if (fbo_id_ && have_context) { | |
| 194 glDeleteFramebuffersEXT(1, &fbo_id_); | |
| 195 CHECK_GL_ERROR(); | |
| 196 } | |
| 197 fbo_id_ = 0; | |
| 198 | |
| 199 stub_destroyed_ = true; | |
| 200 } | |
| 201 | |
| 202 void TextureImageTransportSurface::SetLatencyInfo( | |
| 203 const std::vector<ui::LatencyInfo>& latency_info) { | |
| 204 for (size_t i = 0; i < latency_info.size(); i++) | |
| 205 latency_info_.push_back(latency_info[i]); | |
| 206 } | |
| 207 | |
| 208 void TextureImageTransportSurface::WakeUpGpu() { | |
| 209 NOTIMPLEMENTED(); | |
| 210 } | |
| 211 | |
| 212 bool TextureImageTransportSurface::SwapBuffers() { | |
| 213 DCHECK(IsContextValid(helper_.get())); | |
| 214 DCHECK(backbuffer_suggested_allocation_); | |
| 215 | |
| 216 if (!frontbuffer_suggested_allocation_) | |
| 217 return true; | |
| 218 | |
| 219 if (!backbuffer_.get()) { | |
| 220 LOG(ERROR) << "Swap without valid backing."; | |
| 221 return true; | |
| 222 } | |
| 223 | |
| 224 DCHECK(backbuffer_size() == current_size_); | |
| 225 GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params; | |
| 226 params.size = backbuffer_size(); | |
| 227 params.scale_factor = scale_factor_; | |
| 228 params.mailbox = back_mailbox_; | |
| 229 | |
| 230 glFlush(); | |
| 231 | |
| 232 params.latency_info.swap(latency_info_); | |
| 233 helper_->SendAcceleratedSurfaceBuffersSwapped(params); | |
| 234 | |
| 235 DCHECK(!is_swap_buffers_pending_); | |
| 236 is_swap_buffers_pending_ = true; | |
| 237 return true; | |
| 238 } | |
| 239 | |
| 240 bool TextureImageTransportSurface::PostSubBuffer( | |
| 241 int x, int y, int width, int height) { | |
| 242 DCHECK(IsContextValid(helper_.get())); | |
| 243 DCHECK(backbuffer_suggested_allocation_); | |
| 244 if (!frontbuffer_suggested_allocation_) | |
| 245 return true; | |
| 246 const gfx::Rect new_damage_rect(x, y, width, height); | |
| 247 DCHECK(gfx::Rect(gfx::Point(), current_size_).Contains(new_damage_rect)); | |
| 248 | |
| 249 // An empty damage rect is a successful no-op. | |
| 250 if (new_damage_rect.IsEmpty()) | |
| 251 return true; | |
| 252 | |
| 253 if (!backbuffer_.get()) { | |
| 254 LOG(ERROR) << "Swap without valid backing."; | |
| 255 return true; | |
| 256 } | |
| 257 | |
| 258 DCHECK(current_size_ == backbuffer_size()); | |
| 259 GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params; | |
| 260 params.surface_size = backbuffer_size(); | |
| 261 params.surface_scale_factor = scale_factor_; | |
| 262 params.x = x; | |
| 263 params.y = y; | |
| 264 params.width = width; | |
| 265 params.height = height; | |
| 266 params.mailbox = back_mailbox_; | |
| 267 | |
| 268 glFlush(); | |
| 269 | |
| 270 params.latency_info.swap(latency_info_); | |
| 271 helper_->SendAcceleratedSurfacePostSubBuffer(params); | |
| 272 | |
| 273 DCHECK(!is_swap_buffers_pending_); | |
| 274 is_swap_buffers_pending_ = true; | |
| 275 return true; | |
| 276 } | |
| 277 | |
| 278 bool TextureImageTransportSurface::SupportsPostSubBuffer() { | |
| 279 return true; | |
| 280 } | |
| 281 | |
| 282 gfx::Size TextureImageTransportSurface::GetSize() { | |
| 283 return current_size_; | |
| 284 } | |
| 285 | |
| 286 void* TextureImageTransportSurface::GetHandle() { | |
| 287 return surface_.get() ? surface_->GetHandle() : NULL; | |
| 288 } | |
| 289 | |
| 290 unsigned TextureImageTransportSurface::GetFormat() { | |
| 291 return surface_.get() ? surface_->GetFormat() : 0; | |
| 292 } | |
| 293 | |
| 294 void TextureImageTransportSurface::OnBufferPresented( | |
| 295 const AcceleratedSurfaceMsg_BufferPresented_Params& params) { | |
| 296 if (params.sync_point == 0) { | |
| 297 BufferPresentedImpl(params.mailbox); | |
| 298 } else { | |
| 299 helper_->manager()->sync_point_manager()->AddSyncPointCallback( | |
| 300 params.sync_point, | |
| 301 base::Bind(&TextureImageTransportSurface::BufferPresentedImpl, | |
| 302 this, | |
| 303 params.mailbox)); | |
| 304 } | |
| 305 } | |
| 306 | |
| 307 void TextureImageTransportSurface::BufferPresentedImpl(const Mailbox& mailbox) { | |
| 308 DCHECK(is_swap_buffers_pending_); | |
| 309 is_swap_buffers_pending_ = false; | |
| 310 | |
| 311 // When we wait for a sync point, we may get called back after the stub is | |
| 312 // destroyed. In that case there's no need to do anything with the returned | |
| 313 // mailbox. | |
| 314 if (stub_destroyed_) | |
| 315 return; | |
| 316 | |
| 317 // We should not have allowed the backbuffer to be discarded while the ack | |
| 318 // was pending. | |
| 319 DCHECK(backbuffer_suggested_allocation_); | |
| 320 DCHECK(backbuffer_.get()); | |
| 321 | |
| 322 bool swap = true; | |
| 323 if (!mailbox.IsZero()) { | |
| 324 if (mailbox == back_mailbox_) { | |
| 325 // The browser has skipped the frame to unblock the GPU process, waiting | |
| 326 // for one of the right size, and returned the back buffer, so don't swap. | |
| 327 swap = false; | |
| 328 } | |
| 329 } | |
| 330 if (swap) { | |
| 331 std::swap(backbuffer_, frontbuffer_); | |
| 332 std::swap(back_mailbox_, front_mailbox_); | |
| 333 } | |
| 334 | |
| 335 // We're relying on the fact that the parent context is | |
| 336 // finished with its context when it inserts the sync point that | |
| 337 // triggers this callback. | |
| 338 if (helper_->MakeCurrent()) { | |
| 339 if (frontbuffer_.get() && !frontbuffer_suggested_allocation_) | |
| 340 ReleaseFrontTexture(); | |
| 341 if (!backbuffer_.get() || backbuffer_size() != current_size_) | |
| 342 CreateBackTexture(); | |
| 343 else | |
| 344 AttachBackTextureToFBO(); | |
| 345 } | |
| 346 | |
| 347 // Even if MakeCurrent fails, schedule anyway, to trigger the lost context | |
| 348 // logic. | |
| 349 if (did_unschedule_) { | |
| 350 did_unschedule_ = false; | |
| 351 helper_->SetScheduled(true); | |
| 352 } | |
| 353 } | |
| 354 | |
| 355 void TextureImageTransportSurface::ReleaseBackTexture() { | |
| 356 DCHECK(IsContextValid(helper_.get())); | |
| 357 backbuffer_ = NULL; | |
| 358 back_mailbox_ = Mailbox(); | |
| 359 glFlush(); | |
| 360 CHECK_GL_ERROR(); | |
| 361 } | |
| 362 | |
| 363 void TextureImageTransportSurface::ReleaseFrontTexture() { | |
| 364 DCHECK(IsContextValid(helper_.get())); | |
| 365 frontbuffer_ = NULL; | |
| 366 front_mailbox_ = Mailbox(); | |
| 367 glFlush(); | |
| 368 CHECK_GL_ERROR(); | |
| 369 helper_->SendAcceleratedSurfaceRelease(); | |
| 370 } | |
| 371 | |
| 372 void TextureImageTransportSurface::CreateBackTexture() { | |
| 373 DCHECK(IsContextValid(helper_.get())); | |
| 374 // If |is_swap_buffers_pending| we are waiting for our backbuffer | |
| 375 // in the mailbox, so we shouldn't be reallocating it now. | |
| 376 DCHECK(!is_swap_buffers_pending_); | |
| 377 | |
| 378 if (backbuffer_.get() && backbuffer_size() == current_size_) | |
| 379 return; | |
| 380 | |
| 381 VLOG(1) << "Allocating new backbuffer texture"; | |
| 382 | |
| 383 GLES2Decoder* decoder = helper_->stub()->decoder(); | |
| 384 TextureManager* texture_manager = | |
| 385 decoder->GetContextGroup()->texture_manager(); | |
| 386 if (!backbuffer_.get()) { | |
| 387 back_mailbox_ = gpu::Mailbox::Generate(); | |
| 388 GLuint service_id; | |
| 389 glGenTextures(1, &service_id); | |
| 390 backbuffer_ = TextureRef::Create(texture_manager, 0, service_id); | |
| 391 texture_manager->SetTarget(backbuffer_.get(), GL_TEXTURE_2D); | |
| 392 Texture* texture = texture_manager->Produce(backbuffer_.get()); | |
| 393 mailbox_manager_->ProduceTexture(GL_TEXTURE_2D, back_mailbox_, texture); | |
| 394 } | |
| 395 | |
| 396 { | |
| 397 gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, | |
| 398 backbuffer_->service_id()); | |
| 399 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, | |
| 400 current_size_.width(), current_size_.height(), 0, | |
| 401 GL_RGBA, GL_UNSIGNED_BYTE, NULL); | |
| 402 gpu::gles2::ErrorState* error_state = decoder->GetErrorState(); | |
| 403 texture_manager->SetParameteri("Backbuffer", | |
| 404 error_state, | |
| 405 backbuffer_.get(), | |
| 406 GL_TEXTURE_MIN_FILTER, | |
| 407 GL_LINEAR); | |
| 408 texture_manager->SetParameteri("Backbuffer", | |
| 409 error_state, | |
| 410 backbuffer_.get(), | |
| 411 GL_TEXTURE_MAG_FILTER, | |
| 412 GL_LINEAR); | |
| 413 texture_manager->SetParameteri("Backbuffer", | |
| 414 error_state, | |
| 415 backbuffer_.get(), | |
| 416 GL_TEXTURE_WRAP_S, | |
| 417 GL_CLAMP_TO_EDGE); | |
| 418 texture_manager->SetParameteri("Backbuffer", | |
| 419 error_state, | |
| 420 backbuffer_.get(), | |
| 421 GL_TEXTURE_WRAP_T, | |
| 422 GL_CLAMP_TO_EDGE); | |
| 423 texture_manager->SetLevelInfo(backbuffer_.get(), | |
| 424 GL_TEXTURE_2D, | |
| 425 0, | |
| 426 GL_RGBA, | |
| 427 current_size_.width(), | |
| 428 current_size_.height(), | |
| 429 1, | |
| 430 0, | |
| 431 GL_RGBA, | |
| 432 GL_UNSIGNED_BYTE, | |
| 433 true); | |
| 434 DCHECK(texture_manager->CanRender(backbuffer_.get())); | |
| 435 CHECK_GL_ERROR(); | |
| 436 } | |
| 437 | |
| 438 AttachBackTextureToFBO(); | |
| 439 } | |
| 440 | |
| 441 void TextureImageTransportSurface::AttachBackTextureToFBO() { | |
| 442 DCHECK(IsContextValid(helper_.get())); | |
| 443 DCHECK(backbuffer_.get()); | |
| 444 gfx::ScopedFrameBufferBinder fbo_binder(fbo_id_); | |
| 445 glFramebufferTexture2DEXT(GL_FRAMEBUFFER, | |
| 446 GL_COLOR_ATTACHMENT0, | |
| 447 GL_TEXTURE_2D, | |
| 448 backbuffer_->service_id(), | |
| 449 0); | |
| 450 CHECK_GL_ERROR(); | |
| 451 | |
| 452 #ifndef NDEBUG | |
| 453 GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER); | |
| 454 if (status != GL_FRAMEBUFFER_COMPLETE) { | |
| 455 DLOG(FATAL) << "Framebuffer incomplete: " << status; | |
| 456 } | |
| 457 #endif | |
| 458 } | |
| 459 | |
| 460 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 615503004:
Remove TextureImageTransportSurface (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master