Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 40627ba8 authored by Courtney Goeltzenleuchter's avatar Courtney Goeltzenleuchter
Browse files

Add EGL 1.5 Sync functions 

Test: cts-tradefed run commandAndExit cts -m CtsDeqpTestCases --module-arg 'CtsDeqpTestCases:include-filter:dEQP-EGL.*'
Bug: 80297325
Change-Id: I5d385ec0ef634793983bc77071a08ffb6a2395fd
(cherry picked from commit ed1acaaf3d8ec7f2a11cd6fd0f474a8f4de272c3)
parent 69476e57

opengl/libs/EGL/eglApi.cpp

+41 −0
Original line number Diff line number Diff line
@@ -409,6 +409,13 @@ EGLBoolean eglDestroyImage(EGLDisplay dpy, EGLImageKHR img) { 
// EGL_EGLEXT_VERSION 5

// ----------------------------------------------------------------------------



EGLSyncKHR eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {

    clearError();



    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglCreateSync(dpy, type, attrib_list);

}



EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {

    clearError();
@@ -416,6 +423,13 @@ EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_l 
    return cnx->platform.eglCreateSyncKHR(dpy, type, attrib_list);

}



EGLBoolean eglDestroySync(EGLDisplay dpy, EGLSyncKHR sync) {

    clearError();



    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglDestroySync(dpy, sync);

}



EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {

    clearError();
@@ -423,6 +437,13 @@ EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) { 
    return cnx->platform.eglDestroySyncKHR(dpy, sync);

}



EGLBoolean eglSignalSync(EGLDisplay dpy, EGLSync sync, EGLenum mode) {

    clearError();



    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglSignalSync(dpy, sync, mode);

}



EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {

    clearError();
@@ -430,6 +451,13 @@ EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) { 
    return cnx->platform.eglSignalSyncKHR(dpy, sync, mode);

}



EGLint eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTimeKHR timeout) {

    clearError();



    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglClientWaitSyncKHR(dpy, sync, flags, timeout);

}



EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {

    clearError();
@@ -437,6 +465,13 @@ EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTi 
    return cnx->platform.eglClientWaitSyncKHR(dpy, sync, flags, timeout);

}



EGLBoolean eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {

    clearError();



    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglGetSyncAttrib(dpy, sync, attribute, value);

}



EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value) {

    clearError();
@@ -540,6 +575,12 @@ EGLint eglWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) { 
    return cnx->platform.eglWaitSyncKHR(dpy, sync, flags);

}



EGLBoolean eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {

    clearError();

    egl_connection_t* const cnx = &gEGLImpl;

    return cnx->platform.eglWaitSync(dpy, sync, flags);

}



