-
/**
* Functions related to EGLDisplay.
*/
#include <stdlib.h>
#include <string.h>
#include "eglcontext.h"
+#include "eglsurface.h"
#include "egldisplay.h"
#include "egldriver.h"
#include "eglglobals.h"
-#include "eglhash.h"
-#include "eglstring.h"
+#include "eglmutex.h"
+#include "egllog.h"
+
+
+/**
+ * Return the native platform by parsing EGL_PLATFORM.
+ */
+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;
+
+ 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;
+
+ for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
+ if (strcmp(egl_platforms[i].name, plat_name) == 0) {
+ plat = egl_platforms[i].platform;
+ break;
+ }
+ }
+
+ return plat;
+}
/**
- * Allocate a new _EGLDisplay object for the given nativeDisplay handle.
- * We'll also try to determine the device driver name at this time.
- *
- * Note that nativeDisplay may be an X Display ptr, or a string.
+ * Return the native platform. It is the platform of the EGL native types.
+ */
+_EGLPlatformType
+_eglGetNativePlatform(void)
+{
+ static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM;
+
+ if (native_platform == _EGL_INVALID_PLATFORM) {
+ native_platform = _eglGetNativePlatformFromEnv();
+ if (native_platform == _EGL_INVALID_PLATFORM)
+ native_platform = _EGL_NATIVE_PLATFORM;
+ }
+
+ return native_platform;
+}
+
+
+/**
+ * Finish display management.
+ */
+void
+_eglFiniDisplay(void)
+{
+ _EGLDisplay *dpyList, *dpy;
+
+ /* atexit function is called with global mutex locked */
+ dpyList = _eglGlobal.DisplayList;
+ while (dpyList) {
+ EGLint i;
+
+ /* pop list head */
+ dpy = dpyList;
+ dpyList = dpyList->Next;
+
+ for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
+ if (dpy->ResourceLists[i]) {
+ _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
+ break;
+ }
+ }
+
+ free(dpy);
+ }
+ _eglGlobal.DisplayList = NULL;
+}
+
+
+/**
+ * Find the display corresponding to the specified native display, or create a
+ * new one.
*/
_EGLDisplay *
-_eglNewDisplay(NativeDisplayType nativeDisplay)
+_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
{
- _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
- if (dpy) {
- EGLuint key = _eglHashGenKey(_eglGlobal.Displays);
-
- dpy->Handle = (EGLDisplay) key;
- _eglHashInsert(_eglGlobal.Displays, key, dpy);
-
- dpy->NativeDisplay = nativeDisplay;
-#if defined(_EGL_PLATFORM_X)
- dpy->Xdpy = (Display *) nativeDisplay;
-#endif
-
- dpy->DriverName = _eglChooseDriver(dpy);
- if (!dpy->DriverName) {
- free(dpy);
- return NULL;
+ _EGLDisplay *dpy;
+
+ if (plat == _EGL_INVALID_PLATFORM)
+ return NULL;
+
+ _eglLockMutex(_eglGlobal.Mutex);
+
+ /* search the display list first */
+ dpy = _eglGlobal.DisplayList;
+ while (dpy) {
+ if (dpy->Platform == plat && dpy->PlatformDisplay == plat_dpy)
+ break;
+ dpy = dpy->Next;
+ }
+
+ /* create a new display */
+ if (!dpy) {
+ dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
+ if (dpy) {
+ _eglInitMutex(&dpy->Mutex);
+ dpy->Platform = plat;
+ dpy->PlatformDisplay = plat_dpy;
+
+ /* add to the display list */
+ dpy->Next = _eglGlobal.DisplayList;
+ _eglGlobal.DisplayList = dpy;
}
}
+
+ _eglUnlockMutex(_eglGlobal.Mutex);
+
return dpy;
}
/**
- * Return the public handle for an internal _EGLDisplay.
- * This is the inverse of _eglLookupDisplay().
+ * Destroy the contexts and surfaces that are linked to the display.
*/
-EGLDisplay
-_eglGetDisplayHandle(_EGLDisplay *display)
+void
+_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
{
- if (display)
- return display->Handle;
- else
- return EGL_NO_DISPLAY;
+ _EGLResource *list;
+
+ list = display->ResourceLists[_EGL_RESOURCE_CONTEXT];
+ while (list) {
+ _EGLContext *ctx = (_EGLContext *) list;
+ list = list->Next;
+
+ _eglUnlinkContext(ctx);
+ drv->API.DestroyContext(drv, display, ctx);
+ }
+ assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
+
+ list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
+ while (list) {
+ _EGLSurface *surf = (_EGLSurface *) list;
+ list = list->Next;
+
+ _eglUnlinkSurface(surf);
+ drv->API.DestroySurface(drv, display, surf);
+ }
+ assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
}
-
+
/**
- * Return the _EGLDisplay object that corresponds to the given public/
- * opaque display handle.
- * This is the inverse of _eglGetDisplayHandle().
+ * Free all the data hanging of an _EGLDisplay object, but not
+ * the object itself.
*/
-_EGLDisplay *
-_eglLookupDisplay(EGLDisplay dpy)
+void
+_eglCleanupDisplay(_EGLDisplay *disp)
+{
+ if (disp->Configs) {
+ _eglDestroyArray(disp->Configs, free);
+ disp->Configs = NULL;
+ }
+
+ /* XXX incomplete */
+}
+
+
+/**
+ * Return EGL_TRUE if the given handle is a valid handle to a display.
+ */
+EGLBoolean
+_eglCheckDisplayHandle(EGLDisplay dpy)
{
- EGLuint key = (EGLuint) dpy;
- _EGLDisplay *d = (_EGLDisplay *) _eglHashLookup(_eglGlobal.Displays, key);
- return d;
+ _EGLDisplay *cur;
+
+ _eglLockMutex(_eglGlobal.Mutex);
+ cur = _eglGlobal.DisplayList;
+ while (cur) {
+ if (cur == (_EGLDisplay *) dpy)
+ break;
+ cur = cur->Next;
+ }
+ _eglUnlockMutex(_eglGlobal.Mutex);
+ return (cur != NULL);
}
+/**
+ * Return EGL_TRUE if the given resource is valid. That is, the display does
+ * own the resource.
+ */
+EGLBoolean
+_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
+{
+ _EGLResource *list = dpy->ResourceLists[type];
+
+ if (!res)
+ return EGL_FALSE;
+
+ while (list) {
+ if (res == (void *) list) {
+ assert(list->Display == dpy);
+ break;
+ }
+ list = list->Next;
+ }
+
+ return (list != NULL);
+}
+
+
+/**
+ * Initialize a display resource.
+ */
void
-_eglSaveDisplay(_EGLDisplay *dpy)
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
{
- EGLuint key = _eglHashGenKey(_eglGlobal.Displays);
- assert(dpy);
- assert(!dpy->Handle);
- dpy->Handle = (EGLDisplay) key;
- assert(dpy->Handle);
- _eglHashInsert(_eglGlobal.Displays, key, dpy);
+ memset(res, 0, size);
+ res->Display = dpy;
+ res->RefCount = 1;
}
-_EGLDisplay *
-_eglGetCurrentDisplay(void)
+/**
+ * Increment reference count for the resource.
+ */
+void
+_eglGetResource(_EGLResource *res)
{
- _EGLContext *ctx = _eglGetCurrentContext();
- if (ctx)
- return ctx->Display;
- else
- return NULL;
+ assert(res && res->RefCount > 0);
+ /* hopefully a resource is always manipulated with its display locked */
+ res->RefCount++;
}
+/**
+ * Decrement reference count for the resource.
+ */
+EGLBoolean
+_eglPutResource(_EGLResource *res)
+{
+ assert(res && res->RefCount > 0);
+ res->RefCount--;
+ return (!res->RefCount);
+}
+
+
+/**
+ * Link a resource to its display.
+ */
void
-_eglCleanupDisplay(_EGLDisplay *disp)
+_eglLinkResource(_EGLResource *res, _EGLResourceType type)
{
- /* XXX incomplete */
- free(disp->Configs);
- free((void *) disp->DriverName);
- /* driver deletes _EGLDisplay */
+ assert(res->Display);
+
+ res->IsLinked = EGL_TRUE;
+ res->Next = res->Display->ResourceLists[type];
+ res->Display->ResourceLists[type] = res;
+ _eglGetResource(res);
+}
+
+
+/**
+ * Unlink a linked resource from its display.
+ */
+void
+_eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
+{
+ _EGLResource *prev;
+
+ 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;
+ res->IsLinked = EGL_FALSE;
+ _eglPutResource(res);
+
+ /* We always unlink before destroy. The driver still owns a reference */
+ assert(res->RefCount);
}
projects / mesa.git / blobdiff