fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-06 09:28:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

egl: Remove EGL_MESA_drm_image

Browse source 
This extension was designed in a pre-dmabuf world, to allow us to share
DRM buffers based on global GEM names (generated with flink, as distinct
from context-local GEM handles).

We've had dmabuf since Linux kernel 3.4, so there's no need to carry
around this extension which encourages users to do bad things - namely,
to expose their buffers with a global ID that anyone can access - and
requires us to carry around some irritating support code.

Signed-off-by: Daniel Stone <daniels@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/35885>
This commit is contained in:
Daniel Stone 2025-07-02 13:32:47 +01:00 • committed by Marge Bot
parent 08c6ba223b
commit 20590ca771
9 changed files with 3 additions and 243 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
docs/relnotes/new_features.txt
View file

@ -64,3 +64,4 @@ VK_KHR_calibrated_timestamps on panvk/v10+
VK_EXT_non_seamless_cube_map on panvk
VK_ARM_shader_core_properties on panvk/v10+
removed X11 DRI2 support
removed EGL_MESA_drm_image

146
src/egl/drivers/dri2/egl_dri2.c
View file

@ -701,10 +701,6 @@ dri2_setup_screen(_EGLDisplay *disp)
disp->Extensions.KHR_reusable_sync = EGL_TRUE;
int capabilities;
capabilities = dri2_get_capabilities(dri2_dpy->dri_screen_render_gpu);
disp->Extensions.MESA_drm_image = (capabilities & __DRI_IMAGE_CAP_GLOBAL_NAMES) != 0;
#ifdef HAVE_LIBDRM
if (pscreen->caps.dmabuf & DRM_PRIME_CAP_EXPORT)
disp->Extensions.MESA_image_dma_buf_export = true;
@ -2076,47 +2072,6 @@ dri2_create_wayland_buffer_from_image(_EGLDisplay *disp, _EGLImage *img)
}
#ifdef HAVE_LIBDRM
static _EGLImage *
dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
EGLClientBuffer buffer,
const EGLint *attr_list)
{
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
EGLint name, pitch;
uint32_t fourcc;
_EGLImageAttribs attrs;
struct dri_image *dri_image;
name = (EGLint)(uintptr_t)buffer;
if (!_eglParseImageAttribList(&attrs, disp, attr_list))
return NULL;
if (attrs.Width <= 0 || attrs.Height <= 0 ||
attrs.DRMBufferStrideMESA <= 0) {
_eglError(EGL_BAD_PARAMETER, "bad width, height or stride");
return NULL;
}
switch (attrs.DRMBufferFormatMESA) {
case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
fourcc = DRM_FORMAT_ARGB8888;
pitch = attrs.DRMBufferStrideMESA * 4;
break;
default:
_eglError(EGL_BAD_PARAMETER,
"dri2_create_image_khr: unsupported pixmap depth");
return NULL;
}
int offset = 0;
dri_image = dri2_from_names(
dri2_dpy->dri_screen_render_gpu, attrs.Width, attrs.Height, fourcc,
(int *) &name, 1, (int *) &pitch, &offset, NULL);
return dri2_create_image_from_dri(disp, dri_image);
}
static EGLBoolean
dri2_check_dma_buf_attribs(const _EGLImageAttribs *attrs)
{
@ -2517,103 +2472,6 @@ dri2_create_image_dma_buf(_EGLDisplay *disp, _EGLContext *ctx,
return res;
}
static _EGLImage *
dri2_create_drm_image_mesa(_EGLDisplay *disp, const EGLint *attr_list)
{
struct dri2_egl_display *dri2_dpy = dri2_egl_display_lock(disp);
struct dri2_egl_image *dri2_img;
_EGLImageAttribs attrs;
unsigned int dri_use, valid_mask;
int format;
if (!attr_list) {
_eglError(EGL_BAD_PARAMETER, __func__);
goto fail;
}
if (!_eglParseImageAttribList(&attrs, disp, attr_list))
goto fail;
if (attrs.Width <= 0 || attrs.Height <= 0) {
_eglError(EGL_BAD_PARAMETER, __func__);
goto fail;
}
switch (attrs.DRMBufferFormatMESA) {
case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
format = PIPE_FORMAT_BGRA8888_UNORM;
break;
default:
_eglError(EGL_BAD_PARAMETER, __func__);
goto fail;
}
valid_mask = EGL_DRM_BUFFER_USE_SCANOUT_MESA |
EGL_DRM_BUFFER_USE_SHARE_MESA | EGL_DRM_BUFFER_USE_CURSOR_MESA;
if (attrs.DRMBufferUseMESA & ~valid_mask) {
_eglError(EGL_BAD_PARAMETER, __func__);
goto fail;
}
dri_use = 0;
if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
dri_use |= __DRI_IMAGE_USE_SHARE;
if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
dri_use |= __DRI_IMAGE_USE_SCANOUT;
if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_CURSOR_MESA)
dri_use |= __DRI_IMAGE_USE_CURSOR;
dri2_img = malloc(sizeof *dri2_img);
if (!dri2_img) {
_eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
goto fail;
}
_eglInitImage(&dri2_img->base, disp);
dri2_img->dri_image =
dri_create_image(dri2_dpy->dri_screen_render_gpu, attrs.Width,
attrs.Height, format, NULL, 0, dri_use, dri2_img);
if (dri2_img->dri_image == NULL) {
free(dri2_img);
_eglError(EGL_BAD_ALLOC, "dri2_create_drm_image_mesa");
goto fail;
}
mtx_unlock(&dri2_dpy->lock);
return &dri2_img->base;
fail:
mtx_unlock(&dri2_dpy->lock);
return EGL_NO_IMAGE_KHR;
}
static EGLBoolean
dri2_export_drm_image_mesa(_EGLDisplay *disp, _EGLImage *img, EGLint *name,
EGLint *handle, EGLint *stride)
{
struct dri2_egl_display *dri2_dpy = dri2_egl_display_lock(disp);
struct dri2_egl_image *dri2_img = dri2_egl_image(img);
if (name && !dri2_query_image(dri2_img->dri_image,
__DRI_IMAGE_ATTRIB_NAME, name))
return dri2_egl_error_unlock(dri2_dpy, EGL_BAD_ALLOC,
"dri2_export_drm_image_mesa");
if (handle)
dri2_query_image(dri2_img->dri_image,
__DRI_IMAGE_ATTRIB_HANDLE, handle);
if (stride)
dri2_query_image(dri2_img->dri_image,
__DRI_IMAGE_ATTRIB_STRIDE, stride);
mtx_unlock(&dri2_dpy->lock);
return EGL_TRUE;
}
/**
* Checks if we can support EGL_MESA_image_dma_buf_export on this image.
@ -2747,8 +2605,6 @@ dri2_create_image_khr(_EGLDisplay *disp, _EGLContext *ctx, EGLenum target,
case EGL_GL_RENDERBUFFER_KHR:
return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
#ifdef HAVE_LIBDRM
case EGL_DRM_BUFFER_MESA:
return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
case EGL_LINUX_DMA_BUF_EXT:
return dri2_create_image_dma_buf(disp, ctx, buffer, attr_list);
#endif
@ -3304,8 +3160,6 @@ const _EGLDriver _eglDriver = {
.QueryDriverConfig = dri2_query_driver_config,
.QueryDeviceInfo = dri2_query_device_info,
#ifdef HAVE_LIBDRM
.CreateDRMImageMESA = dri2_create_drm_image_mesa,
.ExportDRMImageMESA = dri2_export_drm_image_mesa,
.ExportDMABUFImageQueryMESA = dri2_export_dma_buf_image_query_mesa,
.ExportDMABUFImageMESA = dri2_export_dma_buf_image_mesa,
.QueryDmaBufFormatsEXT = dri2_query_dma_buf_formats,

4
src/egl/generate/eglFunctionList.py
View file

@ -195,10 +195,6 @@ EGL_FUNCTIONS = (
# EGL_KHR_wait_sync
_eglFunc("eglWaitSyncKHR", "display"),
# EGL_MESA_drm_image
_eglFunc("eglCreateDRMImageMESA", "display"),
_eglFunc("eglExportDRMImageMESA", "display"),
# EGL_MESA_image_dma_buf_export
_eglFunc("eglExportDMABUFImageQueryMESA", "display"),
_eglFunc("eglExportDMABUFImageMESA", "display"),

43
src/egl/main/eglapi.c
View file

@ -591,7 +591,6 @@ _eglCreateExtensionsString(_EGLDisplay *disp)
if (disp->Extensions.KHR_no_config_context)
_eglAppendExtension(&exts, "EGL_MESA_configless_context");
_EGL_CHECK_EXTENSION(MESA_drm_image);
_EGL_CHECK_EXTENSION(MESA_gl_interop);
_EGL_CHECK_EXTENSION(MESA_image_dma_buf_export);
_EGL_CHECK_EXTENSION(MESA_query_driver);
@ -2240,48 +2239,6 @@ eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync)
RETURN_EGL_SUCCESS(disp, ret);
}
static EGLImage EGLAPIENTRY
eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *attr_list)
{
_EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLImage *img;
EGLImage ret;
_EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL);
_EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
if (!disp->Extensions.MESA_drm_image)
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
img = disp->Driver->CreateDRMImageMESA(disp, attr_list);
ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
RETURN_EGL_EVAL(disp, ret);
}
static EGLBoolean EGLAPIENTRY
eglExportDRMImageMESA(EGLDisplay dpy, EGLImage image, EGLint *name,
EGLint *handle, EGLint *stride)
{
_EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLImage *img = _eglLookupImage(image, disp);
EGLBoolean ret = EGL_FALSE;
_EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img);
_EGL_CHECK_DISPLAY(disp, EGL_FALSE);
assert(disp->Extensions.MESA_drm_image);
if (!img)
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
egl_relax (disp, &img->Resource) {
ret = disp->Driver->ExportDRMImageMESA(disp, img, name, handle, stride);
}
RETURN_EGL_EVAL(disp, ret);
}
struct wl_display;
static EGLBoolean EGLAPIENTRY

1
src/egl/main/egldisplay.h
View file

@ -144,7 +144,6 @@ struct _egl_extensions {
EGLBoolean KHR_surfaceless_context;
EGLBoolean KHR_wait_sync;
EGLBoolean MESA_drm_image;
EGLBoolean MESA_gl_interop;
EGLBoolean MESA_image_dma_buf_export;
EGLBoolean MESA_query_driver;

6
src/egl/main/egldriver.h
View file

@ -158,12 +158,6 @@ struct _egl_driver {
/* for EGL_ANDROID_native_fence_sync */
EGLint (*DupNativeFenceFDANDROID)(_EGLDisplay *disp, _EGLSync *sync);
/* for EGL_MESA_drm_image */
_EGLImage *(*CreateDRMImageMESA)(_EGLDisplay *disp, const EGLint *attr_list);
EGLBoolean (*ExportDRMImageMESA)(_EGLDisplay *disp, _EGLImage *img,
EGLint *name, EGLint *handle,
EGLint *stride);
/* for EGL_WL_bind_wayland_display */
EGLBoolean (*BindWaylandDisplayWL)(_EGLDisplay *disp,
struct wl_display *display);

2
src/egl/main/eglentrypoint.h
View file

@ -11,7 +11,6 @@ EGL_ENTRYPOINT(eglClientWaitSync)
EGL_ENTRYPOINT(eglClientWaitSyncKHR)
EGL_ENTRYPOINT(eglCopyBuffers)
EGL_ENTRYPOINT(eglCreateContext)
EGL_ENTRYPOINT(eglCreateDRMImageMESA)
EGL_ENTRYPOINT(eglCreateImage)
EGL_ENTRYPOINT(eglCreateImageKHR)
EGL_ENTRYPOINT(eglCreatePbufferFromClientBuffer)
@ -36,7 +35,6 @@ EGL_ENTRYPOINT(eglDestroySyncKHR)
EGL_ENTRYPOINT(eglDupNativeFenceFDANDROID)
EGL_ENTRYPOINT(eglExportDMABUFImageMESA)
EGL_ENTRYPOINT(eglExportDMABUFImageQueryMESA)
EGL_ENTRYPOINT(eglExportDRMImageMESA)
EGL_ENTRYPOINT2(eglGLInteropExportObjectMESA, MesaGLInteropEGLExportObject)
EGL_ENTRYPOINT2(eglGLInteropFlushObjectsMESA, MesaGLInteropEGLFlushObjects)
EGL_ENTRYPOINT2(eglGLInteropQueryDeviceInfoMESA, MesaGLInteropEGLQueryDeviceInfo)