EGLint eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) {

    clearError();

opengl/libs/EGL/egl_entries.in

+6 −0
Original line number Diff line number Diff line
@@ -50,6 +50,12 @@ EGL_ENTRY(EGLBoolean, eglDestroyImage, EGLDisplay, EGLImage) 
EGL_ENTRY(EGLDisplay, eglGetPlatformDisplay, EGLenum, void *, const EGLAttrib *)

EGL_ENTRY(EGLSurface, eglCreatePlatformWindowSurface, EGLDisplay, EGLConfig, void *, const EGLAttrib *)

EGL_ENTRY(EGLSurface, eglCreatePlatformPixmapSurface, EGLDisplay, EGLConfig, void *, const EGLAttrib *)

EGL_ENTRY(EGLSyncKHR, eglCreateSync, EGLDisplay, EGLenum, const EGLAttrib *)

EGL_ENTRY(EGLBoolean, eglDestroySync, EGLDisplay, EGLSync)

EGL_ENTRY(EGLint, eglClientWaitSync, EGLDisplay, EGLSync, EGLint, EGLTimeKHR)

EGL_ENTRY(EGLBoolean, eglSignalSync, EGLDisplay, EGLSync, EGLenum)

EGL_ENTRY(EGLBoolean, eglGetSyncAttrib, EGLDisplay, EGLSync, EGLint, EGLAttrib *)

EGL_ENTRY(EGLBoolean, eglWaitSync, EGLDisplay, EGLSync, EGLint)



/* EGL_EGLEXT_VERSION 3 */

opengl/libs/EGL/egl_platform_entries.cpp

+172 −30
Original line number Diff line number Diff line
@@ -1813,76 +1813,186 @@ EGLBoolean eglDestroyImageImpl(EGLDisplay dpy, EGLImageKHR img) { 
// EGL_EGLEXT_VERSION 5

// ----------------------------------------------------------------------------





EGLSyncKHR eglCreateSyncKHRImpl(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list)

{

// NOTE: EGLSyncKHR and EGLSync are identical, no need to templatize

template <typename AttrType, typename FuncType>

EGLSyncKHR eglCreateSyncTmpl(EGLDisplay dpy, EGLenum type, const AttrType* attrib_list,

                             FuncType eglCreateSyncFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_NO_SYNC_KHR;



    EGLSyncKHR result = EGL_NO_SYNC_KHR;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglCreateSyncKHR) {

        result = cnx->egl.eglCreateSyncKHR(dp->disp.dpy, type, attrib_list);

    EGLSyncKHR result = EGL_NO_SYNC_KHR;

    if (cnx->dso && eglCreateSyncFunc) {

        result = eglCreateSyncFunc(dp->disp.dpy, type, attrib_list);

    }

    return result;

}



EGLBoolean eglDestroySyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync)

{

typedef EGLSurface(EGLAPIENTRYP PFNEGLCREATESYNC)(EGLDisplay dpy, EGLenum type,

                                                  const EGLAttrib* attrib_list);



EGLSyncKHR eglCreateSyncKHRImpl(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {

    return eglCreateSyncTmpl<EGLint, PFNEGLCREATESYNCKHRPROC>(dpy, type, attrib_list,

                                                              gEGLImpl.egl.eglCreateSyncKHR);

}



EGLSync eglCreateSyncImpl(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglCreateSync) {

            return eglCreateSyncTmpl<EGLAttrib, PFNEGLCREATESYNC>(dpy, type, attrib_list,

                                                                  cnx->egl.eglCreateSync);

        }

        // driver doesn't support native function, return EGL_BAD_DISPLAY

        ALOGE("Driver indicates EGL 1.5 support, but does not have eglCreateSync");

        return setError(EGL_BAD_DISPLAY, EGL_NO_SYNC);

    }



    std::vector<EGLint> convertedAttribs;

    convertAttribs(attrib_list, convertedAttribs);

    return eglCreateSyncTmpl<EGLint, PFNEGLCREATESYNCKHRPROC>(dpy, type, convertedAttribs.data(),

                                                              cnx->egl.eglCreateSyncKHR);

}



EGLBoolean eglDestroySyncTmpl(EGLDisplay dpy, EGLSyncKHR sync,

                              PFNEGLDESTROYSYNCKHRPROC eglDestroySyncFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_FALSE;



    EGLBoolean result = EGL_FALSE;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglDestroySyncKHR) {

        result = cnx->egl.eglDestroySyncKHR(dp->disp.dpy, sync);

    if (cnx->dso && eglDestroySyncFunc) {

        result = eglDestroySyncFunc(dp->disp.dpy, sync);

    }

    return result;

}



EGLBoolean eglSignalSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {

EGLBoolean eglDestroySyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync) {

    return eglDestroySyncTmpl(dpy, sync, gEGLImpl.egl.eglDestroySyncKHR);

}



EGLBoolean eglDestroySyncImpl(EGLDisplay dpy, EGLSyncKHR sync) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglDestroySync) {

            return eglDestroySyncTmpl(dpy, sync, cnx->egl.eglDestroySync);

        }

        ALOGE("Driver indicates EGL 1.5 support, but does not have eglDestroySync");

        return setError(EGL_BAD_DISPLAY, EGL_FALSE);

    }



    return eglDestroySyncTmpl(dpy, sync, cnx->egl.eglDestroySyncKHR);

}



