AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 05:31:07 +00:00
Code Issues Projects Releases Wiki Activity
57073e1057
gtk/gdk/gdkdmabufegl.c

293 lines
9.7 KiB
C
Raw Normal View History

dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
/* gdkdmabufegl.c
*
* Copyright 2023 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#if defined(HAVE_DMABUF) && defined (HAVE_EGL)
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
#include "gdkdmabufeglprivate.h"
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
#include "gdkdmabufformatsbuilderprivate.h"
#include "gdkdebugprivate.h"
dmabuf: Add a fallback list of fourccs That way, we can work with older libdrm versions. The list was generated via a bit of sed and grep from the current dmabuf-fourcc.h, which is why I put it into its own file and included all the formats, no matter how old they are.
2023-11-25 00:33:04 +00:00
#include "gdkdmabuffourccprivate.h"
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
#include "gdkdmabuftextureprivate.h"
#include "gdkmemoryformatprivate.h"
#include "gdkdisplayprivate.h"
#include "gdkglcontextprivate.h"
#include "gdktexturedownloader.h"
#include <graphene.h>
/* A dmabuf downloader implementation that downloads buffers via
* gsk_renderer_render_texture + GL texture download.
*/
static gboolean
dmabufegl: Remove unsued argument from function
2023-12-16 22:19:07 +00:00
gdk_dmabuf_egl_downloader_collect_formats (GdkDisplay *display,
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
GdkDmabufFormatsBuilder *formats,
GdkDmabufFormatsBuilder *external)
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
{
GdkGLContext *context = gdk_display_get_gl_context (display);
EGLDisplay egl_display = gdk_display_get_egl_display (display);
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
int num_fourccs;
int *fourccs;
guint64 *modifiers;
unsigned int *external_only;
int n_mods;
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
if (egl_display == EGL_NO_DISPLAY ||
dmabuf: Don't check for image storage I was wrong about this extension, and it isn't even a GL extension to begin with, so revert all this.
2023-10-29 18:45:20 +00:00
!display->have_egl_dma_buf_import)
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
return FALSE;
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
gdk_gl_context_make_current (context);
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
eglQueryDmaBufFormatsEXT (egl_display, 0, NULL, &num_fourccs);
fourccs = g_new (int, num_fourccs);
eglQueryDmaBufFormatsEXT (egl_display, num_fourccs, fourccs, &num_fourccs);
n_mods = 80;
modifiers = g_new (guint64, n_mods);
external_only = g_new (unsigned int, n_mods);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
for (int i = 0; i < num_fourccs; i++)
{
int num_modifiers;
dmabuf: Refine the handling of implicit modifiers If all formats with a given fourcc are external, treat the fourcc with implicit modifiers as external too, following a sugestion by Benjamin Otte.
2023-10-25 02:24:37 +00:00
gboolean all_external;
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
eglQueryDmaBufModifiersEXT (egl_display,
fourccs[i],
0,
NULL,
NULL,
&num_modifiers);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
if (num_modifiers > n_mods)
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
{
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
n_mods = num_modifiers;
modifiers = g_renew (guint64, modifiers, n_mods);
external_only = g_renew (unsigned int, external_only, n_mods);
}
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
eglQueryDmaBufModifiersEXT (egl_display,
fourccs[i],
num_modifiers,
modifiers,
external_only,
&num_modifiers);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Refine the handling of implicit modifiers If all formats with a given fourcc are external, treat the fourcc with implicit modifiers as external too, following a sugestion by Benjamin Otte.
2023-10-25 02:24:37 +00:00
all_external = TRUE;
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
for (int j = 0; j < num_modifiers; j++)
{
/* All linear formats we support are already added my the mmap downloader.
* We don't add external formats, unless we can use them (via GLES)
*/
if (modifiers[j] != DRM_FORMAT_MOD_LINEAR &&
(!external_only[j] || gdk_gl_context_get_use_es (context)))
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
dmabufegl: Remove unsued argument from function
2023-12-16 22:19:07 +00:00
"%s EGL dmabuf format %.4s:%#" G_GINT64_MODIFIER "x",
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
external_only[j] ? "external " : "",
(char *) &fourccs[i],
modifiers[j]);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
gdk_dmabuf_formats_builder_add_format (formats, fourccs[i], modifiers[j]);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
}
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
if (external_only[j])
gdk_dmabuf_formats_builder_add_format (external, fourccs[i], modifiers[j]);
dmabuf: Refine the handling of implicit modifiers If all formats with a given fourcc are external, treat the fourcc with implicit modifiers as external too, following a sugestion by Benjamin Otte.
2023-10-25 02:24:37 +00:00
else
all_external = FALSE;
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
}
dmabuf: Allow implicit modifiers Remove all the roadblocks we've put up to keep implicit modifiers out. Our importing code already handles them as a signal that says 'No modifiers, please!'. Now we just hope for the best and pass things along. This is necessary since some drivers won't produce any explicit modifiers.
2023-10-24 05:08:17 +00:00
/* Accept implicit modifiers as long as we accept the format at all.
* This is a bit of a crapshot, but unfortunately needed for a bunch
* of drivers.
dmabuf: Refine the handling of implicit modifiers If all formats with a given fourcc are external, treat the fourcc with implicit modifiers as external too, following a sugestion by Benjamin Otte.
2023-10-25 02:24:37 +00:00
*
* As an extra wrinkle, treat the implicit modifier as 'external only'
* if all formats with the same fourcc are 'external only'.
dmabuf: Allow implicit modifiers Remove all the roadblocks we've put up to keep implicit modifiers out. Our importing code already handles them as a signal that says 'No modifiers, please!'. Now we just hope for the best and pass things along. This is necessary since some drivers won't produce any explicit modifiers.
2023-10-24 05:08:17 +00:00
*/
dmabuf: Refine the handling of implicit modifiers If all formats with a given fourcc are external, treat the fourcc with implicit modifiers as external too, following a sugestion by Benjamin Otte.
2023-10-25 02:24:37 +00:00
if (!all_external || gdk_gl_context_get_use_es (context))
gdk_dmabuf_formats_builder_add_format (formats, fourccs[i], DRM_FORMAT_MOD_INVALID);
if (all_external)
gdk_dmabuf_formats_builder_add_format (external, fourccs[i], DRM_FORMAT_MOD_INVALID);
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
}
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
g_free (modifiers);
g_free (external_only);
g_free (fourccs);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Cache egl formats Only call eglQueryDmaBufModifiersEXT once, and reuse the results.
2023-10-25 01:34:48 +00:00
return TRUE;
}
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
/* Hack. We don't include gsk/gsk.h here to avoid a build order problem
* with the generated header gskenumtypes.h, so we need to hack around
* a bit to access the gsk api we need.
*/
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
typedef struct _GskRenderer GskRenderer;
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Use gsk_renderer_realize_for_display() We want to use the correct display when realizing our dmabuf downloaders. It's a good thing that the inspector doesn't use dmabufs, isn't it?
2024-01-07 09:03:44 +00:00
extern GskRenderer * gsk_gl_renderer_new (void);
extern gboolean gsk_renderer_realize_for_display (GskRenderer *renderer,
GdkDisplay *display,
GError **error);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
GdkDmabufDownloader *
dmabuf: Change the way downloaders work Instead of having an add_formats() function, make the get_downloader() function add the formats. This allows putting the actual downloader in a different place from the initialization code.
2023-12-16 20:32:17 +00:00
gdk_dmabuf_get_egl_downloader (GdkDisplay *display,
GdkDmabufFormatsBuilder *builder)
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
{
dmabuf: Change the way downloaders work Instead of having an add_formats() function, make the get_downloader() function add the formats. This allows putting the actual downloader in a different place from the initialization code.
2023-12-16 20:32:17 +00:00
GdkDmabufFormatsBuilder *formats;
GdkDmabufFormatsBuilder *external;
gboolean retval = FALSE;
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
GError *error = NULL;
GskRenderer *renderer;
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
GdkGLContext *previous;
dmabuf: Change the way downloaders work Instead of having an add_formats() function, make the get_downloader() function add the formats. This allows putting the actual downloader in a different place from the initialization code.
2023-12-16 20:32:17 +00:00
g_assert (display->egl_dmabuf_formats == NULL);
g_assert (display->egl_external_formats == NULL);
if (!gdk_display_prepare_gl (display, NULL))
return NULL;
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
previous = gdk_gl_context_get_current ();
dmabuf: Ref previous context In case the context's only reference was held by being the current context, setting the new context would free it. Resetting it later would then be a use-after-free. Fixes #6694
2024-05-06 18:23:47 +00:00
if (previous)
g_object_ref (previous);
dmabuf: Change the way downloaders work Instead of having an add_formats() function, make the get_downloader() function add the formats. This allows putting the actual downloader in a different place from the initialization code.
2023-12-16 20:32:17 +00:00
formats = gdk_dmabuf_formats_builder_new ();
external = gdk_dmabuf_formats_builder_new ();
dmabufegl: Remove unsued argument from function
2023-12-16 22:19:07 +00:00
retval = gdk_dmabuf_egl_downloader_collect_formats (display, formats, external);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
dmabuf: Change the way downloaders work Instead of having an add_formats() function, make the get_downloader() function add the formats. This allows putting the actual downloader in a different place from the initialization code.
2023-12-16 20:32:17 +00:00
display->egl_dmabuf_formats = gdk_dmabuf_formats_builder_free_to_formats (formats);
display->egl_external_formats = gdk_dmabuf_formats_builder_free_to_formats (external);
gdk_dmabuf_formats_builder_add_formats (builder, display->egl_dmabuf_formats);
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
if (!retval)
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
{
if (previous)
gdk_gl_context_make_current (previous);
return NULL;
}
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
renderer = gsk_gl_renderer_new ();
dmabuf: Use gsk_renderer_realize_for_display() We want to use the correct display when realizing our dmabuf downloaders. It's a good thing that the inspector doesn't use dmabufs, isn't it?
2024-01-07 09:03:44 +00:00
if (!gsk_renderer_realize_for_display (renderer, display, &error))
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
{
g_warning ("Failed to realize GL renderer: %s", error->message);
g_error_free (error);
g_object_unref (renderer);
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
if (previous)
gdk_gl_context_make_current (previous);
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
return NULL;
}
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
if (previous)
dmabuf: Ref previous context In case the context's only reference was held by being the current context, setting the new context would free it. Resetting it later would then be a use-after-free. Fixes #6694
2024-05-06 18:23:47 +00:00
{
gdk_gl_context_make_current (previous);
g_object_unref (previous);
}
dmabuf: Make init_dmabuf() restore the previous GL context Random code can call that function and cause unexpected GL context changes. This is especially bad because it can happen nested. Fixes the NGL renderer breaking in the inspector when importing a dmabuf initializes the dmabuf backend which creates a GL renderer which creates a GL context and makes it current causing the NGL renderer to break when it continues rendering. Fixes #6398
2024-02-12 00:26:41 +00:00
dmabuf: Turn the downloader into an interface This way, we can move the actual downloader code into GSK - by just implementing the interface in the GskGLRenderer.
2023-12-18 22:25:56 +00:00
return GDK_DMABUF_DOWNLOADER (renderer);
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
}
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
EGLImage
gdk_dmabuf_egl_create_image (GdkDisplay *display,
int width,
int height,
const GdkDmabuf *dmabuf,
int target)
{
EGLDisplay egl_display = gdk_display_get_egl_display (display);
EGLint attribs[64];
int i;
EGLImage image;
g_return_val_if_fail (width > 0, 0);
g_return_val_if_fail (height > 0, 0);
g_return_val_if_fail (1 <= dmabuf->n_planes && dmabuf->n_planes <= 4, 0);
g_return_val_if_fail (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES, 0);
if (egl_display == EGL_NO_DISPLAY || !display->have_egl_dma_buf_import)
{
GDK_DISPLAY_DEBUG (display, DMABUF,
"Can't import dmabufs into GL, missing EGL or EGL_EXT_image_dma_buf_import_modifiers");
return EGL_NO_IMAGE;
}
GDK_DISPLAY_DEBUG (display, DMABUF,
"Importing dmabuf (format: %.4s:%#" G_GINT64_MODIFIER "x, planes: %u) into GL",
(char *) &dmabuf->fourcc, dmabuf->modifier, dmabuf->n_planes);
i = 0;
attribs[i++] = EGL_IMAGE_PRESERVED_KHR;
attribs[i++] = EGL_TRUE;
attribs[i++] = EGL_WIDTH;
attribs[i++] = width;
attribs[i++] = EGL_HEIGHT;
attribs[i++] = height;
attribs[i++] = EGL_LINUX_DRM_FOURCC_EXT;
attribs[i++] = dmabuf->fourcc;
attribs[i++] = EGL_YUV_COLOR_SPACE_HINT_EXT;
attribs[i++] = EGL_ITU_REC601_EXT;
attribs[i++] = EGL_SAMPLE_RANGE_HINT_EXT;
dmabuf: Use narrow range instead of full range It's way more common, and Mutter uses it, too. Avoid visual glitches when going in/out of offload. Fixes #6672
2024-04-29 12:26:34 +00:00
attribs[i++] = EGL_YUV_NARROW_RANGE_EXT;
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
#define ADD_PLANE(plane) \
{ \
if (dmabuf->modifier != DRM_FORMAT_MOD_INVALID) \
{ \
attribs[i++] = EGL_DMA_BUF_PLANE## plane ##_MODIFIER_LO_EXT; \
attribs[i++] = dmabuf->modifier & 0xFFFFFFFF; \
attribs[i++] = EGL_DMA_BUF_PLANE## plane ## _MODIFIER_HI_EXT; \
attribs[i++] = dmabuf->modifier >> 32; \
} \
attribs[i++] = EGL_DMA_BUF_PLANE## plane ##_FD_EXT; \
attribs[i++] = dmabuf->planes[plane].fd; \
attribs[i++] = EGL_DMA_BUF_PLANE## plane ##_PITCH_EXT; \
attribs[i++] = dmabuf->planes[plane].stride; \
attribs[i++] = EGL_DMA_BUF_PLANE## plane ##_OFFSET_EXT; \
attribs[i++] = dmabuf->planes[plane].offset; \
}
ADD_PLANE (0);
if (dmabuf->n_planes > 1) ADD_PLANE (1);
if (dmabuf->n_planes > 2) ADD_PLANE (2);
if (dmabuf->n_planes > 3) ADD_PLANE (3);
attribs[i++] = EGL_NONE;
dmabuf: Use narrow range instead of full range It's way more common, and Mutter uses it, too. Avoid visual glitches when going in/out of offload. Fixes #6672
2024-04-29 12:26:34 +00:00
g_assert (i < G_N_ELEMENTS (attribs));
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
image = eglCreateImageKHR (egl_display,
EGL_NO_CONTEXT,
EGL_LINUX_DMA_BUF_EXT,
(EGLClientBuffer)NULL,
attribs);
if (image == EGL_NO_IMAGE)
{
GDK_DISPLAY_DEBUG (display, DMABUF,
"Creating EGLImage for dmabuf failed: %#x",
eglGetError ());
return 0;
}
return image;
}
dmabuf: Add an EGL downloader Add an implementation of GdkDmabufDownloader that uses gsk_renderer_render_texture + GL texture download. Since gsk isn't threadsafe, we do the download in the main thread, taking care to not disturb the current GL context of whatever is going on there at the time. And since gsk renderers are expensive to create, we cache it in the display. Note that gsk does not yet have any special support for dmabuf textures, so for now, they will always get downloaded and then reuploaded as GL textures.
2023-10-21 20:31:10 +00:00
#endif /* HAVE_DMABUF && HAVE_EGL */
Reference in New Issue Copy Permalink