| // Copyright 2014 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 "ui/gl/gl_surface.h" |
| |
| #include "base/bind.h" |
| #include "base/callback.h" |
| #include "base/location.h" |
| #include "base/logging.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/threading/worker_pool.h" |
| #include "ui/gfx/native_widget_types.h" |
| #include "ui/gl/gl_context.h" |
| #include "ui/gl/gl_image.h" |
| #include "ui/gl/gl_image_linux_dma_buffer.h" |
| #include "ui/gl/gl_implementation.h" |
| #include "ui/gl/gl_surface_egl.h" |
| #include "ui/gl/gl_surface_osmesa.h" |
| #include "ui/gl/gl_surface_stub.h" |
| #include "ui/gl/scoped_binders.h" |
| #include "ui/gl/scoped_make_current.h" |
| #include "ui/ozone/public/native_pixmap.h" |
| #include "ui/ozone/public/surface_factory_ozone.h" |
| #include "ui/ozone/public/surface_ozone_egl.h" |
| |
| namespace gfx { |
| |
| namespace { |
| |
| void WaitForFence(EGLDisplay display, EGLSyncKHR fence) { |
| eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, |
| EGL_FOREVER_KHR); |
| } |
| |
| // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow |
| class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL { |
| public: |
| GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface, |
| AcceleratedWidget widget) |
| : NativeViewGLSurfaceEGL(ozone_surface->GetNativeWindow()), |
| ozone_surface_(ozone_surface.Pass()), |
| widget_(widget) {} |
| |
| bool Initialize() override { |
| return Initialize(ozone_surface_->CreateVSyncProvider()); |
| } |
| bool Resize(const gfx::Size& size) override { |
| if (!ozone_surface_->ResizeNativeWindow(size)) { |
| if (!ReinitializeNativeSurface() || |
| !ozone_surface_->ResizeNativeWindow(size)) |
| return false; |
| } |
| |
| return NativeViewGLSurfaceEGL::Resize(size); |
| } |
| bool SwapBuffers() override { |
| if (!NativeViewGLSurfaceEGL::SwapBuffers()) |
| return false; |
| |
| return ozone_surface_->OnSwapBuffers(); |
| } |
| bool ScheduleOverlayPlane(int z_order, |
| OverlayTransform transform, |
| GLImage* image, |
| const Rect& bounds_rect, |
| const RectF& crop_rect) override { |
| return image->ScheduleOverlayPlane( |
| widget_, z_order, transform, bounds_rect, crop_rect); |
| } |
| |
| private: |
| using NativeViewGLSurfaceEGL::Initialize; |
| |
| ~GLSurfaceOzoneEGL() override { |
| Destroy(); // EGL surface must be destroyed before SurfaceOzone |
| } |
| |
| bool ReinitializeNativeSurface() { |
| scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current; |
| GLContext* current_context = GLContext::GetCurrent(); |
| bool was_current = |
| current_context && current_context->IsCurrent(this); |
| if (was_current) { |
| scoped_make_current.reset( |
| new ui::ScopedMakeCurrent(current_context, this)); |
| } |
| |
| Destroy(); |
| ozone_surface_ = |
| ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget( |
| widget_).Pass(); |
| if (!ozone_surface_) { |
| LOG(ERROR) << "Failed to create native surface."; |
| return false; |
| } |
| |
| window_ = ozone_surface_->GetNativeWindow(); |
| if (!Initialize()) { |
| LOG(ERROR) << "Failed to initialize."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // The native surface. Deleting this is allowed to free the EGLNativeWindow. |
| scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_; |
| AcceleratedWidget widget_; |
| |
| DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneEGL); |
| }; |
| |
| class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL { |
| public: |
| GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface, |
| AcceleratedWidget widget) |
| : SurfacelessEGL(gfx::Size()), |
| ozone_surface_(ozone_surface.Pass()), |
| widget_(widget), |
| has_implicit_external_sync_( |
| HasEGLExtension("EGL_ARM_implicit_external_sync")), |
| last_swap_buffers_result_(true), |
| weak_factory_(this) {} |
| |
| bool Initialize() override { |
| if (!SurfacelessEGL::Initialize()) |
| return false; |
| vsync_provider_ = ozone_surface_->CreateVSyncProvider(); |
| if (!vsync_provider_) |
| return false; |
| return true; |
| } |
| bool Resize(const gfx::Size& size) override { |
| if (!ozone_surface_->ResizeNativeWindow(size)) |
| return false; |
| |
| return SurfacelessEGL::Resize(size); |
| } |
| bool SwapBuffers() override { |
| glFlush(); |
| // TODO: the following should be replaced by a per surface flush as it gets |
| // implemented in GL drivers. |
| if (has_implicit_external_sync_) { |
| EGLSyncKHR fence = InsertFence(); |
| if (!fence) |
| return false; |
| |
| EGLDisplay display = GetDisplay(); |
| WaitForFence(display, fence); |
| eglDestroySyncKHR(display, fence); |
| } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) { |
| glFinish(); |
| } |
| |
| return ozone_surface_->OnSwapBuffers(); |
| } |
| bool ScheduleOverlayPlane(int z_order, |
| OverlayTransform transform, |
| GLImage* image, |
| const Rect& bounds_rect, |
| const RectF& crop_rect) override { |
| return image->ScheduleOverlayPlane( |
| widget_, z_order, transform, bounds_rect, crop_rect); |
| } |
| bool IsOffscreen() override { return false; } |
| VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); } |
| bool SupportsPostSubBuffer() override { return true; } |
| bool PostSubBuffer(int x, int y, int width, int height) override { |
| // The actual sub buffer handling is handled at higher layers. |
| SwapBuffers(); |
| return true; |
| } |
| bool SwapBuffersAsync(const SwapCompletionCallback& callback) override { |
| glFlush(); |
| // TODO: the following should be replaced by a per surface flush as it gets |
| // implemented in GL drivers. |
| if (has_implicit_external_sync_) { |
| // If last swap failed, don't try to schedule new ones. |
| if (!last_swap_buffers_result_) { |
| last_swap_buffers_result_ = true; |
| return false; |
| } |
| |
| EGLSyncKHR fence = InsertFence(); |
| if (!fence) |
| return false; |
| |
| base::Closure fence_wait_task = |
| base::Bind(&WaitForFence, GetDisplay(), fence); |
| |
| base::Closure fence_retired_callback = |
| base::Bind(&GLSurfaceOzoneSurfaceless::FenceRetired, |
| weak_factory_.GetWeakPtr(), fence, callback); |
| |
| base::WorkerPool::PostTaskAndReply(FROM_HERE, fence_wait_task, |
| fence_retired_callback, false); |
| return true; |
| } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) { |
| glFinish(); |
| } |
| return ozone_surface_->OnSwapBuffersAsync(callback); |
| } |
| bool PostSubBufferAsync(int x, |
| int y, |
| int width, |
| int height, |
| const SwapCompletionCallback& callback) override { |
| return SwapBuffersAsync(callback); |
| } |
| |
| protected: |
| ~GLSurfaceOzoneSurfaceless() override { |
| Destroy(); // EGL surface must be destroyed before SurfaceOzone |
| } |
| |
| EGLSyncKHR InsertFence() { |
| const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR, |
| EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM, |
| EGL_NONE}; |
| return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attrib_list); |
| } |
| |
| void FenceRetired(EGLSyncKHR fence, const SwapCompletionCallback& callback) { |
| eglDestroySyncKHR(GetDisplay(), fence); |
| last_swap_buffers_result_ = ozone_surface_->OnSwapBuffersAsync(callback); |
| } |
| |
| // The native surface. Deleting this is allowed to free the EGLNativeWindow. |
| scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_; |
| AcceleratedWidget widget_; |
| scoped_ptr<VSyncProvider> vsync_provider_; |
| bool has_implicit_external_sync_; |
| bool last_swap_buffers_result_; |
| |
| base::WeakPtrFactory<GLSurfaceOzoneSurfaceless> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfaceless); |
| }; |
| |
| // This provides surface-like semantics implemented through surfaceless. |
| // A framebuffer is bound automatically. |
| class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl |
| : public GLSurfaceOzoneSurfaceless { |
| public: |
| GLSurfaceOzoneSurfacelessSurfaceImpl( |
| scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface, |
| AcceleratedWidget widget) |
| : GLSurfaceOzoneSurfaceless(ozone_surface.Pass(), widget), |
| fbo_(0), |
| current_surface_(0) { |
| for (auto& texture : textures_) |
| texture = 0; |
| } |
| |
| unsigned int GetBackingFrameBufferObject() override { return fbo_; } |
| |
| bool OnMakeCurrent(GLContext* context) override { |
| if (!fbo_) { |
| glGenFramebuffersEXT(1, &fbo_); |
| if (!fbo_) |
| return false; |
| glGenTextures(arraysize(textures_), textures_); |
| if (!CreatePixmaps()) |
| return false; |
| } |
| BindFramebuffer(); |
| glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_); |
| return SurfacelessEGL::OnMakeCurrent(context); |
| } |
| |
| bool Resize(const gfx::Size& size) override { |
| if (size == GetSize()) |
| return true; |
| return GLSurfaceOzoneSurfaceless::Resize(size) && CreatePixmaps(); |
| } |
| |
| bool SupportsPostSubBuffer() override { return false; } |
| |
| bool SwapBuffers() override { |
| if (!images_[current_surface_]->ScheduleOverlayPlane( |
| widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE, |
| gfx::Rect(GetSize()), gfx::RectF(1, 1))) |
| return false; |
| if (!GLSurfaceOzoneSurfaceless::SwapBuffers()) |
| return false; |
| current_surface_ ^= 1; |
| BindFramebuffer(); |
| return true; |
| } |
| |
| bool SwapBuffersAsync(const SwapCompletionCallback& callback) override { |
| if (!images_[current_surface_]->ScheduleOverlayPlane( |
| widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE, |
| gfx::Rect(GetSize()), gfx::RectF(1, 1))) |
| return false; |
| if (!GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback)) |
| return false; |
| current_surface_ ^= 1; |
| BindFramebuffer(); |
| return true; |
| } |
| |
| void Destroy() override { |
| GLContext* current_context = GLContext::GetCurrent(); |
| DCHECK(current_context && current_context->IsCurrent(this)); |
| glBindFramebufferEXT(GL_FRAMEBUFFER, 0); |
| if (fbo_) { |
| glDeleteTextures(arraysize(textures_), textures_); |
| for (auto& texture : textures_) |
| texture = 0; |
| glDeleteFramebuffersEXT(1, &fbo_); |
| fbo_ = 0; |
| } |
| for (auto image : images_) { |
| if (image) |
| image->Destroy(true); |
| } |
| } |
| |
| private: |
| class SurfaceImage : public GLImageLinuxDMABuffer { |
| public: |
| SurfaceImage(const gfx::Size& size, unsigned internalformat) |
| : GLImageLinuxDMABuffer(size, internalformat) {} |
| |
| bool Initialize(scoped_refptr<ui::NativePixmap> pixmap, |
| gfx::GpuMemoryBuffer::Format format) { |
| base::FileDescriptor handle(pixmap->GetDmaBufFd(), false); |
| if (!GLImageLinuxDMABuffer::Initialize(handle, format, |
| pixmap->GetDmaBufPitch())) |
| return false; |
| pixmap_ = pixmap; |
| return true; |
| } |
| bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget, |
| int z_order, |
| gfx::OverlayTransform transform, |
| const gfx::Rect& bounds_rect, |
| const gfx::RectF& crop_rect) override { |
| return ui::SurfaceFactoryOzone::GetInstance()->ScheduleOverlayPlane( |
| widget, z_order, transform, pixmap_, bounds_rect, crop_rect); |
| } |
| |
| private: |
| ~SurfaceImage() override {} |
| |
| scoped_refptr<ui::NativePixmap> pixmap_; |
| }; |
| |
| ~GLSurfaceOzoneSurfacelessSurfaceImpl() override { |
| DCHECK(!fbo_); |
| for (size_t i = 0; i < arraysize(textures_); i++) |
| DCHECK(!textures_[i]) << "texture " << i << " not released"; |
| } |
| |
| void BindFramebuffer() { |
| ScopedFrameBufferBinder fb(fbo_); |
| glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, |
| GL_TEXTURE_2D, textures_[current_surface_], 0); |
| } |
| |
| bool CreatePixmaps() { |
| if (!fbo_) |
| return true; |
| for (size_t i = 0; i < arraysize(textures_); i++) { |
| scoped_refptr<ui::NativePixmap> pixmap = |
| ui::SurfaceFactoryOzone::GetInstance()->CreateNativePixmap( |
| widget_, GetSize(), ui::SurfaceFactoryOzone::RGBA_8888, |
| ui::SurfaceFactoryOzone::SCANOUT); |
| if (!pixmap) |
| return false; |
| scoped_refptr<SurfaceImage> image = new SurfaceImage(GetSize(), GL_RGBA); |
| if (!image->Initialize(pixmap, gfx::GpuMemoryBuffer::Format::BGRA_8888)) |
| return false; |
| images_[i] = image; |
| // Bind image to texture. |
| ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]); |
| if (!images_[i]->BindTexImage(GL_TEXTURE_2D)) |
| return false; |
| } |
| return true; |
| } |
| |
| GLuint fbo_; |
| GLuint textures_[2]; |
| scoped_refptr<GLImage> images_[2]; |
| int current_surface_; |
| DISALLOW_COPY_AND_ASSIGN(GLSurfaceOzoneSurfacelessSurfaceImpl); |
| }; |
| |
| } // namespace |
| |
| // static |
| bool GLSurface::InitializeOneOffInternal() { |
| switch (GetGLImplementation()) { |
| case kGLImplementationEGLGLES2: |
| if (!GLSurfaceEGL::InitializeOneOff()) { |
| LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed."; |
| return false; |
| } |
| |
| return true; |
| case kGLImplementationOSMesaGL: |
| case kGLImplementationMockGL: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // static |
| scoped_refptr<GLSurface> GLSurface::CreateSurfacelessViewGLSurface( |
| gfx::AcceleratedWidget window) { |
| if (GetGLImplementation() == kGLImplementationEGLGLES2 && |
| window != kNullAcceleratedWidget && |
| GLSurfaceEGL::IsEGLSurfacelessContextSupported() && |
| ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) { |
| scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone = |
| ui::SurfaceFactoryOzone::GetInstance() |
| ->CreateSurfacelessEGLSurfaceForWidget(window); |
| if (!surface_ozone) |
| return nullptr; |
| scoped_refptr<GLSurface> surface; |
| surface = new GLSurfaceOzoneSurfaceless(surface_ozone.Pass(), window); |
| if (surface->Initialize()) |
| return surface; |
| } |
| |
| return nullptr; |
| } |
| |
| // static |
| scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface( |
| gfx::AcceleratedWidget window) { |
| if (GetGLImplementation() == kGLImplementationOSMesaGL) { |
| scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless()); |
| if (!surface->Initialize()) |
| return NULL; |
| return surface; |
| } |
| DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2); |
| if (window != kNullAcceleratedWidget) { |
| scoped_refptr<GLSurface> surface; |
| if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() && |
| ui::SurfaceFactoryOzone::GetInstance() |
| ->CanShowPrimaryPlaneAsOverlay()) { |
| scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone = |
| ui::SurfaceFactoryOzone::GetInstance() |
| ->CreateSurfacelessEGLSurfaceForWidget(window); |
| if (!surface_ozone) |
| return NULL; |
| surface = new GLSurfaceOzoneSurfacelessSurfaceImpl(surface_ozone.Pass(), |
| window); |
| } else { |
| scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone = |
| ui::SurfaceFactoryOzone::GetInstance()->CreateEGLSurfaceForWidget( |
| window); |
| if (!surface_ozone) |
| return NULL; |
| |
| surface = new GLSurfaceOzoneEGL(surface_ozone.Pass(), window); |
| } |
| if (!surface->Initialize()) |
| return NULL; |
| return surface; |
| } else { |
| scoped_refptr<GLSurface> surface = new GLSurfaceStub(); |
| if (surface->Initialize()) |
| return surface; |
| } |
| return NULL; |
| } |
| |
| // static |
| scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface( |
| const gfx::Size& size) { |
| switch (GetGLImplementation()) { |
| case kGLImplementationOSMesaGL: { |
| scoped_refptr<GLSurface> surface( |
| new GLSurfaceOSMesa(OSMesaSurfaceFormatBGRA, size)); |
| if (!surface->Initialize()) |
| return NULL; |
| |
| return surface; |
| } |
| case kGLImplementationEGLGLES2: { |
| scoped_refptr<GLSurface> surface; |
| if (GLSurfaceEGL::IsEGLSurfacelessContextSupported() && |
| (size.width() == 0 && size.height() == 0)) { |
| surface = new SurfacelessEGL(size); |
| } else |
| surface = new PbufferGLSurfaceEGL(size); |
| |
| if (!surface->Initialize()) |
| return NULL; |
| return surface; |
| } |
| default: |
| NOTREACHED(); |
| return NULL; |
| } |
| } |
| |
| EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() { |
| return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay(); |
| } |
| |
| } // namespace gfx |