egl: Add funtions to link contexts and surfaces to displays.

EGL contexts and surfaces are resources of displays.  They should be
managed by displays.  This commit adds a bunch of functions to
egldisplay.c to help establish the links between contexts/surfaces and
displays.  How links are established is considered opaque outside
display.  Functions like _eglGetSurfaceHandle or _eglLookupSurface are
therefore moved to egldisplay.c, with some small modifications.

The idea is also extended to display.  That is, displays need to link to
themselves to be looked up.

This commit only adds the functions.  A commit to use them should
follow.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>

diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 332b98adf2c5a982e7af8c15f2b5dd82f22d2b61..eaee9facd82f1a360f3a7d74760cf1f3c3343e2c 100644 (file)
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -52,6 +52,8 @@ eglGetDisplay(NativeDisplayType nativeDisplay)
    _EGLDisplay *dpy;
    _eglInitGlobals();
    dpy = _eglNewDisplay(nativeDisplay);
+   if (dpy)
+      _eglLinkDisplay(dpy);
    return _eglGetDisplayHandle(dpy);
 }
 

diff --git a/src/egl/main/eglcontext.c b/src/egl/main/eglcontext.c
index 81e69e946b318d3e743c02ceed4d86d01ea67f4a..edcc6a986fe0d995b2560cb06e4f322ac5ffd04c 100644 (file)
--- a/src/egl/main/eglcontext.c
+++ b/src/egl/main/eglcontext.c
@@ -83,31 +83,6 @@ _eglRemoveContext(_EGLContext *ctx)
 }
 
 
-/**
- * Return the public handle for the given private context ptr.
- * This is the inverse of _eglLookupContext().
- */
-EGLContext
-_eglGetContextHandle(_EGLContext *ctx)
-{
-   /* just a cast! */
-   return (EGLContext) ctx;
-}
-
-
-/**
- * Return the _EGLContext object that corresponds to the given
- * EGLContext handle.
- * This is the inverse of _eglGetContextHandle().
- */
-_EGLContext *
-_eglLookupContext(EGLContext ctx)
-{
-   /* just a cast since EGLContext is just a void ptr */
-   return (_EGLContext *) ctx;
-}
-
-
 /**
  * Just a placeholder/demo function.  Real driver will never use this!
  */

diff --git a/src/egl/main/eglcontext.h b/src/egl/main/eglcontext.h
index 5c8403153b3f94489e2095932a9827fa11498820..6e418dfbbe6bea4ad41c4c71a73f649f6330872c 100644 (file)
--- a/src/egl/main/eglcontext.h
+++ b/src/egl/main/eglcontext.h
@@ -11,7 +11,9 @@
  */
 struct _egl_context
 {
-   _EGLDisplay *Display; /* who do I belong to? */
+   /* Managed by EGLDisplay for linking */
+   _EGLDisplay *Display;
+   _EGLContext *Next;
 
    _EGLConfig *Config;
 
@@ -39,14 +41,6 @@ extern void
 _eglRemoveContext(_EGLContext *ctx);
 
 
-extern EGLContext
-_eglGetContextHandle(_EGLContext *ctx);
-
-
-extern _EGLContext *
-_eglLookupContext(EGLContext ctx);
- 
-
 extern EGLContext
 _eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list);
 

diff --git a/src/egl/main/egldisplay.c b/src/egl/main/egldisplay.c
index 01f67f6e4702fceb321e530d58c48ae5c9a6bf10..a30e810b4a5e91249939c527ce389bc578f2af89 100644 (file)
--- a/src/egl/main/egldisplay.c
+++ b/src/egl/main/egldisplay.c
@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "eglcontext.h"
+#include "eglsurface.h"
 #include "egldisplay.h"
 #include "egldriver.h"
 #include "eglglobals.h"
@@ -25,11 +26,6 @@ _eglNewDisplay(NativeDisplayType nativeDisplay)
 {
    _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;
@@ -46,8 +42,37 @@ _eglNewDisplay(NativeDisplayType nativeDisplay)
 
 
 /**
- * Return the public handle for an internal _EGLDisplay.
- * This is the inverse of _eglLookupDisplay().
+ * Link a display to itself and return the handle of the link.
+ * The handle can be passed to client directly.
+ */
+EGLDisplay
+_eglLinkDisplay(_EGLDisplay *dpy)
+{
+   EGLuint key;
+   key = _eglHashGenKey(_eglGlobal.Displays);
+   assert(key);
+   /* "link" the display to the hash table */
+   _eglHashInsert(_eglGlobal.Displays, key, dpy);
+   dpy->Handle = (EGLDisplay) key;
+
+   return dpy->Handle;
+}
+
+
+/**
+ * Unlink a linked display from itself.
+ * Accessing an unlinked display should generate EGL_BAD_DISPLAY error.
+ */
+void
+_eglUnlinkDisplay(_EGLDisplay *dpy)
+{
+   _eglHashRemove(_eglGlobal.Displays, (EGLuint) dpy->Handle);
+   dpy->Handle = EGL_NO_DISPLAY;
+}
+
+
+/**
+ * Return the handle of a linked display, or EGL_NO_DISPLAY.
  */
 EGLDisplay
 _eglGetDisplayHandle(_EGLDisplay *display)
@@ -60,32 +85,17 @@ _eglGetDisplayHandle(_EGLDisplay *display)
 
  
 /**
- * Return the _EGLDisplay object that corresponds to the given public/
- * opaque display handle.
- * This is the inverse of _eglGetDisplayHandle().
+ * Lookup a handle to find the linked display.
+ * Return NULL if the handle has no corresponding linked display.
  */
 _EGLDisplay *
 _eglLookupDisplay(EGLDisplay dpy)
 {
    EGLuint key = (EGLuint) dpy;
-   if (!_eglGlobal.Displays)
-      return NULL;
    return (_EGLDisplay *) _eglHashLookup(_eglGlobal.Displays, key);
 }
 
 
-void
-_eglSaveDisplay(_EGLDisplay *dpy)
-{
-   EGLuint key = _eglHashGenKey(_eglGlobal.Displays);
-   assert(dpy);
-   assert(!dpy->Handle);
-   dpy->Handle = (EGLDisplay) key;
-   assert(dpy->Handle);
-   _eglHashInsert(_eglGlobal.Displays, key, dpy);
-}
-
-
 /**
  * Free all the data hanging of an _EGLDisplay object, but not
  * the object itself.
@@ -108,3 +118,147 @@ _eglCleanupDisplay(_EGLDisplay *disp)
 
    /* driver deletes the _EGLDisplay object */
 }
+
+
+/**
+ * Link a context to a display and return the handle of the link.
+ * The handle can be passed to client directly.
+ */
+EGLContext
+_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy)
+{
+   ctx->Display = dpy;
+   ctx->Next = dpy->ContextList;
+   dpy->ContextList = ctx;
+   return (EGLContext) ctx;
+}
+
+
+/**
+ * Unlink a linked context from its display.
+ * Accessing an unlinked context should generate EGL_BAD_CONTEXT error.
+ */
+void
+_eglUnlinkContext(_EGLContext *ctx)
+{
+   _EGLContext *prev;
+
+   prev = ctx->Display->ContextList;
+   if (prev != ctx) {
+      while (prev) {
+         if (prev->Next == ctx)
+            break;
+         prev = prev->Next;
+      }
+      assert(prev);
+      prev->Next = ctx->Next;
+   }
+   else {
+      ctx->Display->ContextList = ctx->Next;
+   }
+
+   ctx->Next = NULL;
+   ctx->Display = 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;
+}
+
+
+/**
+ * Lookup a handle to find the linked context.
+ * Return NULL if the handle has no corresponding linked context.
+ */
+_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)
+{
+   EGLuint key;
+
+   surf->Display = dpy;
+   surf->Next = dpy->SurfaceList;
+   dpy->SurfaceList = surf;
+
+   key = _eglHashGenKey(_eglGlobal.Surfaces);
+   assert(key);
+   _eglHashInsert(_eglGlobal.Surfaces, key, surf);
+
+   surf->Handle = (EGLSurface) key;
+   return surf->Handle;
+}
+
+
+/**
+ * Unlink a linked surface from its display.
+ * Accessing an unlinked surface should generate EGL_BAD_SURFACE error.
+ */
+void
+_eglUnlinkSurface(_EGLSurface *surf)
+{
+   _EGLSurface *prev;
+
+   _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surf->Handle);
+   surf->Handle = EGL_NO_SURFACE;
+
+   prev = surf->Display->SurfaceList;
+   if (prev != surf) {
+      while (prev) {
+         if (prev->Next == surf)
+            break;
+         prev = prev->Next;
+      }
+      assert(prev);
+      prev->Next = surf->Next;
+   }
+   else {
+      prev = NULL;
+      surf->Display->SurfaceList = surf->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)
+{
+   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces,
+                                                   (EGLuint) surf);
+   return c;
+}

diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h
index 69f0d130efc1a368cd7969ee6488a2ca1aa167a4..ac285f52a7e629ccda2fffed3c6683a1c64ca2f3 100644 (file)
--- a/src/egl/main/egldisplay.h
+++ b/src/egl/main/egldisplay.h
@@ -23,6 +23,9 @@ struct _egl_display
    EGLint NumConfigs;
    _EGLConfig **Configs;  /* array [NumConfigs] of ptr to _EGLConfig */
 
+   /* lists of linked contexts and surface */
+   _EGLContext *ContextList;
+   _EGLSurface *SurfaceList;
 #ifdef _EGL_PLATFORM_X
    Display *Xdpy;
 #endif
@@ -33,7 +36,15 @@ extern _EGLDisplay *
 _eglNewDisplay(NativeDisplayType displayName);
 
 
-EGLDisplay
+extern EGLDisplay
+_eglLinkDisplay(_EGLDisplay *dpy);
+
+
+extern void
+_eglUnlinkDisplay(_EGLDisplay *dpy);
+
+
+extern EGLDisplay
 _eglGetDisplayHandle(_EGLDisplay *display);
 
 
@@ -42,16 +53,39 @@ _eglLookupDisplay(EGLDisplay dpy);
 
 
 extern void
-_eglSaveDisplay(_EGLDisplay *dpy);
+_eglCleanupDisplay(_EGLDisplay *disp);
+
+
+extern EGLContext
+_eglLinkContext(_EGLContext *ctx, _EGLDisplay *dpy);
 
 
 extern void
-_eglCleanupDisplay(_EGLDisplay *disp);
+_eglUnlinkContext(_EGLContext *ctx);
+
+
+extern EGLContext
+_eglGetContextHandle(_EGLContext *ctx);
+
+
+extern _EGLContext *
+_eglLookupContext(EGLContext ctx);
+
+
+extern EGLSurface
+_eglLinkSurface(_EGLSurface *surf, _EGLDisplay *dpy);
+
+
+extern void
+_eglUnlinkSurface(_EGLSurface *surf);
+
 
+extern EGLSurface
+_eglGetSurfaceHandle(_EGLSurface *);
 
-extern EGLBoolean 
-_eglQueryDisplayMESA(_EGLDriver *drv, EGLDisplay dpy, EGLint attrib, EGLint *value);
 
+extern _EGLSurface *
+_eglLookupSurface(EGLSurface surf);
 
 
 #endif /* EGLDISPLAY_INCLUDED */

diff --git a/src/egl/main/eglsurface.c b/src/egl/main/eglsurface.c
index 964288aac8bd0a846992150fbb03a6f498f08c0e..854f499fce22220b31faae8a44914d0b893b23b4 100644 (file)
--- a/src/egl/main/eglsurface.c
+++ b/src/egl/main/eglsurface.c
@@ -6,6 +6,7 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include "egldisplay.h"
 #include "eglcontext.h"
 #include "eglconfig.h"
 #include "egldriver.h"
@@ -231,34 +232,6 @@ _eglRemoveSurface(_EGLSurface *surf)
 
 
 
-/**
- * Return the public handle for an internal _EGLSurface.
- * This is the inverse of _eglLookupSurface().
- */
-EGLSurface
-_eglGetSurfaceHandle(_EGLSurface *surface)
-{
-   if (surface)
-      return surface->Handle;
-   else
-      return EGL_NO_SURFACE;
-}
-
-
-/**
- * Return the private _EGLSurface which corresponds to a public EGLSurface
- * handle.
- * This is the inverse of _eglGetSurfaceHandle().
- */
-_EGLSurface *
-_eglLookupSurface(EGLSurface surf)
-{
-   _EGLSurface *c = (_EGLSurface *) _eglHashLookup(_eglGlobal.Surfaces,
-                                                   (EGLuint) surf);
-   return c;
-}
-
-
 EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
 {

diff --git a/src/egl/main/eglsurface.h b/src/egl/main/eglsurface.h
index 3b54221bd32c569f9f1098843a31961c352e5145..dc536690910c68bd4c5431caefc3445ab0ce184e 100644 (file)
--- a/src/egl/main/eglsurface.h
+++ b/src/egl/main/eglsurface.h
@@ -10,7 +10,11 @@
  */
 struct _egl_surface
 {
-   EGLSurface Handle;  /* The public/opaque handle which names this object */
+   /* Managed by EGLDisplay for linking */
+   _EGLDisplay *Display;
+   _EGLSurface *Next;
+   EGLSurface Handle;
+
    _EGLConfig *Config;
 
    /* May need reference counting here */
@@ -52,14 +56,6 @@ extern void
 _eglRemoveSurface(_EGLSurface *surf);
 
 
-extern EGLSurface
-_eglGetSurfaceHandle(_EGLSurface *surface);
-
-
-extern _EGLSurface *
-_eglLookupSurface(EGLSurface surf);
- 
-
 extern EGLBoolean
 _eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw);