/**************************************************************************
*
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
* Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
* Copyright 2010-2011 LunarG, Inc.
* All Rights Reserved.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include "c99_compat.h"
+#include "c11/threads.h"
+#include "eglcompiler.h"
+#include "eglglobals.h"
#include "eglcontext.h"
#include "egldisplay.h"
#include "egltypedefs.h"
#include "eglmode.h"
#include "eglimage.h"
#include "eglsync.h"
+#include "eglstring.h"
/**
_eglUnlockDisplay(disp); \
/* EGL error codes are non-zero */ \
if (err) \
- _eglError(err, __FUNCTION__); \
+ _eglError(err, __func__); \
return ret; \
} while (0)
#define _EGL_CHECK_DISPLAY(disp, ret, drv) \
do { \
- drv = _eglCheckDisplay(disp, __FUNCTION__); \
+ drv = _eglCheckDisplay(disp, __func__); \
if (!drv) \
RETURN_EGL_ERROR(disp, 0, ret); \
} while (0)
#define _EGL_CHECK_OBJECT(disp, type, obj, ret, drv) \
do { \
- drv = _eglCheck ## type(disp, obj, __FUNCTION__); \
+ drv = _eglCheck ## type(disp, obj, __func__); \
if (!drv) \
RETURN_EGL_ERROR(disp, 0, ret); \
} while (0)
_EGL_CHECK_OBJECT(disp, Sync, s, ret, drv)
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckDisplay(_EGLDisplay *disp, const char *msg)
{
if (!disp) {
}
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
}
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
}
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
}
-#ifdef EGL_KHR_reusable_sync
-
-
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckSync(_EGLDisplay *disp, _EGLSync *s, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
}
-#endif /* EGL_KHR_reusable_sync */
-
-
#ifdef EGL_MESA_screen_surface
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
}
-static INLINE _EGLDriver *
+static inline _EGLDriver *
_eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
{
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
/**
* Lookup and lock a display.
*/
-static INLINE _EGLDisplay *
+static inline _EGLDisplay *
_eglLockDisplay(EGLDisplay display)
{
_EGLDisplay *dpy = _eglLookupDisplay(display);
if (dpy)
- _eglLockMutex(&dpy->Mutex);
+ mtx_lock(&dpy->Mutex);
return dpy;
}
/**
* Unlock a display.
*/
-static INLINE void
+static inline void
_eglUnlockDisplay(_EGLDisplay *dpy)
{
- _eglUnlockMutex(&dpy->Mutex);
+ mtx_unlock(&dpy->Mutex);
}
EGLDisplay EGLAPIENTRY
eglGetDisplay(EGLNativeDisplayType nativeDisplay)
{
- _EGLPlatformType plat = _eglGetNativePlatform(nativeDisplay);
- _EGLDisplay *dpy = _eglFindDisplay(plat, (void *) nativeDisplay);
+ _EGLPlatformType plat;
+ _EGLDisplay *dpy;
+ void *native_display_ptr;
+
+ STATIC_ASSERT(sizeof(void*) == sizeof(nativeDisplay));
+ native_display_ptr = (void*) nativeDisplay;
+
+ plat = _eglGetNativePlatform(native_display_ptr);
+ dpy = _eglFindDisplay(plat, native_display_ptr);
+ return _eglGetDisplayHandle(dpy);
+}
+
+EGLDisplay EGLAPIENTRY
+eglGetPlatformDisplayEXT(EGLenum platform, void *native_display,
+ const EGLint *attrib_list)
+{
+ _EGLDisplay *dpy;
+
+ switch (platform) {
+#ifdef HAVE_X11_PLATFORM
+ case EGL_PLATFORM_X11_EXT:
+ dpy = _eglGetX11Display((Display*) native_display, attrib_list);
+ break;
+#endif
+#ifdef HAVE_DRM_PLATFORM
+ case EGL_PLATFORM_GBM_MESA:
+ dpy = _eglGetGbmDisplay((struct gbm_device*) native_display,
+ attrib_list);
+ break;
+#endif
+#ifdef HAVE_WAYLAND_PLATFORM
+ case EGL_PLATFORM_WAYLAND_EXT:
+ dpy = _eglGetWaylandDisplay((struct wl_display*) native_display,
+ attrib_list);
+ break;
+#endif
+ default:
+ RETURN_EGL_ERROR(NULL, EGL_BAD_PARAMETER, NULL);
+ }
+
return _eglGetDisplayHandle(dpy);
}
+/**
+ * Copy the extension into the string and update the string pointer.
+ */
+static EGLint
+_eglAppendExtension(char **str, const char *ext)
+{
+ char *s = *str;
+ size_t len = strlen(ext);
+
+ if (s) {
+ memcpy(s, ext, len);
+ s[len++] = ' ';
+ s[len] = '\0';
+
+ *str += len;
+ }
+ else {
+ len++;
+ }
+
+ return (EGLint) len;
+}
+
+/**
+ * Examine the individual extension enable/disable flags and recompute
+ * the driver's Extensions string.
+ */
+static void
+_eglCreateExtensionsString(_EGLDisplay *dpy)
+{
+#define _EGL_CHECK_EXTENSION(ext) \
+ do { \
+ if (dpy->Extensions.ext) { \
+ _eglAppendExtension(&exts, "EGL_" #ext); \
+ assert(exts <= dpy->ExtensionsString + _EGL_MAX_EXTENSIONS_LEN); \
+ } \
+ } while (0)
+
+ char *exts = dpy->ExtensionsString;
+
+ _EGL_CHECK_EXTENSION(MESA_screen_surface);
+ _EGL_CHECK_EXTENSION(MESA_copy_context);
+ _EGL_CHECK_EXTENSION(MESA_drm_display);
+ _EGL_CHECK_EXTENSION(MESA_drm_image);
+ _EGL_CHECK_EXTENSION(MESA_configless_context);
+
+ _EGL_CHECK_EXTENSION(WL_bind_wayland_display);
+ _EGL_CHECK_EXTENSION(WL_create_wayland_buffer_from_image);
+
+ _EGL_CHECK_EXTENSION(KHR_image_base);
+ _EGL_CHECK_EXTENSION(KHR_image_pixmap);
+ if (dpy->Extensions.KHR_image_base && dpy->Extensions.KHR_image_pixmap)
+ _eglAppendExtension(&exts, "EGL_KHR_image");
+
+ _EGL_CHECK_EXTENSION(KHR_vg_parent_image);
+ _EGL_CHECK_EXTENSION(KHR_get_all_proc_addresses);
+ _EGL_CHECK_EXTENSION(KHR_gl_texture_2D_image);
+ _EGL_CHECK_EXTENSION(KHR_gl_texture_cubemap_image);
+ _EGL_CHECK_EXTENSION(KHR_gl_texture_3D_image);
+ _EGL_CHECK_EXTENSION(KHR_gl_renderbuffer_image);
+
+ _EGL_CHECK_EXTENSION(KHR_reusable_sync);
+ _EGL_CHECK_EXTENSION(KHR_fence_sync);
+
+ _EGL_CHECK_EXTENSION(KHR_surfaceless_context);
+ _EGL_CHECK_EXTENSION(KHR_create_context);
+
+ _EGL_CHECK_EXTENSION(NOK_swap_region);
+ _EGL_CHECK_EXTENSION(NOK_texture_from_pixmap);
+
+ _EGL_CHECK_EXTENSION(ANDROID_image_native_buffer);
+
+ _EGL_CHECK_EXTENSION(CHROMIUM_sync_control);
+
+ _EGL_CHECK_EXTENSION(EXT_create_context_robustness);
+ _EGL_CHECK_EXTENSION(EXT_buffer_age);
+ _EGL_CHECK_EXTENSION(EXT_swap_buffers_with_damage);
+ _EGL_CHECK_EXTENSION(EXT_image_dma_buf_import);
+
+ _EGL_CHECK_EXTENSION(NV_post_sub_buffer);
+#undef _EGL_CHECK_EXTENSION
+}
+
+static void
+_eglCreateAPIsString(_EGLDisplay *dpy)
+{
+ if (dpy->ClientAPIs & EGL_OPENGL_BIT)
+ strcat(dpy->ClientAPIsString, "OpenGL ");
+
+ if (dpy->ClientAPIs & EGL_OPENGL_ES_BIT)
+ strcat(dpy->ClientAPIsString, "OpenGL_ES ");
+
+ if (dpy->ClientAPIs & EGL_OPENGL_ES2_BIT)
+ strcat(dpy->ClientAPIsString, "OpenGL_ES2 ");
+
+ if (dpy->ClientAPIs & EGL_OPENGL_ES3_BIT_KHR)
+ strcat(dpy->ClientAPIsString, "OpenGL_ES3 ");
+
+ if (dpy->ClientAPIs & EGL_OPENVG_BIT)
+ strcat(dpy->ClientAPIsString, "OpenVG ");
+
+ assert(strlen(dpy->ClientAPIsString) < sizeof(dpy->ClientAPIsString));
+}
+
/**
* This is typically the second EGL function that an application calls.
/* limit to APIs supported by core */
disp->ClientAPIs &= _EGL_API_ALL_BITS;
+
+ /* EGL_KHR_get_all_proc_addresses is a corner-case extension. The spec
+ * classifies it as an EGL display extension, though conceptually it's an
+ * EGL client extension.
+ *
+ * From the EGL_KHR_get_all_proc_addresses spec:
+ *
+ * The EGL implementation must expose the name
+ * EGL_KHR_client_get_all_proc_addresses if and only if it exposes
+ * EGL_KHR_get_all_proc_addresses and supports
+ * EGL_EXT_client_extensions.
+ *
+ * Mesa unconditionally exposes both client extensions mentioned above,
+ * so the spec requires that each EGLDisplay unconditionally expose
+ * EGL_KHR_get_all_proc_addresses also.
+ */
+ disp->Extensions.KHR_get_all_proc_addresses = EGL_TRUE;
+
+ _eglCreateExtensionsString(disp);
+ _eglCreateAPIsString(disp);
+ _eglsnprintf(disp->VersionString, sizeof(disp->VersionString),
+ "%d.%d (%s)", disp->VersionMajor, disp->VersionMinor,
+ disp->Driver->Name);
}
/* Update applications version of major and minor if not NULL */
const char * EGLAPIENTRY
eglQueryString(EGLDisplay dpy, EGLint name)
{
- _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDisplay *disp;
_EGLDriver *drv;
const char *ret;
+ if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) {
+ RETURN_EGL_SUCCESS(NULL, _eglGlobal.ClientExtensionString);
+ }
+
+ disp = _eglLockDisplay(dpy);
_EGL_CHECK_DISPLAY(disp, NULL, drv);
ret = drv->API.QueryString(drv, disp, name);
_EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT, drv);
- if (!config) {
- /* config may be NULL if surfaceless */
- if (!disp->Extensions.KHR_surfaceless_gles1 &&
- !disp->Extensions.KHR_surfaceless_gles2 &&
- !disp->Extensions.KHR_surfaceless_opengl)
- RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
- }
+ if (!config && !disp->Extensions.MESA_configless_context)
+ RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
if (!share && share_list != EGL_NO_CONTEXT)
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
if (!context && ctx != EGL_NO_CONTEXT)
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
if (!draw_surf || !read_surf) {
- /* surfaces may be NULL if surfaceless */
- if (!disp->Extensions.KHR_surfaceless_gles1 &&
- !disp->Extensions.KHR_surfaceless_gles2 &&
- !disp->Extensions.KHR_surfaceless_opengl)
+ /* From the EGL 1.4 (20130211) spec:
+ *
+ * To release the current context without assigning a new one, set ctx
+ * to EGL_NO_CONTEXT and set draw and read to EGL_NO_SURFACE.
+ */
+ if (!disp->Extensions.KHR_surfaceless_context && ctx != EGL_NO_CONTEXT)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
if ((!draw_surf && draw != EGL_NO_SURFACE) ||
}
-EGLSurface EGLAPIENTRY
-eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativeWindowType window, const EGLint *attrib_list)
+static EGLSurface
+_eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
+ void *native_window, const EGLint *attrib_list)
{
- _EGLDisplay *disp = _eglLockDisplay(dpy);
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
EGLSurface ret;
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
- if (disp->Platform != _eglGetNativePlatform(disp->PlatformDisplay))
+
+ if (native_window == NULL)
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
- surf = drv->API.CreateWindowSurface(drv, disp, conf, window, attrib_list);
+ surf = drv->API.CreateWindowSurface(drv, disp, conf, native_window,
+ attrib_list);
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
EGLSurface EGLAPIENTRY
-eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
- EGLNativePixmapType pixmap, const EGLint *attrib_list)
+eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
+ EGLNativeWindowType window, const EGLint *attrib_list)
{
_EGLDisplay *disp = _eglLockDisplay(dpy);
+ STATIC_ASSERT(sizeof(void*) == sizeof(window));
+ return _eglCreateWindowSurfaceCommon(disp, config, (void*) window,
+ attrib_list);
+}
+
+
+EGLSurface EGLAPIENTRY
+eglCreatePlatformWindowSurfaceEXT(EGLDisplay dpy, EGLConfig config,
+ void *native_window,
+ const EGLint *attrib_list)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+
+#ifdef HAVE_X11_PLATFORM
+ if (disp->Platform == _EGL_PLATFORM_X11 && native_window != NULL) {
+ /* The `native_window` parameter for the X11 platform differs between
+ * eglCreateWindowSurface() and eglCreatePlatformPixmapSurfaceEXT(). In
+ * eglCreateWindowSurface(), the type of `native_window` is an Xlib
+ * `Window`. In eglCreatePlatformWindowSurfaceEXT(), the type is
+ * `Window*`. Convert `Window*` to `Window` because that's what
+ * dri2_x11_create_window_surface() expects.
+ */
+ native_window = (void*) (* (Window*) native_window);
+ }
+#endif
+
+ return _eglCreateWindowSurfaceCommon(disp, config, native_window,
+ attrib_list);
+}
+
+
+static EGLSurface
+_eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
+ void *native_pixmap, const EGLint *attrib_list)
+{
_EGLConfig *conf = _eglLookupConfig(config, disp);
_EGLDriver *drv;
_EGLSurface *surf;
EGLSurface ret;
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
- if (disp->Platform != _eglGetNativePlatform(disp->PlatformDisplay))
- RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
-
- surf = drv->API.CreatePixmapSurface(drv, disp, conf, pixmap, attrib_list);
+ surf = drv->API.CreatePixmapSurface(drv, disp, conf, native_pixmap,
+ attrib_list);
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
RETURN_EGL_EVAL(disp, ret);
}
+EGLSurface EGLAPIENTRY
+eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
+ EGLNativePixmapType pixmap, const EGLint *attrib_list)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ STATIC_ASSERT(sizeof(void*) == sizeof(pixmap));
+ return _eglCreatePixmapSurfaceCommon(disp, config, (void*) pixmap,
+ attrib_list);
+}
+
+EGLSurface EGLAPIENTRY
+eglCreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, EGLConfig config,
+ void *native_pixmap,
+ const EGLint *attrib_list)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+
+#ifdef HAVE_X11_PLATFORM
+ /* The `native_pixmap` parameter for the X11 platform differs between
+ * eglCreatePixmapSurface() and eglCreatePlatformPixmapSurfaceEXT(). In
+ * eglCreatePixmapSurface(), the type of `native_pixmap` is an Xlib
+ * `Pixmap`. In eglCreatePlatformPixmapSurfaceEXT(), the type is
+ * `Pixmap*`. Convert `Pixmap*` to `Pixmap` because that's what
+ * dri2_x11_create_pixmap_surface() expects.
+ */
+ if (disp->Platform == _EGL_PLATFORM_X11 && native_pixmap != NULL) {
+ native_pixmap = (void*) (* (Pixmap*) native_pixmap);
+ }
+#endif
+
+ return _eglCreatePixmapSurfaceCommon(disp, config, native_pixmap,
+ attrib_list);
+}
+
+
EGLSurface EGLAPIENTRY
eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
const EGLint *attrib_list)
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
/* surface must be bound to current context in EGL 1.4 */
+ #ifndef _EGL_BUILT_IN_DRIVER_HAIKU
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
surf != ctx->DrawSurface)
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+ #endif
ret = drv->API.SwapBuffers(drv, disp, surf);
}
+#ifdef EGL_EXT_swap_buffers_with_damage
+
+EGLBoolean EGLAPIENTRY
+eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface,
+ EGLint *rects, EGLint n_rects)
+{
+ _EGLContext *ctx = _eglGetCurrentContext();
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+
+ /* surface must be bound to current context in EGL 1.4 */
+ if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
+ surf != ctx->DrawSurface)
+ RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
+
+ if ((n_rects > 0 && rects == NULL) || n_rects < 0)
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
+
+ ret = drv->API.SwapBuffersWithDamageEXT(drv, disp, surf, rects, n_rects);
+
+ RETURN_EGL_EVAL(disp, ret);
+}
+
+#endif /* EGL_EXT_swap_buffers_with_damage */
+
EGLBoolean EGLAPIENTRY
eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
{
_EGLSurface *surf = _eglLookupSurface(surface, disp);
_EGLDriver *drv;
EGLBoolean ret;
+ void *native_pixmap_ptr;
+
+ STATIC_ASSERT(sizeof(void*) == sizeof(target));
+ native_pixmap_ptr = (void*) target;
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
if (disp->Platform != _eglGetNativePlatform(disp->PlatformDisplay))
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_FALSE);
- ret = drv->API.CopyBuffers(drv, disp, surf, target);
+ ret = drv->API.CopyBuffers(drv, disp, surf, native_pixmap_ptr);
RETURN_EGL_EVAL(disp, ret);
}
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
disp = ctx->Resource.Display;
- _eglLockMutex(&disp->Mutex);
+ mtx_lock(&disp->Mutex);
/* let bad current context imply bad current surface */
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
EGLBoolean EGLAPIENTRY
eglWaitGL(void)
{
-#ifdef EGL_VERSION_1_2
_EGLThreadInfo *t = _eglGetCurrentThread();
EGLint api_index = t->CurrentAPIIndex;
EGLint es_index = _eglConvertApiToIndex(EGL_OPENGL_ES_API);
ret = eglWaitClient();
t->CurrentAPIIndex = api_index;
return ret;
-#else
- return eglWaitClient();
-#endif
}
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
disp = ctx->Resource.Display;
- _eglLockMutex(&disp->Mutex);
+ mtx_lock(&disp->Mutex);
/* let bad current context imply bad current surface */
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
#ifdef EGL_MESA_drm_display
{ "eglGetDRMDisplayMESA", (_EGLProc) eglGetDRMDisplayMESA },
#endif
-#ifdef EGL_KHR_image_base
{ "eglCreateImageKHR", (_EGLProc) eglCreateImageKHR },
{ "eglDestroyImageKHR", (_EGLProc) eglDestroyImageKHR },
-#endif /* EGL_KHR_image_base */
+ { "eglCreateSyncKHR", (_EGLProc) eglCreateSyncKHR },
+ { "eglDestroySyncKHR", (_EGLProc) eglDestroySyncKHR },
+ { "eglClientWaitSyncKHR", (_EGLProc) eglClientWaitSyncKHR },
+ { "eglSignalSyncKHR", (_EGLProc) eglSignalSyncKHR },
+ { "eglGetSyncAttribKHR", (_EGLProc) eglGetSyncAttribKHR },
#ifdef EGL_NOK_swap_region
{ "eglSwapBuffersRegionNOK", (_EGLProc) eglSwapBuffersRegionNOK },
#endif
#ifdef EGL_WL_bind_wayland_display
{ "eglBindWaylandDisplayWL", (_EGLProc) eglBindWaylandDisplayWL },
{ "eglUnbindWaylandDisplayWL", (_EGLProc) eglUnbindWaylandDisplayWL },
+ { "eglQueryWaylandBufferWL", (_EGLProc) eglQueryWaylandBufferWL },
+#endif
+#ifdef EGL_WL_create_wayland_buffer_from_image
+ { "eglCreateWaylandBufferFromImageWL", (_EGLProc) eglCreateWaylandBufferFromImageWL },
#endif
-#ifdef EGL_ANDROID_swap_rectangle
- { "eglSetSwapRectangleANDROID", (_EGLProc) eglSetSwapRectangleANDROID },
+ { "eglPostSubBufferNV", (_EGLProc) eglPostSubBufferNV },
+#ifdef EGL_EXT_swap_buffers_with_damage
+ { "eglSwapBuffersWithDamageEXT", (_EGLProc) eglSwapBuffersWithDamageEXT },
#endif
+ { "eglGetPlatformDisplayEXT", (_EGLProc) eglGetPlatformDisplayEXT },
+ { "eglCreatePlatformWindowSurfaceEXT", (_EGLProc) eglCreatePlatformWindowSurfaceEXT },
+ { "eglCreatePlatformPixmapSurfaceEXT", (_EGLProc) eglCreatePlatformPixmapSurfaceEXT },
+ { "eglGetSyncValuesCHROMIUM", (_EGLProc) eglGetSyncValuesCHROMIUM },
{ NULL, NULL }
};
EGLint i;
** EGL 1.2
**/
-#ifdef EGL_VERSION_1_2
-
-
/**
* Specify the client API to use for subsequent calls including:
* eglCreateContext()
t->CurrentAPIIndex = i;
- _eglLockMutex(&disp->Mutex);
+ mtx_lock(&disp->Mutex);
drv = disp->Driver;
(void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
- _eglUnlockMutex(&disp->Mutex);
+ mtx_unlock(&disp->Mutex);
}
}
}
-#endif /* EGL_VERSION_1_2 */
-
-
-#ifdef EGL_KHR_image_base
-
-
EGLImageKHR EGLAPIENTRY
eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
EGLClientBuffer buffer, const EGLint *attr_list)
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
if (!context && ctx != EGL_NO_CONTEXT)
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
+ /* "If <target> is EGL_LINUX_DMA_BUF_EXT, <dpy> must be a valid display,
+ * <ctx> must be EGL_NO_CONTEXT..."
+ */
+ if (ctx != EGL_NO_CONTEXT && target == EGL_LINUX_DMA_BUF_EXT)
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
img = drv->API.CreateImageKHR(drv,
disp, context, target, buffer, attr_list);
}
-#endif /* EGL_KHR_image_base */
-
-
-#ifdef EGL_KHR_reusable_sync
-
-
EGLSyncKHR EGLAPIENTRY
eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
{
}
-#endif /* EGL_KHR_reusable_sync */
-
-
#ifdef EGL_NOK_swap_region
EGLBoolean EGLAPIENTRY
RETURN_EGL_EVAL(disp, ret);
}
+
+EGLBoolean EGLAPIENTRY
+eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *buffer,
+ EGLint attribute, EGLint *value)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+ assert(disp->Extensions.WL_bind_wayland_display);
+
+ if (!buffer)
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
+
+ ret = drv->API.QueryWaylandBufferWL(drv, disp, buffer, attribute, value);
+
+ RETURN_EGL_EVAL(disp, ret);
+}
+#endif
+
+#ifdef EGL_WL_create_wayland_buffer_from_image
+struct wl_buffer * EGLAPIENTRY
+eglCreateWaylandBufferFromImageWL(EGLDisplay dpy, EGLImageKHR image)
+{
+ _EGLDisplay *disp = _eglLockDisplay(dpy);
+ _EGLImage *img;
+ _EGLDriver *drv;
+ struct wl_buffer *ret;
+
+ _EGL_CHECK_DISPLAY(disp, NULL, drv);
+ assert(disp->Extensions.WL_create_wayland_buffer_from_image);
+
+ img = _eglLookupImage(image, disp);
+
+ if (!img)
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
+
+ ret = drv->API.CreateWaylandBufferFromImageWL(drv, disp, img);
+
+ RETURN_EGL_EVAL(disp, ret);
+}
#endif
-#ifdef EGL_ANDROID_swap_rectangle
EGLBoolean EGLAPIENTRY
-eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
- EGLint left, EGLint top,
- EGLint width, EGLint height)
+eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface,
+ EGLint x, EGLint y, EGLint width, EGLint height)
{
_EGLDisplay *disp = _eglLockDisplay(dpy);
- _EGLSurface *surf = _eglLookupSurface(draw, disp);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
_EGLDriver *drv;
EGLBoolean ret;
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
- if (!disp->Extensions.ANDROID_swap_rectangle)
+ if (!disp->Extensions.NV_post_sub_buffer)
RETURN_EGL_EVAL(disp, EGL_FALSE);
- ret = drv->API.SetSwapRectangleANDROID(drv, disp, surf, left, top, width, height);
+ ret = drv->API.PostSubBufferNV(drv, disp, surf, x, y, width, height);
+
+ RETURN_EGL_EVAL(disp, ret);
+}
+
+EGLBoolean EGLAPIENTRY
+eglGetSyncValuesCHROMIUM(EGLDisplay display, EGLSurface surface,
+ EGLuint64KHR *ust, EGLuint64KHR *msc,
+ EGLuint64KHR *sbc)
+{
+ _EGLDisplay *disp = _eglLockDisplay(display);
+ _EGLSurface *surf = _eglLookupSurface(surface, disp);
+ _EGLDriver *drv;
+ EGLBoolean ret;
+
+ _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+ if (!disp->Extensions.CHROMIUM_sync_control)
+ RETURN_EGL_EVAL(disp, EGL_FALSE);
+
+ if (!ust || !msc || !sbc)
+ RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
+
+ ret = drv->API.GetSyncValuesCHROMIUM(disp, surf, ust, msc, sbc);
RETURN_EGL_EVAL(disp, ret);
}
-#endif