summaryrefslogtreecommitdiffstats
path: root/gfx/angle/checkout/src/libANGLE/Display.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--gfx/angle/checkout/src/libANGLE/Display.cpp2506
1 files changed, 2506 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/Display.cpp b/gfx/angle/checkout/src/libANGLE/Display.cpp
new file mode 100644
index 0000000000..4b7ced36fb
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/Display.cpp
@@ -0,0 +1,2506 @@
+//
+// Copyright 2002 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// Display.cpp: Implements the egl::Display class, representing the abstract
+// display on which graphics are drawn. Implements EGLDisplay.
+// [EGL 1.4] section 2.1.2 page 3.
+
+#include "libANGLE/Display.h"
+
+#include <algorithm>
+#include <iterator>
+#include <sstream>
+#include <vector>
+
+#include <EGL/eglext.h>
+#include <platform/PlatformMethods.h>
+
+#include "anglebase/no_destructor.h"
+#include "common/android_util.h"
+#include "common/debug.h"
+#include "common/mathutil.h"
+#include "common/platform.h"
+#include "common/string_utils.h"
+#include "common/system_utils.h"
+#include "common/tls.h"
+#include "common/utilities.h"
+#include "gpu_info_util/SystemInfo.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Device.h"
+#include "libANGLE/EGLSync.h"
+#include "libANGLE/Image.h"
+#include "libANGLE/ResourceManager.h"
+#include "libANGLE/Stream.h"
+#include "libANGLE/Surface.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/capture/FrameCapture.h"
+#include "libANGLE/histogram_macros.h"
+#include "libANGLE/renderer/DeviceImpl.h"
+#include "libANGLE/renderer/DisplayImpl.h"
+#include "libANGLE/renderer/ImageImpl.h"
+#include "libANGLE/trace.h"
+
+#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
+# include <versionhelpers.h>
+
+# include "libANGLE/renderer/d3d/DisplayD3D.h"
+#endif
+
+#if defined(ANGLE_ENABLE_OPENGL)
+# if defined(ANGLE_PLATFORM_WINDOWS)
+# include "libANGLE/renderer/gl/wgl/DisplayWGL.h"
+# elif defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_IOS)
+# include "libANGLE/renderer/gl/apple/DisplayApple_api.h"
+# elif defined(ANGLE_PLATFORM_LINUX)
+# include "libANGLE/renderer/gl/egl/DisplayEGL.h"
+# if defined(ANGLE_USE_GBM)
+# include "libANGLE/renderer/gl/egl/gbm/DisplayGbm.h"
+# endif
+# if defined(ANGLE_USE_X11)
+# include "libANGLE/renderer/gl/glx/DisplayGLX.h"
+# endif
+# elif defined(ANGLE_PLATFORM_ANDROID)
+# include "libANGLE/renderer/gl/egl/android/DisplayAndroid.h"
+# else
+# error Unsupported OpenGL platform.
+# endif
+#endif
+
+#if defined(ANGLE_ENABLE_NULL)
+# include "libANGLE/renderer/null/DisplayNULL.h"
+#endif // defined(ANGLE_ENABLE_NULL)
+
+#if defined(ANGLE_ENABLE_VULKAN)
+# include "libANGLE/renderer/vulkan/DisplayVk_api.h"
+#endif // defined(ANGLE_ENABLE_VULKAN)
+
+#if defined(ANGLE_ENABLE_METAL)
+# include "libANGLE/renderer/metal/DisplayMtl_api.h"
+#endif // defined(ANGLE_ENABLE_METAL)
+
+namespace egl
+{
+
+namespace
+{
+
+constexpr angle::SubjectIndex kGPUSwitchedSubjectIndex = 0;
+
+static constexpr size_t kWindowSurfaceMapSize = 32;
+typedef angle::FlatUnorderedMap<EGLNativeWindowType, Surface *, kWindowSurfaceMapSize>
+ WindowSurfaceMap;
+// Get a map of all EGL window surfaces to validate that no window has more than one EGL surface
+// associated with it.
+static WindowSurfaceMap *GetWindowSurfaces()
+{
+ static angle::base::NoDestructor<WindowSurfaceMap> windowSurfaces;
+ return windowSurfaces.get();
+}
+
+struct ANGLEPlatformDisplay
+{
+ ANGLEPlatformDisplay() = default;
+
+ ANGLEPlatformDisplay(EGLNativeDisplayType nativeDisplayType)
+ : nativeDisplayType(nativeDisplayType)
+ {}
+
+ ANGLEPlatformDisplay(EGLNativeDisplayType nativeDisplayType,
+ EGLAttrib powerPreference,
+ EGLAttrib platformANGLEType,
+ EGLAttrib deviceIdHigh,
+ EGLAttrib deviceIdLow)
+ : nativeDisplayType(nativeDisplayType),
+ powerPreference(powerPreference),
+ platformANGLEType(platformANGLEType),
+ deviceIdHigh(deviceIdHigh),
+ deviceIdLow(deviceIdLow)
+ {}
+
+ auto tie() const
+ {
+ return std::tie(nativeDisplayType, powerPreference, platformANGLEType, deviceIdHigh,
+ deviceIdLow);
+ }
+
+ EGLNativeDisplayType nativeDisplayType{EGL_DEFAULT_DISPLAY};
+ EGLAttrib powerPreference{EGL_LOW_POWER_ANGLE};
+ EGLAttrib platformANGLEType{EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE};
+ EGLAttrib deviceIdHigh{0};
+ EGLAttrib deviceIdLow{0};
+};
+
+inline bool operator==(const ANGLEPlatformDisplay &a, const ANGLEPlatformDisplay &b)
+{
+ return a.tie() == b.tie();
+}
+
+static constexpr size_t kANGLEPlatformDisplayMapSize = 9;
+typedef angle::FlatUnorderedMap<ANGLEPlatformDisplay, Display *, kANGLEPlatformDisplayMapSize>
+ ANGLEPlatformDisplayMap;
+static ANGLEPlatformDisplayMap *GetANGLEPlatformDisplayMap()
+{
+ static angle::base::NoDestructor<ANGLEPlatformDisplayMap> displays;
+ return displays.get();
+}
+
+static constexpr size_t kDevicePlatformDisplayMapSize = 8;
+typedef angle::FlatUnorderedMap<Device *, Display *, kDevicePlatformDisplayMapSize>
+ DevicePlatformDisplayMap;
+static DevicePlatformDisplayMap *GetDevicePlatformDisplayMap()
+{
+ static angle::base::NoDestructor<DevicePlatformDisplayMap> displays;
+ return displays.get();
+}
+
+rx::DisplayImpl *CreateDisplayFromDevice(Device *eglDevice, const DisplayState &state)
+{
+ rx::DisplayImpl *impl = nullptr;
+
+ switch (eglDevice->getType())
+ {
+#if defined(ANGLE_ENABLE_D3D11)
+ case EGL_D3D11_DEVICE_ANGLE:
+ impl = new rx::DisplayD3D(state);
+ break;
+#endif
+#if defined(ANGLE_ENABLE_D3D9)
+ case EGL_D3D9_DEVICE_ANGLE:
+ // Currently the only way to get EGLDeviceEXT representing a D3D9 device
+ // is to retrieve one from an already-existing EGLDisplay.
+ // When eglGetPlatformDisplayEXT is called with a D3D9 EGLDeviceEXT,
+ // the already-existing display should be returned.
+ // Therefore this codepath to create a new display from the device
+ // should never be hit.
+ UNREACHABLE();
+ break;
+#endif
+ default:
+ UNREACHABLE();
+ break;
+ }
+
+ ASSERT(impl != nullptr);
+ return impl;
+}
+
+// On platforms with support for multiple back-ends, allow an environment variable to control
+// the default. This is useful to run angle with benchmarks without having to modify the
+// benchmark source. Possible values for this environment variable (ANGLE_DEFAULT_PLATFORM)
+// are: vulkan, gl, d3d11, null.
+EGLAttrib GetDisplayTypeFromEnvironment()
+{
+ std::string angleDefaultEnv = angle::GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM");
+ angle::ToLower(&angleDefaultEnv);
+
+#if defined(ANGLE_ENABLE_VULKAN)
+ if ((angleDefaultEnv == "vulkan") || (angleDefaultEnv == "vulkan-null") ||
+ (angleDefaultEnv == "swiftshader"))
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
+ }
+#endif
+
+#if defined(ANGLE_ENABLE_OPENGL)
+ if (angleDefaultEnv == "gl")
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE;
+ }
+#endif
+
+#if defined(ANGLE_ENABLE_D3D11)
+ if (angleDefaultEnv == "d3d11")
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+ }
+#endif
+
+#if defined(ANGLE_ENABLE_METAL)
+ if (angleDefaultEnv == "metal")
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE;
+ }
+#endif
+
+#if defined(ANGLE_ENABLE_NULL)
+ if (angleDefaultEnv == "null")
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE;
+ }
+#endif
+#if defined(ANGLE_ENABLE_METAL)
+ if (angleDefaultEnv == "metal")
+ {
+ return EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE;
+ }
+
+#endif
+#if defined(ANGLE_ENABLE_D3D11)
+ return EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE;
+#elif defined(ANGLE_ENABLE_D3D9)
+ return EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE;
+#elif defined(ANGLE_ENABLE_VULKAN) && defined(ANGLE_PLATFORM_ANDROID)
+ return EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
+#elif defined(ANGLE_ENABLE_OPENGL)
+# if defined(ANGLE_PLATFORM_ANDROID) || defined(ANGLE_USE_GBM)
+ return EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE;
+# else
+ return EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE;
+# endif
+#elif defined(ANGLE_ENABLE_METAL)
+ return EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE;
+#elif defined(ANGLE_ENABLE_VULKAN)
+ return EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
+#elif defined(ANGLE_ENABLE_NULL)
+ return EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE;
+#else
+# error No default ANGLE platform type
+#endif
+}
+
+EGLAttrib GetDeviceTypeFromEnvironment()
+{
+ std::string angleDefaultEnv = angle::GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM");
+ angle::ToLower(&angleDefaultEnv);
+
+#if defined(ANGLE_ENABLE_VULKAN)
+ if (angleDefaultEnv == "vulkan-null")
+ {
+ return EGL_PLATFORM_ANGLE_DEVICE_TYPE_NULL_ANGLE;
+ }
+ else if (angleDefaultEnv == "swiftshader")
+ {
+ return EGL_PLATFORM_ANGLE_DEVICE_TYPE_SWIFTSHADER_ANGLE;
+ }
+#endif
+ return EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
+}
+
+EGLAttrib GetPlatformTypeFromEnvironment()
+{
+#if defined(ANGLE_USE_OZONE)
+ return 0;
+#elif defined(ANGLE_USE_X11)
+ return EGL_PLATFORM_X11_EXT;
+#elif defined(ANGLE_USE_WAYLAND)
+ return EGL_PLATFORM_WAYLAND_EXT;
+#elif defined(ANGLE_USE_VULKAN_DISPLAY) && defined(ANGLE_VULKAN_DISPLAY_MODE_SIMPLE)
+ return EGL_PLATFORM_VULKAN_DISPLAY_MODE_SIMPLE_ANGLE;
+#elif defined(ANGLE_USE_VULKAN_DISPLAY) && defined(ANGLE_VULKAN_DISPLAY_MODE_HEADLESS)
+ return EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE;
+#else
+ return 0;
+#endif // defined(ANGLE_USE_OZONE)
+}
+
+rx::DisplayImpl *CreateDisplayFromAttribs(EGLAttrib displayType,
+ EGLAttrib deviceType,
+ EGLAttrib platformType,
+ const DisplayState &state)
+{
+ ASSERT(displayType != EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE);
+ rx::DisplayImpl *impl = nullptr;
+
+ switch (displayType)
+ {
+ case EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE:
+ UNREACHABLE();
+ break;
+
+ case EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE:
+ case EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE:
+#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
+ impl = new rx::DisplayD3D(state);
+ break;
+#else
+ // A D3D display was requested on a platform that doesn't support it
+ UNREACHABLE();
+ break;
+#endif
+
+ case EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE:
+#if defined(ANGLE_ENABLE_OPENGL)
+# if defined(ANGLE_PLATFORM_WINDOWS)
+ impl = new rx::DisplayWGL(state);
+ break;
+
+# elif defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_IOS)
+ impl = rx::CreateDisplayCGLOrEAGL(state);
+ break;
+
+# elif defined(ANGLE_PLATFORM_LINUX)
+# if defined(ANGLE_USE_GBM)
+ if (platformType == 0)
+ {
+ // If platformType is unknown, use DisplayGbm now. In the future, it should use
+ // DisplayEGL letting native EGL decide what display to use.
+ impl = new rx::DisplayGbm(state);
+ break;
+ }
+# endif
+ if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_EGL_ANGLE)
+ {
+ impl = new rx::DisplayEGL(state);
+ break;
+ }
+# if defined(ANGLE_USE_X11)
+ if (platformType == EGL_PLATFORM_X11_EXT)
+ {
+ impl = new rx::DisplayGLX(state);
+ break;
+ }
+# endif
+ break;
+
+# elif defined(ANGLE_PLATFORM_ANDROID)
+ // No GL support on this platform, fail display creation.
+ impl = nullptr;
+ break;
+
+# else
+# error Unsupported OpenGL platform.
+# endif
+#else
+ // No display available
+ UNREACHABLE();
+ break;
+
+#endif // defined(ANGLE_ENABLE_OPENGL)
+
+ case EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE:
+#if defined(ANGLE_ENABLE_OPENGL)
+# if defined(ANGLE_PLATFORM_WINDOWS)
+ impl = new rx::DisplayWGL(state);
+# elif defined(ANGLE_PLATFORM_LINUX)
+# if defined(ANGLE_USE_GBM)
+ if (platformType == 0 ||
+ platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE)
+ {
+ // If platformType is unknown, use DisplayGbm now. In the future, it should use
+ // DisplayEGL letting native EGL decide what display to use.
+ // platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE is a hack,
+ // to allow ChromeOS GLES backend to continue functioning when Vulkan is enabled.
+ impl = new rx::DisplayGbm(state);
+ break;
+ }
+# endif
+ if (deviceType == EGL_PLATFORM_ANGLE_DEVICE_TYPE_EGL_ANGLE)
+ {
+ impl = new rx::DisplayEGL(state);
+ break;
+ }
+ else
+ {
+# if defined(ANGLE_USE_X11)
+ if (platformType == EGL_PLATFORM_X11_EXT)
+ {
+ impl = new rx::DisplayGLX(state);
+ break;
+ }
+# endif
+ }
+# elif defined(ANGLE_PLATFORM_ANDROID)
+ impl = new rx::DisplayAndroid(state);
+# else
+ // No GLES support on this platform, fail display creation.
+ impl = nullptr;
+# endif
+#endif // defined(ANGLE_ENABLE_OPENGL)
+ break;
+
+ case EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE:
+#if defined(ANGLE_ENABLE_VULKAN)
+# if defined(ANGLE_USE_VULKAN_NULL_DISPLAY)
+ if (rx::IsVulkanNullDisplayAvailable())
+ {
+ impl = rx::CreateVulkanNullDisplay(state);
+ }
+ break;
+# elif defined(ANGLE_PLATFORM_WINDOWS)
+ if (rx::IsVulkanWin32DisplayAvailable())
+ {
+ impl = rx::CreateVulkanWin32Display(state);
+ }
+ break;
+# elif defined(ANGLE_PLATFORM_LINUX)
+# if defined(ANGLE_USE_GBM)
+ if (platformType == EGL_PLATFORM_GBM_KHR && rx::IsVulkanGbmDisplayAvailable())
+ {
+ impl = rx::CreateVulkanGbmDisplay(state);
+ break;
+ }
+# endif
+# if defined(ANGLE_USE_X11)
+ if (platformType == EGL_PLATFORM_X11_EXT && rx::IsVulkanXcbDisplayAvailable())
+ {
+ impl = rx::CreateVulkanXcbDisplay(state);
+ break;
+ }
+# endif
+# if defined(ANGLE_USE_WAYLAND)
+ if (platformType == EGL_PLATFORM_WAYLAND_EXT && rx::IsVulkanWaylandDisplayAvailable())
+ {
+ impl = rx::CreateVulkanWaylandDisplay(state);
+ break;
+ }
+# endif
+# if defined(ANGLE_USE_VULKAN_DISPLAY)
+ if (platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_SIMPLE_ANGLE &&
+ rx::IsVulkanSimpleDisplayAvailable())
+ {
+ impl = rx::CreateVulkanSimpleDisplay(state);
+ }
+ else if (platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE &&
+ rx::IsVulkanHeadlessDisplayAvailable())
+ {
+ impl = rx::CreateVulkanHeadlessDisplay(state);
+ }
+ else
+ {
+ // Not supported creation type on vulkan display, fail display creation.
+ impl = nullptr;
+ }
+# endif
+ break;
+# elif defined(ANGLE_PLATFORM_ANDROID)
+ if (rx::IsVulkanAndroidDisplayAvailable())
+ {
+ impl = rx::CreateVulkanAndroidDisplay(state);
+ }
+ break;
+# elif defined(ANGLE_PLATFORM_FUCHSIA)
+ if (rx::IsVulkanFuchsiaDisplayAvailable())
+ {
+ impl = rx::CreateVulkanFuchsiaDisplay(state);
+ }
+ break;
+# elif defined(ANGLE_PLATFORM_GGP)
+ if (rx::IsVulkanGGPDisplayAvailable())
+ {
+ impl = rx::CreateVulkanGGPDisplay(state);
+ }
+ break;
+# elif defined(ANGLE_PLATFORM_APPLE)
+ if (rx::IsVulkanMacDisplayAvailable())
+ {
+ impl = rx::CreateVulkanMacDisplay(state);
+ }
+ break;
+# else
+# error Unsupported Vulkan platform.
+# endif
+#else
+ // No display available
+ UNREACHABLE();
+ break;
+#endif // defined(ANGLE_ENABLE_VULKAN)
+
+ case EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE:
+#if defined(ANGLE_ENABLE_METAL)
+ if (rx::IsMetalDisplayAvailable())
+ {
+ impl = rx::CreateMetalDisplay(state);
+ break;
+ }
+#endif
+ // No display available
+ UNREACHABLE();
+ break;
+
+ case EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE:
+#if defined(ANGLE_ENABLE_NULL)
+ impl = new rx::DisplayNULL(state);
+ break;
+#else
+ // No display available
+ UNREACHABLE();
+ break;
+#endif // defined(ANGLE_ENABLE_NULL)
+
+ default:
+ UNREACHABLE();
+ break;
+ }
+
+ return impl;
+}
+
+void Display_logError(angle::PlatformMethods *platform, const char *errorMessage)
+{
+ gl::Trace(gl::LOG_ERR, errorMessage);
+}
+
+void Display_logWarning(angle::PlatformMethods *platform, const char *warningMessage)
+{
+ gl::Trace(gl::LOG_WARN, warningMessage);
+}
+
+void Display_logInfo(angle::PlatformMethods *platform, const char *infoMessage)
+{
+ // Uncomment to get info spam
+#if defined(ANGLE_ENABLE_DEBUG_TRACE)
+ gl::Trace(gl::LOG_INFO, infoMessage);
+#endif
+}
+
+const std::vector<std::string> EGLStringArrayToStringVector(const char **ary)
+{
+ std::vector<std::string> vec;
+ if (ary != nullptr)
+ {
+ for (; *ary != nullptr; ary++)
+ {
+ vec.push_back(std::string(*ary));
+ }
+ }
+ return vec;
+}
+
+void ANGLESetDefaultDisplayPlatform(angle::EGLDisplayType display)
+{
+ angle::PlatformMethods *platformMethods = ANGLEPlatformCurrent();
+
+ ANGLEResetDisplayPlatform(display);
+ platformMethods->logError = Display_logError;
+ platformMethods->logWarning = Display_logWarning;
+ platformMethods->logInfo = Display_logInfo;
+}
+
+void UpdateAttribsFromEnvironment(AttributeMap &attribMap)
+{
+ EGLAttrib displayType =
+ attribMap.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE);
+ if (displayType == EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE)
+ {
+ displayType = GetDisplayTypeFromEnvironment();
+ attribMap.insert(EGL_PLATFORM_ANGLE_TYPE_ANGLE, displayType);
+ }
+ EGLAttrib deviceType = attribMap.get(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, 0);
+ if (deviceType == 0)
+ {
+ deviceType = GetDeviceTypeFromEnvironment();
+ attribMap.insert(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE, deviceType);
+ }
+ EGLAttrib platformType = attribMap.get(EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE, 0);
+ if (platformType == 0)
+ {
+ platformType = GetPlatformTypeFromEnvironment();
+ attribMap.insert(EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE, platformType);
+ }
+}
+
+static constexpr uint32_t kScratchBufferLifetime = 64u;
+
+} // anonymous namespace
+
+// ShareGroup
+ShareGroup::ShareGroup(rx::EGLImplFactory *factory)
+ : mRefCount(1),
+ mImplementation(factory->createShareGroup()),
+ mFrameCaptureShared(new angle::FrameCaptureShared)
+{}
+
+void ShareGroup::finishAllContexts()
+{
+ for (gl::Context *shareContext : mContexts)
+ {
+ if (shareContext->hasBeenCurrent() && !shareContext->isDestroyed())
+ {
+ shareContext->finish();
+ }
+ }
+}
+
+void ShareGroup::addSharedContext(gl::Context *context)
+{
+ mContexts.insert(context);
+
+ if (context->isRobustnessEnabled())
+ {
+ mImplementation->onRobustContextAdd();
+ }
+}
+
+void ShareGroup::removeSharedContext(gl::Context *context)
+{
+ mContexts.erase(context);
+}
+
+ShareGroup::~ShareGroup()
+{
+ SafeDelete(mImplementation);
+}
+
+void ShareGroup::addRef()
+{
+ // This is protected by global lock, so no atomic is required
+ mRefCount++;
+}
+
+void ShareGroup::release(const Display *display)
+{
+ if (--mRefCount == 0)
+ {
+ if (mImplementation)
+ {
+ mImplementation->onDestroy(display);
+ }
+ delete this;
+ }
+}
+
+// DisplayState
+DisplayState::DisplayState(EGLNativeDisplayType nativeDisplayId)
+ : label(nullptr), featuresAllDisabled(false), displayId(nativeDisplayId)
+{}
+
+DisplayState::~DisplayState() {}
+
+// Note that ANGLE support on Ozone platform is limited. Our preferred support Matrix for
+// EGL_ANGLE_platform_angle on Linux and Ozone/Linux/Fuchsia platforms should be the following:
+//
+// |--------------------------------------------------------|
+// | ANGLE type | DEVICE type | PLATFORM type | Display |
+// |--------------------------------------------------------|
+// | OPENGL | EGL | ANY | EGL |
+// | OPENGL | HARDWARE | X11_EXT | GLX |
+// | OPENGLES | HARDWARE | X11_EXT | GLX |
+// | OPENGLES | EGL | ANY | EGL |
+// | VULKAN | HARDWARE | X11_EXT | VkXcb |
+// | VULKAN | SWIFTSHADER | X11_EXT | VkXcb |
+// | OPENGLES | HARDWARE | SURFACELESS_MESA | EGL* |
+// | OPENGLES | HARDWARE | DEVICE_EXT | EGL |
+// | VULKAN | HARDWARE | SURFACELESS_MESA | VkBase** |
+// | VULKAN | SWIFTSHADER | SURFACELESS_MESA | VkBase** |
+// |--------------------------------------------------------|
+//
+// * No surfaceless support yet.
+// ** Not implemented yet.
+//
+// |-----------------------------------------------|
+// | OS | BUILD type | Default PLATFORM type |
+// |-----------------------------------------------|
+// | Linux | X11 | X11_EXT |
+// | Linux | Ozone | SURFACELESS_MESA |
+// | Fuchsia | Ozone | FUCHSIA*** |
+// |-----------------------------------------------|
+//
+// *** Chosen implicitly. No EGLAttrib available.
+//
+// For more details, please refer to
+// https://docs.google.com/document/d/1XjHiDZQISq1AMrg_l1TX1_kIKvDpU76hidn9i4cAjl8/edit?disco=AAAAJl9V_YY
+//
+// static
+Display *Display::GetDisplayFromNativeDisplay(EGLenum platform,
+ EGLNativeDisplayType nativeDisplay,
+ const AttributeMap &attribMap)
+{
+ Display *display = nullptr;
+
+ AttributeMap updatedAttribMap(attribMap);
+ UpdateAttribsFromEnvironment(updatedAttribMap);
+
+ EGLAttrib powerPreference =
+ updatedAttribMap.get(EGL_POWER_PREFERENCE_ANGLE, EGL_LOW_POWER_ANGLE);
+ EGLAttrib platformANGLEType =
+ updatedAttribMap.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE);
+ EGLAttrib deviceIdHigh = updatedAttribMap.get(EGL_PLATFORM_ANGLE_DEVICE_ID_HIGH_ANGLE, 0);
+ EGLAttrib deviceIdLow = updatedAttribMap.get(EGL_PLATFORM_ANGLE_DEVICE_ID_LOW_ANGLE, 0);
+ ANGLEPlatformDisplayMap *displays = GetANGLEPlatformDisplayMap();
+ ANGLEPlatformDisplay displayKey(nativeDisplay, powerPreference, platformANGLEType, deviceIdHigh,
+ deviceIdLow);
+ const auto &iter = displays->find(displayKey);
+ if (iter != displays->end())
+ {
+ display = iter->second;
+ }
+
+ if (display == nullptr)
+ {
+ // Validate the native display
+ if (!Display::isValidNativeDisplay(nativeDisplay))
+ {
+ return nullptr;
+ }
+
+ display = new Display(platform, nativeDisplay, nullptr);
+ displays->insert(std::make_pair(displayKey, display));
+ }
+ // Apply new attributes if the display is not initialized yet.
+ if (!display->isInitialized())
+ {
+ display->setAttributes(updatedAttribMap);
+
+ EGLAttrib displayType = display->mAttributeMap.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
+ EGLAttrib deviceType = display->mAttributeMap.get(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
+ EGLAttrib platformType = platform;
+ if (platform == EGL_PLATFORM_ANGLE_ANGLE)
+ {
+ platformType =
+ display->mAttributeMap.get(EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE);
+ }
+ rx::DisplayImpl *impl =
+ CreateDisplayFromAttribs(displayType, deviceType, platformType, display->getState());
+ if (impl == nullptr)
+ {
+ // No valid display implementation for these attributes
+ return nullptr;
+ }
+
+#if defined(ANGLE_USE_ANDROID_TLS_SLOT)
+ angle::gUseAndroidOpenGLTlsSlot = displayType == EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;
+#endif // defined(ANGLE_PLATFORM_ANDROID)
+
+ display->setupDisplayPlatform(impl);
+ }
+
+ return display;
+}
+
+// static
+Display *Display::GetExistingDisplayFromNativeDisplay(EGLNativeDisplayType nativeDisplay)
+{
+ ANGLEPlatformDisplayMap *displays = GetANGLEPlatformDisplayMap();
+ const auto &iter = displays->find(nativeDisplay);
+
+ // Check that there is a matching display
+ if (iter == displays->end())
+ {
+ return nullptr;
+ }
+
+ return iter->second;
+}
+
+// static
+Display *Display::GetDisplayFromDevice(Device *device, const AttributeMap &attribMap)
+{
+ Display *display = nullptr;
+
+ ASSERT(Device::IsValidDevice(device));
+
+ ANGLEPlatformDisplayMap *anglePlatformDisplays = GetANGLEPlatformDisplayMap();
+ DevicePlatformDisplayMap *devicePlatformDisplays = GetDevicePlatformDisplayMap();
+
+ // First see if this eglDevice is in use by a Display created using ANGLE platform
+ for (auto &displayMapEntry : *anglePlatformDisplays)
+ {
+ egl::Display *iterDisplay = displayMapEntry.second;
+ if (iterDisplay->getDevice() == device)
+ {
+ display = iterDisplay;
+ }
+ }
+
+ if (display == nullptr)
+ {
+ // See if the eglDevice is in use by a Display created using the DEVICE platform
+ const auto &iter = devicePlatformDisplays->find(device);
+ if (iter != devicePlatformDisplays->end())
+ {
+ display = iter->second;
+ }
+ }
+
+ if (display == nullptr)
+ {
+ // Otherwise create a new Display
+ display = new Display(EGL_PLATFORM_DEVICE_EXT, 0, device);
+ devicePlatformDisplays->insert(std::make_pair(device, display));
+ }
+
+ // Apply new attributes if the display is not initialized yet.
+ if (!display->isInitialized())
+ {
+ display->setAttributes(attribMap);
+ rx::DisplayImpl *impl = CreateDisplayFromDevice(device, display->getState());
+ display->setupDisplayPlatform(impl);
+ }
+
+ return display;
+}
+
+// static
+Display::EglDisplaySet Display::GetEglDisplaySet()
+{
+ Display::EglDisplaySet displays;
+
+ ANGLEPlatformDisplayMap *anglePlatformDisplays = GetANGLEPlatformDisplayMap();
+ DevicePlatformDisplayMap *devicePlatformDisplays = GetDevicePlatformDisplayMap();
+
+ for (auto anglePlatformDisplayMapEntry : *anglePlatformDisplays)
+ {
+ displays.insert(anglePlatformDisplayMapEntry.second);
+ }
+
+ for (auto devicePlatformDisplayMapEntry : *devicePlatformDisplays)
+ {
+ displays.insert(devicePlatformDisplayMapEntry.second);
+ }
+
+ return displays;
+}
+
+Display::Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDevice)
+ : mState(displayId),
+ mImplementation(nullptr),
+ mGPUSwitchedBinding(this, kGPUSwitchedSubjectIndex),
+ mAttributeMap(),
+ mConfigSet(),
+ mStreamSet(),
+ mInvalidContextSet(),
+ mInvalidImageSet(),
+ mInvalidStreamSet(),
+ mInvalidSurfaceSet(),
+ mInvalidSyncSet(),
+ mInitialized(false),
+ mDeviceLost(false),
+ mCaps(),
+ mDisplayExtensions(),
+ mDisplayExtensionString(),
+ mVendorString(),
+ mVersionString(),
+ mDevice(eglDevice),
+ mSurface(nullptr),
+ mPlatform(platform),
+ mTextureManager(nullptr),
+ mSemaphoreManager(nullptr),
+ mBlobCache(gl::kDefaultMaxProgramCacheMemoryBytes),
+ mMemoryProgramCache(mBlobCache),
+ mMemoryShaderCache(mBlobCache),
+ mGlobalTextureShareGroupUsers(0),
+ mGlobalSemaphoreShareGroupUsers(0),
+ mTerminatedByApi(false),
+ mActiveThreads()
+{}
+
+Display::~Display()
+{
+ switch (mPlatform)
+ {
+ case EGL_PLATFORM_ANGLE_ANGLE:
+ case EGL_PLATFORM_GBM_KHR:
+ case EGL_PLATFORM_WAYLAND_EXT:
+ {
+ ANGLEPlatformDisplayMap *displays = GetANGLEPlatformDisplayMap();
+ ANGLEPlatformDisplayMap::iterator iter = displays->find(ANGLEPlatformDisplay(
+ mState.displayId,
+ mAttributeMap.get(EGL_POWER_PREFERENCE_ANGLE, EGL_LOW_POWER_ANGLE),
+ mAttributeMap.get(EGL_PLATFORM_ANGLE_TYPE_ANGLE,
+ EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
+ mAttributeMap.get(EGL_PLATFORM_ANGLE_DEVICE_ID_HIGH_ANGLE, 0),
+ mAttributeMap.get(EGL_PLATFORM_ANGLE_DEVICE_ID_LOW_ANGLE, 0)));
+ if (iter != displays->end())
+ {
+ displays->erase(iter);
+ }
+ break;
+ }
+ case EGL_PLATFORM_DEVICE_EXT:
+ {
+ DevicePlatformDisplayMap *displays = GetDevicePlatformDisplayMap();
+ DevicePlatformDisplayMap::iterator iter = displays->find(mDevice);
+ if (iter != displays->end())
+ {
+ displays->erase(iter);
+ }
+ break;
+ }
+ default:
+ {
+ UNREACHABLE();
+ }
+ }
+
+ SafeDelete(mDevice);
+ SafeDelete(mImplementation);
+}
+
+void Display::setLabel(EGLLabelKHR label)
+{
+ mState.label = label;
+}
+
+EGLLabelKHR Display::getLabel() const
+{
+ return mState.label;
+}
+
+void Display::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
+{
+ ASSERT(index == kGPUSwitchedSubjectIndex);
+ ASSERT(message == angle::SubjectMessage::SubjectChanged);
+ for (gl::Context *context : mState.contextSet)
+ {
+ context->onGPUSwitch();
+ }
+}
+
+void Display::setupDisplayPlatform(rx::DisplayImpl *impl)
+{
+ ASSERT(!mInitialized);
+
+ ASSERT(impl != nullptr);
+ SafeDelete(mImplementation);
+ mImplementation = impl;
+
+ // TODO(anglebug.com/7365): Remove PlatformMethods.
+ const angle::PlatformMethods *platformMethods =
+ reinterpret_cast<const angle::PlatformMethods *>(
+ mAttributeMap.get(EGL_PLATFORM_ANGLE_PLATFORM_METHODS_ANGLEX, 0));
+ if (platformMethods != nullptr)
+ {
+ *ANGLEPlatformCurrent() = *platformMethods;
+ }
+ else
+ {
+ ANGLESetDefaultDisplayPlatform(this);
+ }
+
+ const char **featuresForceEnabled =
+ reinterpret_cast<const char **>(mAttributeMap.get(EGL_FEATURE_OVERRIDES_ENABLED_ANGLE, 0));
+ const char **featuresForceDisabled =
+ reinterpret_cast<const char **>(mAttributeMap.get(EGL_FEATURE_OVERRIDES_DISABLED_ANGLE, 0));
+ mState.featureOverridesEnabled = EGLStringArrayToStringVector(featuresForceEnabled);
+ mState.featureOverridesDisabled = EGLStringArrayToStringVector(featuresForceDisabled);
+ mState.featuresAllDisabled =
+ static_cast<bool>(mAttributeMap.get(EGL_FEATURE_ALL_DISABLED_ANGLE, 0));
+ mImplementation->addObserver(&mGPUSwitchedBinding);
+}
+
+Error Display::initialize()
+{
+ mTerminatedByApi = false;
+
+ ASSERT(mImplementation != nullptr);
+ mImplementation->setBlobCache(&mBlobCache);
+
+ // Enable shader caching if debug layers are turned on. This allows us to test that shaders are
+ // properly saved & restored on all platforms. The cache won't allocate space until it's used
+ // and will be ignored entirely if the application / system sets it's own cache functions.
+ if (rx::ShouldUseDebugLayers(mAttributeMap))
+ {
+ mBlobCache.resize(1024 * 1024);
+ }
+
+ setGlobalDebugAnnotator();
+
+ gl::InitializeDebugMutexIfNeeded();
+
+ ANGLE_TRACE_EVENT0("gpu.angle", "egl::Display::initialize");
+
+ if (isInitialized())
+ {
+ return NoError();
+ }
+
+ Error error = mImplementation->initialize(this);
+ if (error.isError())
+ {
+ // Log extended error message here
+ ERR() << "ANGLE Display::initialize error " << error.getID() << ": " << error.getMessage();
+ return error;
+ }
+
+ mCaps = mImplementation->getCaps();
+
+ mConfigSet = mImplementation->generateConfigs();
+ if (mConfigSet.size() == 0)
+ {
+ mImplementation->terminate();
+ return EglNotInitialized() << "No configs were generated.";
+ }
+
+ // OpenGL ES1 is implemented in the frontend, explicitly add ES1 support to all configs
+ for (auto &config : mConfigSet)
+ {
+ // TODO(geofflang): Enable the conformant bit once we pass enough tests
+ // config.second.conformant |= EGL_OPENGL_ES_BIT;
+
+ config.second.renderableType |= EGL_OPENGL_ES_BIT;
+
+ // If we aren't using desktop GL entry points, remove desktop GL support from all configs
+#if !defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND)
+ config.second.renderableType &= ~EGL_OPENGL_BIT;
+#endif
+ }
+
+ if (!mState.featuresAllDisabled)
+ {
+ initializeFrontendFeatures();
+ }
+
+ mFeatures.clear();
+ mFrontendFeatures.populateFeatureList(&mFeatures);
+ mImplementation->populateFeatureList(&mFeatures);
+
+ initDisplayExtensions();
+ initVendorString();
+ initVersionString();
+ initClientAPIString();
+
+ // Populate the Display's EGLDeviceEXT if the Display wasn't created using one
+ if (mPlatform == EGL_PLATFORM_DEVICE_EXT)
+ {
+ // For EGL_PLATFORM_DEVICE_EXT, mDevice should always be populated using
+ // an external device
+ ASSERT(mDevice != nullptr);
+ }
+ else if (GetClientExtensions().deviceQueryEXT)
+ {
+ std::unique_ptr<rx::DeviceImpl> impl(mImplementation->createDevice());
+ ASSERT(impl);
+ error = impl->initialize();
+ if (error.isError())
+ {
+ ERR() << "Failed to initialize display because device creation failed: "
+ << error.getMessage();
+ mImplementation->terminate();
+ return error;
+ }
+ // Don't leak Device memory.
+ ASSERT(mDevice == nullptr);
+ mDevice = new Device(this, impl.release());
+ }
+ else
+ {
+ mDevice = nullptr;
+ }
+
+ mInitialized = true;
+
+ return NoError();
+}
+
+Error Display::destroyInvalidEglObjects()
+{
+ // Destroy invalid EGL objects
+ while (!mInvalidContextSet.empty())
+ {
+ gl::Context *context = *mInvalidContextSet.begin();
+ context->setIsDestroyed();
+ ANGLE_TRY(releaseContextImpl(context, &mInvalidContextSet));
+ }
+
+ while (!mInvalidImageSet.empty())
+ {
+ destroyImageImpl(*mInvalidImageSet.begin(), &mInvalidImageSet);
+ }
+
+ while (!mInvalidStreamSet.empty())
+ {
+ destroyStreamImpl(*mInvalidStreamSet.begin(), &mInvalidStreamSet);
+ }
+
+ while (!mInvalidSurfaceSet.empty())
+ {
+ ANGLE_TRY(destroySurfaceImpl(*mInvalidSurfaceSet.begin(), &mInvalidSurfaceSet));
+ }
+
+ while (!mInvalidSyncSet.empty())
+ {
+ destroySyncImpl(*mInvalidSyncSet.begin(), &mInvalidSyncSet);
+ }
+
+ return NoError();
+}
+
+Error Display::terminate(Thread *thread, TerminateReason terminateReason)
+{
+ if (terminateReason == TerminateReason::Api)
+ {
+ mTerminatedByApi = true;
+ }
+
+ // All subsequent calls assume the display to be valid and terminated by app.
+ // If it is not terminated or if it isn't even initialized, early return.
+ if (!mTerminatedByApi || !mInitialized)
+ {
+ return NoError();
+ }
+
+ // EGL 1.5 Specification
+ // 3.2 Initialization
+ // Termination marks all EGL-specific resources, such as contexts and surfaces, associated
+ // with the specified display for deletion. Handles to all such resources are invalid as soon
+ // as eglTerminate returns. Cache EGL objects that are no longer valid.
+ //
+ // It is fairly common for apps to call eglTerminate while some contexts and/or surfaces are
+ // still current on some thread. Since objects are refCounted, trying to destroy them right away
+ // would only result in a decRef. We instead cache such invalid objects and use other EGL
+ // entrypoints like eglReleaseThread or thread exit events (on the Android platform) to
+ // perform the necessary cleanup.
+ mInvalidImageSet.insert(mImageSet.begin(), mImageSet.end());
+ mImageSet.clear();
+
+ mInvalidStreamSet.insert(mStreamSet.begin(), mStreamSet.end());
+ mStreamSet.clear();
+
+ mInvalidSurfaceSet.insert(mState.surfaceSet.begin(), mState.surfaceSet.end());
+ mState.surfaceSet.clear();
+
+ mInvalidSyncSet.insert(mSyncSet.begin(), mSyncSet.end());
+ mSyncSet.clear();
+
+ // Cache total number of contexts before invalidation. This is used as a check to verify that
+ // no context is "lost" while being moved between the various sets.
+ size_t contextSetSizeBeforeInvalidation = mState.contextSet.size() + mInvalidContextSet.size();
+
+ // If app called eglTerminate and no active threads remain,
+ // force realease any context that is still current.
+ ContextSet contextsStillCurrent = {};
+ for (gl::Context *context : mState.contextSet)
+ {
+ if (context->getRefCount() > 0)
+ {
+ if (terminateReason == TerminateReason::NoActiveThreads)
+ {
+ ASSERT(mTerminatedByApi);
+ context->release();
+ (void)context->unMakeCurrent(this);
+ }
+ else
+ {
+ contextsStillCurrent.emplace(context);
+ continue;
+ }
+ }
+
+ // Add context that is not current to mInvalidContextSet for cleanup.
+ mInvalidContextSet.emplace(context);
+ }
+
+ // There are many methods that require contexts that are still current to be present in
+ // display's contextSet like during context release or to notify of state changes in a subject.
+ // So as to not interrupt this flow, do not remove contexts that are still current on some
+ // thread from display's contextSet even though eglTerminate marks such contexts as invalid.
+ //
+ // "mState.contextSet" will now contain only those contexts that are still current on some
+ // thread.
+ mState.contextSet = std::move(contextsStillCurrent);
+
+ // Assert that the total number of contexts is the same before and after context invalidation.
+ ASSERT(contextSetSizeBeforeInvalidation ==
+ mState.contextSet.size() + mInvalidContextSet.size());
+
+ if (!mState.contextSet.empty())
+ {
+ // There was atleast 1 context that was current on some thread, early return.
+ return NoError();
+ }
+
+ mMemoryProgramCache.clear();
+ mMemoryShaderCache.clear();
+ mBlobCache.setBlobCacheFuncs(nullptr, nullptr);
+
+ // The global texture and semaphore managers should be deleted with the last context that uses
+ // it.
+ ASSERT(mGlobalTextureShareGroupUsers == 0 && mTextureManager == nullptr);
+ ASSERT(mGlobalSemaphoreShareGroupUsers == 0 && mSemaphoreManager == nullptr);
+
+ // Clean up all invalid objects
+ ANGLE_TRY(destroyInvalidEglObjects());
+
+ mConfigSet.clear();
+
+ if (mDevice != nullptr && mDevice->getOwningDisplay() != nullptr)
+ {
+ // Don't delete the device if it was created externally using eglCreateDeviceANGLE
+ // We also shouldn't set it to null in case eglInitialize() is called again later
+ SafeDelete(mDevice);
+ }
+
+ mImplementation->terminate();
+
+ mDeviceLost = false;
+
+ mInitialized = false;
+
+ gl::UninitializeDebugAnnotations();
+
+ // TODO(jmadill): Store Platform in Display and deinit here.
+ ANGLEResetDisplayPlatform(this);
+
+ return NoError();
+}
+
+Error Display::prepareForCall()
+{
+ return mImplementation->prepareForCall();
+}
+
+Error Display::releaseThread()
+{
+ ANGLE_TRY(mImplementation->releaseThread());
+ return destroyInvalidEglObjects();
+}
+
+void Display::addActiveThread(Thread *thread)
+{
+ mActiveThreads.insert(thread);
+}
+
+void Display::threadCleanup(Thread *thread)
+{
+ mActiveThreads.erase(thread);
+ const bool noActiveThreads = mActiveThreads.size() == 0;
+
+ (void)terminate(thread, noActiveThreads ? TerminateReason::NoActiveThreads
+ : TerminateReason::InternalCleanup);
+}
+
+std::vector<const Config *> Display::getConfigs(const egl::AttributeMap &attribs) const
+{
+ return mConfigSet.filter(attribs);
+}
+
+std::vector<const Config *> Display::chooseConfig(const egl::AttributeMap &attribs) const
+{
+ egl::AttributeMap attribsWithDefaults = AttributeMap();
+
+ // Insert default values for attributes that have either an Exact or Mask selection criteria,
+ // and a default value that matters (e.g. isn't EGL_DONT_CARE):
+ attribsWithDefaults.insert(EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER);
+ attribsWithDefaults.insert(EGL_LEVEL, 0);
+ attribsWithDefaults.insert(EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT);
+ attribsWithDefaults.insert(EGL_SURFACE_TYPE, EGL_WINDOW_BIT);
+ attribsWithDefaults.insert(EGL_TRANSPARENT_TYPE, EGL_NONE);
+ if (getExtensions().pixelFormatFloat)
+ {
+ attribsWithDefaults.insert(EGL_COLOR_COMPONENT_TYPE_EXT,
+ EGL_COLOR_COMPONENT_TYPE_FIXED_EXT);
+ }
+
+ // Add the caller-specified values (Note: the poorly-named insert() method will replace any
+ // of the default values from above):
+ for (auto attribIter = attribs.begin(); attribIter != attribs.end(); attribIter++)
+ {
+ attribsWithDefaults.insert(attribIter->first, attribIter->second);
+ }
+
+ return mConfigSet.filter(attribsWithDefaults);
+}
+
+Error Display::createWindowSurface(const Config *configuration,
+ EGLNativeWindowType window,
+ const AttributeMap &attribs,
+ Surface **outSurface)
+{
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ SurfacePointer surface(new WindowSurface(mImplementation, configuration, window, attribs,
+ mFrontendFeatures.forceRobustResourceInit.enabled),
+ this);
+ ANGLE_TRY(surface->initialize(this));
+
+ ASSERT(outSurface != nullptr);
+ *outSurface = surface.release();
+ mState.surfaceSet.insert(*outSurface);
+
+ WindowSurfaceMap *windowSurfaces = GetWindowSurfaces();
+ ASSERT(windowSurfaces && windowSurfaces->find(window) == windowSurfaces->end());
+ windowSurfaces->insert(std::make_pair(window, *outSurface));
+
+ mSurface = *outSurface;
+
+ return NoError();
+}
+
+Error Display::createPbufferSurface(const Config *configuration,
+ const AttributeMap &attribs,
+ Surface **outSurface)
+{
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ SurfacePointer surface(new PbufferSurface(mImplementation, configuration, attribs,
+ mFrontendFeatures.forceRobustResourceInit.enabled),
+ this);
+ ANGLE_TRY(surface->initialize(this));
+
+ ASSERT(outSurface != nullptr);
+ *outSurface = surface.release();
+ mState.surfaceSet.insert(*outSurface);
+
+ return NoError();
+}
+
+Error Display::createPbufferFromClientBuffer(const Config *configuration,
+ EGLenum buftype,
+ EGLClientBuffer clientBuffer,
+ const AttributeMap &attribs,
+ Surface **outSurface)
+{
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ SurfacePointer surface(
+ new PbufferSurface(mImplementation, configuration, buftype, clientBuffer, attribs,
+ mFrontendFeatures.forceRobustResourceInit.enabled),
+ this);
+ ANGLE_TRY(surface->initialize(this));
+
+ ASSERT(outSurface != nullptr);
+ *outSurface = surface.release();
+ mState.surfaceSet.insert(*outSurface);
+
+ return NoError();
+}
+
+Error Display::createPixmapSurface(const Config *configuration,
+ NativePixmapType nativePixmap,
+ const AttributeMap &attribs,
+ Surface **outSurface)
+{
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ SurfacePointer surface(new PixmapSurface(mImplementation, configuration, nativePixmap, attribs,
+ mFrontendFeatures.forceRobustResourceInit.enabled),
+ this);
+ ANGLE_TRY(surface->initialize(this));
+
+ ASSERT(outSurface != nullptr);
+ *outSurface = surface.release();
+ mState.surfaceSet.insert(*outSurface);
+
+ return NoError();
+}
+
+Error Display::createImage(const gl::Context *context,
+ EGLenum target,
+ EGLClientBuffer buffer,
+ const AttributeMap &attribs,
+ Image **outImage)
+{
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ egl::ImageSibling *sibling = nullptr;
+ if (IsTextureTarget(target))
+ {
+ sibling = context->getTexture({egl_gl::EGLClientBufferToGLObjectHandle(buffer)});
+ }
+ else if (IsRenderbufferTarget(target))
+ {
+ sibling = context->getRenderbuffer({egl_gl::EGLClientBufferToGLObjectHandle(buffer)});
+ }
+ else if (IsExternalImageTarget(target))
+ {
+ sibling = new ExternalImageSibling(mImplementation, context, target, buffer, attribs);
+ }
+ else
+ {
+ UNREACHABLE();
+ }
+ ASSERT(sibling != nullptr);
+
+ angle::UniqueObjectPointer<Image, Display> imagePtr(
+ new Image(mImplementation, context, target, sibling, attribs), this);
+ ANGLE_TRY(imagePtr->initialize(this));
+
+ Image *image = imagePtr.release();
+
+ ASSERT(outImage != nullptr);
+ *outImage = image;
+
+ // Add this image to the list of all images and hold a ref to it.
+ image->addRef();
+ mImageSet.insert(image);
+
+ return NoError();
+}
+
+Error Display::createStream(const AttributeMap &attribs, Stream **outStream)
+{
+ ASSERT(isInitialized());
+
+ Stream *stream = new Stream(this, attribs);
+
+ ASSERT(stream != nullptr);
+ mStreamSet.insert(stream);
+
+ ASSERT(outStream != nullptr);
+ *outStream = stream;
+
+ return NoError();
+}
+
+Error Display::createContext(const Config *configuration,
+ gl::Context *shareContext,
+ EGLenum clientType,
+ const AttributeMap &attribs,
+ gl::Context **outContext)
+{
+ ASSERT(!mTerminatedByApi);
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ // This display texture sharing will allow the first context to create the texture share group.
+ bool usingDisplayTextureShareGroup =
+ attribs.get(EGL_DISPLAY_TEXTURE_SHARE_GROUP_ANGLE, EGL_FALSE) == EGL_TRUE;
+ gl::TextureManager *shareTextures = nullptr;
+
+ if (usingDisplayTextureShareGroup)
+ {
+ ASSERT((mTextureManager == nullptr) == (mGlobalTextureShareGroupUsers == 0));
+ if (mTextureManager == nullptr)
+ {
+ mTextureManager = new gl::TextureManager();
+ }
+
+ mGlobalTextureShareGroupUsers++;
+ shareTextures = mTextureManager;
+ }
+
+ // This display semaphore sharing will allow the first context to create the semaphore share
+ // group.
+ bool usingDisplaySemaphoreShareGroup =
+ attribs.get(EGL_DISPLAY_SEMAPHORE_SHARE_GROUP_ANGLE, EGL_FALSE) == EGL_TRUE;
+ gl::SemaphoreManager *shareSemaphores = nullptr;
+ if (usingDisplaySemaphoreShareGroup)
+ {
+ ASSERT((mSemaphoreManager == nullptr) == (mGlobalSemaphoreShareGroupUsers == 0));
+ if (mSemaphoreManager == nullptr)
+ {
+ mSemaphoreManager = new gl::SemaphoreManager();
+ }
+
+ mGlobalSemaphoreShareGroupUsers++;
+ shareSemaphores = mSemaphoreManager;
+ }
+
+ gl::MemoryProgramCache *programCachePointer = &mMemoryProgramCache;
+ // Check context creation attributes to see if we are using EGL_ANGLE_program_cache_control.
+ // If not, keep caching enabled for EGL_ANDROID_blob_cache, which can have its callbacks set
+ // at any time.
+ bool usesProgramCacheControl = attribs.contains(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE);
+ if (usesProgramCacheControl)
+ {
+ bool programCacheControlEnabled =
+ (attribs.get(EGL_CONTEXT_PROGRAM_BINARY_CACHE_ENABLED_ANGLE, GL_FALSE) == GL_TRUE);
+ // A program cache size of zero indicates it should be disabled.
+ if (!programCacheControlEnabled || mMemoryProgramCache.maxSize() == 0)
+ {
+ programCachePointer = nullptr;
+ }
+ }
+
+ gl::MemoryShaderCache *shaderCachePointer = &mMemoryShaderCache;
+ // Check if shader caching frontend feature is enabled.
+ if (!mFrontendFeatures.cacheCompiledShader.enabled)
+ {
+ shaderCachePointer = nullptr;
+ }
+
+ gl::Context *context = new gl::Context(
+ this, configuration, shareContext, shareTextures, shareSemaphores, programCachePointer,
+ shaderCachePointer, clientType, attribs, mDisplayExtensions, GetClientExtensions());
+ Error error = context->initialize();
+ if (error.isError())
+ {
+ delete context;
+ return error;
+ }
+
+ if (shareContext != nullptr)
+ {
+ shareContext->setShared();
+ }
+
+ ASSERT(context != nullptr);
+ mState.contextSet.insert(context);
+
+ ASSERT(outContext != nullptr);
+ *outContext = context;
+ return NoError();
+}
+
+Error Display::createSync(const gl::Context *currentContext,
+ EGLenum type,
+ const AttributeMap &attribs,
+ Sync **outSync)
+{
+ ASSERT(isInitialized());
+
+ if (mImplementation->testDeviceLost())
+ {
+ ANGLE_TRY(restoreLostDevice());
+ }
+
+ angle::UniqueObjectPointer<egl::Sync, Display> syncPtr(new Sync(mImplementation, type, attribs),
+ this);
+
+ ANGLE_TRY(syncPtr->initialize(this, currentContext));
+
+ Sync *sync = syncPtr.release();
+
+ sync->addRef();
+ mSyncSet.insert(sync);
+
+ *outSync = sync;
+ return NoError();
+}
+
+Error Display::makeCurrent(Thread *thread,
+ gl::Context *previousContext,
+ egl::Surface *drawSurface,
+ egl::Surface *readSurface,
+ gl::Context *context)
+{
+ if (!mInitialized)
+ {
+ return NoError();
+ }
+
+ bool contextChanged = context != previousContext;
+ if (previousContext != nullptr && contextChanged)
+ {
+ previousContext->release();
+ thread->setCurrent(nullptr);
+
+ auto error = previousContext->unMakeCurrent(this);
+ if (previousContext->getRefCount() == 0 && previousContext->isDestroyed())
+ {
+ // The previous Context may have been created with a different Display.
+ Display *previousDisplay = previousContext->getDisplay();
+ ANGLE_TRY(previousDisplay->releaseContext(previousContext, thread));
+ }
+ ANGLE_TRY(error);
+ }
+
+ thread->setCurrent(context);
+
+ ANGLE_TRY(mImplementation->makeCurrent(this, drawSurface, readSurface, context));
+
+ if (context != nullptr)
+ {
+ ANGLE_TRY(context->makeCurrent(this, drawSurface, readSurface));
+ if (contextChanged)
+ {
+ context->addRef();
+ }
+ }
+
+ // Tick all the scratch buffers to make sure they get cleaned up eventually if they stop being
+ // used.
+ {
+ std::lock_guard<std::mutex> lock(mScratchBufferMutex);
+
+ for (angle::ScratchBuffer &scatchBuffer : mScratchBuffers)
+ {
+ scatchBuffer.tick();
+ }
+ for (angle::ScratchBuffer &zeroFilledBuffer : mZeroFilledBuffers)
+ {
+ zeroFilledBuffer.tick();
+ }
+ }
+
+ return NoError();
+}
+
+Error Display::restoreLostDevice()
+{
+ for (ContextSet::iterator ctx = mState.contextSet.begin(); ctx != mState.contextSet.end();
+ ctx++)
+ {
+ if ((*ctx)->isResetNotificationEnabled())
+ {
+ // If reset notifications have been requested, application must delete all contexts
+ // first
+ return EglContextLost();
+ }
+ }
+
+ return mImplementation->restoreLostDevice(this);
+}
+
+Error Display::destroySurfaceImpl(Surface *surface, SurfaceSet *surfaces)
+{
+ if (surface->getType() == EGL_WINDOW_BIT)
+ {
+ WindowSurfaceMap *windowSurfaces = GetWindowSurfaces();
+ ASSERT(windowSurfaces);
+
+ bool surfaceRemoved = false;
+ for (WindowSurfaceMap::iterator iter = windowSurfaces->begin();
+ iter != windowSurfaces->end(); iter++)
+ {
+ if (iter->second == surface)
+ {
+ windowSurfaces->erase(iter);
+ surfaceRemoved = true;
+ break;
+ }
+ }
+
+ ASSERT(surfaceRemoved);
+ }
+
+ auto iter = surfaces->find(surface);
+ ASSERT(iter != surfaces->end());
+ surfaces->erase(iter);
+ ANGLE_TRY(surface->onDestroy(this));
+ return NoError();
+}
+
+void Display::destroyImageImpl(Image *image, ImageSet *images)
+{
+ auto iter = images->find(image);
+ ASSERT(iter != images->end());
+ (*iter)->release(this);
+ images->erase(iter);
+}
+
+void Display::destroyStreamImpl(Stream *stream, StreamSet *streams)
+{
+ streams->erase(stream);
+ SafeDelete(stream);
+}
+
+// releaseContext must be called with the context being deleted as current.
+// To do that we can only call this in two places, Display::makeCurrent at the point where this
+// context is being made uncurrent and in Display::destroyContext where we make the context current
+// as part of destruction.
+Error Display::releaseContext(gl::Context *context, Thread *thread)
+{
+ return releaseContextImpl(context, &mState.contextSet);
+}
+
+Error Display::releaseContextImpl(gl::Context *context, ContextSet *contexts)
+{
+ ASSERT(context->getRefCount() == 0);
+
+ // Use scoped_ptr to make sure the context is always freed.
+ std::unique_ptr<gl::Context> unique_context(context);
+ ASSERT(contexts->find(context) != contexts->end());
+ contexts->erase(context);
+
+ if (context->usingDisplayTextureShareGroup())
+ {
+ ASSERT(mGlobalTextureShareGroupUsers >= 1 && mTextureManager != nullptr);
+ if (mGlobalTextureShareGroupUsers == 1)
+ {
+ // If this is the last context using the global share group, destroy the global
+ // texture manager so that the textures can be destroyed while a context still
+ // exists
+ mTextureManager->release(context);
+ mTextureManager = nullptr;
+ }
+ mGlobalTextureShareGroupUsers--;
+ }
+
+ if (context->usingDisplaySemaphoreShareGroup())
+ {
+ ASSERT(mGlobalSemaphoreShareGroupUsers >= 1 && mSemaphoreManager != nullptr);
+ if (mGlobalSemaphoreShareGroupUsers == 1)
+ {
+ // If this is the last context using the global share group, destroy the global
+ // semaphore manager so that the semaphores can be destroyed while a context still
+ // exists
+ mSemaphoreManager->release(context);
+ mSemaphoreManager = nullptr;
+ }
+ mGlobalSemaphoreShareGroupUsers--;
+ }
+
+ ANGLE_TRY(context->onDestroy(this));
+
+ return NoError();
+}
+
+Error Display::destroyContext(Thread *thread, gl::Context *context)
+{
+ auto *currentContext = thread->getContext();
+ auto *currentDrawSurface = thread->getCurrentDrawSurface();
+ auto *currentReadSurface = thread->getCurrentReadSurface();
+
+ context->setIsDestroyed();
+
+ // If the context is still current on at least 1 thread, just return since it'll be released
+ // once no threads have it current anymore.
+ if (context->getRefCount() > 0)
+ {
+ return NoError();
+ }
+
+ // For external context, we cannot change the current native context, and the API user should
+ // make sure the native context is current.
+ if (context->isExternal())
+ {
+ ANGLE_TRY(releaseContext(context, thread));
+ }
+ else
+ {
+ // Keep |currentContext| alive, while releasing |context|.
+ gl::ScopedContextRef scopedContextRef(currentContext);
+
+ // keep |currentDrawSurface| and |currentReadSurface| alive as well
+ // while releasing |context|.
+ ScopedSurfaceRef drawSurfaceRef(currentDrawSurface);
+ ScopedSurfaceRef readSurfaceRef(
+ currentReadSurface == currentDrawSurface ? nullptr : currentReadSurface);
+
+ // Make the context current, so we can release resources belong to the context, and then
+ // when context is released from the current, it will be destroyed.
+ // TODO(http://www.anglebug.com/6322): Don't require a Context to be current in order to
+ // destroy it.
+ ANGLE_TRY(makeCurrent(thread, currentContext, nullptr, nullptr, context));
+ ANGLE_TRY(
+ makeCurrent(thread, context, currentDrawSurface, currentReadSurface, currentContext));
+ }
+
+ // If eglTerminate() has previously been called and this is the last Context the Display owns,
+ // we can now fully terminate the display and release all of its resources.
+ if (mTerminatedByApi)
+ {
+ for (const gl::Context *ctx : mState.contextSet)
+ {
+ if (ctx->getRefCount() > 0)
+ {
+ return NoError();
+ }
+ }
+
+ return terminate(thread, TerminateReason::InternalCleanup);
+ }
+
+ return NoError();
+}
+
+void Display::destroySyncImpl(Sync *sync, SyncSet *syncs)
+{
+ auto iter = syncs->find(sync);
+ ASSERT(iter != syncs->end());
+ (*iter)->release(this);
+ syncs->erase(iter);
+}
+
+void Display::destroyImage(Image *image)
+{
+ return destroyImageImpl(image, &mImageSet);
+}
+
+void Display::destroyStream(Stream *stream)
+{
+ return destroyStreamImpl(stream, &mStreamSet);
+}
+
+Error Display::destroySurface(Surface *surface)
+{
+ return destroySurfaceImpl(surface, &mState.surfaceSet);
+}
+
+void Display::destroySync(Sync *sync)
+{
+ return destroySyncImpl(sync, &mSyncSet);
+}
+
+bool Display::isDeviceLost() const
+{
+ ASSERT(isInitialized());
+ return mDeviceLost;
+}
+
+bool Display::testDeviceLost()
+{
+ ASSERT(isInitialized());
+
+ if (!mDeviceLost && mImplementation->testDeviceLost())
+ {
+ notifyDeviceLost();
+ }
+
+ return mDeviceLost;
+}
+
+void Display::notifyDeviceLost()
+{
+ if (mDeviceLost)
+ {
+ return;
+ }
+
+ for (ContextSet::iterator context = mState.contextSet.begin();
+ context != mState.contextSet.end(); context++)
+ {
+ (*context)->markContextLost(gl::GraphicsResetStatus::UnknownContextReset);
+ }
+
+ mDeviceLost = true;
+}
+
+void Display::setBlobCacheFuncs(EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get)
+{
+ mBlobCache.setBlobCacheFuncs(set, get);
+ mImplementation->setBlobCacheFuncs(set, get);
+}
+
+// static
+EGLClientBuffer Display::GetNativeClientBuffer(const AHardwareBuffer *buffer)
+{
+ return angle::android::AHardwareBufferToClientBuffer(buffer);
+}
+
+// static
+Error Display::CreateNativeClientBuffer(const egl::AttributeMap &attribMap,
+ EGLClientBuffer *eglClientBuffer)
+{
+ int androidHardwareBufferFormat = gl::GetAndroidHardwareBufferFormatFromChannelSizes(attribMap);
+ int width = attribMap.getAsInt(EGL_WIDTH, 0);
+ int height = attribMap.getAsInt(EGL_HEIGHT, 0);
+ int usage = attribMap.getAsInt(EGL_NATIVE_BUFFER_USAGE_ANDROID, 0);
+
+ // https://developer.android.com/ndk/reference/group/a-hardware-buffer#ahardwarebuffer_lock
+ // for AHardwareBuffer_lock()
+ // The passed AHardwareBuffer must have one layer, otherwise the call will fail.
+ constexpr int kLayerCount = 1;
+
+ *eglClientBuffer = angle::android::CreateEGLClientBufferFromAHardwareBuffer(
+ width, height, kLayerCount, androidHardwareBufferFormat, usage);
+
+ return (*eglClientBuffer == nullptr)
+ ? egl::EglBadParameter() << "native client buffer allocation failed."
+ : NoError();
+}
+
+Error Display::waitClient(const gl::Context *context)
+{
+ return mImplementation->waitClient(context);
+}
+
+Error Display::waitNative(const gl::Context *context, EGLint engine)
+{
+ return mImplementation->waitNative(context, engine);
+}
+
+const Caps &Display::getCaps() const
+{
+ return mCaps;
+}
+
+bool Display::isInitialized() const
+{
+ return mInitialized;
+}
+
+bool Display::isValidConfig(const Config *config) const
+{
+ return mConfigSet.contains(config);
+}
+
+bool Display::isValidContext(const gl::Context *context) const
+{
+ return mState.contextSet.find(const_cast<gl::Context *>(context)) != mState.contextSet.end();
+}
+
+bool Display::isValidSurface(const Surface *surface) const
+{
+ return mState.surfaceSet.find(const_cast<Surface *>(surface)) != mState.surfaceSet.end();
+}
+
+bool Display::isValidImage(const Image *image) const
+{
+ return mImageSet.find(const_cast<Image *>(image)) != mImageSet.end();
+}
+
+bool Display::isValidStream(const Stream *stream) const
+{
+ return mStreamSet.find(const_cast<Stream *>(stream)) != mStreamSet.end();
+}
+
+bool Display::isValidSync(const Sync *sync) const
+{
+ return mSyncSet.find(const_cast<Sync *>(sync)) != mSyncSet.end();
+}
+
+bool Display::hasExistingWindowSurface(EGLNativeWindowType window)
+{
+ WindowSurfaceMap *windowSurfaces = GetWindowSurfaces();
+ ASSERT(windowSurfaces);
+
+ return windowSurfaces->find(window) != windowSurfaces->end();
+}
+
+static ClientExtensions GenerateClientExtensions()
+{
+ ClientExtensions extensions;
+
+ extensions.clientExtensions = true;
+ extensions.platformBase = true;
+ extensions.platformANGLE = true;
+
+#if defined(ANGLE_ENABLE_D3D9) || defined(ANGLE_ENABLE_D3D11)
+ extensions.platformANGLED3D = true;
+ extensions.platformDevice = true;
+#endif
+
+#if defined(ANGLE_USE_GBM)
+ extensions.platformGbmKHR = true;
+#endif
+
+#if defined(ANGLE_USE_WAYLAND)
+ extensions.platformWaylandEXT = true;
+#endif
+
+#if defined(ANGLE_ENABLE_D3D11)
+# if defined(ANGLE_ENABLE_WINDOWS_UWP)
+ extensions.platformANGLED3D11ON12 = true;
+# else
+ extensions.platformANGLED3D11ON12 = IsWindows10OrGreater();
+# endif
+ extensions.platformANGLEDeviceId = true;
+#endif
+
+#if defined(ANGLE_ENABLE_OPENGL)
+ extensions.platformANGLEOpenGL = true;
+#endif
+
+#if defined(ANGLE_ENABLE_NULL)
+ extensions.platformANGLENULL = true;
+#endif
+
+#if defined(ANGLE_ENABLE_D3D11)
+ extensions.deviceCreation = true;
+ extensions.deviceCreationD3D11 = true;
+ extensions.experimentalPresentPath = true;
+#endif
+
+#if defined(ANGLE_ENABLE_VULKAN)
+ extensions.platformANGLEVulkan = true;
+ extensions.platformANGLEDeviceId = true;
+#endif
+
+#if defined(ANGLE_ENABLE_SWIFTSHADER)
+ extensions.platformANGLEDeviceTypeSwiftShader = true;
+#endif
+
+#if defined(ANGLE_ENABLE_METAL)
+ extensions.platformANGLEMetal = true;
+ extensions.platformANGLEDeviceId = true;
+#endif
+
+#if defined(ANGLE_USE_X11)
+ extensions.x11Visual = true;
+#endif
+
+#if defined(ANGLE_PLATFORM_LINUX)
+ extensions.platformANGLEDeviceTypeEGLANGLE = true;
+#endif
+
+#if (defined(ANGLE_PLATFORM_IOS) && !defined(ANGLE_PLATFORM_MACCATALYST)) || \
+ (defined(ANGLE_PLATFORM_MACCATALYST) && defined(ANGLE_CPU_ARM64))
+ extensions.platformANGLEDeviceContextVolatileEagl = true;
+#endif
+
+#if defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_MACCATALYST)
+ extensions.platformANGLEDeviceContextVolatileCgl = true;
+#endif
+
+#if defined(ANGLE_ENABLE_METAL)
+ extensions.displayPowerPreferenceANGLE = true;
+#endif
+
+ extensions.clientGetAllProcAddresses = true;
+ extensions.debug = true;
+ extensions.featureControlANGLE = true;
+ extensions.deviceQueryEXT = true;
+
+ return extensions;
+}
+
+template <typename T>
+static std::string GenerateExtensionsString(const T &extensions)
+{
+ std::vector<std::string> extensionsVector = extensions.getStrings();
+
+ std::ostringstream stream;
+ std::copy(extensionsVector.begin(), extensionsVector.end(),
+ std::ostream_iterator<std::string>(stream, " "));
+ return stream.str();
+}
+
+// static
+const ClientExtensions &Display::GetClientExtensions()
+{
+ static const ClientExtensions clientExtensions = GenerateClientExtensions();
+ return clientExtensions;
+}
+
+// static
+const std::string &Display::GetClientExtensionString()
+{
+ static const angle::base::NoDestructor<std::string> clientExtensionsString(
+ GenerateExtensionsString(GetClientExtensions()));
+ return *clientExtensionsString;
+}
+
+void Display::initDisplayExtensions()
+{
+ mDisplayExtensions = mImplementation->getExtensions();
+
+ // Some extensions are always available because they are implemented in the EGL layer.
+ mDisplayExtensions.createContext = true;
+ mDisplayExtensions.createContextNoError = !mFrontendFeatures.forceGlErrorChecking.enabled;
+ mDisplayExtensions.createContextWebGLCompatibility = true;
+ mDisplayExtensions.createContextBindGeneratesResource = true;
+ mDisplayExtensions.createContextClientArrays = true;
+ mDisplayExtensions.pixelFormatFloat = true;
+ mDisplayExtensions.reusableSyncKHR = true;
+
+ // Force EGL_KHR_get_all_proc_addresses on.
+ mDisplayExtensions.getAllProcAddresses = true;
+
+ // Enable program cache control since it is not back-end dependent.
+ mDisplayExtensions.programCacheControlANGLE = true;
+
+ // Request extension is implemented in the ANGLE frontend
+ mDisplayExtensions.createContextExtensionsEnabled = true;
+
+ // Blob cache extension is provided by the ANGLE frontend
+ mDisplayExtensions.blobCache = true;
+
+ // The EGL_ANDROID_recordable extension is provided by the ANGLE frontend, and will always
+ // say that ANativeWindow is not recordable.
+ mDisplayExtensions.recordable = true;
+
+ // All backends support specific context versions
+ mDisplayExtensions.createContextBackwardsCompatible = true;
+
+ mDisplayExtensionString = GenerateExtensionsString(mDisplayExtensions);
+}
+
+bool Display::isValidNativeWindow(EGLNativeWindowType window) const
+{
+ return mImplementation->isValidNativeWindow(window);
+}
+
+Error Display::validateClientBuffer(const Config *configuration,
+ EGLenum buftype,
+ EGLClientBuffer clientBuffer,
+ const AttributeMap &attribs) const
+{
+ return mImplementation->validateClientBuffer(configuration, buftype, clientBuffer, attribs);
+}
+
+Error Display::validateImageClientBuffer(const gl::Context *context,
+ EGLenum target,
+ EGLClientBuffer clientBuffer,
+ const egl::AttributeMap &attribs) const
+{
+ return mImplementation->validateImageClientBuffer(context, target, clientBuffer, attribs);
+}
+
+Error Display::valdiatePixmap(const Config *config,
+ EGLNativePixmapType pixmap,
+ const AttributeMap &attributes) const
+{
+ return mImplementation->validatePixmap(config, pixmap, attributes);
+}
+
+bool Display::isValidDisplay(const egl::Display *display)
+{
+ const ANGLEPlatformDisplayMap *anglePlatformDisplayMap = GetANGLEPlatformDisplayMap();
+ for (const auto &displayPair : *anglePlatformDisplayMap)
+ {
+ if (displayPair.second == display)
+ {
+ return true;
+ }
+ }
+
+ const DevicePlatformDisplayMap *devicePlatformDisplayMap = GetDevicePlatformDisplayMap();
+ for (const auto &displayPair : *devicePlatformDisplayMap)
+ {
+ if (displayPair.second == display)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool Display::isValidNativeDisplay(EGLNativeDisplayType display)
+{
+ // TODO(jmadill): handle this properly
+ if (display == EGL_DEFAULT_DISPLAY)
+ {
+ return true;
+ }
+
+#if defined(ANGLE_PLATFORM_WINDOWS) && !defined(ANGLE_ENABLE_WINDOWS_UWP)
+ if (display == EGL_SOFTWARE_DISPLAY_ANGLE || display == EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE ||
+ display == EGL_D3D11_ONLY_DISPLAY_ANGLE)
+ {
+ return true;
+ }
+ return (WindowFromDC(display) != nullptr);
+#else
+ return true;
+#endif
+}
+
+void Display::initVendorString()
+{
+ mVendorString = "Google Inc.";
+ std::string vendorStringImpl = mImplementation->getVendorString();
+ if (!vendorStringImpl.empty())
+ {
+ mVendorString += " (" + vendorStringImpl + ")";
+ }
+}
+
+void Display::initVersionString()
+{
+ mVersionString = mImplementation->getVersionString(true);
+}
+
+void Display::initClientAPIString()
+{
+ // If the max supported desktop version is not None, we support a desktop GL frontend.
+ if (mImplementation->getMaxSupportedDesktopVersion().valid())
+ {
+ mClientAPIString = "OpenGL_ES OpenGL";
+ }
+ else
+ {
+ mClientAPIString = "OpenGL_ES";
+ }
+}
+
+void Display::initializeFrontendFeatures()
+{
+ // Enable on all Impls
+ ANGLE_FEATURE_CONDITION((&mFrontendFeatures), loseContextOnOutOfMemory, true);
+ ANGLE_FEATURE_CONDITION((&mFrontendFeatures), allowCompressedFormats, true);
+
+ // No longer enable this on any Impl - crbug.com/1165751
+ ANGLE_FEATURE_CONDITION((&mFrontendFeatures), scalarizeVecAndMatConstructorArgs, false);
+
+ // Disabled by default. To reduce the risk, create a feature to enable
+ // compressing pipeline cache in multi-thread pool.
+ ANGLE_FEATURE_CONDITION(&mFrontendFeatures, enableCompressingPipelineCacheInThreadPool, false);
+
+ // Disabled by default until work on the extension is complete - anglebug.com/7279.
+ ANGLE_FEATURE_CONDITION(&mFrontendFeatures, emulatePixelLocalStorage, false);
+
+ mImplementation->initializeFrontendFeatures(&mFrontendFeatures);
+
+ rx::ApplyFeatureOverrides(&mFrontendFeatures, mState);
+}
+
+const DisplayExtensions &Display::getExtensions() const
+{
+ return mDisplayExtensions;
+}
+
+const std::string &Display::getExtensionString() const
+{
+ return mDisplayExtensionString;
+}
+
+const std::string &Display::getVendorString() const
+{
+ return mVendorString;
+}
+
+const std::string &Display::getVersionString() const
+{
+ return mVersionString;
+}
+
+const std::string &Display::getClientAPIString() const
+{
+ return mClientAPIString;
+}
+
+std::string Display::getBackendRendererDescription() const
+{
+ return mImplementation->getRendererDescription();
+}
+
+std::string Display::getBackendVendorString() const
+{
+ return mImplementation->getVendorString();
+}
+
+std::string Display::getBackendVersionString(bool includeFullVersion) const
+{
+ return mImplementation->getVersionString(includeFullVersion);
+}
+
+Device *Display::getDevice() const
+{
+ return mDevice;
+}
+
+Surface *Display::getWGLSurface() const
+{
+ return mSurface;
+}
+
+gl::Version Display::getMaxSupportedESVersion() const
+{
+ return mImplementation->getMaxSupportedESVersion();
+}
+
+EGLint Display::programCacheGetAttrib(EGLenum attrib) const
+{
+ switch (attrib)
+ {
+ case EGL_PROGRAM_CACHE_KEY_LENGTH_ANGLE:
+ return static_cast<EGLint>(BlobCache::kKeyLength);
+
+ case EGL_PROGRAM_CACHE_SIZE_ANGLE:
+ return static_cast<EGLint>(mMemoryProgramCache.entryCount());
+
+ default:
+ UNREACHABLE();
+ return 0;
+ }
+}
+
+Error Display::programCacheQuery(EGLint index,
+ void *key,
+ EGLint *keysize,
+ void *binary,
+ EGLint *binarysize)
+{
+ ASSERT(index >= 0 && index < static_cast<EGLint>(mMemoryProgramCache.entryCount()));
+
+ const BlobCache::Key *programHash = nullptr;
+ BlobCache::Value programBinary;
+ // TODO(jmadill): Make this thread-safe.
+ bool result =
+ mMemoryProgramCache.getAt(static_cast<size_t>(index), &programHash, &programBinary);
+ if (!result)
+ {
+ return EglBadAccess() << "Program binary not accessible.";
+ }
+
+ ASSERT(keysize && binarysize);
+
+ if (key)
+ {
+ ASSERT(*keysize == static_cast<EGLint>(BlobCache::kKeyLength));
+ memcpy(key, programHash->data(), BlobCache::kKeyLength);
+ }
+
+ if (binary)
+ {
+ // Note: we check the size here instead of in the validation code, since we need to
+ // access the cache as atomically as possible. It's possible that the cache contents
+ // could change between the validation size check and the retrieval.
+ if (programBinary.size() > static_cast<size_t>(*binarysize))
+ {
+ return EglBadAccess() << "Program binary too large or changed during access.";
+ }
+
+ memcpy(binary, programBinary.data(), programBinary.size());
+ }
+
+ *binarysize = static_cast<EGLint>(programBinary.size());
+ *keysize = static_cast<EGLint>(BlobCache::kKeyLength);
+
+ return NoError();
+}
+
+Error Display::programCachePopulate(const void *key,
+ EGLint keysize,
+ const void *binary,
+ EGLint binarysize)
+{
+ ASSERT(keysize == static_cast<EGLint>(BlobCache::kKeyLength));
+
+ BlobCache::Key programHash;
+ memcpy(programHash.data(), key, BlobCache::kKeyLength);
+
+ if (!mMemoryProgramCache.putBinary(programHash, reinterpret_cast<const uint8_t *>(binary),
+ static_cast<size_t>(binarysize)))
+ {
+ return EglBadAccess() << "Failed to copy program binary into the cache.";
+ }
+
+ return NoError();
+}
+
+EGLint Display::programCacheResize(EGLint limit, EGLenum mode)
+{
+ switch (mode)
+ {
+ case EGL_PROGRAM_CACHE_RESIZE_ANGLE:
+ {
+ size_t initialSize = mMemoryProgramCache.size();
+ mMemoryProgramCache.resize(static_cast<size_t>(limit));
+ return static_cast<EGLint>(initialSize);
+ }
+
+ case EGL_PROGRAM_CACHE_TRIM_ANGLE:
+ return static_cast<EGLint>(mMemoryProgramCache.trim(static_cast<size_t>(limit)));
+
+ default:
+ UNREACHABLE();
+ return 0;
+ }
+}
+
+void Display::overrideFrontendFeatures(const std::vector<std::string> &featureNames, bool enabled)
+{
+ mFrontendFeatures.overrideFeatures(featureNames, enabled);
+}
+
+const char *Display::queryStringi(const EGLint name, const EGLint index)
+{
+ const char *result = nullptr;
+ switch (name)
+ {
+ case EGL_FEATURE_NAME_ANGLE:
+ result = mFeatures[index]->name;
+ break;
+ case EGL_FEATURE_CATEGORY_ANGLE:
+ result = angle::FeatureCategoryToString(mFeatures[index]->category);
+ break;
+ case EGL_FEATURE_DESCRIPTION_ANGLE:
+ result = mFeatures[index]->description;
+ break;
+ case EGL_FEATURE_BUG_ANGLE:
+ result = mFeatures[index]->bug;
+ break;
+ case EGL_FEATURE_STATUS_ANGLE:
+ result = angle::FeatureStatusToString(mFeatures[index]->enabled);
+ break;
+ case EGL_FEATURE_CONDITION_ANGLE:
+ result = mFeatures[index]->condition;
+ break;
+ default:
+ UNREACHABLE();
+ return nullptr;
+ }
+ return result;
+}
+
+EGLAttrib Display::queryAttrib(const EGLint attribute)
+{
+ EGLAttrib value = 0;
+ switch (attribute)
+ {
+ case EGL_DEVICE_EXT:
+ value = reinterpret_cast<EGLAttrib>(mDevice);
+ break;
+
+ case EGL_FEATURE_COUNT_ANGLE:
+ value = mFeatures.size();
+ break;
+
+ default:
+ UNREACHABLE();
+ }
+ return value;
+}
+
+angle::ScratchBuffer Display::requestScratchBuffer()
+{
+ return requestScratchBufferImpl(&mScratchBuffers);
+}
+
+void Display::returnScratchBuffer(angle::ScratchBuffer scratchBuffer)
+{
+ returnScratchBufferImpl(std::move(scratchBuffer), &mScratchBuffers);
+}
+
+angle::ScratchBuffer Display::requestZeroFilledBuffer()
+{
+ return requestScratchBufferImpl(&mZeroFilledBuffers);
+}
+
+void Display::returnZeroFilledBuffer(angle::ScratchBuffer zeroFilledBuffer)
+{
+ returnScratchBufferImpl(std::move(zeroFilledBuffer), &mZeroFilledBuffers);
+}
+
+angle::ScratchBuffer Display::requestScratchBufferImpl(
+ std::vector<angle::ScratchBuffer> *bufferVector)
+{
+ std::lock_guard<std::mutex> lock(mScratchBufferMutex);
+ if (!bufferVector->empty())
+ {
+ angle::ScratchBuffer buffer = std::move(bufferVector->back());
+ bufferVector->pop_back();
+ return buffer;
+ }
+
+ return angle::ScratchBuffer(kScratchBufferLifetime);
+}
+
+void Display::returnScratchBufferImpl(angle::ScratchBuffer scratchBuffer,
+ std::vector<angle::ScratchBuffer> *bufferVector)
+{
+ std::lock_guard<std::mutex> lock(mScratchBufferMutex);
+ bufferVector->push_back(std::move(scratchBuffer));
+}
+
+Error Display::handleGPUSwitch()
+{
+ ANGLE_TRY(mImplementation->handleGPUSwitch());
+ initVendorString();
+ return NoError();
+}
+
+Error Display::forceGPUSwitch(EGLint gpuIDHigh, EGLint gpuIDLow)
+{
+ ANGLE_TRY(mImplementation->forceGPUSwitch(gpuIDHigh, gpuIDLow));
+ initVendorString();
+ return NoError();
+}
+
+bool Display::supportsDmaBufFormat(EGLint format) const
+{
+ return mImplementation->supportsDmaBufFormat(format);
+}
+
+Error Display::queryDmaBufFormats(EGLint max_formats, EGLint *formats, EGLint *num_formats)
+{
+ ANGLE_TRY(mImplementation->queryDmaBufFormats(max_formats, formats, num_formats));
+ return NoError();
+}
+
+Error Display::queryDmaBufModifiers(EGLint format,
+ EGLint max_modifiers,
+ EGLuint64KHR *modifiers,
+ EGLBoolean *external_only,
+ EGLint *num_modifiers)
+{
+ ANGLE_TRY(mImplementation->queryDmaBufModifiers(format, max_modifiers, modifiers, external_only,
+ num_modifiers));
+ return NoError();
+}
+
+} // namespace egl
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 13:37:31 +0000