diff options
Diffstat (limited to 'opengl/libs/EGL/egl_platform_entries.cpp')
| -rw-r--r-- | opengl/libs/EGL/egl_platform_entries.cpp | 1055 |
1 files changed, 451 insertions, 604 deletions
diff --git a/opengl/libs/EGL/egl_platform_entries.cpp b/opengl/libs/EGL/egl_platform_entries.cpp index aa24e8ee68..de36a7aea6 100644 --- a/opengl/libs/EGL/egl_platform_entries.cpp +++ b/opengl/libs/EGL/egl_platform_entries.cpp @@ -18,36 +18,32 @@ #include "egl_platform_entries.h" -#include <ctype.h> -#include <dlfcn.h> -#include <stdlib.h> -#include <string.h> - -#include <EGL/egl.h> -#include <EGL/eglext.h> -#include <EGL/eglext_angle.h> - #include <android-base/properties.h> #include <android-base/strings.h> #include <android/hardware_buffer.h> -#include <graphicsenv/GraphicsEnv.h> -#include <private/android/AHardwareBufferHelpers.h> - +#include <ctype.h> #include <cutils/compiler.h> +#include <dlfcn.h> +#include <graphicsenv/GraphicsEnv.h> #include <log/log.h> +#include <private/android/AHardwareBufferHelpers.h> +#include <stdlib.h> +#include <string.h> #include <condition_variable> #include <deque> #include <mutex> -#include <unordered_map> #include <string> #include <thread> +#include <unordered_map> #include "../egl_impl.h" - +#include "EGL/egl.h" +#include "EGL/eglext.h" +#include "EGL/eglext_angle.h" #include "egl_display.h" -#include "egl_object.h" #include "egl_layers.h" +#include "egl_object.h" #include "egl_tls.h" #include "egl_trace.h" @@ -80,71 +76,71 @@ struct extension_map_t { * NOTE: Both strings MUST have a single space as the last character. */ -extern char const * const gBuiltinExtensionString; -extern char const * const gExtensionString; +extern const char* const gBuiltinExtensionString; +extern const char* const gExtensionString; // clang-format off // Extensions implemented by the EGL wrapper. -char const * const gBuiltinExtensionString = - "EGL_KHR_get_all_proc_addresses " - "EGL_ANDROID_presentation_time " - "EGL_KHR_swap_buffers_with_damage " - "EGL_ANDROID_get_native_client_buffer " +const char* const gBuiltinExtensionString = "EGL_ANDROID_front_buffer_auto_refresh " "EGL_ANDROID_get_frame_timestamps " - "EGL_EXT_surface_SMPTE2086_metadata " + "EGL_ANDROID_get_native_client_buffer " + "EGL_ANDROID_presentation_time " "EGL_EXT_surface_CTA861_3_metadata " + "EGL_EXT_surface_SMPTE2086_metadata " + "EGL_KHR_get_all_proc_addresses " + "EGL_KHR_swap_buffers_with_damage " ; // Allowed list of extensions exposed to applications if implemented in the vendor driver. -char const * const gExtensionString = - "EGL_KHR_image " // mandatory - "EGL_KHR_image_base " // mandatory +const char* const gExtensionString = + "EGL_ANDROID_image_native_buffer " // mandatory + "EGL_ANDROID_native_fence_sync " // strongly recommended + "EGL_ANDROID_recordable " // mandatory + "EGL_EXT_buffer_age " // strongly recommended with partial_update + "EGL_EXT_create_context_robustness " "EGL_EXT_image_gl_colorspace " - "EGL_KHR_image_pixmap " - "EGL_KHR_lock_surface " + "EGL_EXT_pixel_format_float " + "EGL_EXT_protected_content " + "EGL_EXT_yuv_surface " + "EGL_IMG_context_priority " + "EGL_KHR_config_attribs " + "EGL_KHR_create_context " + "EGL_KHR_create_context_no_error " + "EGL_KHR_fence_sync " "EGL_KHR_gl_colorspace " + "EGL_KHR_gl_renderbuffer_image " "EGL_KHR_gl_texture_2D_image " "EGL_KHR_gl_texture_3D_image " "EGL_KHR_gl_texture_cubemap_image " - "EGL_KHR_gl_renderbuffer_image " + "EGL_KHR_image " // mandatory + "EGL_KHR_image_base " // mandatory + "EGL_KHR_image_pixmap " + "EGL_KHR_lock_surface " + "EGL_KHR_mutable_render_buffer " + "EGL_KHR_no_config_context " + "EGL_KHR_partial_update " // strongly recommended "EGL_KHR_reusable_sync " - "EGL_KHR_fence_sync " - "EGL_KHR_create_context " - "EGL_KHR_config_attribs " - "EGL_KHR_surfaceless_context " "EGL_KHR_stream " - "EGL_KHR_stream_fifo " - "EGL_KHR_stream_producer_eglsurface " "EGL_KHR_stream_consumer_gltexture " "EGL_KHR_stream_cross_process_fd " - "EGL_EXT_create_context_robustness " - "EGL_NV_system_time " - "EGL_ANDROID_image_native_buffer " // mandatory + "EGL_KHR_stream_fifo " + "EGL_KHR_stream_producer_eglsurface " + "EGL_KHR_surfaceless_context " "EGL_KHR_wait_sync " // strongly recommended - "EGL_ANDROID_recordable " // mandatory - "EGL_KHR_partial_update " // strongly recommended - "EGL_EXT_pixel_format_float " - "EGL_EXT_buffer_age " // strongly recommended with partial_update - "EGL_KHR_create_context_no_error " - "EGL_KHR_mutable_render_buffer " - "EGL_EXT_yuv_surface " - "EGL_EXT_protected_content " - "EGL_IMG_context_priority " - "EGL_KHR_no_config_context " + "EGL_NV_context_priority_realtime " + "EGL_NV_system_time " ; -char const * const gClientExtensionString = +const char* const gClientExtensionString = + "EGL_ANDROID_GLES_layers " + "EGL_ANGLE_platform_angle " "EGL_EXT_client_extensions " "EGL_KHR_platform_android " - "EGL_ANGLE_platform_angle " - "EGL_ANDROID_GLES_layers"; -// clang-format on + ; // extensions not exposed to applications but used by the ANDROID system // "EGL_ANDROID_blob_cache " // strongly recommended -// "EGL_IMG_hibernate_process " // optional -// "EGL_ANDROID_native_fence_sync " // strongly recommended // "EGL_ANDROID_framebuffer_target " // mandatory for HWC 1.1 /* @@ -154,105 +150,69 @@ char const * const gClientExtensionString = */ static const extension_map_t sExtensionMap[] = { // EGL_KHR_lock_surface - { "eglLockSurfaceKHR", - (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR }, - { "eglUnlockSurfaceKHR", - (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR }, + { "eglLockSurfaceKHR", (__eglMustCastToProperFunctionPointerType)&eglLockSurfaceKHR }, + { "eglUnlockSurfaceKHR", (__eglMustCastToProperFunctionPointerType)&eglUnlockSurfaceKHR }, // EGL_KHR_image, EGL_KHR_image_base - { "eglCreateImageKHR", - (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR }, - { "eglDestroyImageKHR", - (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR }, + { "eglCreateImageKHR", (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR }, + { "eglDestroyImageKHR", (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR }, // EGL_KHR_reusable_sync, EGL_KHR_fence_sync - { "eglCreateSyncKHR", - (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR }, - { "eglDestroySyncKHR", - (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR }, - { "eglClientWaitSyncKHR", - (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR }, - { "eglSignalSyncKHR", - (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR }, - { "eglGetSyncAttribKHR", - (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR }, + { "eglCreateSyncKHR", (__eglMustCastToProperFunctionPointerType)&eglCreateSyncKHR }, + { "eglDestroySyncKHR", (__eglMustCastToProperFunctionPointerType)&eglDestroySyncKHR }, + { "eglClientWaitSyncKHR", (__eglMustCastToProperFunctionPointerType)&eglClientWaitSyncKHR }, + { "eglSignalSyncKHR", (__eglMustCastToProperFunctionPointerType)&eglSignalSyncKHR }, + { "eglGetSyncAttribKHR", (__eglMustCastToProperFunctionPointerType)&eglGetSyncAttribKHR }, // EGL_NV_system_time - { "eglGetSystemTimeFrequencyNV", - (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV }, - { "eglGetSystemTimeNV", - (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV }, + { "eglGetSystemTimeFrequencyNV", (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeFrequencyNV }, + { "eglGetSystemTimeNV", (__eglMustCastToProperFunctionPointerType)&eglGetSystemTimeNV }, // EGL_KHR_wait_sync - { "eglWaitSyncKHR", - (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR }, + { "eglWaitSyncKHR", (__eglMustCastToProperFunctionPointerType)&eglWaitSyncKHR }, // EGL_ANDROID_presentation_time - { "eglPresentationTimeANDROID", - (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID }, + { "eglPresentationTimeANDROID", (__eglMustCastToProperFunctionPointerType)&eglPresentationTimeANDROID }, // EGL_KHR_swap_buffers_with_damage - { "eglSwapBuffersWithDamageKHR", - (__eglMustCastToProperFunctionPointerType)&eglSwapBuffersWithDamageKHR }, + { "eglSwapBuffersWithDamageKHR", (__eglMustCastToProperFunctionPointerType)&eglSwapBuffersWithDamageKHR }, // EGL_ANDROID_get_native_client_buffer - { "eglGetNativeClientBufferANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetNativeClientBufferANDROID }, + { "eglGetNativeClientBufferANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetNativeClientBufferANDROID }, // EGL_KHR_partial_update - { "eglSetDamageRegionKHR", - (__eglMustCastToProperFunctionPointerType)&eglSetDamageRegionKHR }, - - { "eglCreateStreamKHR", - (__eglMustCastToProperFunctionPointerType)&eglCreateStreamKHR }, - { "eglDestroyStreamKHR", - (__eglMustCastToProperFunctionPointerType)&eglDestroyStreamKHR }, - { "eglStreamAttribKHR", - (__eglMustCastToProperFunctionPointerType)&eglStreamAttribKHR }, - { "eglQueryStreamKHR", - (__eglMustCastToProperFunctionPointerType)&eglQueryStreamKHR }, - { "eglQueryStreamu64KHR", - (__eglMustCastToProperFunctionPointerType)&eglQueryStreamu64KHR }, - { "eglQueryStreamTimeKHR", - (__eglMustCastToProperFunctionPointerType)&eglQueryStreamTimeKHR }, - { "eglCreateStreamProducerSurfaceKHR", - (__eglMustCastToProperFunctionPointerType)&eglCreateStreamProducerSurfaceKHR }, - { "eglStreamConsumerGLTextureExternalKHR", - (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerGLTextureExternalKHR }, - { "eglStreamConsumerAcquireKHR", - (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerAcquireKHR }, - { "eglStreamConsumerReleaseKHR", - (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerReleaseKHR }, - { "eglGetStreamFileDescriptorKHR", - (__eglMustCastToProperFunctionPointerType)&eglGetStreamFileDescriptorKHR }, - { "eglCreateStreamFromFileDescriptorKHR", - (__eglMustCastToProperFunctionPointerType)&eglCreateStreamFromFileDescriptorKHR }, + { "eglSetDamageRegionKHR", (__eglMustCastToProperFunctionPointerType)&eglSetDamageRegionKHR }, + + { "eglCreateStreamKHR", (__eglMustCastToProperFunctionPointerType)&eglCreateStreamKHR }, + { "eglDestroyStreamKHR", (__eglMustCastToProperFunctionPointerType)&eglDestroyStreamKHR }, + { "eglStreamAttribKHR", (__eglMustCastToProperFunctionPointerType)&eglStreamAttribKHR }, + { "eglQueryStreamKHR", (__eglMustCastToProperFunctionPointerType)&eglQueryStreamKHR }, + { "eglQueryStreamu64KHR", (__eglMustCastToProperFunctionPointerType)&eglQueryStreamu64KHR }, + { "eglQueryStreamTimeKHR", (__eglMustCastToProperFunctionPointerType)&eglQueryStreamTimeKHR }, + { "eglCreateStreamProducerSurfaceKHR", (__eglMustCastToProperFunctionPointerType)&eglCreateStreamProducerSurfaceKHR }, + { "eglStreamConsumerGLTextureExternalKHR", (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerGLTextureExternalKHR }, + { "eglStreamConsumerAcquireKHR", (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerAcquireKHR }, + { "eglStreamConsumerReleaseKHR", (__eglMustCastToProperFunctionPointerType)&eglStreamConsumerReleaseKHR }, + { "eglGetStreamFileDescriptorKHR", (__eglMustCastToProperFunctionPointerType)&eglGetStreamFileDescriptorKHR }, + { "eglCreateStreamFromFileDescriptorKHR", (__eglMustCastToProperFunctionPointerType)&eglCreateStreamFromFileDescriptorKHR }, // EGL_ANDROID_get_frame_timestamps - { "eglGetNextFrameIdANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID }, - { "eglGetCompositorTimingANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID }, - { "eglGetCompositorTimingSupportedANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID }, - { "eglGetFrameTimestampsANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID }, - { "eglGetFrameTimestampSupportedANDROID", - (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID }, + { "eglGetNextFrameIdANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID }, + { "eglGetCompositorTimingANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID }, + { "eglGetCompositorTimingSupportedANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID }, + { "eglGetFrameTimestampsANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID }, + { "eglGetFrameTimestampSupportedANDROID", (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID }, // EGL_ANDROID_native_fence_sync - { "eglDupNativeFenceFDANDROID", - (__eglMustCastToProperFunctionPointerType)&eglDupNativeFenceFDANDROID }, + { "eglDupNativeFenceFDANDROID", (__eglMustCastToProperFunctionPointerType)&eglDupNativeFenceFDANDROID }, }; +// clang-format on /* * These extensions entry-points should not be exposed to applications. * They're used internally by the Android EGL layer. */ -#define FILTER_EXTENSIONS(procname) \ - (!strcmp((procname), "eglSetBlobCacheFuncsANDROID") || \ - !strcmp((procname), "eglHibernateProcessIMG") || \ - !strcmp((procname), "eglAwakenProcessIMG")) +#define FILTER_EXTENSIONS(procname) (!strcmp((procname), "eglSetBlobCacheFuncsANDROID")) // accesses protected by sExtensionMapMutex static std::unordered_map<std::string, __eglMustCastToProperFunctionPointerType> sGLExtensionMap; @@ -261,9 +221,8 @@ static std::unordered_map<std::string, int> sGLExtensionSlotMap; static int sGLExtensionSlot = 0; static pthread_mutex_t sExtensionMapMutex = PTHREAD_MUTEX_INITIALIZER; -static void(*findProcAddress(const char* name, - const extension_map_t* map, size_t n))() { - for (uint32_t i=0 ; i<n ; i++) { +static void (*findProcAddress(const char* name, const extension_map_t* map, size_t n))() { + for (uint32_t i = 0; i < n; i++) { if (!strcmp(name, map[i].name)) { return map[i].address; } @@ -273,14 +232,17 @@ static void(*findProcAddress(const char* name, // ---------------------------------------------------------------------------- -extern void setGLHooksThreadSpecific(gl_hooks_t const *value); +extern void setGLHooksThreadSpecific(gl_hooks_t const* value); extern EGLBoolean egl_init_drivers(); -extern const __eglMustCastToProperFunctionPointerType gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS]; +extern const __eglMustCastToProperFunctionPointerType + gExtensionForwarders[MAX_NUMBER_OF_GL_EXTENSIONS]; extern gl_hooks_t gHooksTrace; // ---------------------------------------------------------------------------- -static inline EGLContext getContext() { return egl_tls_t::getContext(); } +static inline EGLContext getContext() { + return egl_tls_t::getContext(); +} // ---------------------------------------------------------------------------- @@ -313,9 +275,8 @@ EGLDisplay eglGetPlatformDisplayImpl(EGLenum platform, void* native_display, // Initialization // ---------------------------------------------------------------------------- -EGLBoolean eglInitializeImpl(EGLDisplay dpy, EGLint *major, EGLint *minor) -{ - egl_display_ptr dp = get_display(dpy); +EGLBoolean eglInitializeImpl(EGLDisplay dpy, EGLint* major, EGLint* minor) { + egl_display_t* dp = get_display(dpy); if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); EGLBoolean res = dp->initialize(major, minor); @@ -323,13 +284,12 @@ EGLBoolean eglInitializeImpl(EGLDisplay dpy, EGLint *major, EGLint *minor) return res; } -EGLBoolean eglTerminateImpl(EGLDisplay dpy) -{ +EGLBoolean eglTerminateImpl(EGLDisplay dpy) { // NOTE: don't unload the drivers b/c some APIs can be called // after eglTerminate() has been called. eglTerminate() only // terminates an EGLDisplay, not a EGL itself. - egl_display_ptr dp = get_display(dpy); + egl_display_t* dp = get_display(dpy); if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); EGLBoolean res = dp->terminate(); @@ -341,14 +301,12 @@ EGLBoolean eglTerminateImpl(EGLDisplay dpy) // configuration // ---------------------------------------------------------------------------- -EGLBoolean eglGetConfigsImpl(EGLDisplay dpy, - EGLConfig *configs, - EGLint config_size, EGLint *num_config) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglGetConfigsImpl(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, + EGLint* num_config) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - if (num_config==nullptr) { + if (num_config == nullptr) { return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } @@ -357,96 +315,88 @@ EGLBoolean eglGetConfigsImpl(EGLDisplay dpy, egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso) { - res = cnx->egl.eglGetConfigs( - dp->disp.dpy, configs, config_size, num_config); + res = cnx->egl.eglGetConfigs(dp->disp.dpy, configs, config_size, num_config); } return res; } -EGLBoolean eglChooseConfigImpl( EGLDisplay dpy, const EGLint *attrib_list, - EGLConfig *configs, EGLint config_size, - EGLint *num_config) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglChooseConfigImpl(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, + EGLint config_size, EGLint* num_config) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - if (num_config==nullptr) { + if (num_config == nullptr) { return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); } - EGLBoolean res = EGL_FALSE; *num_config = 0; egl_connection_t* const cnx = &gEGLImpl; - if (cnx->dso) { - if (attrib_list) { - if (base::GetBoolProperty("debug.egl.force_msaa", false)) { - size_t attribCount = 0; - EGLint attrib = attrib_list[0]; - - // Only enable MSAA if the context is OpenGL ES 2.0 and - // if no caveat is requested - const EGLint *attribRendererable = nullptr; - const EGLint *attribCaveat = nullptr; - - // Count the number of attributes and look for - // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT - while (attrib != EGL_NONE) { - attrib = attrib_list[attribCount]; - switch (attrib) { - case EGL_RENDERABLE_TYPE: - attribRendererable = &attrib_list[attribCount]; - break; - case EGL_CONFIG_CAVEAT: - attribCaveat = &attrib_list[attribCount]; - break; - default: - break; - } - attribCount++; - } - - if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT && - (!attribCaveat || attribCaveat[1] != EGL_NONE)) { + if (!cnx->dso) return EGL_FALSE; + + if (!attrib_list || !base::GetBoolProperty("debug.egl.force_msaa", false)) + return cnx->egl.eglChooseConfig(dp->disp.dpy, attrib_list, configs, config_size, + num_config); + + // Force 4x MSAA + size_t attribCount = 0; + EGLint attrib = attrib_list[0]; + + // Only enable MSAA if the context is OpenGL ES 2.0 and + // if no caveat is requested + const EGLint* attribRendererable = nullptr; + const EGLint* attribCaveat = nullptr; + + // Count the number of attributes and look for + // EGL_RENDERABLE_TYPE and EGL_CONFIG_CAVEAT + while (attrib != EGL_NONE) { + attrib = attrib_list[attribCount]; + switch (attrib) { + case EGL_RENDERABLE_TYPE: + attribRendererable = &attrib_list[attribCount]; + break; + case EGL_CONFIG_CAVEAT: + attribCaveat = &attrib_list[attribCount]; + break; + default: + break; + } + attribCount++; + } - // Insert 2 extra attributes to force-enable MSAA 4x - EGLint aaAttribs[attribCount + 4]; - aaAttribs[0] = EGL_SAMPLE_BUFFERS; - aaAttribs[1] = 1; - aaAttribs[2] = EGL_SAMPLES; - aaAttribs[3] = 4; + if (attribRendererable && attribRendererable[1] == EGL_OPENGL_ES2_BIT && + (!attribCaveat || attribCaveat[1] != EGL_NONE)) { + // Insert 2 extra attributes to force-enable MSAA 4x + EGLint aaAttribs[attribCount + 4]; + aaAttribs[0] = EGL_SAMPLE_BUFFERS; + aaAttribs[1] = 1; + aaAttribs[2] = EGL_SAMPLES; + aaAttribs[3] = 4; - memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint)); + memcpy(&aaAttribs[4], attrib_list, attribCount * sizeof(EGLint)); - EGLint numConfigAA; - EGLBoolean resAA = cnx->egl.eglChooseConfig( - dp->disp.dpy, aaAttribs, configs, config_size, &numConfigAA); + EGLint numConfigAA; + EGLBoolean resAA = cnx->egl.eglChooseConfig(dp->disp.dpy, aaAttribs, configs, config_size, + &numConfigAA); - if (resAA == EGL_TRUE && numConfigAA > 0) { - ALOGD("Enabling MSAA 4x"); - *num_config = numConfigAA; - return resAA; - } - } - } + if (resAA == EGL_TRUE && numConfigAA > 0) { + ALOGD("Enabling MSAA 4x"); + *num_config = numConfigAA; + return resAA; } - - res = cnx->egl.eglChooseConfig( - dp->disp.dpy, attrib_list, configs, config_size, num_config); } - return res; + + return cnx->egl.eglChooseConfig(dp->disp.dpy, attrib_list, configs, config_size, num_config); } -EGLBoolean eglGetConfigAttribImpl(EGLDisplay dpy, EGLConfig config, - EGLint attribute, EGLint *value) -{ +EGLBoolean eglGetConfigAttribImpl(EGLDisplay dpy, EGLConfig config, EGLint attribute, + EGLint* value) { egl_connection_t* cnx = nullptr; - const egl_display_ptr dp = validate_display_connection(dpy, cnx); + const egl_display_t* dp = validate_display_connection(dpy, &cnx); if (!dp) return EGL_FALSE; - return cnx->egl.eglGetConfigAttrib( - dp->disp.dpy, config, attribute, value); + return cnx->egl.eglGetConfigAttrib(dp->disp.dpy, config, attribute, value); } // ---------------------------------------------------------------------------- @@ -484,7 +434,7 @@ static EGLint getReportedColorSpace(EGLint colorspace) { } // Returns a list of color spaces understood by the vendor EGL driver. -static std::vector<EGLint> getDriverColorSpaces(egl_display_ptr dp) { +static std::vector<EGLint> getDriverColorSpaces(egl_display_t* dp) { std::vector<EGLint> colorSpaces; // sRGB and linear are always supported when color space support is present. @@ -509,7 +459,8 @@ static std::vector<EGLint> getDriverColorSpaces(egl_display_ptr dp) { if (findExtension(dp->disp.queryString.extensions, "EGL_EXT_gl_colorspace_display_p3_linear")) { colorSpaces.push_back(EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT); } - if (findExtension(dp->disp.queryString.extensions, "EGL_EXT_gl_colorspace_display_p3_passthrough")) { + if (findExtension(dp->disp.queryString.extensions, + "EGL_EXT_gl_colorspace_display_p3_passthrough")) { colorSpaces.push_back(EGL_GL_COLORSPACE_DISPLAY_P3_PASSTHROUGH_EXT); } return colorSpaces; @@ -519,7 +470,7 @@ static std::vector<EGLint> getDriverColorSpaces(egl_display_ptr dp) { // If there is no color space attribute in attrib_list, colorSpace is left // unmodified. template <typename AttrType> -static EGLBoolean processAttributes(egl_display_ptr dp, ANativeWindow* window, +static EGLBoolean processAttributes(egl_display_t* dp, ANativeWindow* window, const AttrType* attrib_list, EGLint* colorSpace, std::vector<AttrType>* strippedAttribList) { for (const AttrType* attr = attrib_list; attr && attr[0] != EGL_NONE; attr += 2) { @@ -699,7 +650,7 @@ EGLBoolean sendSurfaceMetadata(egl_surface_t* s) { } template <typename AttrType, typename CreateFuncType> -EGLSurface eglCreateWindowSurfaceTmpl(egl_display_ptr dp, egl_connection_t* cnx, EGLConfig config, +EGLSurface eglCreateWindowSurfaceTmpl(egl_display_t* dp, egl_connection_t* cnx, EGLConfig config, ANativeWindow* window, const AttrType* attrib_list, CreateFuncType createWindowSurfaceFunc) { const AttrType* origAttribList = attrib_list; @@ -768,7 +719,7 @@ EGLSurface eglCreateWindowSurfaceTmpl(egl_display_ptr dp, egl_connection_t* cnx, EGLSurface surface = createWindowSurfaceFunc(iDpy, config, window, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, window, surface, + egl_surface_t* s = new egl_surface_t(dp, config, window, surface, getReportedColorSpace(colorSpace), cnx); return s; } @@ -789,8 +740,8 @@ typedef EGLSurface(EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEPROC)( EGLSurface eglCreateWindowSurfaceImpl(EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint* attrib_list) { - egl_connection_t* cnx = NULL; - egl_display_ptr dp = validate_display_connection(dpy, cnx); + egl_connection_t* cnx = nullptr; + egl_display_t* dp = validate_display_connection(dpy, &cnx); if (dp) { return eglCreateWindowSurfaceTmpl< EGLint, PFNEGLCREATEWINDOWSURFACEPROC>(dp, cnx, config, window, attrib_list, @@ -801,8 +752,8 @@ EGLSurface eglCreateWindowSurfaceImpl(EGLDisplay dpy, EGLConfig config, NativeWi EGLSurface eglCreatePlatformWindowSurfaceImpl(EGLDisplay dpy, EGLConfig config, void* native_window, const EGLAttrib* attrib_list) { - egl_connection_t* cnx = NULL; - egl_display_ptr dp = validate_display_connection(dpy, cnx); + egl_connection_t* cnx = nullptr; + egl_display_t* dp = validate_display_connection(dpy, &cnx); if (dp) { if (cnx->driverVersion >= EGL_MAKE_VERSION(1, 5, 0)) { if (cnx->egl.eglCreatePlatformWindowSurface) { @@ -842,8 +793,8 @@ EGLSurface eglCreatePlatformPixmapSurfaceImpl(EGLDisplay dpy, EGLConfig /*config // belongs to the Android platform. Any such call fails and generates // an EGL_BAD_PARAMETER error. - egl_connection_t* cnx = NULL; - egl_display_ptr dp = validate_display_connection(dpy, cnx); + egl_connection_t* cnx = nullptr; + const egl_display_t* dp = validate_display_connection(dpy, &cnx); if (dp) { return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } @@ -853,7 +804,7 @@ EGLSurface eglCreatePlatformPixmapSurfaceImpl(EGLDisplay dpy, EGLConfig /*config EGLSurface eglCreatePixmapSurfaceImpl(EGLDisplay dpy, EGLConfig /*config*/, NativePixmapType /*pixmap*/, const EGLint* /*attrib_list*/) { egl_connection_t* cnx = nullptr; - egl_display_ptr dp = validate_display_connection(dpy, cnx); + const egl_display_t* dp = validate_display_connection(dpy, &cnx); if (dp) { return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } @@ -863,36 +814,33 @@ EGLSurface eglCreatePixmapSurfaceImpl(EGLDisplay dpy, EGLConfig /*config*/, EGLSurface eglCreatePbufferSurfaceImpl(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) { egl_connection_t* cnx = nullptr; - egl_display_ptr dp = validate_display_connection(dpy, cnx); - if (dp) { - EGLDisplay iDpy = dp->disp.dpy; - android_pixel_format format; - getNativePixelFormat(iDpy, cnx, config, &format); - - // Select correct colorspace based on user's attribute list - EGLint colorSpace = EGL_UNKNOWN; - std::vector<EGLint> strippedAttribList; - if (!processAttributes(dp, nullptr, attrib_list, &colorSpace, &strippedAttribList)) { - ALOGE("error invalid colorspace: %d", colorSpace); - return EGL_NO_SURFACE; - } - attrib_list = strippedAttribList.data(); + egl_display_t* dp = validate_display_connection(dpy, &cnx); + if (!dp) return EGL_NO_SURFACE; - EGLSurface surface = cnx->egl.eglCreatePbufferSurface(dp->disp.dpy, config, attrib_list); - if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, nullptr, surface, - getReportedColorSpace(colorSpace), cnx); - return s; - } + EGLDisplay iDpy = dp->disp.dpy; + android_pixel_format format; + getNativePixelFormat(iDpy, cnx, config, &format); + + // Select correct colorspace based on user's attribute list + EGLint colorSpace = EGL_UNKNOWN; + std::vector<EGLint> strippedAttribList; + if (!processAttributes(dp, nullptr, attrib_list, &colorSpace, &strippedAttribList)) { + ALOGE("error invalid colorspace: %d", colorSpace); + return EGL_NO_SURFACE; } - return EGL_NO_SURFACE; + attrib_list = strippedAttribList.data(); + + EGLSurface surface = cnx->egl.eglCreatePbufferSurface(iDpy, config, attrib_list); + if (surface == EGL_NO_SURFACE) return surface; + + return new egl_surface_t(dp, config, nullptr, surface, getReportedColorSpace(colorSpace), cnx); } EGLBoolean eglDestroySurfaceImpl(EGLDisplay dpy, EGLSurface surface) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t* const s = get_surface(surface); @@ -905,10 +853,10 @@ EGLBoolean eglDestroySurfaceImpl(EGLDisplay dpy, EGLSurface surface) { EGLBoolean eglQuerySurfaceImpl(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); egl_surface_t const* const s = get_surface(surface); @@ -923,12 +871,12 @@ EGLBoolean eglQuerySurfaceImpl(EGLDisplay dpy, EGLSurface surface, EGLint attrib } void EGLAPI eglBeginFrameImpl(EGLDisplay dpy, EGLSurface surface) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) { return; } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { setError(EGL_BAD_SURFACE, EGL_FALSE); } @@ -938,14 +886,13 @@ void EGLAPI eglBeginFrameImpl(EGLDisplay dpy, EGLSurface surface) { // Contexts // ---------------------------------------------------------------------------- -EGLContext eglCreateContextImpl(EGLDisplay dpy, EGLConfig config, - EGLContext share_list, const EGLint *attrib_list) -{ +EGLContext eglCreateContextImpl(EGLDisplay dpy, EGLConfig config, EGLContext share_list, + const EGLint* attrib_list) { egl_connection_t* cnx = nullptr; - const egl_display_ptr dp = validate_display_connection(dpy, cnx); + const egl_display_t* dp = validate_display_connection(dpy, &cnx); if (dp) { if (share_list != EGL_NO_CONTEXT) { - if (!ContextRef(dp.get(), share_list).get()) { + if (!ContextRef(dp, share_list).get()) { return setError(EGL_BAD_CONTEXT, EGL_NO_CONTEXT); } egl_context_t* const c = get_context(share_list); @@ -967,8 +914,8 @@ EGLContext eglCreateContextImpl(EGLDisplay dpy, EGLConfig config, } }; } - EGLContext context = cnx->egl.eglCreateContext( - dp->disp.dpy, config, share_list, attrib_list); + EGLContext context = + cnx->egl.eglCreateContext(dp->disp.dpy, config, share_list, attrib_list); if (context != EGL_NO_CONTEXT) { // figure out if it's a GLESv1 or GLESv2 int version = egl_connection_t::GLESv1_INDEX; @@ -992,17 +939,14 @@ EGLContext eglCreateContextImpl(EGLDisplay dpy, EGLConfig config, return EGL_NO_CONTEXT; } -EGLBoolean eglDestroyContextImpl(EGLDisplay dpy, EGLContext ctx) -{ - const egl_display_ptr dp = validate_display(dpy); - if (!dp) - return EGL_FALSE; +EGLBoolean eglDestroyContextImpl(EGLDisplay dpy, EGLContext ctx) { + const egl_display_t* dp = validate_display(dpy); + if (!dp) return EGL_FALSE; - ContextRef _c(dp.get(), ctx); - if (!_c.get()) - return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); + ContextRef _c(dp, ctx); + if (!_c.get()) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); - egl_context_t * const c = get_context(ctx); + egl_context_t* const c = get_context(ctx); EGLBoolean result = c->cnx->egl.eglDestroyContext(dp->disp.dpy, c->context); if (result == EGL_TRUE) { _c.terminate(); @@ -1010,24 +954,21 @@ EGLBoolean eglDestroyContextImpl(EGLDisplay dpy, EGLContext ctx) return result; } -EGLBoolean eglMakeCurrentImpl( EGLDisplay dpy, EGLSurface draw, - EGLSurface read, EGLContext ctx) -{ - egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglMakeCurrentImpl(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { + egl_display_t* dp = validate_display(dpy); if (!dp) return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); // If ctx is not EGL_NO_CONTEXT, read is not EGL_NO_SURFACE, or draw is not // EGL_NO_SURFACE, then an EGL_NOT_INITIALIZED error is generated if dpy is // a valid but uninitialized display. - if ( (ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) || - (draw != EGL_NO_SURFACE) ) { + if ((ctx != EGL_NO_CONTEXT) || (read != EGL_NO_SURFACE) || (draw != EGL_NO_SURFACE)) { if (!dp->isReady()) return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } // get a reference to the object passed in - ContextRef _c(dp.get(), ctx); - SurfaceRef _d(dp.get(), draw); - SurfaceRef _r(dp.get(), read); + ContextRef _c(dp, ctx); + SurfaceRef _d(dp, draw); + SurfaceRef _r(dp, read); // validate the context (if not EGL_NO_CONTEXT) if ((ctx != EGL_NO_CONTEXT) && !_c.get()) { @@ -1036,17 +977,17 @@ EGLBoolean eglMakeCurrentImpl( EGLDisplay dpy, EGLSurface draw, } // these are the underlying implementation's object - EGLContext impl_ctx = EGL_NO_CONTEXT; + EGLContext impl_ctx = EGL_NO_CONTEXT; EGLSurface impl_draw = EGL_NO_SURFACE; EGLSurface impl_read = EGL_NO_SURFACE; // these are our objects structs passed in - egl_context_t * c = nullptr; - egl_surface_t const * d = nullptr; - egl_surface_t const * r = nullptr; + egl_context_t* c = nullptr; + egl_surface_t const* d = nullptr; + egl_surface_t const* r = nullptr; // these are the current objects structs - egl_context_t * cur_c = get_context(getContext()); + egl_context_t* cur_c = get_context(getContext()); if (ctx != EGL_NO_CONTEXT) { c = get_context(ctx); @@ -1078,10 +1019,7 @@ EGLBoolean eglMakeCurrentImpl( EGLDisplay dpy, EGLSurface draw, impl_read = r->surface; } - - EGLBoolean result = dp->makeCurrent(c, cur_c, - draw, read, ctx, - impl_draw, impl_read, impl_ctx); + EGLBoolean result = dp->makeCurrent(c, cur_c, draw, read, ctx, impl_draw, impl_read, impl_ctx); if (result == EGL_TRUE) { if (c) { @@ -1102,81 +1040,72 @@ EGLBoolean eglMakeCurrentImpl( EGLDisplay dpy, EGLSurface draw, return result; } -EGLBoolean eglQueryContextImpl( EGLDisplay dpy, EGLContext ctx, - EGLint attribute, EGLint *value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglQueryContextImpl(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - ContextRef _c(dp.get(), ctx); + ContextRef _c(dp, ctx); if (!_c.get()) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); - egl_context_t * const c = get_context(ctx); - return c->cnx->egl.eglQueryContext( - dp->disp.dpy, c->context, attribute, value); - + egl_context_t* const c = get_context(ctx); + return c->cnx->egl.eglQueryContext(dp->disp.dpy, c->context, attribute, value); } -EGLContext eglGetCurrentContextImpl(void) -{ +EGLContext eglGetCurrentContextImpl(void) { // could be called before eglInitialize(), but we wouldn't have a context // then, and this function would correctly return EGL_NO_CONTEXT. EGLContext ctx = getContext(); return ctx; } -EGLSurface eglGetCurrentSurfaceImpl(EGLint readdraw) -{ +EGLSurface eglGetCurrentSurfaceImpl(EGLint readdraw) { // could be called before eglInitialize(), but we wouldn't have a context // then, and this function would correctly return EGL_NO_SURFACE. EGLContext ctx = getContext(); if (ctx) { - egl_context_t const * const c = get_context(ctx); + egl_context_t const* const c = get_context(ctx); if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE); switch (readdraw) { - case EGL_READ: return c->read; - case EGL_DRAW: return c->draw; - default: return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); + case EGL_READ: + return c->read; + case EGL_DRAW: + return c->draw; + default: + return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); } } return EGL_NO_SURFACE; } -EGLDisplay eglGetCurrentDisplayImpl(void) -{ +EGLDisplay eglGetCurrentDisplayImpl(void) { // could be called before eglInitialize(), but we wouldn't have a context // then, and this function would correctly return EGL_NO_DISPLAY. EGLContext ctx = getContext(); if (ctx) { - egl_context_t const * const c = get_context(ctx); + egl_context_t const* const c = get_context(ctx); if (!c) return setError(EGL_BAD_CONTEXT, EGL_NO_SURFACE); return c->dpy; } return EGL_NO_DISPLAY; } -EGLBoolean eglWaitGLImpl(void) -{ +EGLBoolean eglWaitGLImpl(void) { egl_connection_t* const cnx = &gEGLImpl; - if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); + if (!cnx->dso) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); return cnx->egl.eglWaitGL(); } -EGLBoolean eglWaitNativeImpl(EGLint engine) -{ +EGLBoolean eglWaitNativeImpl(EGLint engine) { egl_connection_t* const cnx = &gEGLImpl; - if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); + if (!cnx->dso) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); return cnx->egl.eglWaitNative(engine); } -EGLint eglGetErrorImpl(void) -{ +EGLint eglGetErrorImpl(void) { EGLint err = EGL_SUCCESS; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso) { @@ -1188,8 +1117,7 @@ EGLint eglGetErrorImpl(void) return err; } -static __eglMustCastToProperFunctionPointerType findBuiltinWrapper( - const char* procname) { +static __eglMustCastToProperFunctionPointerType findBuiltinWrapper(const char* procname) { const egl_connection_t* cnx = &gEGLImpl; void* proc = nullptr; @@ -1205,8 +1133,7 @@ static __eglMustCastToProperFunctionPointerType findBuiltinWrapper( return nullptr; } -__eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char *procname) -{ +__eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char* procname) { if (FILTER_EXTENSIONS(procname)) { return nullptr; } @@ -1253,13 +1180,10 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char *procn // Ensure we have room to track it const int slot = sGLExtensionSlot; if (slot < MAX_NUMBER_OF_GL_EXTENSIONS) { - if (cnx->dso && cnx->egl.eglGetProcAddress) { - // Extensions are independent of the bound context addr = cnx->egl.eglGetProcAddress(procname); if (addr) { - // purposefully track the bottom of the stack in extensionMap extensionMap[name] = addr; @@ -1268,7 +1192,7 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char *procn // Track the top most entry point return the extension forwarder cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[slot] = - cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] = addr; + cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[slot] = addr; addr = gExtensionForwarders[slot]; // Remember the slot for this extension @@ -1300,7 +1224,7 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char *procn // Track the top most entry point and return the extension forwarder cnx->hooks[egl_connection_t::GLESv1_INDEX]->ext.extensions[ext_slot] = - cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[ext_slot] = addr; + cnx->hooks[egl_connection_t::GLESv2_INDEX]->ext.extensions[ext_slot] = addr; addr = gExtensionForwarders[ext_slot]; } @@ -1310,7 +1234,6 @@ __eglMustCastToProperFunctionPointerType eglGetProcAddressImpl(const char *procn class FrameCompletionThread { public: - static void queueSync(EGLSyncKHR sync) { static FrameCompletionThread thread; @@ -1327,7 +1250,6 @@ public: } private: - FrameCompletionThread() : mFramesQueued(0), mFramesCompleted(0) { std::thread thread(&FrameCompletionThread::loop, this); thread.detach(); @@ -1382,15 +1304,13 @@ private: std::mutex mMutex; }; -EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw, - EGLint *rects, EGLint n_rects) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw, EGLint* rects, + EGLint n_rects) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), draw); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, draw); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); if (n_rects < 0 || (n_rects > 0 && rects == NULL)) return setError(EGL_BAD_PARAMETER, (EGLBoolean)EGL_FALSE); @@ -1406,11 +1326,11 @@ EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw, if (CC_UNLIKELY(dp->finishOnSwap)) { uint32_t pixel; - egl_context_t * const c = get_context( egl_tls_t::getContext() ); + egl_context_t* const c = get_context(egl_tls_t::getContext()); if (c) { // glReadPixels() ensures that the frame is complete - s->cnx->hooks[c->version]->gl.glReadPixels(0,0,1,1, - GL_RGBA,GL_UNSIGNED_BYTE,&pixel); + s->cnx->hooks[c->version]->gl.glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, + &pixel); } } @@ -1445,41 +1365,35 @@ EGLBoolean eglSwapBuffersWithDamageKHRImpl(EGLDisplay dpy, EGLSurface draw, } if (s->cnx->egl.eglSwapBuffersWithDamageKHR) { - return s->cnx->egl.eglSwapBuffersWithDamageKHR(dp->disp.dpy, s->surface, - rects, n_rects); - } else { - return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface); + return s->cnx->egl.eglSwapBuffersWithDamageKHR(dp->disp.dpy, s->surface, rects, n_rects); } + + return s->cnx->egl.eglSwapBuffers(dp->disp.dpy, s->surface); } -EGLBoolean eglSwapBuffersImpl(EGLDisplay dpy, EGLSurface surface) -{ +EGLBoolean eglSwapBuffersImpl(EGLDisplay dpy, EGLSurface surface) { return eglSwapBuffersWithDamageKHRImpl(dpy, surface, nullptr, 0); } -EGLBoolean eglCopyBuffersImpl( EGLDisplay dpy, EGLSurface surface, - NativePixmapType target) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglCopyBuffersImpl(EGLDisplay dpy, EGLSurface surface, NativePixmapType target) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); return s->cnx->egl.eglCopyBuffers(dp->disp.dpy, s->surface, target); } -const char* eglQueryStringImpl(EGLDisplay dpy, EGLint name) -{ +const char* eglQueryStringImpl(EGLDisplay dpy, EGLint name) { if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) { // Return list of client extensions return gClientExtensionString; } - const egl_display_ptr dp = validate_display(dpy); - if (!dp) return (const char *) nullptr; + const egl_display_t* dp = validate_display(dpy); + if (!dp) return (const char*)nullptr; switch (name) { case EGL_VENDOR: @@ -1493,13 +1407,12 @@ const char* eglQueryStringImpl(EGLDisplay dpy, EGLint name) default: break; } - return setError(EGL_BAD_PARAMETER, (const char *)nullptr); + return setError(EGL_BAD_PARAMETER, (const char*)nullptr); } -EGLAPI const char* eglQueryStringImplementationANDROIDImpl(EGLDisplay dpy, EGLint name) -{ - const egl_display_ptr dp = validate_display(dpy); - if (!dp) return (const char *) nullptr; +EGLAPI const char* eglQueryStringImplementationANDROIDImpl(EGLDisplay dpy, EGLint name) { + const egl_display_t* dp = validate_display(dpy); + if (!dp) return (const char*)nullptr; switch (name) { case EGL_VENDOR: @@ -1513,24 +1426,22 @@ EGLAPI const char* eglQueryStringImplementationANDROIDImpl(EGLDisplay dpy, EGLin default: break; } - return setError(EGL_BAD_PARAMETER, (const char *)nullptr); + return setError(EGL_BAD_PARAMETER, (const char*)nullptr); } // ---------------------------------------------------------------------------- // EGL 1.1 // ---------------------------------------------------------------------------- -EGLBoolean eglSurfaceAttribImpl( - EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglSurfaceAttribImpl(EGLDisplay dpy, EGLSurface surface, EGLint attribute, + EGLint value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t * const s = get_surface(surface); + egl_surface_t* const s = get_surface(surface); if (attribute == EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID) { if (!s->getNativeWindow()) { @@ -1542,7 +1453,9 @@ EGLBoolean eglSurfaceAttribImpl( if (attribute == EGL_TIMESTAMPS_ANDROID) { if (!s->getNativeWindow()) { - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + // According to the spec, "if surface is not a window surface this has no + // effect." + return EGL_TRUE; } int err = native_window_enable_frame_timestamps(s->getNativeWindow(), value != 0); return (err == 0) ? EGL_TRUE : setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); @@ -1553,51 +1466,41 @@ EGLBoolean eglSurfaceAttribImpl( } else if (s->setCta8613Attribute(attribute, value)) { return EGL_TRUE; } else if (s->cnx->egl.eglSurfaceAttrib) { - return s->cnx->egl.eglSurfaceAttrib( - dp->disp.dpy, s->surface, attribute, value); + return s->cnx->egl.eglSurfaceAttrib(dp->disp.dpy, s->surface, attribute, value); } return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } -EGLBoolean eglBindTexImageImpl( - EGLDisplay dpy, EGLSurface surface, EGLint buffer) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglBindTexImageImpl(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (s->cnx->egl.eglBindTexImage) { - return s->cnx->egl.eglBindTexImage( - dp->disp.dpy, s->surface, buffer); + return s->cnx->egl.eglBindTexImage(dp->disp.dpy, s->surface, buffer); } return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } -EGLBoolean eglReleaseTexImageImpl( - EGLDisplay dpy, EGLSurface surface, EGLint buffer) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglReleaseTexImageImpl(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (s->cnx->egl.eglReleaseTexImage) { - return s->cnx->egl.eglReleaseTexImage( - dp->disp.dpy, s->surface, buffer); + return s->cnx->egl.eglReleaseTexImage(dp->disp.dpy, s->surface, buffer); } return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } -EGLBoolean eglSwapIntervalImpl(EGLDisplay dpy, EGLint interval) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglSwapIntervalImpl(EGLDisplay dpy, EGLint interval) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean res = EGL_TRUE; @@ -1609,16 +1512,13 @@ EGLBoolean eglSwapIntervalImpl(EGLDisplay dpy, EGLint interval) return res; } - // ---------------------------------------------------------------------------- // EGL 1.2 // ---------------------------------------------------------------------------- -EGLBoolean eglWaitClientImpl(void) -{ +EGLBoolean eglWaitClientImpl(void) { egl_connection_t* const cnx = &gEGLImpl; - if (!cnx->dso) - return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); + if (!cnx->dso) return setError(EGL_BAD_CONTEXT, (EGLBoolean)EGL_FALSE); EGLBoolean res; if (cnx->egl.eglWaitClient) { @@ -1629,8 +1529,7 @@ EGLBoolean eglWaitClientImpl(void) return res; } -EGLBoolean eglBindAPIImpl(EGLenum api) -{ +EGLBoolean eglBindAPIImpl(EGLenum api) { // bind this API on all EGLs EGLBoolean res = EGL_TRUE; egl_connection_t* const cnx = &gEGLImpl; @@ -1640,8 +1539,7 @@ EGLBoolean eglBindAPIImpl(EGLenum api) return res; } -EGLenum eglQueryAPIImpl(void) -{ +EGLenum eglQueryAPIImpl(void) { egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglQueryAPI) { return cnx->egl.eglQueryAPI(); @@ -1651,8 +1549,7 @@ EGLenum eglQueryAPIImpl(void) return EGL_OPENGL_ES_API; } -EGLBoolean eglReleaseThreadImpl(void) -{ +EGLBoolean eglReleaseThreadImpl(void) { egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglReleaseThread) { cnx->egl.eglReleaseThread(); @@ -1665,16 +1562,15 @@ EGLBoolean eglReleaseThreadImpl(void) return EGL_TRUE; } -EGLSurface eglCreatePbufferFromClientBufferImpl( - EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, - EGLConfig config, const EGLint *attrib_list) -{ +EGLSurface eglCreatePbufferFromClientBufferImpl(EGLDisplay dpy, EGLenum buftype, + EGLClientBuffer buffer, EGLConfig config, + const EGLint* attrib_list) { egl_connection_t* cnx = nullptr; - const egl_display_ptr dp = validate_display_connection(dpy, cnx); + const egl_display_t* dp = validate_display_connection(dpy, &cnx); if (!dp) return EGL_FALSE; if (cnx->egl.eglCreatePbufferFromClientBuffer) { - return cnx->egl.eglCreatePbufferFromClientBuffer( - dp->disp.dpy, buftype, buffer, config, attrib_list); + return cnx->egl.eglCreatePbufferFromClientBuffer(dp->disp.dpy, buftype, buffer, config, + attrib_list); } return setError(EGL_BAD_CONFIG, EGL_NO_SURFACE); } @@ -1683,34 +1579,28 @@ EGLSurface eglCreatePbufferFromClientBufferImpl( // EGL_EGLEXT_VERSION 3 // ---------------------------------------------------------------------------- -EGLBoolean eglLockSurfaceKHRImpl(EGLDisplay dpy, EGLSurface surface, - const EGLint *attrib_list) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglLockSurfaceKHRImpl(EGLDisplay dpy, EGLSurface surface, const EGLint* attrib_list) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (s->cnx->egl.eglLockSurfaceKHR) { - return s->cnx->egl.eglLockSurfaceKHR( - dp->disp.dpy, s->surface, attrib_list); + return s->cnx->egl.eglLockSurfaceKHR(dp->disp.dpy, s->surface, attrib_list); } return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } -EGLBoolean eglUnlockSurfaceKHRImpl(EGLDisplay dpy, EGLSurface surface) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglUnlockSurfaceKHRImpl(EGLDisplay dpy, EGLSurface surface) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; - SurfaceRef _s(dp.get(), surface); - if (!_s.get()) - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + SurfaceRef _s(dp, surface); + if (!_s.get()) return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (s->cnx->egl.eglUnlockSurfaceKHR) { return s->cnx->egl.eglUnlockSurfaceKHR(dp->disp.dpy, s->surface); } @@ -1723,7 +1613,7 @@ template <typename AttrType, typename FuncType> EGLImageKHR eglCreateImageTmpl(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const AttrType* attrib_list, FuncType eglCreateImageFunc) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_IMAGE_KHR; std::vector<AttrType> strippedAttribs; @@ -1732,7 +1622,7 @@ EGLImageKHR eglCreateImageTmpl(EGLDisplay dpy, EGLContext ctx, EGLenum target, // EGL_GL_COLORSPACE_LINEAR_KHR, EGL_GL_COLORSPACE_SRGB_KHR and // EGL_GL_COLORSPACE_DEFAULT_EXT if EGL_EXT_image_gl_colorspace is supported, // but some drivers don't like the DEFAULT value and generate an error. - for (const AttrType *attr = attrib_list; attr && attr[0] != EGL_NONE; attr += 2) { + for (const AttrType* attr = attrib_list; attr && attr[0] != EGL_NONE; attr += 2) { if (attr[0] == EGL_GL_COLORSPACE_KHR && dp->haveExtension("EGL_EXT_image_gl_colorspace")) { if (attr[1] != EGL_GL_COLORSPACE_LINEAR_KHR && @@ -1746,14 +1636,15 @@ EGLImageKHR eglCreateImageTmpl(EGLDisplay dpy, EGLContext ctx, EGLenum target, strippedAttribs.push_back(EGL_NONE); } - ContextRef _c(dp.get(), ctx); + ContextRef _c(dp, ctx); egl_context_t* const c = _c.get(); EGLImageKHR result = EGL_NO_IMAGE_KHR; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && eglCreateImageFunc) { result = eglCreateImageFunc(dp->disp.dpy, c ? c->context : EGL_NO_CONTEXT, target, buffer, - needsAndroidPEglMitigation() ? strippedAttribs.data() : attrib_list); + needsAndroidPEglMitigation() ? strippedAttribs.data() + : attrib_list); } return result; } @@ -1792,7 +1683,7 @@ EGLImage eglCreateImageImpl(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLC EGLBoolean eglDestroyImageTmpl(EGLDisplay dpy, EGLImageKHR img, PFNEGLDESTROYIMAGEKHRPROC destroyImageFunc) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; @@ -1829,7 +1720,7 @@ EGLBoolean eglDestroyImageImpl(EGLDisplay dpy, EGLImageKHR img) { 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); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_SYNC_KHR; egl_connection_t* const cnx = &gEGLImpl; @@ -1868,7 +1759,7 @@ EGLSync eglCreateSyncImpl(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_ EGLBoolean eglDestroySyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, PFNEGLDESTROYSYNCKHRPROC eglDestroySyncFunc) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; @@ -1897,7 +1788,7 @@ EGLBoolean eglDestroySyncImpl(EGLDisplay dpy, EGLSyncKHR sync) { } EGLBoolean eglSignalSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; @@ -1910,7 +1801,7 @@ EGLBoolean eglSignalSyncKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) { EGLint eglClientWaitSyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout, PFNEGLCLIENTWAITSYNCKHRPROC eglClientWaitSyncFunc) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLint result = EGL_FALSE; @@ -1942,7 +1833,7 @@ EGLint eglClientWaitSyncImpl(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime 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); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; @@ -1987,106 +1878,93 @@ EGLBoolean eglGetSyncAttribKHRImpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint attri .eglGetSyncAttribKHR); } -EGLStreamKHR eglCreateStreamKHRImpl(EGLDisplay dpy, const EGLint *attrib_list) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLStreamKHR eglCreateStreamKHRImpl(EGLDisplay dpy, const EGLint* attrib_list) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_STREAM_KHR; EGLStreamKHR result = EGL_NO_STREAM_KHR; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglCreateStreamKHR) { - result = cnx->egl.eglCreateStreamKHR( - dp->disp.dpy, attrib_list); + result = cnx->egl.eglCreateStreamKHR(dp->disp.dpy, attrib_list); } return result; } -EGLBoolean eglDestroyStreamKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglDestroyStreamKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglDestroyStreamKHR) { - result = cnx->egl.eglDestroyStreamKHR( - dp->disp.dpy, stream); + result = cnx->egl.eglDestroyStreamKHR(dp->disp.dpy, stream); } return result; } -EGLBoolean eglStreamAttribKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, - EGLenum attribute, EGLint value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglStreamAttribKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, + EGLint value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglStreamAttribKHR) { - result = cnx->egl.eglStreamAttribKHR( - dp->disp.dpy, stream, attribute, value); + result = cnx->egl.eglStreamAttribKHR(dp->disp.dpy, stream, attribute, value); } return result; } -EGLBoolean eglQueryStreamKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, - EGLenum attribute, EGLint *value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglQueryStreamKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, + EGLint* value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglQueryStreamKHR) { - result = cnx->egl.eglQueryStreamKHR( - dp->disp.dpy, stream, attribute, value); + result = cnx->egl.eglQueryStreamKHR(dp->disp.dpy, stream, attribute, value); } return result; } -EGLBoolean eglQueryStreamu64KHRImpl(EGLDisplay dpy, EGLStreamKHR stream, - EGLenum attribute, EGLuint64KHR *value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglQueryStreamu64KHRImpl(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, + EGLuint64KHR* value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglQueryStreamu64KHR) { - result = cnx->egl.eglQueryStreamu64KHR( - dp->disp.dpy, stream, attribute, value); + result = cnx->egl.eglQueryStreamu64KHR(dp->disp.dpy, stream, attribute, value); } return result; } -EGLBoolean eglQueryStreamTimeKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, - EGLenum attribute, EGLTimeKHR *value) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglQueryStreamTimeKHRImpl(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, + EGLTimeKHR* value) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglQueryStreamTimeKHR) { - result = cnx->egl.eglQueryStreamTimeKHR( - dp->disp.dpy, stream, attribute, value); + result = cnx->egl.eglQueryStreamTimeKHR(dp->disp.dpy, stream, attribute, value); } return result; } EGLSurface eglCreateStreamProducerSurfaceKHRImpl(EGLDisplay dpy, EGLConfig config, - EGLStreamKHR stream, const EGLint *attrib_list) -{ - egl_display_ptr dp = validate_display(dpy); + EGLStreamKHR stream, const EGLint* attrib_list) { + egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_SURFACE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglCreateStreamProducerSurfaceKHR) { - EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR( - dp->disp.dpy, config, stream, attrib_list); + EGLSurface surface = cnx->egl.eglCreateStreamProducerSurfaceKHR(dp->disp.dpy, config, + stream, attrib_list); if (surface != EGL_NO_SURFACE) { - egl_surface_t* s = new egl_surface_t(dp.get(), config, nullptr, surface, + egl_surface_t* s = new egl_surface_t(dp, config, nullptr, surface, EGL_GL_COLORSPACE_LINEAR_KHR, cnx); return s; } @@ -2094,77 +1972,63 @@ EGLSurface eglCreateStreamProducerSurfaceKHRImpl(EGLDisplay dpy, EGLConfig confi return EGL_NO_SURFACE; } -EGLBoolean eglStreamConsumerGLTextureExternalKHRImpl(EGLDisplay dpy, - EGLStreamKHR stream) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglStreamConsumerGLTextureExternalKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglStreamConsumerGLTextureExternalKHR) { - result = cnx->egl.eglStreamConsumerGLTextureExternalKHR( - dp->disp.dpy, stream); + result = cnx->egl.eglStreamConsumerGLTextureExternalKHR(dp->disp.dpy, stream); } return result; } -EGLBoolean eglStreamConsumerAcquireKHRImpl(EGLDisplay dpy, - EGLStreamKHR stream) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglStreamConsumerAcquireKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglStreamConsumerAcquireKHR) { - result = cnx->egl.eglStreamConsumerAcquireKHR( - dp->disp.dpy, stream); + result = cnx->egl.eglStreamConsumerAcquireKHR(dp->disp.dpy, stream); } return result; } -EGLBoolean eglStreamConsumerReleaseKHRImpl(EGLDisplay dpy, - EGLStreamKHR stream) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglStreamConsumerReleaseKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; EGLBoolean result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglStreamConsumerReleaseKHR) { - result = cnx->egl.eglStreamConsumerReleaseKHR( - dp->disp.dpy, stream); + result = cnx->egl.eglStreamConsumerReleaseKHR(dp->disp.dpy, stream); } return result; } -EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHRImpl( - EGLDisplay dpy, EGLStreamKHR stream) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLNativeFileDescriptorKHR eglGetStreamFileDescriptorKHRImpl(EGLDisplay dpy, EGLStreamKHR stream) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_FILE_DESCRIPTOR_KHR; EGLNativeFileDescriptorKHR result = EGL_NO_FILE_DESCRIPTOR_KHR; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglGetStreamFileDescriptorKHR) { - result = cnx->egl.eglGetStreamFileDescriptorKHR( - dp->disp.dpy, stream); + result = cnx->egl.eglGetStreamFileDescriptorKHR(dpy, stream); } return result; } -EGLStreamKHR eglCreateStreamFromFileDescriptorKHRImpl( - EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLStreamKHR eglCreateStreamFromFileDescriptorKHRImpl(EGLDisplay dpy, + EGLNativeFileDescriptorKHR file_descriptor) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_STREAM_KHR; EGLStreamKHR result = EGL_NO_STREAM_KHR; egl_connection_t* const cnx = &gEGLImpl; if (cnx->dso && cnx->egl.eglCreateStreamFromFileDescriptorKHR) { - result = cnx->egl.eglCreateStreamFromFileDescriptorKHR( - dp->disp.dpy, file_descriptor); + result = cnx->egl.eglCreateStreamFromFileDescriptorKHR(dp->disp.dpy, file_descriptor); } return result; } @@ -2177,7 +2041,7 @@ EGLStreamKHR eglCreateStreamFromFileDescriptorKHRImpl( template <typename ReturnType, typename FuncType> ReturnType eglWaitSyncTmpl(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, FuncType eglWaitSyncFunc) { - const egl_display_ptr dp = validate_display(dpy); + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_FALSE; ReturnType result = EGL_FALSE; egl_connection_t* const cnx = &gEGLImpl; @@ -2214,9 +2078,8 @@ EGLBoolean eglWaitSyncImpl(EGLDisplay dpy, EGLSync sync, EGLint flags) { // ANDROID extensions // ---------------------------------------------------------------------------- -EGLint eglDupNativeFenceFDANDROIDImpl(EGLDisplay dpy, EGLSyncKHR sync) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLint eglDupNativeFenceFDANDROIDImpl(EGLDisplay dpy, EGLSyncKHR sync) { + const egl_display_t* dp = validate_display(dpy); if (!dp) return EGL_NO_NATIVE_FENCE_FD_ANDROID; EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID; @@ -2228,42 +2091,33 @@ EGLint eglDupNativeFenceFDANDROIDImpl(EGLDisplay dpy, EGLSyncKHR sync) } EGLBoolean eglPresentationTimeANDROIDImpl(EGLDisplay dpy, EGLSurface surface, - EGLnsecsANDROID time) -{ - const egl_display_ptr dp = validate_display(dpy); + EGLnsecsANDROID time) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return EGL_FALSE; } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { setError(EGL_BAD_SURFACE, EGL_FALSE); return EGL_FALSE; } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); native_window_set_buffers_timestamp(s->getNativeWindow(), time); return EGL_TRUE; } -EGLClientBuffer eglGetNativeClientBufferANDROIDImpl(const AHardwareBuffer *buffer) { - // AHardwareBuffer_to_ANativeWindowBuffer is a platform-only symbol and thus - // this function cannot be implemented when this libEGL is built for - // vendors. -#ifndef __ANDROID_VNDK__ +EGLClientBuffer eglGetNativeClientBufferANDROIDImpl(const AHardwareBuffer* buffer) { if (!buffer) return setError(EGL_BAD_PARAMETER, (EGLClientBuffer) nullptr); - return const_cast<ANativeWindowBuffer *>(AHardwareBuffer_to_ANativeWindowBuffer(buffer)); -#else - return setError(EGL_BAD_PARAMETER, (EGLClientBuffer) nullptr); -#endif + return const_cast<ANativeWindowBuffer*>(AHardwareBuffer_to_ANativeWindowBuffer(buffer)); } // ---------------------------------------------------------------------------- // NVIDIA extensions // ---------------------------------------------------------------------------- -EGLuint64NV eglGetSystemTimeFrequencyNVImpl() -{ +EGLuint64NV eglGetSystemTimeFrequencyNVImpl() { EGLuint64NV ret = 0; egl_connection_t* const cnx = &gEGLImpl; @@ -2274,8 +2128,7 @@ EGLuint64NV eglGetSystemTimeFrequencyNVImpl() return setErrorQuiet(EGL_BAD_DISPLAY, (EGLuint64NV)0); } -EGLuint64NV eglGetSystemTimeNVImpl() -{ +EGLuint64NV eglGetSystemTimeNVImpl() { EGLuint64NV ret = 0; egl_connection_t* const cnx = &gEGLImpl; @@ -2289,43 +2142,40 @@ EGLuint64NV eglGetSystemTimeNVImpl() // ---------------------------------------------------------------------------- // Partial update extension // ---------------------------------------------------------------------------- -EGLBoolean eglSetDamageRegionKHRImpl(EGLDisplay dpy, EGLSurface surface, - EGLint *rects, EGLint n_rects) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglSetDamageRegionKHRImpl(EGLDisplay dpy, EGLSurface surface, EGLint* rects, + EGLint n_rects) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { setError(EGL_BAD_DISPLAY, EGL_FALSE); return EGL_FALSE; } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { setError(EGL_BAD_SURFACE, EGL_FALSE); return EGL_FALSE; } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (s->cnx->egl.eglSetDamageRegionKHR) { - return s->cnx->egl.eglSetDamageRegionKHR(dp->disp.dpy, s->surface, - rects, n_rects); + return s->cnx->egl.eglSetDamageRegionKHR(dp->disp.dpy, s->surface, rects, n_rects); } return EGL_FALSE; } -EGLBoolean eglGetNextFrameIdANDROIDImpl(EGLDisplay dpy, EGLSurface surface, - EGLuint64KHR *frameId) { - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglGetNextFrameIdANDROIDImpl(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR* frameId) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (!s->getNativeWindow()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); @@ -2346,19 +2196,19 @@ EGLBoolean eglGetNextFrameIdANDROIDImpl(EGLDisplay dpy, EGLSurface surface, } EGLBoolean eglGetCompositorTimingANDROIDImpl(EGLDisplay dpy, EGLSurface surface, - EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values) -{ - const egl_display_ptr dp = validate_display(dpy); + EGLint numTimestamps, const EGLint* names, + EGLnsecsANDROID* values) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (!s->getNativeWindow()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); @@ -2384,36 +2234,35 @@ EGLBoolean eglGetCompositorTimingANDROIDImpl(EGLDisplay dpy, EGLSurface surface, } } - int ret = native_window_get_compositor_timing(s->getNativeWindow(), - compositeDeadline, compositeInterval, compositeToPresentLatency); + int ret = native_window_get_compositor_timing(s->getNativeWindow(), compositeDeadline, + compositeInterval, compositeToPresentLatency); switch (ret) { - case 0: - return EGL_TRUE; - case -ENOSYS: - return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); - default: - // This should not happen. Return an error that is not in the spec - // so it's obvious something is very wrong. - ALOGE("eglGetCompositorTiming: Unexpected error."); - return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); + case 0: + return EGL_TRUE; + case -ENOSYS: + return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); + default: + // This should not happen. Return an error that is not in the spec + // so it's obvious something is very wrong. + ALOGE("eglGetCompositorTiming: Unexpected error."); + return setError(EGL_NOT_INITIALIZED, (EGLBoolean)EGL_FALSE); } } -EGLBoolean eglGetCompositorTimingSupportedANDROIDImpl( - EGLDisplay dpy, EGLSurface surface, EGLint name) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglGetCompositorTimingSupportedANDROIDImpl(EGLDisplay dpy, EGLSurface surface, + EGLint name) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); ANativeWindow* window = s->getNativeWindow(); if (!window) { @@ -2431,20 +2280,19 @@ EGLBoolean eglGetCompositorTimingSupportedANDROIDImpl( } EGLBoolean eglGetFrameTimestampsANDROIDImpl(EGLDisplay dpy, EGLSurface surface, - EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, - EGLnsecsANDROID *values) -{ - const egl_display_ptr dp = validate_display(dpy); + EGLuint64KHR frameId, EGLint numTimestamps, + const EGLint* timestamps, EGLnsecsANDROID* values) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); if (!s->getNativeWindow()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); @@ -2494,10 +2342,11 @@ EGLBoolean eglGetFrameTimestampsANDROIDImpl(EGLDisplay dpy, EGLSurface surface, } } - int ret = native_window_get_frame_timestamps(s->getNativeWindow(), frameId, - requestedPresentTime, acquireTime, latchTime, firstRefreshStartTime, - lastRefreshStartTime, gpuCompositionDoneTime, displayPresentTime, - dequeueReadyTime, releaseTime); + int ret = + native_window_get_frame_timestamps(s->getNativeWindow(), frameId, requestedPresentTime, + acquireTime, latchTime, firstRefreshStartTime, + lastRefreshStartTime, gpuCompositionDoneTime, + displayPresentTime, dequeueReadyTime, releaseTime); switch (ret) { case 0: @@ -2516,20 +2365,19 @@ EGLBoolean eglGetFrameTimestampsANDROIDImpl(EGLDisplay dpy, EGLSurface surface, } } -EGLBoolean eglGetFrameTimestampSupportedANDROIDImpl( - EGLDisplay dpy, EGLSurface surface, EGLint timestamp) -{ - const egl_display_ptr dp = validate_display(dpy); +EGLBoolean eglGetFrameTimestampSupportedANDROIDImpl(EGLDisplay dpy, EGLSurface surface, + EGLint timestamp) { + const egl_display_t* dp = validate_display(dpy); if (!dp) { return setError(EGL_BAD_DISPLAY, (EGLBoolean)EGL_FALSE); } - SurfaceRef _s(dp.get(), surface); + SurfaceRef _s(dp, surface); if (!_s.get()) { return setError(EGL_BAD_SURFACE, (EGLBoolean)EGL_FALSE); } - egl_surface_t const * const s = get_surface(surface); + egl_surface_t const* const s = get_surface(surface); ANativeWindow* window = s->getNativeWindow(); if (!window) { @@ -2551,8 +2399,7 @@ EGLBoolean eglGetFrameTimestampSupportedANDROIDImpl( return EGL_TRUE; case EGL_DISPLAY_PRESENT_TIME_ANDROID: { int value = 0; - window->query(window, - NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value); + window->query(window, NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &value); return value == 0 ? EGL_FALSE : EGL_TRUE; } default: @@ -2560,25 +2407,25 @@ EGLBoolean eglGetFrameTimestampSupportedANDROIDImpl( } } -const GLubyte * glGetStringImpl(GLenum name) { - const GLubyte * ret = egl_get_string_for_current_context(name); +const GLubyte* glGetStringImpl(GLenum name) { + const GLubyte* ret = egl_get_string_for_current_context(name); if (ret == NULL) { - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; - if(_c) ret = _c->glGetString(name); + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; + if (_c) ret = _c->glGetString(name); } return ret; } -const GLubyte * glGetStringiImpl(GLenum name, GLuint index) { - const GLubyte * ret = egl_get_string_for_current_context(name, index); +const GLubyte* glGetStringiImpl(GLenum name, GLuint index) { + const GLubyte* ret = egl_get_string_for_current_context(name, index); if (ret == NULL) { - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; - if(_c) ret = _c->glGetStringi(name, index); + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; + if (_c) ret = _c->glGetStringi(name, index); } return ret; } -void glGetBooleanvImpl(GLenum pname, GLboolean * data) { +void glGetBooleanvImpl(GLenum pname, GLboolean* data) { if (pname == GL_NUM_EXTENSIONS) { int num_exts = egl_get_num_extensions_for_current_context(); if (num_exts >= 0) { @@ -2587,11 +2434,11 @@ void glGetBooleanvImpl(GLenum pname, GLboolean * data) { } } - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; if (_c) _c->glGetBooleanv(pname, data); } -void glGetFloatvImpl(GLenum pname, GLfloat * data) { +void glGetFloatvImpl(GLenum pname, GLfloat* data) { if (pname == GL_NUM_EXTENSIONS) { int num_exts = egl_get_num_extensions_for_current_context(); if (num_exts >= 0) { @@ -2600,11 +2447,11 @@ void glGetFloatvImpl(GLenum pname, GLfloat * data) { } } - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; if (_c) _c->glGetFloatv(pname, data); } -void glGetIntegervImpl(GLenum pname, GLint * data) { +void glGetIntegervImpl(GLenum pname, GLint* data) { if (pname == GL_NUM_EXTENSIONS) { int num_exts = egl_get_num_extensions_for_current_context(); if (num_exts >= 0) { @@ -2613,11 +2460,11 @@ void glGetIntegervImpl(GLenum pname, GLint * data) { } } - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; if (_c) _c->glGetIntegerv(pname, data); } -void glGetInteger64vImpl(GLenum pname, GLint64 * data) { +void glGetInteger64vImpl(GLenum pname, GLint64* data) { if (pname == GL_NUM_EXTENSIONS) { int num_exts = egl_get_num_extensions_for_current_context(); if (num_exts >= 0) { @@ -2626,7 +2473,7 @@ void glGetInteger64vImpl(GLenum pname, GLint64 * data) { } } - gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; + gl_hooks_t::gl_t const* const _c = &getGlThreadSpecific()->gl; if (_c) _c->glGetInteger64v(pname, data); } @@ -2635,8 +2482,8 @@ struct implementation_map_t { EGLFuncPointer address; }; +// clang-format off static const implementation_map_t sPlatformImplMap[] = { - // clang-format off { "eglGetDisplay", (EGLFuncPointer)&eglGetDisplayImpl }, { "eglGetPlatformDisplay", (EGLFuncPointer)&eglGetPlatformDisplayImpl }, { "eglInitialize", (EGLFuncPointer)&eglInitializeImpl }, @@ -2723,11 +2570,10 @@ static const implementation_map_t sPlatformImplMap[] = { { "glGetFloatv", (EGLFuncPointer)&glGetFloatvImpl }, { "glGetIntegerv", (EGLFuncPointer)&glGetIntegervImpl }, { "glGetInteger64v", (EGLFuncPointer)&glGetInteger64vImpl }, - // clang-format on }; +// clang-format on -EGLFuncPointer FindPlatformImplAddr(const char* name) -{ +EGLFuncPointer FindPlatformImplAddr(const char* name) { static const bool DEBUG = false; if (name == nullptr) { @@ -2741,7 +2587,8 @@ EGLFuncPointer FindPlatformImplAddr(const char* name) return nullptr; } if (!strcmp(name, sPlatformImplMap[i].name)) { - ALOGV("FindPlatformImplAddr found %llu for sPlatformImplMap[%i].address (%s)", (unsigned long long)sPlatformImplMap[i].address, i, name); + ALOGV("FindPlatformImplAddr found %llu for sPlatformImplMap[%i].address (%s)", + (unsigned long long)sPlatformImplMap[i].address, i, name); return sPlatformImplMap[i].address; } } |