#include <string>
#include "base/containers/span.h"
#include "base/trace_event/trace_event.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_egl_api_implementation.h"
#include "ui/gl/gl_enums.h"
#include "ui/gl/gl_implementation.h"
#include "ui/gl/gl_version_info.h"
namespace gl {
DriverEGL g_driver_egl = {};
void DriverEGL::InitializeStaticBindings(
GLGetProcAddressProc get_proc_address) {
TRACE_EVENT("gpu,startup", "DriverEGL::InitializeStaticBindings");
fn.eglAcquireExternalContextANGLEFn =
reinterpret_cast<eglAcquireExternalContextANGLEProc>(
get_proc_address("eglAcquireExternalContextANGLE"));
fn.eglBindAPIFn =
reinterpret_cast<eglBindAPIProc>(get_proc_address("eglBindAPI"));
fn.eglBindTexImageFn = reinterpret_cast<eglBindTexImageProc>(
get_proc_address("eglBindTexImage"));
fn.eglChooseConfigFn = reinterpret_cast<eglChooseConfigProc>(
get_proc_address("eglChooseConfig"));
fn.eglClientWaitSyncFn = reinterpret_cast<eglClientWaitSyncProc>(
get_proc_address("eglClientWaitSync"));
fn.eglClientWaitSyncKHRFn = reinterpret_cast<eglClientWaitSyncKHRProc>(
get_proc_address("eglClientWaitSyncKHR"));
fn.eglCopyBuffersFn =
reinterpret_cast<eglCopyBuffersProc>(get_proc_address("eglCopyBuffers"));
fn.eglCopyMetalSharedEventANGLEFn =
reinterpret_cast<eglCopyMetalSharedEventANGLEProc>(
get_proc_address("eglCopyMetalSharedEventANGLE"));
fn.eglCreateContextFn = reinterpret_cast<eglCreateContextProc>(
get_proc_address("eglCreateContext"));
fn.eglCreateImageFn =
reinterpret_cast<eglCreateImageProc>(get_proc_address("eglCreateImage"));
fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
get_proc_address("eglCreateImageKHR"));
fn.eglCreatePbufferFromClientBufferFn =
reinterpret_cast<eglCreatePbufferFromClientBufferProc>(
get_proc_address("eglCreatePbufferFromClientBuffer"));
fn.eglCreatePbufferSurfaceFn = reinterpret_cast<eglCreatePbufferSurfaceProc>(
get_proc_address("eglCreatePbufferSurface"));
fn.eglCreatePixmapSurfaceFn = reinterpret_cast<eglCreatePixmapSurfaceProc>(
get_proc_address("eglCreatePixmapSurface"));
fn.eglCreatePlatformPixmapSurfaceFn =
reinterpret_cast<eglCreatePlatformPixmapSurfaceProc>(
get_proc_address("eglCreatePlatformPixmapSurface"));
fn.eglCreatePlatformWindowSurfaceFn =
reinterpret_cast<eglCreatePlatformWindowSurfaceProc>(
get_proc_address("eglCreatePlatformWindowSurface"));
fn.eglCreateStreamKHRFn = reinterpret_cast<eglCreateStreamKHRProc>(
get_proc_address("eglCreateStreamKHR"));
fn.eglCreateStreamProducerD3DTextureANGLEFn =
reinterpret_cast<eglCreateStreamProducerD3DTextureANGLEProc>(
get_proc_address("eglCreateStreamProducerD3DTextureANGLE"));
fn.eglCreateSyncFn =
reinterpret_cast<eglCreateSyncProc>(get_proc_address("eglCreateSync"));
fn.eglCreateSyncKHRFn = reinterpret_cast<eglCreateSyncKHRProc>(
get_proc_address("eglCreateSyncKHR"));
fn.eglCreateWindowSurfaceFn = reinterpret_cast<eglCreateWindowSurfaceProc>(
get_proc_address("eglCreateWindowSurface"));
fn.eglDebugMessageControlKHRFn =
reinterpret_cast<eglDebugMessageControlKHRProc>(
get_proc_address("eglDebugMessageControlKHR"));
fn.eglDestroyContextFn = reinterpret_cast<eglDestroyContextProc>(
get_proc_address("eglDestroyContext"));
fn.eglDestroyImageFn = reinterpret_cast<eglDestroyImageProc>(
get_proc_address("eglDestroyImage"));
fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
get_proc_address("eglDestroyImageKHR"));
fn.eglDestroyStreamKHRFn = reinterpret_cast<eglDestroyStreamKHRProc>(
get_proc_address("eglDestroyStreamKHR"));
fn.eglDestroySurfaceFn = reinterpret_cast<eglDestroySurfaceProc>(
get_proc_address("eglDestroySurface"));
fn.eglDestroySyncFn =
reinterpret_cast<eglDestroySyncProc>(get_proc_address("eglDestroySync"));
fn.eglDestroySyncKHRFn = reinterpret_cast<eglDestroySyncKHRProc>(
get_proc_address("eglDestroySyncKHR"));
fn.eglDupNativeFenceFDANDROIDFn =
reinterpret_cast<eglDupNativeFenceFDANDROIDProc>(
get_proc_address("eglDupNativeFenceFDANDROID"));
fn.eglExportDMABUFImageMESAFn =
reinterpret_cast<eglExportDMABUFImageMESAProc>(
get_proc_address("eglExportDMABUFImageMESA"));
fn.eglExportDMABUFImageQueryMESAFn =
reinterpret_cast<eglExportDMABUFImageQueryMESAProc>(
get_proc_address("eglExportDMABUFImageQueryMESA"));
fn.eglExportVkImageANGLEFn = reinterpret_cast<eglExportVkImageANGLEProc>(
get_proc_address("eglExportVkImageANGLE"));
fn.eglGetCompositorTimingANDROIDFn =
reinterpret_cast<eglGetCompositorTimingANDROIDProc>(
get_proc_address("eglGetCompositorTimingANDROID"));
fn.eglGetCompositorTimingSupportedANDROIDFn =
reinterpret_cast<eglGetCompositorTimingSupportedANDROIDProc>(
get_proc_address("eglGetCompositorTimingSupportedANDROID"));
fn.eglGetConfigAttribFn = reinterpret_cast<eglGetConfigAttribProc>(
get_proc_address("eglGetConfigAttrib"));
fn.eglGetConfigsFn =
reinterpret_cast<eglGetConfigsProc>(get_proc_address("eglGetConfigs"));
fn.eglGetCurrentContextFn = reinterpret_cast<eglGetCurrentContextProc>(
get_proc_address("eglGetCurrentContext"));
fn.eglGetCurrentDisplayFn = reinterpret_cast<eglGetCurrentDisplayProc>(
get_proc_address("eglGetCurrentDisplay"));
fn.eglGetCurrentSurfaceFn = reinterpret_cast<eglGetCurrentSurfaceProc>(
get_proc_address("eglGetCurrentSurface"));
fn.eglGetDisplayFn =
reinterpret_cast<eglGetDisplayProc>(get_proc_address("eglGetDisplay"));
fn.eglGetErrorFn =
reinterpret_cast<eglGetErrorProc>(get_proc_address("eglGetError"));
fn.eglGetFrameTimestampsANDROIDFn =
reinterpret_cast<eglGetFrameTimestampsANDROIDProc>(
get_proc_address("eglGetFrameTimestampsANDROID"));
fn.eglGetFrameTimestampSupportedANDROIDFn =
reinterpret_cast<eglGetFrameTimestampSupportedANDROIDProc>(
get_proc_address("eglGetFrameTimestampSupportedANDROID"));
fn.eglGetMscRateANGLEFn = reinterpret_cast<eglGetMscRateANGLEProc>(
get_proc_address("eglGetMscRateANGLE"));
fn.eglGetNativeClientBufferANDROIDFn =
reinterpret_cast<eglGetNativeClientBufferANDROIDProc>(
get_proc_address("eglGetNativeClientBufferANDROID"));
fn.eglGetNextFrameIdANDROIDFn =
reinterpret_cast<eglGetNextFrameIdANDROIDProc>(
get_proc_address("eglGetNextFrameIdANDROID"));
fn.eglGetPlatformDisplayFn = reinterpret_cast<eglGetPlatformDisplayProc>(
get_proc_address("eglGetPlatformDisplay"));
fn.eglGetProcAddressFn = reinterpret_cast<eglGetProcAddressProc>(
get_proc_address("eglGetProcAddress"));
fn.eglGetSyncAttribFn = reinterpret_cast<eglGetSyncAttribProc>(
get_proc_address("eglGetSyncAttrib"));
fn.eglGetSyncAttribKHRFn = reinterpret_cast<eglGetSyncAttribKHRProc>(
get_proc_address("eglGetSyncAttribKHR"));
fn.eglGetSyncValuesCHROMIUMFn =
reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
get_proc_address("eglGetSyncValuesCHROMIUM"));
fn.eglHandleGPUSwitchANGLEFn = reinterpret_cast<eglHandleGPUSwitchANGLEProc>(
get_proc_address("eglHandleGPUSwitchANGLE"));
fn.eglImageFlushExternalEXTFn =
reinterpret_cast<eglImageFlushExternalEXTProc>(
get_proc_address("eglImageFlushExternalEXT"));
fn.eglInitializeFn =
reinterpret_cast<eglInitializeProc>(get_proc_address("eglInitialize"));
fn.eglLabelObjectKHRFn = reinterpret_cast<eglLabelObjectKHRProc>(
get_proc_address("eglLabelObjectKHR"));
fn.eglLockVulkanQueueANGLEFn = reinterpret_cast<eglLockVulkanQueueANGLEProc>(
get_proc_address("eglLockVulkanQueueANGLE"));
fn.eglMakeCurrentFn =
reinterpret_cast<eglMakeCurrentProc>(get_proc_address("eglMakeCurrent"));
fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
get_proc_address("eglPostSubBufferNV"));
fn.eglPresentationTimeANDROIDFn =
reinterpret_cast<eglPresentationTimeANDROIDProc>(
get_proc_address("eglPresentationTimeANDROID"));
fn.eglQueryAPIFn =
reinterpret_cast<eglQueryAPIProc>(get_proc_address("eglQueryAPI"));
fn.eglQueryContextFn = reinterpret_cast<eglQueryContextProc>(
get_proc_address("eglQueryContext"));
fn.eglQueryDebugKHRFn = reinterpret_cast<eglQueryDebugKHRProc>(
get_proc_address("eglQueryDebugKHR"));
fn.eglQueryDeviceAttribEXTFn = reinterpret_cast<eglQueryDeviceAttribEXTProc>(
get_proc_address("eglQueryDeviceAttribEXT"));
fn.eglQueryDevicesEXTFn = reinterpret_cast<eglQueryDevicesEXTProc>(
get_proc_address("eglQueryDevicesEXT"));
fn.eglQueryDeviceStringEXTFn = reinterpret_cast<eglQueryDeviceStringEXTProc>(
get_proc_address("eglQueryDeviceStringEXT"));
fn.eglQueryDisplayAttribANGLEFn =
reinterpret_cast<eglQueryDisplayAttribANGLEProc>(
get_proc_address("eglQueryDisplayAttribANGLE"));
fn.eglQueryDisplayAttribEXTFn =
reinterpret_cast<eglQueryDisplayAttribEXTProc>(
get_proc_address("eglQueryDisplayAttribEXT"));
fn.eglQueryDmaBufFormatsEXTFn =
reinterpret_cast<eglQueryDmaBufFormatsEXTProc>(
get_proc_address("eglQueryDmaBufFormatsEXT"));
fn.eglQueryDmaBufModifiersEXTFn =
reinterpret_cast<eglQueryDmaBufModifiersEXTProc>(
get_proc_address("eglQueryDmaBufModifiersEXT"));
fn.eglQueryStreamKHRFn = reinterpret_cast<eglQueryStreamKHRProc>(
get_proc_address("eglQueryStreamKHR"));
fn.eglQueryStreamu64KHRFn = reinterpret_cast<eglQueryStreamu64KHRProc>(
get_proc_address("eglQueryStreamu64KHR"));
fn.eglQueryStringFn =
reinterpret_cast<eglQueryStringProc>(get_proc_address("eglQueryString"));
fn.eglQueryStringiANGLEFn = reinterpret_cast<eglQueryStringiANGLEProc>(
get_proc_address("eglQueryStringiANGLE"));
fn.eglQuerySurfaceFn = reinterpret_cast<eglQuerySurfaceProc>(
get_proc_address("eglQuerySurface"));
fn.eglQuerySurfacePointerANGLEFn =
reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
get_proc_address("eglQuerySurfacePointerANGLE"));
fn.eglReacquireHighPowerGPUANGLEFn =
reinterpret_cast<eglReacquireHighPowerGPUANGLEProc>(
get_proc_address("eglReacquireHighPowerGPUANGLE"));
fn.eglReleaseExternalContextANGLEFn =
reinterpret_cast<eglReleaseExternalContextANGLEProc>(
get_proc_address("eglReleaseExternalContextANGLE"));
fn.eglReleaseHighPowerGPUANGLEFn =
reinterpret_cast<eglReleaseHighPowerGPUANGLEProc>(
get_proc_address("eglReleaseHighPowerGPUANGLE"));
fn.eglReleaseTexImageFn = reinterpret_cast<eglReleaseTexImageProc>(
get_proc_address("eglReleaseTexImage"));
fn.eglReleaseThreadFn = reinterpret_cast<eglReleaseThreadProc>(
get_proc_address("eglReleaseThread"));
fn.eglSetBlobCacheFuncsANDROIDFn =
reinterpret_cast<eglSetBlobCacheFuncsANDROIDProc>(
get_proc_address("eglSetBlobCacheFuncsANDROID"));
#if BUILDFLAG(IS_ARKWEB)
fn.eglSetDamageRegionKHRFn = reinterpret_cast<eglSetDamageRegionKHRProc>(
get_proc_address("eglSetDamageRegionKHR"));
#endif
fn.eglSetValidationEnabledANGLEFn =
reinterpret_cast<eglSetValidationEnabledANGLEProc>(
get_proc_address("eglSetValidationEnabledANGLE"));
fn.eglStreamAttribKHRFn = reinterpret_cast<eglStreamAttribKHRProc>(
get_proc_address("eglStreamAttribKHR"));
fn.eglStreamConsumerAcquireKHRFn =
reinterpret_cast<eglStreamConsumerAcquireKHRProc>(
get_proc_address("eglStreamConsumerAcquireKHR"));
fn.eglStreamConsumerGLTextureExternalAttribsNVFn =
reinterpret_cast<eglStreamConsumerGLTextureExternalAttribsNVProc>(
get_proc_address("eglStreamConsumerGLTextureExternalAttribsNV"));
fn.eglStreamConsumerGLTextureExternalKHRFn =
reinterpret_cast<eglStreamConsumerGLTextureExternalKHRProc>(
get_proc_address("eglStreamConsumerGLTextureExternalKHR"));
fn.eglStreamConsumerReleaseKHRFn =
reinterpret_cast<eglStreamConsumerReleaseKHRProc>(
get_proc_address("eglStreamConsumerReleaseKHR"));
fn.eglStreamPostD3DTextureANGLEFn =
reinterpret_cast<eglStreamPostD3DTextureANGLEProc>(
get_proc_address("eglStreamPostD3DTextureANGLE"));
fn.eglSurfaceAttribFn = reinterpret_cast<eglSurfaceAttribProc>(
get_proc_address("eglSurfaceAttrib"));
fn.eglSwapBuffersFn =
reinterpret_cast<eglSwapBuffersProc>(get_proc_address("eglSwapBuffers"));
fn.eglSwapBuffersWithDamageKHRFn =
reinterpret_cast<eglSwapBuffersWithDamageKHRProc>(
get_proc_address("eglSwapBuffersWithDamageKHR"));
fn.eglSwapIntervalFn = reinterpret_cast<eglSwapIntervalProc>(
get_proc_address("eglSwapInterval"));
fn.eglTerminateFn =
reinterpret_cast<eglTerminateProc>(get_proc_address("eglTerminate"));
fn.eglUnlockVulkanQueueANGLEFn =
reinterpret_cast<eglUnlockVulkanQueueANGLEProc>(
get_proc_address("eglUnlockVulkanQueueANGLE"));
fn.eglWaitClientFn =
reinterpret_cast<eglWaitClientProc>(get_proc_address("eglWaitClient"));
fn.eglWaitGLFn =
reinterpret_cast<eglWaitGLProc>(get_proc_address("eglWaitGL"));
fn.eglWaitNativeFn =
reinterpret_cast<eglWaitNativeProc>(get_proc_address("eglWaitNative"));
fn.eglWaitSyncFn =
reinterpret_cast<eglWaitSyncProc>(get_proc_address("eglWaitSync"));
fn.eglWaitSyncKHRFn =
reinterpret_cast<eglWaitSyncKHRProc>(get_proc_address("eglWaitSyncKHR"));
fn.eglWaitUntilWorkScheduledANGLEFn =
reinterpret_cast<eglWaitUntilWorkScheduledANGLEProc>(
get_proc_address("eglWaitUntilWorkScheduledANGLE"));
}
void ClientExtensionsEGL::InitializeClientExtensionSettings() {
TRACE_EVENT("gpu,startup", "DriverEGL::InitializeClientExtensionSettings");
std::string client_extensions(GetClientExtensions());
[[maybe_unused]] gfx::ExtensionSet extensions(
gfx::MakeExtensionSet(client_extensions));
b_EGL_ANGLE_display_power_preference =
gfx::HasExtension(extensions, "EGL_ANGLE_display_power_preference");
b_EGL_ANGLE_feature_control =
gfx::HasExtension(extensions, "EGL_ANGLE_feature_control");
b_EGL_ANGLE_no_error = gfx::HasExtension(extensions, "EGL_ANGLE_no_error");
b_EGL_ANGLE_platform_angle =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle");
b_EGL_ANGLE_platform_angle_d3d =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_d3d");
b_EGL_ANGLE_platform_angle_device_id =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_device_id");
b_EGL_ANGLE_platform_angle_device_type_egl_angle = gfx::HasExtension(
extensions, "EGL_ANGLE_platform_angle_device_type_egl_angle");
b_EGL_ANGLE_platform_angle_device_type_swiftshader = gfx::HasExtension(
extensions, "EGL_ANGLE_platform_angle_device_type_swiftshader");
b_EGL_ANGLE_platform_angle_metal =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_metal");
b_EGL_ANGLE_platform_angle_null =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_null");
b_EGL_ANGLE_platform_angle_opengl =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_opengl");
b_EGL_ANGLE_platform_angle_vulkan =
gfx::HasExtension(extensions, "EGL_ANGLE_platform_angle_vulkan");
b_EGL_EXT_device_base = gfx::HasExtension(extensions, "EGL_EXT_device_base");
b_EGL_EXT_device_enumeration =
gfx::HasExtension(extensions, "EGL_EXT_device_enumeration");
b_EGL_EXT_device_query =
gfx::HasExtension(extensions, "EGL_EXT_device_query");
b_EGL_EXT_platform_base =
gfx::HasExtension(extensions, "EGL_EXT_platform_base");
b_EGL_EXT_platform_device =
gfx::HasExtension(extensions, "EGL_EXT_platform_device");
b_EGL_KHR_debug = gfx::HasExtension(extensions, "EGL_KHR_debug");
b_EGL_KHR_platform_gbm =
gfx::HasExtension(extensions, "EGL_KHR_platform_gbm");
b_EGL_MESA_platform_surfaceless =
gfx::HasExtension(extensions, "EGL_MESA_platform_surfaceless");
}
void DisplayExtensionsEGL::InitializeExtensionSettings(EGLDisplay display) {
TRACE_EVENT("gpu,startup", "DriverEGL::InitializeExtensionSettings");
std::string platform_extensions(GetPlatformExtensions(display));
[[maybe_unused]] gfx::ExtensionSet extensions(
gfx::MakeExtensionSet(platform_extensions));
b_EGL_ANDROID_blob_cache =
gfx::HasExtension(extensions, "EGL_ANDROID_blob_cache");
b_EGL_ANDROID_create_native_client_buffer =
gfx::HasExtension(extensions, "EGL_ANDROID_create_native_client_buffer");
b_EGL_ANDROID_front_buffer_auto_refresh =
gfx::HasExtension(extensions, "EGL_ANDROID_front_buffer_auto_refresh");
b_EGL_ANDROID_get_frame_timestamps =
gfx::HasExtension(extensions, "EGL_ANDROID_get_frame_timestamps");
b_EGL_ANDROID_get_native_client_buffer =
gfx::HasExtension(extensions, "EGL_ANDROID_get_native_client_buffer");
b_EGL_ANDROID_native_fence_sync =
gfx::HasExtension(extensions, "EGL_ANDROID_native_fence_sync");
b_EGL_ANDROID_presentation_time =
gfx::HasExtension(extensions, "EGL_ANDROID_presentation_time");
b_EGL_ANGLE_context_virtualization =
gfx::HasExtension(extensions, "EGL_ANGLE_context_virtualization");
b_EGL_ANGLE_create_context_backwards_compatible = gfx::HasExtension(
extensions, "EGL_ANGLE_create_context_backwards_compatible");
b_EGL_ANGLE_create_context_client_arrays =
gfx::HasExtension(extensions, "EGL_ANGLE_create_context_client_arrays");
b_EGL_ANGLE_create_context_passthrough_shaders = gfx::HasExtension(
extensions, "EGL_ANGLE_create_context_passthrough_shaders");
b_EGL_ANGLE_create_context_webgl_compatibility = gfx::HasExtension(
extensions, "EGL_ANGLE_create_context_webgl_compatibility");
b_EGL_ANGLE_d3d_share_handle_client_buffer =
gfx::HasExtension(extensions, "EGL_ANGLE_d3d_share_handle_client_buffer");
b_EGL_ANGLE_device_vulkan =
gfx::HasExtension(extensions, "EGL_ANGLE_device_vulkan");
b_EGL_ANGLE_display_semaphore_share_group =
gfx::HasExtension(extensions, "EGL_ANGLE_display_semaphore_share_group");
b_EGL_ANGLE_display_texture_share_group =
gfx::HasExtension(extensions, "EGL_ANGLE_display_texture_share_group");
b_EGL_ANGLE_external_context_and_surface =
gfx::HasExtension(extensions, "EGL_ANGLE_external_context_and_surface");
b_EGL_ANGLE_global_fence_sync =
gfx::HasExtension(extensions, "EGL_ANGLE_global_fence_sync");
b_EGL_ANGLE_iosurface_client_buffer =
gfx::HasExtension(extensions, "EGL_ANGLE_iosurface_client_buffer");
b_EGL_ANGLE_keyed_mutex =
gfx::HasExtension(extensions, "EGL_ANGLE_keyed_mutex");
b_EGL_ANGLE_metal_shared_event_sync =
gfx::HasExtension(extensions, "EGL_ANGLE_metal_shared_event_sync");
b_EGL_ANGLE_no_error = gfx::HasExtension(extensions, "EGL_ANGLE_no_error");
b_EGL_ANGLE_power_preference =
gfx::HasExtension(extensions, "EGL_ANGLE_power_preference");
b_EGL_ANGLE_query_surface_pointer =
gfx::HasExtension(extensions, "EGL_ANGLE_query_surface_pointer");
b_EGL_ANGLE_robust_resource_initialization =
gfx::HasExtension(extensions, "EGL_ANGLE_robust_resource_initialization");
b_EGL_ANGLE_stream_producer_d3d_texture =
gfx::HasExtension(extensions, "EGL_ANGLE_stream_producer_d3d_texture");
b_EGL_ANGLE_surface_d3d_texture_2d_share_handle = gfx::HasExtension(
extensions, "EGL_ANGLE_surface_d3d_texture_2d_share_handle");
b_EGL_ANGLE_surface_orientation =
gfx::HasExtension(extensions, "EGL_ANGLE_surface_orientation");
b_EGL_ANGLE_sync_control_rate =
gfx::HasExtension(extensions, "EGL_ANGLE_sync_control_rate");
b_EGL_ANGLE_vulkan_image =
gfx::HasExtension(extensions, "EGL_ANGLE_vulkan_image");
b_EGL_ANGLE_wait_until_work_scheduled =
gfx::HasExtension(extensions, "EGL_ANGLE_wait_until_work_scheduled");
b_EGL_ANGLE_window_fixed_size =
gfx::HasExtension(extensions, "EGL_ANGLE_window_fixed_size");
b_EGL_ARM_implicit_external_sync =
gfx::HasExtension(extensions, "EGL_ARM_implicit_external_sync");
b_EGL_CHROMIUM_create_context_bind_generates_resource = gfx::HasExtension(
extensions, "EGL_CHROMIUM_create_context_bind_generates_resource");
b_EGL_CHROMIUM_sync_control =
gfx::HasExtension(extensions, "EGL_CHROMIUM_sync_control");
b_EGL_EXT_create_context_robustness =
gfx::HasExtension(extensions, "EGL_EXT_create_context_robustness");
b_EGL_EXT_gl_colorspace_display_p3 =
gfx::HasExtension(extensions, "EGL_EXT_gl_colorspace_display_p3");
b_EGL_EXT_gl_colorspace_display_p3_passthrough = gfx::HasExtension(
extensions, "EGL_EXT_gl_colorspace_display_p3_passthrough");
b_EGL_EXT_image_dma_buf_import =
gfx::HasExtension(extensions, "EGL_EXT_image_dma_buf_import");
b_EGL_EXT_image_dma_buf_import_modifiers =
gfx::HasExtension(extensions, "EGL_EXT_image_dma_buf_import_modifiers");
b_EGL_EXT_image_flush_external =
gfx::HasExtension(extensions, "EGL_EXT_image_flush_external");
b_EGL_EXT_pixel_format_float =
gfx::HasExtension(extensions, "EGL_EXT_pixel_format_float");
b_EGL_IMG_context_priority =
gfx::HasExtension(extensions, "EGL_IMG_context_priority");
b_EGL_KHR_create_context =
gfx::HasExtension(extensions, "EGL_KHR_create_context");
b_EGL_KHR_fence_sync = gfx::HasExtension(extensions, "EGL_KHR_fence_sync");
b_EGL_KHR_gl_colorspace =
gfx::HasExtension(extensions, "EGL_KHR_gl_colorspace");
b_EGL_KHR_gl_texture_2D_image =
gfx::HasExtension(extensions, "EGL_KHR_gl_texture_2D_image");
b_EGL_KHR_image = gfx::HasExtension(extensions, "EGL_KHR_image");
b_EGL_KHR_image_base = gfx::HasExtension(extensions, "EGL_KHR_image_base");
b_EGL_KHR_no_config_context =
gfx::HasExtension(extensions, "EGL_KHR_no_config_context");
#if BUILDFLAG(IS_ARKWEB)
b_EGL_KHR_partial_update =
gfx::HasExtension(extensions, "EGL_KHR_partial_update");
#endif
b_EGL_KHR_stream = gfx::HasExtension(extensions, "EGL_KHR_stream");
b_EGL_KHR_stream_consumer_gltexture =
gfx::HasExtension(extensions, "EGL_KHR_stream_consumer_gltexture");
b_EGL_KHR_surfaceless_context =
gfx::HasExtension(extensions, "EGL_KHR_surfaceless_context");
b_EGL_KHR_swap_buffers_with_damage =
gfx::HasExtension(extensions, "EGL_KHR_swap_buffers_with_damage");
b_EGL_KHR_wait_sync = gfx::HasExtension(extensions, "EGL_KHR_wait_sync");
b_EGL_MESA_image_dma_buf_export =
gfx::HasExtension(extensions, "EGL_MESA_image_dma_buf_export");
b_EGL_NOK_texture_from_pixmap =
gfx::HasExtension(extensions, "EGL_NOK_texture_from_pixmap");
b_EGL_NV_post_sub_buffer =
gfx::HasExtension(extensions, "EGL_NV_post_sub_buffer");
b_EGL_NV_robustness_video_memory_purge =
gfx::HasExtension(extensions, "EGL_NV_robustness_video_memory_purge");
b_EGL_NV_stream_consumer_gltexture_yuv =
gfx::HasExtension(extensions, "EGL_NV_stream_consumer_gltexture_yuv");
b_GL_CHROMIUM_egl_android_native_fence_sync_hack = gfx::HasExtension(
extensions, "GL_CHROMIUM_egl_android_native_fence_sync_hack");
b_GL_CHROMIUM_egl_khr_fence_sync_hack =
gfx::HasExtension(extensions, "GL_CHROMIUM_egl_khr_fence_sync_hack");
}
void DriverEGL::ClearBindings() {
*this = {};
}
void EGLApiBase::eglAcquireExternalContextANGLEFn(EGLDisplay dpy,
EGLSurface readAndDraw) {
driver_->fn.eglAcquireExternalContextANGLEFn(dpy, readAndDraw);
}
EGLBoolean EGLApiBase::eglBindAPIFn(EGLenum api) {
return driver_->fn.eglBindAPIFn(api);
}
EGLBoolean EGLApiBase::eglBindTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
return driver_->fn.eglBindTexImageFn(dpy, surface, buffer);
}
EGLBoolean EGLApiBase::eglChooseConfigFn(EGLDisplay dpy,
const EGLint* attrib_list,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
return driver_->fn.eglChooseConfigFn(dpy, attrib_list, configs, config_size,
num_config);
}
EGLint EGLApiBase::eglClientWaitSyncFn(EGLDisplay dpy,
EGLSync sync,
EGLint flags,
EGLTime timeout) {
return driver_->fn.eglClientWaitSyncFn(dpy, sync, flags, timeout);
}
EGLint EGLApiBase::eglClientWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags,
EGLTimeKHR timeout) {
return driver_->fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
}
EGLBoolean EGLApiBase::eglCopyBuffersFn(EGLDisplay dpy,
EGLSurface surface,
EGLNativePixmapType target) {
return driver_->fn.eglCopyBuffersFn(dpy, surface, target);
}
void* EGLApiBase::eglCopyMetalSharedEventANGLEFn(EGLDisplay dpy, EGLSync sync) {
return driver_->fn.eglCopyMetalSharedEventANGLEFn(dpy, sync);
}
EGLContext EGLApiBase::eglCreateContextFn(EGLDisplay dpy,
EGLConfig config,
EGLContext share_context,
const EGLint* attrib_list) {
return driver_->fn.eglCreateContextFn(dpy, config, share_context,
attrib_list);
}
EGLImage EGLApiBase::eglCreateImageFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
return driver_->fn.eglCreateImageFn(dpy, ctx, target, buffer, attrib_list);
}
EGLImageKHR EGLApiBase::eglCreateImageKHRFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint* attrib_list) {
return driver_->fn.eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
}
EGLSurface EGLApiBase::eglCreatePbufferFromClientBufferFn(
EGLDisplay dpy,
EGLenum buftype,
void* buffer,
EGLConfig config,
const EGLint* attrib_list) {
return driver_->fn.eglCreatePbufferFromClientBufferFn(dpy, buftype, buffer,
config, attrib_list);
}
EGLSurface EGLApiBase::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
EGLConfig config,
const EGLint* attrib_list) {
return driver_->fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
}
EGLSurface EGLApiBase::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint* attrib_list) {
return driver_->fn.eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
}
EGLSurface EGLApiBase::eglCreatePlatformPixmapSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_pixmap,
const EGLAttrib* attrib_list) {
return driver_->fn.eglCreatePlatformPixmapSurfaceFn(
dpy, config, native_pixmap, attrib_list);
}
EGLSurface EGLApiBase::eglCreatePlatformWindowSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_window,
const EGLAttrib* attrib_list) {
return driver_->fn.eglCreatePlatformWindowSurfaceFn(
dpy, config, native_window, attrib_list);
}
EGLStreamKHR EGLApiBase::eglCreateStreamKHRFn(EGLDisplay dpy,
const EGLint* attrib_list) {
return driver_->fn.eglCreateStreamKHRFn(dpy, attrib_list);
}
EGLBoolean EGLApiBase::eglCreateStreamProducerD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
return driver_->fn.eglCreateStreamProducerD3DTextureANGLEFn(dpy, stream,
attrib_list);
}
EGLSync EGLApiBase::eglCreateSyncFn(EGLDisplay dpy,
EGLenum type,
const EGLAttrib* attrib_list) {
return driver_->fn.eglCreateSyncFn(dpy, type, attrib_list);
}
EGLSyncKHR EGLApiBase::eglCreateSyncKHRFn(EGLDisplay dpy,
EGLenum type,
const EGLint* attrib_list) {
return driver_->fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
}
EGLSurface EGLApiBase::eglCreateWindowSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativeWindowType win,
const EGLint* attrib_list) {
return driver_->fn.eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
}
EGLint EGLApiBase::eglDebugMessageControlKHRFn(EGLDEBUGPROCKHR callback,
const EGLAttrib* attrib_list) {
return driver_->fn.eglDebugMessageControlKHRFn(callback, attrib_list);
}
EGLBoolean EGLApiBase::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
return driver_->fn.eglDestroyContextFn(dpy, ctx);
}
EGLBoolean EGLApiBase::eglDestroyImageFn(EGLDisplay dpy, EGLImage image) {
return driver_->fn.eglDestroyImageFn(dpy, image);
}
EGLBoolean EGLApiBase::eglDestroyImageKHRFn(EGLDisplay dpy, EGLImageKHR image) {
return driver_->fn.eglDestroyImageKHRFn(dpy, image);
}
EGLBoolean EGLApiBase::eglDestroyStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
return driver_->fn.eglDestroyStreamKHRFn(dpy, stream);
}
EGLBoolean EGLApiBase::eglDestroySurfaceFn(EGLDisplay dpy, EGLSurface surface) {
return driver_->fn.eglDestroySurfaceFn(dpy, surface);
}
EGLBoolean EGLApiBase::eglDestroySyncFn(EGLDisplay dpy, EGLSync sync) {
return driver_->fn.eglDestroySyncFn(dpy, sync);
}
EGLBoolean EGLApiBase::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
return driver_->fn.eglDestroySyncKHRFn(dpy, sync);
}
EGLint EGLApiBase::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
EGLSyncKHR sync) {
return driver_->fn.eglDupNativeFenceFDANDROIDFn(dpy, sync);
}
EGLBoolean EGLApiBase::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
EGLImageKHR image,
int* fds,
EGLint* strides,
EGLint* offsets) {
return driver_->fn.eglExportDMABUFImageMESAFn(dpy, image, fds, strides,
offsets);
}
EGLBoolean EGLApiBase::eglExportDMABUFImageQueryMESAFn(
EGLDisplay dpy,
EGLImageKHR image,
int* fourcc,
int* num_planes,
EGLuint64KHR* modifiers) {
return driver_->fn.eglExportDMABUFImageQueryMESAFn(dpy, image, fourcc,
num_planes, modifiers);
}
EGLBoolean EGLApiBase::eglExportVkImageANGLEFn(EGLDisplay dpy,
EGLImageKHR image,
void* vk_image,
void* vk_image_create_info) {
return driver_->fn.eglExportVkImageANGLEFn(dpy, image, vk_image,
vk_image_create_info);
}
EGLBoolean EGLApiBase::eglGetCompositorTimingANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint numTimestamps,
EGLint* names,
EGLnsecsANDROID* values) {
return driver_->fn.eglGetCompositorTimingANDROIDFn(
dpy, surface, numTimestamps, names, values);
}
EGLBoolean EGLApiBase::eglGetCompositorTimingSupportedANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
return driver_->fn.eglGetCompositorTimingSupportedANDROIDFn(dpy, surface,
timestamp);
}
EGLBoolean EGLApiBase::eglGetConfigAttribFn(EGLDisplay dpy,
EGLConfig config,
EGLint attribute,
EGLint* value) {
return driver_->fn.eglGetConfigAttribFn(dpy, config, attribute, value);
}
EGLBoolean EGLApiBase::eglGetConfigsFn(EGLDisplay dpy,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
return driver_->fn.eglGetConfigsFn(dpy, configs, config_size, num_config);
}
EGLContext EGLApiBase::eglGetCurrentContextFn(void) {
return driver_->fn.eglGetCurrentContextFn();
}
EGLDisplay EGLApiBase::eglGetCurrentDisplayFn(void) {
return driver_->fn.eglGetCurrentDisplayFn();
}
EGLSurface EGLApiBase::eglGetCurrentSurfaceFn(EGLint readdraw) {
return driver_->fn.eglGetCurrentSurfaceFn(readdraw);
}
EGLDisplay EGLApiBase::eglGetDisplayFn(EGLNativeDisplayType display_id) {
return driver_->fn.eglGetDisplayFn(display_id);
}
EGLint EGLApiBase::eglGetErrorFn(void) {
return driver_->fn.eglGetErrorFn();
}
EGLBoolean EGLApiBase::eglGetFrameTimestampsANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
EGLint* timestamps,
EGLnsecsANDROID* values) {
return driver_->fn.eglGetFrameTimestampsANDROIDFn(
dpy, surface, frameId, numTimestamps, timestamps, values);
}
EGLBoolean EGLApiBase::eglGetFrameTimestampSupportedANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
return driver_->fn.eglGetFrameTimestampSupportedANDROIDFn(dpy, surface,
timestamp);
}
EGLBoolean EGLApiBase::eglGetMscRateANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* numerator,
EGLint* denominator) {
return driver_->fn.eglGetMscRateANGLEFn(dpy, surface, numerator, denominator);
}
EGLClientBuffer EGLApiBase::eglGetNativeClientBufferANDROIDFn(
const struct AHardwareBuffer* ahardwarebuffer) {
return driver_->fn.eglGetNativeClientBufferANDROIDFn(ahardwarebuffer);
}
EGLBoolean EGLApiBase::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR* frameId) {
return driver_->fn.eglGetNextFrameIdANDROIDFn(dpy, surface, frameId);
}
EGLDisplay EGLApiBase::eglGetPlatformDisplayFn(EGLenum platform,
void* native_display,
const EGLAttrib* attrib_list) {
return driver_->fn.eglGetPlatformDisplayFn(platform, native_display,
attrib_list);
}
__eglMustCastToProperFunctionPointerType EGLApiBase::eglGetProcAddressFn(
const char* procname) {
return driver_->fn.eglGetProcAddressFn(procname);
}
EGLBoolean EGLApiBase::eglGetSyncAttribFn(EGLDisplay dpy,
EGLSync sync,
EGLint attribute,
EGLAttrib* value) {
return driver_->fn.eglGetSyncAttribFn(dpy, sync, attribute, value);
}
EGLBoolean EGLApiBase::eglGetSyncAttribKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint attribute,
EGLint* value) {
return driver_->fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
}
EGLBoolean EGLApiBase::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64CHROMIUM* ust,
EGLuint64CHROMIUM* msc,
EGLuint64CHROMIUM* sbc) {
return driver_->fn.eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
}
void EGLApiBase::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) {
driver_->fn.eglHandleGPUSwitchANGLEFn(dpy);
}
EGLBoolean EGLApiBase::eglImageFlushExternalEXTFn(
EGLDisplay dpy,
EGLImageKHR image,
const EGLAttrib* attrib_list) {
return driver_->fn.eglImageFlushExternalEXTFn(dpy, image, attrib_list);
}
EGLBoolean EGLApiBase::eglInitializeFn(EGLDisplay dpy,
EGLint* major,
EGLint* minor) {
return driver_->fn.eglInitializeFn(dpy, major, minor);
}
EGLint EGLApiBase::eglLabelObjectKHRFn(EGLDisplay display,
EGLenum objectType,
EGLObjectKHR object,
EGLLabelKHR label) {
return driver_->fn.eglLabelObjectKHRFn(display, objectType, object, label);
}
void EGLApiBase::eglLockVulkanQueueANGLEFn(EGLDisplay dpy) {
driver_->fn.eglLockVulkanQueueANGLEFn(dpy);
}
EGLBoolean EGLApiBase::eglMakeCurrentFn(EGLDisplay dpy,
EGLSurface draw,
EGLSurface read,
EGLContext ctx) {
return driver_->fn.eglMakeCurrentFn(dpy, draw, read, ctx);
}
EGLBoolean EGLApiBase::eglPostSubBufferNVFn(EGLDisplay dpy,
EGLSurface surface,
EGLint x,
EGLint y,
EGLint width,
EGLint height) {
return driver_->fn.eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
}
EGLBoolean EGLApiBase::eglPresentationTimeANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLnsecsANDROID time) {
return driver_->fn.eglPresentationTimeANDROIDFn(dpy, surface, time);
}
EGLenum EGLApiBase::eglQueryAPIFn(void) {
return driver_->fn.eglQueryAPIFn();
}
EGLBoolean EGLApiBase::eglQueryContextFn(EGLDisplay dpy,
EGLContext ctx,
EGLint attribute,
EGLint* value) {
return driver_->fn.eglQueryContextFn(dpy, ctx, attribute, value);
}
EGLBoolean EGLApiBase::eglQueryDebugKHRFn(EGLint attribute, EGLAttrib* value) {
return driver_->fn.eglQueryDebugKHRFn(attribute, value);
}
EGLBoolean EGLApiBase::eglQueryDeviceAttribEXTFn(EGLDeviceEXT device,
EGLint attribute,
EGLAttrib* value) {
return driver_->fn.eglQueryDeviceAttribEXTFn(device, attribute, value);
}
EGLBoolean EGLApiBase::eglQueryDevicesEXTFn(EGLint max_devices,
EGLDeviceEXT* devices,
EGLint* num_devices) {
return driver_->fn.eglQueryDevicesEXTFn(max_devices, devices, num_devices);
}
const char* EGLApiBase::eglQueryDeviceStringEXTFn(EGLDeviceEXT device,
EGLint name) {
return driver_->fn.eglQueryDeviceStringEXTFn(device, name);
}
EGLBoolean EGLApiBase::eglQueryDisplayAttribANGLEFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
return driver_->fn.eglQueryDisplayAttribANGLEFn(dpy, attribute, value);
}
EGLBoolean EGLApiBase::eglQueryDisplayAttribEXTFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
return driver_->fn.eglQueryDisplayAttribEXTFn(dpy, attribute, value);
}
EGLBoolean EGLApiBase::eglQueryDmaBufFormatsEXTFn(EGLDisplay dpy,
EGLint max_formats,
EGLint* formats,
EGLint* num_formats) {
return driver_->fn.eglQueryDmaBufFormatsEXTFn(dpy, max_formats, formats,
num_formats);
}
EGLBoolean EGLApiBase::eglQueryDmaBufModifiersEXTFn(EGLDisplay dpy,
EGLint format,
EGLint max_modifiers,
EGLuint64KHR* modifiers,
EGLBoolean* external_only,
EGLint* num_modifiers) {
return driver_->fn.eglQueryDmaBufModifiersEXTFn(
dpy, format, max_modifiers, modifiers, external_only, num_modifiers);
}
EGLBoolean EGLApiBase::eglQueryStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint* value) {
return driver_->fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
}
EGLBoolean EGLApiBase::eglQueryStreamu64KHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLuint64KHR* value) {
return driver_->fn.eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
}
const char* EGLApiBase::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
return driver_->fn.eglQueryStringFn(dpy, name);
}
const char* EGLApiBase::eglQueryStringiANGLEFn(EGLDisplay dpy,
EGLint name,
EGLint index) {
return driver_->fn.eglQueryStringiANGLEFn(dpy, name, index);
}
EGLBoolean EGLApiBase::eglQuerySurfaceFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint* value) {
return driver_->fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
}
EGLBoolean EGLApiBase::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
void** value) {
return driver_->fn.eglQuerySurfacePointerANGLEFn(dpy, surface, attribute,
value);
}
void EGLApiBase::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy,
EGLContext ctx) {
driver_->fn.eglReacquireHighPowerGPUANGLEFn(dpy, ctx);
}
void EGLApiBase::eglReleaseExternalContextANGLEFn(EGLDisplay dpy) {
driver_->fn.eglReleaseExternalContextANGLEFn(dpy);
}
void EGLApiBase::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) {
driver_->fn.eglReleaseHighPowerGPUANGLEFn(dpy, ctx);
}
EGLBoolean EGLApiBase::eglReleaseTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
return driver_->fn.eglReleaseTexImageFn(dpy, surface, buffer);
}
EGLBoolean EGLApiBase::eglReleaseThreadFn(void) {
return driver_->fn.eglReleaseThreadFn();
}
void EGLApiBase::eglSetBlobCacheFuncsANDROIDFn(EGLDisplay dpy,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get) {
driver_->fn.eglSetBlobCacheFuncsANDROIDFn(dpy, set, get);
}
#if BUILDFLAG(IS_ARKWEB)
EGLBoolean EGLApiBase::eglSetDamageRegionKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
return driver_->fn.eglSetDamageRegionKHRFn(dpy, surface, rects, n_rects);
}
#endif
void EGLApiBase::eglSetValidationEnabledANGLEFn(EGLBoolean validationState) {
driver_->fn.eglSetValidationEnabledANGLEFn(validationState);
}
EGLBoolean EGLApiBase::eglStreamAttribKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint value) {
return driver_->fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
}
EGLBoolean EGLApiBase::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
return driver_->fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
}
EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalAttribsNVFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
return driver_->fn.eglStreamConsumerGLTextureExternalAttribsNVFn(dpy, stream,
attrib_list);
}
EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalKHRFn(
EGLDisplay dpy,
EGLStreamKHR stream) {
return driver_->fn.eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
}
EGLBoolean EGLApiBase::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
return driver_->fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
}
EGLBoolean EGLApiBase::eglStreamPostD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
void* texture,
const EGLAttrib* attrib_list) {
return driver_->fn.eglStreamPostD3DTextureANGLEFn(dpy, stream, texture,
attrib_list);
}
EGLBoolean EGLApiBase::eglSurfaceAttribFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint value) {
return driver_->fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
}
EGLBoolean EGLApiBase::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
return driver_->fn.eglSwapBuffersFn(dpy, surface);
}
EGLBoolean EGLApiBase::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
return driver_->fn.eglSwapBuffersWithDamageKHRFn(dpy, surface, rects,
n_rects);
}
EGLBoolean EGLApiBase::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
return driver_->fn.eglSwapIntervalFn(dpy, interval);
}
EGLBoolean EGLApiBase::eglTerminateFn(EGLDisplay dpy) {
return driver_->fn.eglTerminateFn(dpy);
}
void EGLApiBase::eglUnlockVulkanQueueANGLEFn(EGLDisplay dpy) {
driver_->fn.eglUnlockVulkanQueueANGLEFn(dpy);
}
EGLBoolean EGLApiBase::eglWaitClientFn(void) {
return driver_->fn.eglWaitClientFn();
}
EGLBoolean EGLApiBase::eglWaitGLFn(void) {
return driver_->fn.eglWaitGLFn();
}
EGLBoolean EGLApiBase::eglWaitNativeFn(EGLint engine) {
return driver_->fn.eglWaitNativeFn(engine);
}
EGLint EGLApiBase::eglWaitSyncFn(EGLDisplay dpy, EGLSync sync, EGLint flags) {
return driver_->fn.eglWaitSyncFn(dpy, sync, flags);
}
EGLint EGLApiBase::eglWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags) {
return driver_->fn.eglWaitSyncKHRFn(dpy, sync, flags);
}
void EGLApiBase::eglWaitUntilWorkScheduledANGLEFn(EGLDisplay dpy) {
driver_->fn.eglWaitUntilWorkScheduledANGLEFn(dpy);
}
void TraceEGLApi::eglAcquireExternalContextANGLEFn(EGLDisplay dpy,
EGLSurface readAndDraw) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglAcquireExternalContextANGLE");
egl_api_->eglAcquireExternalContextANGLEFn(dpy, readAndDraw);
}
EGLBoolean TraceEGLApi::eglBindAPIFn(EGLenum api) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglBindAPI");
return egl_api_->eglBindAPIFn(api);
}
EGLBoolean TraceEGLApi::eglBindTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglBindTexImage");
return egl_api_->eglBindTexImageFn(dpy, surface, buffer);
}
EGLBoolean TraceEGLApi::eglChooseConfigFn(EGLDisplay dpy,
const EGLint* attrib_list,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglChooseConfig");
return egl_api_->eglChooseConfigFn(dpy, attrib_list, configs, config_size,
num_config);
}
EGLint TraceEGLApi::eglClientWaitSyncFn(EGLDisplay dpy,
EGLSync sync,
EGLint flags,
EGLTime timeout) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglClientWaitSync");
return egl_api_->eglClientWaitSyncFn(dpy, sync, flags, timeout);
}
EGLint TraceEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags,
EGLTimeKHR timeout) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglClientWaitSyncKHR");
return egl_api_->eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
}
EGLBoolean TraceEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
EGLSurface surface,
EGLNativePixmapType target) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCopyBuffers");
return egl_api_->eglCopyBuffersFn(dpy, surface, target);
}
void* TraceEGLApi::eglCopyMetalSharedEventANGLEFn(EGLDisplay dpy,
EGLSync sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglCopyMetalSharedEventANGLE");
return egl_api_->eglCopyMetalSharedEventANGLEFn(dpy, sync);
}
EGLContext TraceEGLApi::eglCreateContextFn(EGLDisplay dpy,
EGLConfig config,
EGLContext share_context,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateContext");
return egl_api_->eglCreateContextFn(dpy, config, share_context, attrib_list);
}
EGLImage TraceEGLApi::eglCreateImageFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateImage");
return egl_api_->eglCreateImageFn(dpy, ctx, target, buffer, attrib_list);
}
EGLImageKHR TraceEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateImageKHR");
return egl_api_->eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
}
EGLSurface TraceEGLApi::eglCreatePbufferFromClientBufferFn(
EGLDisplay dpy,
EGLenum buftype,
void* buffer,
EGLConfig config,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglCreatePbufferFromClientBuffer");
return egl_api_->eglCreatePbufferFromClientBufferFn(dpy, buftype, buffer,
config, attrib_list);
}
EGLSurface TraceEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
EGLConfig config,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreatePbufferSurface");
return egl_api_->eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
}
EGLSurface TraceEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreatePixmapSurface");
return egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
}
EGLSurface TraceEGLApi::eglCreatePlatformPixmapSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_pixmap,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglCreatePlatformPixmapSurface");
return egl_api_->eglCreatePlatformPixmapSurfaceFn(dpy, config, native_pixmap,
attrib_list);
}
EGLSurface TraceEGLApi::eglCreatePlatformWindowSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_window,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglCreatePlatformWindowSurface");
return egl_api_->eglCreatePlatformWindowSurfaceFn(dpy, config, native_window,
attrib_list);
}
EGLStreamKHR TraceEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateStreamKHR");
return egl_api_->eglCreateStreamKHRFn(dpy, attrib_list);
}
EGLBoolean TraceEGLApi::eglCreateStreamProducerD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglCreateStreamProducerD3DTextureANGLE");
return egl_api_->eglCreateStreamProducerD3DTextureANGLEFn(dpy, stream,
attrib_list);
}
EGLSync TraceEGLApi::eglCreateSyncFn(EGLDisplay dpy,
EGLenum type,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateSync");
return egl_api_->eglCreateSyncFn(dpy, type, attrib_list);
}
EGLSyncKHR TraceEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
EGLenum type,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateSyncKHR");
return egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
}
EGLSurface TraceEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativeWindowType win,
const EGLint* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglCreateWindowSurface");
return egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
}
EGLint TraceEGLApi::eglDebugMessageControlKHRFn(EGLDEBUGPROCKHR callback,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglDebugMessageControlKHR");
return egl_api_->eglDebugMessageControlKHRFn(callback, attrib_list);
}
EGLBoolean TraceEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroyContext");
return egl_api_->eglDestroyContextFn(dpy, ctx);
}
EGLBoolean TraceEGLApi::eglDestroyImageFn(EGLDisplay dpy, EGLImage image) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroyImage");
return egl_api_->eglDestroyImageFn(dpy, image);
}
EGLBoolean TraceEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
EGLImageKHR image) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroyImageKHR");
return egl_api_->eglDestroyImageKHRFn(dpy, image);
}
EGLBoolean TraceEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroyStreamKHR");
return egl_api_->eglDestroyStreamKHRFn(dpy, stream);
}
EGLBoolean TraceEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
EGLSurface surface) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroySurface");
return egl_api_->eglDestroySurfaceFn(dpy, surface);
}
EGLBoolean TraceEGLApi::eglDestroySyncFn(EGLDisplay dpy, EGLSync sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroySync");
return egl_api_->eglDestroySyncFn(dpy, sync);
}
EGLBoolean TraceEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglDestroySyncKHR");
return egl_api_->eglDestroySyncKHRFn(dpy, sync);
}
EGLint TraceEGLApi::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
EGLSyncKHR sync) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglDupNativeFenceFDANDROID");
return egl_api_->eglDupNativeFenceFDANDROIDFn(dpy, sync);
}
EGLBoolean TraceEGLApi::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
EGLImageKHR image,
int* fds,
EGLint* strides,
EGLint* offsets) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglExportDMABUFImageMESA");
return egl_api_->eglExportDMABUFImageMESAFn(dpy, image, fds, strides,
offsets);
}
EGLBoolean TraceEGLApi::eglExportDMABUFImageQueryMESAFn(
EGLDisplay dpy,
EGLImageKHR image,
int* fourcc,
int* num_planes,
EGLuint64KHR* modifiers) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglExportDMABUFImageQueryMESA");
return egl_api_->eglExportDMABUFImageQueryMESAFn(dpy, image, fourcc,
num_planes, modifiers);
}
EGLBoolean TraceEGLApi::eglExportVkImageANGLEFn(EGLDisplay dpy,
EGLImageKHR image,
void* vk_image,
void* vk_image_create_info) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglExportVkImageANGLE");
return egl_api_->eglExportVkImageANGLEFn(dpy, image, vk_image,
vk_image_create_info);
}
EGLBoolean TraceEGLApi::eglGetCompositorTimingANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint numTimestamps,
EGLint* names,
EGLnsecsANDROID* values) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglGetCompositorTimingANDROID");
return egl_api_->eglGetCompositorTimingANDROIDFn(dpy, surface, numTimestamps,
names, values);
}
EGLBoolean TraceEGLApi::eglGetCompositorTimingSupportedANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglGetCompositorTimingSupportedANDROID");
return egl_api_->eglGetCompositorTimingSupportedANDROIDFn(dpy, surface,
timestamp);
}
EGLBoolean TraceEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
EGLConfig config,
EGLint attribute,
EGLint* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetConfigAttrib");
return egl_api_->eglGetConfigAttribFn(dpy, config, attribute, value);
}
EGLBoolean TraceEGLApi::eglGetConfigsFn(EGLDisplay dpy,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetConfigs");
return egl_api_->eglGetConfigsFn(dpy, configs, config_size, num_config);
}
EGLContext TraceEGLApi::eglGetCurrentContextFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetCurrentContext");
return egl_api_->eglGetCurrentContextFn();
}
EGLDisplay TraceEGLApi::eglGetCurrentDisplayFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetCurrentDisplay");
return egl_api_->eglGetCurrentDisplayFn();
}
EGLSurface TraceEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetCurrentSurface");
return egl_api_->eglGetCurrentSurfaceFn(readdraw);
}
EGLDisplay TraceEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetDisplay");
return egl_api_->eglGetDisplayFn(display_id);
}
EGLint TraceEGLApi::eglGetErrorFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetError");
return egl_api_->eglGetErrorFn();
}
EGLBoolean TraceEGLApi::eglGetFrameTimestampsANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
EGLint* timestamps,
EGLnsecsANDROID* values) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglGetFrameTimestampsANDROID");
return egl_api_->eglGetFrameTimestampsANDROIDFn(
dpy, surface, frameId, numTimestamps, timestamps, values);
}
EGLBoolean TraceEGLApi::eglGetFrameTimestampSupportedANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglGetFrameTimestampSupportedANDROID");
return egl_api_->eglGetFrameTimestampSupportedANDROIDFn(dpy, surface,
timestamp);
}
EGLBoolean TraceEGLApi::eglGetMscRateANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* numerator,
EGLint* denominator) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetMscRateANGLE");
return egl_api_->eglGetMscRateANGLEFn(dpy, surface, numerator, denominator);
}
EGLClientBuffer TraceEGLApi::eglGetNativeClientBufferANDROIDFn(
const struct AHardwareBuffer* ahardwarebuffer) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglGetNativeClientBufferANDROID");
return egl_api_->eglGetNativeClientBufferANDROIDFn(ahardwarebuffer);
}
EGLBoolean TraceEGLApi::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR* frameId) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetNextFrameIdANDROID");
return egl_api_->eglGetNextFrameIdANDROIDFn(dpy, surface, frameId);
}
EGLDisplay TraceEGLApi::eglGetPlatformDisplayFn(EGLenum platform,
void* native_display,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetPlatformDisplay");
return egl_api_->eglGetPlatformDisplayFn(platform, native_display,
attrib_list);
}
__eglMustCastToProperFunctionPointerType TraceEGLApi::eglGetProcAddressFn(
const char* procname) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetProcAddress");
return egl_api_->eglGetProcAddressFn(procname);
}
EGLBoolean TraceEGLApi::eglGetSyncAttribFn(EGLDisplay dpy,
EGLSync sync,
EGLint attribute,
EGLAttrib* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetSyncAttrib");
return egl_api_->eglGetSyncAttribFn(dpy, sync, attribute, value);
}
EGLBoolean TraceEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint attribute,
EGLint* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetSyncAttribKHR");
return egl_api_->eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
}
EGLBoolean TraceEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64CHROMIUM* ust,
EGLuint64CHROMIUM* msc,
EGLuint64CHROMIUM* sbc) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglGetSyncValuesCHROMIUM");
return egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
}
void TraceEGLApi::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglHandleGPUSwitchANGLE");
egl_api_->eglHandleGPUSwitchANGLEFn(dpy);
}
EGLBoolean TraceEGLApi::eglImageFlushExternalEXTFn(
EGLDisplay dpy,
EGLImageKHR image,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglImageFlushExternalEXT");
return egl_api_->eglImageFlushExternalEXTFn(dpy, image, attrib_list);
}
EGLBoolean TraceEGLApi::eglInitializeFn(EGLDisplay dpy,
EGLint* major,
EGLint* minor) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglInitialize");
return egl_api_->eglInitializeFn(dpy, major, minor);
}
EGLint TraceEGLApi::eglLabelObjectKHRFn(EGLDisplay display,
EGLenum objectType,
EGLObjectKHR object,
EGLLabelKHR label) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglLabelObjectKHR");
return egl_api_->eglLabelObjectKHRFn(display, objectType, object, label);
}
void TraceEGLApi::eglLockVulkanQueueANGLEFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglLockVulkanQueueANGLE");
egl_api_->eglLockVulkanQueueANGLEFn(dpy);
}
EGLBoolean TraceEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
EGLSurface draw,
EGLSurface read,
EGLContext ctx) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglMakeCurrent");
return egl_api_->eglMakeCurrentFn(dpy, draw, read, ctx);
}
EGLBoolean TraceEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
EGLSurface surface,
EGLint x,
EGLint y,
EGLint width,
EGLint height) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglPostSubBufferNV");
return egl_api_->eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
}
EGLBoolean TraceEGLApi::eglPresentationTimeANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLnsecsANDROID time) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglPresentationTimeANDROID");
return egl_api_->eglPresentationTimeANDROIDFn(dpy, surface, time);
}
EGLenum TraceEGLApi::eglQueryAPIFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryAPI");
return egl_api_->eglQueryAPIFn();
}
EGLBoolean TraceEGLApi::eglQueryContextFn(EGLDisplay dpy,
EGLContext ctx,
EGLint attribute,
EGLint* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryContext");
return egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryDebugKHRFn(EGLint attribute, EGLAttrib* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDebugKHR");
return egl_api_->eglQueryDebugKHRFn(attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryDeviceAttribEXTFn(EGLDeviceEXT device,
EGLint attribute,
EGLAttrib* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDeviceAttribEXT");
return egl_api_->eglQueryDeviceAttribEXTFn(device, attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryDevicesEXTFn(EGLint max_devices,
EGLDeviceEXT* devices,
EGLint* num_devices) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDevicesEXT");
return egl_api_->eglQueryDevicesEXTFn(max_devices, devices, num_devices);
}
const char* TraceEGLApi::eglQueryDeviceStringEXTFn(EGLDeviceEXT device,
EGLint name) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDeviceStringEXT");
return egl_api_->eglQueryDeviceStringEXTFn(device, name);
}
EGLBoolean TraceEGLApi::eglQueryDisplayAttribANGLEFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglQueryDisplayAttribANGLE");
return egl_api_->eglQueryDisplayAttribANGLEFn(dpy, attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryDisplayAttribEXTFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDisplayAttribEXT");
return egl_api_->eglQueryDisplayAttribEXTFn(dpy, attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryDmaBufFormatsEXTFn(EGLDisplay dpy,
EGLint max_formats,
EGLint* formats,
EGLint* num_formats) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryDmaBufFormatsEXT");
return egl_api_->eglQueryDmaBufFormatsEXTFn(dpy, max_formats, formats,
num_formats);
}
EGLBoolean TraceEGLApi::eglQueryDmaBufModifiersEXTFn(EGLDisplay dpy,
EGLint format,
EGLint max_modifiers,
EGLuint64KHR* modifiers,
EGLBoolean* external_only,
EGLint* num_modifiers) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglQueryDmaBufModifiersEXT");
return egl_api_->eglQueryDmaBufModifiersEXTFn(
dpy, format, max_modifiers, modifiers, external_only, num_modifiers);
}
EGLBoolean TraceEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryStreamKHR");
return egl_api_->eglQueryStreamKHRFn(dpy, stream, attribute, value);
}
EGLBoolean TraceEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLuint64KHR* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryStreamu64KHR");
return egl_api_->eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
}
const char* TraceEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryString");
return egl_api_->eglQueryStringFn(dpy, name);
}
const char* TraceEGLApi::eglQueryStringiANGLEFn(EGLDisplay dpy,
EGLint name,
EGLint index) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQueryStringiANGLE");
return egl_api_->eglQueryStringiANGLEFn(dpy, name, index);
}
EGLBoolean TraceEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint* value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglQuerySurface");
return egl_api_->eglQuerySurfaceFn(dpy, surface, attribute, value);
}
EGLBoolean TraceEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
void** value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglQuerySurfacePointerANGLE");
return egl_api_->eglQuerySurfacePointerANGLEFn(dpy, surface, attribute,
value);
}
void TraceEGLApi::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy,
EGLContext ctx) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglReacquireHighPowerGPUANGLE");
egl_api_->eglReacquireHighPowerGPUANGLEFn(dpy, ctx);
}
void TraceEGLApi::eglReleaseExternalContextANGLEFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglReleaseExternalContextANGLE");
egl_api_->eglReleaseExternalContextANGLEFn(dpy);
}
void TraceEGLApi::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy,
EGLContext ctx) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglReleaseHighPowerGPUANGLE");
egl_api_->eglReleaseHighPowerGPUANGLEFn(dpy, ctx);
}
EGLBoolean TraceEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglReleaseTexImage");
return egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
}
EGLBoolean TraceEGLApi::eglReleaseThreadFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglReleaseThread");
return egl_api_->eglReleaseThreadFn();
}
void TraceEGLApi::eglSetBlobCacheFuncsANDROIDFn(EGLDisplay dpy,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglSetBlobCacheFuncsANDROID");
egl_api_->eglSetBlobCacheFuncsANDROIDFn(dpy, set, get);
}
#if BUILDFLAG(IS_ARKWEB)
EGLBoolean TraceEGLApi::eglSetDamageRegionKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglSetDamageRegionKHR");
return egl_api_->eglSetDamageRegionKHRFn(dpy, surface, rects, n_rects);
}
#endif
void TraceEGLApi::eglSetValidationEnabledANGLEFn(EGLBoolean validationState) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglSetValidationEnabledANGLE");
egl_api_->eglSetValidationEnabledANGLEFn(validationState);
}
EGLBoolean TraceEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglStreamAttribKHR");
return egl_api_->eglStreamAttribKHRFn(dpy, stream, attribute, value);
}
EGLBoolean TraceEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglStreamConsumerAcquireKHR");
return egl_api_->eglStreamConsumerAcquireKHRFn(dpy, stream);
}
EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglStreamConsumerGLTextureExternalAttribsNV");
return egl_api_->eglStreamConsumerGLTextureExternalAttribsNVFn(dpy, stream,
attrib_list);
}
EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
EGLDisplay dpy,
EGLStreamKHR stream) {
TRACE_EVENT_BINARY_EFFICIENT0(
"gpu", "TraceEGLAPI::eglStreamConsumerGLTextureExternalKHR");
return egl_api_->eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
}
EGLBoolean TraceEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglStreamConsumerReleaseKHR");
return egl_api_->eglStreamConsumerReleaseKHRFn(dpy, stream);
}
EGLBoolean TraceEGLApi::eglStreamPostD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
void* texture,
const EGLAttrib* attrib_list) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglStreamPostD3DTextureANGLE");
return egl_api_->eglStreamPostD3DTextureANGLEFn(dpy, stream, texture,
attrib_list);
}
EGLBoolean TraceEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint value) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglSurfaceAttrib");
return egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
}
EGLBoolean TraceEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglSwapBuffers");
return egl_api_->eglSwapBuffersFn(dpy, surface);
}
EGLBoolean TraceEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglSwapBuffersWithDamageKHR");
return egl_api_->eglSwapBuffersWithDamageKHRFn(dpy, surface, rects, n_rects);
}
EGLBoolean TraceEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglSwapInterval");
return egl_api_->eglSwapIntervalFn(dpy, interval);
}
EGLBoolean TraceEGLApi::eglTerminateFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglTerminate");
return egl_api_->eglTerminateFn(dpy);
}
void TraceEGLApi::eglUnlockVulkanQueueANGLEFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglUnlockVulkanQueueANGLE");
egl_api_->eglUnlockVulkanQueueANGLEFn(dpy);
}
EGLBoolean TraceEGLApi::eglWaitClientFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglWaitClient");
return egl_api_->eglWaitClientFn();
}
EGLBoolean TraceEGLApi::eglWaitGLFn(void) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglWaitGL");
return egl_api_->eglWaitGLFn();
}
EGLBoolean TraceEGLApi::eglWaitNativeFn(EGLint engine) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglWaitNative");
return egl_api_->eglWaitNativeFn(engine);
}
EGLint TraceEGLApi::eglWaitSyncFn(EGLDisplay dpy, EGLSync sync, EGLint flags) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglWaitSync");
return egl_api_->eglWaitSyncFn(dpy, sync, flags);
}
EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceEGLAPI::eglWaitSyncKHR");
return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
}
void TraceEGLApi::eglWaitUntilWorkScheduledANGLEFn(EGLDisplay dpy) {
TRACE_EVENT_BINARY_EFFICIENT0("gpu",
"TraceEGLAPI::eglWaitUntilWorkScheduledANGLE");
egl_api_->eglWaitUntilWorkScheduledANGLEFn(dpy);
}
void LogEGLApi::eglAcquireExternalContextANGLEFn(EGLDisplay dpy,
EGLSurface readAndDraw) {
GL_SERVICE_LOG("eglAcquireExternalContextANGLE"
<< "(" << dpy << ", " << readAndDraw << ")");
egl_api_->eglAcquireExternalContextANGLEFn(dpy, readAndDraw);
}
EGLBoolean LogEGLApi::eglBindAPIFn(EGLenum api) {
GL_SERVICE_LOG("eglBindAPI"
<< "(" << api << ")");
EGLBoolean result = egl_api_->eglBindAPIFn(api);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglBindTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
GL_SERVICE_LOG("eglBindTexImage"
<< "(" << dpy << ", " << surface << ", " << buffer << ")");
EGLBoolean result = egl_api_->eglBindTexImageFn(dpy, surface, buffer);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglChooseConfigFn(EGLDisplay dpy,
const EGLint* attrib_list,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
GL_SERVICE_LOG("eglChooseConfig"
<< "(" << dpy << ", " << static_cast<const void*>(attrib_list)
<< ", " << static_cast<const void*>(configs) << ", "
<< config_size << ", " << static_cast<const void*>(num_config)
<< ")");
EGLBoolean result = egl_api_->eglChooseConfigFn(dpy, attrib_list, configs,
config_size, num_config);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglClientWaitSyncFn(EGLDisplay dpy,
EGLSync sync,
EGLint flags,
EGLTime timeout) {
GL_SERVICE_LOG("eglClientWaitSync"
<< "(" << dpy << ", " << sync << ", " << flags << ", "
<< timeout << ")");
EGLint result = egl_api_->eglClientWaitSyncFn(dpy, sync, flags, timeout);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags,
EGLTimeKHR timeout) {
GL_SERVICE_LOG("eglClientWaitSyncKHR"
<< "(" << dpy << ", " << sync << ", " << flags << ", "
<< timeout << ")");
EGLint result = egl_api_->eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
EGLSurface surface,
EGLNativePixmapType target) {
GL_SERVICE_LOG("eglCopyBuffers"
<< "(" << dpy << ", " << surface << ", " << target << ")");
EGLBoolean result = egl_api_->eglCopyBuffersFn(dpy, surface, target);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void* LogEGLApi::eglCopyMetalSharedEventANGLEFn(EGLDisplay dpy, EGLSync sync) {
GL_SERVICE_LOG("eglCopyMetalSharedEventANGLE"
<< "(" << dpy << ", " << sync << ")");
void* result = egl_api_->eglCopyMetalSharedEventANGLEFn(dpy, sync);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLContext LogEGLApi::eglCreateContextFn(EGLDisplay dpy,
EGLConfig config,
EGLContext share_context,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreateContext"
<< "(" << dpy << ", " << config << ", " << share_context
<< ", " << static_cast<const void*>(attrib_list) << ")");
EGLContext result =
egl_api_->eglCreateContextFn(dpy, config, share_context, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLImage LogEGLApi::eglCreateImageFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglCreateImage"
<< "(" << dpy << ", " << ctx << ", " << target << ", "
<< buffer << ", " << static_cast<const void*>(attrib_list)
<< ")");
EGLImage result =
egl_api_->eglCreateImageFn(dpy, ctx, target, buffer, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLImageKHR LogEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
EGLContext ctx,
EGLenum target,
EGLClientBuffer buffer,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreateImageKHR"
<< "(" << dpy << ", " << ctx << ", " << target << ", "
<< buffer << ", " << static_cast<const void*>(attrib_list)
<< ")");
EGLImageKHR result =
egl_api_->eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreatePbufferFromClientBufferFn(
EGLDisplay dpy,
EGLenum buftype,
void* buffer,
EGLConfig config,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreatePbufferFromClientBuffer"
<< "(" << dpy << ", " << buftype << ", "
<< static_cast<const void*>(buffer) << ", " << config << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result = egl_api_->eglCreatePbufferFromClientBufferFn(
dpy, buftype, buffer, config, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
EGLConfig config,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreatePbufferSurface"
<< "(" << dpy << ", " << config << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result =
egl_api_->eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreatePixmapSurface"
<< "(" << dpy << ", " << config << ", " << pixmap << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result =
egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreatePlatformPixmapSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_pixmap,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglCreatePlatformPixmapSurface"
<< "(" << dpy << ", " << config << ", "
<< static_cast<const void*>(native_pixmap) << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result = egl_api_->eglCreatePlatformPixmapSurfaceFn(
dpy, config, native_pixmap, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreatePlatformWindowSurfaceFn(
EGLDisplay dpy,
EGLConfig config,
void* native_window,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglCreatePlatformWindowSurface"
<< "(" << dpy << ", " << config << ", "
<< static_cast<const void*>(native_window) << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result = egl_api_->eglCreatePlatformWindowSurfaceFn(
dpy, config, native_window, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLStreamKHR LogEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreateStreamKHR"
<< "(" << dpy << ", " << static_cast<const void*>(attrib_list)
<< ")");
EGLStreamKHR result = egl_api_->eglCreateStreamKHRFn(dpy, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglCreateStreamProducerD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglCreateStreamProducerD3DTextureANGLE"
<< "(" << dpy << ", " << stream << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLBoolean result = egl_api_->eglCreateStreamProducerD3DTextureANGLEFn(
dpy, stream, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSync LogEGLApi::eglCreateSyncFn(EGLDisplay dpy,
EGLenum type,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglCreateSync"
<< "(" << dpy << ", " << type << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSync result = egl_api_->eglCreateSyncFn(dpy, type, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSyncKHR LogEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
EGLenum type,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreateSyncKHR"
<< "(" << dpy << ", " << type << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSyncKHR result = egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
EGLConfig config,
EGLNativeWindowType win,
const EGLint* attrib_list) {
GL_SERVICE_LOG("eglCreateWindowSurface"
<< "(" << dpy << ", " << config << ", " << win << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLSurface result =
egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglDebugMessageControlKHRFn(EGLDEBUGPROCKHR callback,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglDebugMessageControlKHR"
<< "(" << reinterpret_cast<void*>(callback) << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLint result = egl_api_->eglDebugMessageControlKHRFn(callback, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
GL_SERVICE_LOG("eglDestroyContext"
<< "(" << dpy << ", " << ctx << ")");
EGLBoolean result = egl_api_->eglDestroyContextFn(dpy, ctx);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroyImageFn(EGLDisplay dpy, EGLImage image) {
GL_SERVICE_LOG("eglDestroyImage"
<< "(" << dpy << ", " << image << ")");
EGLBoolean result = egl_api_->eglDestroyImageFn(dpy, image);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy, EGLImageKHR image) {
GL_SERVICE_LOG("eglDestroyImageKHR"
<< "(" << dpy << ", " << image << ")");
EGLBoolean result = egl_api_->eglDestroyImageKHRFn(dpy, image);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
GL_SERVICE_LOG("eglDestroyStreamKHR"
<< "(" << dpy << ", " << stream << ")");
EGLBoolean result = egl_api_->eglDestroyStreamKHRFn(dpy, stream);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroySurfaceFn(EGLDisplay dpy, EGLSurface surface) {
GL_SERVICE_LOG("eglDestroySurface"
<< "(" << dpy << ", " << surface << ")");
EGLBoolean result = egl_api_->eglDestroySurfaceFn(dpy, surface);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroySyncFn(EGLDisplay dpy, EGLSync sync) {
GL_SERVICE_LOG("eglDestroySync"
<< "(" << dpy << ", " << sync << ")");
EGLBoolean result = egl_api_->eglDestroySyncFn(dpy, sync);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
GL_SERVICE_LOG("eglDestroySyncKHR"
<< "(" << dpy << ", " << sync << ")");
EGLBoolean result = egl_api_->eglDestroySyncKHRFn(dpy, sync);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
EGLSyncKHR sync) {
GL_SERVICE_LOG("eglDupNativeFenceFDANDROID"
<< "(" << dpy << ", " << sync << ")");
EGLint result = egl_api_->eglDupNativeFenceFDANDROIDFn(dpy, sync);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
EGLImageKHR image,
int* fds,
EGLint* strides,
EGLint* offsets) {
GL_SERVICE_LOG("eglExportDMABUFImageMESA"
<< "(" << dpy << ", " << image << ", "
<< static_cast<const void*>(fds) << ", "
<< static_cast<const void*>(strides) << ", "
<< static_cast<const void*>(offsets) << ")");
EGLBoolean result =
egl_api_->eglExportDMABUFImageMESAFn(dpy, image, fds, strides, offsets);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglExportDMABUFImageQueryMESAFn(EGLDisplay dpy,
EGLImageKHR image,
int* fourcc,
int* num_planes,
EGLuint64KHR* modifiers) {
GL_SERVICE_LOG("eglExportDMABUFImageQueryMESA"
<< "(" << dpy << ", " << image << ", "
<< static_cast<const void*>(fourcc) << ", "
<< static_cast<const void*>(num_planes) << ", "
<< static_cast<const void*>(modifiers) << ")");
EGLBoolean result = egl_api_->eglExportDMABUFImageQueryMESAFn(
dpy, image, fourcc, num_planes, modifiers);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglExportVkImageANGLEFn(EGLDisplay dpy,
EGLImageKHR image,
void* vk_image,
void* vk_image_create_info) {
GL_SERVICE_LOG("eglExportVkImageANGLE"
<< "(" << dpy << ", " << image << ", "
<< static_cast<const void*>(vk_image) << ", "
<< static_cast<const void*>(vk_image_create_info) << ")");
EGLBoolean result = egl_api_->eglExportVkImageANGLEFn(dpy, image, vk_image,
vk_image_create_info);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetCompositorTimingANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLint numTimestamps,
EGLint* names,
EGLnsecsANDROID* values) {
GL_SERVICE_LOG("eglGetCompositorTimingANDROID"
<< "(" << dpy << ", " << surface << ", " << numTimestamps
<< ", " << static_cast<const void*>(names) << ", "
<< static_cast<const void*>(values) << ")");
EGLBoolean result = egl_api_->eglGetCompositorTimingANDROIDFn(
dpy, surface, numTimestamps, names, values);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetCompositorTimingSupportedANDROIDFn(
EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
GL_SERVICE_LOG("eglGetCompositorTimingSupportedANDROID"
<< "(" << dpy << ", " << surface << ", " << timestamp << ")");
EGLBoolean result = egl_api_->eglGetCompositorTimingSupportedANDROIDFn(
dpy, surface, timestamp);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
EGLConfig config,
EGLint attribute,
EGLint* value) {
GL_SERVICE_LOG("eglGetConfigAttrib"
<< "(" << dpy << ", " << config << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglGetConfigAttribFn(dpy, config, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetConfigsFn(EGLDisplay dpy,
EGLConfig* configs,
EGLint config_size,
EGLint* num_config) {
GL_SERVICE_LOG("eglGetConfigs"
<< "(" << dpy << ", " << static_cast<const void*>(configs)
<< ", " << config_size << ", "
<< static_cast<const void*>(num_config) << ")");
EGLBoolean result =
egl_api_->eglGetConfigsFn(dpy, configs, config_size, num_config);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLContext LogEGLApi::eglGetCurrentContextFn(void) {
GL_SERVICE_LOG("eglGetCurrentContext"
<< "("
<< ")");
EGLContext result = egl_api_->eglGetCurrentContextFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLDisplay LogEGLApi::eglGetCurrentDisplayFn(void) {
GL_SERVICE_LOG("eglGetCurrentDisplay"
<< "("
<< ")");
EGLDisplay result = egl_api_->eglGetCurrentDisplayFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLSurface LogEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
GL_SERVICE_LOG("eglGetCurrentSurface"
<< "(" << readdraw << ")");
EGLSurface result = egl_api_->eglGetCurrentSurfaceFn(readdraw);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLDisplay LogEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
GL_SERVICE_LOG("eglGetDisplay"
<< "(" << display_id << ")");
EGLDisplay result = egl_api_->eglGetDisplayFn(display_id);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglGetErrorFn(void) {
GL_SERVICE_LOG("eglGetError"
<< "("
<< ")");
EGLint result = egl_api_->eglGetErrorFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetFrameTimestampsANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR frameId,
EGLint numTimestamps,
EGLint* timestamps,
EGLnsecsANDROID* values) {
GL_SERVICE_LOG("eglGetFrameTimestampsANDROID"
<< "(" << dpy << ", " << surface << ", " << frameId << ", "
<< numTimestamps << ", "
<< static_cast<const void*>(timestamps) << ", "
<< static_cast<const void*>(values) << ")");
EGLBoolean result = egl_api_->eglGetFrameTimestampsANDROIDFn(
dpy, surface, frameId, numTimestamps, timestamps, values);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetFrameTimestampSupportedANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLint timestamp) {
GL_SERVICE_LOG("eglGetFrameTimestampSupportedANDROID"
<< "(" << dpy << ", " << surface << ", " << timestamp << ")");
EGLBoolean result =
egl_api_->eglGetFrameTimestampSupportedANDROIDFn(dpy, surface, timestamp);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetMscRateANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* numerator,
EGLint* denominator) {
GL_SERVICE_LOG("eglGetMscRateANGLE"
<< "(" << dpy << ", " << surface << ", "
<< static_cast<const void*>(numerator) << ", "
<< static_cast<const void*>(denominator) << ")");
EGLBoolean result =
egl_api_->eglGetMscRateANGLEFn(dpy, surface, numerator, denominator);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLClientBuffer LogEGLApi::eglGetNativeClientBufferANDROIDFn(
const struct AHardwareBuffer* ahardwarebuffer) {
GL_SERVICE_LOG("eglGetNativeClientBufferANDROID"
<< "(" << static_cast<const void*>(ahardwarebuffer) << ")");
EGLClientBuffer result =
egl_api_->eglGetNativeClientBufferANDROIDFn(ahardwarebuffer);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64KHR* frameId) {
GL_SERVICE_LOG("eglGetNextFrameIdANDROID"
<< "(" << dpy << ", " << surface << ", "
<< static_cast<const void*>(frameId) << ")");
EGLBoolean result =
egl_api_->eglGetNextFrameIdANDROIDFn(dpy, surface, frameId);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLDisplay LogEGLApi::eglGetPlatformDisplayFn(EGLenum platform,
void* native_display,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglGetPlatformDisplay"
<< "(" << platform << ", "
<< static_cast<const void*>(native_display) << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLDisplay result =
egl_api_->eglGetPlatformDisplayFn(platform, native_display, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
__eglMustCastToProperFunctionPointerType LogEGLApi::eglGetProcAddressFn(
const char* procname) {
GL_SERVICE_LOG("eglGetProcAddress"
<< "(" << procname << ")");
__eglMustCastToProperFunctionPointerType result =
egl_api_->eglGetProcAddressFn(procname);
GL_SERVICE_LOG("GL_RESULT: " << reinterpret_cast<void*>(result));
return result;
}
EGLBoolean LogEGLApi::eglGetSyncAttribFn(EGLDisplay dpy,
EGLSync sync,
EGLint attribute,
EGLAttrib* value) {
GL_SERVICE_LOG("eglGetSyncAttrib"
<< "(" << dpy << ", " << sync << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result = egl_api_->eglGetSyncAttribFn(dpy, sync, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint attribute,
EGLint* value) {
GL_SERVICE_LOG("eglGetSyncAttribKHR"
<< "(" << dpy << ", " << sync << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
EGLSurface surface,
EGLuint64CHROMIUM* ust,
EGLuint64CHROMIUM* msc,
EGLuint64CHROMIUM* sbc) {
GL_SERVICE_LOG("eglGetSyncValuesCHROMIUM"
<< "(" << dpy << ", " << surface << ", "
<< static_cast<const void*>(ust) << ", "
<< static_cast<const void*>(msc) << ", "
<< static_cast<const void*>(sbc) << ")");
EGLBoolean result =
egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglHandleGPUSwitchANGLEFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglHandleGPUSwitchANGLE"
<< "(" << dpy << ")");
egl_api_->eglHandleGPUSwitchANGLEFn(dpy);
}
EGLBoolean LogEGLApi::eglImageFlushExternalEXTFn(EGLDisplay dpy,
EGLImageKHR image,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglImageFlushExternalEXT"
<< "(" << dpy << ", " << image << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLBoolean result =
egl_api_->eglImageFlushExternalEXTFn(dpy, image, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglInitializeFn(EGLDisplay dpy,
EGLint* major,
EGLint* minor) {
GL_SERVICE_LOG("eglInitialize"
<< "(" << dpy << ", " << static_cast<const void*>(major)
<< ", " << static_cast<const void*>(minor) << ")");
EGLBoolean result = egl_api_->eglInitializeFn(dpy, major, minor);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglLabelObjectKHRFn(EGLDisplay display,
EGLenum objectType,
EGLObjectKHR object,
EGLLabelKHR label) {
GL_SERVICE_LOG("eglLabelObjectKHR"
<< "(" << display << ", " << objectType << ", " << object
<< ", " << label << ")");
EGLint result =
egl_api_->eglLabelObjectKHRFn(display, objectType, object, label);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglLockVulkanQueueANGLEFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglLockVulkanQueueANGLE"
<< "(" << dpy << ")");
egl_api_->eglLockVulkanQueueANGLEFn(dpy);
}
EGLBoolean LogEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
EGLSurface draw,
EGLSurface read,
EGLContext ctx) {
GL_SERVICE_LOG("eglMakeCurrent"
<< "(" << dpy << ", " << draw << ", " << read << ", " << ctx
<< ")");
EGLBoolean result = egl_api_->eglMakeCurrentFn(dpy, draw, read, ctx);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
EGLSurface surface,
EGLint x,
EGLint y,
EGLint width,
EGLint height) {
GL_SERVICE_LOG("eglPostSubBufferNV"
<< "(" << dpy << ", " << surface << ", " << x << ", " << y
<< ", " << width << ", " << height << ")");
EGLBoolean result =
egl_api_->eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglPresentationTimeANDROIDFn(EGLDisplay dpy,
EGLSurface surface,
EGLnsecsANDROID time) {
GL_SERVICE_LOG("eglPresentationTimeANDROID"
<< "(" << dpy << ", " << surface << ", " << time << ")");
EGLBoolean result =
egl_api_->eglPresentationTimeANDROIDFn(dpy, surface, time);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLenum LogEGLApi::eglQueryAPIFn(void) {
GL_SERVICE_LOG("eglQueryAPI"
<< "("
<< ")");
EGLenum result = egl_api_->eglQueryAPIFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryContextFn(EGLDisplay dpy,
EGLContext ctx,
EGLint attribute,
EGLint* value) {
GL_SERVICE_LOG("eglQueryContext"
<< "(" << dpy << ", " << ctx << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result = egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDebugKHRFn(EGLint attribute, EGLAttrib* value) {
GL_SERVICE_LOG("eglQueryDebugKHR"
<< "(" << attribute << ", " << static_cast<const void*>(value)
<< ")");
EGLBoolean result = egl_api_->eglQueryDebugKHRFn(attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDeviceAttribEXTFn(EGLDeviceEXT device,
EGLint attribute,
EGLAttrib* value) {
GL_SERVICE_LOG("eglQueryDeviceAttribEXT"
<< "(" << device << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQueryDeviceAttribEXTFn(device, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDevicesEXTFn(EGLint max_devices,
EGLDeviceEXT* devices,
EGLint* num_devices) {
GL_SERVICE_LOG("eglQueryDevicesEXT"
<< "(" << max_devices << ", "
<< static_cast<const void*>(devices) << ", "
<< static_cast<const void*>(num_devices) << ")");
EGLBoolean result =
egl_api_->eglQueryDevicesEXTFn(max_devices, devices, num_devices);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
const char* LogEGLApi::eglQueryDeviceStringEXTFn(EGLDeviceEXT device,
EGLint name) {
GL_SERVICE_LOG("eglQueryDeviceStringEXT"
<< "(" << device << ", " << name << ")");
const char* result = egl_api_->eglQueryDeviceStringEXTFn(device, name);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDisplayAttribANGLEFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
GL_SERVICE_LOG("eglQueryDisplayAttribANGLE"
<< "(" << dpy << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQueryDisplayAttribANGLEFn(dpy, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDisplayAttribEXTFn(EGLDisplay dpy,
EGLint attribute,
EGLAttrib* value) {
GL_SERVICE_LOG("eglQueryDisplayAttribEXT"
<< "(" << dpy << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQueryDisplayAttribEXTFn(dpy, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDmaBufFormatsEXTFn(EGLDisplay dpy,
EGLint max_formats,
EGLint* formats,
EGLint* num_formats) {
GL_SERVICE_LOG("eglQueryDmaBufFormatsEXT"
<< "(" << dpy << ", " << max_formats << ", "
<< static_cast<const void*>(formats) << ", "
<< static_cast<const void*>(num_formats) << ")");
EGLBoolean result = egl_api_->eglQueryDmaBufFormatsEXTFn(
dpy, max_formats, formats, num_formats);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryDmaBufModifiersEXTFn(EGLDisplay dpy,
EGLint format,
EGLint max_modifiers,
EGLuint64KHR* modifiers,
EGLBoolean* external_only,
EGLint* num_modifiers) {
GL_SERVICE_LOG("eglQueryDmaBufModifiersEXT"
<< "(" << dpy << ", " << format << ", " << max_modifiers
<< ", " << static_cast<const void*>(modifiers) << ", "
<< static_cast<const void*>(external_only) << ", "
<< static_cast<const void*>(num_modifiers) << ")");
EGLBoolean result = egl_api_->eglQueryDmaBufModifiersEXTFn(
dpy, format, max_modifiers, modifiers, external_only, num_modifiers);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint* value) {
GL_SERVICE_LOG("eglQueryStreamKHR"
<< "(" << dpy << ", " << stream << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQueryStreamKHRFn(dpy, stream, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLuint64KHR* value) {
GL_SERVICE_LOG("eglQueryStreamu64KHR"
<< "(" << dpy << ", " << stream << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
const char* LogEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
GL_SERVICE_LOG("eglQueryString"
<< "(" << dpy << ", " << name << ")");
const char* result = egl_api_->eglQueryStringFn(dpy, name);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
const char* LogEGLApi::eglQueryStringiANGLEFn(EGLDisplay dpy,
EGLint name,
EGLint index) {
GL_SERVICE_LOG("eglQueryStringiANGLE"
<< "(" << dpy << ", " << name << ", " << index << ")");
const char* result = egl_api_->eglQueryStringiANGLEFn(dpy, name, index);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint* value) {
GL_SERVICE_LOG("eglQuerySurface"
<< "(" << dpy << ", " << surface << ", " << attribute << ", "
<< static_cast<const void*>(value) << ")");
EGLBoolean result =
egl_api_->eglQuerySurfaceFn(dpy, surface, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
void** value) {
GL_SERVICE_LOG("eglQuerySurfacePointerANGLE"
<< "(" << dpy << ", " << surface << ", " << attribute << ", "
<< value << ")");
EGLBoolean result =
egl_api_->eglQuerySurfacePointerANGLEFn(dpy, surface, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglReacquireHighPowerGPUANGLEFn(EGLDisplay dpy,
EGLContext ctx) {
GL_SERVICE_LOG("eglReacquireHighPowerGPUANGLE"
<< "(" << dpy << ", " << ctx << ")");
egl_api_->eglReacquireHighPowerGPUANGLEFn(dpy, ctx);
}
void LogEGLApi::eglReleaseExternalContextANGLEFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglReleaseExternalContextANGLE"
<< "(" << dpy << ")");
egl_api_->eglReleaseExternalContextANGLEFn(dpy);
}
void LogEGLApi::eglReleaseHighPowerGPUANGLEFn(EGLDisplay dpy, EGLContext ctx) {
GL_SERVICE_LOG("eglReleaseHighPowerGPUANGLE"
<< "(" << dpy << ", " << ctx << ")");
egl_api_->eglReleaseHighPowerGPUANGLEFn(dpy, ctx);
}
EGLBoolean LogEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
EGLSurface surface,
EGLint buffer) {
GL_SERVICE_LOG("eglReleaseTexImage"
<< "(" << dpy << ", " << surface << ", " << buffer << ")");
EGLBoolean result = egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglReleaseThreadFn(void) {
GL_SERVICE_LOG("eglReleaseThread"
<< "("
<< ")");
EGLBoolean result = egl_api_->eglReleaseThreadFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglSetBlobCacheFuncsANDROIDFn(EGLDisplay dpy,
EGLSetBlobFuncANDROID set,
EGLGetBlobFuncANDROID get) {
GL_SERVICE_LOG("eglSetBlobCacheFuncsANDROID"
<< "(" << dpy << ", " << reinterpret_cast<const void*>(set)
<< ", " << reinterpret_cast<const void*>(get) << ")");
egl_api_->eglSetBlobCacheFuncsANDROIDFn(dpy, set, get);
}
#if BUILDFLAG(IS_ARKWEB)
EGLBoolean LogEGLApi::eglSetDamageRegionKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
GL_SERVICE_LOG("eglSetDamageRegionKHR"
<< "(" << dpy << ", " << surface << ", "
<< static_cast<const void*>(rects) << ", " << n_rects << ")");
EGLBoolean result =
egl_api_->eglSetDamageRegionKHRFn(dpy, surface, rects, n_rects);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
#endif
void LogEGLApi::eglSetValidationEnabledANGLEFn(EGLBoolean validationState) {
GL_SERVICE_LOG("eglSetValidationEnabledANGLE"
<< "(" << validationState << ")");
egl_api_->eglSetValidationEnabledANGLEFn(validationState);
}
EGLBoolean LogEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
EGLStreamKHR stream,
EGLenum attribute,
EGLint value) {
GL_SERVICE_LOG("eglStreamAttribKHR"
<< "(" << dpy << ", " << stream << ", " << attribute << ", "
<< value << ")");
EGLBoolean result =
egl_api_->eglStreamAttribKHRFn(dpy, stream, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
<< "(" << dpy << ", " << stream << ")");
EGLBoolean result = egl_api_->eglStreamConsumerAcquireKHRFn(dpy, stream);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
EGLDisplay dpy,
EGLStreamKHR stream,
EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalAttribsNV"
<< "(" << dpy << ", " << stream << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLBoolean result = egl_api_->eglStreamConsumerGLTextureExternalAttribsNVFn(
dpy, stream, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
EGLDisplay dpy,
EGLStreamKHR stream) {
GL_SERVICE_LOG("eglStreamConsumerGLTextureExternalKHR"
<< "(" << dpy << ", " << stream << ")");
EGLBoolean result =
egl_api_->eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
EGLStreamKHR stream) {
GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
<< "(" << dpy << ", " << stream << ")");
EGLBoolean result = egl_api_->eglStreamConsumerReleaseKHRFn(dpy, stream);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglStreamPostD3DTextureANGLEFn(
EGLDisplay dpy,
EGLStreamKHR stream,
void* texture,
const EGLAttrib* attrib_list) {
GL_SERVICE_LOG("eglStreamPostD3DTextureANGLE"
<< "(" << dpy << ", " << stream << ", "
<< static_cast<const void*>(texture) << ", "
<< static_cast<const void*>(attrib_list) << ")");
EGLBoolean result = egl_api_->eglStreamPostD3DTextureANGLEFn(
dpy, stream, texture, attrib_list);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
EGLSurface surface,
EGLint attribute,
EGLint value) {
GL_SERVICE_LOG("eglSurfaceAttrib"
<< "(" << dpy << ", " << surface << ", " << attribute << ", "
<< value << ")");
EGLBoolean result =
egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
GL_SERVICE_LOG("eglSwapBuffers"
<< "(" << dpy << ", " << surface << ")");
EGLBoolean result = egl_api_->eglSwapBuffersFn(dpy, surface);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
EGLSurface surface,
EGLint* rects,
EGLint n_rects) {
GL_SERVICE_LOG("eglSwapBuffersWithDamageKHR"
<< "(" << dpy << ", " << surface << ", "
<< static_cast<const void*>(rects) << ", " << n_rects << ")");
EGLBoolean result =
egl_api_->eglSwapBuffersWithDamageKHRFn(dpy, surface, rects, n_rects);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
GL_SERVICE_LOG("eglSwapInterval"
<< "(" << dpy << ", " << interval << ")");
EGLBoolean result = egl_api_->eglSwapIntervalFn(dpy, interval);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglTerminateFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglTerminate"
<< "(" << dpy << ")");
EGLBoolean result = egl_api_->eglTerminateFn(dpy);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglUnlockVulkanQueueANGLEFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglUnlockVulkanQueueANGLE"
<< "(" << dpy << ")");
egl_api_->eglUnlockVulkanQueueANGLEFn(dpy);
}
EGLBoolean LogEGLApi::eglWaitClientFn(void) {
GL_SERVICE_LOG("eglWaitClient"
<< "("
<< ")");
EGLBoolean result = egl_api_->eglWaitClientFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglWaitGLFn(void) {
GL_SERVICE_LOG("eglWaitGL"
<< "("
<< ")");
EGLBoolean result = egl_api_->eglWaitGLFn();
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLBoolean LogEGLApi::eglWaitNativeFn(EGLint engine) {
GL_SERVICE_LOG("eglWaitNative"
<< "(" << engine << ")");
EGLBoolean result = egl_api_->eglWaitNativeFn(engine);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglWaitSyncFn(EGLDisplay dpy, EGLSync sync, EGLint flags) {
GL_SERVICE_LOG("eglWaitSync"
<< "(" << dpy << ", " << sync << ", " << flags << ")");
EGLint result = egl_api_->eglWaitSyncFn(dpy, sync, flags);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
EGLint LogEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
EGLSyncKHR sync,
EGLint flags) {
GL_SERVICE_LOG("eglWaitSyncKHR"
<< "(" << dpy << ", " << sync << ", " << flags << ")");
EGLint result = egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
GL_SERVICE_LOG("GL_RESULT: " << result);
return result;
}
void LogEGLApi::eglWaitUntilWorkScheduledANGLEFn(EGLDisplay dpy) {
GL_SERVICE_LOG("eglWaitUntilWorkScheduledANGLE"
<< "(" << dpy << ")");
egl_api_->eglWaitUntilWorkScheduledANGLEFn(dpy);
}
}
