2011-07-02 09:57:30 +01:00
|
|
|
/**************************************************************************
|
|
|
|
*
|
s/Tungsten Graphics/VMware/
Tungsten Graphics Inc. was acquired by VMware Inc. in 2008. Leaving the
old copyright name is creating unnecessary confusion, hence this change.
This was the sed script I used:
$ cat tg2vmw.sed
# Run as:
#
# git reset --hard HEAD && find include scons src -type f -not -name 'sed*' -print0 | xargs -0 sed -i -f tg2vmw.sed
#
# Rename copyrights
s/Tungsten Gra\(ph\|hp\)ics,\? [iI]nc\.\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./g
/Copyright/s/Tungsten Graphics\(,\? [iI]nc\.\)\?\(, Cedar Park\)\?\(, Austin\)\?\(, \(Texas\|TX\)\)\?\.\?/VMware, Inc./
s/TUNGSTEN GRAPHICS/VMWARE/g
# Rename emails
s/alanh@tungstengraphics.com/alanh@vmware.com/
s/jens@tungstengraphics.com/jowen@vmware.com/g
s/jrfonseca-at-tungstengraphics-dot-com/jfonseca-at-vmware-dot-com/
s/jrfonseca\?@tungstengraphics.com/jfonseca@vmware.com/g
s/keithw\?@tungstengraphics.com/keithw@vmware.com/g
s/michel@tungstengraphics.com/daenzer@vmware.com/g
s/thomas-at-tungstengraphics-dot-com/thellstom-at-vmware-dot-com/
s/zack@tungstengraphics.com/zackr@vmware.com/
# Remove dead links
s@Tungsten Graphics (http://www.tungstengraphics.com)@Tungsten Graphics@g
# C string src/gallium/state_trackers/vega/api_misc.c
s/"Tungsten Graphics, Inc"/"VMware, Inc"/
Reviewed-by: Brian Paul <brianp@vmware.com>
2014-01-17 16:27:50 +00:00
|
|
|
* Copyright 2008 VMware, Inc.
|
2011-07-02 09:57:30 +01:00
|
|
|
* Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
|
|
|
|
* Copyright 2010-2011 LunarG, Inc.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
|
|
* of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
* DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
/**
|
|
|
|
* Public EGL API entrypoints
|
|
|
|
*
|
|
|
|
* Generally, we use the EGLDisplay parameter as a key to lookup the
|
|
|
|
* appropriate device driver handle, then jump though the driver's
|
|
|
|
* dispatch table to handle the function.
|
|
|
|
*
|
|
|
|
* That allows us the option of supporting multiple, simultaneous,
|
|
|
|
* heterogeneous hardware devices in the future.
|
|
|
|
*
|
|
|
|
* The EGLDisplay, EGLConfig, EGLContext and EGLSurface types are
|
2009-09-30 08:08:34 +01:00
|
|
|
* opaque handles. Internal objects are linked to a display to
|
|
|
|
* create the handles.
|
2005-04-22 22:09:39 +01:00
|
|
|
*
|
2009-09-30 08:08:34 +01:00
|
|
|
* For each public API entry point, the opaque handles are looked up
|
|
|
|
* before being dispatched to the drivers. When it fails to look up
|
|
|
|
* a handle, one of
|
|
|
|
*
|
|
|
|
* EGL_BAD_DISPLAY
|
|
|
|
* EGL_BAD_CONFIG
|
|
|
|
* EGL_BAD_CONTEXT
|
|
|
|
* EGL_BAD_SURFACE
|
|
|
|
* EGL_BAD_SCREEN_MESA
|
|
|
|
* EGL_BAD_MODE_MESA
|
|
|
|
*
|
|
|
|
* is generated and the driver function is not called. An
|
|
|
|
* uninitialized EGLDisplay has no driver associated with it. When
|
|
|
|
* such display is detected,
|
|
|
|
*
|
|
|
|
* EGL_NOT_INITIALIZED
|
|
|
|
*
|
|
|
|
* is generated.
|
2005-04-22 22:09:39 +01:00
|
|
|
*
|
2009-10-15 04:08:33 +01:00
|
|
|
* Some of the entry points use current display, context, or surface
|
|
|
|
* implicitly. For such entry points, the implicit objects are also
|
|
|
|
* checked before calling the driver function. Other than the
|
|
|
|
* errors listed above,
|
|
|
|
*
|
|
|
|
* EGL_BAD_CURRENT_SURFACE
|
|
|
|
*
|
|
|
|
* may also be generated.
|
|
|
|
*
|
2005-04-22 22:09:39 +01:00
|
|
|
* Notes on naming conventions:
|
|
|
|
*
|
|
|
|
* eglFooBar - public EGL function
|
|
|
|
* EGL_FOO_BAR - public EGL token
|
|
|
|
* EGLDatatype - public EGL datatype
|
|
|
|
*
|
|
|
|
* _eglFooBar - private EGL function
|
|
|
|
* _EGLDatatype - private EGL datatype, typedef'd struct
|
|
|
|
* _egl_struct - private EGL struct, non-typedef'd
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
2006-01-30 00:10:55 +00:00
|
|
|
#include <stdlib.h>
|
2005-04-22 22:09:39 +01:00
|
|
|
#include <string.h>
|
2015-02-28 16:35:22 +00:00
|
|
|
#include "c99_compat.h"
|
2015-03-06 16:54:55 +00:00
|
|
|
#include "c11/threads.h"
|
|
|
|
#include "eglcompiler.h"
|
2010-05-31 04:47:58 +01:00
|
|
|
|
2013-10-12 00:04:55 +01:00
|
|
|
#include "eglglobals.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
#include "eglcontext.h"
|
|
|
|
#include "egldisplay.h"
|
|
|
|
#include "egltypedefs.h"
|
2010-01-29 01:00:30 +00:00
|
|
|
#include "eglcurrent.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
#include "egldriver.h"
|
|
|
|
#include "eglsurface.h"
|
2009-08-11 10:09:39 +01:00
|
|
|
#include "eglconfig.h"
|
|
|
|
#include "eglscreen.h"
|
|
|
|
#include "eglmode.h"
|
2009-08-15 15:58:13 +01:00
|
|
|
#include "eglimage.h"
|
2010-08-14 16:09:12 +01:00
|
|
|
#include "eglsync.h"
|
2015-03-10 18:41:57 +00:00
|
|
|
#include "eglstring.h"
|
2005-04-22 22:09:39 +01:00
|
|
|
|
|
|
|
|
2010-02-17 07:22:03 +00:00
|
|
|
/**
|
|
|
|
* Macros to help return an API entrypoint.
|
2010-02-17 09:30:44 +00:00
|
|
|
*
|
|
|
|
* These macros will unlock the display and record the error code.
|
2010-02-17 07:22:03 +00:00
|
|
|
*/
|
2010-02-19 04:08:50 +00:00
|
|
|
#define RETURN_EGL_ERROR(disp, err, ret) \
|
|
|
|
do { \
|
2010-02-17 09:30:44 +00:00
|
|
|
if (disp) \
|
|
|
|
_eglUnlockDisplay(disp); \
|
2010-02-17 07:22:03 +00:00
|
|
|
/* EGL error codes are non-zero */ \
|
|
|
|
if (err) \
|
2015-02-28 16:39:10 +00:00
|
|
|
_eglError(err, __func__); \
|
2010-02-19 04:08:50 +00:00
|
|
|
return ret; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define RETURN_EGL_SUCCESS(disp, ret) \
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_SUCCESS, ret)
|
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
/* record EGL_SUCCESS only when ret evaluates to true */
|
2010-02-19 04:08:50 +00:00
|
|
|
#define RETURN_EGL_EVAL(disp, ret) \
|
|
|
|
RETURN_EGL_ERROR(disp, (ret) ? EGL_SUCCESS : 0, ret)
|
2010-02-17 07:22:03 +00:00
|
|
|
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
/*
|
2010-02-17 07:22:03 +00:00
|
|
|
* A bunch of macros and checks to simplify error checking.
|
|
|
|
*/
|
2010-02-19 04:08:50 +00:00
|
|
|
|
|
|
|
#define _EGL_CHECK_DISPLAY(disp, ret, drv) \
|
|
|
|
do { \
|
2015-02-28 16:39:10 +00:00
|
|
|
drv = _eglCheckDisplay(disp, __func__); \
|
2010-02-19 04:08:50 +00:00
|
|
|
if (!drv) \
|
|
|
|
RETURN_EGL_ERROR(disp, 0, ret); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_OBJECT(disp, type, obj, ret, drv) \
|
|
|
|
do { \
|
2015-02-28 16:39:10 +00:00
|
|
|
drv = _eglCheck ## type(disp, obj, __func__); \
|
2010-02-19 04:08:50 +00:00
|
|
|
if (!drv) \
|
|
|
|
RETURN_EGL_ERROR(disp, 0, ret); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_SURFACE(disp, surf, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Surface, surf, ret, drv)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_CONTEXT(disp, context, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Context, context, ret, drv)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_CONFIG(disp, conf, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Config, conf, ret, drv)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_SCREEN(disp, scrn, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Screen, scrn, ret, drv)
|
|
|
|
|
|
|
|
#define _EGL_CHECK_MODE(disp, m, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Mode, m, ret, drv)
|
|
|
|
|
2010-08-14 16:09:12 +01:00
|
|
|
#define _EGL_CHECK_SYNC(disp, s, ret, drv) \
|
|
|
|
_EGL_CHECK_OBJECT(disp, Sync, s, ret, drv)
|
2010-02-17 07:22:03 +00:00
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckDisplay(_EGLDisplay *disp, const char *msg)
|
|
|
|
{
|
|
|
|
if (!disp) {
|
|
|
|
_eglError(EGL_BAD_DISPLAY, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (!disp->Initialized) {
|
|
|
|
_eglError(EGL_NOT_INITIALIZED, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return disp->Driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!surf) {
|
|
|
|
_eglError(EGL_BAD_SURFACE, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!context) {
|
|
|
|
_eglError(EGL_BAD_CONTEXT, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!conf) {
|
|
|
|
_eglError(EGL_BAD_CONFIG, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-08-14 16:09:12 +01:00
|
|
|
_eglCheckSync(_EGLDisplay *disp, _EGLSync *s, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!s) {
|
|
|
|
_eglError(EGL_BAD_PARAMETER, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-02-17 07:22:03 +00:00
|
|
|
#ifdef EGL_MESA_screen_surface
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckScreen(_EGLDisplay *disp, _EGLScreen *scrn, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!scrn) {
|
|
|
|
_eglError(EGL_BAD_SCREEN_MESA, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDriver *
|
2010-02-17 07:22:03 +00:00
|
|
|
_eglCheckMode(_EGLDisplay *disp, _EGLMode *m, const char *msg)
|
|
|
|
{
|
|
|
|
_EGLDriver *drv = _eglCheckDisplay(disp, msg);
|
|
|
|
if (!drv)
|
|
|
|
return NULL;
|
|
|
|
if (!m) {
|
|
|
|
_eglError(EGL_BAD_MODE_MESA, msg);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return drv;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* EGL_MESA_screen_surface */
|
|
|
|
|
|
|
|
|
2010-02-17 09:30:44 +00:00
|
|
|
/**
|
|
|
|
* Lookup and lock a display.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline _EGLDisplay *
|
2010-02-17 09:30:44 +00:00
|
|
|
_eglLockDisplay(EGLDisplay display)
|
|
|
|
{
|
|
|
|
_EGLDisplay *dpy = _eglLookupDisplay(display);
|
|
|
|
if (dpy)
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_lock(&dpy->Mutex);
|
2010-02-17 09:30:44 +00:00
|
|
|
return dpy;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unlock a display.
|
|
|
|
*/
|
2015-02-28 16:35:22 +00:00
|
|
|
static inline void
|
2010-02-17 09:30:44 +00:00
|
|
|
_eglUnlockDisplay(_EGLDisplay *dpy)
|
|
|
|
{
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_unlock(&dpy->Mutex);
|
2010-02-17 09:30:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
/**
|
2008-05-27 23:48:23 +01:00
|
|
|
* This is typically the first EGL function that an application calls.
|
2010-02-17 10:39:27 +00:00
|
|
|
* It associates a private _EGLDisplay object to the native display.
|
2005-04-22 22:09:39 +01:00
|
|
|
*/
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLDisplay EGLAPIENTRY
|
2010-01-25 03:55:48 +00:00
|
|
|
eglGetDisplay(EGLNativeDisplayType nativeDisplay)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
_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);
|
2008-05-27 21:33:54 +01:00
|
|
|
return _eglGetDisplayHandle(dpy);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
2014-01-23 15:26:10 +00:00
|
|
|
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);
|
|
|
|
}
|
2005-04-22 22:09:39 +01:00
|
|
|
|
2015-03-10 18:41:57 +00:00
|
|
|
/**
|
|
|
|
* 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));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 23:48:23 +01:00
|
|
|
/**
|
|
|
|
* This is typically the second EGL function that an application calls.
|
|
|
|
* Here we load/initialize the actual hardware driver.
|
|
|
|
*/
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2008-08-06 20:40:03 +01:00
|
|
|
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!disp)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-01-27 15:55:58 +00:00
|
|
|
if (!disp->Initialized) {
|
2010-07-04 08:55:12 +01:00
|
|
|
if (!_eglMatchDriver(disp, EGL_FALSE))
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_NOT_INITIALIZED, EGL_FALSE);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2009-08-17 08:53:54 +01:00
|
|
|
/* limit to APIs supported by core */
|
2011-01-13 08:53:13 +00:00
|
|
|
disp->ClientAPIs &= _EGL_API_ALL_BITS;
|
2014-11-20 18:26:38 +00:00
|
|
|
|
|
|
|
/* 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;
|
2015-03-10 18:41:57 +00:00
|
|
|
|
|
|
|
_eglCreateExtensionsString(disp);
|
|
|
|
_eglCreateAPIsString(disp);
|
|
|
|
_eglsnprintf(disp->VersionString, sizeof(disp->VersionString),
|
|
|
|
"%d.%d (%s)", disp->VersionMajor, disp->VersionMinor,
|
|
|
|
disp->Driver->Name);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
/* Update applications version of major and minor if not NULL */
|
|
|
|
if ((major != NULL) && (minor != NULL)) {
|
2011-01-13 08:53:13 +00:00
|
|
|
*major = disp->VersionMajor;
|
|
|
|
*minor = disp->VersionMinor;
|
2009-08-11 10:09:39 +01:00
|
|
|
}
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(disp, EGL_TRUE);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglTerminate(EGLDisplay dpy)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
if (!disp)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, EGL_BAD_DISPLAY, EGL_FALSE);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-01-27 15:55:58 +00:00
|
|
|
if (disp->Initialized) {
|
|
|
|
_EGLDriver *drv = disp->Driver;
|
|
|
|
|
2009-08-13 06:39:51 +01:00
|
|
|
drv->API.Terminate(drv, disp);
|
2010-01-27 15:55:58 +00:00
|
|
|
/* do not reset disp->Driver */
|
|
|
|
disp->Initialized = EGL_FALSE;
|
2009-08-11 10:09:39 +01:00
|
|
|
}
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(disp, EGL_TRUE);
|
2009-08-11 10:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
const char * EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglQueryString(EGLDisplay dpy, EGLint name)
|
|
|
|
{
|
2013-10-12 00:04:55 +01:00
|
|
|
_EGLDisplay *disp;
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLDriver *drv;
|
|
|
|
|
2013-10-12 00:04:55 +01:00
|
|
|
if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) {
|
|
|
|
RETURN_EGL_SUCCESS(NULL, _eglGlobal.ClientExtensionString);
|
|
|
|
}
|
|
|
|
|
|
|
|
disp = _eglLockDisplay(dpy);
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, NULL, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2015-03-14 00:00:26 +00:00
|
|
|
switch (name) {
|
|
|
|
case EGL_VENDOR:
|
|
|
|
RETURN_EGL_SUCCESS(disp, _EGL_VENDOR_STRING);
|
|
|
|
case EGL_VERSION:
|
|
|
|
RETURN_EGL_SUCCESS(disp, disp->VersionString);
|
|
|
|
case EGL_EXTENSIONS:
|
|
|
|
RETURN_EGL_SUCCESS(disp, disp->ExtensionsString);
|
|
|
|
case EGL_CLIENT_APIS:
|
|
|
|
RETURN_EGL_SUCCESS(disp, disp->ClientAPIsString);
|
|
|
|
default:
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
|
|
|
|
}
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
|
|
|
|
EGLint config_size, EGLint *num_config)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.GetConfigs(drv, disp, configs, config_size, num_config);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
|
|
|
|
EGLint config_size, EGLint *num_config)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.ChooseConfig(drv, disp, attrib_list, configs,
|
2009-08-11 10:09:39 +01:00
|
|
|
config_size, num_config);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
|
|
|
|
EGLint attribute, EGLint *value)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.GetConfigAttrib(drv, disp, conf, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLContext EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
|
|
|
|
const EGLint *attrib_list)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLContext *share = _eglLookupContext(share_list, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLContext *context;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLContext ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-09-23 19:42:15 +01:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT, drv);
|
|
|
|
|
2014-03-07 18:05:47 +00:00
|
|
|
if (!config && !disp->Extensions.MESA_configless_context)
|
2014-03-07 18:05:46 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
|
2010-06-03 03:48:06 +01:00
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
if (!share && share_list != EGL_NO_CONTEXT)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
context = drv->API.CreateContext(drv, disp, conf, share, attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (context) ? _eglLinkContext(context) : EGL_NO_CONTEXT;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLContext *context = _eglLookupContext(ctx, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
_eglUnlinkContext(context);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.DestroyContext(drv, disp, context);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
|
|
|
|
EGLContext ctx)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLContext *context = _eglLookupContext(ctx, disp);
|
|
|
|
_EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
|
|
|
|
_EGLSurface *read_surf = _eglLookupSurface(read, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-01-27 15:51:54 +00:00
|
|
|
if (!disp)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
|
2010-01-27 15:51:54 +00:00
|
|
|
drv = disp->Driver;
|
|
|
|
|
|
|
|
/* display is allowed to be uninitialized under certain condition */
|
|
|
|
if (!disp->Initialized) {
|
|
|
|
if (draw != EGL_NO_SURFACE || read != EGL_NO_SURFACE ||
|
|
|
|
ctx != EGL_NO_CONTEXT)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
|
2010-01-27 15:51:54 +00:00
|
|
|
}
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!drv)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(disp, EGL_TRUE);
|
2010-01-27 15:51:54 +00:00
|
|
|
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!context && ctx != EGL_NO_CONTEXT)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!draw_surf || !read_surf) {
|
2014-03-20 07:36:34 +00:00
|
|
|
/* 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)
|
2010-09-23 19:42:15 +01:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
|
|
|
|
|
|
|
if ((!draw_surf && draw != EGL_NO_SURFACE) ||
|
|
|
|
(!read_surf && read != EGL_NO_SURFACE))
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
|
|
|
if (draw_surf || read_surf)
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_FALSE);
|
|
|
|
}
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.MakeCurrent(drv, disp, draw_surf, read_surf, context);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglQueryContext(EGLDisplay dpy, EGLContext ctx,
|
|
|
|
EGLint attribute, EGLint *value)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLContext *context = _eglLookupContext(ctx, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QueryContext(drv, disp, context, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-23 15:26:10 +00:00
|
|
|
static EGLSurface
|
|
|
|
_eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
|
|
|
|
void *native_window, const EGLint *attrib_list)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
|
2014-06-03 22:00:13 +01:00
|
|
|
|
|
|
|
if (native_window == NULL)
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
|
|
|
|
|
2014-01-23 15:26:10 +00:00
|
|
|
surf = drv->API.CreateWindowSurface(drv, disp, conf, native_window,
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLSurface EGLAPIENTRY
|
2014-01-23 15:26:10 +00:00
|
|
|
eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
|
|
|
|
EGLNativeWindowType window, const EGLint *attrib_list)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2014-01-23 15:26:10 +00:00
|
|
|
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)
|
|
|
|
{
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
|
2014-01-23 15:26:10 +00:00
|
|
|
surf = drv->API.CreatePixmapSurface(drv, disp, conf, native_pixmap,
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-23 15:26:10 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLSurface EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
|
|
|
|
const EGLint *attrib_list)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
surf = drv->API.CreatePbufferSurface(drv, disp, conf, attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
_eglUnlinkSurface(surf);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.DestroySurface(drv, disp, surf);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
|
|
|
|
EGLint attribute, EGLint *value)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QuerySurface(drv, disp, surf, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
|
|
|
|
EGLint attribute, EGLint value)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.SurfaceAttrib(drv, disp, surf, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.BindTexImage(drv, disp, surf, buffer);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.ReleaseTexImage(drv, disp, surf, buffer);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglSwapInterval(EGLDisplay dpy, EGLint interval)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-10-15 04:08:48 +01:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2009-10-15 04:08:48 +01:00
|
|
|
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
|
|
|
|
ctx->Resource.Display != disp)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
|
2009-10-15 04:08:48 +01:00
|
|
|
|
|
|
|
surf = ctx->DrawSurface;
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetSurfaceHandle(surf) == EGL_NO_SURFACE)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
2009-10-15 04:08:48 +01:00
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.SwapInterval(drv, disp, surf, interval);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2009-10-15 04:08:33 +01:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2009-10-15 04:08:33 +01:00
|
|
|
|
|
|
|
/* surface must be bound to current context in EGL 1.4 */
|
2014-12-22 15:10:13 +00:00
|
|
|
#ifndef _EGL_BUILT_IN_DRIVER_HAIKU
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
|
|
|
|
surf != ctx->DrawSurface)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
2014-12-22 15:10:13 +00:00
|
|
|
#endif
|
2010-02-17 08:05:27 +00:00
|
|
|
|
|
|
|
ret = drv->API.SwapBuffers(drv, disp, surf);
|
2009-10-15 04:08:33 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-04-25 13:41:42 +01:00
|
|
|
#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 */
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2010-01-25 03:55:48 +00:00
|
|
|
eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
void *native_pixmap_ptr;
|
|
|
|
|
|
|
|
STATIC_ASSERT(sizeof(void*) == sizeof(target));
|
|
|
|
native_pixmap_ptr = (void*) target;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
2011-08-09 13:23:18 +01:00
|
|
|
if (disp->Platform != _eglGetNativePlatform(disp->PlatformDisplay))
|
2010-06-17 10:14:03 +01:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_FALSE);
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
ret = drv->API.CopyBuffers(drv, disp, surf, native_pixmap_ptr);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-09-28 07:12:39 +01:00
|
|
|
eglWaitClient(void)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2009-09-28 07:12:39 +01:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
|
|
|
_EGLDisplay *disp;
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2009-09-28 07:12:39 +01:00
|
|
|
if (!ctx)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-01-24 12:32:34 +00:00
|
|
|
disp = ctx->Resource.Display;
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_lock(&disp->Mutex);
|
2010-02-17 09:30:44 +00:00
|
|
|
|
|
|
|
/* let bad current context imply bad current surface */
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
|
|
|
|
_eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
|
|
|
/* a valid current context implies an initialized current display */
|
2010-01-27 15:55:58 +00:00
|
|
|
assert(disp->Initialized);
|
2009-08-11 10:09:39 +01:00
|
|
|
drv = disp->Driver;
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.WaitClient(drv, disp, ctx);
|
2009-09-28 07:12:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2009-09-28 07:12:39 +01:00
|
|
|
}
|
|
|
|
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2009-09-28 07:12:39 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglWaitGL(void)
|
|
|
|
{
|
|
|
|
_EGLThreadInfo *t = _eglGetCurrentThread();
|
|
|
|
EGLint api_index = t->CurrentAPIIndex;
|
|
|
|
EGLint es_index = _eglConvertApiToIndex(EGL_OPENGL_ES_API);
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
if (api_index != es_index && _eglIsCurrentThreadDummy())
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
|
2009-09-28 07:12:39 +01:00
|
|
|
|
|
|
|
t->CurrentAPIIndex = es_index;
|
|
|
|
ret = eglWaitClient();
|
|
|
|
t->CurrentAPIIndex = api_index;
|
|
|
|
return ret;
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglWaitNative(EGLint engine)
|
|
|
|
{
|
2009-09-28 07:12:39 +01:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
|
|
|
_EGLDisplay *disp;
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2009-09-28 07:12:39 +01:00
|
|
|
if (!ctx)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-17 09:30:44 +00:00
|
|
|
disp = ctx->Resource.Display;
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_lock(&disp->Mutex);
|
2010-02-17 09:30:44 +00:00
|
|
|
|
2009-09-28 07:12:39 +01:00
|
|
|
/* let bad current context imply bad current surface */
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
|
|
|
|
_eglGetSurfaceHandle(ctx->DrawSurface) == EGL_NO_SURFACE)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CURRENT_SURFACE, EGL_FALSE);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
|
|
|
/* a valid current context implies an initialized current display */
|
2010-01-27 15:55:58 +00:00
|
|
|
assert(disp->Initialized);
|
2009-08-11 10:09:39 +01:00
|
|
|
drv = disp->Driver;
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.WaitNative(drv, disp, engine);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLDisplay EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglGetCurrentDisplay(void)
|
|
|
|
{
|
2010-01-26 09:13:51 +00:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLDisplay ret;
|
|
|
|
|
|
|
|
ret = (ctx) ? _eglGetDisplayHandle(ctx->Resource.Display) : EGL_NO_DISPLAY;
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLContext EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglGetCurrentContext(void)
|
|
|
|
{
|
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLContext ret;
|
|
|
|
|
|
|
|
ret = _eglGetContextHandle(ctx);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLSurface EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglGetCurrentSurface(EGLint readdraw)
|
|
|
|
{
|
2009-09-30 08:34:45 +01:00
|
|
|
_EGLContext *ctx = _eglGetCurrentContext();
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLint err = EGL_SUCCESS;
|
2009-09-30 08:34:45 +01:00
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-09-30 08:34:45 +01:00
|
|
|
|
|
|
|
if (!ctx)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, EGL_NO_SURFACE);
|
2009-09-30 08:34:45 +01:00
|
|
|
|
|
|
|
switch (readdraw) {
|
|
|
|
case EGL_DRAW:
|
|
|
|
surf = ctx->DrawSurface;
|
|
|
|
break;
|
|
|
|
case EGL_READ:
|
|
|
|
surf = ctx->ReadSurface;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
surf = NULL;
|
2010-02-17 08:05:27 +00:00
|
|
|
err = EGL_BAD_PARAMETER;
|
2009-09-30 08:34:45 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = _eglGetSurfaceHandle(surf);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, err, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLint EGLAPIENTRY
|
2005-04-22 22:09:39 +01:00
|
|
|
eglGetError(void)
|
|
|
|
{
|
2005-12-10 17:54:00 +00:00
|
|
|
_EGLThreadInfo *t = _eglGetCurrentThread();
|
|
|
|
EGLint e = t->LastError;
|
2009-07-17 18:41:02 +01:00
|
|
|
if (!_eglIsCurrentThreadDummy())
|
|
|
|
t->LastError = EGL_SUCCESS;
|
2005-04-22 22:09:39 +01:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-15 15:57:47 +01:00
|
|
|
__eglMustCastToProperFunctionPointerType EGLAPIENTRY
|
|
|
|
eglGetProcAddress(const char *procname)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2009-08-15 15:44:46 +01:00
|
|
|
static const struct {
|
2005-04-22 22:09:39 +01:00
|
|
|
const char *name;
|
|
|
|
_EGLProc function;
|
2009-08-15 15:44:46 +01:00
|
|
|
} egl_functions[] = {
|
2010-08-20 05:35:02 +01:00
|
|
|
/* core functions should not be queryable, but, well... */
|
|
|
|
#ifdef _EGL_GET_CORE_ADDRESSES
|
|
|
|
/* alphabetical order */
|
|
|
|
{ "eglBindAPI", (_EGLProc) eglBindAPI },
|
|
|
|
{ "eglBindTexImage", (_EGLProc) eglBindTexImage },
|
|
|
|
{ "eglChooseConfig", (_EGLProc) eglChooseConfig },
|
|
|
|
{ "eglCopyBuffers", (_EGLProc) eglCopyBuffers },
|
|
|
|
{ "eglCreateContext", (_EGLProc) eglCreateContext },
|
|
|
|
{ "eglCreatePbufferFromClientBuffer", (_EGLProc) eglCreatePbufferFromClientBuffer },
|
|
|
|
{ "eglCreatePbufferSurface", (_EGLProc) eglCreatePbufferSurface },
|
|
|
|
{ "eglCreatePixmapSurface", (_EGLProc) eglCreatePixmapSurface },
|
|
|
|
{ "eglCreateWindowSurface", (_EGLProc) eglCreateWindowSurface },
|
|
|
|
{ "eglDestroyContext", (_EGLProc) eglDestroyContext },
|
|
|
|
{ "eglDestroySurface", (_EGLProc) eglDestroySurface },
|
|
|
|
{ "eglGetConfigAttrib", (_EGLProc) eglGetConfigAttrib },
|
|
|
|
{ "eglGetConfigs", (_EGLProc) eglGetConfigs },
|
|
|
|
{ "eglGetCurrentContext", (_EGLProc) eglGetCurrentContext },
|
|
|
|
{ "eglGetCurrentDisplay", (_EGLProc) eglGetCurrentDisplay },
|
|
|
|
{ "eglGetCurrentSurface", (_EGLProc) eglGetCurrentSurface },
|
|
|
|
{ "eglGetDisplay", (_EGLProc) eglGetDisplay },
|
|
|
|
{ "eglGetError", (_EGLProc) eglGetError },
|
|
|
|
{ "eglGetProcAddress", (_EGLProc) eglGetProcAddress },
|
|
|
|
{ "eglInitialize", (_EGLProc) eglInitialize },
|
|
|
|
{ "eglMakeCurrent", (_EGLProc) eglMakeCurrent },
|
|
|
|
{ "eglQueryAPI", (_EGLProc) eglQueryAPI },
|
|
|
|
{ "eglQueryContext", (_EGLProc) eglQueryContext },
|
|
|
|
{ "eglQueryString", (_EGLProc) eglQueryString },
|
|
|
|
{ "eglQuerySurface", (_EGLProc) eglQuerySurface },
|
|
|
|
{ "eglReleaseTexImage", (_EGLProc) eglReleaseTexImage },
|
|
|
|
{ "eglReleaseThread", (_EGLProc) eglReleaseThread },
|
|
|
|
{ "eglSurfaceAttrib", (_EGLProc) eglSurfaceAttrib },
|
|
|
|
{ "eglSwapBuffers", (_EGLProc) eglSwapBuffers },
|
|
|
|
{ "eglSwapInterval", (_EGLProc) eglSwapInterval },
|
|
|
|
{ "eglTerminate", (_EGLProc) eglTerminate },
|
|
|
|
{ "eglWaitClient", (_EGLProc) eglWaitClient },
|
|
|
|
{ "eglWaitGL", (_EGLProc) eglWaitGL },
|
|
|
|
{ "eglWaitNative", (_EGLProc) eglWaitNative },
|
|
|
|
#endif /* _EGL_GET_CORE_ADDRESSES */
|
2006-01-30 00:10:55 +00:00
|
|
|
#ifdef EGL_MESA_screen_surface
|
2005-05-13 19:31:35 +01:00
|
|
|
{ "eglChooseModeMESA", (_EGLProc) eglChooseModeMESA },
|
|
|
|
{ "eglGetModesMESA", (_EGLProc) eglGetModesMESA },
|
|
|
|
{ "eglGetModeAttribMESA", (_EGLProc) eglGetModeAttribMESA },
|
2005-05-14 15:54:38 +01:00
|
|
|
{ "eglCopyContextMESA", (_EGLProc) eglCopyContextMESA },
|
2005-05-13 19:31:35 +01:00
|
|
|
{ "eglGetScreensMESA", (_EGLProc) eglGetScreensMESA },
|
|
|
|
{ "eglCreateScreenSurfaceMESA", (_EGLProc) eglCreateScreenSurfaceMESA },
|
2005-12-10 17:54:00 +00:00
|
|
|
{ "eglShowScreenSurfaceMESA", (_EGLProc) eglShowScreenSurfaceMESA },
|
2005-05-13 19:31:35 +01:00
|
|
|
{ "eglScreenPositionMESA", (_EGLProc) eglScreenPositionMESA },
|
|
|
|
{ "eglQueryScreenMESA", (_EGLProc) eglQueryScreenMESA },
|
|
|
|
{ "eglQueryScreenSurfaceMESA", (_EGLProc) eglQueryScreenSurfaceMESA },
|
|
|
|
{ "eglQueryScreenModeMESA", (_EGLProc) eglQueryScreenModeMESA },
|
|
|
|
{ "eglQueryModeStringMESA", (_EGLProc) eglQueryModeStringMESA },
|
2006-01-30 00:10:55 +00:00
|
|
|
#endif /* EGL_MESA_screen_surface */
|
2010-06-17 10:09:01 +01:00
|
|
|
#ifdef EGL_MESA_drm_display
|
|
|
|
{ "eglGetDRMDisplayMESA", (_EGLProc) eglGetDRMDisplayMESA },
|
|
|
|
#endif
|
2009-08-15 15:58:13 +01:00
|
|
|
{ "eglCreateImageKHR", (_EGLProc) eglCreateImageKHR },
|
|
|
|
{ "eglDestroyImageKHR", (_EGLProc) eglDestroyImageKHR },
|
2011-12-20 08:42:11 +00:00
|
|
|
{ "eglCreateSyncKHR", (_EGLProc) eglCreateSyncKHR },
|
|
|
|
{ "eglDestroySyncKHR", (_EGLProc) eglDestroySyncKHR },
|
|
|
|
{ "eglClientWaitSyncKHR", (_EGLProc) eglClientWaitSyncKHR },
|
|
|
|
{ "eglSignalSyncKHR", (_EGLProc) eglSignalSyncKHR },
|
|
|
|
{ "eglGetSyncAttribKHR", (_EGLProc) eglGetSyncAttribKHR },
|
2010-05-07 03:01:35 +01:00
|
|
|
#ifdef EGL_NOK_swap_region
|
|
|
|
{ "eglSwapBuffersRegionNOK", (_EGLProc) eglSwapBuffersRegionNOK },
|
2010-06-04 19:28:59 +01:00
|
|
|
#endif
|
|
|
|
#ifdef EGL_MESA_drm_image
|
|
|
|
{ "eglCreateDRMImageMESA", (_EGLProc) eglCreateDRMImageMESA },
|
|
|
|
{ "eglExportDRMImageMESA", (_EGLProc) eglExportDRMImageMESA },
|
2011-02-21 15:22:34 +00:00
|
|
|
#endif
|
2011-04-25 20:34:04 +01:00
|
|
|
#ifdef EGL_WL_bind_wayland_display
|
2011-02-21 15:22:34 +00:00
|
|
|
{ "eglBindWaylandDisplayWL", (_EGLProc) eglBindWaylandDisplayWL },
|
|
|
|
{ "eglUnbindWaylandDisplayWL", (_EGLProc) eglUnbindWaylandDisplayWL },
|
2012-07-05 21:43:04 +01:00
|
|
|
{ "eglQueryWaylandBufferWL", (_EGLProc) eglQueryWaylandBufferWL },
|
2013-10-28 15:07:03 +00:00
|
|
|
#endif
|
|
|
|
#ifdef EGL_WL_create_wayland_buffer_from_image
|
|
|
|
{ "eglCreateWaylandBufferFromImageWL", (_EGLProc) eglCreateWaylandBufferFromImageWL },
|
2010-05-07 03:01:35 +01:00
|
|
|
#endif
|
2011-12-14 20:24:09 +00:00
|
|
|
{ "eglPostSubBufferNV", (_EGLProc) eglPostSubBufferNV },
|
2013-04-25 13:41:42 +01:00
|
|
|
#ifdef EGL_EXT_swap_buffers_with_damage
|
|
|
|
{ "eglSwapBuffersWithDamageEXT", (_EGLProc) eglSwapBuffersWithDamageEXT },
|
|
|
|
#endif
|
2014-01-23 15:26:10 +00:00
|
|
|
{ "eglGetPlatformDisplayEXT", (_EGLProc) eglGetPlatformDisplayEXT },
|
|
|
|
{ "eglCreatePlatformWindowSurfaceEXT", (_EGLProc) eglCreatePlatformWindowSurfaceEXT },
|
|
|
|
{ "eglCreatePlatformPixmapSurfaceEXT", (_EGLProc) eglCreatePlatformPixmapSurfaceEXT },
|
2014-05-06 20:10:57 +01:00
|
|
|
{ "eglGetSyncValuesCHROMIUM", (_EGLProc) eglGetSyncValuesCHROMIUM },
|
2005-04-22 22:09:39 +01:00
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
|
|
|
EGLint i;
|
2010-02-17 08:05:27 +00:00
|
|
|
_EGLProc ret;
|
2009-08-15 15:44:46 +01:00
|
|
|
|
|
|
|
if (!procname)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, NULL);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
|
|
|
ret = NULL;
|
2009-08-15 15:44:46 +01:00
|
|
|
if (strncmp(procname, "egl", 3) == 0) {
|
|
|
|
for (i = 0; egl_functions[i].name; i++) {
|
2010-02-17 08:05:27 +00:00
|
|
|
if (strcmp(egl_functions[i].name, procname) == 0) {
|
|
|
|
ret = egl_functions[i].function;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
}
|
2010-07-04 08:55:12 +01:00
|
|
|
if (!ret)
|
|
|
|
ret = _eglGetDriverProc(procname);
|
2008-05-30 21:50:33 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-15 15:44:46 +01:00
|
|
|
#ifdef EGL_MESA_screen_surface
|
|
|
|
|
|
|
|
|
2005-04-22 22:09:39 +01:00
|
|
|
/*
|
|
|
|
* EGL_MESA_screen extension
|
|
|
|
*/
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-05-04 04:33:21 +01:00
|
|
|
eglChooseModeMESA(EGLDisplay dpy, EGLScreenMESA screen,
|
2005-04-22 22:09:39 +01:00
|
|
|
const EGLint *attrib_list, EGLModeMESA *modes,
|
|
|
|
EGLint modes_size, EGLint *num_modes)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen(screen, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.ChooseModeMESA(drv, disp, scrn, attrib_list,
|
|
|
|
modes, modes_size, num_modes);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglGetModesMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *modes,
|
|
|
|
EGLint mode_size, EGLint *num_mode)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen(screen, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.GetModesMESA(drv, disp, scrn, modes, mode_size, num_mode);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglGetModeAttribMESA(EGLDisplay dpy, EGLModeMESA mode,
|
|
|
|
EGLint attribute, EGLint *value)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLMode *m = _eglLookupMode(mode, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_MODE(disp, m, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.GetModeAttribMESA(drv, disp, m, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-27 20:45:41 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglCopyContextMESA(EGLDisplay dpy, EGLContext source, EGLContext dest,
|
|
|
|
EGLint mask)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLContext *source_context = _eglLookupContext(source, disp);
|
|
|
|
_EGLContext *dest_context = _eglLookupContext(dest, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONTEXT(disp, source_context, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
if (!dest_context)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_FALSE);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.CopyContextMESA(drv, disp,
|
|
|
|
source_context, dest_context, mask);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-05-14 15:54:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglGetScreensMESA(EGLDisplay dpy, EGLScreenMESA *screens,
|
|
|
|
EGLint max_screens, EGLint *num_screens)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.GetScreensMESA(drv, disp, screens, max_screens, num_screens);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLSurface EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglCreateScreenSurfaceMESA(EGLDisplay dpy, EGLConfig config,
|
|
|
|
const EGLint *attrib_list)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
surf = drv->API.CreateScreenSurfaceMESA(drv, disp, conf, attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglShowScreenSurfaceMESA(EGLDisplay dpy, EGLint screen,
|
|
|
|
EGLSurface surface, EGLModeMESA mode)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
|
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLMode *m = _eglLookupMode(mode, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!surf && surface != EGL_NO_SURFACE)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!m && mode != EGL_NO_MODE_MESA)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_MODE_MESA, EGL_FALSE);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
|
|
|
ret = drv->API.ShowScreenSurfaceMESA(drv, disp, scrn, surf, m);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-05-13 19:31:35 +01:00
|
|
|
eglScreenPositionMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLint x, EGLint y)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen(screen, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.ScreenPositionMESA(drv, disp, scrn, x, y);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-05-13 19:31:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglQueryScreenMESA(EGLDisplay dpy, EGLScreenMESA screen,
|
|
|
|
EGLint attribute, EGLint *value)
|
2005-05-13 19:31:35 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen(screen, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QueryScreenMESA(drv, disp, scrn, attribute, value);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2009-08-11 10:09:39 +01:00
|
|
|
eglQueryScreenSurfaceMESA(EGLDisplay dpy, EGLScreenMESA screen,
|
|
|
|
EGLSurface *surface)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QueryScreenSurfaceMESA(drv, disp, scrn, &surf);
|
|
|
|
if (ret && surface)
|
2009-08-11 10:09:39 +01:00
|
|
|
*surface = _eglGetSurfaceHandle(surf);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2005-05-13 19:31:35 +01:00
|
|
|
eglQueryScreenModeMESA(EGLDisplay dpy, EGLScreenMESA screen, EGLModeMESA *mode)
|
2005-04-22 22:09:39 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLScreen *scrn = _eglLookupScreen((EGLScreenMESA) screen, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLMode *m;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_SCREEN(disp, scrn, EGL_FALSE, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QueryScreenModeMESA(drv, disp, scrn, &m);
|
|
|
|
if (ret && mode)
|
2009-08-11 10:09:39 +01:00
|
|
|
*mode = m->Handle;
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-04-22 22:09:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
const char * EGLAPIENTRY
|
2005-05-13 19:31:35 +01:00
|
|
|
eglQueryModeStringMESA(EGLDisplay dpy, EGLModeMESA mode)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2010-02-17 07:43:47 +00:00
|
|
|
_EGLMode *m = _eglLookupMode(mode, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
const char *ret;
|
2010-02-17 07:43:47 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_MODE(disp, m, NULL, drv);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.QueryModeStringMESA(drv, disp, m);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2005-05-13 19:31:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-08-15 15:44:46 +01:00
|
|
|
#endif /* EGL_MESA_screen_surface */
|
|
|
|
|
|
|
|
|
2010-06-17 10:09:01 +01:00
|
|
|
#ifdef EGL_MESA_drm_display
|
|
|
|
|
|
|
|
EGLDisplay EGLAPIENTRY
|
|
|
|
eglGetDRMDisplayMESA(int fd)
|
|
|
|
{
|
2011-05-12 15:12:16 +01:00
|
|
|
_EGLDisplay *dpy = _eglFindDisplay(_EGL_PLATFORM_DRM, (void *) (intptr_t) fd);
|
2010-06-17 10:09:01 +01:00
|
|
|
return _eglGetDisplayHandle(dpy);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* EGL_MESA_drm_display */
|
|
|
|
|
2006-01-30 00:10:55 +00:00
|
|
|
/**
|
|
|
|
** EGL 1.2
|
|
|
|
**/
|
|
|
|
|
2008-05-30 20:45:40 +01:00
|
|
|
/**
|
|
|
|
* Specify the client API to use for subsequent calls including:
|
|
|
|
* eglCreateContext()
|
|
|
|
* eglGetCurrentContext()
|
|
|
|
* eglGetCurrentDisplay()
|
|
|
|
* eglGetCurrentSurface()
|
|
|
|
* eglMakeCurrent(when the ctx parameter is EGL NO CONTEXT)
|
|
|
|
* eglWaitClient()
|
|
|
|
* eglWaitNative()
|
|
|
|
* See section 3.7 "Rendering Context" in the EGL specification for details.
|
|
|
|
*/
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2006-01-30 00:10:55 +00:00
|
|
|
eglBindAPI(EGLenum api)
|
|
|
|
{
|
|
|
|
_EGLThreadInfo *t = _eglGetCurrentThread();
|
|
|
|
|
2009-07-17 18:41:02 +01:00
|
|
|
if (_eglIsCurrentThreadDummy())
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, EGL_BAD_ALLOC, EGL_FALSE);
|
2009-07-17 18:41:02 +01:00
|
|
|
|
2009-07-17 18:42:04 +01:00
|
|
|
if (!_eglIsApiValid(api))
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(NULL, EGL_BAD_PARAMETER, EGL_FALSE);
|
2009-07-17 18:42:04 +01:00
|
|
|
|
2009-08-17 08:53:54 +01:00
|
|
|
t->CurrentAPIIndex = _eglConvertApiToIndex(api);
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
|
2006-01-30 00:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-05-30 20:45:40 +01:00
|
|
|
/**
|
|
|
|
* Return the last value set with eglBindAPI().
|
|
|
|
*/
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLenum EGLAPIENTRY
|
2008-05-30 20:45:40 +01:00
|
|
|
eglQueryAPI(void)
|
|
|
|
{
|
|
|
|
_EGLThreadInfo *t = _eglGetCurrentThread();
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLenum ret;
|
|
|
|
|
|
|
|
/* returns one of EGL_OPENGL_API, EGL_OPENGL_ES_API or EGL_OPENVG_API */
|
|
|
|
ret = _eglConvertApiFromIndex(t->CurrentAPIIndex);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, ret);
|
2008-05-30 20:45:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLSurface EGLAPIENTRY
|
2006-01-30 00:10:55 +00:00
|
|
|
eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
|
|
|
|
EGLClientBuffer buffer, EGLConfig config,
|
|
|
|
const EGLint *attrib_list)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-11 10:09:39 +01:00
|
|
|
_EGLConfig *conf = _eglLookupConfig(config, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSurface *surf;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLSurface ret;
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
|
2009-08-11 10:09:39 +01:00
|
|
|
|
|
|
|
surf = drv->API.CreatePbufferFromClientBuffer(drv, disp, buftype, buffer,
|
|
|
|
conf, attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2006-01-30 00:10:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2006-01-30 00:10:55 +00:00
|
|
|
eglReleaseThread(void)
|
|
|
|
{
|
2010-01-26 09:22:21 +00:00
|
|
|
/* unbind current contexts */
|
2009-08-11 10:09:39 +01:00
|
|
|
if (!_eglIsCurrentThreadDummy()) {
|
2010-01-26 09:22:21 +00:00
|
|
|
_EGLThreadInfo *t = _eglGetCurrentThread();
|
2010-01-28 08:49:40 +00:00
|
|
|
EGLint api_index = t->CurrentAPIIndex;
|
2010-01-26 09:22:21 +00:00
|
|
|
EGLint i;
|
|
|
|
|
|
|
|
for (i = 0; i < _EGL_API_NUM_APIS; i++) {
|
|
|
|
_EGLContext *ctx = t->CurrentContexts[i];
|
|
|
|
if (ctx) {
|
|
|
|
_EGLDisplay *disp = ctx->Resource.Display;
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDriver *drv;
|
|
|
|
|
2010-01-28 08:49:40 +00:00
|
|
|
t->CurrentAPIIndex = i;
|
2010-02-17 09:30:44 +00:00
|
|
|
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_lock(&disp->Mutex);
|
2010-02-17 09:30:44 +00:00
|
|
|
drv = disp->Driver;
|
2010-01-27 15:51:54 +00:00
|
|
|
(void) drv->API.MakeCurrent(drv, disp, NULL, NULL, NULL);
|
2015-03-06 16:54:55 +00:00
|
|
|
mtx_unlock(&disp->Mutex);
|
2010-01-26 09:22:21 +00:00
|
|
|
}
|
2009-08-11 10:09:39 +01:00
|
|
|
}
|
2010-01-28 08:49:40 +00:00
|
|
|
|
|
|
|
t->CurrentAPIIndex = api_index;
|
2006-01-30 00:10:55 +00:00
|
|
|
}
|
2009-08-11 10:09:39 +01:00
|
|
|
|
2009-07-17 18:41:02 +01:00
|
|
|
_eglDestroyCurrentThread();
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_SUCCESS(NULL, EGL_TRUE);
|
2006-01-30 00:10:55 +00:00
|
|
|
}
|
2005-05-13 19:31:35 +01:00
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLImageKHR EGLAPIENTRY
|
2009-08-15 15:58:13 +01:00
|
|
|
eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
|
|
|
|
EGLClientBuffer buffer, const EGLint *attr_list)
|
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-15 15:58:13 +01:00
|
|
|
_EGLContext *context = _eglLookupContext(ctx, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLImage *img;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLImageKHR ret;
|
2009-08-15 15:58:13 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!disp->Extensions.KHR_image_base)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
|
2010-02-17 08:05:27 +00:00
|
|
|
if (!context && ctx != EGL_NO_CONTEXT)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
|
2013-03-22 12:31:01 +00:00
|
|
|
/* "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);
|
2009-08-15 15:58:13 +01:00
|
|
|
|
|
|
|
img = drv->API.CreateImageKHR(drv,
|
|
|
|
disp, context, target, buffer, attr_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
|
2010-02-17 08:05:27 +00:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2009-08-15 15:58:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2010-02-17 08:05:27 +00:00
|
|
|
eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
|
2009-08-15 15:58:13 +01:00
|
|
|
{
|
2010-02-17 09:30:44 +00:00
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
2009-08-15 15:58:13 +01:00
|
|
|
_EGLImage *img = _eglLookupImage(image, disp);
|
|
|
|
_EGLDriver *drv;
|
2010-02-17 08:05:27 +00:00
|
|
|
EGLBoolean ret;
|
2009-08-15 15:58:13 +01:00
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!disp->Extensions.KHR_image_base)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_FALSE);
|
2009-08-15 15:58:13 +01:00
|
|
|
if (!img)
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
|
2009-08-15 15:58:13 +01:00
|
|
|
|
|
|
|
_eglUnlinkImage(img);
|
2010-02-17 08:05:27 +00:00
|
|
|
ret = drv->API.DestroyImageKHR(drv, disp, img);
|
|
|
|
|
2010-02-19 04:08:50 +00:00
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
2009-08-15 15:58:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-08-14 16:09:12 +01:00
|
|
|
EGLSyncKHR EGLAPIENTRY
|
|
|
|
eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLSync *sync;
|
|
|
|
EGLSyncKHR ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_NO_SYNC_KHR, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!disp->Extensions.KHR_reusable_sync)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_NO_SYNC_KHR);
|
2010-08-14 16:09:12 +01:00
|
|
|
|
|
|
|
sync = drv->API.CreateSyncKHR(drv, disp, type, attrib_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (sync) ? _eglLinkSync(sync) : EGL_NO_SYNC_KHR;
|
2010-08-14 16:09:12 +01:00
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLSync *s = _eglLookupSync(sync, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
assert(disp->Extensions.KHR_reusable_sync);
|
|
|
|
|
2010-08-14 16:09:12 +01:00
|
|
|
_eglUnlinkSync(s);
|
|
|
|
ret = drv->API.DestroySyncKHR(drv, disp, s);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EGLint EGLAPIENTRY
|
|
|
|
eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLSync *s = _eglLookupSync(sync, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLint ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
assert(disp->Extensions.KHR_reusable_sync);
|
2010-08-14 16:09:12 +01:00
|
|
|
ret = drv->API.ClientWaitSyncKHR(drv, disp, s, flags, timeout);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLSync *s = _eglLookupSync(sync, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
assert(disp->Extensions.KHR_reusable_sync);
|
2010-08-14 16:09:12 +01:00
|
|
|
ret = drv->API.SignalSyncKHR(drv, disp, s, mode);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLSync *s = _eglLookupSync(sync, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
assert(disp->Extensions.KHR_reusable_sync);
|
2010-08-14 16:09:12 +01:00
|
|
|
ret = drv->API.GetSyncAttribKHR(drv, disp, s, attribute, value);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-07 03:01:35 +01:00
|
|
|
#ifdef EGL_NOK_swap_region
|
|
|
|
|
2010-07-03 00:38:07 +01:00
|
|
|
EGLBoolean EGLAPIENTRY
|
2010-05-07 03:01:35 +01:00
|
|
|
eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface,
|
|
|
|
EGLint numRects, const EGLint *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);
|
|
|
|
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!disp->Extensions.NOK_swap_region)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_FALSE);
|
|
|
|
|
2010-05-07 03:01:35 +01:00
|
|
|
/* surface must be bound to current context in EGL 1.4 */
|
2010-10-23 05:52:26 +01:00
|
|
|
if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
|
|
|
|
surf != ctx->DrawSurface)
|
2010-05-07 03:01:35 +01:00
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
|
|
|
|
|
2010-09-23 19:42:15 +01:00
|
|
|
ret = drv->API.SwapBuffersRegionNOK(drv, disp, surf, numRects, rects);
|
2010-05-07 03:01:35 +01:00
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* EGL_NOK_swap_region */
|
2010-06-04 19:28:59 +01:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef EGL_MESA_drm_image
|
|
|
|
|
|
|
|
EGLImageKHR EGLAPIENTRY
|
|
|
|
eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *attr_list)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
_EGLImage *img;
|
|
|
|
EGLImageKHR ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
if (!disp->Extensions.MESA_drm_image)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
|
2010-06-04 19:28:59 +01:00
|
|
|
|
|
|
|
img = drv->API.CreateDRMImageMESA(drv, disp, attr_list);
|
2010-10-22 17:37:19 +01:00
|
|
|
ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
|
2010-06-04 19:28:59 +01:00
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglExportDRMImageMESA(EGLDisplay dpy, EGLImageKHR image,
|
|
|
|
EGLint *name, EGLint *handle, EGLint *stride)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLImage *img = _eglLookupImage(image, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
2010-09-23 19:42:15 +01:00
|
|
|
assert(disp->Extensions.MESA_drm_image);
|
|
|
|
|
2010-06-04 19:28:59 +01:00
|
|
|
if (!img)
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
|
|
|
|
|
|
|
|
ret = drv->API.ExportDRMImageMESA(drv, disp, img, name, handle, stride);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2011-02-21 15:22:34 +00:00
|
|
|
|
|
|
|
#ifdef EGL_WL_bind_wayland_display
|
|
|
|
struct wl_display;
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglBindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
|
|
|
assert(disp->Extensions.WL_bind_wayland_display);
|
|
|
|
|
|
|
|
if (!display)
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
|
|
|
|
|
|
|
|
ret = drv->API.BindWaylandDisplayWL(drv, disp, display);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglUnbindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
|
|
|
|
assert(disp->Extensions.WL_bind_wayland_display);
|
|
|
|
|
|
|
|
if (!display)
|
|
|
|
RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
|
|
|
|
|
|
|
|
ret = drv->API.UnbindWaylandDisplayWL(drv, disp, display);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
2012-07-05 21:43:04 +01:00
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
2013-07-18 13:11:25 +01:00
|
|
|
eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *buffer,
|
2012-07-05 21:43:04 +01:00
|
|
|
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);
|
|
|
|
}
|
2011-02-21 15:22:34 +00:00
|
|
|
#endif
|
2011-12-14 20:24:09 +00:00
|
|
|
|
2013-10-28 15:07:03 +00:00
|
|
|
#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
|
2011-12-14 20:24:09 +00:00
|
|
|
|
|
|
|
EGLBoolean EGLAPIENTRY
|
|
|
|
eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface,
|
|
|
|
EGLint x, EGLint y, EGLint width, EGLint height)
|
|
|
|
{
|
|
|
|
_EGLDisplay *disp = _eglLockDisplay(dpy);
|
|
|
|
_EGLSurface *surf = _eglLookupSurface(surface, disp);
|
|
|
|
_EGLDriver *drv;
|
|
|
|
EGLBoolean ret;
|
|
|
|
|
|
|
|
_EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
|
|
|
|
|
|
|
|
if (!disp->Extensions.NV_post_sub_buffer)
|
|
|
|
RETURN_EGL_EVAL(disp, EGL_FALSE);
|
|
|
|
|
|
|
|
ret = drv->API.PostSubBufferNV(drv, disp, surf, x, y, width, height);
|
|
|
|
|
|
|
|
RETURN_EGL_EVAL(disp, ret);
|
|
|
|
}
|
2014-05-06 20:10:57 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|