EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreatePixmapSurface, "eglCreatePixmapSurface");
return (*_eglCreatePixmapSurface)(dpy, config, pixmap, attrib_list);
}
EGLSurface eglCreatePbufferFromClientBuffer(
EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
EGLConfig config, const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreatePbufferFromClientBuffer, "eglCreatePbufferFromClientBuffer");
return (*_eglCreatePbufferFromClientBuffer)(dpy, buftype, buffer, config, attrib_list);
}
EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
EGLint attribute, EGLint *value)
{
EGL_DLSYM(&_eglGetConfigAttrib, "eglGetConfigAttrib");
return (*_eglGetConfigAttrib)(dpy, config,
attribute, value);
}
EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
EGLNativeWindowType win,
const EGLint * attrib_list)
{
EGL_DEBUG("%s: %s\n", __FILE__, __func__);
EGL_DLSYM(eglCreateWindowSurface);
return _eglCreateWindowSurface(dpy, config, win, attrib_list);
}
EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint * attrib_list)
{
EGL_DEBUG("%s: %s\n", __FILE__, __func__);
EGL_DLSYM(eglCreatePixmapSurface);
return _eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
}
EGLBoolean eglTerminate(EGLDisplay dpy)
{
EGL_DLSYM(&_eglTerminate, "eglTerminate");
struct _EGLDisplay *display = hybris_egl_display_get_mapping(dpy);
ws_Terminate(display);
return (*_eglTerminate)(dpy);
}
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
EGLContext share_context,
const EGLint * attrib_list)
{
EGL_DEBUG("%s: %s\n", __FILE__, __func__);
EGL_DLSYM(eglCreateContext);
return _eglCreateContext(dpy, config, share_context, attrib_list);
}
EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
EGLConfig *configs, EGLint config_size,
EGLint *num_config)
{
EGL_DLSYM(&_eglChooseConfig, "eglChooseConfig");
return (*_eglChooseConfig)(dpy, attrib_list,
configs, config_size,
num_config);
}
EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
{
EGLBoolean ret;
HYBRIS_TRACE_BEGIN("hybris-egl", "eglSwapBuffers", "");
EGL_DLSYM(&_eglSwapBuffers, "eglSwapBuffers");
ret = (*_eglSwapBuffers)(dpy, surface);
HYBRIS_TRACE_END("hybris-egl", "eglSwapBuffers", "");
return ret;
}
EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint * attrib_list,
EGLConfig * configs, EGLint config_size,
EGLint * num_config)
{
EGL_DEBUG("%s: %s\n", __FILE__, __func__);
EGL_DLSYM(eglChooseConfig);
return _eglChooseConfig(dpy, attrib_list,
configs, config_size, num_config);
}
EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
EGLClientBuffer buffer,
EGLConfig config,
const EGLint * attrib_list)
{
EGL_DEBUG("%s: %s\n", __FILE__, __func__);
EGL_DLSYM(eglCreatePbufferFromClientBuffer);
return _eglCreatePbufferFromClientBuffer(dpy, buftype, buffer,
config, attrib_list);
}
EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
EGLNativeWindowType win,
const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreateWindowSurface, "eglCreateWindowSurface");
win = ws_CreateWindow(win, _egldisplay2NDT(dpy));
assert(((struct ANativeWindowBuffer *) win)->common.magic == ANDROID_NATIVE_WINDOW_MAGIC);
EGLSurface result = (*_eglCreateWindowSurface)(dpy, config, win, attrib_list);
egl_helper_push_mapping(result, win);
return result;
}
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval)
{
EGLBoolean ret;
EGLSurface surface;
EGLNativeWindowType win;
HYBRIS_TRACE_BEGIN("hybris-egl", "eglSwapInterval", "=%d", interval);
/* Some egl implementations don't pass through the setSwapInterval
* call. Since we may support various swap intervals internally, we'll
* call it anyway and then give the wrapped egl implementation a chance
* to chage it. */
EGL_DLSYM(&_eglGetCurrentSurface, "eglGetCurrentSurface");
surface = (*_eglGetCurrentSurface)(EGL_DRAW);
if (egl_helper_has_mapping(surface))
ws_setSwapInterval(dpy, egl_helper_get_mapping(surface), interval);
HYBRIS_TRACE_BEGIN("native-egl", "eglSwapInterval", "=%d", interval);
EGL_DLSYM(&_eglSwapInterval, "eglSwapInterval");
ret = (*_eglSwapInterval)(dpy, interval);
HYBRIS_TRACE_END("native-egl", "eglSwapInterval", "");
HYBRIS_TRACE_END("hybris-egl", "eglSwapInterval", "");
return ret;
}
EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
{
EGL_DLSYM(&_eglDestroySurface, "eglDestroySurface");
EGLBoolean result = (*_eglDestroySurface)(dpy, surface);
/**
* If the surface was created via eglCreateWindowSurface, we must
* notify the ws about surface destruction for clean-up.
**/
if (egl_helper_has_mapping(surface)) {
ws_DestroyWindow(egl_helper_pop_mapping(surface));
}
return result;
}
static EGLImageKHR _my_eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreateImageKHR, "eglCreateImageKHR");
EGLenum newtarget = target;
EGLClientBuffer newbuffer = buffer;
ws_passthroughImageKHR(&newtarget, &newbuffer);
if (newtarget == EGL_NATIVE_BUFFER_ANDROID)
{
assert(((struct ANativeWindowBuffer *) newbuffer)->common.magic == ANDROID_NATIVE_BUFFER_MAGIC);
attrib_list=NULL;
}
EGLImageKHR ret = (*_eglCreateImageKHR)(dpy, EGL_NO_CONTEXT, newtarget, newbuffer, attrib_list);
return ret;
}
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
EGLContext share_context,
const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreateContext, "eglCreateContext");
EGLint *p = attrib_list;
while (p != NULL && *p != EGL_NONE) {
if (*p == EGL_CONTEXT_CLIENT_VERSION) {
_egl_context_client_version = p[1];
}
p += 2;
}
return (*_eglCreateContext)(dpy, config, share_context, attrib_list);
}
__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
{
EGL_DLSYM(&_eglGetProcAddress, "eglGetProcAddress");
if (strcmp(procname, "eglCreateImageKHR") == 0)
{
return _my_eglCreateImageKHR;
}
else if (strcmp(procname, "glEGLImageTargetTexture2DOES") == 0)
{
return _my_glEGLImageTargetTexture2DOES;
}
__eglMustCastToProperFunctionPointerType ret = ws_eglGetProcAddress(procname);
if (ret == NULL)
return (*_eglGetProcAddress)(procname);
else return ret;
}
EGLBoolean _my_eglSwapBuffersWithDamageEXT(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects)
{
EGLNativeWindowType win;
EGLBoolean ret;
HYBRIS_TRACE_BEGIN("hybris-egl", "eglSwapBuffersWithDamageEXT", "");
EGL_DLSYM(&_eglSwapBuffers, "eglSwapBuffers");
if (egl_helper_has_mapping(surface)) {
win = egl_helper_get_mapping(surface);
ws_prepareSwap(dpy, win, rects, n_rects);
ret = (*_eglSwapBuffers)(dpy, surface);
ws_finishSwap(dpy, win);
} else {
ret = (*_eglSwapBuffers)(dpy, surface);
}
HYBRIS_TRACE_END("hybris-egl", "eglSwapBuffersWithDamageEXT", "");
return ret;
}
EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)
{
EGL_DLSYM(&_eglGetDisplay, "eglGetDisplay");
EGLNativeDisplayType real_display;
if (!ws_IsValidDisplay(display_id))
{
return EGL_NO_DISPLAY;
}
real_display = (*_eglGetDisplay)(EGL_DEFAULT_DISPLAY);
if (real_display == EGL_NO_DISPLAY)
{
return EGL_NO_DISPLAY;
}
_addMapping(display_id, real_display);
return real_display;
}
__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname)
{
EGL_DLSYM(eglGetProcAddress);
EGL_DEBUG("%s: %s(%s)\n", __FILE__, __func__, procname);
if (strcmp(procname, "eglCreateImageKHR") == 0) {
return (__eglMustCastToProperFunctionPointerType)__eglCreateImageKHR;
}
#ifdef WANT_WAYLAND
else if (strcmp(procname, "eglBindWaylandDisplayWL") == 0) {
return (__eglMustCastToProperFunctionPointerType)__eglBindWaylandDisplayWL;
} else if (strcmp(procname, "eglUnbindWaylandDisplayWL") == 0) {
return (__eglMustCastToProperFunctionPointerType)__eglUnbindWaylandDisplayWL;
} else if (strcmp(procname, "eglQueryWaylandBufferWL") == 0) {
return (__eglMustCastToProperFunctionPointerType)__eglQueryWaylandBufferWL;
}
#endif
return _eglGetProcAddress(procname);
}
EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
EGLNativeWindowType win,
const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreateWindowSurface, "eglCreateWindowSurface");
HYBRIS_TRACE_BEGIN("hybris-egl", "eglCreateWindowSurface", "");
struct _EGLDisplay *display = hybris_egl_display_get_mapping(dpy);
win = ws_CreateWindow(win, display);
assert(((struct ANativeWindowBuffer *) win)->common.magic == ANDROID_NATIVE_WINDOW_MAGIC);
HYBRIS_TRACE_BEGIN("native-egl", "eglCreateWindowSurface", "");
EGLSurface result = (*_eglCreateWindowSurface)(dpy, config, win, attrib_list);
HYBRIS_TRACE_END("native-egl", "eglCreateWindowSurface", "");
egl_helper_push_mapping(result, win);
HYBRIS_TRACE_END("hybris-egl", "eglCreateWindowSurface", "");
return result;
}
EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)
{
EGL_DLSYM(&_eglGetDisplay, "eglGetDisplay");
EGLNativeDisplayType real_display;
real_display = (*_eglGetDisplay)(EGL_DEFAULT_DISPLAY);
if (real_display == EGL_NO_DISPLAY)
{
return EGL_NO_DISPLAY;
}
struct _EGLDisplay *dpy = hybris_egl_display_get_mapping(real_display);
if (!dpy) {
dpy = ws_GetDisplay(display_id);
if (!dpy) {
return EGL_NO_DISPLAY;
}
dpy->dpy = real_display;
_addMapping(dpy);
}
return real_display;
}
static EGLImageKHR _my_eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{
EGL_DLSYM(&_eglCreateImageKHR, "eglCreateImageKHR");
EGLContext newctx = ctx;
EGLenum newtarget = target;
EGLClientBuffer newbuffer = buffer;
const EGLint *newattrib_list = attrib_list;
ws_passthroughImageKHR(&newctx, &newtarget, &newbuffer, &newattrib_list);
EGLImageKHR eik = (*_eglCreateImageKHR)(dpy, newctx, newtarget, newbuffer, newattrib_list);
if (eik == EGL_NO_IMAGE_KHR) {
return EGL_NO_IMAGE_KHR;
}
struct egl_image *image;
image = malloc(sizeof *image);
image->egl_image = eik;
image->egl_buffer = buffer;
image->target = target;
return (EGLImageKHR)image;
}
EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
EGLNativePixmapType target)
{
EGL_DLSYM(&_eglCopyBuffers, "eglCopyBuffers");
return (*_eglCopyBuffers)(dpy, surface, target);
}
EGLBoolean eglWaitNative(EGLint engine)
{
EGL_DLSYM(&_eglWaitNative, "eglWaitNative");
return (*_eglWaitNative)(engine);
}
EGLBoolean eglWaitGL(void)
{
EGL_DLSYM(&_eglWaitGL, "eglWaitGL");
return (*_eglWaitGL)();
}
EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx,
EGLint attribute, EGLint *value)
{
EGL_DLSYM(&_eglQueryContext, "eglQueryContext");
return (*_eglQueryContext)(dpy, ctx, attribute, value);
}
EGLDisplay eglGetCurrentDisplay(void)
{
EGL_DLSYM(&_eglGetCurrentDisplay, "eglGetCurrentDisplay");
return (*_eglGetCurrentDisplay)();
}
EGLSurface eglGetCurrentSurface(EGLint readdraw)
{
EGL_DLSYM(&_eglGetCurrentSurface, "eglGetCurrentSurface");
return (*_eglGetCurrentSurface)(readdraw);
}
EGLContext eglGetCurrentContext(void)
{
EGL_DLSYM(&_eglGetCurrentContext, "eglGetCurrentContext");
return (*_eglGetCurrentContext)();
}