isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-28 11:00:54 -05:00
Code Issues Packages Projects Releases Wiki Activity
65401ed3f9
mutter/src/backends/native/meta-renderer-native-gles3.c

158 lines
5.4 KiB
C
Raw Normal View History

renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
renderer/native: honour dumb buffer stride meta_renderer_native_gles3_read_pixels() was assuming that the target buffer stride == width * 4. This is not generally true. When a DRM driver allocates a dumb buffer, it is free to choose a stride so that the buffer can actually work on the hardware. Record the driver chosen stride in MetaDumbBuffer, and use it in the CPU copy path. This should fix any possible stride issues in meta_renderer_native_gles3_read_pixels().
2018-09-05 05:07:59 -04:00
* Copyright (c) 2018 DisplayLink (UK) Ltd.
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
*/
#include "config.h"
#define GL_GLEXT_PROTOTYPES
#include "backends/native/meta-renderer-native-gles3.h"
Clean up include macros mess The order and way include macros were structured was chaotic, with no real common thread between files. Try to tidy up the mess with some common scheme, to make things look less messy.
2018-07-10 04:36:24 -04:00
#include <GLES3/gl3.h>
renderer/native: Create GBM surfaces with modifiers Now that we have the list of supported modifiers from the monitor manager (via the CRTCs to the primary planes), we can use this to inform EGL it can use those modifiers to allocate the GBM surface with. Doing so allows us to use tiling and compression for our scanout surfaces. This requires the Mesa commit in: Mesa 10.3 (08264e5dad4df448e7718e782ad9077902089a07) or Mesa 10.2.7 (55d28925e6109a4afd61f109e845a8a51bd17652). Otherwise Mesa closes the fd behind our back and re-importing will fail. See FDO bug #76188 for details. https://bugzilla.gnome.org/show_bug.cgi?id=785779
2017-08-03 10:42:50 -04:00
#include <drm_fourcc.h>
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
#include <errno.h>
renderer-native-gles3: Remove unnecessary includes They caused conflicts on i686 as GL/gl.h was included by cogl. https://bugzilla.gnome.org/show_bug.cgi?id=788695
2017-10-30 04:08:12 -04:00
#include <gio/gio.h>
#include <string.h>
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
renderer/native: Create GBM surfaces with modifiers Now that we have the list of supported modifiers from the monitor manager (via the CRTCs to the primary planes), we can use this to inform EGL it can use those modifiers to allocate the GBM surface with. Doing so allows us to use tiling and compression for our scanout surfaces. This requires the Mesa commit in: Mesa 10.3 (08264e5dad4df448e7718e782ad9077902089a07) or Mesa 10.2.7 (55d28925e6109a4afd61f109e845a8a51bd17652). Otherwise Mesa closes the fd behind our back and re-importing will fail. See FDO bug #76188 for details. https://bugzilla.gnome.org/show_bug.cgi?id=785779
2017-08-03 10:42:50 -04:00
#include "backends/meta-egl-ext.h"
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
#include "backends/meta-gles3.h"
#include "backends/meta-gles3-table.h"
renderer-native-gles3: Add cpp error if gl.h was included On some architectures, including both GLES3/gl3.h GL/gl.h will cause compilation issues due to incompatible type definitions. To avoid running into that issue while building on other architectures, make sure we haven't included GL/gl.h by accident. https://bugzilla.gnome.org/show_bug.cgi?id=788695
2017-10-30 04:08:46 -04:00
/*
* GL/gl.h being included may conflit with gl3.h on some architectures.
* Make sure that hasn't happened on any architecture.
*/
#ifdef GL_VERSION_1_1
#error "Somehow included OpenGL headers when we shouldn't have"
#endif
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
static void
paint_egl_image (MetaGles3 *gles3,
EGLImageKHR egl_image,
int width,
int height)
{
GLuint texture;
GLuint framebuffer;
meta_gles3_clear_error (gles3);
GLBAS (gles3, glGenFramebuffers, (1, &framebuffer));
GLBAS (gles3, glBindFramebuffer, (GL_READ_FRAMEBUFFER, framebuffer));
GLBAS (gles3, glActiveTexture, (GL_TEXTURE0));
GLBAS (gles3, glGenTextures, (1, &texture));
GLBAS (gles3, glBindTexture, (GL_TEXTURE_2D, texture));
GLEXT (gles3, glEGLImageTargetTexture2DOES, (GL_TEXTURE_2D, egl_image));
GLBAS (gles3, glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_NEAREST));
GLBAS (gles3, glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST));
GLBAS (gles3, glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE));
GLBAS (gles3, glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE));
GLBAS (gles3, glTexParameteri, (GL_TEXTURE_2D, GL_TEXTURE_WRAP_R_OES,
GL_CLAMP_TO_EDGE));
GLBAS (gles3, glFramebufferTexture2D, (GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, texture, 0));
GLBAS (gles3, glBindFramebuffer, (GL_READ_FRAMEBUFFER, framebuffer));
GLBAS (gles3, glBlitFramebuffer, (0, height, width, 0,
0, 0, width, height,
GL_COLOR_BUFFER_BIT,
GL_NEAREST));
}
gboolean
meta_renderer_native_gles3_blit_shared_bo (MetaEgl *egl,
MetaGles3 *gles3,
EGLDisplay egl_display,
EGLContext egl_context,
EGLSurface egl_surface,
struct gbm_bo *shared_bo,
GError **error)
{
int shared_bo_fd;
unsigned int width;
unsigned int height;
renderer/native: Create GBM surfaces with modifiers Now that we have the list of supported modifiers from the monitor manager (via the CRTCs to the primary planes), we can use this to inform EGL it can use those modifiers to allocate the GBM surface with. Doing so allows us to use tiling and compression for our scanout surfaces. This requires the Mesa commit in: Mesa 10.3 (08264e5dad4df448e7718e782ad9077902089a07) or Mesa 10.2.7 (55d28925e6109a4afd61f109e845a8a51bd17652). Otherwise Mesa closes the fd behind our back and re-importing will fail. See FDO bug #76188 for details. https://bugzilla.gnome.org/show_bug.cgi?id=785779
2017-08-03 10:42:50 -04:00
uint32_t i, n_planes;
renderer/native: Use the right EGL image parameters for extra planes There was a typo for modifier parameter of planes 1 & 2. https://gitlab.gnome.org/GNOME/mutter/issues/18
2018-02-13 14:05:02 -05:00
uint32_t strides[4] = { 0 };
uint32_t offsets[4] = { 0 };
uint64_t modifiers[4] = { 0 };
egl: Introduce meta_egl_create_dmabuf_image This bit of code was more or less duplicated in meta-renderer-native-gles3.c and meta-wayland-dma-buf.c. Start consolidating the two implementations by moving the *-gles3.c function into meta-egl.c and generalizing it so it could also accommodate the meta-wayland-dma-buf.c usage. The workaround in the *-gles3.c implementation is moved to the caller. It is the caller's responsibility to check for the existence of the appropriate EGL extensions. Commit 6f59e4858e24c828e3ab0e611d36dfaaded1b272 worked around the lack of EGL_EXT_image_dma_buf_import_modifiers with the assumption that if the modifier is linear, there is no need to pass it into EGL. The problem is that not passing a modifier explicitly to EGL invokes implementation-defined behaviour, so we should not have that workaround in meta-egl.c. This patch intends to be pure refactoring, no behavioral changes. The one change is the addition of g_assert to catch overwriting arbitrary memory. https://gitlab.gnome.org/GNOME/mutter/merge_requests/615
2019-06-10 10:07:55 -04:00
int fds[4] = { -1, -1, -1, -1 };
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
uint32_t format;
EGLImageKHR egl_image;
egl: Introduce meta_egl_create_dmabuf_image This bit of code was more or less duplicated in meta-renderer-native-gles3.c and meta-wayland-dma-buf.c. Start consolidating the two implementations by moving the *-gles3.c function into meta-egl.c and generalizing it so it could also accommodate the meta-wayland-dma-buf.c usage. The workaround in the *-gles3.c implementation is moved to the caller. It is the caller's responsibility to check for the existence of the appropriate EGL extensions. Commit 6f59e4858e24c828e3ab0e611d36dfaaded1b272 worked around the lack of EGL_EXT_image_dma_buf_import_modifiers with the assumption that if the modifier is linear, there is no need to pass it into EGL. The problem is that not passing a modifier explicitly to EGL invokes implementation-defined behaviour, so we should not have that workaround in meta-egl.c. This patch intends to be pure refactoring, no behavioral changes. The one change is the addition of g_assert to catch overwriting arbitrary memory. https://gitlab.gnome.org/GNOME/mutter/merge_requests/615
2019-06-10 10:07:55 -04:00
gboolean use_modifiers;
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
shared_bo_fd = gbm_bo_get_fd (shared_bo);
if (shared_bo_fd < 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to export gbm_bo: %s", strerror (errno));
return FALSE;
}
width = gbm_bo_get_width (shared_bo);
height = gbm_bo_get_height (shared_bo);
format = gbm_bo_get_format (shared_bo);
renderer/native: Create GBM surfaces with modifiers Now that we have the list of supported modifiers from the monitor manager (via the CRTCs to the primary planes), we can use this to inform EGL it can use those modifiers to allocate the GBM surface with. Doing so allows us to use tiling and compression for our scanout surfaces. This requires the Mesa commit in: Mesa 10.3 (08264e5dad4df448e7718e782ad9077902089a07) or Mesa 10.2.7 (55d28925e6109a4afd61f109e845a8a51bd17652). Otherwise Mesa closes the fd behind our back and re-importing will fail. See FDO bug #76188 for details. https://bugzilla.gnome.org/show_bug.cgi?id=785779
2017-08-03 10:42:50 -04:00
n_planes = gbm_bo_get_plane_count (shared_bo);
for (i = 0; i < n_planes; i++)
{
strides[i] = gbm_bo_get_stride_for_plane (shared_bo, i);
offsets[i] = gbm_bo_get_offset (shared_bo, i);
modifiers[i] = gbm_bo_get_modifier (shared_bo);
egl: Introduce meta_egl_create_dmabuf_image This bit of code was more or less duplicated in meta-renderer-native-gles3.c and meta-wayland-dma-buf.c. Start consolidating the two implementations by moving the *-gles3.c function into meta-egl.c and generalizing it so it could also accommodate the meta-wayland-dma-buf.c usage. The workaround in the *-gles3.c implementation is moved to the caller. It is the caller's responsibility to check for the existence of the appropriate EGL extensions. Commit 6f59e4858e24c828e3ab0e611d36dfaaded1b272 worked around the lack of EGL_EXT_image_dma_buf_import_modifiers with the assumption that if the modifier is linear, there is no need to pass it into EGL. The problem is that not passing a modifier explicitly to EGL invokes implementation-defined behaviour, so we should not have that workaround in meta-egl.c. This patch intends to be pure refactoring, no behavioral changes. The one change is the addition of g_assert to catch overwriting arbitrary memory. https://gitlab.gnome.org/GNOME/mutter/merge_requests/615
2019-06-10 10:07:55 -04:00
fds[i] = shared_bo_fd;
renderer/native: Create GBM surfaces with modifiers Now that we have the list of supported modifiers from the monitor manager (via the CRTCs to the primary planes), we can use this to inform EGL it can use those modifiers to allocate the GBM surface with. Doing so allows us to use tiling and compression for our scanout surfaces. This requires the Mesa commit in: Mesa 10.3 (08264e5dad4df448e7718e782ad9077902089a07) or Mesa 10.2.7 (55d28925e6109a4afd61f109e845a8a51bd17652). Otherwise Mesa closes the fd behind our back and re-importing will fail. See FDO bug #76188 for details. https://bugzilla.gnome.org/show_bug.cgi?id=785779
2017-08-03 10:42:50 -04:00
}
egl: Introduce meta_egl_create_dmabuf_image This bit of code was more or less duplicated in meta-renderer-native-gles3.c and meta-wayland-dma-buf.c. Start consolidating the two implementations by moving the *-gles3.c function into meta-egl.c and generalizing it so it could also accommodate the meta-wayland-dma-buf.c usage. The workaround in the *-gles3.c implementation is moved to the caller. It is the caller's responsibility to check for the existence of the appropriate EGL extensions. Commit 6f59e4858e24c828e3ab0e611d36dfaaded1b272 worked around the lack of EGL_EXT_image_dma_buf_import_modifiers with the assumption that if the modifier is linear, there is no need to pass it into EGL. The problem is that not passing a modifier explicitly to EGL invokes implementation-defined behaviour, so we should not have that workaround in meta-egl.c. This patch intends to be pure refactoring, no behavioral changes. The one change is the addition of g_assert to catch overwriting arbitrary memory. https://gitlab.gnome.org/GNOME/mutter/merge_requests/615
2019-06-10 10:07:55 -04:00
/* Workaround for https://gitlab.gnome.org/GNOME/mutter/issues/18 */
if (modifiers[0] == DRM_FORMAT_MOD_LINEAR ||
modifiers[0] == DRM_FORMAT_MOD_INVALID)
use_modifiers = FALSE;
else
use_modifiers = TRUE;
egl_image = meta_egl_create_dmabuf_image (egl,
egl_display,
width,
height,
format,
n_planes,
fds,
strides,
offsets,
use_modifiers ? modifiers : NULL,
error);
renderer-native: Add hybrid GPU system support A hybrid GPU system is a system where more than one GPU is connected to connectors. A common configuration is having a integrated GPU (iGPU) connected to a laptop panel, and a dedicated GPU (dGPU) connected to one or more external connector (such as HDMI). This commit adds support for rendering the compositor stage using the iGPU, then copying the framebuffer content onto a secondary framebuffer that will be page flipped on the CRTC of the dGPU. This can work in two different ways: GPU accelerated using Open GL ES 3, or CPU unaccelerated. When supported, GPU accelerated copying works by exporting the iGPU onscreen framebuffer as a DMA-BUF, importing it as a texture on a separate dGPU EGL context, then using glBlitFramebuffer(), blitting it onto a framebuffer on the dGPU that can then be page flipped on the dGPU CRTC. When GPU acceleration is not available, copying works by creating two dumb buffers, and each frame glReadPixels() from the iGPU EGL render context directly into the dumb buffer. The dumb buffer is then page flipped on the dGPU CRTC. https://bugzilla.gnome.org/show_bug.cgi?id=785381
2017-07-24 22:21:04 -04:00
close (shared_bo_fd);
if (!egl_image)
return FALSE;
paint_egl_image (gles3, egl_image, width, height);
meta_egl_destroy_image (egl, egl_display, egl_image, NULL);
return TRUE;
}
Reference in New Issue Copy Permalink