EGLBoolean eglSignalSyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode,

                             PFNEGLSIGNALSYNCKHRPROC eglSignalSyncFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_FALSE;



    EGLBoolean result = EGL_FALSE;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglSignalSyncKHR) {

        result = cnx->egl.eglSignalSyncKHR(

                dp->disp.dpy, sync, mode);

    if (cnx->dso && eglSignalSyncFunc) {

        result = eglSignalSyncFunc(dp->disp.dpy, sync, mode);

    }

    return result;

}



EGLint eglClientWaitSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync,

        EGLint flags, EGLTimeKHR timeout)

{

EGLBoolean eglSignalSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {

    return eglSignalSyncTmpl(dpy, sync, mode, gEGLImpl.egl.eglSignalSyncKHR);

}



EGLBoolean eglSignalSyncImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglSignalSync) {

            return eglSignalSyncTmpl(dpy, sync, mode, cnx->egl.eglSignalSync);

        }

        ALOGE("Driver indicates EGL 1.5 support, but does not have eglSignalSync");

        return setError(EGL_BAD_DISPLAY, EGL_FALSE);

    }



    return eglSignalSyncTmpl(dpy, sync, mode, gEGLImpl.egl.eglSignalSyncKHR);

}



EGLint eglClientWaitSyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout,

                             PFNEGLCLIENTWAITSYNCKHRPROC eglClientWaitSyncFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_FALSE;



    EGLint result = EGL_FALSE;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglClientWaitSyncKHR) {

        result = cnx->egl.eglClientWaitSyncKHR(

                dp->disp.dpy, sync, flags, timeout);

    if (cnx->dso && eglClientWaitSyncFunc) {

        result = eglClientWaitSyncFunc(dp->disp.dpy, sync, flags, timeout);

    }

    return result;

}



EGLBoolean eglGetSyncAttribKHRImpl(EGLDisplay dpy, EGLSyncKHR sync,

        EGLint attribute, EGLint *value)

{

EGLint eglClientWaitSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {

    egl_connection_t* const cnx = &gEGLImpl;

    return eglClientWaitSyncTmpl(dpy, sync, flags, timeout, cnx->egl.eglClientWaitSyncKHR);

}



EGLint eglClientWaitSyncImpl(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTimeKHR timeout) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglClientWaitSync) {

            return eglClientWaitSyncTmpl(dpy, sync, flags, timeout, cnx->egl.eglClientWaitSync);

        }

        ALOGE("Driver indicates EGL 1.5 support, but does not have eglClientWaitSync");

        return setError(EGL_BAD_DISPLAY, (EGLint)EGL_FALSE);

    }



    return eglClientWaitSyncTmpl(dpy, sync, flags, timeout, cnx->egl.eglClientWaitSyncKHR);

}



template <typename AttrType, typename FuncType>

EGLBoolean eglGetSyncAttribTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, AttrType* value,

                                FuncType eglGetSyncAttribFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_FALSE;



    EGLBoolean result = EGL_FALSE;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglGetSyncAttribKHR) {

        result = cnx->egl.eglGetSyncAttribKHR(

                dp->disp.dpy, sync, attribute, value);

    if (cnx->dso && eglGetSyncAttribFunc) {

        result = eglGetSyncAttribFunc(dp->disp.dpy, sync, attribute, value);

    }

    return result;

}



typedef EGLBoolean(EGLAPIENTRYP PFNEGLGETSYNCATTRIB)(EGLDisplay dpy, EGLSync sync, EGLint attribute,

                                                     EGLAttrib* value);



EGLBoolean eglGetSyncAttribImpl(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglGetSyncAttrib) {

            return eglGetSyncAttribTmpl<EGLAttrib, PFNEGLGETSYNCATTRIB>(dpy, sync, attribute, value,

                                                                        cnx->egl.eglGetSyncAttrib);

        }

        ALOGE("Driver indicates EGL 1.5 support, but does not have eglGetSyncAttrib");

        return setError(EGL_BAD_DISPLAY, (EGLint)EGL_FALSE);

    }



    // Fallback to KHR, ask for EGLint attribute and cast back to EGLAttrib

    EGLint attribValue;

    EGLBoolean ret =

            eglGetSyncAttribTmpl<EGLint, PFNEGLGETSYNCATTRIBKHRPROC>(dpy, sync, attribute,

                                                                     &attribValue,

                                                                     gEGLImpl.egl

                                                                             .eglGetSyncAttribKHR);

    if (ret) {

        *value = static_cast<EGLAttrib>(attribValue);

    }

    return ret;

}



