X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fmain%2Fegldisplay.c;h=37711bd8695ea744dd18d66053e89d1946a57d0e;hb=9db5cc829f6bd7ba09f3bf0bf057b7162d05d037;hp=565e44d2d23c8fc98d292aaa77983772042d2bdb;hpb=4926c5748028d33da4808f8a5473aa7b2f2bdc62;p=mesa.git diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c index 565e44d2d23..37711bd8695 100644 --- a/src/egl/main/egldisplay.c +++ b/src/egl/main/egldisplay.c @@ -1,3 +1,33 @@ +/************************************************************************** + * + * Copyright 2008 VMware, Inc. + * Copyright 2009-2010 Chia-I Wu + * 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. + * + **************************************************************************/ + + /** * Functions related to EGLDisplay. */ @@ -5,13 +35,45 @@ #include #include #include +#include "c11/threads.h" + #include "eglcontext.h" +#include "eglcurrent.h" #include "eglsurface.h" #include "egldisplay.h" #include "egldriver.h" #include "eglglobals.h" -#include "eglmutex.h" #include "egllog.h" +#include "eglimage.h" +#include "eglsync.h" + +/* Includes for _eglNativePlatformDetectNativeDisplay */ +#ifdef HAVE_MINCORE +#include +#include +#endif +#ifdef HAVE_WAYLAND_PLATFORM +#include +#endif +#ifdef HAVE_DRM_PLATFORM +#include +#endif + + +/** + * Map --with-egl-platforms names to platform types. + */ +static const struct { + _EGLPlatformType platform; + const char *name; +} egl_platforms[_EGL_NUM_PLATFORMS] = { + { _EGL_PLATFORM_X11, "x11" }, + { _EGL_PLATFORM_WAYLAND, "wayland" }, + { _EGL_PLATFORM_DRM, "drm" }, + { _EGL_PLATFORM_ANDROID, "android" }, + { _EGL_PLATFORM_HAIKU, "haiku" }, + { _EGL_PLATFORM_SURFACELESS, "surfaceless" }, +}; /** @@ -20,16 +82,6 @@ static _EGLPlatformType _eglGetNativePlatformFromEnv(void) { - /* map --with-egl-platforms names to platform types */ - static const struct { - _EGLPlatformType platform; - const char *name; - } egl_platforms[_EGL_NUM_PLATFORMS] = { - { _EGL_PLATFORM_WINDOWS, "gdi" }, - { _EGL_PLATFORM_X11, "x11" }, - { _EGL_PLATFORM_DRM, "drm" }, - { _EGL_PLATFORM_FBDEV, "fbdev" } - }; _EGLPlatformType plat = _EGL_INVALID_PLATFORM; const char *plat_name; EGLint i; @@ -52,20 +104,101 @@ _eglGetNativePlatformFromEnv(void) } +/** + * Perform validity checks on a generic pointer. + */ +static EGLBoolean +_eglPointerIsDereferencable(void *p) +{ +#ifdef HAVE_MINCORE + uintptr_t addr = (uintptr_t) p; + unsigned char valid = 0; + const long page_size = getpagesize(); + + if (p == NULL) + return EGL_FALSE; + + /* align addr to page_size */ + addr &= ~(page_size - 1); + + if (mincore((void *) addr, page_size, &valid) < 0) { + _eglLog(_EGL_DEBUG, "mincore failed: %m"); + return EGL_FALSE; + } + + return (valid & 0x01) == 0x01; +#else + return p != NULL; +#endif +} + + +/** + * Try detecting native platform with the help of native display characteristcs. + */ +static _EGLPlatformType +_eglNativePlatformDetectNativeDisplay(void *nativeDisplay) +{ + if (nativeDisplay == EGL_DEFAULT_DISPLAY) + return _EGL_INVALID_PLATFORM; + + if (_eglPointerIsDereferencable(nativeDisplay)) { + void *first_pointer = *(void **) nativeDisplay; + + (void) first_pointer; /* silence unused var warning */ + +#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 + +#ifdef HAVE_X11_PLATFORM + /* If not matched to any other platform, fallback to x11. */ + return _EGL_PLATFORM_X11; +#endif + +#ifdef HAVE_HAIKU_PLATFORM + return _EGL_PLATFORM_HAIKU; +#endif + } + + return _EGL_INVALID_PLATFORM; +} + + /** * Return the native platform. It is the platform of the EGL native types. */ _EGLPlatformType -_eglGetNativePlatform(void) +_eglGetNativePlatform(void *nativeDisplay) { - static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM; + static _EGLPlatformType native_platform; + char *detection_method; + + native_platform = _eglGetNativePlatformFromEnv(); + detection_method = "environment overwrite"; if (native_platform == _EGL_INVALID_PLATFORM) { - native_platform = _eglGetNativePlatformFromEnv(); - if (native_platform == _EGL_INVALID_PLATFORM) - native_platform = _EGL_NATIVE_PLATFORM; + native_platform = _eglNativePlatformDetectNativeDisplay(nativeDisplay); + detection_method = "autodetected"; } + if (native_platform == _EGL_INVALID_PLATFORM) { + native_platform = _EGL_NATIVE_PLATFORM; + detection_method = "build-time configuration"; + } + + _eglLog(_EGL_DEBUG, "Native platform type: %s (%s)", + egl_platforms[native_platform].name, detection_method); + return native_platform; } @@ -112,7 +245,7 @@ _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy) if (plat == _EGL_INVALID_PLATFORM) return NULL; - _eglLockMutex(_eglGlobal.Mutex); + mtx_lock(_eglGlobal.Mutex); /* search the display list first */ dpy = _eglGlobal.DisplayList; @@ -124,9 +257,9 @@ _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy) /* create a new display */ if (!dpy) { - dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay)); + dpy = calloc(1, sizeof(_EGLDisplay)); if (dpy) { - _eglInitMutex(&dpy->Mutex); + mtx_init(&dpy->Mutex, mtx_plain); dpy->Platform = plat; dpy->PlatformDisplay = plat_dpy; @@ -136,7 +269,7 @@ _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy) } } - _eglUnlockMutex(_eglGlobal.Mutex); + mtx_unlock(_eglGlobal.Mutex); return dpy; } @@ -169,6 +302,26 @@ _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display) drv->API.DestroySurface(drv, display, surf); } assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]); + + list = display->ResourceLists[_EGL_RESOURCE_IMAGE]; + while (list) { + _EGLImage *image = (_EGLImage *) list; + list = list->Next; + + _eglUnlinkImage(image); + drv->API.DestroyImageKHR(drv, display, image); + } + assert(!display->ResourceLists[_EGL_RESOURCE_IMAGE]); + + list = display->ResourceLists[_EGL_RESOURCE_SYNC]; + while (list) { + _EGLSync *sync = (_EGLSync *) list; + list = list->Next; + + _eglUnlinkSync(sync); + drv->API.DestroySyncKHR(drv, display, sync); + } + assert(!display->ResourceLists[_EGL_RESOURCE_SYNC]); } @@ -196,14 +349,14 @@ _eglCheckDisplayHandle(EGLDisplay dpy) { _EGLDisplay *cur; - _eglLockMutex(_eglGlobal.Mutex); + mtx_lock(_eglGlobal.Mutex); cur = _eglGlobal.DisplayList; while (cur) { if (cur == (_EGLDisplay *) dpy) break; cur = cur->Next; } - _eglUnlockMutex(_eglGlobal.Mutex); + mtx_unlock(_eglGlobal.Mutex); return (cur != NULL); } @@ -233,7 +386,11 @@ _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy) /** - * Initialize a display resource. + * 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. */ void _eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy) @@ -312,3 +469,95 @@ _eglUnlinkResource(_EGLResource *res, _EGLResourceType type) /* We always unlink before destroy. The driver still owns a reference */ assert(res->RefCount); } + +#ifdef HAVE_X11_PLATFORM +static EGLBoolean +_eglParseX11DisplayAttribList(const EGLint *attrib_list) +{ + int i; + + if (attrib_list == NULL) { + return EGL_TRUE; + } + + for (i = 0; attrib_list[i] != EGL_NONE; i += 2) { + EGLint attrib = attrib_list[i]; + EGLint value = attrib_list[i + 1]; + + /* EGL_EXT_platform_x11 recognizes exactly one attribute, + * EGL_PLATFORM_X11_SCREEN_EXT, which is optional. + * + * Mesa supports connecting to only the default screen, so we reject + * screen != 0. + */ + if (attrib != EGL_PLATFORM_X11_SCREEN_EXT || value != 0) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay"); + return EGL_FALSE; + } + } + + return EGL_TRUE; +} + +_EGLDisplay* +_eglGetX11Display(Display *native_display, + const EGLint *attrib_list) +{ + if (!_eglParseX11DisplayAttribList(attrib_list)) { + return NULL; + } + + return _eglFindDisplay(_EGL_PLATFORM_X11, native_display); +} +#endif /* HAVE_X11_PLATFORM */ + +#ifdef HAVE_DRM_PLATFORM +_EGLDisplay* +_eglGetGbmDisplay(struct gbm_device *native_display, + const EGLint *attrib_list) +{ + /* EGL_MESA_platform_gbm recognizes no attributes. */ + if (attrib_list != NULL && attrib_list[0] != EGL_NONE) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay"); + return NULL; + } + + return _eglFindDisplay(_EGL_PLATFORM_DRM, native_display); +} +#endif /* HAVE_DRM_PLATFORM */ + +#ifdef HAVE_WAYLAND_PLATFORM +_EGLDisplay* +_eglGetWaylandDisplay(struct wl_display *native_display, + const EGLint *attrib_list) +{ + /* EGL_EXT_platform_wayland recognizes no attributes. */ + if (attrib_list != NULL && attrib_list[0] != EGL_NONE) { + _eglError(EGL_BAD_ATTRIBUTE, "eglGetPlatformDisplay"); + return NULL; + } + + return _eglFindDisplay(_EGL_PLATFORM_WAYLAND, native_display); +} +#endif /* HAVE_WAYLAND_PLATFORM */ + +#ifdef HAVE_SURFACELESS_PLATFORM +_EGLDisplay* +_eglGetSurfacelessDisplay(void *native_display, + const EGLint *attrib_list) +{ + /* 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; + } + + return _eglFindDisplay(_EGL_PLATFORM_SURFACELESS, native_display); +} +#endif /* HAVE_SURFACELESS_PLATFORM */