X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fmain%2Fegldisplay.c;h=565e44d2d23c8fc98d292aaa77983772042d2bdb;hb=b2ddb93ff3b8c88682634ccdef247967e31fab84;hp=5897372fc5347b170fa34db1648874a8de525b0e;hpb=bee9964b29b2428ee75e2d1efc0e1d2c2518a417;p=mesa.git

diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 5897372fc53..565e44d2d23 100644
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -10,128 +10,135 @@
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
-#include "eglcurrent.h"
 #include "eglmutex.h"
 #include "egllog.h"
 
 
 /**
- * Finish display management.
+ * Return the native platform by parsing EGL_PLATFORM.
  */
-void
-_eglFiniDisplay(void)
+static _EGLPlatformType
+_eglGetNativePlatformFromEnv(void)
 {
-   _EGLDisplay *dpyList, *dpy;
-
-   /* atexit function is called with global mutex locked */
-   dpyList = _eglGlobal.DisplayList;
-   while (dpyList) {
-      EGLint i;
+   /* 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;
 
-      /* pop list head */
-      dpy = dpyList;
-      dpyList = dpyList->Next;
+   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_RESOURCES; i++) {
-         if (dpy->ResourceLists[i]) {
-            _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
-            break;
-         }
+   for (i = 0; i < _EGL_NUM_PLATFORMS; i++) {
+      if (strcmp(egl_platforms[i].name, plat_name) == 0) {
+         plat = egl_platforms[i].platform;
+         break;
       }
-
-      free(dpy);
    }
-   _eglGlobal.DisplayList = NULL;
-}
-
 
-/**
- * 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.
- */
-_EGLDisplay *
-_eglNewDisplay(EGLNativeDisplayType nativeDisplay)
-{
-   _EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
-   if (dpy) {
-      dpy->NativeDisplay = nativeDisplay;
-   }
-   return dpy;
+   return plat;
 }
 
 
 /**
- * Link a display to itself and return the handle of the link.
- * The handle can be passed to client directly.
+ * Return the native platform.  It is the platform of the EGL native types.
  */
-EGLDisplay
-_eglLinkDisplay(_EGLDisplay *dpy)
+_EGLPlatformType
+_eglGetNativePlatform(void)
 {
-   _eglLockMutex(_eglGlobal.Mutex);
-
-   dpy->Next = _eglGlobal.DisplayList;
-   _eglGlobal.DisplayList = dpy;
+   static _EGLPlatformType native_platform = _EGL_INVALID_PLATFORM;
 
-   _eglUnlockMutex(_eglGlobal.Mutex);
+   if (native_platform == _EGL_INVALID_PLATFORM) {
+      native_platform = _eglGetNativePlatformFromEnv();
+      if (native_platform == _EGL_INVALID_PLATFORM)
+         native_platform = _EGL_NATIVE_PLATFORM;
+   }
 
-   return (EGLDisplay) dpy;
+   return native_platform;
 }
 
 
 /**
- * Unlink a linked display from itself.
- * Accessing an unlinked display should generate EGL_BAD_DISPLAY error.
+ * Finish display management.
  */
 void
-_eglUnlinkDisplay(_EGLDisplay *dpy)
+_eglFiniDisplay(void)
 {
-   _EGLDisplay *prev;
+   _EGLDisplay *dpyList, *dpy;
 
-   _eglLockMutex(_eglGlobal.Mutex);
+   /* atexit function is called with global mutex locked */
+   dpyList = _eglGlobal.DisplayList;
+   while (dpyList) {
+      EGLint i;
 
-   prev = _eglGlobal.DisplayList;
-   if (prev != dpy) {
-      while (prev) {
-         if (prev->Next == dpy)
+      /* 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;
-         prev = prev->Next;
+         }
       }
-      assert(prev);
-      prev->Next = dpy->Next;
-   }
-   else {
-      _eglGlobal.DisplayList = dpy->Next;
-   }
 
-   _eglUnlockMutex(_eglGlobal.Mutex);
+      free(dpy);
+   }
+   _eglGlobal.DisplayList = NULL;
 }
 
 
 /**
- * Find the display corresponding to the specified native display id in all
- * linked displays.
+ * Find the display corresponding to the specified native display, or create a
+ * new one.
  */
 _EGLDisplay *
-_eglFindDisplay(EGLNativeDisplayType nativeDisplay)
+_eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
 {
    _EGLDisplay *dpy;
 
+   if (plat == _EGL_INVALID_PLATFORM)
+      return NULL;
+
    _eglLockMutex(_eglGlobal.Mutex);
 
+   /* search the display list first */
    dpy = _eglGlobal.DisplayList;
    while (dpy) {
-      if (dpy->NativeDisplay == nativeDisplay) {
-         _eglUnlockMutex(_eglGlobal.Mutex);
-         return 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 NULL;
+   return dpy;
 }
 
 
@@ -172,24 +179,15 @@ _eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
 void
 _eglCleanupDisplay(_EGLDisplay *disp)
 {
-   EGLint i;
-
    if (disp->Configs) {
-      for (i = 0; i < disp->NumConfigs; i++)
-         free(disp->Configs[i]);
-      free(disp->Configs);
+      _eglDestroyArray(disp->Configs, free);
       disp->Configs = NULL;
-      disp->NumConfigs = 0;
-      disp->MaxConfigs = 0;
    }
 
    /* XXX incomplete */
 }
 
 
-#ifndef _EGL_SKIP_HANDLE_CHECK
-
-
 /**
  * Return EGL_TRUE if the given handle is a valid handle to a display.
  */
@@ -234,21 +232,54 @@ _eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
 }
 
 
-#endif /* !_EGL_SKIP_HANDLE_CHECK */
+/**
+ * Initialize a display resource.
+ */
+void
+_eglInitResource(_EGLResource *res, EGLint size, _EGLDisplay *dpy)
+{
+   memset(res, 0, size);
+   res->Display = dpy;
+   res->RefCount = 1;
+}
 
 
 /**
- * Link a resource to a display.
+ * Increment reference count for the resource.
  */
 void
-_eglLinkResource(_EGLResource *res, _EGLResourceType type, _EGLDisplay *dpy)
+_eglGetResource(_EGLResource *res)
 {
-   assert(!res->Display || res->Display == dpy);
+   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
+_eglLinkResource(_EGLResource *res, _EGLResourceType type)
+{
+   assert(res->Display);
 
-   res->Display = dpy;
    res->IsLinked = EGL_TRUE;
-   res->Next = dpy->ResourceLists[type];
-   dpy->ResourceLists[type] = res;
+   res->Next = res->Display->ResourceLists[type];
+   res->Display->ResourceLists[type] = res;
+   _eglGetResource(res);
 }
 
 
@@ -275,6 +306,9 @@ _eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
    }
 
    res->Next = NULL;
-   /* do not reset res->Display */
    res->IsLinked = EGL_FALSE;
+   _eglPutResource(res);
+
+   /* We always unlink before destroy.  The driver still owns a reference */
+   assert(res->RefCount);
 }