summaryrefslogtreecommitdiffstats
path: root/gfx/gl/GLLibraryEGL.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--gfx/gl/GLLibraryEGL.h993
1 files changed, 993 insertions, 0 deletions
diff --git a/gfx/gl/GLLibraryEGL.h b/gfx/gl/GLLibraryEGL.h
new file mode 100644
index 0000000000..de296508bb
--- /dev/null
+++ b/gfx/gl/GLLibraryEGL.h
@@ -0,0 +1,993 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GLLIBRARYEGL_H_
+#define GLLIBRARYEGL_H_
+
+#if defined(MOZ_X11)
+# include "mozilla/X11Util.h"
+#endif
+
+#include "base/platform_thread.h" // for PlatformThreadId
+#include "gfxEnv.h"
+#include "GLContext.h"
+#include "mozilla/EnumTypeTraits.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/StaticPtr.h"
+#include "nsISupports.h"
+#include "prlink.h"
+
+#include <bitset>
+#include <memory>
+#include <unordered_map>
+
+#ifdef MOZ_WIDGET_ANDROID
+# include "mozilla/ProfilerLabels.h"
+# include "AndroidBuild.h"
+#endif
+
+#if defined(MOZ_X11)
+# define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)mozilla::DefaultXDisplay())
+#else
+# define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
+#endif
+
+struct ID3D11Device;
+
+extern "C" {
+struct AHardwareBuffer;
+}
+
+namespace angle {
+class Platform;
+}
+
+namespace mozilla {
+
+namespace gfx {
+class DataSourceSurface;
+}
+
+namespace gl {
+
+class SymbolLoader;
+
+PRLibrary* LoadApitraceLibrary();
+
+void BeforeEGLCall(const char* funcName);
+void AfterEGLCall(const char* funcName);
+
+class EglDisplay;
+/**
+ * Known GL extensions that can be queried by
+ * IsExtensionSupported. The results of this are cached, and as
+ * such it's safe to use this even in performance critical code.
+ * If you add to this array, remember to add to the string names
+ * in GLLibraryEGL.cpp.
+ */
+enum class EGLLibExtension {
+ ANDROID_get_native_client_buffer,
+ ANGLE_device_creation,
+ ANGLE_device_creation_d3d11,
+ ANGLE_platform_angle,
+ ANGLE_platform_angle_d3d,
+ EXT_device_enumeration,
+ EXT_device_query,
+ EXT_platform_device,
+ MESA_platform_surfaceless,
+ Max
+};
+
+/**
+ * Known GL extensions that can be queried by
+ * IsExtensionSupported. The results of this are cached, and as
+ * such it's safe to use this even in performance critical code.
+ * If you add to this array, remember to add to the string names
+ * in GLLibraryEGL.cpp.
+ */
+enum class EGLExtension {
+ KHR_image_base,
+ KHR_image_pixmap,
+ KHR_gl_texture_2D_image,
+ ANGLE_surface_d3d_texture_2d_share_handle,
+ EXT_create_context_robustness,
+ KHR_image,
+ KHR_fence_sync,
+ KHR_wait_sync,
+ ANDROID_native_fence_sync,
+ EGL_ANDROID_image_crop,
+ ANGLE_d3d_share_handle_client_buffer,
+ KHR_create_context,
+ KHR_stream,
+ KHR_stream_consumer_gltexture,
+ NV_stream_consumer_gltexture_yuv,
+ ANGLE_stream_producer_d3d_texture,
+ KHR_surfaceless_context,
+ KHR_create_context_no_error,
+ MOZ_create_context_provoking_vertex_dont_care,
+ EXT_swap_buffers_with_damage,
+ KHR_swap_buffers_with_damage,
+ EXT_buffer_age,
+ KHR_partial_update,
+ NV_robustness_video_memory_purge,
+ EXT_image_dma_buf_import,
+ EXT_image_dma_buf_import_modifiers,
+ MESA_image_dma_buf_export,
+ KHR_no_config_context,
+ Max
+};
+
+// -
+
+class GLLibraryEGL final {
+ friend class EglDisplay;
+
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GLLibraryEGL)
+
+ private:
+ PRLibrary* mEGLLibrary = nullptr;
+ PRLibrary* mGLLibrary = nullptr;
+ bool mIsANGLE = false;
+ std::bitset<UnderlyingValue(EGLLibExtension::Max)> mAvailableExtensions;
+ std::weak_ptr<EglDisplay> mDefaultDisplay;
+ std::unordered_map<EGLDisplay, std::weak_ptr<EglDisplay>> mActiveDisplays;
+
+ public:
+ static RefPtr<GLLibraryEGL> Get(nsACString* const out_failureId);
+ static void Shutdown();
+
+ private:
+ ~GLLibraryEGL() = default;
+
+ static StaticMutex sMutex;
+ static StaticRefPtr<GLLibraryEGL> sInstance MOZ_GUARDED_BY(sMutex);
+
+ bool Init(nsACString* const out_failureId);
+ void InitLibExtensions();
+
+ std::shared_ptr<EglDisplay> CreateDisplayLocked(
+ bool forceAccel, nsACString* const out_failureId,
+ const StaticMutexAutoLock& aProofOfLock);
+
+ public:
+ Maybe<SymbolLoader> GetSymbolLoader() const;
+
+ std::shared_ptr<EglDisplay> CreateDisplay(bool forceAccel,
+ nsACString* const out_failureId);
+ std::shared_ptr<EglDisplay> CreateDisplay(ID3D11Device*);
+ std::shared_ptr<EglDisplay> DefaultDisplay(nsACString* const out_failureId);
+
+ bool IsExtensionSupported(EGLLibExtension aKnownExtension) const {
+ return mAvailableExtensions[UnderlyingValue(aKnownExtension)];
+ }
+
+ void MarkExtensionUnsupported(EGLLibExtension aKnownExtension) {
+ mAvailableExtensions[UnderlyingValue(aKnownExtension)] = false;
+ }
+
+ bool IsANGLE() const { return mIsANGLE; }
+
+ // -
+ // PFN wrappers
+
+#ifdef MOZ_WIDGET_ANDROID
+# define PROFILE_CALL AUTO_PROFILER_LABEL(__func__, GRAPHICS);
+#else
+# define PROFILE_CALL
+#endif
+
+#ifndef MOZ_FUNCTION_NAME
+# ifdef __GNUC__
+# define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
+# elif defined(_MSC_VER)
+# define MOZ_FUNCTION_NAME __FUNCTION__
+# else
+# define MOZ_FUNCTION_NAME \
+ __func__ // defined in C99, supported in various C++ compilers. Just raw
+ // function name.
+# endif
+#endif
+
+#ifdef DEBUG
+# define BEFORE_CALL BeforeEGLCall(MOZ_FUNCTION_NAME);
+# define AFTER_CALL AfterEGLCall(MOZ_FUNCTION_NAME);
+#else
+# define BEFORE_CALL
+# define AFTER_CALL
+#endif
+
+#define WRAP(X) \
+ PROFILE_CALL \
+ BEFORE_CALL \
+ const auto ret = mSymbols.X; \
+ AFTER_CALL \
+ return ret
+
+ public:
+ EGLDisplay fGetDisplay(void* display_id) const {
+ WRAP(fGetDisplay(display_id));
+ }
+
+ EGLDisplay fGetPlatformDisplay(EGLenum platform, void* native_display,
+ const EGLAttrib* attrib_list) const {
+ WRAP(fGetPlatformDisplay(platform, native_display, attrib_list));
+ }
+
+ EGLSurface fGetCurrentSurface(EGLint id) const {
+ WRAP(fGetCurrentSurface(id));
+ }
+
+ EGLContext fGetCurrentContext() const { WRAP(fGetCurrentContext()); }
+
+ EGLBoolean fBindAPI(EGLenum api) const { WRAP(fBindAPI(api)); }
+
+ EGLint fGetError() const { WRAP(fGetError()); }
+
+ EGLBoolean fWaitNative(EGLint engine) const { WRAP(fWaitNative(engine)); }
+
+ EGLCastToRelevantPtr fGetProcAddress(const char* procname) const {
+ WRAP(fGetProcAddress(procname));
+ }
+
+ // ANGLE_device_creation
+ EGLDeviceEXT fCreateDeviceANGLE(EGLint device_type, void* native_device,
+ const EGLAttrib* attrib_list) const {
+ WRAP(fCreateDeviceANGLE(device_type, native_device, attrib_list));
+ }
+
+ EGLBoolean fReleaseDeviceANGLE(EGLDeviceEXT device) {
+ WRAP(fReleaseDeviceANGLE(device));
+ }
+
+ // ANDROID_get_native_client_buffer
+ EGLClientBuffer fGetNativeClientBufferANDROID(
+ const struct AHardwareBuffer* buffer) {
+ WRAP(fGetNativeClientBufferANDROID(buffer));
+ }
+
+ private:
+ EGLBoolean fTerminate(EGLDisplay display) const { WRAP(fTerminate(display)); }
+
+ // -
+
+ mutable Mutex mMutex = Mutex{"GLLibraryEGL::mMutex"};
+ mutable std::unordered_map<EGLContext, PlatformThreadId>
+ mOwningThreadByContext MOZ_GUARDED_BY(mMutex);
+
+ EGLBoolean fMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
+ EGLContext ctx) const {
+ const bool CHECK_CONTEXT_OWNERSHIP = true;
+ if (CHECK_CONTEXT_OWNERSHIP) {
+ const MutexAutoLock lock(mMutex);
+ const auto tid = PlatformThread::CurrentId();
+ const auto prevCtx = fGetCurrentContext();
+
+ if (prevCtx) {
+ mOwningThreadByContext[prevCtx] = 0;
+ }
+ if (ctx) {
+ auto& ctxOwnerThread = mOwningThreadByContext[ctx];
+ if (ctxOwnerThread && ctxOwnerThread != tid) {
+ gfxCriticalError()
+ << "EGLContext#" << ctx << " is owned by/Current on"
+ << " thread#" << ctxOwnerThread << " but MakeCurrent requested on"
+ << " thread#" << tid << "!";
+ if (gfxEnv::MOZ_EGL_RELEASE_ASSERT_CONTEXT_OWNERSHIP()) {
+ MOZ_CRASH("MOZ_EGL_RELEASE_ASSERT_CONTEXT_OWNERSHIP");
+ }
+ return false;
+ }
+ ctxOwnerThread = tid;
+ }
+ }
+
+ // Always reset the TLS current context.
+ // If we're called by TLS-caching MakeCurrent, after we return true,
+ // the caller will set the TLS correctly anyway.
+ GLContext::ResetTLSCurrentContext();
+
+ WRAP(fMakeCurrent(dpy, draw, read, ctx));
+ }
+
+ // -
+
+ EGLBoolean fDestroyContext(EGLDisplay dpy, EGLContext ctx) const {
+ {
+ const MutexAutoLock lock(mMutex);
+ mOwningThreadByContext.erase(ctx);
+ }
+
+ WRAP(fDestroyContext(dpy, ctx));
+ }
+
+ EGLContext fCreateContext(EGLDisplay dpy, EGLConfig config,
+ EGLContext share_context,
+ const EGLint* attrib_list) const {
+ WRAP(fCreateContext(dpy, config, share_context, attrib_list));
+ }
+
+ EGLBoolean fDestroySurface(EGLDisplay dpy, EGLSurface surface) const {
+ WRAP(fDestroySurface(dpy, surface));
+ }
+
+ public:
+ EGLSurface fCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
+ EGLNativeWindowType win,
+ const EGLint* attrib_list) const {
+ WRAP(fCreateWindowSurface(dpy, config, win, attrib_list));
+ }
+
+ private:
+ EGLSurface fCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
+ const EGLint* attrib_list) const {
+ WRAP(fCreatePbufferSurface(dpy, config, attrib_list));
+ }
+
+ EGLSurface fCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
+ EGLClientBuffer buffer,
+ EGLConfig config,
+ const EGLint* attrib_list) const {
+ WRAP(fCreatePbufferFromClientBuffer(dpy, buftype, buffer, config,
+ attrib_list));
+ }
+
+ EGLSurface fCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
+ EGLNativePixmapType pixmap,
+ const EGLint* attrib_list) const {
+ WRAP(fCreatePixmapSurface(dpy, config, pixmap, attrib_list));
+ }
+
+ EGLBoolean fInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) const {
+ WRAP(fInitialize(dpy, major, minor));
+ }
+
+ EGLBoolean fChooseConfig(EGLDisplay dpy, const EGLint* attrib_list,
+ EGLConfig* configs, EGLint config_size,
+ EGLint* num_config) const {
+ WRAP(fChooseConfig(dpy, attrib_list, configs, config_size, num_config));
+ }
+
+ EGLBoolean fGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
+ EGLint attribute, EGLint* value) const {
+ WRAP(fGetConfigAttrib(dpy, config, attribute, value));
+ }
+
+ EGLBoolean fGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size,
+ EGLint* num_config) const {
+ WRAP(fGetConfigs(dpy, configs, config_size, num_config));
+ }
+
+ EGLBoolean fSwapBuffers(EGLDisplay dpy, EGLSurface surface) const {
+ WRAP(fSwapBuffers(dpy, surface));
+ }
+
+ EGLBoolean fCopyBuffers(EGLDisplay dpy, EGLSurface surface,
+ EGLNativePixmapType target) const {
+ WRAP(fCopyBuffers(dpy, surface, target));
+ }
+
+ public:
+ const GLubyte* fQueryString(EGLDisplay dpy, EGLint name) const {
+ WRAP(fQueryString(dpy, name));
+ }
+
+ private:
+ EGLBoolean fQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
+ EGLint* value) const {
+ WRAP(fQueryContext(dpy, ctx, attribute, value));
+ }
+
+ EGLBoolean fBindTexImage(EGLDisplay dpy, EGLSurface surface,
+ EGLint buffer) const {
+ WRAP(fBindTexImage(dpy, surface, buffer));
+ }
+
+ EGLBoolean fReleaseTexImage(EGLDisplay dpy, EGLSurface surface,
+ EGLint buffer) const {
+ WRAP(fReleaseTexImage(dpy, surface, buffer));
+ }
+
+ EGLBoolean fSwapInterval(EGLDisplay dpy, EGLint interval) const {
+ WRAP(fSwapInterval(dpy, interval));
+ }
+
+ EGLImage fCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target,
+ EGLClientBuffer buffer,
+ const EGLint* attrib_list) const {
+ WRAP(fCreateImageKHR(dpy, ctx, target, buffer, attrib_list));
+ }
+
+ EGLBoolean fDestroyImage(EGLDisplay dpy, EGLImage image) const {
+ WRAP(fDestroyImageKHR(dpy, image));
+ }
+
+ EGLBoolean fQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
+ EGLint* value) const {
+ WRAP(fQuerySurface(dpy, surface, attribute, value));
+ }
+
+ EGLBoolean fQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface,
+ EGLint attribute, void** value) const {
+ WRAP(fQuerySurfacePointerANGLE(dpy, surface, attribute, value));
+ }
+
+ EGLSync fCreateSync(EGLDisplay dpy, EGLenum type,
+ const EGLint* attrib_list) const {
+ WRAP(fCreateSyncKHR(dpy, type, attrib_list));
+ }
+
+ EGLBoolean fDestroySync(EGLDisplay dpy, EGLSync sync) const {
+ WRAP(fDestroySyncKHR(dpy, sync));
+ }
+
+ EGLint fClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags,
+ EGLTime timeout) const {
+ WRAP(fClientWaitSyncKHR(dpy, sync, flags, timeout));
+ }
+
+ EGLBoolean fGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute,
+ EGLint* value) const {
+ WRAP(fGetSyncAttribKHR(dpy, sync, attribute, value));
+ }
+
+ EGLint fWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) const {
+ WRAP(fWaitSyncKHR(dpy, sync, flags));
+ }
+
+ EGLint fDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync) const {
+ WRAP(fDupNativeFenceFDANDROID(dpy, sync));
+ }
+
+ // KHR_stream
+ EGLStreamKHR fCreateStreamKHR(EGLDisplay dpy,
+ const EGLint* attrib_list) const {
+ WRAP(fCreateStreamKHR(dpy, attrib_list));
+ }
+
+ EGLBoolean fDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) const {
+ WRAP(fDestroyStreamKHR(dpy, stream));
+ }
+
+ EGLBoolean fQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream,
+ EGLenum attribute, EGLint* value) const {
+ WRAP(fQueryStreamKHR(dpy, stream, attribute, value));
+ }
+
+ // KHR_stream_consumer_gltexture
+ EGLBoolean fStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
+ EGLStreamKHR stream) const {
+ WRAP(fStreamConsumerGLTextureExternalKHR(dpy, stream));
+ }
+
+ EGLBoolean fStreamConsumerAcquireKHR(EGLDisplay dpy,
+ EGLStreamKHR stream) const {
+ WRAP(fStreamConsumerAcquireKHR(dpy, stream));
+ }
+
+ EGLBoolean fStreamConsumerReleaseKHR(EGLDisplay dpy,
+ EGLStreamKHR stream) const {
+ WRAP(fStreamConsumerReleaseKHR(dpy, stream));
+ }
+
+ // EXT_device_query
+ EGLBoolean fQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute,
+ EGLAttrib* value) const {
+ WRAP(fQueryDisplayAttribEXT(dpy, attribute, value));
+ }
+
+ public:
+ EGLBoolean fQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute,
+ EGLAttrib* value) const {
+ WRAP(fQueryDeviceAttribEXT(device, attribute, value));
+ }
+
+ const char* fQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name) {
+ WRAP(fQueryDeviceStringEXT(device, name));
+ }
+
+ private:
+ // NV_stream_consumer_gltexture_yuv
+ EGLBoolean fStreamConsumerGLTextureExternalAttribsNV(
+ EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
+ WRAP(fStreamConsumerGLTextureExternalAttribsNV(dpy, stream, attrib_list));
+ }
+
+ // ANGLE_stream_producer_d3d_texture
+ EGLBoolean fCreateStreamProducerD3DTextureANGLE(
+ EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
+ WRAP(fCreateStreamProducerD3DTextureANGLE(dpy, stream, attrib_list));
+ }
+
+ EGLBoolean fStreamPostD3DTextureANGLE(EGLDisplay dpy, EGLStreamKHR stream,
+ void* texture,
+ const EGLAttrib* attrib_list) const {
+ WRAP(fStreamPostD3DTextureANGLE(dpy, stream, texture, attrib_list));
+ }
+
+ // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
+ EGLBoolean fSwapBuffersWithDamage(EGLDisplay dpy, EGLSurface surface,
+ const EGLint* rects, EGLint n_rects) {
+ WRAP(fSwapBuffersWithDamage(dpy, surface, rects, n_rects));
+ }
+
+ // EGL_KHR_partial_update
+ EGLBoolean fSetDamageRegion(EGLDisplay dpy, EGLSurface surface,
+ const EGLint* rects, EGLint n_rects) {
+ WRAP(fSetDamageRegion(dpy, surface, rects, n_rects));
+ }
+ // EGL_MESA_image_dma_buf_export
+ EGLBoolean fExportDMABUFImageQuery(EGLDisplay dpy, EGLImage image,
+ int* fourcc, int* num_planes,
+ uint64_t* modifiers) {
+ WRAP(
+ fExportDMABUFImageQueryMESA(dpy, image, fourcc, num_planes, modifiers));
+ }
+ EGLBoolean fExportDMABUFImage(EGLDisplay dpy, EGLImage image, int* fds,
+ EGLint* strides, EGLint* offsets) {
+ WRAP(fExportDMABUFImageMESA(dpy, image, fds, strides, offsets));
+ }
+
+ public:
+ // EGL_EXT_device_enumeration
+ EGLBoolean fQueryDevicesEXT(EGLint max_devices, EGLDeviceEXT* devices,
+ EGLint* num_devices) {
+ WRAP(fQueryDevicesEXT(max_devices, devices, num_devices));
+ }
+
+#undef WRAP
+
+#undef WRAP
+#undef PROFILE_CALL
+#undef BEFORE_CALL
+#undef AFTER_CALL
+#undef MOZ_FUNCTION_NAME
+
+ ////
+
+ private:
+ struct {
+ EGLCastToRelevantPtr(GLAPIENTRY* fGetProcAddress)(const char* procname);
+ EGLDisplay(GLAPIENTRY* fGetDisplay)(void* display_id);
+ EGLDisplay(GLAPIENTRY* fGetPlatformDisplay)(EGLenum platform,
+ void* native_display,
+ const EGLAttrib* attrib_list);
+ EGLBoolean(GLAPIENTRY* fTerminate)(EGLDisplay dpy);
+ EGLSurface(GLAPIENTRY* fGetCurrentSurface)(EGLint);
+ EGLContext(GLAPIENTRY* fGetCurrentContext)(void);
+ EGLBoolean(GLAPIENTRY* fMakeCurrent)(EGLDisplay dpy, EGLSurface draw,
+ EGLSurface read, EGLContext ctx);
+ EGLBoolean(GLAPIENTRY* fDestroyContext)(EGLDisplay dpy, EGLContext ctx);
+ EGLContext(GLAPIENTRY* fCreateContext)(EGLDisplay dpy, EGLConfig config,
+ EGLContext share_context,
+ const EGLint* attrib_list);
+ EGLBoolean(GLAPIENTRY* fDestroySurface)(EGLDisplay dpy, EGLSurface surface);
+ EGLSurface(GLAPIENTRY* fCreateWindowSurface)(EGLDisplay dpy,
+ EGLConfig config,
+ EGLNativeWindowType win,
+ const EGLint* attrib_list);
+ EGLSurface(GLAPIENTRY* fCreatePbufferSurface)(EGLDisplay dpy,
+ EGLConfig config,
+ const EGLint* attrib_list);
+ EGLSurface(GLAPIENTRY* fCreatePbufferFromClientBuffer)(
+ EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
+ EGLConfig config, const EGLint* attrib_list);
+ EGLSurface(GLAPIENTRY* fCreatePixmapSurface)(EGLDisplay dpy,
+ EGLConfig config,
+ EGLNativePixmapType pixmap,
+ const EGLint* attrib_list);
+ EGLBoolean(GLAPIENTRY* fBindAPI)(EGLenum api);
+ EGLBoolean(GLAPIENTRY* fInitialize)(EGLDisplay dpy, EGLint* major,
+ EGLint* minor);
+ EGLBoolean(GLAPIENTRY* fChooseConfig)(EGLDisplay dpy,
+ const EGLint* attrib_list,
+ EGLConfig* configs,
+ EGLint config_size,
+ EGLint* num_config);
+ EGLint(GLAPIENTRY* fGetError)(void);
+ EGLBoolean(GLAPIENTRY* fGetConfigAttrib)(EGLDisplay dpy, EGLConfig config,
+ EGLint attribute, EGLint* value);
+ EGLBoolean(GLAPIENTRY* fGetConfigs)(EGLDisplay dpy, EGLConfig* configs,
+ EGLint config_size, EGLint* num_config);
+ EGLBoolean(GLAPIENTRY* fWaitNative)(EGLint engine);
+ EGLBoolean(GLAPIENTRY* fSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
+ EGLBoolean(GLAPIENTRY* fCopyBuffers)(EGLDisplay dpy, EGLSurface surface,
+ EGLNativePixmapType target);
+ const GLubyte*(GLAPIENTRY* fQueryString)(EGLDisplay, EGLint name);
+ EGLBoolean(GLAPIENTRY* fQueryContext)(EGLDisplay dpy, EGLContext ctx,
+ EGLint attribute, EGLint* value);
+ EGLBoolean(GLAPIENTRY* fBindTexImage)(EGLDisplay, EGLSurface surface,
+ EGLint buffer);
+ EGLBoolean(GLAPIENTRY* fReleaseTexImage)(EGLDisplay, EGLSurface surface,
+ EGLint buffer);
+ EGLBoolean(GLAPIENTRY* fSwapInterval)(EGLDisplay dpy, EGLint interval);
+ EGLImage(GLAPIENTRY* fCreateImageKHR)(EGLDisplay dpy, EGLContext ctx,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const EGLint* attrib_list);
+ EGLBoolean(GLAPIENTRY* fDestroyImageKHR)(EGLDisplay dpy, EGLImage image);
+ EGLBoolean(GLAPIENTRY* fQuerySurface)(EGLDisplay dpy, EGLSurface surface,
+ EGLint attribute, EGLint* value);
+ EGLBoolean(GLAPIENTRY* fQuerySurfacePointerANGLE)(EGLDisplay dpy,
+ EGLSurface surface,
+ EGLint attribute,
+ void** value);
+ EGLSync(GLAPIENTRY* fCreateSyncKHR)(EGLDisplay dpy, EGLenum type,
+ const EGLint* attrib_list);
+ EGLBoolean(GLAPIENTRY* fDestroySyncKHR)(EGLDisplay dpy, EGLSync sync);
+ EGLint(GLAPIENTRY* fClientWaitSyncKHR)(EGLDisplay dpy, EGLSync sync,
+ EGLint flags, EGLTime timeout);
+ EGLBoolean(GLAPIENTRY* fGetSyncAttribKHR)(EGLDisplay dpy, EGLSync sync,
+ EGLint attribute, EGLint* value);
+ EGLint(GLAPIENTRY* fWaitSyncKHR)(EGLDisplay dpy, EGLSync sync,
+ EGLint flags);
+ EGLint(GLAPIENTRY* fDupNativeFenceFDANDROID)(EGLDisplay dpy, EGLSync sync);
+ // KHR_stream
+ EGLStreamKHR(GLAPIENTRY* fCreateStreamKHR)(EGLDisplay dpy,
+ const EGLint* attrib_list);
+ EGLBoolean(GLAPIENTRY* fDestroyStreamKHR)(EGLDisplay dpy,
+ EGLStreamKHR stream);
+ EGLBoolean(GLAPIENTRY* fQueryStreamKHR)(EGLDisplay dpy, EGLStreamKHR stream,
+ EGLenum attribute, EGLint* value);
+ // KHR_stream_consumer_gltexture
+ EGLBoolean(GLAPIENTRY* fStreamConsumerGLTextureExternalKHR)(
+ EGLDisplay dpy, EGLStreamKHR stream);
+ EGLBoolean(GLAPIENTRY* fStreamConsumerAcquireKHR)(EGLDisplay dpy,
+ EGLStreamKHR stream);
+ EGLBoolean(GLAPIENTRY* fStreamConsumerReleaseKHR)(EGLDisplay dpy,
+ EGLStreamKHR stream);
+ // EXT_device_query
+ EGLBoolean(GLAPIENTRY* fQueryDisplayAttribEXT)(EGLDisplay dpy,
+ EGLint attribute,
+ EGLAttrib* value);
+ EGLBoolean(GLAPIENTRY* fQueryDeviceAttribEXT)(EGLDeviceEXT device,
+ EGLint attribute,
+ EGLAttrib* value);
+ const char*(GLAPIENTRY* fQueryDeviceStringEXT)(EGLDeviceEXT device,
+ EGLint name);
+
+ // NV_stream_consumer_gltexture_yuv
+ EGLBoolean(GLAPIENTRY* fStreamConsumerGLTextureExternalAttribsNV)(
+ EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list);
+ // ANGLE_stream_producer_d3d_texture
+ EGLBoolean(GLAPIENTRY* fCreateStreamProducerD3DTextureANGLE)(
+ EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list);
+ EGLBoolean(GLAPIENTRY* fStreamPostD3DTextureANGLE)(
+ EGLDisplay dpy, EGLStreamKHR stream, void* texture,
+ const EGLAttrib* attrib_list);
+ // ANGLE_device_creation
+ EGLDeviceEXT(GLAPIENTRY* fCreateDeviceANGLE)(EGLint device_type,
+ void* native_device,
+ const EGLAttrib* attrib_list);
+ EGLBoolean(GLAPIENTRY* fReleaseDeviceANGLE)(EGLDeviceEXT device);
+ // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
+ EGLBoolean(GLAPIENTRY* fSwapBuffersWithDamage)(EGLDisplay dpy,
+ EGLSurface surface,
+ const EGLint* rects,
+ EGLint n_rects);
+ // EGL_KHR_partial_update
+ EGLBoolean(GLAPIENTRY* fSetDamageRegion)(EGLDisplay dpy, EGLSurface surface,
+ const EGLint* rects,
+ EGLint n_rects);
+ EGLClientBuffer(GLAPIENTRY* fGetNativeClientBufferANDROID)(
+ const struct AHardwareBuffer* buffer);
+
+ // EGL_MESA_image_dma_buf_export
+ EGLBoolean(GLAPIENTRY* fExportDMABUFImageQueryMESA)(EGLDisplay dpy,
+ EGLImage image,
+ int* fourcc,
+ int* num_planes,
+ uint64_t* modifiers);
+ EGLBoolean(GLAPIENTRY* fExportDMABUFImageMESA)(EGLDisplay dpy,
+ EGLImage image, int* fds,
+ EGLint* strides,
+ EGLint* offsets);
+
+ EGLBoolean(GLAPIENTRY* fQueryDevicesEXT)(EGLint max_devices,
+ EGLDeviceEXT* devices,
+ EGLint* num_devices);
+
+ } mSymbols = {};
+};
+
+static bool ShouldLeakEglDisplay() {
+ // We are seeing crashes in eglTerminate on the Samsung S22 family of devices
+ // running Android 14, so we leak the EGLDisplay rather than call
+ // eglTerminate.
+#ifdef MOZ_WIDGET_ANDROID
+ if (jni::GetAPIVersion() >= 34) {
+ const auto board = java::sdk::Build::BOARD()->ToString();
+ if (board.EqualsASCII("s5e9925")) {
+ return true;
+ }
+ }
+#endif
+ return false;
+}
+
+class EglDisplay final {
+ public:
+ const RefPtr<GLLibraryEGL> mLib;
+ const EGLDisplay mDisplay;
+ const bool mIsWARP;
+
+ private:
+ std::bitset<UnderlyingValue(EGLExtension::Max)> mAvailableExtensions;
+
+ struct PrivateUseOnly final {};
+
+ public:
+ static std::shared_ptr<EglDisplay> Create(
+ GLLibraryEGL&, EGLDisplay, bool isWarp,
+ const StaticMutexAutoLock& aProofOfLock);
+
+ // Only `public` for make_shared.
+ EglDisplay(const PrivateUseOnly&, GLLibraryEGL&, EGLDisplay, bool isWarp);
+
+ public:
+ ~EglDisplay();
+
+ bool IsExtensionSupported(EGLExtension aKnownExtension) const {
+ return mAvailableExtensions[UnderlyingValue(aKnownExtension)];
+ }
+
+ void MarkExtensionUnsupported(EGLExtension aKnownExtension) {
+ mAvailableExtensions[UnderlyingValue(aKnownExtension)] = false;
+ }
+
+ void DumpEGLConfig(EGLConfig) const;
+ void DumpEGLConfigs() const;
+
+ void Shutdown();
+
+ // -
+
+ bool HasKHRImageBase() const {
+ return IsExtensionSupported(EGLExtension::KHR_image) ||
+ IsExtensionSupported(EGLExtension::KHR_image_base);
+ }
+
+ bool HasKHRImagePixmap() const {
+ return IsExtensionSupported(EGLExtension::KHR_image) ||
+ IsExtensionSupported(EGLExtension::KHR_image_pixmap);
+ }
+
+ // -
+
+ EGLBoolean fTerminate() {
+ static const bool shouldLeak = ShouldLeakEglDisplay();
+ if (shouldLeak) {
+ return LOCAL_EGL_TRUE;
+ }
+ return mLib->fTerminate(mDisplay);
+ }
+
+ EGLBoolean fMakeCurrent(EGLSurface draw, EGLSurface read,
+ EGLContext ctx) const {
+ return mLib->fMakeCurrent(mDisplay, draw, read, ctx);
+ }
+
+ EGLBoolean fDestroyContext(EGLContext ctx) const {
+ return mLib->fDestroyContext(mDisplay, ctx);
+ }
+
+ EGLContext fCreateContext(EGLConfig config, EGLContext share_context,
+ const EGLint* attrib_list) const {
+ return mLib->fCreateContext(mDisplay, config, share_context, attrib_list);
+ }
+
+ EGLBoolean fDestroySurface(EGLSurface surface) const {
+ return mLib->fDestroySurface(mDisplay, surface);
+ }
+
+ EGLSurface fCreateWindowSurface(EGLConfig config, EGLNativeWindowType win,
+ const EGLint* attrib_list) const {
+ return mLib->fCreateWindowSurface(mDisplay, config, win, attrib_list);
+ }
+
+ EGLSurface fCreatePbufferSurface(EGLConfig config,
+ const EGLint* attrib_list) const {
+ return mLib->fCreatePbufferSurface(mDisplay, config, attrib_list);
+ }
+
+ EGLSurface fCreatePbufferFromClientBuffer(EGLenum buftype,
+ EGLClientBuffer buffer,
+ EGLConfig config,
+ const EGLint* attrib_list) const {
+ return mLib->fCreatePbufferFromClientBuffer(mDisplay, buftype, buffer,
+ config, attrib_list);
+ }
+
+ EGLBoolean fChooseConfig(const EGLint* attrib_list, EGLConfig* configs,
+ EGLint config_size, EGLint* num_config) const {
+ return mLib->fChooseConfig(mDisplay, attrib_list, configs, config_size,
+ num_config);
+ }
+
+ EGLBoolean fGetConfigAttrib(EGLConfig config, EGLint attribute,
+ EGLint* value) const {
+ return mLib->fGetConfigAttrib(mDisplay, config, attribute, value);
+ }
+
+ EGLBoolean fGetConfigs(EGLConfig* configs, EGLint config_size,
+ EGLint* num_config) const {
+ return mLib->fGetConfigs(mDisplay, configs, config_size, num_config);
+ }
+
+ EGLBoolean fSwapBuffers(EGLSurface surface) const {
+ return mLib->fSwapBuffers(mDisplay, surface);
+ }
+
+ EGLBoolean fBindTexImage(EGLSurface surface, EGLint buffer) const {
+ return mLib->fBindTexImage(mDisplay, surface, buffer);
+ }
+
+ EGLBoolean fReleaseTexImage(EGLSurface surface, EGLint buffer) const {
+ return mLib->fReleaseTexImage(mDisplay, surface, buffer);
+ }
+
+ EGLBoolean fSwapInterval(EGLint interval) const {
+ return mLib->fSwapInterval(mDisplay, interval);
+ }
+
+ EGLImage fCreateImage(EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
+ const EGLint* attribList) const {
+ MOZ_ASSERT(HasKHRImageBase());
+ return mLib->fCreateImage(mDisplay, ctx, target, buffer, attribList);
+ }
+
+ EGLBoolean fDestroyImage(EGLImage image) const {
+ MOZ_ASSERT(HasKHRImageBase());
+ return mLib->fDestroyImage(mDisplay, image);
+ }
+
+ EGLBoolean fQuerySurface(EGLSurface surface, EGLint attribute,
+ EGLint* value) const {
+ return mLib->fQuerySurface(mDisplay, surface, attribute, value);
+ }
+
+ EGLBoolean fQuerySurfacePointerANGLE(EGLSurface surface, EGLint attribute,
+ void** value) const {
+ MOZ_ASSERT(IsExtensionSupported(
+ EGLExtension::ANGLE_surface_d3d_texture_2d_share_handle));
+ return mLib->fQuerySurfacePointerANGLE(mDisplay, surface, attribute, value);
+ }
+
+ EGLSync fCreateSync(EGLenum type, const EGLint* attrib_list) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
+ return mLib->fCreateSync(mDisplay, type, attrib_list);
+ }
+
+ EGLBoolean fDestroySync(EGLSync sync) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
+ return mLib->fDestroySync(mDisplay, sync);
+ }
+
+ EGLint fClientWaitSync(EGLSync sync, EGLint flags, EGLTime timeout) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
+ return mLib->fClientWaitSync(mDisplay, sync, flags, timeout);
+ }
+
+ EGLBoolean fGetSyncAttrib(EGLSync sync, EGLint attribute,
+ EGLint* value) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
+ return mLib->fGetSyncAttrib(mDisplay, sync, attribute, value);
+ }
+
+ EGLint fWaitSync(EGLSync sync, EGLint flags) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_wait_sync));
+ return mLib->fWaitSync(mDisplay, sync, flags);
+ }
+
+ EGLint fDupNativeFenceFDANDROID(EGLSync sync) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::ANDROID_native_fence_sync));
+ return mLib->fDupNativeFenceFDANDROID(mDisplay, sync);
+ }
+
+ // EXT_device_query
+ EGLBoolean fQueryDisplayAttribEXT(EGLint attribute, EGLAttrib* value) const {
+ MOZ_ASSERT(mLib->IsExtensionSupported(EGLLibExtension::EXT_device_query));
+ return mLib->fQueryDisplayAttribEXT(mDisplay, attribute, value);
+ }
+
+ // KHR_stream
+ EGLStreamKHR fCreateStreamKHR(const EGLint* attrib_list) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
+ return mLib->fCreateStreamKHR(mDisplay, attrib_list);
+ }
+
+ EGLBoolean fDestroyStreamKHR(EGLStreamKHR stream) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
+ return mLib->fDestroyStreamKHR(mDisplay, stream);
+ }
+
+ EGLBoolean fQueryStreamKHR(EGLStreamKHR stream, EGLenum attribute,
+ EGLint* value) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
+ return mLib->fQueryStreamKHR(mDisplay, stream, attribute, value);
+ }
+
+ // KHR_stream_consumer_gltexture
+ EGLBoolean fStreamConsumerGLTextureExternalKHR(EGLStreamKHR stream) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
+ return mLib->fStreamConsumerGLTextureExternalKHR(mDisplay, stream);
+ }
+
+ EGLBoolean fStreamConsumerAcquireKHR(EGLStreamKHR stream) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
+ return mLib->fStreamConsumerAcquireKHR(mDisplay, stream);
+ }
+
+ EGLBoolean fStreamConsumerReleaseKHR(EGLStreamKHR stream) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
+ return mLib->fStreamConsumerReleaseKHR(mDisplay, stream);
+ }
+
+ // NV_stream_consumer_gltexture_yuv
+ EGLBoolean fStreamConsumerGLTextureExternalAttribsNV(
+ EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::NV_stream_consumer_gltexture_yuv));
+ return mLib->fStreamConsumerGLTextureExternalAttribsNV(mDisplay, stream,
+ attrib_list);
+ }
+
+ // ANGLE_stream_producer_d3d_texture
+ EGLBoolean fCreateStreamProducerD3DTextureANGLE(
+ EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::ANGLE_stream_producer_d3d_texture));
+ return mLib->fCreateStreamProducerD3DTextureANGLE(mDisplay, stream,
+ attrib_list);
+ }
+
+ EGLBoolean fStreamPostD3DTextureANGLE(EGLStreamKHR stream, void* texture,
+ const EGLAttrib* attrib_list) const {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::ANGLE_stream_producer_d3d_texture));
+ return mLib->fStreamPostD3DTextureANGLE(mDisplay, stream, texture,
+ attrib_list);
+ }
+
+ // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
+ EGLBoolean fSwapBuffersWithDamage(EGLSurface surface, const EGLint* rects,
+ EGLint n_rects) {
+ MOZ_ASSERT(
+ IsExtensionSupported(EGLExtension::EXT_swap_buffers_with_damage) ||
+ IsExtensionSupported(EGLExtension::KHR_swap_buffers_with_damage));
+ return mLib->fSwapBuffersWithDamage(mDisplay, surface, rects, n_rects);
+ }
+
+ // EGL_KHR_partial_update
+ EGLBoolean fSetDamageRegion(EGLSurface surface, const EGLint* rects,
+ EGLint n_rects) {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_partial_update));
+ return mLib->fSetDamageRegion(mDisplay, surface, rects, n_rects);
+ }
+
+ EGLBoolean fExportDMABUFImageQuery(EGLImage image, int* fourcc,
+ int* num_planes,
+ uint64_t* modifiers) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::MESA_image_dma_buf_export));
+ return mLib->fExportDMABUFImageQuery(mDisplay, image, fourcc, num_planes,
+ modifiers);
+ }
+ EGLBoolean fExportDMABUFImage(EGLImage image, int* fds, EGLint* strides,
+ EGLint* offsets) const {
+ MOZ_ASSERT(IsExtensionSupported(EGLExtension::MESA_image_dma_buf_export));
+ return mLib->fExportDMABUFImage(mDisplay, image, fds, strides, offsets);
+ }
+};
+
+} /* namespace gl */
+} /* namespace mozilla */
+
+#endif /* GLLIBRARYEGL_H_ */