EGLBoolean eglGetSyncAttribKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute,

                                   EGLint* value) {

    return eglGetSyncAttribTmpl<EGLint, PFNEGLGETSYNCATTRIBKHRPROC>(dpy, sync, attribute, value,

                                                                    gEGLImpl.egl

                                                                            .eglGetSyncAttribKHR);

}



EGLStreamKHR eglCreateStreamKHRImpl(EGLDisplay dpy, const EGLint *attrib_list)

{

    const egl_display_ptr dp = validate_display(dpy);
@@ -2069,17 +2179,43 @@ EGLStreamKHR eglCreateStreamFromFileDescriptorKHRImpl( 
// EGL_EGLEXT_VERSION 15

// ----------------------------------------------------------------------------



EGLint eglWaitSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {

// Need to template function type because return type is different

template <typename ReturnType, typename FuncType>

ReturnType eglWaitSyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags,

                           FuncType eglWaitSyncFunc) {

    const egl_display_ptr dp = validate_display(dpy);

    if (!dp) return EGL_FALSE;

    EGLint result = EGL_FALSE;

    ReturnType result = EGL_FALSE;

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->dso && cnx->egl.eglWaitSyncKHR) {

        result = cnx->egl.eglWaitSyncKHR(dp->disp.dpy, sync, flags);

    if (cnx->dso && eglWaitSyncFunc) {

        result = eglWaitSyncFunc(dp->disp.dpy, sync, flags);

    }

    return result;

}



typedef EGLBoolean(EGLAPIENTRYP PFNEGLWAITSYNC)(EGLDisplay dpy, EGLSync sync, EGLint flags);



EGLint eglWaitSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) {

    egl_connection_t* const cnx = &gEGLImpl;

    return eglWaitSyncTmpl<EGLint, PFNEGLWAITSYNCKHRPROC>(dpy, sync, flags,

                                                          cnx->egl.eglWaitSyncKHR);

}



EGLBoolean eglWaitSyncImpl(EGLDisplay dpy, EGLSync sync, EGLint flags) {

    egl_connection_t* const cnx = &gEGLImpl;

    if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) {

        if (cnx->egl.eglWaitSync) {

            return eglWaitSyncTmpl<EGLBoolean, PFNEGLWAITSYNC>(dpy, sync, flags,

                                                               cnx->egl.eglWaitSync);

        }

        return setError(EGL_BAD_DISPLAY, (EGLint)EGL_FALSE);

    }



    return static_cast<EGLBoolean>(

            eglWaitSyncTmpl<EGLint, PFNEGLWAITSYNCKHRPROC>(dpy, sync, flags,

                                                           cnx->egl.eglWaitSyncKHR));

}



// ----------------------------------------------------------------------------

// ANDROID extensions

