2014-06-16 20:34:55 +02:00
|
|
|
/*
|
|
|
|
* Copyright © 2011-2014 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software
|
|
|
|
* and its documentation for any purpose is hereby granted without
|
|
|
|
* fee, provided that the above copyright notice appear in all copies
|
|
|
|
* and that both that copyright notice and this permission notice
|
|
|
|
* appear in supporting documentation, and that the name of the
|
|
|
|
* copyright holders not be used in advertising or publicity
|
|
|
|
* pertaining to distribution of the software without specific,
|
|
|
|
* written prior permission. The copyright holders make no
|
|
|
|
* representations about the suitability of this software for any
|
|
|
|
* purpose. It is provided "as is" without express or implied
|
|
|
|
* warranty.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
|
|
|
|
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "xwayland.h"
|
|
|
|
|
|
|
|
#define MESA_EGL_NO_X11_HEADERS
|
2019-11-04 20:03:17 +01:00
|
|
|
#define EGL_NO_X11
|
2016-10-05 18:34:34 +02:00
|
|
|
#include <glamor_egl.h>
|
2014-06-16 20:34:55 +02:00
|
|
|
|
|
|
|
#include <glamor.h>
|
|
|
|
#include <glamor_context.h>
|
2019-05-08 20:09:00 +02:00
|
|
|
#ifdef GLXEXT
|
|
|
|
#include "glx_extinit.h"
|
|
|
|
#endif
|
2014-06-16 20:34:55 +02:00
|
|
|
|
|
|
|
static void
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
glamor_egl_make_current(struct glamor_context *glamor_ctx)
|
2014-06-16 20:34:55 +02:00
|
|
|
{
|
|
|
|
eglMakeCurrent(glamor_ctx->display, EGL_NO_SURFACE,
|
|
|
|
EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
|
|
|
if (!eglMakeCurrent(glamor_ctx->display,
|
|
|
|
EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
|
|
glamor_ctx->ctx))
|
|
|
|
FatalError("Failed to make EGL context current\n");
|
|
|
|
}
|
|
|
|
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
void
|
|
|
|
xwl_glamor_egl_make_current(struct xwl_screen *xwl_screen)
|
|
|
|
{
|
|
|
|
if (lastGLContext == xwl_screen->glamor_ctx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lastGLContext = xwl_screen->glamor_ctx;
|
|
|
|
xwl_screen->glamor_ctx->make_current(xwl_screen->glamor_ctx);
|
|
|
|
}
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
void
|
|
|
|
glamor_egl_screen_init(ScreenPtr screen, struct glamor_context *glamor_ctx)
|
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
|
|
|
|
|
2018-07-25 16:33:23 +02:00
|
|
|
glamor_enable_dri3(screen);
|
2014-06-16 20:34:55 +02:00
|
|
|
glamor_ctx->ctx = xwl_screen->egl_context;
|
|
|
|
glamor_ctx->display = xwl_screen->egl_display;
|
|
|
|
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
glamor_ctx->make_current = glamor_egl_make_current;
|
2014-06-16 20:34:55 +02:00
|
|
|
|
|
|
|
xwl_screen->glamor_ctx = glamor_ctx;
|
|
|
|
}
|
|
|
|
|
2018-04-20 20:38:03 +02:00
|
|
|
void
|
|
|
|
xwl_glamor_init_wl_registry(struct xwl_screen *xwl_screen,
|
|
|
|
struct wl_registry *registry,
|
|
|
|
uint32_t id, const char *interface,
|
|
|
|
uint32_t version)
|
2014-06-16 20:34:55 +02:00
|
|
|
{
|
2018-06-05 19:38:43 +02:00
|
|
|
if (xwl_screen->gbm_backend.is_available &&
|
|
|
|
xwl_screen->gbm_backend.init_wl_registry(xwl_screen,
|
|
|
|
registry,
|
|
|
|
id,
|
|
|
|
interface,
|
2018-10-16 01:39:54 +02:00
|
|
|
version)) {
|
|
|
|
/* no-op */
|
|
|
|
} else if (xwl_screen->eglstream_backend.is_available &&
|
2018-06-05 19:38:43 +02:00
|
|
|
xwl_screen->eglstream_backend.init_wl_registry(xwl_screen,
|
|
|
|
registry,
|
|
|
|
id,
|
|
|
|
interface,
|
2018-10-16 01:39:54 +02:00
|
|
|
version)) {
|
|
|
|
/* no-op */
|
|
|
|
}
|
2014-06-16 20:34:55 +02:00
|
|
|
}
|
|
|
|
|
2018-06-05 19:38:41 +02:00
|
|
|
Bool
|
|
|
|
xwl_glamor_has_wl_interfaces(struct xwl_screen *xwl_screen,
|
|
|
|
struct xwl_egl_backend *xwl_egl_backend)
|
|
|
|
{
|
2018-06-11 09:21:08 +02:00
|
|
|
return xwl_egl_backend->has_wl_interfaces(xwl_screen);
|
2018-06-05 19:38:41 +02:00
|
|
|
}
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
struct wl_buffer *
|
2018-03-13 16:00:52 +01:00
|
|
|
xwl_glamor_pixmap_get_wl_buffer(PixmapPtr pixmap,
|
|
|
|
Bool *created)
|
2014-06-16 20:34:55 +02:00
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_screen_get(pixmap->drawable.pScreen);
|
|
|
|
|
2018-06-05 19:38:43 +02:00
|
|
|
if (xwl_screen->egl_backend->get_wl_buffer_for_pixmap)
|
|
|
|
return xwl_screen->egl_backend->get_wl_buffer_for_pixmap(pixmap,
|
2018-06-11 09:13:30 +02:00
|
|
|
created);
|
2014-06-16 20:34:55 +02:00
|
|
|
|
2018-04-20 20:38:03 +02:00
|
|
|
return NULL;
|
2014-06-16 20:34:55 +02:00
|
|
|
}
|
|
|
|
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
void
|
|
|
|
xwl_glamor_post_damage(struct xwl_window *xwl_window,
|
|
|
|
PixmapPtr pixmap, RegionPtr region)
|
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
|
|
|
|
|
2018-06-05 19:38:43 +02:00
|
|
|
if (xwl_screen->egl_backend->post_damage)
|
|
|
|
xwl_screen->egl_backend->post_damage(xwl_window, pixmap, region);
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
xwl_glamor_allow_commits(struct xwl_window *xwl_window)
|
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_window->xwl_screen;
|
|
|
|
|
2018-06-05 19:38:43 +02:00
|
|
|
if (xwl_screen->egl_backend->allow_commits)
|
|
|
|
return xwl_screen->egl_backend->allow_commits(xwl_window);
|
xwayland: Add glamor egl_backend for EGLStreams
This adds initial support for displaying Xwayland applications through
the use of EGLStreams and nvidia's custom wayland protocol by adding
another egl_backend driver. This also adds some additional egl_backend
hooks that are required to make things work properly.
EGLStreams work a lot differently then the traditional way of handling
buffers with wayland. Unfortunately, there are also a LOT of various
pitfalls baked into it's design that need to be explained.
This has a very large and unfortunate implication: direct rendering is,
for the time being at least, impossible to do through EGLStreams. The
main reason being that the EGLStream spec mandates that we lose the
entire color buffer contents with each eglSwapBuffers(), which goes
against X's requirement of not losing data with pixmaps. no way to use
an allocated EGLSurface as the storage for glamor rendering like we do
with GBM, we have to rely on blitting each pixmap to it's respective
EGLSurface producer each frame. In order to pull this off, we add two
different additional egl_backend hooks that GBM opts out of
implementing:
- egl_backend.allow_commits for holding off displaying any EGLStream
backed pixmaps until the point where it's stream is completely
initialized and ready for use
- egl_backend.post_damage for blitting the content of the EGLStream
surface producer before Xwayland actually damages and commits the
wl_surface to the screen.
The other big pitfall here is that using nvidia's wayland-eglstreams
helper library is also not possible for the most part. All of it's API
for creating and destroying streams rely on being able to perform a
roundtrip in order to bring each stream to completion since the wayland
compositor must perform it's job of connecting a consumer to each
EGLstream. Because Xwayland has to potentially handle both responding to
the wayland compositor and it's own X clients, the situation of the
wayland compositor being one of our X clients must be considered. If we
perform a roundtrip with the Wayland compositor, it's possible that the
wayland compositor might currently be connected to us as an X client and
thus hang while both Xwayland and the wayland compositor await responses
from eachother. To avoid this, we work directly with the wayland
protocol and use wl_display_sync() events along with release() events to
set up and destroy EGLStreams asynchronously alongside handling X
clients.
Additionally, since setting up EGLStreams is not an atomic operation we
have to take into consideration the fact that an EGLStream can
potentially be created in response to a window resize, then immediately
deleted due to another pending window resize in the same X client's
pending reqests before Xwayland hits the part of it's event loop where
we read from the wayland compositor. To make this even more painful, we
also have to take into consideration that since EGLStreams are not
atomic that it's possible we could delete wayland resources for an
EGLStream before the compositor even finishes using them and thus run
into errors. So, we use quite a bit of tracking logic to keep EGLStream
objects alive until we know the compositor isn't using them (even if
this means the stream outlives the pixmap it backed).
While the default backend for glamor remains GBM, this patch exists for
users who have had to deal with the reprecussion of their GPU
manufacturers ignoring the advice of upstream and the standardization of
GBM across most major GPU manufacturers. It is not intended to be a
final solution to the GBM debate, but merely a baindaid so our users
don't have to suffer from the consequences of companies avoiding working
upstream. New drivers are strongly encouraged not to use this as a
backend, and use GBM like everyone else. We even spit this out as an
error from Xwayland when using the eglstream backend.
Signed-off-by: Lyude Paul <lyude@redhat.com>
Acked-by: Daniel Stone <daniels@collabora.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-04-20 20:38:05 +02:00
|
|
|
else
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
static Bool
|
|
|
|
xwl_glamor_create_screen_resources(ScreenPtr screen)
|
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
screen->CreateScreenResources = xwl_screen->CreateScreenResources;
|
|
|
|
ret = (*screen->CreateScreenResources) (screen);
|
|
|
|
xwl_screen->CreateScreenResources = screen->CreateScreenResources;
|
|
|
|
screen->CreateScreenResources = xwl_glamor_create_screen_resources;
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return ret;
|
|
|
|
|
2015-11-23 08:51:48 +01:00
|
|
|
if (xwl_screen->rootless) {
|
2014-06-16 20:34:55 +02:00
|
|
|
screen->devPrivate =
|
|
|
|
fbCreatePixmap(screen, 0, 0, screen->rootDepth, 0);
|
2015-11-23 08:51:48 +01:00
|
|
|
}
|
2014-06-16 20:34:55 +02:00
|
|
|
else {
|
2018-04-20 20:38:03 +02:00
|
|
|
screen->devPrivate = screen->CreatePixmap(
|
|
|
|
screen, screen->width, screen->height, screen->rootDepth,
|
|
|
|
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
|
2014-06-16 20:34:55 +02:00
|
|
|
}
|
|
|
|
|
dix: Add hybrid full-size/empty-clip mode to SetRootClip
216bdbc735 removed the SetRootClip call in the XWayland output-hotplug
handler when running rootless (e.g. as a part of Weston/Mutter), since
the root window has no storage, so generating exposures will result in
writes to invalid memory.
Unfortunately, preventing the segfault also breaks sprite confinement.
SetRootClip updates winSize and borderSize for the root window, which
when combined with RRScreenSizeChanged calling ScreenRestructured,
generates a new sprite-confinment area to update it to the whole screen.
Removing this call results in the window geometry being reported
correctly, but winSize/borderSize never changing from their values at
startup, i.e. out of sync with the root window geometry / screen
information in the connection info / XRandR.
This patch introduces a hybrid mode, where we update winSize and
borderSize for the root window, enabling sprite confinement to work
correctly, but keep the clip emptied so exposures are never generated.
Signed-off-by: Daniel Stone <daniels@collabora.com>
Tested-by: Olivier Fourdan <ofourdan@redhat.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2016-02-12 17:36:59 +01:00
|
|
|
SetRootClip(screen, xwl_screen->root_clip_mode);
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
return screen->devPrivate != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2018-02-28 02:19:43 +01:00
|
|
|
glamor_egl_fd_name_from_pixmap(ScreenPtr screen,
|
|
|
|
PixmapPtr pixmap,
|
|
|
|
CARD16 *stride, CARD32 *size)
|
2014-06-16 20:34:55 +02:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-06-05 19:38:42 +02:00
|
|
|
void
|
|
|
|
xwl_glamor_init_backends(struct xwl_screen *xwl_screen, Bool use_eglstream)
|
|
|
|
{
|
2018-06-05 19:38:43 +02:00
|
|
|
#ifdef GLAMOR_HAS_GBM
|
|
|
|
xwl_glamor_init_gbm(xwl_screen);
|
|
|
|
if (!xwl_screen->gbm_backend.is_available && !use_eglstream)
|
|
|
|
ErrorF("xwayland glamor: GBM backend (default) is not available\n");
|
|
|
|
#endif
|
2018-06-05 19:38:42 +02:00
|
|
|
#ifdef XWL_HAS_EGLSTREAM
|
2018-06-05 19:38:43 +02:00
|
|
|
xwl_glamor_init_eglstream(xwl_screen);
|
|
|
|
if (!xwl_screen->eglstream_backend.is_available && use_eglstream)
|
|
|
|
ErrorF("xwayland glamor: EGLStream backend requested but not available\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
xwl_glamor_select_gbm_backend(struct xwl_screen *xwl_screen)
|
|
|
|
{
|
|
|
|
#ifdef GLAMOR_HAS_GBM
|
|
|
|
if (xwl_screen->gbm_backend.is_available &&
|
|
|
|
xwl_glamor_has_wl_interfaces(xwl_screen, &xwl_screen->gbm_backend)) {
|
|
|
|
xwl_screen->egl_backend = &xwl_screen->gbm_backend;
|
|
|
|
return TRUE;
|
2018-06-05 19:38:42 +02:00
|
|
|
}
|
2018-06-05 19:38:43 +02:00
|
|
|
else
|
|
|
|
ErrorF("Missing Wayland requirements for glamor GBM backend\n");
|
2018-06-05 19:38:42 +02:00
|
|
|
#endif
|
2018-06-05 19:38:43 +02:00
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
xwl_glamor_select_eglstream_backend(struct xwl_screen *xwl_screen)
|
|
|
|
{
|
|
|
|
#ifdef XWL_HAS_EGLSTREAM
|
|
|
|
if (xwl_screen->eglstream_backend.is_available &&
|
|
|
|
xwl_glamor_has_wl_interfaces(xwl_screen, &xwl_screen->eglstream_backend)) {
|
|
|
|
ErrorF("glamor: Using nvidia's EGLStream interface, direct rendering impossible.\n");
|
|
|
|
ErrorF("glamor: Performance may be affected. Ask your vendor to support GBM!\n");
|
|
|
|
xwl_screen->egl_backend = &xwl_screen->eglstream_backend;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ErrorF("Missing Wayland requirements for glamor EGLStream backend\n");
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xwl_glamor_select_backend(struct xwl_screen *xwl_screen, Bool use_eglstream)
|
|
|
|
{
|
|
|
|
if (use_eglstream) {
|
|
|
|
if (!xwl_glamor_select_eglstream_backend(xwl_screen))
|
|
|
|
xwl_glamor_select_gbm_backend(xwl_screen);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!xwl_glamor_select_gbm_backend(xwl_screen))
|
|
|
|
xwl_glamor_select_eglstream_backend(xwl_screen);
|
2018-06-05 19:38:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
Bool
|
|
|
|
xwl_glamor_init(struct xwl_screen *xwl_screen)
|
|
|
|
{
|
|
|
|
ScreenPtr screen = xwl_screen->screen;
|
2017-03-02 11:03:15 +01:00
|
|
|
const char *no_glamor_env;
|
|
|
|
|
|
|
|
no_glamor_env = getenv("XWAYLAND_NO_GLAMOR");
|
|
|
|
if (no_glamor_env && *no_glamor_env != '0') {
|
|
|
|
ErrorF("Disabling glamor and dri3 support, XWAYLAND_NO_GLAMOR is set\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
2014-06-16 20:34:55 +02:00
|
|
|
|
2018-06-05 19:38:43 +02:00
|
|
|
if (!xwl_screen->egl_backend->init_egl(xwl_screen)) {
|
2018-04-20 20:38:03 +02:00
|
|
|
ErrorF("EGL setup failed, disabling glamor\n");
|
2014-06-16 20:34:55 +02:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2014-10-30 04:30:12 +01:00
|
|
|
if (!glamor_init(xwl_screen->screen, GLAMOR_USE_EGL_SCREEN)) {
|
2014-06-16 20:34:55 +02:00
|
|
|
ErrorF("Failed to initialize glamor\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2018-06-05 19:38:43 +02:00
|
|
|
if (!xwl_screen->egl_backend->init_screen(xwl_screen)) {
|
2018-04-20 20:38:03 +02:00
|
|
|
ErrorF("EGL backend init_screen() failed, disabling glamor\n");
|
2017-03-08 10:32:22 +01:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
xwl_screen->CreateScreenResources = screen->CreateScreenResources;
|
|
|
|
screen->CreateScreenResources = xwl_glamor_create_screen_resources;
|
|
|
|
|
2016-03-09 16:21:18 +01:00
|
|
|
#ifdef XV
|
|
|
|
if (!xwl_glamor_xv_init(screen))
|
|
|
|
ErrorF("Failed to initialize glamor Xv extension\n");
|
|
|
|
#endif
|
|
|
|
|
2019-05-08 20:09:00 +02:00
|
|
|
#ifdef GLXEXT
|
|
|
|
GlxPushProvider(&glamor_provider);
|
|
|
|
#endif
|
|
|
|
|
2014-06-16 20:34:55 +02:00
|
|
|
return TRUE;
|
|
|
|
}
|