#include "egldisplay.h"
#include "egldriver.h"
#include "eglglobals.h"
-#include "eglhash.h"
#include "eglstring.h"
#include "eglmutex.h"
-
-
-static _EGL_DECLARE_MUTEX(_eglDisplayInitMutex);
-static _EGLHashtable *_eglDisplayHash;
-/* TODO surface hash table should be per-display */
-static _EGLHashtable *_eglSurfaceHash;
+#include "egllog.h"
/**
* Finish display management.
*/
-static void
+void
_eglFiniDisplay(void)
{
- _eglLockMutex(&_eglDisplayInitMutex);
- if (_eglDisplayHash) {
- /* XXX TODO walk over table entries, deleting each */
- _eglDeleteHashTable(_eglDisplayHash);
- _eglDisplayHash = NULL;
- _eglDeleteHashTable(_eglSurfaceHash);
- _eglSurfaceHash = NULL;
- }
- _eglUnlockMutex(&_eglDisplayInitMutex);
-}
+ _EGLDisplay *dpyList, *dpy;
+ /* atexit function is called with global mutex locked */
+ dpyList = _eglGlobal.DisplayList;
+ while (dpyList) {
+ EGLint i;
-/* This can be avoided if hash table can be statically initialized */
-static INLINE void
-_eglInitDisplay(void)
-{
- if (!_eglDisplayHash) {
- _eglLockMutex(&_eglDisplayInitMutex);
-
- /* check again after acquiring lock */
- if (!_eglDisplayHash) {
- _eglDisplayHash = _eglNewHashTable();
- _eglSurfaceHash = _eglNewHashTable();
+ /* pop list head */
+ dpy = dpyList;
+ dpyList = dpyList->Next;
- (void) _eglFiniDisplay;
+ for (i = 0; i < _EGL_NUM_RESOURCES; i++) {
+ if (dpy->ResourceLists[i]) {
+ _eglLog(_EGL_DEBUG, "Display %p is destroyed with resources", dpy);
+ break;
+ }
}
- _eglUnlockMutex(&_eglDisplayInitMutex);
+ free(dpy);
}
+ _eglGlobal.DisplayList = NULL;
}
* Note that nativeDisplay may be an X Display ptr, or a string.
*/
_EGLDisplay *
-_eglNewDisplay(NativeDisplayType nativeDisplay)
+_eglNewDisplay(EGLNativeDisplayType nativeDisplay)
{
_EGLDisplay *dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
if (dpy) {
dpy->NativeDisplay = nativeDisplay;
-#if defined(_EGL_PLATFORM_X)
- dpy->Xdpy = (Display *) nativeDisplay;
-#endif
-
- _eglInitDisplay();
- dpy->SurfaceHash = _eglSurfaceHash;
-
- dpy->DriverName = _eglChooseDriver(dpy);
- if (!dpy->DriverName) {
- free(dpy);
- return NULL;
- }
}
return dpy;
}
EGLDisplay
_eglLinkDisplay(_EGLDisplay *dpy)
{
- EGLuint key;
+ _eglLockMutex(_eglGlobal.Mutex);
- _eglInitDisplay();
+ dpy->Next = _eglGlobal.DisplayList;
+ _eglGlobal.DisplayList = dpy;
- key = _eglHashGenKey(_eglDisplayHash);
- assert(key);
- /* "link" the display to the hash table */
- _eglHashInsert(_eglDisplayHash, key, dpy);
- dpy->Handle = (EGLDisplay) _eglUIntToPointer(key);
+ _eglUnlockMutex(_eglGlobal.Mutex);
- return dpy->Handle;
+ return (EGLDisplay) dpy;
}
void
_eglUnlinkDisplay(_EGLDisplay *dpy)
{
- EGLuint key = _eglPointerToUInt((void *) dpy->Handle);
-
- _eglInitDisplay();
-
- _eglHashRemove(_eglDisplayHash, key);
- dpy->Handle = EGL_NO_DISPLAY;
-}
-
-
-/**
- * Return the handle of a linked display, or EGL_NO_DISPLAY.
- */
-EGLDisplay
-_eglGetDisplayHandle(_EGLDisplay *display)
-{
- if (display)
- return display->Handle;
- else
- return EGL_NO_DISPLAY;
-}
-
+ _EGLDisplay *prev;
-/**
- * Lookup a handle to find the linked display.
- * Return NULL if the handle has no corresponding linked display.
- */
-_EGLDisplay *
-_eglLookupDisplay(EGLDisplay dpy)
-{
- EGLuint key = _eglPointerToUInt((void *) dpy);
+ _eglLockMutex(_eglGlobal.Mutex);
- _eglInitDisplay();
+ prev = _eglGlobal.DisplayList;
+ if (prev != dpy) {
+ while (prev) {
+ if (prev->Next == dpy)
+ break;
+ prev = prev->Next;
+ }
+ assert(prev);
+ prev->Next = dpy->Next;
+ }
+ else {
+ _eglGlobal.DisplayList = dpy->Next;
+ }
- return (_EGLDisplay *) _eglHashLookup(_eglDisplayHash, key);
+ _eglUnlockMutex(_eglGlobal.Mutex);
}
* linked displays.
*/
_EGLDisplay *
-_eglFindDisplay(NativeDisplayType nativeDisplay)
+_eglFindDisplay(EGLNativeDisplayType nativeDisplay)
{
- EGLuint key;
-
- _eglInitDisplay();
+ _EGLDisplay *dpy;
- /* Walk the hash table. Should switch to list if it is a problem. */
- key = _eglHashFirstEntry(_eglDisplayHash);
- while (key) {
- _EGLDisplay *dpy = (_EGLDisplay *)
- _eglHashLookup(_eglDisplayHash, key);
- assert(dpy);
+ _eglLockMutex(_eglGlobal.Mutex);
- if (dpy->NativeDisplay == nativeDisplay)
+ dpy = _eglGlobal.DisplayList;
+ while (dpy) {
+ if (dpy->NativeDisplay == nativeDisplay) {
+ _eglUnlockMutex(_eglGlobal.Mutex);
return dpy;
- key = _eglHashNextEntry(_eglDisplayHash, key);
+ }
+ dpy = dpy->Next;
}
+ _eglUnlockMutex(_eglGlobal.Mutex);
+
return NULL;
}
* Destroy the contexts and surfaces that are linked to the display.
*/
void
-_eglReleaseDisplayResources(_EGLDriver *drv, EGLDisplay dpy)
+_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)
{
- _EGLDisplay *display;
- _EGLContext *contexts;
- _EGLSurface *surfaces;
-
- display = _eglLookupDisplay(dpy);
- if (!display)
- return;
- contexts = display->ContextList;
- surfaces = display->SurfaceList;
-
- while (contexts) {
- EGLContext handle = _eglGetContextHandle(contexts);
- contexts = contexts->Next;
- drv->API.DestroyContext(drv, dpy, handle);
+ _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->ContextList);
+ assert(!display->ResourceLists[_EGL_RESOURCE_CONTEXT]);
+
+ list = display->ResourceLists[_EGL_RESOURCE_SURFACE];
+ while (list) {
+ _EGLSurface *surf = (_EGLSurface *) list;
+ list = list->Next;
- while (surfaces) {
- EGLSurface handle = _eglGetSurfaceHandle(surfaces);
- surfaces = surfaces->Next;
- drv->API.DestroySurface(drv, dpy, handle);
+ _eglUnlinkSurface(surf);
+ drv->API.DestroySurface(drv, display, surf);
}
- assert(!display->SurfaceList);
+ assert(!display->ResourceLists[_EGL_RESOURCE_SURFACE]);
}
{
EGLint i;
- for (i = 0; i < disp->NumConfigs; i++) {
- free(disp->Configs[i]);
+ if (disp->Configs) {
+ for (i = 0; i < disp->NumConfigs; i++)
+ free(disp->Configs[i]);
+ free(disp->Configs);
+ disp->Configs = NULL;
+ disp->NumConfigs = 0;
+ disp->MaxConfigs = 0;
}
- free(disp->Configs);
- disp->Configs = NULL;
/* XXX incomplete */
+}
- free((void *) disp->DriverName);
- disp->DriverName = NULL;
- /* driver deletes the _EGLDisplay object */
-}
+#ifndef _EGL_SKIP_HANDLE_CHECK
/**
- * Link a context to a display and return the handle of the link.
- * The handle can be passed to client directly.
+ * Return EGL_TRUE if the given handle is a valid handle to a display.
*/
-EGLContext
-_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy)
+EGLBoolean
+_eglCheckDisplayHandle(EGLDisplay dpy)
{
- ctx->Display = dpy;
- ctx->Next = dpy->ContextList;
- dpy->ContextList = ctx;
- return (EGLContext) ctx;
+ _EGLDisplay *cur;
+
+ _eglLockMutex(_eglGlobal.Mutex);
+ cur = _eglGlobal.DisplayList;
+ while (cur) {
+ if (cur == (_EGLDisplay *) dpy)
+ break;
+ cur = cur->Next;
+ }
+ _eglUnlockMutex(_eglGlobal.Mutex);
+ return (cur != NULL);
}
/**
- * Unlink a linked context from its display.
- * Accessing an unlinked context should generate EGL_BAD_CONTEXT error.
+ * Return EGL_TRUE if the given resource is valid. That is, the display does
+ * own the resource.
*/
-void
-_eglUnlinkContext(_EGLContext *ctx)
+EGLBoolean
+_eglCheckResource(void *res, _EGLResourceType type, _EGLDisplay *dpy)
{
- _EGLContext *prev;
-
- prev = ctx->Display->ContextList;
- if (prev != ctx) {
- while (prev) {
- if (prev->Next == ctx)
- break;
- prev = prev->Next;
+ _EGLResource *list = dpy->ResourceLists[type];
+
+ if (!res)
+ return EGL_FALSE;
+
+ while (list) {
+ if (res == (void *) list) {
+ assert(list->Display == dpy);
+ break;
}
- assert(prev);
- prev->Next = ctx->Next;
- }
- else {
- ctx->Display->ContextList = ctx->Next;
+ list = list->Next;
}
- ctx->Next = NULL;
- ctx->Display = NULL;
+ return (list != NULL);
}
-/**
- * Return the handle of a linked context, or EGL_NO_CONTEXT.
- */
-EGLContext
-_eglGetContextHandle(_EGLContext *ctx)
-{
- return (EGLContext) ((ctx && ctx->Display) ? ctx : EGL_NO_CONTEXT);
-}
+#endif /* !_EGL_SKIP_HANDLE_CHECK */
/**
- * Lookup a handle to find the linked context.
- * Return NULL if the handle has no corresponding linked context.
+ * Link a resource to a display.
*/
-_EGLContext *
-_eglLookupContext(EGLContext ctx)
-{
- _EGLContext *context = (_EGLContext *) ctx;
- return (context && context->Display) ? context : NULL;
-}
-
-
-/**
- * Link a surface to a display and return the handle of the link.
- * The handle can be passed to client directly.
- */
-EGLSurface
-_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy)
+void
+_eglLinkResource(_EGLResource *res, _EGLResourceType type, _EGLDisplay *dpy)
{
- EGLuint key;
-
- surf->Display = dpy;
- surf->Next = dpy->SurfaceList;
- dpy->SurfaceList = surf;
+ assert(!res->Display || res->Display == dpy);
- key = _eglHashGenKey(dpy->SurfaceHash);
- assert(key);
- _eglHashInsert(dpy->SurfaceHash, key, surf);
-
- surf->Handle = (EGLSurface) _eglUIntToPointer(key);
- return surf->Handle;
+ res->Display = dpy;
+ res->IsLinked = EGL_TRUE;
+ res->Next = dpy->ResourceLists[type];
+ dpy->ResourceLists[type] = res;
}
/**
- * Unlink a linked surface from its display.
- * Accessing an unlinked surface should generate EGL_BAD_SURFACE error.
+ * Unlink a linked resource from its display.
*/
void
-_eglUnlinkSurface(_EGLSurface *surf)
+_eglUnlinkResource(_EGLResource *res, _EGLResourceType type)
{
- _EGLSurface *prev;
- EGLuint key = _eglPointerToUInt((void *) surf->Handle);
-
- _eglHashRemove(surf->Display->SurfaceHash, key);
- surf->Handle = EGL_NO_SURFACE;
+ _EGLResource *prev;
- prev = surf->Display->SurfaceList;
- if (prev != surf) {
+ prev = res->Display->ResourceLists[type];
+ if (prev != res) {
while (prev) {
- if (prev->Next == surf)
+ if (prev->Next == res)
break;
prev = prev->Next;
}
assert(prev);
- prev->Next = surf->Next;
+ prev->Next = res->Next;
}
else {
- prev = NULL;
- surf->Display->SurfaceList = surf->Next;
+ res->Display->ResourceLists[type] = res->Next;
}
- surf->Next = NULL;
- surf->Display = NULL;
-}
-
-
-/**
- * Return the handle of a linked surface, or EGL_NO_SURFACE.
- */
-EGLSurface
-_eglGetSurfaceHandle(_EGLSurface *surface)
-{
- if (surface)
- return surface->Handle;
- else
- return EGL_NO_SURFACE;
-}
-
-
-/**
- * Lookup a handle to find the linked surface.
- * Return NULL if the handle has no corresponding linked surface.
- */
-_EGLSurface *
-_eglLookupSurface(EGLSurface surf)
-{
- EGLuint key = _eglPointerToUInt((void *) surf);
- return (_EGLSurface *) _eglHashLookup(_eglSurfaceHash, key);
+ res->Next = NULL;
+ /* do not reset res->Display */
+ res->IsLinked = EGL_FALSE;
}
projects / mesa.git / blobdiff