// ----------------------------------------------------------------------------
@@ -2553,6 +2689,11 @@ static const implementation_map_t sPlatformImplMap[] = { 
    { "eglDestroyImageKHR", (EGLFuncPointer)&eglDestroyImageKHRImpl },

    { "eglCreateImage", (EGLFuncPointer)&eglCreateImageImpl },

    { "eglDestroyImage", (EGLFuncPointer)&eglDestroyImageImpl },

    { "eglCreateSync", (EGLFuncPointer)&eglCreateSyncImpl },

    { "eglDestroySync", (EGLFuncPointer)&eglDestroySyncImpl },

    { "eglSignalSync", (EGLFuncPointer)&eglSignalSyncImpl },

    { "eglClientWaitSync", (EGLFuncPointer)&eglClientWaitSyncImpl },

    { "eglGetSyncAttrib", (EGLFuncPointer)&eglGetSyncAttribImpl },

    { "eglCreateSyncKHR", (EGLFuncPointer)&eglCreateSyncKHRImpl },

    { "eglDestroySyncKHR", (EGLFuncPointer)&eglDestroySyncKHRImpl },

    { "eglSignalSyncKHR", (EGLFuncPointer)&eglSignalSyncKHRImpl },
@@ -2570,6 +2711,7 @@ static const implementation_map_t sPlatformImplMap[] = { 
    { "eglStreamConsumerReleaseKHR", (EGLFuncPointer)&eglStreamConsumerReleaseKHRImpl },

    { "eglGetStreamFileDescriptorKHR", (EGLFuncPointer)&eglGetStreamFileDescriptorKHRImpl },

    { "eglCreateStreamFromFileDescriptorKHR", (EGLFuncPointer)&eglCreateStreamFromFileDescriptorKHRImpl },

    { "eglWaitSync", (EGLFuncPointer)&eglWaitSyncImpl },

    { "eglWaitSyncKHR", (EGLFuncPointer)&eglWaitSyncKHRImpl },

    { "eglDupNativeFenceFDANDROID", (EGLFuncPointer)&eglDupNativeFenceFDANDROIDImpl },

    { "eglPresentationTimeANDROID", (EGLFuncPointer)&eglPresentationTimeANDROIDImpl },

opengl/libs/platform_entries.in

+6 −0
Original line number Diff line number Diff line
@@ -44,6 +44,11 @@ EGL_ENTRY(EGLImage, eglCreateImage, EGLDisplay, EGLContext, EGLenum, EGLClientBu 
EGL_ENTRY(EGLBoolean, eglDestroyImage, EGLDisplay, EGLImage)

EGL_ENTRY(EGLImageKHR, eglCreateImageKHR, EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*)

EGL_ENTRY(EGLBoolean, eglDestroyImageKHR, EGLDisplay, EGLImageKHR)

EGL_ENTRY(EGLSync, eglCreateSync, EGLDisplay, EGLenum, const EGLAttrib*)

EGL_ENTRY(EGLBoolean, eglDestroySync, EGLDisplay, EGLSync)

EGL_ENTRY(EGLBoolean, eglSignalSync, EGLDisplay, EGLSync, EGLenum)

EGL_ENTRY(EGLint, eglClientWaitSync, EGLDisplay, EGLSync, EGLint, EGLTimeKHR)

EGL_ENTRY(EGLBoolean, eglGetSyncAttrib, EGLDisplay, EGLSyncKHR, EGLint, EGLAttrib*)

EGL_ENTRY(EGLSyncKHR, eglCreateSyncKHR, EGLDisplay, EGLenum, const EGLint*)

EGL_ENTRY(EGLBoolean, eglDestroySyncKHR, EGLDisplay, EGLSyncKHR)

EGL_ENTRY(EGLBoolean, eglSignalSyncKHR, EGLDisplay, EGLSyncKHR, EGLenum)
@@ -61,6 +66,7 @@ EGL_ENTRY(EGLBoolean, eglStreamConsumerAcquireKHR, EGLDisplay, EGLStreamKHR) 
EGL_ENTRY(EGLBoolean, eglStreamConsumerReleaseKHR, EGLDisplay, EGLStreamKHR)

EGL_ENTRY(EGLNativeFileDescriptorKHR, eglGetStreamFileDescriptorKHR, EGLDisplay, EGLStreamKHR)

EGL_ENTRY(EGLStreamKHR, eglCreateStreamFromFileDescriptorKHR, EGLDisplay, EGLNativeFileDescriptorKHR)

EGL_ENTRY(EGLint, eglWaitSync, EGLDisplay, EGLSync, EGLint)

EGL_ENTRY(EGLint, eglWaitSyncKHR, EGLDisplay, EGLSyncKHR, EGLint)

EGL_ENTRY(EGLint, eglDupNativeFenceFDANDROID, EGLDisplay, EGLSyncKHR)

EGL_ENTRY(EGLBoolean, eglPresentationTimeANDROID, EGLDisplay, EGLSurface, EGLnsecsANDROID)