Redo _eglInitContext() to do error checking, attribute list parsing, etc.
* Typical fallback routine for eglChooseConfig
*/
EGLBoolean
-_eglChooseConfig(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+_eglChooseConfig(_EGLDriver *drv, EGLDisplay dpy, const EGLint *attrib_list,
+ EGLConfig *configs, EGLint config_size, EGLint *num_config)
{
_EGLDisplay *disp = _eglLookupDisplay(dpy);
_EGLConfig criteria;
* Fallback for eglGetConfigAttrib.
*/
EGLBoolean
-_eglGetConfigAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
+_eglGetConfigAttrib(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ EGLint attribute, EGLint *value)
{
const _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
const EGLint k = attribute - FIRST_ATTRIB;
* Fallback for eglGetConfigs.
*/
EGLBoolean
-_eglGetConfigs(_EGLDriver *drv, EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+_eglGetConfigs(_EGLDriver *drv, EGLDisplay dpy, EGLConfig *configs,
+ EGLint config_size, EGLint *num_config)
{
_EGLDisplay *disp = _eglLookupDisplay(dpy);
*/
GLboolean
_eglFillInConfigs(_EGLConfig * configs,
- GLenum fb_format, GLenum fb_type,
- const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
- unsigned num_depth_stencil_bits,
- const GLenum * db_modes, unsigned num_db_modes,
- int visType) {
+ GLenum fb_format, GLenum fb_type,
+ const u_int8_t * depth_bits, const u_int8_t * stencil_bits,
+ unsigned num_depth_stencil_bits,
+ const GLenum * db_modes, unsigned num_db_modes,
+ int visType)
+{
static const u_int8_t bits_table[3][4] = {
/* R G B A */
{ 5, 6, 5, 0 }, /* Any GL_UNSIGNED_SHORT_5_6_5 */
#include <string.h>
#include "eglconfig.h"
#include "eglcontext.h"
+#include "egldisplay.h"
#include "egldriver.h"
#include "eglglobals.h"
#include "eglhash.h"
/**
* Initialize the given _EGLContext object to defaults.
*/
-void
-_eglInitContext(_EGLContext *ctx)
+EGLBoolean
+_eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
+ EGLConfig config, const EGLint *attrib_list)
{
- /* just init to zero for now */
+ _EGLConfig *conf;
+ _EGLDisplay *display = _eglLookupDisplay(dpy);
+ EGLint i;
+
+ conf = _eglLookupConfig(drv, dpy, config);
+ if (!conf) {
+ _eglError(EGL_BAD_CONFIG, "eglCreateContext");
+ return EGL_FALSE;
+ }
+
+ for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
+ switch (attrib_list[i]) {
+ /* no attribs defined for now */
+ default:
+ _eglError(EGL_BAD_ATTRIBUTE, "eglCreateContext");
+ return EGL_NO_CONTEXT;
+ }
+ }
+
memset(ctx, 0, sizeof(_EGLContext));
+ ctx->Display = display;
+ ctx->Config = conf;
+ ctx->DrawSurface = EGL_NO_SURFACE;
+ ctx->ReadSurface = EGL_NO_SURFACE;
+
+ return EGL_TRUE;
}
* Just a placeholder/demo function. Real driver will never use this!
*/
EGLContext
-_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
+_eglCreateContext(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ EGLContext share_list, const EGLint *attrib_list)
{
- _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
- if (!conf) {
- _eglError(EGL_BAD_CONFIG, "eglCreateContext");
+#if 0 /* example code */
+ _EGLContext *context;
+
+ context = (_EGLContext *) calloc(1, sizeof(_EGLContext));
+ if (!context)
return EGL_NO_CONTEXT;
- }
- if (share_list != EGL_NO_CONTEXT) {
- _EGLContext *shareCtx = _eglLookupContext(share_list);
- if (!shareCtx) {
- _eglError(EGL_BAD_CONTEXT, "eglCreateContext(share_list)");
- return EGL_NO_CONTEXT;
- }
+ if (!_eglInitContext(drv, dpy, context, config, attrib_list)) {
+ free(context);
+ return EGL_NO_CONTEXT;
}
+ _eglSaveContext(context);
+ return context->Handle;
+#endif
return EGL_NO_CONTEXT;
}
EGLBoolean
-_eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
+_eglQueryContext(_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx,
+ EGLint attribute, EGLint *value)
{
_EGLContext *c = _eglLookupContext(ctx);
* Then, the driver will do its device-dependent Make-Current stuff.
*/
EGLBoolean
-_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d, EGLSurface r, EGLContext context)
+_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy, EGLSurface d,
+ EGLSurface r, EGLContext context)
{
_EGLContext *ctx = _eglLookupContext(context);
_EGLSurface *draw = _eglLookupSurface(d);
};
-extern void
-_eglInitContext(_EGLContext *ctx);
+extern EGLBoolean
+_eglInitContext(_EGLDriver *drv, EGLDisplay dpy, _EGLContext *ctx,
+ EGLConfig config, const EGLint *attrib_list);
extern void
/**
- * Initialize the given _EGLSurface object. Do error checking.
- * Assign it an EGLSurface handle and insert into hash table.
- * \return EGLSurface handle or EGL_NO_SURFACE if error.
+ * Example function - drivers should do a proper implementation.
*/
EGLSurface
-_eglInitScreenSurface(_EGLSurface *surf, _EGLDriver *drv, EGLDisplay dpy,
- EGLConfig config, const EGLint *attrib_list)
+_eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ const EGLint *attrib_list)
{
- EGLint width = 0, height = 0;
- EGLint i;
+#if 0 /* THIS IS JUST EXAMPLE CODE */
+ _EGLSurface *surf;
- for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
- switch (attrib_list[i]) {
- case EGL_WIDTH:
- width = attrib_list[++i];
- break;
- case EGL_HEIGHT:
- height = attrib_list[++i];
- break;
- default:
- _eglError(EGL_BAD_ATTRIBUTE, "eglCreateScreenSurfaceMESA");
- return EGL_NO_SURFACE;
- }
- }
+ surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
+ if (!surf)
+ return EGL_NO_SURFACE;
- if (width <= 0 || height <= 0) {
- _eglError(EGL_BAD_ATTRIBUTE,
- "eglCreateScreenSurfaceMESA(width or height)");
+ if (!_eglInitSurface(drv, dpy, surf, EGL_SCREEN_BIT_MESA,
+ config, attrib_list)) {
+ free(surf);
return EGL_NO_SURFACE;
}
- _eglInitSurface(surf);
- surf->Width = width;
- surf->Height = height;
- surf->Type = EGL_SCREEN_BIT_MESA;
- surf->Config = _eglLookupConfig(drv, dpy, config);
-
- /* insert into hash table */
_eglSaveSurface(surf);
- assert(surf->Handle);
return surf->Handle;
-}
-
-
-/**
- * Create a drawing surface which can be directly displayed on a screen.
- */
-EGLSurface
-_eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
- const EGLint *attrib_list)
-{
- _EGLSurface *surf;
- EGLSurface surface;
-
- surf = (_EGLSurface *) malloc(sizeof(_EGLSurface));
- surface = _eglInitScreenSurface(surf, drv, dpy, config, attrib_list);
- if (surface == EGL_NO_SURFACE)
- free(surf);
-
- return surface;
+#endif
+ return EGL_NO_SURFACE;
}
* an integer.
*/
+
+/**
+ * Per-screen information.
+ * Note that an EGL screen doesn't have a size. A screen may be set to
+ * one of several display modes (width/height/scanrate). The screen
+ * then displays a drawing surface. The drawing surface must be at least
+ * as large as the display mode's resolution. If it's larger, the
+ * OriginX and OriginY fields control what part of the surface is visible
+ * on the screen.
+ */
struct _egl_screen
{
EGLScreenMESA Handle; /* The public/opaque handle which names this object */
_eglGetScreensMESA(_EGLDriver *drv, EGLDisplay dpy, EGLScreenMESA *screens, EGLint max_screens, EGLint *num_screens);
-extern EGLSurface
-_eglInitScreenSurface(_EGLSurface *surf, _EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
-
-
extern EGLSurface
_eglCreateScreenSurfaceMESA(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
#include <string.h>
#include "eglcontext.h"
#include "eglconfig.h"
-#include "eglsurface.h"
#include "eglglobals.h"
#include "eglhash.h"
+#include "egllog.h"
+#include "eglsurface.h"
-void
-_eglInitSurface(_EGLSurface *surf)
+/**
+ * Do error check on parameters and initialize the given _EGLSurface object.
+ * \return EGL_TRUE if no errors, EGL_FALSE otherwise.
+ */
+EGLBoolean
+_eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
+ _EGLSurface *surf, EGLint type, EGLConfig config,
+ const EGLint *attrib_list)
{
- /* XXX fix this up */
+ const char *func;
+ _EGLConfig *conf;
+ EGLint width = 0, height = 0, largest = 0;
+ EGLint texFormat = 0, texTarget = 0, mipmapTex = 0;
+ EGLint i;
+
+ switch (type) {
+ case EGL_WINDOW_BIT:
+ func = "eglCreateWindowSurface";
+ break;
+ case EGL_PIXMAP_BIT:
+ func = "eglCreatePixmapSurface";
+ break;
+ case EGL_PBUFFER_BIT:
+ func = "eglCreatePBufferSurface";
+ break;
+ case EGL_SCREEN_BIT_MESA:
+ func = "eglCreateScreenSurface";
+ break;
+ default:
+ _eglLog(_EGL_WARNING, "Bad type in _eglInitSurface");
+ return EGL_FALSE;
+ }
+
+ conf = _eglLookupConfig(drv, dpy, config);
+ if (!conf) {
+ _eglError(EGL_BAD_CONFIG, func);
+ return EGL_FALSE;
+ }
+
+ /*
+ * Parse attribute list. Different kinds of surfaces support different
+ * attributes.
+ */
+ for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
+ switch (attrib_list[i]) {
+ case EGL_WIDTH:
+ if (type == EGL_PBUFFER_BIT || type == EGL_SCREEN_BIT_MESA) {
+ width = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ case EGL_HEIGHT:
+ if (type == EGL_PBUFFER_BIT || type == EGL_SCREEN_BIT_MESA) {
+ height = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ case EGL_LARGEST_PBUFFER:
+ if (type == EGL_PBUFFER_BIT) {
+ largest = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ case EGL_TEXTURE_FORMAT:
+ if (type == EGL_PBUFFER_BIT) {
+ texFormat = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ case EGL_TEXTURE_TARGET:
+ if (type == EGL_PBUFFER_BIT) {
+ texTarget = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ case EGL_MIPMAP_TEXTURE:
+ if (type == EGL_PBUFFER_BIT) {
+ mipmapTex = attrib_list[++i];
+ }
+ else {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ break;
+ default:
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+ }
+
+ if (width <= 0 || height <= 0) {
+ _eglError(EGL_BAD_ATTRIBUTE, func);
+ return EGL_FALSE;
+ }
+
memset(surf, 0, sizeof(_EGLSurface));
+ surf->Config = conf;
+ surf->Type = type;
+ surf->Width = width;
+ surf->Height = height;
+ surf->TextureFormat = texFormat;
+ surf->TextureTarget = texTarget;
+ surf->MipmapTexture = mipmapTex;
+ surf->MipmapLevel = 0;
+ surf->SwapInterval = 0;
+
+ return EGL_TRUE;
}
_eglSaveSurface(_EGLSurface *surf)
{
assert(surf);
+ assert(!surf->Handle);
surf->Handle = _eglHashGenKey(_eglGlobal.Contexts);
+ assert(surf->Handle);
_eglHashInsert(_eglGlobal.Surfaces, surf->Handle, surf);
}
EGLBoolean
-_eglCopyBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface, NativePixmapType target)
+_eglCopyBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface,
+ NativePixmapType target)
{
/* copy surface to native pixmap */
/* All implementation burdon for this is in the device driver */
EGLBoolean
-_eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf, EGLint attribute, EGLint *value)
+_eglQuerySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surf,
+ EGLint attribute, EGLint *value)
{
_EGLSurface *surface = _eglLookupSurface(surf);
if (surface == NULL) {
/**
- * Default fallback routine - drivers should usually override this.
+ * Example function - drivers should do a proper implementation.
*/
EGLSurface
-_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
+_eglCreateWindowSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ NativeWindowType window, const EGLint *attrib_list)
{
- /* nothing - just a placeholder */
+#if 0 /* THIS IS JUST EXAMPLE CODE */
+ _EGLSurface *surf;
+
+ surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
+ if (!surf)
+ return EGL_NO_SURFACE;
+
+ if (!_eglInitSurface(drv, dpy, surf, EGL_WINDOW_BIT, config, attrib_list)) {
+ free(surf);
+ return EGL_NO_SURFACE;
+ }
+
+ _eglSaveSurface(surf);
+
+ return surf->Handle;
+#endif
return EGL_NO_SURFACE;
}
/**
- * Default fallback routine - drivers should usually override this.
+ * Example function - drivers should do a proper implementation.
*/
EGLSurface
-_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativePixmapType pixmap, const EGLint *attrib_list)
+_eglCreatePixmapSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ NativePixmapType pixmap, const EGLint *attrib_list)
{
- /* nothing - just a placeholder */
+#if 0 /* THIS IS JUST EXAMPLE CODE */
+ _EGLSurface *surf;
+
+ surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
+ if (!surf)
+ return EGL_NO_SURFACE;
+
+ if (!_eglInitSurface(drv, dpy, surf, EGL_PIXMAP_BIT, config, attrib_list)) {
+ free(surf);
+ return EGL_NO_SURFACE;
+ }
+
+ _eglSaveSurface(surf);
+
+ return surf->Handle;
+#endif
return EGL_NO_SURFACE;
}
/**
- * Default fallback routine - drivers should usually override this.
+ * Example function - drivers should do a proper implementation.
*/
EGLSurface
-_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+_eglCreatePbufferSurface(_EGLDriver *drv, EGLDisplay dpy, EGLConfig config,
+ const EGLint *attrib_list)
{
- /* nothing - just a placeholder */
+#if 0 /* THIS IS JUST EXAMPLE CODE */
+ _EGLSurface *surf;
+
+ surf = (_EGLSurface *) calloc(1, sizeof(_EGLSurface));
+ if (!surf)
+ return EGL_NO_SURFACE;
+
+ if (!_eglInitSurface(drv, dpy, surf, EGL_PBUFFER_BIT, config, attrib_list)) {
+ free(surf);
+ return EGL_NO_SURFACE;
+ }
+
+ _eglSaveSurface(surf);
+
+ return surf->Handle;
+#endif
return EGL_NO_SURFACE;
}
surf->SwapInterval = interval;
return EGL_TRUE;
}
-
-
-
-/**
- ** EGL Surface Utility Functions. This could be handy for device drivers.
- **/
-
-
-/**
- * Initialize the fields of the given _EGLSurface object from the other
- * parameters. Do error checking too. Allocate EGLSurface handle and
- * insert into hash table.
- * \return EGLSurface handle or EGL_NO_SURFACE if any error
- */
-EGLSurface
-_eglInitPbufferSurface(_EGLSurface *surface, _EGLDriver *drv, EGLDisplay dpy,
- EGLConfig config, const EGLint *attrib_list)
-{
- _EGLConfig *conf;
- EGLint width = 0, height = 0, largest = 0;
- EGLint texFormat = 0, texTarget = 0, mipmapTex = 0;
- EGLint i;
-
- conf = _eglLookupConfig(drv, dpy, config);
- if (!conf) {
- _eglError(EGL_BAD_CONFIG, "eglCreatePbufferSurface");
- return EGL_NO_SURFACE;
- }
-
- for (i = 0; attrib_list && attrib_list[i] != EGL_NONE; i++) {
- switch (attrib_list[i]) {
- case EGL_WIDTH:
- width = attrib_list[++i];
- break;
- case EGL_HEIGHT:
- height = attrib_list[++i];
- break;
- case EGL_LARGEST_PBUFFER:
- largest = attrib_list[++i];
- break;
- case EGL_TEXTURE_FORMAT:
- texFormat = attrib_list[++i];
- break;
- case EGL_TEXTURE_TARGET:
- texTarget = attrib_list[++i];
- break;
- case EGL_MIPMAP_TEXTURE:
- mipmapTex = attrib_list[++i];
- break;
- default:
- _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePbufferSurface");
- return EGL_NO_SURFACE;
- }
- }
-
- if (width <= 0 || height <= 0) {
- _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePbufferSurface(width or height)");
- return EGL_NO_SURFACE;
- }
-
- surface->Config = conf;
- surface->Type = EGL_PBUFFER_BIT;
- surface->Width = width;
- surface->Height = height;
- surface->TextureFormat = texFormat;
- surface->TextureTarget = texTarget;
- surface->MipmapTexture = mipmapTex;
- surface->MipmapLevel = 0;
- surface->SwapInterval = 0;
-
- /* insert into hash table */
- _eglSaveSurface(surface);
- assert(surface->Handle);
-
- return surface->Handle;
-}
};
-extern void
-_eglInitSurface(_EGLSurface *surf);
+extern EGLBoolean
+_eglInitSurface(_EGLDriver *drv, EGLDisplay dpy,
+ _EGLSurface *surf, EGLint type, EGLConfig config,
+ const EGLint *attrib_list);
extern void
_eglSwapInterval(_EGLDriver *drv, EGLDisplay dpy, EGLint interval);
-
-extern EGLSurface
-_eglInitPbufferSurface(_EGLSurface *surface, _EGLDriver *drv, EGLDisplay dpy,
- EGLConfig config, const EGLint *attrib_list);
-
#endif /* EGLSURFACE_INCLUDED */
projects / mesa.git / commitdiff