mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-10-16 12:17:34 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
797
gfx/gl/GLLibraryEGL.cpp
Normal file
797
gfx/gl/GLLibraryEGL.cpp
Normal file
|
|
@ -0,0 +1,797 @@
|
|||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||||
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
||||
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
#include "GLLibraryEGL.h"
|
||||
|
||||
#include "angle/Platform.h"
|
||||
#include "gfxConfig.h"
|
||||
#include "gfxCrashReporterUtils.h"
|
||||
#include "gfxUtils.h"
|
||||
#include "mozilla/Preferences.h"
|
||||
#include "mozilla/Assertions.h"
|
||||
#include "mozilla/Telemetry.h"
|
||||
#include "mozilla/Tokenizer.h"
|
||||
#include "mozilla/ScopeExit.h"
|
||||
#include "mozilla/Unused.h"
|
||||
#include "nsDirectoryServiceDefs.h"
|
||||
#include "nsDirectoryServiceUtils.h"
|
||||
#include "nsIGfxInfo.h"
|
||||
#include "nsPrintfCString.h"
|
||||
#ifdef XP_WIN
|
||||
#include "nsWindowsHelpers.h"
|
||||
#endif
|
||||
#include "OGLShaderProgram.h"
|
||||
#include "prenv.h"
|
||||
#include "GLContext.h"
|
||||
#include "GLContextProvider.h"
|
||||
#include "gfxPrefs.h"
|
||||
#include "ScopedGLHelpers.h"
|
||||
|
||||
namespace mozilla {
|
||||
namespace gl {
|
||||
|
||||
StaticMutex GLLibraryEGL::sMutex;
|
||||
GLLibraryEGL sEGLLibrary;
|
||||
#ifdef MOZ_B2G
|
||||
MOZ_THREAD_LOCAL(EGLContext) GLLibraryEGL::sCurrentContext;
|
||||
#endif
|
||||
|
||||
// should match the order of EGLExtensions, and be null-terminated.
|
||||
static const char* sEGLExtensionNames[] = {
|
||||
"EGL_KHR_image_base",
|
||||
"EGL_KHR_image_pixmap",
|
||||
"EGL_KHR_gl_texture_2D_image",
|
||||
"EGL_KHR_lock_surface",
|
||||
"EGL_ANGLE_surface_d3d_texture_2d_share_handle",
|
||||
"EGL_EXT_create_context_robustness",
|
||||
"EGL_KHR_image",
|
||||
"EGL_KHR_fence_sync",
|
||||
"EGL_ANDROID_native_fence_sync",
|
||||
"EGL_ANDROID_image_crop",
|
||||
"EGL_ANGLE_platform_angle",
|
||||
"EGL_ANGLE_platform_angle_d3d"
|
||||
};
|
||||
|
||||
#if defined(ANDROID)
|
||||
|
||||
static PRLibrary* LoadApitraceLibrary()
|
||||
{
|
||||
// Initialization of gfx prefs here is only needed during the unit tests...
|
||||
gfxPrefs::GetSingleton();
|
||||
if (!gfxPrefs::UseApitrace()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static PRLibrary* sApitraceLibrary = nullptr;
|
||||
|
||||
if (sApitraceLibrary)
|
||||
return sApitraceLibrary;
|
||||
|
||||
nsCString logFile = Preferences::GetCString("gfx.apitrace.logfile");
|
||||
|
||||
if (logFile.IsEmpty()) {
|
||||
logFile = "firefox.trace";
|
||||
}
|
||||
|
||||
// The firefox process can't write to /data/local, but it can write
|
||||
// to $GRE_HOME/
|
||||
nsAutoCString logPath;
|
||||
logPath.AppendPrintf("%s/%s", getenv("GRE_HOME"), logFile.get());
|
||||
|
||||
// apitrace uses the TRACE_FILE environment variable to determine where
|
||||
// to log trace output to
|
||||
printf_stderr("Logging GL tracing output to %s", logPath.get());
|
||||
setenv("TRACE_FILE", logPath.get(), false);
|
||||
|
||||
printf_stderr("Attempting load of %s\n", APITRACE_LIB);
|
||||
|
||||
sApitraceLibrary = PR_LoadLibrary(APITRACE_LIB);
|
||||
|
||||
return sApitraceLibrary;
|
||||
}
|
||||
|
||||
#endif // ANDROID
|
||||
|
||||
#ifdef XP_WIN
|
||||
// see the comment in GLLibraryEGL::EnsureInitialized() for the rationale here.
|
||||
static PRLibrary*
|
||||
LoadLibraryForEGLOnWindows(const nsAString& filename)
|
||||
{
|
||||
nsCOMPtr<nsIFile> file;
|
||||
nsresult rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(file));
|
||||
if (NS_FAILED(rv))
|
||||
return nullptr;
|
||||
|
||||
file->Append(filename);
|
||||
PRLibrary* lib = nullptr;
|
||||
rv = file->Load(&lib);
|
||||
if (NS_FAILED(rv)) {
|
||||
nsPrintfCString msg("Failed to load %s - Expect EGL initialization to fail",
|
||||
NS_LossyConvertUTF16toASCII(filename).get());
|
||||
NS_WARNING(msg.get());
|
||||
}
|
||||
return lib;
|
||||
}
|
||||
|
||||
#endif // XP_WIN
|
||||
|
||||
static EGLDisplay
|
||||
GetAndInitWARPDisplay(GLLibraryEGL& egl, void* displayType)
|
||||
{
|
||||
EGLint attrib_list[] = { LOCAL_EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE,
|
||||
LOCAL_EGL_PLATFORM_ANGLE_DEVICE_TYPE_WARP_ANGLE,
|
||||
// Requires:
|
||||
LOCAL_EGL_PLATFORM_ANGLE_TYPE_ANGLE,
|
||||
LOCAL_EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
|
||||
LOCAL_EGL_NONE };
|
||||
EGLDisplay display = egl.fGetPlatformDisplayEXT(LOCAL_EGL_PLATFORM_ANGLE_ANGLE,
|
||||
displayType,
|
||||
attrib_list);
|
||||
|
||||
if (display == EGL_NO_DISPLAY) {
|
||||
const EGLint err = egl.fGetError();
|
||||
if (err != LOCAL_EGL_SUCCESS) {
|
||||
gfxCriticalError() << "Unexpected GL error: " << gfx::hexa(err);
|
||||
MOZ_CRASH("GFX: Unexpected GL error.");
|
||||
}
|
||||
return EGL_NO_DISPLAY;
|
||||
}
|
||||
|
||||
if (!egl.fInitialize(display, nullptr, nullptr))
|
||||
return EGL_NO_DISPLAY;
|
||||
|
||||
return display;
|
||||
}
|
||||
|
||||
static bool
|
||||
IsAccelAngleSupported(const nsCOMPtr<nsIGfxInfo>& gfxInfo,
|
||||
nsACString* const out_failureId)
|
||||
{
|
||||
int32_t angleSupport;
|
||||
nsCString failureId;
|
||||
gfxUtils::ThreadSafeGetFeatureStatus(gfxInfo,
|
||||
nsIGfxInfo::FEATURE_WEBGL_ANGLE,
|
||||
failureId,
|
||||
&angleSupport);
|
||||
if (failureId.IsEmpty() && angleSupport != nsIGfxInfo::FEATURE_STATUS_OK) {
|
||||
// This shouldn't happen, if we see this it's because we've missed
|
||||
// some failure paths
|
||||
failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_ACCL_ANGLE_NOT_OK");
|
||||
}
|
||||
if (out_failureId->IsEmpty()) {
|
||||
*out_failureId = failureId;
|
||||
}
|
||||
return (angleSupport == nsIGfxInfo::FEATURE_STATUS_OK);
|
||||
}
|
||||
|
||||
static EGLDisplay
|
||||
GetAndInitDisplay(GLLibraryEGL& egl, void* displayType)
|
||||
{
|
||||
EGLDisplay display = egl.fGetDisplay(displayType);
|
||||
if (display == EGL_NO_DISPLAY)
|
||||
return EGL_NO_DISPLAY;
|
||||
|
||||
if (!egl.fInitialize(display, nullptr, nullptr))
|
||||
return EGL_NO_DISPLAY;
|
||||
|
||||
return display;
|
||||
}
|
||||
|
||||
class AngleErrorReporting: public angle::Platform {
|
||||
public:
|
||||
AngleErrorReporting()
|
||||
{
|
||||
// No static constructor
|
||||
}
|
||||
|
||||
void SetFailureId(nsACString* const aFailureId)
|
||||
{
|
||||
mFailureId = aFailureId;
|
||||
}
|
||||
|
||||
void logError(const char *errorMessage) override
|
||||
{
|
||||
if (!mFailureId) {
|
||||
return;
|
||||
}
|
||||
|
||||
nsCString str(errorMessage);
|
||||
Tokenizer tokenizer(str);
|
||||
|
||||
// Parse "ANGLE Display::initialize error " << error.getID() << ": "
|
||||
// << error.getMessage()
|
||||
nsCString currWord;
|
||||
Tokenizer::Token intToken;
|
||||
if (tokenizer.CheckWord("ANGLE") &&
|
||||
tokenizer.CheckWhite() &&
|
||||
tokenizer.CheckWord("Display") &&
|
||||
tokenizer.CheckChar(':') &&
|
||||
tokenizer.CheckChar(':') &&
|
||||
tokenizer.CheckWord("initialize") &&
|
||||
tokenizer.CheckWhite() &&
|
||||
tokenizer.CheckWord("error") &&
|
||||
tokenizer.CheckWhite() &&
|
||||
tokenizer.Check(Tokenizer::TOKEN_INTEGER, intToken)) {
|
||||
*mFailureId = "FAILURE_ID_ANGLE_ID_";
|
||||
mFailureId->AppendPrintf("%i", intToken.AsInteger());
|
||||
} else {
|
||||
*mFailureId = "FAILURE_ID_ANGLE_UNKNOWN";
|
||||
}
|
||||
}
|
||||
private:
|
||||
nsACString* mFailureId;
|
||||
};
|
||||
|
||||
AngleErrorReporting gAngleErrorReporter;
|
||||
|
||||
static EGLDisplay
|
||||
GetAndInitDisplayForAccelANGLE(GLLibraryEGL& egl, nsACString* const out_failureId)
|
||||
{
|
||||
EGLDisplay ret = 0;
|
||||
|
||||
FeatureState& d3d11ANGLE = gfxConfig::GetFeature(Feature::D3D11_HW_ANGLE);
|
||||
|
||||
if (!gfxPrefs::WebGLANGLETryD3D11())
|
||||
d3d11ANGLE.UserDisable("User disabled D3D11 ANGLE by pref",
|
||||
NS_LITERAL_CSTRING("FAILURE_ID_ANGLE_PREF"));
|
||||
|
||||
if (gfxPrefs::WebGLANGLEForceD3D11())
|
||||
d3d11ANGLE.UserForceEnable("User force-enabled D3D11 ANGLE on disabled hardware");
|
||||
|
||||
gAngleErrorReporter.SetFailureId(out_failureId);
|
||||
egl.fANGLEPlatformInitialize(&gAngleErrorReporter);
|
||||
|
||||
auto guardShutdown = mozilla::MakeScopeExit([&] {
|
||||
gAngleErrorReporter.SetFailureId(nullptr);
|
||||
// NOTE: Ideally we should be calling ANGLEPlatformShutdown after the
|
||||
// ANGLE display is destroyed. However gAngleErrorReporter
|
||||
// will live longer than the ANGLE display so we're fine.
|
||||
});
|
||||
|
||||
if (gfxConfig::IsForcedOnByUser(Feature::D3D11_HW_ANGLE)) {
|
||||
return GetAndInitDisplay(egl, LOCAL_EGL_D3D11_ONLY_DISPLAY_ANGLE);
|
||||
}
|
||||
|
||||
if (d3d11ANGLE.IsEnabled()) {
|
||||
ret = GetAndInitDisplay(egl, LOCAL_EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE);
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
ret = GetAndInitDisplay(egl, EGL_DEFAULT_DISPLAY);
|
||||
}
|
||||
|
||||
if (!ret && out_failureId->IsEmpty()) {
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_ACCL_ANGLE_NO_DISP");
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool
|
||||
GLLibraryEGL::ReadbackEGLImage(EGLImage image, gfx::DataSourceSurface* out_surface)
|
||||
{
|
||||
StaticMutexAutoUnlock lock(sMutex);
|
||||
if (!mReadbackGL) {
|
||||
nsCString discardFailureId;
|
||||
mReadbackGL = gl::GLContextProvider::CreateHeadless(gl::CreateContextFlags::NONE,
|
||||
&discardFailureId);
|
||||
}
|
||||
|
||||
ScopedTexture destTex(mReadbackGL);
|
||||
const GLuint target = mReadbackGL->GetPreferredEGLImageTextureTarget();
|
||||
ScopedBindTexture autoTex(mReadbackGL, destTex.Texture(), target);
|
||||
mReadbackGL->fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_S, LOCAL_GL_CLAMP_TO_EDGE);
|
||||
mReadbackGL->fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_T, LOCAL_GL_CLAMP_TO_EDGE);
|
||||
mReadbackGL->fTexParameteri(target, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_NEAREST);
|
||||
mReadbackGL->fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_NEAREST);
|
||||
mReadbackGL->fEGLImageTargetTexture2D(target, image);
|
||||
|
||||
ShaderConfigOGL config = ShaderConfigFromTargetAndFormat(target,
|
||||
out_surface->GetFormat());
|
||||
int shaderConfig = config.mFeatures;
|
||||
mReadbackGL->ReadTexImageHelper()->ReadTexImage(out_surface, 0, target,
|
||||
out_surface->GetSize(), shaderConfig);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
GLLibraryEGL::EnsureInitialized(bool forceAccel, nsACString* const out_failureId)
|
||||
{
|
||||
if (mInitialized) {
|
||||
return true;
|
||||
}
|
||||
|
||||
mozilla::ScopedGfxFeatureReporter reporter("EGL");
|
||||
|
||||
#ifdef MOZ_B2G
|
||||
if (!sCurrentContext.init())
|
||||
MOZ_CRASH("GFX: Tls init failed");
|
||||
#endif
|
||||
|
||||
#ifdef XP_WIN
|
||||
if (!mEGLLibrary) {
|
||||
// On Windows, the GLESv2, EGL and DXSDK libraries are shipped with libxul and
|
||||
// we should look for them there. We have to load the libs in this
|
||||
// order, because libEGL.dll depends on libGLESv2.dll which depends on the DXSDK
|
||||
// libraries. This matters especially for WebRT apps which are in a different directory.
|
||||
// See bug 760323 and bug 749459
|
||||
|
||||
// Also note that we intentionally leak the libs we load.
|
||||
|
||||
do {
|
||||
// Windows 8.1 has d3dcompiler_47.dll in the system directory.
|
||||
// Try it first. Note that _46 will never be in the system
|
||||
// directory and we ship with at least _43. So there is no point
|
||||
// trying _46 and _43 in the system directory.
|
||||
|
||||
if (LoadLibrarySystem32(L"d3dcompiler_47.dll"))
|
||||
break;
|
||||
|
||||
#ifdef MOZ_D3DCOMPILER_VISTA_DLL
|
||||
if (LoadLibraryForEGLOnWindows(NS_LITERAL_STRING(NS_STRINGIFY(MOZ_D3DCOMPILER_VISTA_DLL))))
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef MOZ_D3DCOMPILER_XP_DLL
|
||||
if (LoadLibraryForEGLOnWindows(NS_LITERAL_STRING(NS_STRINGIFY(MOZ_D3DCOMPILER_XP_DLL))))
|
||||
break;
|
||||
#endif
|
||||
|
||||
MOZ_ASSERT(false, "d3dcompiler DLL loading failed.");
|
||||
} while (false);
|
||||
|
||||
LoadLibraryForEGLOnWindows(NS_LITERAL_STRING("libGLESv2.dll"));
|
||||
|
||||
mEGLLibrary = LoadLibraryForEGLOnWindows(NS_LITERAL_STRING("libEGL.dll"));
|
||||
|
||||
if (!mEGLLibrary) {
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_EGL_LOAD");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#else // !Windows
|
||||
|
||||
// On non-Windows (Android) we use system copies of libEGL. We look for
|
||||
// the APITrace lib, libEGL.so, and libEGL.so.1 in that order.
|
||||
|
||||
#if defined(ANDROID)
|
||||
if (!mEGLLibrary)
|
||||
mEGLLibrary = LoadApitraceLibrary();
|
||||
#endif
|
||||
|
||||
if (!mEGLLibrary) {
|
||||
printf_stderr("Attempting load of libEGL.so\n");
|
||||
mEGLLibrary = PR_LoadLibrary("libEGL.so");
|
||||
}
|
||||
#if defined(XP_UNIX)
|
||||
if (!mEGLLibrary) {
|
||||
mEGLLibrary = PR_LoadLibrary("libEGL.so.1");
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!mEGLLibrary) {
|
||||
NS_WARNING("Couldn't load EGL LIB.");
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_EGL_LOAD_2");
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif // !Windows
|
||||
|
||||
#define SYMBOL(name) \
|
||||
{ (PRFuncPtr*) &mSymbols.f##name, { "egl" #name, nullptr } }
|
||||
|
||||
GLLibraryLoader::SymLoadStruct earlySymbols[] = {
|
||||
SYMBOL(GetDisplay),
|
||||
SYMBOL(Terminate),
|
||||
SYMBOL(GetCurrentSurface),
|
||||
SYMBOL(GetCurrentContext),
|
||||
SYMBOL(MakeCurrent),
|
||||
SYMBOL(DestroyContext),
|
||||
SYMBOL(CreateContext),
|
||||
SYMBOL(DestroySurface),
|
||||
SYMBOL(CreateWindowSurface),
|
||||
SYMBOL(CreatePbufferSurface),
|
||||
SYMBOL(CreatePixmapSurface),
|
||||
SYMBOL(BindAPI),
|
||||
SYMBOL(Initialize),
|
||||
SYMBOL(ChooseConfig),
|
||||
SYMBOL(GetError),
|
||||
SYMBOL(GetConfigs),
|
||||
SYMBOL(GetConfigAttrib),
|
||||
SYMBOL(WaitNative),
|
||||
SYMBOL(GetProcAddress),
|
||||
SYMBOL(SwapBuffers),
|
||||
SYMBOL(CopyBuffers),
|
||||
SYMBOL(QueryString),
|
||||
SYMBOL(QueryContext),
|
||||
SYMBOL(BindTexImage),
|
||||
SYMBOL(ReleaseTexImage),
|
||||
SYMBOL(QuerySurface),
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
if (!GLLibraryLoader::LoadSymbols(mEGLLibrary, &earlySymbols[0])) {
|
||||
NS_WARNING("Couldn't find required entry points in EGL library (early init)");
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_EGL_SYM");
|
||||
return false;
|
||||
}
|
||||
|
||||
GLLibraryLoader::SymLoadStruct optionalSymbols[] = {
|
||||
// On Android 4.3 and up, certain features like ANDROID_native_fence_sync
|
||||
// can only be queried by using a special eglQueryString.
|
||||
{ (PRFuncPtr*) &mSymbols.fQueryStringImplementationANDROID,
|
||||
{ "_Z35eglQueryStringImplementationANDROIDPvi", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
// Do not warn about the failure to load this - see bug 1092191
|
||||
Unused << GLLibraryLoader::LoadSymbols(mEGLLibrary, &optionalSymbols[0],
|
||||
nullptr, nullptr, false);
|
||||
|
||||
InitClientExtensions();
|
||||
|
||||
const auto lookupFunction =
|
||||
(GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
|
||||
|
||||
// Client exts are ready. (But not display exts!)
|
||||
if (IsExtensionSupported(ANGLE_platform_angle_d3d)) {
|
||||
GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
|
||||
{ (PRFuncPtr*)&mSymbols.fANGLEPlatformInitialize, { "ANGLEPlatformInitialize", nullptr } },
|
||||
{ (PRFuncPtr*)&mSymbols.fANGLEPlatformShutdown, { "ANGLEPlatformShutdown", nullptr } },
|
||||
{ (PRFuncPtr*)&mSymbols.fGetPlatformDisplayEXT, { "eglGetPlatformDisplayEXT", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&d3dSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports ANGLE_platform_angle_d3d without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(ANGLE_platform_angle_d3d);
|
||||
|
||||
mSymbols.fGetPlatformDisplayEXT = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// Check the ANGLE support the system has
|
||||
nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
|
||||
mIsANGLE = IsExtensionSupported(ANGLE_platform_angle);
|
||||
|
||||
EGLDisplay chosenDisplay = nullptr;
|
||||
|
||||
if (IsExtensionSupported(ANGLE_platform_angle_d3d)) {
|
||||
nsCString accelAngleFailureId;
|
||||
bool accelAngleSupport = IsAccelAngleSupported(gfxInfo, &accelAngleFailureId);
|
||||
bool shouldTryAccel = forceAccel || accelAngleSupport;
|
||||
bool shouldTryWARP = !forceAccel; // Only if ANGLE not supported or fails
|
||||
|
||||
// If WARP preferred, will override ANGLE support
|
||||
if (gfxPrefs::WebGLANGLEForceWARP()) {
|
||||
shouldTryWARP = true;
|
||||
shouldTryAccel = false;
|
||||
if (accelAngleFailureId.IsEmpty()) {
|
||||
accelAngleFailureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_FORCE_WARP");
|
||||
}
|
||||
}
|
||||
|
||||
// Hardware accelerated ANGLE path (supported or force accel)
|
||||
if (shouldTryAccel) {
|
||||
chosenDisplay = GetAndInitDisplayForAccelANGLE(*this, out_failureId);
|
||||
}
|
||||
|
||||
// Report the acceleration status to telemetry
|
||||
if (!chosenDisplay) {
|
||||
if (accelAngleFailureId.IsEmpty()) {
|
||||
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_ACCL_FAILURE_ID,
|
||||
NS_LITERAL_CSTRING("FEATURE_FAILURE_ACCL_ANGLE_UNKNOWN"));
|
||||
} else {
|
||||
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_ACCL_FAILURE_ID,
|
||||
accelAngleFailureId);
|
||||
}
|
||||
} else {
|
||||
Telemetry::Accumulate(Telemetry::CANVAS_WEBGL_ACCL_FAILURE_ID,
|
||||
NS_LITERAL_CSTRING("SUCCESS"));
|
||||
}
|
||||
|
||||
// Fallback to a WARP display if ANGLE fails, or if WARP is forced
|
||||
if (!chosenDisplay && shouldTryWARP) {
|
||||
chosenDisplay = GetAndInitWARPDisplay(*this, EGL_DEFAULT_DISPLAY);
|
||||
if (!chosenDisplay) {
|
||||
if (out_failureId->IsEmpty()) {
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_WARP_FALLBACK");
|
||||
}
|
||||
NS_ERROR("Fallback WARP context failed to initialize.");
|
||||
return false;
|
||||
}
|
||||
mIsWARP = true;
|
||||
}
|
||||
} else {
|
||||
chosenDisplay = GetAndInitDisplay(*this, EGL_DEFAULT_DISPLAY);
|
||||
}
|
||||
|
||||
if (!chosenDisplay) {
|
||||
if (out_failureId->IsEmpty()) {
|
||||
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_NO_DISPLAY");
|
||||
}
|
||||
NS_WARNING("Failed to initialize a display.");
|
||||
return false;
|
||||
}
|
||||
mEGLDisplay = chosenDisplay;
|
||||
|
||||
InitDisplayExtensions();
|
||||
|
||||
////////////////////////////////////
|
||||
// Alright, load display exts.
|
||||
|
||||
if (IsExtensionSupported(KHR_lock_surface)) {
|
||||
GLLibraryLoader::SymLoadStruct lockSymbols[] = {
|
||||
{ (PRFuncPtr*) &mSymbols.fLockSurface, { "eglLockSurfaceKHR", nullptr } },
|
||||
{ (PRFuncPtr*) &mSymbols.fUnlockSurface, { "eglUnlockSurfaceKHR", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&lockSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports KHR_lock_surface without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(KHR_lock_surface);
|
||||
|
||||
mSymbols.fLockSurface = nullptr;
|
||||
mSymbols.fUnlockSurface = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
if (IsExtensionSupported(ANGLE_surface_d3d_texture_2d_share_handle)) {
|
||||
GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
|
||||
{ (PRFuncPtr*) &mSymbols.fQuerySurfacePointerANGLE, { "eglQuerySurfacePointerANGLE", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&d3dSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports ANGLE_surface_d3d_texture_2d_share_handle without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(ANGLE_surface_d3d_texture_2d_share_handle);
|
||||
|
||||
mSymbols.fQuerySurfacePointerANGLE = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
if (IsExtensionSupported(KHR_fence_sync)) {
|
||||
GLLibraryLoader::SymLoadStruct syncSymbols[] = {
|
||||
{ (PRFuncPtr*) &mSymbols.fCreateSync, { "eglCreateSyncKHR", nullptr } },
|
||||
{ (PRFuncPtr*) &mSymbols.fDestroySync, { "eglDestroySyncKHR", nullptr } },
|
||||
{ (PRFuncPtr*) &mSymbols.fClientWaitSync, { "eglClientWaitSyncKHR", nullptr } },
|
||||
{ (PRFuncPtr*) &mSymbols.fGetSyncAttrib, { "eglGetSyncAttribKHR", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&syncSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports KHR_fence_sync without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(KHR_fence_sync);
|
||||
|
||||
mSymbols.fCreateSync = nullptr;
|
||||
mSymbols.fDestroySync = nullptr;
|
||||
mSymbols.fClientWaitSync = nullptr;
|
||||
mSymbols.fGetSyncAttrib = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
if (IsExtensionSupported(KHR_image) || IsExtensionSupported(KHR_image_base)) {
|
||||
GLLibraryLoader::SymLoadStruct imageSymbols[] = {
|
||||
{ (PRFuncPtr*) &mSymbols.fCreateImage, { "eglCreateImageKHR", nullptr } },
|
||||
{ (PRFuncPtr*) &mSymbols.fDestroyImage, { "eglDestroyImageKHR", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&imageSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports KHR_image(_base) without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(KHR_image);
|
||||
MarkExtensionUnsupported(KHR_image_base);
|
||||
MarkExtensionUnsupported(KHR_image_pixmap);
|
||||
|
||||
mSymbols.fCreateImage = nullptr;
|
||||
mSymbols.fDestroyImage = nullptr;
|
||||
}
|
||||
} else {
|
||||
MarkExtensionUnsupported(KHR_image_pixmap);
|
||||
}
|
||||
|
||||
if (IsExtensionSupported(ANDROID_native_fence_sync)) {
|
||||
GLLibraryLoader::SymLoadStruct nativeFenceSymbols[] = {
|
||||
{ (PRFuncPtr*) &mSymbols.fDupNativeFenceFDANDROID, { "eglDupNativeFenceFDANDROID", nullptr } },
|
||||
{ nullptr, { nullptr } }
|
||||
};
|
||||
|
||||
bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
|
||||
&nativeFenceSymbols[0],
|
||||
lookupFunction);
|
||||
if (!success) {
|
||||
NS_ERROR("EGL supports ANDROID_native_fence_sync without exposing its functions!");
|
||||
|
||||
MarkExtensionUnsupported(ANDROID_native_fence_sync);
|
||||
|
||||
mSymbols.fDupNativeFenceFDANDROID = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
mInitialized = true;
|
||||
reporter.SetSuccessful();
|
||||
return true;
|
||||
}
|
||||
|
||||
template<size_t N>
|
||||
static void
|
||||
MarkExtensions(const char* rawExtString, bool shouldDumpExts, const char* extType,
|
||||
std::bitset<N>* const out)
|
||||
{
|
||||
MOZ_ASSERT(rawExtString);
|
||||
|
||||
const nsDependentCString extString(rawExtString);
|
||||
|
||||
std::vector<nsCString> extList;
|
||||
SplitByChar(extString, ' ', &extList);
|
||||
|
||||
if (shouldDumpExts) {
|
||||
printf_stderr("%u EGL %s extensions: (*: recognized)\n",
|
||||
(uint32_t)extList.size(), extType);
|
||||
}
|
||||
|
||||
MarkBitfieldByStrings(extList, shouldDumpExts, sEGLExtensionNames, out);
|
||||
}
|
||||
|
||||
void
|
||||
GLLibraryEGL::InitClientExtensions()
|
||||
{
|
||||
const bool shouldDumpExts = GLContext::ShouldDumpExts();
|
||||
|
||||
const char* rawExtString = nullptr;
|
||||
|
||||
#ifndef ANDROID
|
||||
// Bug 1209612: Crashes on a number of android drivers.
|
||||
// Ideally we would only blocklist this there, but for now we don't need the client
|
||||
// extension list on ANDROID (we mostly need it on ANGLE), and we'd rather not crash.
|
||||
rawExtString = (const char*)fQueryString(nullptr, LOCAL_EGL_EXTENSIONS);
|
||||
#endif
|
||||
|
||||
if (!rawExtString) {
|
||||
if (shouldDumpExts) {
|
||||
printf_stderr("No EGL client extensions.\n");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
MarkExtensions(rawExtString, shouldDumpExts, "client", &mAvailableExtensions);
|
||||
}
|
||||
|
||||
void
|
||||
GLLibraryEGL::InitDisplayExtensions()
|
||||
{
|
||||
MOZ_ASSERT(mEGLDisplay);
|
||||
|
||||
const bool shouldDumpExts = GLContext::ShouldDumpExts();
|
||||
|
||||
const auto rawExtString = (const char*)fQueryString(mEGLDisplay,
|
||||
LOCAL_EGL_EXTENSIONS);
|
||||
if (!rawExtString) {
|
||||
NS_WARNING("Failed to query EGL display extensions!.");
|
||||
return;
|
||||
}
|
||||
|
||||
MarkExtensions(rawExtString, shouldDumpExts, "display", &mAvailableExtensions);
|
||||
}
|
||||
|
||||
void
|
||||
GLLibraryEGL::DumpEGLConfig(EGLConfig cfg)
|
||||
{
|
||||
int attrval;
|
||||
int err;
|
||||
|
||||
#define ATTR(_x) do { \
|
||||
fGetConfigAttrib(mEGLDisplay, cfg, LOCAL_EGL_##_x, &attrval); \
|
||||
if ((err = fGetError()) != 0x3000) { \
|
||||
printf_stderr(" %s: ERROR (0x%04x)\n", #_x, err); \
|
||||
} else { \
|
||||
printf_stderr(" %s: %d (0x%04x)\n", #_x, attrval, attrval); \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
printf_stderr("EGL Config: %d [%p]\n", (int)(intptr_t)cfg, cfg);
|
||||
|
||||
ATTR(BUFFER_SIZE);
|
||||
ATTR(ALPHA_SIZE);
|
||||
ATTR(BLUE_SIZE);
|
||||
ATTR(GREEN_SIZE);
|
||||
ATTR(RED_SIZE);
|
||||
ATTR(DEPTH_SIZE);
|
||||
ATTR(STENCIL_SIZE);
|
||||
ATTR(CONFIG_CAVEAT);
|
||||
ATTR(CONFIG_ID);
|
||||
ATTR(LEVEL);
|
||||
ATTR(MAX_PBUFFER_HEIGHT);
|
||||
ATTR(MAX_PBUFFER_PIXELS);
|
||||
ATTR(MAX_PBUFFER_WIDTH);
|
||||
ATTR(NATIVE_RENDERABLE);
|
||||
ATTR(NATIVE_VISUAL_ID);
|
||||
ATTR(NATIVE_VISUAL_TYPE);
|
||||
ATTR(PRESERVED_RESOURCES);
|
||||
ATTR(SAMPLES);
|
||||
ATTR(SAMPLE_BUFFERS);
|
||||
ATTR(SURFACE_TYPE);
|
||||
ATTR(TRANSPARENT_TYPE);
|
||||
ATTR(TRANSPARENT_RED_VALUE);
|
||||
ATTR(TRANSPARENT_GREEN_VALUE);
|
||||
ATTR(TRANSPARENT_BLUE_VALUE);
|
||||
ATTR(BIND_TO_TEXTURE_RGB);
|
||||
ATTR(BIND_TO_TEXTURE_RGBA);
|
||||
ATTR(MIN_SWAP_INTERVAL);
|
||||
ATTR(MAX_SWAP_INTERVAL);
|
||||
ATTR(LUMINANCE_SIZE);
|
||||
ATTR(ALPHA_MASK_SIZE);
|
||||
ATTR(COLOR_BUFFER_TYPE);
|
||||
ATTR(RENDERABLE_TYPE);
|
||||
ATTR(CONFORMANT);
|
||||
|
||||
#undef ATTR
|
||||
}
|
||||
|
||||
void
|
||||
GLLibraryEGL::DumpEGLConfigs()
|
||||
{
|
||||
int nc = 0;
|
||||
fGetConfigs(mEGLDisplay, nullptr, 0, &nc);
|
||||
EGLConfig* ec = new EGLConfig[nc];
|
||||
fGetConfigs(mEGLDisplay, ec, nc, &nc);
|
||||
|
||||
for (int i = 0; i < nc; ++i) {
|
||||
printf_stderr("========= EGL Config %d ========\n", i);
|
||||
DumpEGLConfig(ec[i]);
|
||||
}
|
||||
|
||||
delete [] ec;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
static bool
|
||||
ShouldTrace()
|
||||
{
|
||||
static bool ret = gfxEnv::GlDebugVerbose();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*static*/ void
|
||||
GLLibraryEGL::BeforeGLCall(const char* glFunction)
|
||||
{
|
||||
if (ShouldTrace()) {
|
||||
printf_stderr("[egl] > %s\n", glFunction);
|
||||
}
|
||||
}
|
||||
|
||||
/*static*/ void
|
||||
GLLibraryEGL::AfterGLCall(const char* glFunction)
|
||||
{
|
||||
if (ShouldTrace()) {
|
||||
printf_stderr("[egl] < %s\n", glFunction);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
} /* namespace gl */
|
||||
} /* namespace mozilla */
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue