eglhash.h \
eglmode.h \
eglscreen.h \
- eglsurface.h
+ eglsurface.h \
+ eglx.h
SOURCES = \
eglapi.c \
eglhash.c \
eglmode.c \
eglscreen.c \
- eglsurface.c
+ eglsurface.c \
+ eglx.c
OBJECTS = $(SOURCES:.c=.o)
+LOCAL_CFLAGS = -D_EGL_PLATFORM_X=1
+
+
.c.o:
- $(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $< -o $@
+ $(CC) -c $(INCLUDE_DIRS) $(CFLAGS) $(LOCAL_CFLAGS) $< -o $@
/**
- * NOTE: displayName is treated as a string in _eglChooseDriver()!!!
- * This will probably change!
- * See _eglChooseDriver() for details!
+ * This is typically the first EGL function that an application calls.
+ * We initialize our global vars and create a private _EGLDisplay object.
*/
EGLDisplay EGLAPIENTRY
-eglGetDisplay(NativeDisplayType displayName)
+eglGetDisplay(NativeDisplayType nativeDisplay)
{
_EGLDisplay *dpy;
_eglInitGlobals();
- dpy = _eglNewDisplay(displayName);
+ dpy = _eglNewDisplay(nativeDisplay);
return _eglGetDisplayHandle(dpy);
}
+/**
+ * This is typically the second EGL function that an application calls.
+ * Here we load/initialize the actual hardware driver.
+ */
EGLBoolean EGLAPIENTRY
eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
{
if (dpy) {
- _EGLDriver *drv = _eglChooseDriver(dpy);
- if (drv)
- return drv->API.Initialize(drv, dpy, major, minor);
+ _EGLDisplay *dpyPriv = _eglLookupDisplay(dpy);
+ if (!dpyPriv) {
+ return EGL_FALSE;
+ }
+ dpyPriv->Driver = _eglOpenDriver(dpyPriv, dpyPriv->DriverName);
+ if (!dpyPriv->Driver) {
+ return EGL_FALSE;
+ }
+ /* Initialize the particular driver now */
+ return dpyPriv->Driver->API.Initialize(dpyPriv->Driver, dpy,
+ major, minor);
}
return EGL_FALSE;
}
#define MIN2(A, B) (((A) < (B)) ? (A) : (B))
-#if 0
/**
* Convert an _EGLConfig to a __GLcontextModes object.
* NOTE: This routine may be incomplete - we're only making sure that
mode->visualType = GLX_TRUE_COLOR;
mode->renderType = GLX_RGBA_BIT;
}
-#endif
void
}
+#if 0
/**
* Creates a set of \c __GLcontextModes that a driver will expose.
*
* \c GL_UNSIGNED_3BYTE_8_8_8, \c GL_4FLOAT_32_32_32_32,
* \c GL_4HALF_16_16_16_16, etc. We can cross that bridge when we come to it.
*/
-#if 0
GLboolean
_eglFillInConfigs(_EGLConfig * configs,
GLenum fb_format, GLenum fb_type,
#include "egltypedefs.h"
-#if 0
+#include <GLES/gl.h>
#include "GL/internal/glcore.h"
-#endif
#define MAX_ATTRIBS 100
int visType );
#endif
-#if 0
+
extern void
_eglConfigToContextModesRec(const _EGLConfig *config, __GLcontextModes *mode);
-#endif
#endif /* EGLCONFIG_INCLUDED */
+
+/**
+ * Functions related to EGLDisplay.
+ */
+
+#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "eglcontext.h"
#include "egldisplay.h"
+#include "egldriver.h"
#include "eglglobals.h"
#include "eglhash.h"
static char *
my_strdup(const char *s)
{
- int l = strlen(s);
- char *s2 = malloc(l + 1);
- strcpy(s2, s);
- return s2;
+ if (s) {
+ int l = strlen(s);
+ char *s2 = malloc(l + 1);
+ if (s2)
+ strcpy(s2, s);
+ return s2;
+ }
+ return NULL;
}
/**
- * We're assuming that the NativeDisplayType parameter is actually
- * a string.
- * Return a new _EGLDisplay object for the given displayName
+ * Allocate a new _EGLDisplay object for the given nativeDisplay handle.
+ * We'll also try to determine the device driver name at this time.
*/
_EGLDisplay *
-_eglNewDisplay(NativeDisplayType displayName)
+_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);
- if (displayName)
- dpy->Name = my_strdup((char *) displayName);
- else
- dpy->Name = NULL;
- dpy->Driver = NULL; /* this gets set later */
+
+ dpy->NativeDisplay = nativeDisplay;
+#if defined(_EGL_PLATFORM_X)
+ dpy->Xdpy = (Display *) nativeDisplay;
+#endif
+
+ dpy->DriverName = my_strdup(_eglChooseDriver(dpy));
+ if (!dpy->DriverName) {
+ free(dpy);
+ return NULL;
+ }
}
return dpy;
}
}
+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);
+}
+
+
_EGLDisplay *
_eglGetCurrentDisplay(void)
{
{
/* XXX incomplete */
free(disp->Configs);
- free(disp->Name);
+ free((void *) disp->DriverName);
/* driver deletes _EGLDisplay */
}
#ifndef EGLDISPLAY_INCLUDED
#define EGLDISPLAY_INCLUDED
+#ifdef _EGL_PLATFORM_X
+#include <X11/Xlib.h>
+#endif
#include "egltypedefs.h"
struct _egl_display
{
+ EGLNativeDisplayType NativeDisplay;
EGLDisplay Handle;
- char *Name;
+ const char *DriverName;
_EGLDriver *Driver;
EGLint NumScreens;
EGLint NumConfigs;
_EGLConfig *Configs; /* array [NumConfigs] */
+
+#ifdef _EGL_PLATFORM_X
+ Display *Xdpy;
+#endif
};
_eglLookupDisplay(EGLDisplay dpy);
+extern void
+_eglSaveDisplay(_EGLDisplay *dpy);
+
+
extern _EGLDisplay *
_eglGetCurrentDisplay(void);
+/**
+ * Functions for choosing and opening/loading device drivers.
+ */
+
+
#include <assert.h>
#include <dlfcn.h>
#include <stdio.h>
#include "eglmode.h"
#include "eglscreen.h"
#include "eglsurface.h"
+#include "eglx.h"
const char *DefaultDriverName = "demodriver";
/**
- * Choose and open/init the hardware driver for the given EGLDisplay.
- * Previously, the EGLDisplay was created with _eglNewDisplay() where
- * we recorded the user's NativeDisplayType parameter.
+ * Determine/return the name of the driver to use for the given _EGLDisplay.
*
- * Now we'll use the NativeDisplayType value.
+ * Try to be clever and determine if nativeDisplay is an Xlib Display
+ * ptr or a string (naming a driver or screen number, etc).
*
- * Currently, the native display value is treated as a string.
* If the first character is ':' we interpret it as a screen or card index
* number (i.e. ":0" or ":1", etc)
* Else if the first character is '!' we interpret it as specific driver name
* (i.e. "!r200" or "!i830".
+ *
+ * The caller should make a copy of the returned string.
*/
-_EGLDriver *
-_eglChooseDriver(EGLDisplay display)
+const char *
+_eglChooseDriver(_EGLDisplay *dpy)
{
- _EGLDisplay *dpy = _eglLookupDisplay(display);
- _EGLDriver *drv;
- const char *driverName = DefaultDriverName;
- const char *name;
+ const char *name = (const char *) dpy->NativeDisplay;
+ const char *driverName = NULL;
- assert(dpy);
-
- name = dpy->Name;
- if (!name) {
- /* use default */
+ if (!dpy->NativeDisplay) {
+ /* choose a default */
+ driverName = DefaultDriverName;
}
- else if (name[0] == ':' && (name[1] >= '0' && name[1] <= '9') && !name[2]) {
+ else if (name && name[0] == ':' &&
+ (name[1] >= '0' && name[1] <= '9') && !name[2]) {
/* XXX probe hardware here to determine which driver to open */
driverName = "libEGLdri";
}
- else if (name[0] == '!') {
+ else if (name && name[0] == '!') {
/* use specified driver name */
driverName = name + 1;
}
else {
- /* Maybe display was returned by XOpenDisplay? */
- _eglLog(_EGL_FATAL, "eglChooseDriver() bad name");
+#if defined(_EGL_PLATFORM_X)
+ driverName = _xeglChooseDriver(dpy);
+#elif defined(_EGL_PLATFORM_WINDOWS)
+ /* XXX to do */
+ driverName = _weglChooseDriver(dpy);
+#elif defined(_EGL_PLATFORM_WINCE)
+ /* XXX to do */
+#endif
}
- _eglLog(_EGL_INFO, "eglChooseDriver() choosing %s", driverName);
-
- drv = _eglOpenDriver(dpy, driverName);
- dpy->Driver = drv;
-
- return drv;
+ return driverName;
}
/**
* Open/load the named driver and call its bootstrap function: _eglMain().
+ * By the time this function is called, the dpy->DriverName should have
+ * been determined.
+ *
* \return new _EGLDriver object.
*/
_EGLDriver *
void *lib;
char driverFilename[1000];
+ assert(driverName);
+
/* XXX also prepend a directory path??? */
sprintf(driverFilename, "%s.so", driverName);
extern _EGLDriver *_eglMain(_EGLDisplay *dpy);
-extern _EGLDriver *
-_eglChooseDriver(EGLDisplay dpy);
+extern const char *
+_eglChooseDriver(_EGLDisplay *dpy);
extern _EGLDriver *
-_eglOpenDriver(_EGLDisplay *dpy, const char *driverName);
+_eglOpenDriver(_EGLDisplay *dpy, const char *DriverName);
extern EGLBoolean
projects / mesa.git / commitdiff