gfx/gl/GLLibraryEGL.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef GLLIBRARYEGL_H_
   6 #define GLLIBRARYEGL_H_
   7
   8 #if defined(MOZ_X11)
   9 #  include "mozilla/X11Util.h"
  10 #endif
  11
  12 #include "GLTypes.h"
  13 #include "mozilla/EnumTypeTraits.h"
  14 #include "mozilla/Maybe.h"
  15 #include "mozilla/RefPtr.h"
  16 #include "mozilla/StaticMutex.h"
  17 #include "mozilla/StaticPtr.h"
  18 #include "nsISupports.h"
  19 #include "prlink.h"
  20
  21 #include <bitset>
  22 #include <memory>
  23 #include <unordered_map>
  24
  25 #ifdef MOZ_WIDGET_ANDROID
  26 #  include "mozilla/ProfilerLabels.h"
  27 #endif
  28
  29 #if defined(MOZ_X11)
  30 #  define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)mozilla::DefaultXDisplay())
  31 #else
  32 #  define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
  33 #endif
  34
  35 struct ID3D11Device;
  36
  37 extern "C" {
  38 struct AHardwareBuffer;
  39 }
  40
  41 namespace angle {
  42 class Platform;
  43 }
  44
  45 namespace mozilla {
  46
  47 namespace gfx {
  48 class DataSourceSurface;
  49 }
  50
  51 namespace gl {
  52
  53 class SymbolLoader;
  54
  55 PRLibrary* LoadApitraceLibrary();
  56
  57 void BeforeEGLCall(const char* funcName);
  58 void AfterEGLCall(const char* funcName);
  59
  60 class EglDisplay;
  61 /**
  62  * Known GL extensions that can be queried by
  63  * IsExtensionSupported.  The results of this are cached, and as
  64  * such it's safe to use this even in performance critical code.
  65  * If you add to this array, remember to add to the string names
  66  * in GLLibraryEGL.cpp.
  67  */
  68 enum class EGLLibExtension {
  69   ANDROID_get_native_client_buffer,
  70   ANGLE_device_creation,
  71   ANGLE_device_creation_d3d11,
  72   ANGLE_platform_angle,
  73   ANGLE_platform_angle_d3d,
  74   EXT_device_enumeration,
  75   EXT_device_query,
  76   EXT_platform_device,
  77   MESA_platform_surfaceless,
  78   Max
  79 };
  80
  81 /**
  82  * Known GL extensions that can be queried by
  83  * IsExtensionSupported.  The results of this are cached, and as
  84  * such it's safe to use this even in performance critical code.
  85  * If you add to this array, remember to add to the string names
  86  * in GLLibraryEGL.cpp.
  87  */
  88 enum class EGLExtension {
  89   KHR_image_base,
  90   KHR_image_pixmap,
  91   KHR_gl_texture_2D_image,
  92   ANGLE_surface_d3d_texture_2d_share_handle,
  93   EXT_create_context_robustness,
  94   KHR_image,
  95   KHR_fence_sync,
  96   KHR_wait_sync,
  97   ANDROID_native_fence_sync,
  98   EGL_ANDROID_image_crop,
  99   ANGLE_d3d_share_handle_client_buffer,
 100   KHR_create_context,
 101   KHR_stream,
 102   KHR_stream_consumer_gltexture,
 103   NV_stream_consumer_gltexture_yuv,
 104   ANGLE_stream_producer_d3d_texture,
 105   KHR_surfaceless_context,
 106   KHR_create_context_no_error,
 107   MOZ_create_context_provoking_vertex_dont_care,
 108   EXT_swap_buffers_with_damage,
 109   KHR_swap_buffers_with_damage,
 110   EXT_buffer_age,
 111   KHR_partial_update,
 112   NV_robustness_video_memory_purge,
 113   EXT_image_dma_buf_import,
 114   EXT_image_dma_buf_import_modifiers,
 115   MESA_image_dma_buf_export,
 116   Max
 117 };
 118
 119 // -
 120
 121 class GLLibraryEGL final {
 122   friend class EglDisplay;
 123
 124  public:
 125   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GLLibraryEGL)
 126
 127  private:
 128   PRLibrary* mEGLLibrary = nullptr;
 129   PRLibrary* mGLLibrary = nullptr;
 130   bool mIsANGLE = false;
 131   std::bitset<UnderlyingValue(EGLLibExtension::Max)> mAvailableExtensions;
 132   std::weak_ptr<EglDisplay> mDefaultDisplay;
 133   std::unordered_map<EGLDisplay, std::weak_ptr<EglDisplay>> mActiveDisplays;
 134
 135  public:
 136   static RefPtr<GLLibraryEGL> Get(nsACString* const out_failureId);
 137   static void Shutdown();
 138
 139  private:
 140   ~GLLibraryEGL() = default;
 141
 142   static StaticMutex sMutex;
 143   static StaticRefPtr<GLLibraryEGL> sInstance GUARDED_BY(sMutex);
 144
 145   bool Init(nsACString* const out_failureId);
 146   void InitLibExtensions();
 147
 148   std::shared_ptr<EglDisplay> CreateDisplayLocked(
 149       bool forceAccel, nsACString* const out_failureId,
 150       const StaticMutexAutoLock& aProofOfLock);
 151
 152  public:
 153   Maybe<SymbolLoader> GetSymbolLoader() const;
 154
 155   std::shared_ptr<EglDisplay> CreateDisplay(bool forceAccel,
 156                                             nsACString* const out_failureId);
 157   std::shared_ptr<EglDisplay> CreateDisplay(ID3D11Device*);
 158   std::shared_ptr<EglDisplay> DefaultDisplay(nsACString* const out_failureId);
 159
 160   bool IsExtensionSupported(EGLLibExtension aKnownExtension) const {
 161     return mAvailableExtensions[UnderlyingValue(aKnownExtension)];
 162   }
 163
 164   void MarkExtensionUnsupported(EGLLibExtension aKnownExtension) {
 165     mAvailableExtensions[UnderlyingValue(aKnownExtension)] = false;
 166   }
 167
 168   bool IsANGLE() const { return mIsANGLE; }
 169
 170   // -
 171   // PFN wrappers
 172
 173 #ifdef MOZ_WIDGET_ANDROID
 174 #  define PROFILE_CALL AUTO_PROFILER_LABEL(__func__, GRAPHICS);
 175 #else
 176 #  define PROFILE_CALL
 177 #endif
 178
 179 #ifndef MOZ_FUNCTION_NAME
 180 #  ifdef __GNUC__
 181 #    define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
 182 #  elif defined(_MSC_VER)
 183 #    define MOZ_FUNCTION_NAME __FUNCTION__
 184 #  else
 185 #    define MOZ_FUNCTION_NAME \
 186       __func__  // defined in C99, supported in various C++ compilers. Just raw
 187                 // function name.
 188 #  endif
 189 #endif
 190
 191 #ifdef DEBUG
 192 #  define BEFORE_CALL BeforeEGLCall(MOZ_FUNCTION_NAME);
 193 #  define AFTER_CALL AfterEGLCall(MOZ_FUNCTION_NAME);
 194 #else
 195 #  define BEFORE_CALL
 196 #  define AFTER_CALL
 197 #endif
 198
 199 #define WRAP(X)                \
 200   PROFILE_CALL                 \
 201   BEFORE_CALL                  \
 202   const auto ret = mSymbols.X; \
 203   AFTER_CALL                   \
 204   return ret
 205
 206  public:
 207   EGLDisplay fGetDisplay(void* display_id) const {
 208     WRAP(fGetDisplay(display_id));
 209   }
 210
 211   EGLDisplay fGetPlatformDisplay(EGLenum platform, void* native_display,
 212                                  const EGLAttrib* attrib_list) const {
 213     WRAP(fGetPlatformDisplay(platform, native_display, attrib_list));
 214   }
 215
 216   EGLSurface fGetCurrentSurface(EGLint id) const {
 217     WRAP(fGetCurrentSurface(id));
 218   }
 219
 220   EGLContext fGetCurrentContext() const { WRAP(fGetCurrentContext()); }
 221
 222   EGLBoolean fBindAPI(EGLenum api) const { WRAP(fBindAPI(api)); }
 223
 224   EGLint fGetError() const { WRAP(fGetError()); }
 225
 226   EGLBoolean fWaitNative(EGLint engine) const { WRAP(fWaitNative(engine)); }
 227
 228   EGLCastToRelevantPtr fGetProcAddress(const char* procname) const {
 229     WRAP(fGetProcAddress(procname));
 230   }
 231
 232   // ANGLE_device_creation
 233   EGLDeviceEXT fCreateDeviceANGLE(EGLint device_type, void* native_device,
 234                                   const EGLAttrib* attrib_list) const {
 235     WRAP(fCreateDeviceANGLE(device_type, native_device, attrib_list));
 236   }
 237
 238   EGLBoolean fReleaseDeviceANGLE(EGLDeviceEXT device) {
 239     WRAP(fReleaseDeviceANGLE(device));
 240   }
 241
 242   // ANDROID_get_native_client_buffer
 243   EGLClientBuffer fGetNativeClientBufferANDROID(
 244       const struct AHardwareBuffer* buffer) {
 245     WRAP(fGetNativeClientBufferANDROID(buffer));
 246   }
 247
 248  private:
 249   EGLBoolean fTerminate(EGLDisplay display) const { WRAP(fTerminate(display)); }
 250
 251   EGLBoolean fMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
 252                           EGLContext ctx) const {
 253     WRAP(fMakeCurrent(dpy, draw, read, ctx));
 254   }
 255
 256   EGLBoolean fDestroyContext(EGLDisplay dpy, EGLContext ctx) const {
 257     WRAP(fDestroyContext(dpy, ctx));
 258   }
 259
 260   EGLContext fCreateContext(EGLDisplay dpy, EGLConfig config,
 261                             EGLContext share_context,
 262                             const EGLint* attrib_list) const {
 263     WRAP(fCreateContext(dpy, config, share_context, attrib_list));
 264   }
 265
 266   EGLBoolean fDestroySurface(EGLDisplay dpy, EGLSurface surface) const {
 267     WRAP(fDestroySurface(dpy, surface));
 268   }
 269
 270  public:
 271   EGLSurface fCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
 272                                   EGLNativeWindowType win,
 273                                   const EGLint* attrib_list) const {
 274     WRAP(fCreateWindowSurface(dpy, config, win, attrib_list));
 275   }
 276
 277  private:
 278   EGLSurface fCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
 279                                    const EGLint* attrib_list) const {
 280     WRAP(fCreatePbufferSurface(dpy, config, attrib_list));
 281   }
 282
 283   EGLSurface fCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
 284                                             EGLClientBuffer buffer,
 285                                             EGLConfig config,
 286                                             const EGLint* attrib_list) const {
 287     WRAP(fCreatePbufferFromClientBuffer(dpy, buftype, buffer, config,
 288                                         attrib_list));
 289   }
 290
 291   EGLSurface fCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
 292                                   EGLNativePixmapType pixmap,
 293                                   const EGLint* attrib_list) const {
 294     WRAP(fCreatePixmapSurface(dpy, config, pixmap, attrib_list));
 295   }
 296
 297   EGLBoolean fInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) const {
 298     WRAP(fInitialize(dpy, major, minor));
 299   }
 300
 301   EGLBoolean fChooseConfig(EGLDisplay dpy, const EGLint* attrib_list,
 302                            EGLConfig* configs, EGLint config_size,
 303                            EGLint* num_config) const {
 304     WRAP(fChooseConfig(dpy, attrib_list, configs, config_size, num_config));
 305   }
 306
 307   EGLBoolean fGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 308                               EGLint attribute, EGLint* value) const {
 309     WRAP(fGetConfigAttrib(dpy, config, attribute, value));
 310   }
 311
 312   EGLBoolean fGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size,
 313                          EGLint* num_config) const {
 314     WRAP(fGetConfigs(dpy, configs, config_size, num_config));
 315   }
 316
 317   EGLBoolean fSwapBuffers(EGLDisplay dpy, EGLSurface surface) const {
 318     WRAP(fSwapBuffers(dpy, surface));
 319   }
 320
 321   EGLBoolean fCopyBuffers(EGLDisplay dpy, EGLSurface surface,
 322                           EGLNativePixmapType target) const {
 323     WRAP(fCopyBuffers(dpy, surface, target));
 324   }
 325
 326  public:
 327   const GLubyte* fQueryString(EGLDisplay dpy, EGLint name) const {
 328     WRAP(fQueryString(dpy, name));
 329   }
 330
 331  private:
 332   EGLBoolean fQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute,
 333                            EGLint* value) const {
 334     WRAP(fQueryContext(dpy, ctx, attribute, value));
 335   }
 336
 337   EGLBoolean fBindTexImage(EGLDisplay dpy, EGLSurface surface,
 338                            EGLint buffer) const {
 339     WRAP(fBindTexImage(dpy, surface, buffer));
 340   }
 341
 342   EGLBoolean fReleaseTexImage(EGLDisplay dpy, EGLSurface surface,
 343                               EGLint buffer) const {
 344     WRAP(fReleaseTexImage(dpy, surface, buffer));
 345   }
 346
 347   EGLBoolean fSwapInterval(EGLDisplay dpy, EGLint interval) const {
 348     WRAP(fSwapInterval(dpy, interval));
 349   }
 350
 351   EGLImage fCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target,
 352                         EGLClientBuffer buffer,
 353                         const EGLint* attrib_list) const {
 354     WRAP(fCreateImageKHR(dpy, ctx, target, buffer, attrib_list));
 355   }
 356
 357   EGLBoolean fDestroyImage(EGLDisplay dpy, EGLImage image) const {
 358     WRAP(fDestroyImageKHR(dpy, image));
 359   }
 360
 361   EGLBoolean fQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute,
 362                            EGLint* value) const {
 363     WRAP(fQuerySurface(dpy, surface, attribute, value));
 364   }
 365
 366   EGLBoolean fQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface,
 367                                        EGLint attribute, void** value) const {
 368     WRAP(fQuerySurfacePointerANGLE(dpy, surface, attribute, value));
 369   }
 370
 371   EGLSync fCreateSync(EGLDisplay dpy, EGLenum type,
 372                       const EGLint* attrib_list) const {
 373     WRAP(fCreateSyncKHR(dpy, type, attrib_list));
 374   }
 375
 376   EGLBoolean fDestroySync(EGLDisplay dpy, EGLSync sync) const {
 377     WRAP(fDestroySyncKHR(dpy, sync));
 378   }
 379
 380   EGLint fClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags,
 381                          EGLTime timeout) const {
 382     WRAP(fClientWaitSyncKHR(dpy, sync, flags, timeout));
 383   }
 384
 385   EGLBoolean fGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute,
 386                             EGLint* value) const {
 387     WRAP(fGetSyncAttribKHR(dpy, sync, attribute, value));
 388   }
 389
 390   EGLint fWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) const {
 391     WRAP(fWaitSyncKHR(dpy, sync, flags));
 392   }
 393
 394   EGLint fDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync) const {
 395     WRAP(fDupNativeFenceFDANDROID(dpy, sync));
 396   }
 397
 398   // KHR_stream
 399   EGLStreamKHR fCreateStreamKHR(EGLDisplay dpy,
 400                                 const EGLint* attrib_list) const {
 401     WRAP(fCreateStreamKHR(dpy, attrib_list));
 402   }
 403
 404   EGLBoolean fDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) const {
 405     WRAP(fDestroyStreamKHR(dpy, stream));
 406   }
 407
 408   EGLBoolean fQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream,
 409                              EGLenum attribute, EGLint* value) const {
 410     WRAP(fQueryStreamKHR(dpy, stream, attribute, value));
 411   }
 412
 413   // KHR_stream_consumer_gltexture
 414   EGLBoolean fStreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
 415                                                  EGLStreamKHR stream) const {
 416     WRAP(fStreamConsumerGLTextureExternalKHR(dpy, stream));
 417   }
 418
 419   EGLBoolean fStreamConsumerAcquireKHR(EGLDisplay dpy,
 420                                        EGLStreamKHR stream) const {
 421     WRAP(fStreamConsumerAcquireKHR(dpy, stream));
 422   }
 423
 424   EGLBoolean fStreamConsumerReleaseKHR(EGLDisplay dpy,
 425                                        EGLStreamKHR stream) const {
 426     WRAP(fStreamConsumerReleaseKHR(dpy, stream));
 427   }
 428
 429   // EXT_device_query
 430   EGLBoolean fQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute,
 431                                     EGLAttrib* value) const {
 432     WRAP(fQueryDisplayAttribEXT(dpy, attribute, value));
 433   }
 434
 435  public:
 436   EGLBoolean fQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute,
 437                                    EGLAttrib* value) const {
 438     WRAP(fQueryDeviceAttribEXT(device, attribute, value));
 439   }
 440
 441   const char* fQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name) {
 442     WRAP(fQueryDeviceStringEXT(device, name));
 443   }
 444
 445  private:
 446   // NV_stream_consumer_gltexture_yuv
 447   EGLBoolean fStreamConsumerGLTextureExternalAttribsNV(
 448       EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
 449     WRAP(fStreamConsumerGLTextureExternalAttribsNV(dpy, stream, attrib_list));
 450   }
 451
 452   // ANGLE_stream_producer_d3d_texture
 453   EGLBoolean fCreateStreamProducerD3DTextureANGLE(
 454       EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
 455     WRAP(fCreateStreamProducerD3DTextureANGLE(dpy, stream, attrib_list));
 456   }
 457
 458   EGLBoolean fStreamPostD3DTextureANGLE(EGLDisplay dpy, EGLStreamKHR stream,
 459                                         void* texture,
 460                                         const EGLAttrib* attrib_list) const {
 461     WRAP(fStreamPostD3DTextureANGLE(dpy, stream, texture, attrib_list));
 462   }
 463
 464   // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
 465   EGLBoolean fSwapBuffersWithDamage(EGLDisplay dpy, EGLSurface surface,
 466                                     const EGLint* rects, EGLint n_rects) {
 467     WRAP(fSwapBuffersWithDamage(dpy, surface, rects, n_rects));
 468   }
 469
 470   // EGL_KHR_partial_update
 471   EGLBoolean fSetDamageRegion(EGLDisplay dpy, EGLSurface surface,
 472                               const EGLint* rects, EGLint n_rects) {
 473     WRAP(fSetDamageRegion(dpy, surface, rects, n_rects));
 474   }
 475   // EGL_MESA_image_dma_buf_export
 476   EGLBoolean fExportDMABUFImageQuery(EGLDisplay dpy, EGLImage image,
 477                                      int* fourcc, int* num_planes,
 478                                      uint64_t* modifiers) {
 479     WRAP(
 480         fExportDMABUFImageQueryMESA(dpy, image, fourcc, num_planes, modifiers));
 481   }
 482   EGLBoolean fExportDMABUFImage(EGLDisplay dpy, EGLImage image, int* fds,
 483                                 EGLint* strides, EGLint* offsets) {
 484     WRAP(fExportDMABUFImageMESA(dpy, image, fds, strides, offsets));
 485   }
 486
 487  public:
 488   // EGL_EXT_device_enumeration
 489   EGLBoolean fQueryDevicesEXT(EGLint max_devices, EGLDeviceEXT* devices,
 490                               EGLint* num_devices) {
 491     WRAP(fQueryDevicesEXT(max_devices, devices, num_devices));
 492   }
 493
 494 #undef WRAP
 495
 496 #undef WRAP
 497 #undef PROFILE_CALL
 498 #undef BEFORE_CALL
 499 #undef AFTER_CALL
 500 #undef MOZ_FUNCTION_NAME
 501
 502   ////
 503
 504  private:
 505   struct {
 506     EGLCastToRelevantPtr(GLAPIENTRY* fGetProcAddress)(const char* procname);
 507     EGLDisplay(GLAPIENTRY* fGetDisplay)(void* display_id);
 508     EGLDisplay(GLAPIENTRY* fGetPlatformDisplay)(EGLenum platform,
 509                                                 void* native_display,
 510                                                 const EGLAttrib* attrib_list);
 511     EGLBoolean(GLAPIENTRY* fTerminate)(EGLDisplay dpy);
 512     EGLSurface(GLAPIENTRY* fGetCurrentSurface)(EGLint);
 513     EGLContext(GLAPIENTRY* fGetCurrentContext)(void);
 514     EGLBoolean(GLAPIENTRY* fMakeCurrent)(EGLDisplay dpy, EGLSurface draw,
 515                                          EGLSurface read, EGLContext ctx);
 516     EGLBoolean(GLAPIENTRY* fDestroyContext)(EGLDisplay dpy, EGLContext ctx);
 517     EGLContext(GLAPIENTRY* fCreateContext)(EGLDisplay dpy, EGLConfig config,
 518                                            EGLContext share_context,
 519                                            const EGLint* attrib_list);
 520     EGLBoolean(GLAPIENTRY* fDestroySurface)(EGLDisplay dpy, EGLSurface surface);
 521     EGLSurface(GLAPIENTRY* fCreateWindowSurface)(EGLDisplay dpy,
 522                                                  EGLConfig config,
 523                                                  EGLNativeWindowType win,
 524                                                  const EGLint* attrib_list);
 525     EGLSurface(GLAPIENTRY* fCreatePbufferSurface)(EGLDisplay dpy,
 526                                                   EGLConfig config,
 527                                                   const EGLint* attrib_list);
 528     EGLSurface(GLAPIENTRY* fCreatePbufferFromClientBuffer)(
 529         EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
 530         EGLConfig config, const EGLint* attrib_list);
 531     EGLSurface(GLAPIENTRY* fCreatePixmapSurface)(EGLDisplay dpy,
 532                                                  EGLConfig config,
 533                                                  EGLNativePixmapType pixmap,
 534                                                  const EGLint* attrib_list);
 535     EGLBoolean(GLAPIENTRY* fBindAPI)(EGLenum api);
 536     EGLBoolean(GLAPIENTRY* fInitialize)(EGLDisplay dpy, EGLint* major,
 537                                         EGLint* minor);
 538     EGLBoolean(GLAPIENTRY* fChooseConfig)(EGLDisplay dpy,
 539                                           const EGLint* attrib_list,
 540                                           EGLConfig* configs,
 541                                           EGLint config_size,
 542                                           EGLint* num_config);
 543     EGLint(GLAPIENTRY* fGetError)(void);
 544     EGLBoolean(GLAPIENTRY* fGetConfigAttrib)(EGLDisplay dpy, EGLConfig config,
 545                                              EGLint attribute, EGLint* value);
 546     EGLBoolean(GLAPIENTRY* fGetConfigs)(EGLDisplay dpy, EGLConfig* configs,
 547                                         EGLint config_size, EGLint* num_config);
 548     EGLBoolean(GLAPIENTRY* fWaitNative)(EGLint engine);
 549     EGLBoolean(GLAPIENTRY* fSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
 550     EGLBoolean(GLAPIENTRY* fCopyBuffers)(EGLDisplay dpy, EGLSurface surface,
 551                                          EGLNativePixmapType target);
 552     const GLubyte*(GLAPIENTRY* fQueryString)(EGLDisplay, EGLint name);
 553     EGLBoolean(GLAPIENTRY* fQueryContext)(EGLDisplay dpy, EGLContext ctx,
 554                                           EGLint attribute, EGLint* value);
 555     EGLBoolean(GLAPIENTRY* fBindTexImage)(EGLDisplay, EGLSurface surface,
 556                                           EGLint buffer);
 557     EGLBoolean(GLAPIENTRY* fReleaseTexImage)(EGLDisplay, EGLSurface surface,
 558                                              EGLint buffer);
 559     EGLBoolean(GLAPIENTRY* fSwapInterval)(EGLDisplay dpy, EGLint interval);
 560     EGLImage(GLAPIENTRY* fCreateImageKHR)(EGLDisplay dpy, EGLContext ctx,
 561                                           EGLenum target,
 562                                           EGLClientBuffer buffer,
 563                                           const EGLint* attrib_list);
 564     EGLBoolean(GLAPIENTRY* fDestroyImageKHR)(EGLDisplay dpy, EGLImage image);
 565     EGLBoolean(GLAPIENTRY* fQuerySurface)(EGLDisplay dpy, EGLSurface surface,
 566                                           EGLint attribute, EGLint* value);
 567     EGLBoolean(GLAPIENTRY* fQuerySurfacePointerANGLE)(EGLDisplay dpy,
 568                                                       EGLSurface surface,
 569                                                       EGLint attribute,
 570                                                       void** value);
 571     EGLSync(GLAPIENTRY* fCreateSyncKHR)(EGLDisplay dpy, EGLenum type,
 572                                         const EGLint* attrib_list);
 573     EGLBoolean(GLAPIENTRY* fDestroySyncKHR)(EGLDisplay dpy, EGLSync sync);
 574     EGLint(GLAPIENTRY* fClientWaitSyncKHR)(EGLDisplay dpy, EGLSync sync,
 575                                            EGLint flags, EGLTime timeout);
 576     EGLBoolean(GLAPIENTRY* fGetSyncAttribKHR)(EGLDisplay dpy, EGLSync sync,
 577                                               EGLint attribute, EGLint* value);
 578     EGLint(GLAPIENTRY* fWaitSyncKHR)(EGLDisplay dpy, EGLSync sync,
 579                                      EGLint flags);
 580     EGLint(GLAPIENTRY* fDupNativeFenceFDANDROID)(EGLDisplay dpy, EGLSync sync);
 581     // KHR_stream
 582     EGLStreamKHR(GLAPIENTRY* fCreateStreamKHR)(EGLDisplay dpy,
 583                                                const EGLint* attrib_list);
 584     EGLBoolean(GLAPIENTRY* fDestroyStreamKHR)(EGLDisplay dpy,
 585                                               EGLStreamKHR stream);
 586     EGLBoolean(GLAPIENTRY* fQueryStreamKHR)(EGLDisplay dpy, EGLStreamKHR stream,
 587                                             EGLenum attribute, EGLint* value);
 588     // KHR_stream_consumer_gltexture
 589     EGLBoolean(GLAPIENTRY* fStreamConsumerGLTextureExternalKHR)(
 590         EGLDisplay dpy, EGLStreamKHR stream);
 591     EGLBoolean(GLAPIENTRY* fStreamConsumerAcquireKHR)(EGLDisplay dpy,
 592                                                       EGLStreamKHR stream);
 593     EGLBoolean(GLAPIENTRY* fStreamConsumerReleaseKHR)(EGLDisplay dpy,
 594                                                       EGLStreamKHR stream);
 595     // EXT_device_query
 596     EGLBoolean(GLAPIENTRY* fQueryDisplayAttribEXT)(EGLDisplay dpy,
 597                                                    EGLint attribute,
 598                                                    EGLAttrib* value);
 599     EGLBoolean(GLAPIENTRY* fQueryDeviceAttribEXT)(EGLDeviceEXT device,
 600                                                   EGLint attribute,
 601                                                   EGLAttrib* value);
 602     const char*(GLAPIENTRY* fQueryDeviceStringEXT)(EGLDeviceEXT device,
 603                                                    EGLint name);
 604
 605     // NV_stream_consumer_gltexture_yuv
 606     EGLBoolean(GLAPIENTRY* fStreamConsumerGLTextureExternalAttribsNV)(
 607         EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list);
 608     // ANGLE_stream_producer_d3d_texture
 609     EGLBoolean(GLAPIENTRY* fCreateStreamProducerD3DTextureANGLE)(
 610         EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib* attrib_list);
 611     EGLBoolean(GLAPIENTRY* fStreamPostD3DTextureANGLE)(
 612         EGLDisplay dpy, EGLStreamKHR stream, void* texture,
 613         const EGLAttrib* attrib_list);
 614     // ANGLE_device_creation
 615     EGLDeviceEXT(GLAPIENTRY* fCreateDeviceANGLE)(EGLint device_type,
 616                                                  void* native_device,
 617                                                  const EGLAttrib* attrib_list);
 618     EGLBoolean(GLAPIENTRY* fReleaseDeviceANGLE)(EGLDeviceEXT device);
 619     // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
 620     EGLBoolean(GLAPIENTRY* fSwapBuffersWithDamage)(EGLDisplay dpy,
 621                                                    EGLSurface surface,
 622                                                    const EGLint* rects,
 623                                                    EGLint n_rects);
 624     // EGL_KHR_partial_update
 625     EGLBoolean(GLAPIENTRY* fSetDamageRegion)(EGLDisplay dpy, EGLSurface surface,
 626                                              const EGLint* rects,
 627                                              EGLint n_rects);
 628     EGLClientBuffer(GLAPIENTRY* fGetNativeClientBufferANDROID)(
 629         const struct AHardwareBuffer* buffer);
 630
 631     // EGL_MESA_image_dma_buf_export
 632     EGLBoolean(GLAPIENTRY* fExportDMABUFImageQueryMESA)(EGLDisplay dpy,
 633                                                         EGLImage image,
 634                                                         int* fourcc,
 635                                                         int* num_planes,
 636                                                         uint64_t* modifiers);
 637     EGLBoolean(GLAPIENTRY* fExportDMABUFImageMESA)(EGLDisplay dpy,
 638                                                    EGLImage image, int* fds,
 639                                                    EGLint* strides,
 640                                                    EGLint* offsets);
 641
 642     EGLBoolean(GLAPIENTRY* fQueryDevicesEXT)(EGLint max_devices,
 643                                              EGLDeviceEXT* devices,
 644                                              EGLint* num_devices);
 645
 646   } mSymbols = {};
 647 };
 648
 649 class EglDisplay final {
 650  public:
 651   const RefPtr<GLLibraryEGL> mLib;
 652   const EGLDisplay mDisplay;
 653   const bool mIsWARP;
 654
 655  private:
 656   std::bitset<UnderlyingValue(EGLExtension::Max)> mAvailableExtensions;
 657
 658   struct PrivateUseOnly final {};
 659
 660  public:
 661   static std::shared_ptr<EglDisplay> Create(
 662       GLLibraryEGL&, EGLDisplay, bool isWarp,
 663       const StaticMutexAutoLock& aProofOfLock);
 664
 665   // Only `public` for make_shared.
 666   EglDisplay(const PrivateUseOnly&, GLLibraryEGL&, EGLDisplay, bool isWarp);
 667
 668  public:
 669   ~EglDisplay();
 670
 671   bool IsExtensionSupported(EGLExtension aKnownExtension) const {
 672     return mAvailableExtensions[UnderlyingValue(aKnownExtension)];
 673   }
 674
 675   void MarkExtensionUnsupported(EGLExtension aKnownExtension) {
 676     mAvailableExtensions[UnderlyingValue(aKnownExtension)] = false;
 677   }
 678
 679   void DumpEGLConfig(EGLConfig) const;
 680   void DumpEGLConfigs() const;
 681
 682   void Shutdown();
 683
 684   // -
 685
 686   bool HasKHRImageBase() const {
 687     return IsExtensionSupported(EGLExtension::KHR_image) ||
 688            IsExtensionSupported(EGLExtension::KHR_image_base);
 689   }
 690
 691   bool HasKHRImagePixmap() const {
 692     return IsExtensionSupported(EGLExtension::KHR_image) ||
 693            IsExtensionSupported(EGLExtension::KHR_image_pixmap);
 694   }
 695
 696   // -
 697
 698   EGLBoolean fTerminate() { return mLib->fTerminate(mDisplay); }
 699
 700   EGLBoolean fMakeCurrent(EGLSurface draw, EGLSurface read,
 701                           EGLContext ctx) const {
 702     return mLib->fMakeCurrent(mDisplay, draw, read, ctx);
 703   }
 704
 705   EGLBoolean fDestroyContext(EGLContext ctx) const {
 706     return mLib->fDestroyContext(mDisplay, ctx);
 707   }
 708
 709   EGLContext fCreateContext(EGLConfig config, EGLContext share_context,
 710                             const EGLint* attrib_list) const {
 711     return mLib->fCreateContext(mDisplay, config, share_context, attrib_list);
 712   }
 713
 714   EGLBoolean fDestroySurface(EGLSurface surface) const {
 715     return mLib->fDestroySurface(mDisplay, surface);
 716   }
 717
 718   EGLSurface fCreateWindowSurface(EGLConfig config, EGLNativeWindowType win,
 719                                   const EGLint* attrib_list) const {
 720     return mLib->fCreateWindowSurface(mDisplay, config, win, attrib_list);
 721   }
 722
 723   EGLSurface fCreatePbufferSurface(EGLConfig config,
 724                                    const EGLint* attrib_list) const {
 725     return mLib->fCreatePbufferSurface(mDisplay, config, attrib_list);
 726   }
 727
 728   EGLSurface fCreatePbufferFromClientBuffer(EGLenum buftype,
 729                                             EGLClientBuffer buffer,
 730                                             EGLConfig config,
 731                                             const EGLint* attrib_list) const {
 732     return mLib->fCreatePbufferFromClientBuffer(mDisplay, buftype, buffer,
 733                                                 config, attrib_list);
 734   }
 735
 736   EGLBoolean fChooseConfig(const EGLint* attrib_list, EGLConfig* configs,
 737                            EGLint config_size, EGLint* num_config) const {
 738     return mLib->fChooseConfig(mDisplay, attrib_list, configs, config_size,
 739                                num_config);
 740   }
 741
 742   EGLBoolean fGetConfigAttrib(EGLConfig config, EGLint attribute,
 743                               EGLint* value) const {
 744     return mLib->fGetConfigAttrib(mDisplay, config, attribute, value);
 745   }
 746
 747   EGLBoolean fGetConfigs(EGLConfig* configs, EGLint config_size,
 748                          EGLint* num_config) const {
 749     return mLib->fGetConfigs(mDisplay, configs, config_size, num_config);
 750   }
 751
 752   EGLBoolean fSwapBuffers(EGLSurface surface) const {
 753     return mLib->fSwapBuffers(mDisplay, surface);
 754   }
 755
 756   EGLBoolean fBindTexImage(EGLSurface surface, EGLint buffer) const {
 757     return mLib->fBindTexImage(mDisplay, surface, buffer);
 758   }
 759
 760   EGLBoolean fReleaseTexImage(EGLSurface surface, EGLint buffer) const {
 761     return mLib->fReleaseTexImage(mDisplay, surface, buffer);
 762   }
 763
 764   EGLBoolean fSwapInterval(EGLint interval) const {
 765     return mLib->fSwapInterval(mDisplay, interval);
 766   }
 767
 768   EGLImage fCreateImage(EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
 769                         const EGLint* attribList) const {
 770     MOZ_ASSERT(HasKHRImageBase());
 771     return mLib->fCreateImage(mDisplay, ctx, target, buffer, attribList);
 772   }
 773
 774   EGLBoolean fDestroyImage(EGLImage image) const {
 775     MOZ_ASSERT(HasKHRImageBase());
 776     return mLib->fDestroyImage(mDisplay, image);
 777   }
 778
 779   EGLBoolean fQuerySurface(EGLSurface surface, EGLint attribute,
 780                            EGLint* value) const {
 781     return mLib->fQuerySurface(mDisplay, surface, attribute, value);
 782   }
 783
 784   EGLBoolean fQuerySurfacePointerANGLE(EGLSurface surface, EGLint attribute,
 785                                        void** value) const {
 786     MOZ_ASSERT(IsExtensionSupported(
 787         EGLExtension::ANGLE_surface_d3d_texture_2d_share_handle));
 788     return mLib->fQuerySurfacePointerANGLE(mDisplay, surface, attribute, value);
 789   }
 790
 791   EGLSync fCreateSync(EGLenum type, const EGLint* attrib_list) const {
 792     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
 793     return mLib->fCreateSync(mDisplay, type, attrib_list);
 794   }
 795
 796   EGLBoolean fDestroySync(EGLSync sync) const {
 797     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
 798     return mLib->fDestroySync(mDisplay, sync);
 799   }
 800
 801   EGLint fClientWaitSync(EGLSync sync, EGLint flags, EGLTime timeout) const {
 802     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
 803     return mLib->fClientWaitSync(mDisplay, sync, flags, timeout);
 804   }
 805
 806   EGLBoolean fGetSyncAttrib(EGLSync sync, EGLint attribute,
 807                             EGLint* value) const {
 808     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_fence_sync));
 809     return mLib->fGetSyncAttrib(mDisplay, sync, attribute, value);
 810   }
 811
 812   EGLint fWaitSync(EGLSync sync, EGLint flags) const {
 813     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_wait_sync));
 814     return mLib->fWaitSync(mDisplay, sync, flags);
 815   }
 816
 817   EGLint fDupNativeFenceFDANDROID(EGLSync sync) const {
 818     MOZ_ASSERT(IsExtensionSupported(EGLExtension::ANDROID_native_fence_sync));
 819     return mLib->fDupNativeFenceFDANDROID(mDisplay, sync);
 820   }
 821
 822   // EXT_device_query
 823   EGLBoolean fQueryDisplayAttribEXT(EGLint attribute, EGLAttrib* value) const {
 824     MOZ_ASSERT(mLib->IsExtensionSupported(EGLLibExtension::EXT_device_query));
 825     return mLib->fQueryDisplayAttribEXT(mDisplay, attribute, value);
 826   }
 827
 828   // KHR_stream
 829   EGLStreamKHR fCreateStreamKHR(const EGLint* attrib_list) const {
 830     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
 831     return mLib->fCreateStreamKHR(mDisplay, attrib_list);
 832   }
 833
 834   EGLBoolean fDestroyStreamKHR(EGLStreamKHR stream) const {
 835     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
 836     return mLib->fDestroyStreamKHR(mDisplay, stream);
 837   }
 838
 839   EGLBoolean fQueryStreamKHR(EGLStreamKHR stream, EGLenum attribute,
 840                              EGLint* value) const {
 841     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_stream));
 842     return mLib->fQueryStreamKHR(mDisplay, stream, attribute, value);
 843   }
 844
 845   // KHR_stream_consumer_gltexture
 846   EGLBoolean fStreamConsumerGLTextureExternalKHR(EGLStreamKHR stream) const {
 847     MOZ_ASSERT(
 848         IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
 849     return mLib->fStreamConsumerGLTextureExternalKHR(mDisplay, stream);
 850   }
 851
 852   EGLBoolean fStreamConsumerAcquireKHR(EGLStreamKHR stream) const {
 853     MOZ_ASSERT(
 854         IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
 855     return mLib->fStreamConsumerAcquireKHR(mDisplay, stream);
 856   }
 857
 858   EGLBoolean fStreamConsumerReleaseKHR(EGLStreamKHR stream) const {
 859     MOZ_ASSERT(
 860         IsExtensionSupported(EGLExtension::KHR_stream_consumer_gltexture));
 861     return mLib->fStreamConsumerReleaseKHR(mDisplay, stream);
 862   }
 863
 864   // NV_stream_consumer_gltexture_yuv
 865   EGLBoolean fStreamConsumerGLTextureExternalAttribsNV(
 866       EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
 867     MOZ_ASSERT(
 868         IsExtensionSupported(EGLExtension::NV_stream_consumer_gltexture_yuv));
 869     return mLib->fStreamConsumerGLTextureExternalAttribsNV(mDisplay, stream,
 870                                                            attrib_list);
 871   }
 872
 873   // ANGLE_stream_producer_d3d_texture
 874   EGLBoolean fCreateStreamProducerD3DTextureANGLE(
 875       EGLStreamKHR stream, const EGLAttrib* attrib_list) const {
 876     MOZ_ASSERT(
 877         IsExtensionSupported(EGLExtension::ANGLE_stream_producer_d3d_texture));
 878     return mLib->fCreateStreamProducerD3DTextureANGLE(mDisplay, stream,
 879                                                       attrib_list);
 880   }
 881
 882   EGLBoolean fStreamPostD3DTextureANGLE(EGLStreamKHR stream, void* texture,
 883                                         const EGLAttrib* attrib_list) const {
 884     MOZ_ASSERT(
 885         IsExtensionSupported(EGLExtension::ANGLE_stream_producer_d3d_texture));
 886     return mLib->fStreamPostD3DTextureANGLE(mDisplay, stream, texture,
 887                                             attrib_list);
 888   }
 889
 890   // EGL_EXT_swap_buffers_with_damage / EGL_KHR_swap_buffers_with_damage
 891   EGLBoolean fSwapBuffersWithDamage(EGLSurface surface, const EGLint* rects,
 892                                     EGLint n_rects) {
 893     MOZ_ASSERT(
 894         IsExtensionSupported(EGLExtension::EXT_swap_buffers_with_damage) ||
 895         IsExtensionSupported(EGLExtension::KHR_swap_buffers_with_damage));
 896     return mLib->fSwapBuffersWithDamage(mDisplay, surface, rects, n_rects);
 897   }
 898
 899   // EGL_KHR_partial_update
 900   EGLBoolean fSetDamageRegion(EGLSurface surface, const EGLint* rects,
 901                               EGLint n_rects) {
 902     MOZ_ASSERT(IsExtensionSupported(EGLExtension::KHR_partial_update));
 903     return mLib->fSetDamageRegion(mDisplay, surface, rects, n_rects);
 904   }
 905
 906   EGLBoolean fExportDMABUFImageQuery(EGLImage image, int* fourcc,
 907                                      int* num_planes,
 908                                      uint64_t* modifiers) const {
 909     MOZ_ASSERT(IsExtensionSupported(EGLExtension::MESA_image_dma_buf_export));
 910     return mLib->fExportDMABUFImageQuery(mDisplay, image, fourcc, num_planes,
 911                                          modifiers);
 912   }
 913   EGLBoolean fExportDMABUFImage(EGLImage image, int* fds, EGLint* strides,
 914                                 EGLint* offsets) const {
 915     MOZ_ASSERT(IsExtensionSupported(EGLExtension::MESA_image_dma_buf_export));
 916     return mLib->fExportDMABUFImage(mDisplay, image, fds, strides, offsets);
 917   }
 918 };
 919
 920 } /* namespace gl */
 921 } /* namespace mozilla */
 922
 923 #endif /* GLLIBRARYEGL_H_ */