2011-07-02 09:57:30 +01:00
|
|
|
/**************************************************************************
|
|
|
|
*
|
s/Tungsten Graphics/VMware/
Tungsten Graphics Inc. was acquired by VMware Inc. in 2008. Leaving the
old copyright name is creating unnecessary confusion, hence this change.
This was the sed script I used:
$ cat tg2vmw.sed
# Run as:
#
# git reset --hard HEAD && find include scons src -type f -not -name 'sed*' -print0 | xargs -0 sed -i -f tg2vmw.sed
#
# Rename copyrights
s/Tungsten Gra\(ph\|hp\)ics,\? [iI]nc\.\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./g
/Copyright/s/Tungsten Graphics\(,\? [iI]nc\.\)\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./
s/TUNGSTEN GRAPHICS/VMWARE/g
# Rename emails
s/alanh@tungstengraphics.com/alanh@vmware.com/
s/jens@tungstengraphics.com/jowen@vmware.com/g
s/jrfonseca-at-tungstengraphics-dot-com/jfonseca-at-vmware-dot-com/
s/jrfonseca\?@tungstengraphics.com/jfonseca@vmware.com/g
s/keithw\?@tungstengraphics.com/keithw@vmware.com/g
s/michel@tungstengraphics.com/daenzer@vmware.com/g
s/thomas-at-tungstengraphics-dot-com/thellstom-at-vmware-dot-com/
s/zack@tungstengraphics.com/zackr@vmware.com/
# Remove dead links
s@Tungsten Graphics (http://www.tungstengraphics.com)@Tungsten Graphics@g
# C string src/gallium/state_trackers/vega/api_misc.c
s/"Tungsten Graphics, Inc"/"VMware, Inc"/
Reviewed-by: Brian Paul <brianp@vmware.com>
2014-01-17 16:27:50 +00:00
|
|
|
* Copyright 2008 VMware, Inc.
|
2011-07-02 09:57:30 +01:00
|
|
|
* Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
|
|
|
|
* Copyright 2010-2011 LunarG, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
|
|
* of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
* DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
2008-05-27 23:48:23 +01:00
|
|
|
/**
|
|
|
|
* Functions related to EGLDisplay.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <assert.h>
|
2005-04-22 22:09:39 +01:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2021-09-01 16:54:13 +01:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include <io.h>
|
|
|
|
#else
|
2019-06-11 13:19:35 +01:00
|
|
|
#include <unistd.h>
|
2021-09-01 16:54:13 +01:00
|
|
|
#endif
|
2019-05-16 18:01:40 +01:00
|
|
|
#include <fcntl.h>
|
2015-03-06 16:54:55 +00:00
|
|
|
#include "c11/threads.h"
|
2019-09-01 15:22:24 +01:00
|
|
|
#include "util/macros.h"
|
2020-06-05 00:09:35 +01:00
|
|
|
#include "util/os_file.h"
|
2017-06-15 23:53:55 +01:00
|
|
|
#include "util/u_atomic.h"
|
2015-03-06 16:54:55 +00:00
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
#include "eglcontext.h"
|
2014-01-23 15:26:10 +00:00
|
|
|
#include "eglcurrent.h"
|
2009-07-17 18:48:27 +01:00
|
|
|
#include "eglsurface.h"
|
2019-05-16 18:01:40 +01:00
|
|
|
#include "egldevice.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
#include "egldisplay.h"
|
2008-05-27 23:48:23 +01:00
|
|
|
#include "egldriver.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
#include "eglglobals.h"
|
2009-08-10 08:13:42 +01:00
|
|
|
#include "egllog.h"
|
2016-09-09 18:45:09 +01:00
|
|
|
#include "eglimage.h"
|
|
|
|
#include "eglsync.h"
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2011-08-09 13:23:18 +01:00
|
|
|
/* Includes for _eglNativePlatformDetectNativeDisplay */
|
|
|
|
#ifdef HAVE_WAYLAND_PLATFORM
|
|
|
|
#include <wayland-client.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_DRM_PLATFORM
|
|
|
|
#include <gbm.h>
|
|
|
|
#endif
|
2021-09-08 20:54:17 +01:00
|
|
|
#ifdef HAVE_WINDOWS_PLATFORM
|
|
|
|
#include <windows.h>
|
|
|
|
#endif
|
2011-08-09 13:23:18 +01:00
|
|
|
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2011-08-09 15:16:33 +01:00
|
|
|
/**
|
2019-04-24 13:21:18 +01:00
|
|
|
* Map build-system platform names to platform types.
|
2011-08-09 15:16:33 +01:00
|
|
|
*/
|
|
|
|
static const struct {
|
|
|
|
_EGLPlatformType platform;
|
|
|
|
const char *name;
|
2019-09-01 15:22:24 +01:00
|
|
|
} egl_platforms[] = {
|
2011-08-09 15:16:33 +01:00
|
|
|
{ _EGL_PLATFORM_X11, "x11" },
|
2020-08-26 19:01:53 +01:00
|
|
|
{ _EGL_PLATFORM_XCB, "xcb" },
|
2011-08-09 15:16:33 +01:00
|
|
|
{ _EGL_PLATFORM_WAYLAND, "wayland" },
|
|
|
|
{ _EGL_PLATFORM_DRM, "drm" },
|
2014-12-22 15:10:13 +00:00
|
|
|
{ _EGL_PLATFORM_ANDROID, "android" },
|
2015-06-12 18:10:58 +01:00
|
|
|
{ _EGL_PLATFORM_HAIKU, "haiku" },
|
|
|
|
{ _EGL_PLATFORM_SURFACELESS, "surfaceless" },
|
2019-09-01 15:22:24 +01:00
|
|
|
{ _EGL_PLATFORM_DEVICE, "device" },
|
2021-09-01 16:54:13 +01:00
|
|
|
{ _EGL_PLATFORM_WINDOWS, "windows" },
|
2011-08-09 15:16:33 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-06-17 16:45:41 +01:00
|
|
|
/**
|
|
|
|
* Return the native platform by parsing EGL_PLATFORM.
|
|
|
|
*/
|
|
|
|
static _EGLPlatformType
|
|
|
|
_eglGetNativePlatformFromEnv(void)
|
|
|
|
{
|
|
|
|
_EGLPlatformType plat = _EGL_INVALID_PLATFORM;
|
|
|
|
const char *plat_name;
|
|
|
|
EGLint i;
|
|
|
|
|
2019-09-01 15:22:24 +01:00
|
|
|
static_assert(ARRAY_SIZE(egl_platforms) == _EGL_NUM_PLATFORMS,
|
|
|
|
"Missing platform");
|
|
|
|
|
2010-06-17 16:45:41 +01:00
|
|
|
plat_name = getenv("EGL_PLATFORM");
|
|
|
|
/* try deprecated env variable */
|
|
|
|
if (!plat_name || !plat_name[0])
|
|
|
|
plat_name = getenv("EGL_DISPLAY");
|
|
|
|
if (!plat_name || !plat_name[0])
|
|
|
|
return _EGL_INVALID_PLATFORM;
|
|
|
|
|
2019-09-01 15:22:24 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(egl_platforms); i++) {
|
2010-06-17 16:45:41 +01:00
|
|
|
if (strcmp(egl_platforms[i].name, plat_name) == 0) {
|
|
|
|
plat = egl_platforms[i].platform;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-02 10:09:58 +01:00
|
|
|
if (plat == _EGL_INVALID_PLATFORM)
|
|
|
|
_eglLog(_EGL_WARNING, "invalid EGL_PLATFORM given");
|
|
|
|
|
2010-06-17 16:45:41 +01:00
|
|
|
return plat;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-09 13:23:18 +01:00
|
|
|
/**
|
|
|
|
* Try detecting native platform with the help of native display characteristcs.
|
|
|
|
*/
|
|
|
|
static _EGLPlatformType
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
_eglNativePlatformDetectNativeDisplay(void *nativeDisplay)
|
2011-08-09 13:23:18 +01:00
|
|
|
{
|
|
|
|
if (nativeDisplay == EGL_DEFAULT_DISPLAY)
|
|
|
|
return _EGL_INVALID_PLATFORM;
|
|
|
|
|
2021-09-08 20:54:17 +01:00
|
|
|
#ifdef HAVE_WINDOWS_PLATFORM
|
|
|
|
if (GetObjectType(nativeDisplay) == OBJ_DC)
|
|
|
|
return _EGL_PLATFORM_WINDOWS;
|
|
|
|
#endif
|
|
|
|
|
2021-09-08 20:51:53 +01:00
|
|
|
#if defined(HAVE_WAYLAND_PLATFORM) || defined(HAVE_DRM_PLATFORM)
|
2011-08-09 13:23:18 +01:00
|
|
|
if (_eglPointerIsDereferencable(nativeDisplay)) {
|
|
|
|
void *first_pointer = *(void **) nativeDisplay;
|
|
|
|
|
|
|
|
#ifdef HAVE_WAYLAND_PLATFORM
|
|
|
|
/* wl_display is a wl_proxy, which is a wl_object.
|
|
|
|
* wl_object's first element points to the interfacetype. */
|
|
|
|
if (first_pointer == &wl_display_interface)
|
|
|
|
return _EGL_PLATFORM_WAYLAND;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_DRM_PLATFORM
|
|
|
|
/* gbm has a pointer to its constructor as first element. */
|
|
|
|
if (first_pointer == gbm_create_device)
|
|
|
|
return _EGL_PLATFORM_DRM;
|
|
|
|
#endif
|
|
|
|
}
|
2021-09-08 20:51:53 +01:00
|
|
|
#endif
|
2011-08-09 13:23:18 +01:00
|
|
|
|
|
|
|
return _EGL_INVALID_PLATFORM;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-06-17 16:45:41 +01:00
|
|
|
/**
|
|
|
|
* Return the native platform. It is the platform of the EGL native types.
|
|
|
|
*/
|
|
|
|
_EGLPlatformType
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
_eglGetNativePlatform(void *nativeDisplay)
|
2010-06-17 16:45:41 +01:00
|
|
|
{
|
2019-10-09 01:20:36 +01:00
|
|
|
_EGLPlatformType detected_platform = _eglGetNativePlatformFromEnv();
|
|
|
|
const char *detection_method = "environment";
|
2010-06-17 16:45:41 +01:00
|
|
|
|
2017-06-15 23:53:55 +01:00
|
|
|
if (detected_platform == _EGL_INVALID_PLATFORM) {
|
2019-10-09 01:20:36 +01:00
|
|
|
detected_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay);
|
|
|
|
detection_method = "autodetected";
|
|
|
|
}
|
2017-06-15 23:53:55 +01:00
|
|
|
|
2019-10-09 01:20:36 +01:00
|
|
|
if (detected_platform == _EGL_INVALID_PLATFORM) {
|
|
|
|
detected_platform = _EGL_NATIVE_PLATFORM;
|
|
|
|
detection_method = "build-time configuration";
|
2017-06-15 23:53:54 +01:00
|
|
|
}
|
2011-08-09 15:16:33 +01:00
|
|
|
|
2019-10-09 01:20:36 +01:00
|
|
|
_eglLog(_EGL_DEBUG, "Native platform type: %s (%s)",
|
|
|
|
egl_platforms[detected_platform].name, detection_method);
|
|
|
|
|
|
|
|
return detected_platform;
|
2010-06-17 16:45:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-10 07:16:32 +01:00
|
|
|
/**
|
|
|
|
* Finish display management.
|
|
|
|
*/
|
2009-08-14 10:47:00 +01:00
|
|
|
void
|
2009-08-10 07:16:32 +01:00
|
|
|
_eglFiniDisplay(void)
|
|
|
|
{
|
2019-02-02 11:38:45 +00:00
|
|
|
_EGLDisplay *dispList, *disp;
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2009-08-14 10:47:00 +01:00
|
|
|
/* atexit function is called with global mutex locked */
|
2019-02-02 11:38:45 +00:00
|
|
|
dispList = _eglGlobal.DisplayList;
|
|
|
|
while (dispList) {
|
2010-01-24 12:32:34 +00:00
|
|
|
EGLint i;
|
|
|
|
|
2009-08-14 10:47:00 +01:00
|
|
|
/* pop list head */
|
2019-02-02 11:38:45 +00:00
|
|
|
disp = dispList;
|
|
|
|
dispList = dispList->Next;
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
|
2019-02-02 11:38:45 +00:00
|
|
|
if (disp->ResourceLists[i]) {
|
|
|
|
_eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", disp);
|
2010-01-24 12:32:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2019-05-16 18:01:40 +01:00
|
|
|
|
|
|
|
/* The fcntl() code in _eglGetDeviceDisplay() ensures that valid fd >= 3,
|
|
|
|
* and invalid one is 0.
|
|
|
|
*/
|
|
|
|
if (disp->Options.fd)
|
|
|
|
close(disp->Options.fd);
|
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
free(disp->Options.Attribs);
|
2019-02-02 11:38:45 +00:00
|
|
|
free(disp);
|
2009-08-10 07:16:32 +01:00
|
|
|
}
|
2009-08-14 10:47:00 +01:00
|
|
|
_eglGlobal.DisplayList = NULL;
|
2009-08-10 07:16:32 +01:00
|
|
|
}
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
static EGLBoolean
|
|
|
|
_eglSameAttribs(const EGLAttrib *a, const EGLAttrib *b)
|
|
|
|
{
|
|
|
|
size_t na = _eglNumAttribs(a);
|
|
|
|
size_t nb = _eglNumAttribs(b);
|
|
|
|
|
|
|
|
/* different numbers of attributes must be different */
|
|
|
|
if (na != nb)
|
|
|
|
return EGL_FALSE;
|
|
|
|
|
|
|
|
/* both lists NULL are the same */
|
|
|
|
if (!a && !b)
|
|
|
|
return EGL_TRUE;
|
|
|
|
|
|
|
|
/* otherwise, compare the lists */
|
2019-06-06 21:30:49 +01:00
|
|
|
return memcmp(a, b, na * sizeof(a[0])) == 0 ? EGL_TRUE : EGL_FALSE;
|
2019-05-16 18:01:34 +01:00
|
|
|
}
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
/**
|
2010-02-17 10:39:27 +00:00
|
|
|
* Find the display corresponding to the specified native display, or create a
|
2019-05-16 18:01:34 +01:00
|
|
|
* new one. EGL 1.5 says:
|
|
|
|
*
|
|
|
|
* Multiple calls made to eglGetPlatformDisplay with the same parameters
|
|
|
|
* will return the same EGLDisplay handle.
|
|
|
|
*
|
|
|
|
* We read this extremely strictly, and treat a call with NULL attribs as
|
|
|
|
* different from a call with attribs only equal to { EGL_NONE }. Similarly
|
|
|
|
* we do not sort the attribute list, so even if all attribute _values_ are
|
|
|
|
* identical, different attribute orders will be considered different
|
|
|
|
* parameters.
|
2009-07-17 05:21:56 +01:00
|
|
|
*/
|
|
|
|
_EGLDisplay *
|
2019-05-16 18:01:34 +01:00
|
|
|
_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy,
|
|
|
|
const EGLAttrib *attrib_list)
|
2009-07-17 05:21:56 +01:00
|
|
|
{
|
2019-02-02 11:38:45 +00:00
|
|
|
_EGLDisplay *disp;
|
2019-05-16 18:01:34 +01:00
|
|
|
size_t num_attribs;
|
2009-08-10 07:16:32 +01:00
|
|
|
|
2010-06-17 10:14:03 +01:00
|
|
|
if (plat == _EGL_INVALID_PLATFORM)
|
|
|
|
return NULL;
|
|
|
|
|
2022-08-11 17:56:37 +01:00
|
|
|
simple_mtx_lock(_eglGlobal.Mutex);
|
2009-07-17 05:21:56 +01:00
|
|
|
|
2010-02-17 10:39:27 +00:00
|
|
|
/* search the display list first */
|
2018-12-13 17:35:28 +00:00
|
|
|
for (disp = _eglGlobal.DisplayList; disp; disp = disp->Next) {
|
2019-05-16 18:01:34 +01:00
|
|
|
if (disp->Platform == plat && disp->PlatformDisplay == plat_dpy &&
|
|
|
|
_eglSameAttribs(disp->Options.Attribs, attrib_list))
|
2020-08-18 10:45:34 +01:00
|
|
|
goto out;
|
2009-07-17 05:21:56 +01:00
|
|
|
}
|
|
|
|
|
2010-02-17 10:39:27 +00:00
|
|
|
/* create a new display */
|
2020-08-18 10:45:34 +01:00
|
|
|
assert(!disp);
|
|
|
|
disp = calloc(1, sizeof(_EGLDisplay));
|
2020-08-18 10:48:54 +01:00
|
|
|
if (!disp)
|
|
|
|
goto out;
|
|
|
|
|
2022-08-11 17:56:37 +01:00
|
|
|
simple_mtx_init(&disp->Mutex, mtx_plain);
|
2022-08-29 18:28:11 +01:00
|
|
|
u_rwlock_init(&disp->TerminateLock);
|
2020-08-18 10:48:54 +01:00
|
|
|
disp->Platform = plat;
|
|
|
|
disp->PlatformDisplay = plat_dpy;
|
|
|
|
num_attribs = _eglNumAttribs(attrib_list);
|
|
|
|
if (num_attribs) {
|
|
|
|
disp->Options.Attribs = calloc(num_attribs, sizeof(EGLAttrib));
|
|
|
|
if (!disp->Options.Attribs) {
|
|
|
|
free(disp);
|
|
|
|
disp = NULL;
|
|
|
|
goto out;
|
2010-02-17 10:39:27 +00:00
|
|
|
}
|
2020-08-18 10:48:54 +01:00
|
|
|
memcpy(disp->Options.Attribs, attrib_list,
|
|
|
|
num_attribs * sizeof(EGLAttrib));
|
2010-02-17 10:39:27 +00:00
|
|
|
}
|
|
|
|
|
2020-08-18 10:48:54 +01:00
|
|
|
/* add to the display list */
|
|
|
|
disp->Next = _eglGlobal.DisplayList;
|
|
|
|
_eglGlobal.DisplayList = disp;
|
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
out:
|
2022-08-11 17:56:37 +01:00
|
|
|
simple_mtx_unlock(_eglGlobal.Mutex);
|
2009-08-14 10:47:00 +01:00
|
|
|
|
2019-02-02 11:38:45 +00:00
|
|
|
return disp;
|
2009-07-17 05:21:56 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-17 05:21:57 +01:00
|
|
|
/**
|
|
|
|
* Destroy the contexts and surfaces that are linked to the display.
|
|
|
|
*/
|
|
|
|
void
|
2018-04-22 15:48:15 +01:00
|
|
|
_eglReleaseDisplayResources(_EGLDisplay *display)
|
2009-07-17 05:21:57 +01:00
|
|
|
{
|
2010-01-24 12:32:34 +00:00
|
|
|
_EGLResource *list;
|
2018-04-22 15:48:15 +01:00
|
|
|
const _EGLDriver *drv = display->Driver;
|
2009-07-17 05:21:57 +01:00
|
|
|
|
2022-08-11 18:01:01 +01:00
|
|
|
simple_mtx_assert_locked(&display->Mutex);
|
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
list = display->ResourceLists[_EGL_RESOURCE_CONTEXT];
|
|
|
|
while (list) {
|
|
|
|
_EGLContext *ctx = (_EGLContext *) list;
|
|
|
|
list = list->Next;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
_eglUnlinkContext(ctx);
|
2018-04-22 15:48:15 +01:00
|
|
|
drv->DestroyContext(display, ctx);
|
2009-07-17 05:21:57 +01:00
|
|
|
}
|
2010-01-24 12:32:34 +00:00
|
|
|
assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
|
2009-07-17 05:21:57 +01:00
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
|
|
|
|
while (list) {
|
|
|
|
_EGLSurface *surf = (_EGLSurface *) list;
|
|
|
|
list = list->Next;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
_eglUnlinkSurface(surf);
|
2018-04-22 15:48:15 +01:00
|
|
|
drv->DestroySurface(display, surf);
|
2009-07-17 05:21:57 +01:00
|
|
|
}
|
2010-01-24 12:32:34 +00:00
|
|
|
assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
|
2016-09-09 18:45:09 +01:00
|
|
|
|
|
|
|
list = display->ResourceLists[_EGL_RESOURCE_IMAGE];
|
|
|
|
while (list) {
|
|
|
|
_EGLImage *image = (_EGLImage *) list;
|
|
|
|
list = list->Next;
|
|
|
|
|
|
|
|
_eglUnlinkImage(image);
|
2018-04-22 15:48:15 +01:00
|
|
|
drv->DestroyImageKHR(display, image);
|
2016-09-09 18:45:09 +01:00
|
|
|
}
|
|
|
|
assert(!display->ResourceLists[_EGL_RESOURCE_IMAGE]);
|
|
|
|
|
|
|
|
list = display->ResourceLists[_EGL_RESOURCE_SYNC];
|
|
|
|
while (list) {
|
|
|
|
_EGLSync *sync = (_EGLSync *) list;
|
|
|
|
list = list->Next;
|
|
|
|
|
|
|
|
_eglUnlinkSync(sync);
|
2018-04-22 15:48:15 +01:00
|
|
|
drv->DestroySyncKHR(display, sync);
|
2016-09-09 18:45:09 +01:00
|
|
|
}
|
|
|
|
assert(!display->ResourceLists[_EGL_RESOURCE_SYNC]);
|
2009-07-17 05:21:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-04 18:34:10 +01:00
|
|
|
/**
|
|
|
|
* Free all the data hanging of an _EGLDisplay object, but not
|
|
|
|
* the object itself.
|
|
|
|
*/
|
2005-04-22 22:09:39 +01:00
|
|
|
void
|
2005-05-13 19:31:35 +01:00
|
|
|
_eglCleanupDisplay(_EGLDisplay *disp)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2009-08-13 06:39:51 +01:00
|
|
|
if (disp->Configs) {
|
2010-06-30 10:10:10 +01:00
|
|
|
_eglDestroyArray(disp->Configs, free);
|
2009-08-13 06:39:51 +01:00
|
|
|
disp->Configs = NULL;
|
2008-06-04 18:34:10 +01:00
|
|
|
}
|
|
|
|
|
2022-10-18 21:36:02 +01:00
|
|
|
/* XXX incomplete */
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
2009-07-17 18:48:27 +01:00
|
|
|
|
2009-08-14 11:02:38 +01:00
|
|
|
|
2010-01-24 12:30:04 +00:00
|
|
|
/**
|
|
|
|
* Return EGL_TRUE if the given resource is valid. That is, the display does
|
|
|
|
* own the resource.
|
|
|
|
*/
|
|
|
|
EGLBoolean
|
2019-02-02 11:38:45 +00:00
|
|
|
_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *disp)
|
2010-01-24 12:30:04 +00:00
|
|
|
{
|
2019-02-02 11:38:45 +00:00
|
|
|
_EGLResource *list = disp->ResourceLists[type];
|
2010-01-24 12:30:04 +00:00
|
|
|
|
2022-08-11 18:01:01 +01:00
|
|
|
simple_mtx_assert_locked(&disp->Mutex);
|
|
|
|
|
2010-01-25 03:39:44 +00:00
|
|
|
if (!res)
|
|
|
|
return EGL_FALSE;
|
|
|
|
|
2010-01-24 12:30:04 +00:00
|
|
|
while (list) {
|
2010-01-25 03:39:44 +00:00
|
|
|
if (res == (void *) list) {
|
2019-02-02 11:38:45 +00:00
|
|
|
assert(list->Display == disp);
|
2010-01-24 12:30:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
list = list->Next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (list != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-23 04:59:03 +01:00
|
|
|
/**
|
2014-02-19 05:04:04 +00:00
|
|
|
* Initialize a display resource. The size of the subclass object is
|
|
|
|
* specified.
|
|
|
|
*
|
|
|
|
* This is supposed to be called from the initializers of subclasses, such as
|
|
|
|
* _eglInitContext or _eglInitSurface.
|
2010-10-23 04:59:03 +01:00
|
|
|
*/
|
|
|
|
void
|
2019-02-02 11:38:45 +00:00
|
|
|
_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *disp)
|
2010-10-23 04:59:03 +01:00
|
|
|
{
|
|
|
|
memset(res, 0, size);
|
2019-02-02 11:38:45 +00:00
|
|
|
res->Display = disp;
|
2010-10-23 04:59:03 +01:00
|
|
|
res->RefCount = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Increment reference count for the resource.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_eglGetResource(_EGLResource *res)
|
|
|
|
{
|
|
|
|
assert(res && res->RefCount > 0);
|
2022-08-18 18:59:50 +01:00
|
|
|
p_atomic_inc(&res->RefCount);
|
2010-10-23 04:59:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Decrement reference count for the resource.
|
|
|
|
*/
|
|
|
|
EGLBoolean
|
|
|
|
_eglPutResource(_EGLResource *res)
|
|
|
|
{
|
|
|
|
assert(res && res->RefCount > 0);
|
2022-08-18 18:59:50 +01:00
|
|
|
return p_atomic_dec_zero(&res->RefCount);
|
2010-10-23 04:59:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-24 12:30:04 +00:00
|
|
|
/**
|
2010-10-22 17:37:19 +01:00
|
|
|
* Link a resource to its display.
|
2010-01-24 12:30:04 +00:00
|
|
|
*/
|
|
|
|
void
|
2010-10-22 17:37:19 +01:00
|
|
|
_eglLinkResource(_EGLResource *res, _EGLResourceType type)
|
2010-01-24 12:30:04 +00:00
|
|
|
{
|
2010-10-22 17:37:19 +01:00
|
|
|
assert(res->Display);
|
2022-08-11 18:01:01 +01:00
|
|
|
simple_mtx_assert_locked(&res->Display->Mutex);
|
2010-01-26 07:16:49 +00:00
|
|
|
|
|
|
|
res->IsLinked = EGL_TRUE;
|
2010-10-22 17:37:19 +01:00
|
|
|
res->Next = res->Display->ResourceLists[type];
|
|
|
|
res->Display->ResourceLists[type] = res;
|
2010-10-23 04:59:03 +01:00
|
|
|
_eglGetResource(res);
|
2010-01-24 12:30:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unlink a linked resource from its display.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
_eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
|
|
|
|
{
|
|
|
|
_EGLResource *prev;
|
|
|
|
|
2022-08-11 18:01:01 +01:00
|
|
|
simple_mtx_assert_locked(&res->Display->Mutex);
|
|
|
|
|
2010-01-24 12:30:04 +00:00
|
|
|
prev = res->Display->ResourceLists[type];
|
|
|
|
if (prev != res) {
|
|
|
|
while (prev) {
|
|
|
|
if (prev->Next == res)
|
|
|
|
break;
|
|
|
|
prev = prev->Next;
|
|
|
|
}
|
|
|
|
assert(prev);
|
|
|
|
prev->Next = res->Next;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
res->Display->ResourceLists[type] = res->Next;
|
|
|
|
}
|
|
|
|
|
|
|
|
res->Next = NULL;
|
2010-01-26 07:16:49 +00:00
|
|
|
res->IsLinked = EGL_FALSE;
|
2010-10-23 04:59:03 +01:00
|
|
|
_eglPutResource(res);
|
|
|
|
|
|
|
|
/* We always unlink before destroy. The driver still owns a reference */
|
|
|
|
assert(res->RefCount);
|
2010-01-24 12:30:04 +00:00
|
|
|
}
|
2014-01-23 15:26:10 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_X11_PLATFORM
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetX11Display(Display *native_display,
|
2017-11-16 18:27:27 +00:00
|
|
|
const EGLAttrib *attrib_list)
|
2014-01-23 15:26:10 +00:00
|
|
|
{
|
2019-05-16 18:01:37 +01:00
|
|
|
/* EGL_EXT_platform_x11 recognizes exactly one attribute,
|
|
|
|
* EGL_PLATFORM_X11_SCREEN_EXT, which is optional.
|
|
|
|
*/
|
|
|
|
if (attrib_list != NULL) {
|
|
|
|
for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
|
|
|
|
if (attrib_list[i] != EGL_PLATFORM_X11_SCREEN_EXT) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2014-01-23 15:26:10 +00:00
|
|
|
}
|
2019-05-16 18:01:37 +01:00
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_X11, native_display, attrib_list);
|
2014-01-23 15:26:10 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_X11_PLATFORM */
|
|
|
|
|
2020-08-26 19:01:53 +01:00
|
|
|
#ifdef HAVE_XCB_PLATFORM
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetXcbDisplay(xcb_connection_t *native_display,
|
|
|
|
const EGLAttrib *attrib_list)
|
|
|
|
{
|
|
|
|
/* EGL_EXT_platform_xcb recognizes exactly one attribute,
|
|
|
|
* EGL_PLATFORM_XCB_SCREEN_EXT, which is optional.
|
|
|
|
*/
|
|
|
|
if (attrib_list != NULL) {
|
|
|
|
for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
|
|
|
|
if (attrib_list[i] != EGL_PLATFORM_XCB_SCREEN_EXT) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_XCB, native_display, attrib_list);
|
|
|
|
}
|
|
|
|
#endif /* HAVE_XCB_PLATFORM */
|
|
|
|
|
2014-01-23 15:26:10 +00:00
|
|
|
#ifdef HAVE_DRM_PLATFORM
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetGbmDisplay(struct gbm_device *native_display,
|
2017-11-16 18:27:27 +00:00
|
|
|
const EGLAttrib *attrib_list)
|
2014-01-23 15:26:10 +00:00
|
|
|
{
|
|
|
|
/* EGL_MESA_platform_gbm recognizes no attributes. */
|
|
|
|
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display, attrib_list);
|
2014-01-23 15:26:10 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_DRM_PLATFORM */
|
|
|
|
|
|
|
|
#ifdef HAVE_WAYLAND_PLATFORM
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetWaylandDisplay(struct wl_display *native_display,
|
2017-11-16 18:27:27 +00:00
|
|
|
const EGLAttrib *attrib_list)
|
2014-01-23 15:26:10 +00:00
|
|
|
{
|
|
|
|
/* EGL_EXT_platform_wayland recognizes no attributes. */
|
|
|
|
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display, attrib_list);
|
2014-01-23 15:26:10 +00:00
|
|
|
}
|
|
|
|
#endif /* HAVE_WAYLAND_PLATFORM */
|
2016-10-12 23:48:15 +01:00
|
|
|
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetSurfacelessDisplay(void *native_display,
|
2017-11-16 18:27:27 +00:00
|
|
|
const EGLAttrib *attrib_list)
|
2016-10-12 23:48:15 +01:00
|
|
|
{
|
|
|
|
/* This platform has no native display. */
|
|
|
|
if (native_display != NULL) {
|
|
|
|
_eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This platform recognizes no display attributes. */
|
|
|
|
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-05-16 18:01:34 +01:00
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display,
|
|
|
|
attrib_list);
|
2016-10-12 23:48:15 +01:00
|
|
|
}
|
2019-05-16 18:01:40 +01:00
|
|
|
|
2019-06-28 08:21:08 +01:00
|
|
|
#ifdef HAVE_ANDROID_PLATFORM
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetAndroidDisplay(void *native_display,
|
|
|
|
const EGLAttrib *attrib_list)
|
|
|
|
{
|
|
|
|
|
|
|
|
/* This platform recognizes no display attributes. */
|
|
|
|
if (attrib_list != NULL && attrib_list[0] != EGL_NONE) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return _eglFindDisplay(_EGL_PLATFORM_ANDROID, native_display,
|
|
|
|
attrib_list);
|
|
|
|
}
|
|
|
|
#endif /* HAVE_ANDROID_PLATFORM */
|
2019-05-16 18:01:40 +01:00
|
|
|
|
|
|
|
_EGLDisplay*
|
|
|
|
_eglGetDeviceDisplay(void *native_display,
|
|
|
|
const EGLAttrib *attrib_list)
|
|
|
|
{
|
|
|
|
_EGLDevice *dev;
|
|
|
|
_EGLDisplay *display;
|
|
|
|
int fd = -1;
|
|
|
|
|
|
|
|
dev = _eglLookupDevice(native_display);
|
|
|
|
if (!dev) {
|
|
|
|
_eglError(EGL_BAD_PARAMETER, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attrib_list) {
|
|
|
|
for (int i = 0; attrib_list[i] != EGL_NONE; i += 2) {
|
|
|
|
EGLAttrib attrib = attrib_list[i];
|
|
|
|
EGLAttrib value = attrib_list[i + 1];
|
|
|
|
|
|
|
|
/* EGL_EXT_platform_device does not recognize any attributes,
|
|
|
|
* EGL_EXT_device_drm adds the optional EGL_DRM_MASTER_FD_EXT.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!_eglDeviceSupports(dev, _EGL_DEVICE_DRM) ||
|
|
|
|
attrib != EGL_DRM_MASTER_FD_EXT) {
|
|
|
|
_eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
fd = (int) value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
display = _eglFindDisplay(_EGL_PLATFORM_DEVICE, native_display, attrib_list);
|
|
|
|
if (!display) {
|
|
|
|
_eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the fd is explicitly provided and we did not dup() it yet, do so.
|
|
|
|
* The spec mandates that we do so, since we'll need it past the
|
|
|
|
* eglGetPlatformDispay call.
|
|
|
|
*
|
|
|
|
* The new fd is guaranteed to be 3 or greater.
|
|
|
|
*/
|
|
|
|
if (fd != -1 && display->Options.fd == 0) {
|
2020-06-05 00:09:35 +01:00
|
|
|
display->Options.fd = os_dupfd_cloexec(fd);
|
2019-05-16 18:01:40 +01:00
|
|
|
if (display->Options.fd == -1) {
|
|
|
|
/* Do not (really) need to teardown the display */
|
|
|
|
_eglError(EGL_BAD_ALLOC, "eglGetPlatformDisplay");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return display;
|
|
|
|
}
|