34
src/egl/main/eglimage.c
View file

@ -71,36 +71,6 @@ _eglParseKHRImageAttribs(_EGLImageAttribs *attrs, _EGLDisplay *disp,
return EGL_SUCCESS;
}
static EGLint
_eglParseMESADrmImageAttribs(_EGLImageAttribs *attrs, _EGLDisplay *disp,
EGLint attr, EGLint val)
{
if (!disp->Extensions.MESA_drm_image)
return EGL_BAD_PARAMETER;
switch (attr) {
case EGL_WIDTH:
attrs->Width = val;
break;
case EGL_HEIGHT:
attrs->Height = val;
break;
case EGL_DRM_BUFFER_FORMAT_MESA:
attrs->DRMBufferFormatMESA = val;
break;
case EGL_DRM_BUFFER_USE_MESA:
attrs->DRMBufferUseMESA = val;
break;
case EGL_DRM_BUFFER_STRIDE_MESA:
attrs->DRMBufferStrideMESA = val;
break;
default:
return EGL_BAD_PARAMETER;
}
return EGL_SUCCESS;
}
static EGLint
_eglParseWLBindWaylandDisplayAttribs(_EGLImageAttribs *attrs, _EGLDisplay *disp,
EGLint attr, EGLint val)
@ -296,10 +266,6 @@ _eglParseImageAttribList(_EGLImageAttribs *attrs, _EGLDisplay *disp,
if (err == EGL_SUCCESS)
continue;
err = _eglParseMESADrmImageAttribs(attrs, disp, attr, val);
if (err == EGL_SUCCESS)
continue;
err = _eglParseWLBindWaylandDisplayAttribs(attrs, disp, attr, val);
if (err == EGL_SUCCESS)
continue;

9
src/egl/main/eglimage.h
View file

@ -51,18 +51,13 @@ struct _egl_image_attribs {
EGLint GLTextureLevel;
EGLint GLTextureZOffset;
/* EGL_MESA_drm_image */
EGLint Width;
EGLint Height;
EGLint DRMBufferFormatMESA;
EGLint DRMBufferUseMESA;
EGLint DRMBufferStrideMESA;
/* EGL_WL_bind_wayland_display */
EGLint PlaneWL;
/* EGL_EXT_image_dma_buf_import and
* EGL_EXT_image_dma_buf_import_modifiers */
EGLint Width;
EGLint Height;
struct _egl_image_attrib_int DMABufFourCC;
struct _egl_image_attrib_int DMABufPlaneFds[DMA_BUF_MAX_PLANES];
struct _egl_image_attrib_int DMABufPlaneOffsets[DMA_BUF_MAX_PLANES];