mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/gfx/gl/GLContextProviderGLX.cpp

1162 строки
36 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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/. */
#ifdef MOZ_WIDGET_GTK
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#define GET_NATIVE_WINDOW(aWidget) GDK_WINDOW_XID((GdkWindow*) aWidget->GetNativeData(NS_NATIVE_WINDOW))
#endif
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "X11UndefineNone.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/layers/CompositorOptions.h"
#include "mozilla/Range.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/widget/CompositorWidget.h"
#include "mozilla/widget/GtkCompositorWidget.h"
#include "mozilla/Unused.h"
#include "prenv.h"
#include "GLContextProvider.h"
#include "GLLibraryLoader.h"
#include "nsDebug.h"
#include "nsIWidget.h"
#include "GLXLibrary.h"
#include "gfxXlibSurface.h"
#include "gfxContext.h"
#include "gfxEnv.h"
#include "gfxPlatform.h"
#include "GLContextGLX.h"
#include "gfxUtils.h"
#include "gfx2DGlue.h"
#include "GLScreenBuffer.h"
#include "gfxPrefs.h"
#include "gfxCrashReporterUtils.h"
#ifdef MOZ_WIDGET_GTK
#include "gfxPlatformGtk.h"
#endif
namespace mozilla {
namespace gl {
using namespace mozilla::gfx;
using namespace mozilla::widget;
GLXLibrary sGLXLibrary;
static inline bool
HasExtension(const char* aExtensions, const char* aRequiredExtension)
{
return GLContext::ListHasExtension(
reinterpret_cast<const GLubyte*>(aExtensions), aRequiredExtension);
}
bool
GLXLibrary::EnsureInitialized()
{
if (mInitialized) {
return true;
}
// Don't repeatedly try to initialize.
if (mTriedInitializing) {
return false;
}
mTriedInitializing = true;
// Force enabling s3 texture compression. (Bug 774134)
PR_SetEnv("force_s3tc_enable=true");
if (!mOGLLibrary) {
const char* libGLfilename = nullptr;
bool forceFeatureReport = false;
// see e.g. bug 608526: it is intrinsically interesting to know whether we have dynamically linked to libGL.so.1
// because at least the NVIDIA implementation requires an executable stack, which causes mprotect calls,
// which trigger glibc bug http://sourceware.org/bugzilla/show_bug.cgi?id=12225
#ifdef __OpenBSD__
libGLfilename = "libGL.so";
#else
libGLfilename = "libGL.so.1";
#endif
ScopedGfxFeatureReporter reporter(libGLfilename, forceFeatureReport);
mOGLLibrary = PR_LoadLibrary(libGLfilename);
if (!mOGLLibrary) {
NS_WARNING("Couldn't load OpenGL shared library.");
return false;
}
reporter.SetSuccessful();
}
if (gfxEnv::GlxDebug()) {
mDebug = true;
}
#define SYMBOL(X) { (PRFuncPtr*)&mSymbols.f##X, { "glX" #X, nullptr } }
#define END_OF_SYMBOLS { nullptr, { nullptr } }
const GLLibraryLoader::SymLoadStruct symbols[] = {
/* functions that were in GLX 1.0 */
SYMBOL(DestroyContext),
SYMBOL(MakeCurrent),
SYMBOL(SwapBuffers),
SYMBOL(QueryVersion),
SYMBOL(GetConfig),
SYMBOL(GetCurrentContext),
SYMBOL(WaitGL),
SYMBOL(WaitX),
/* functions introduced in GLX 1.1 */
SYMBOL(QueryExtensionsString),
SYMBOL(GetClientString),
SYMBOL(QueryServerString),
/* functions introduced in GLX 1.3 */
SYMBOL(ChooseFBConfig),
SYMBOL(ChooseVisual),
SYMBOL(GetFBConfigAttrib),
SYMBOL(GetFBConfigs),
SYMBOL(CreatePixmap),
SYMBOL(DestroyPixmap),
SYMBOL(CreateNewContext),
// Core in GLX 1.4, ARB extension before.
{ (PRFuncPtr*)&mSymbols.fGetProcAddress, { "glXGetProcAddress",
"glXGetProcAddressARB",
nullptr } },
END_OF_SYMBOLS
};
if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols)) {
NS_WARNING("Couldn't load required GLX symbols.");
return false;
}
Display* display = DefaultXDisplay();
int screen = DefaultScreen(display);
{
int major, minor;
if (!fQueryVersion(display, &major, &minor) ||
major != 1 || minor < 3)
{
NS_ERROR("GLX version older than 1.3. (released in 1998)");
return false;
}
}
const GLLibraryLoader::SymLoadStruct symbols_texturefrompixmap[] = {
SYMBOL(BindTexImageEXT),
SYMBOL(ReleaseTexImageEXT),
END_OF_SYMBOLS
};
const GLLibraryLoader::SymLoadStruct symbols_createcontext[] = {
SYMBOL(CreateContextAttribsARB),
END_OF_SYMBOLS
};
const GLLibraryLoader::SymLoadStruct symbols_videosync[] = {
SYMBOL(GetVideoSyncSGI),
SYMBOL(WaitVideoSyncSGI),
END_OF_SYMBOLS
};
const GLLibraryLoader::SymLoadStruct symbols_swapcontrol[] = {
SYMBOL(SwapIntervalEXT),
END_OF_SYMBOLS
};
const auto lookupFunction =
(GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
const auto fnLoadSymbols = [&](const GLLibraryLoader::SymLoadStruct* symbols) {
if (GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols, lookupFunction))
return true;
GLLibraryLoader::ClearSymbols(symbols);
return false;
};
const char* clientVendor = fGetClientString(display, LOCAL_GLX_VENDOR);
const char* serverVendor = fQueryServerString(display, screen, LOCAL_GLX_VENDOR);
const char* extensionsStr = fQueryExtensionsString(display, screen);
if (HasExtension(extensionsStr, "GLX_EXT_texture_from_pixmap") &&
fnLoadSymbols(symbols_texturefrompixmap))
{
mUseTextureFromPixmap = gfxPrefs::UseGLXTextureFromPixmap();
} else {
mUseTextureFromPixmap = false;
NS_WARNING("Texture from pixmap disabled");
}
if (HasExtension(extensionsStr, "GLX_ARB_create_context") &&
HasExtension(extensionsStr, "GLX_ARB_create_context_profile") &&
fnLoadSymbols(symbols_createcontext))
{
mHasCreateContextAttribs = true;
}
if (HasExtension(extensionsStr, "GLX_ARB_create_context_robustness")) {
mHasRobustness = true;
}
if (HasExtension(extensionsStr, "GLX_NV_robustness_video_memory_purge")) {
mHasVideoMemoryPurge = true;
}
if (HasExtension(extensionsStr, "GLX_SGI_video_sync") &&
fnLoadSymbols(symbols_videosync))
{
mHasVideoSync = true;
}
if (!HasExtension(extensionsStr, "GLX_EXT_swap_control") ||
!fnLoadSymbols(symbols_swapcontrol))
{
NS_WARNING("GLX_swap_control unsupported, ASAP mode may still block on buffer swaps.");
}
mIsATI = serverVendor && DoesStringMatch(serverVendor, "ATI");
mIsNVIDIA = serverVendor && DoesStringMatch(serverVendor, "NVIDIA Corporation");
mClientIsMesa = clientVendor && DoesStringMatch(clientVendor, "Mesa");
mInitialized = true;
return true;
}
bool
GLXLibrary::SupportsTextureFromPixmap(gfxASurface* aSurface)
{
if (!EnsureInitialized()) {
return false;
}
if (aSurface->GetType() != gfxSurfaceType::Xlib || !mUseTextureFromPixmap) {
return false;
}
return true;
}
bool
GLXLibrary::SupportsVideoSync()
{
if (!EnsureInitialized()) {
return false;
}
return mHasVideoSync;
}
GLXPixmap
GLXLibrary::CreatePixmap(gfxASurface* aSurface)
{
if (!SupportsTextureFromPixmap(aSurface)) {
return X11None;
}
gfxXlibSurface* xs = static_cast<gfxXlibSurface*>(aSurface);
const XRenderPictFormat* format = xs->XRenderFormat();
if (!format || format->type != PictTypeDirect) {
return X11None;
}
const XRenderDirectFormat& direct = format->direct;
int alphaSize = FloorLog2(direct.alphaMask + 1);
NS_ASSERTION((1 << alphaSize) - 1 == direct.alphaMask,
"Unexpected render format with non-adjacent alpha bits");
int attribs[] = { LOCAL_GLX_DOUBLEBUFFER, False,
LOCAL_GLX_DRAWABLE_TYPE, LOCAL_GLX_PIXMAP_BIT,
LOCAL_GLX_ALPHA_SIZE, alphaSize,
(alphaSize ? LOCAL_GLX_BIND_TO_TEXTURE_RGBA_EXT
: LOCAL_GLX_BIND_TO_TEXTURE_RGB_EXT), True,
LOCAL_GLX_RENDER_TYPE, LOCAL_GLX_RGBA_BIT,
X11None };
int numConfigs = 0;
Display* display = xs->XDisplay();
int xscreen = DefaultScreen(display);
ScopedXFree<GLXFBConfig> cfgs(fChooseFBConfig(display,
xscreen,
attribs,
&numConfigs));
// Find an fbconfig that matches the pixel format used on the Pixmap.
int matchIndex = -1;
unsigned long redMask =
static_cast<unsigned long>(direct.redMask) << direct.red;
unsigned long greenMask =
static_cast<unsigned long>(direct.greenMask) << direct.green;
unsigned long blueMask =
static_cast<unsigned long>(direct.blueMask) << direct.blue;
// This is true if the Pixmap has bits for alpha or unused bits.
bool haveNonColorBits =
~(redMask | greenMask | blueMask) != -1UL << format->depth;
for (int i = 0; i < numConfigs; i++) {
int id = X11None;
sGLXLibrary.fGetFBConfigAttrib(display, cfgs[i], LOCAL_GLX_VISUAL_ID, &id);
Visual* visual;
int depth;
FindVisualAndDepth(display, id, &visual, &depth);
if (!visual ||
visual->c_class != TrueColor ||
visual->red_mask != redMask ||
visual->green_mask != greenMask ||
visual->blue_mask != blueMask ) {
continue;
}
// Historically Xlib Visuals did not try to represent an alpha channel
// and there was no means to use an alpha channel on a Pixmap. The
// Xlib Visual from the fbconfig was not intended to have any
// information about alpha bits.
//
// Since then, RENDER has added formats for 32 bit depth Pixmaps.
// Some of these formats have bits for alpha and some have unused
// bits.
//
// Then the Composite extension added a 32 bit depth Visual intended
// for Windows with an alpha channel, so bits not in the visual color
// masks were expected to be treated as alpha bits.
//
// Usually GLX counts only color bits in the Visual depth, but the
// depth of Composite's ARGB Visual includes alpha bits. However,
// bits not in the color masks are not necessarily alpha bits because
// sometimes (NVIDIA) 32 bit Visuals are added for fbconfigs with 32
// bit BUFFER_SIZE but zero alpha bits and 24 color bits (NVIDIA
// again).
//
// This checks that the depth matches in one of the two ways.
// NVIDIA now forces format->depth == depth so only the first way
// is checked for NVIDIA
if (depth != format->depth &&
(mIsNVIDIA || depth != format->depth - alphaSize) ) {
continue;
}
// If all bits of the Pixmap are color bits and the Pixmap depth
// matches the depth of the fbconfig visual, then we can assume that
// the driver will do whatever is necessary to ensure that any
// GLXPixmap alpha bits are treated as set. We can skip the
// ALPHA_SIZE check in this situation. We need to skip this check for
// situations (ATI) where there are no fbconfigs without alpha bits.
//
// glXChooseFBConfig should prefer configs with smaller
// LOCAL_GLX_BUFFER_SIZE, so we should still get zero alpha bits if
// available, except perhaps with NVIDIA drivers where buffer size is
// not the specified sum of the component sizes.
if (haveNonColorBits) {
// There are bits in the Pixmap format that haven't been matched
// against the fbconfig visual. These bits could either represent
// alpha or be unused, so just check that the number of alpha bits
// matches.
int size = 0;
sGLXLibrary.fGetFBConfigAttrib(display, cfgs[i],
LOCAL_GLX_ALPHA_SIZE, &size);
if (size != alphaSize) {
continue;
}
}
matchIndex = i;
break;
}
if (matchIndex == -1) {
// GLX can't handle A8 surfaces, so this is not really unexpected. The
// caller should deal with this situation.
NS_WARNING_ASSERTION(
format->depth == 8,
"[GLX] Couldn't find a FBConfig matching Pixmap format");
return X11None;
}
int pixmapAttribs[] = { LOCAL_GLX_TEXTURE_TARGET_EXT, LOCAL_GLX_TEXTURE_2D_EXT,
LOCAL_GLX_TEXTURE_FORMAT_EXT,
(alphaSize ? LOCAL_GLX_TEXTURE_FORMAT_RGBA_EXT
: LOCAL_GLX_TEXTURE_FORMAT_RGB_EXT),
X11None};
GLXPixmap glxpixmap = fCreatePixmap(display,
cfgs[matchIndex],
xs->XDrawable(),
pixmapAttribs);
return glxpixmap;
}
void
GLXLibrary::DestroyPixmap(Display* aDisplay, GLXPixmap aPixmap)
{
if (!mUseTextureFromPixmap) {
return;
}
fDestroyPixmap(aDisplay, aPixmap);
}
void
GLXLibrary::BindTexImage(Display* aDisplay, GLXPixmap aPixmap)
{
if (!mUseTextureFromPixmap) {
return;
}
// Make sure all X drawing to the surface has finished before binding to a texture.
if (mClientIsMesa) {
// Using XSync instead of Mesa's glXWaitX, because its glxWaitX is a
// noop when direct rendering unless the current drawable is a
// single-buffer window.
FinishX(aDisplay);
} else {
fWaitX();
}
fBindTexImage(aDisplay, aPixmap, LOCAL_GLX_FRONT_LEFT_EXT, nullptr);
}
void
GLXLibrary::ReleaseTexImage(Display* aDisplay, GLXPixmap aPixmap)
{
if (!mUseTextureFromPixmap) {
return;
}
fReleaseTexImage(aDisplay, aPixmap, LOCAL_GLX_FRONT_LEFT_EXT);
}
void
GLXLibrary::UpdateTexImage(Display* aDisplay, GLXPixmap aPixmap)
{
// NVIDIA drivers don't require a rebind of the pixmap in order
// to display an updated image, and it's faster not to do it.
if (mIsNVIDIA) {
fWaitX();
return;
}
ReleaseTexImage(aDisplay, aPixmap);
BindTexImage(aDisplay, aPixmap);
}
static int (*sOldErrorHandler)(Display*, XErrorEvent*);
ScopedXErrorHandler::ErrorEvent sErrorEvent;
static int GLXErrorHandler(Display* display, XErrorEvent* ev)
{
if (!sErrorEvent.mError.error_code) {
sErrorEvent.mError = *ev;
}
return 0;
}
void
GLXLibrary::BeforeGLXCall() const
{
if (mDebug) {
sOldErrorHandler = XSetErrorHandler(GLXErrorHandler);
}
}
void
GLXLibrary::AfterGLXCall() const
{
if (mDebug) {
FinishX(DefaultXDisplay());
if (sErrorEvent.mError.error_code) {
char buffer[2048];
XGetErrorText(DefaultXDisplay(), sErrorEvent.mError.error_code, buffer, sizeof(buffer));
printf_stderr("X ERROR: %s (%i) - Request: %i.%i, Serial: %lu",
buffer,
sErrorEvent.mError.error_code,
sErrorEvent.mError.request_code,
sErrorEvent.mError.minor_code,
sErrorEvent.mError.serial);
MOZ_ASSERT_UNREACHABLE("AfterGLXCall sErrorEvent");
}
XSetErrorHandler(sOldErrorHandler);
}
}
already_AddRefed<GLContextGLX>
GLContextGLX::CreateGLContext(CreateContextFlags flags, const SurfaceCaps& caps,
bool isOffscreen, Display* display, GLXDrawable drawable,
GLXFBConfig cfg, bool deleteDrawable,
gfxXlibSurface* pixmap)
{
GLXLibrary& glx = sGLXLibrary;
int db = 0;
int err = glx.fGetFBConfigAttrib(display, cfg,
LOCAL_GLX_DOUBLEBUFFER, &db);
if (LOCAL_GLX_BAD_ATTRIBUTE != err) {
if (ShouldSpew()) {
printf("[GLX] FBConfig is %sdouble-buffered\n", db ? "" : "not ");
}
}
GLXContext context;
RefPtr<GLContextGLX> glContext;
bool error;
OffMainThreadScopedXErrorHandler xErrorHandler;
do {
error = false;
if (glx.HasCreateContextAttribs()) {
AutoTArray<int, 13> attrib_list;
if (glx.HasRobustness()) {
const int robust_attribs[] = {
LOCAL_GLX_CONTEXT_FLAGS_ARB,
LOCAL_GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB,
LOCAL_GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
LOCAL_GLX_LOSE_CONTEXT_ON_RESET_ARB,
};
attrib_list.AppendElements(robust_attribs, MOZ_ARRAY_LENGTH(robust_attribs));
}
if (glx.HasVideoMemoryPurge()) {
const int memory_purge_attribs[] = {
LOCAL_GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV,
LOCAL_GL_TRUE,
};
attrib_list.AppendElements(memory_purge_attribs, MOZ_ARRAY_LENGTH(memory_purge_attribs));
}
if (!(flags & CreateContextFlags::REQUIRE_COMPAT_PROFILE)) {
int core_attribs[] = {
LOCAL_GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
LOCAL_GLX_CONTEXT_MINOR_VERSION_ARB, 2,
LOCAL_GLX_CONTEXT_PROFILE_MASK_ARB, LOCAL_GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
};
attrib_list.AppendElements(core_attribs, MOZ_ARRAY_LENGTH(core_attribs));
};
attrib_list.AppendElement(0);
context = glx.fCreateContextAttribs(
display,
cfg,
nullptr,
True,
attrib_list.Elements());
} else {
context = glx.fCreateNewContext(
display,
cfg,
LOCAL_GLX_RGBA_TYPE,
nullptr,
True);
}
if (context) {
glContext = new GLContextGLX(flags, caps, isOffscreen, display, drawable,
context, deleteDrawable, db, pixmap);
if (!glContext->Init())
error = true;
} else {
error = true;
}
error |= xErrorHandler.SyncAndGetError(display);
if (error) {
NS_WARNING("Failed to create GLXContext!");
glContext = nullptr; // note: this must be done while the graceful X error handler is set,
// because glxMakeCurrent can give a GLXBadDrawable error
}
return glContext.forget();
} while (true);
}
GLContextGLX::~GLContextGLX()
{
MarkDestroyed();
// Wrapped context should not destroy glxContext/Surface
if (!mOwnsContext) {
return;
}
// see bug 659842 comment 76
#ifdef DEBUG
bool success =
#endif
mGLX->fMakeCurrent(mDisplay, X11None, nullptr);
MOZ_ASSERT(success,
"glXMakeCurrent failed to release GL context before we call "
"glXDestroyContext!");
mGLX->fDestroyContext(mDisplay, mContext);
if (mDeleteDrawable) {
mGLX->fDestroyPixmap(mDisplay, mDrawable);
}
}
bool
GLContextGLX::Init()
{
SetupLookupFunction();
if (!InitWithPrefix("gl", true)) {
return false;
}
// EXT_framebuffer_object is not supported on Core contexts
// so we'll also check for ARB_framebuffer_object
if (!IsExtensionSupported(EXT_framebuffer_object) && !IsSupported(GLFeature::framebuffer_object))
return false;
return true;
}
bool
GLContextGLX::MakeCurrentImpl() const
{
if (mGLX->IsMesa()) {
// Read into the event queue to ensure that Mesa receives a
// DRI2InvalidateBuffers event before drawing. See bug 1280653.
Unused << XPending(mDisplay);
}
const bool succeeded = mGLX->fMakeCurrent(mDisplay, mDrawable, mContext);
NS_ASSERTION(succeeded, "Failed to make GL context current!");
if (!IsOffscreen() && mGLX->SupportsSwapControl()) {
// Many GLX implementations default to blocking until the next
// VBlank when calling glXSwapBuffers. We want to run unthrottled
// in ASAP mode. See bug 1280744.
const bool isASAP = (gfxPrefs::LayoutFrameRate() == 0);
mGLX->fSwapInterval(mDisplay, mDrawable, isASAP ? 0 : 1);
}
return succeeded;
}
bool
GLContextGLX::IsCurrentImpl() const
{
return mGLX->fGetCurrentContext() == mContext;
}
bool
GLContextGLX::SetupLookupFunction()
{
mLookupFunc = (PlatformLookupFunction)sGLXLibrary.GetGetProcAddress();
return true;
}
bool
GLContextGLX::IsDoubleBuffered() const
{
return mDoubleBuffered;
}
bool
GLContextGLX::SwapBuffers()
{
if (!mDoubleBuffered)
return false;
mGLX->fSwapBuffers(mDisplay, mDrawable);
return true;
}
void
GLContextGLX::GetWSIInfo(nsCString* const out) const
{
Display* display = DefaultXDisplay();
int screen = DefaultScreen(display);
int majorVersion, minorVersion;
sGLXLibrary.fQueryVersion(display, &majorVersion, &minorVersion);
out->Append(nsPrintfCString("GLX %u.%u", majorVersion, minorVersion));
out->AppendLiteral("\nGLX_VENDOR(client): ");
out->Append(sGLXLibrary.fGetClientString(display, LOCAL_GLX_VENDOR));
out->AppendLiteral("\nGLX_VENDOR(server): ");
out->Append(sGLXLibrary.fQueryServerString(display, screen, LOCAL_GLX_VENDOR));
out->AppendLiteral("\nExtensions: ");
out->Append(sGLXLibrary.fQueryExtensionsString(display, screen));
}
bool
GLContextGLX::OverrideDrawable(GLXDrawable drawable)
{
if (Screen())
Screen()->AssureBlitted();
Bool result = mGLX->fMakeCurrent(mDisplay, drawable, mContext);
return result;
}
bool
GLContextGLX::RestoreDrawable()
{
return mGLX->fMakeCurrent(mDisplay, mDrawable, mContext);
}
GLContextGLX::GLContextGLX(
CreateContextFlags flags,
const SurfaceCaps& caps,
bool isOffscreen,
Display* aDisplay,
GLXDrawable aDrawable,
GLXContext aContext,
bool aDeleteDrawable,
bool aDoubleBuffered,
gfxXlibSurface* aPixmap)
: GLContext(flags, caps, nullptr, isOffscreen),
mContext(aContext),
mDisplay(aDisplay),
mDrawable(aDrawable),
mDeleteDrawable(aDeleteDrawable),
mDoubleBuffered(aDoubleBuffered),
mGLX(&sGLXLibrary),
mPixmap(aPixmap)
{
}
static bool
AreCompatibleVisuals(Visual* one, Visual* two)
{
if (one->c_class != two->c_class) {
return false;
}
if (one->red_mask != two->red_mask ||
one->green_mask != two->green_mask ||
one->blue_mask != two->blue_mask) {
return false;
}
if (one->bits_per_rgb != two->bits_per_rgb) {
return false;
}
return true;
}
already_AddRefed<GLContext>
GLContextProviderGLX::CreateWrappingExisting(void* aContext, void* aSurface)
{
if (!sGLXLibrary.EnsureInitialized()) {
return nullptr;
}
if (aContext && aSurface) {
SurfaceCaps caps = SurfaceCaps::Any();
RefPtr<GLContextGLX> glContext =
new GLContextGLX(CreateContextFlags::NONE, caps,
false, // Offscreen
(Display*)DefaultXDisplay(), // Display
(GLXDrawable)aSurface, (GLXContext)aContext,
false, // aDeleteDrawable,
true,
(gfxXlibSurface*)nullptr);
glContext->mOwnsContext = false;
return glContext.forget();
}
return nullptr;
}
already_AddRefed<GLContext>
CreateForWidget(Display* aXDisplay, Window aXWindow,
bool aWebRender,
bool aForceAccelerated)
{
if (!sGLXLibrary.EnsureInitialized()) {
return nullptr;
}
// Currently, we take whatever Visual the window already has, and
// try to create an fbconfig for that visual. This isn't
// necessarily what we want in the long run; an fbconfig may not
// be available for the existing visual, or if it is, the GL
// performance might be suboptimal. But using the existing visual
// is a relatively safe intermediate step.
if (!aXDisplay) {
NS_ERROR("X Display required for GLX Context provider");
return nullptr;
}
int xscreen = DefaultScreen(aXDisplay);
ScopedXFree<GLXFBConfig> cfgs;
GLXFBConfig config;
int visid;
if (!GLContextGLX::FindFBConfigForWindow(aXDisplay, xscreen, aXWindow, &cfgs,
&config, &visid, aWebRender))
{
return nullptr;
}
CreateContextFlags flags;
if (aWebRender) {
flags = CreateContextFlags::NONE; // WR needs GL3.2+
} else {
flags = CreateContextFlags::REQUIRE_COMPAT_PROFILE;
}
return GLContextGLX::CreateGLContext(flags, SurfaceCaps::Any(), false, aXDisplay,
aXWindow, config, false, nullptr);
}
already_AddRefed<GLContext>
GLContextProviderGLX::CreateForCompositorWidget(CompositorWidget* aCompositorWidget, bool aForceAccelerated)
{
GtkCompositorWidget* compWidget = aCompositorWidget->AsX11();
MOZ_ASSERT(compWidget);
return CreateForWidget(compWidget->XDisplay(),
compWidget->XWindow(),
compWidget->GetCompositorOptions().UseWebRender(),
aForceAccelerated);
}
already_AddRefed<GLContext>
GLContextProviderGLX::CreateForWindow(nsIWidget* aWidget,
bool aWebRender,
bool aForceAccelerated)
{
Display* display = (Display*)aWidget->GetNativeData(NS_NATIVE_COMPOSITOR_DISPLAY);
Window window = GET_NATIVE_WINDOW(aWidget);
return CreateForWidget(display,
window,
aWebRender,
aForceAccelerated);
}
static bool
ChooseConfig(GLXLibrary* glx, Display* display, int screen, const SurfaceCaps& minCaps,
ScopedXFree<GLXFBConfig>* const out_scopedConfigArr,
GLXFBConfig* const out_config, int* const out_visid)
{
ScopedXFree<GLXFBConfig>& scopedConfigArr = *out_scopedConfigArr;
if (minCaps.antialias)
return false;
int attribs[] = {
LOCAL_GLX_DRAWABLE_TYPE, LOCAL_GLX_PIXMAP_BIT,
LOCAL_GLX_X_RENDERABLE, True,
LOCAL_GLX_RED_SIZE, 8,
LOCAL_GLX_GREEN_SIZE, 8,
LOCAL_GLX_BLUE_SIZE, 8,
LOCAL_GLX_ALPHA_SIZE, minCaps.alpha ? 8 : 0,
LOCAL_GLX_DEPTH_SIZE, minCaps.depth ? 16 : 0,
LOCAL_GLX_STENCIL_SIZE, minCaps.stencil ? 8 : 0,
0
};
int numConfigs = 0;
scopedConfigArr = glx->fChooseFBConfig(display, screen, attribs, &numConfigs);
if (!scopedConfigArr || !numConfigs)
return false;
// Issues with glxChooseFBConfig selection and sorting:
// * ALPHA_SIZE is sorted as 'largest total RGBA bits first'. If we don't request
// alpha bits, we'll probably get RGBA anyways, since 32 is more than 24.
// * DEPTH_SIZE is sorted largest first, including for `0` inputs.
// * STENCIL_SIZE is smallest first, but it might return `8` even though we ask for
// `0`.
// For now, we don't care about these. We *will* care when we do XPixmap sharing.
for (int i = 0; i < numConfigs; ++i) {
GLXFBConfig curConfig = scopedConfigArr[i];
int visid;
if (glx->fGetFBConfigAttrib(display, curConfig, LOCAL_GLX_VISUAL_ID, &visid)
!= Success)
{
continue;
}
if (!visid)
continue;
*out_config = curConfig;
*out_visid = visid;
return true;
}
return false;
}
bool
GLContextGLX::FindVisual(Display* display, int screen, bool useWebRender,
bool useAlpha, int* const out_visualId)
{
if (!sGLXLibrary.EnsureInitialized()) {
return false;
}
XVisualInfo visualTemplate;
visualTemplate.screen = screen;
// Get all visuals of screen
int visualsLen = 0;
XVisualInfo* xVisuals = XGetVisualInfo(display, VisualScreenMask, &visualTemplate, &visualsLen);
if (!xVisuals) {
return false;
}
const Range<XVisualInfo> visualInfos(xVisuals, visualsLen);
auto cleanupVisuals = MakeScopeExit([&] {
XFree(xVisuals);
});
// Get default visual info
Visual* defaultVisual = DefaultVisual(display, screen);
const auto defaultVisualInfo = [&]() -> const XVisualInfo* {
for (const auto& cur : visualInfos) {
if (cur.visual == defaultVisual) {
return &cur;
}
}
return nullptr;
}();
if (!defaultVisualInfo) {
MOZ_ASSERT(false);
return false;
}
const int bpp = useAlpha ? 32 : 24;
const int alphaSize = useAlpha ? 8 : 0;
const int depthSize = useWebRender ? 24 : 0;
for (auto& cur : visualInfos) {
const auto fnConfigMatches = [&](const int pname, const int expected) {
int actual;
if (sGLXLibrary.fGetConfig(display, &cur, pname, &actual)) {
return false;
}
return actual == expected;
};
// Check if visual is compatible.
if (cur.depth != bpp ||
cur.c_class != defaultVisualInfo->c_class) {
continue;
}
// Check if visual is compatible to GL requests.
if (fnConfigMatches(LOCAL_GLX_USE_GL, 1) &&
fnConfigMatches(LOCAL_GLX_DOUBLEBUFFER, 1) &&
fnConfigMatches(LOCAL_GLX_RED_SIZE, 8) &&
fnConfigMatches(LOCAL_GLX_GREEN_SIZE, 8) &&
fnConfigMatches(LOCAL_GLX_BLUE_SIZE, 8) &&
fnConfigMatches(LOCAL_GLX_ALPHA_SIZE, alphaSize) &&
fnConfigMatches(LOCAL_GLX_DEPTH_SIZE, depthSize))
{
*out_visualId = cur.visualid;
return true;
}
}
return false;
}
bool
GLContextGLX::FindFBConfigForWindow(Display* display, int screen, Window window,
ScopedXFree<GLXFBConfig>* const out_scopedConfigArr,
GLXFBConfig* const out_config, int* const out_visid,
bool aWebRender)
{
// XXX the visual ID is almost certainly the LOCAL_GLX_FBCONFIG_ID, so
// we could probably do this first and replace the glXGetFBConfigs
// with glXChooseConfigs. Docs are sparklingly clear as always.
XWindowAttributes windowAttrs;
if (!XGetWindowAttributes(display, window, &windowAttrs)) {
NS_WARNING("[GLX] XGetWindowAttributes() failed");
return false;
}
ScopedXFree<GLXFBConfig>& cfgs = *out_scopedConfigArr;
int numConfigs;
const int webrenderAttribs[] = {
LOCAL_GLX_ALPHA_SIZE, windowAttrs.depth == 32 ? 8 : 0,
LOCAL_GLX_DEPTH_SIZE, 24,
LOCAL_GLX_DOUBLEBUFFER, True,
0
};
if (aWebRender) {
cfgs = sGLXLibrary.fChooseFBConfig(display,
screen,
webrenderAttribs,
&numConfigs);
} else {
cfgs = sGLXLibrary.fGetFBConfigs(display,
screen,
&numConfigs);
}
if (!cfgs) {
NS_WARNING("[GLX] glXGetFBConfigs() failed");
return false;
}
NS_ASSERTION(numConfigs > 0, "No FBConfigs found!");
const VisualID windowVisualID = XVisualIDFromVisual(windowAttrs.visual);
#ifdef DEBUG
printf("[GLX] window %lx has VisualID 0x%lx\n", window, windowVisualID);
#endif
for (int i = 0; i < numConfigs; i++) {
int visid = X11None;
sGLXLibrary.fGetFBConfigAttrib(display, cfgs[i], LOCAL_GLX_VISUAL_ID, &visid);
if (visid) {
// WebRender compatible GLX visual is configured
// at nsWindow::Create() by GLContextGLX::FindVisual(),
// just reuse it here.
if (windowVisualID == static_cast<VisualID>(visid)) {
*out_config = cfgs[i];
*out_visid = visid;
return true;
}
}
}
// We don't have a frame buffer visual which matches the GLX visual
// from GLContextGLX::FindVisual(). Let's try to find a near one and hope
// we're not on NVIDIA (Bug 1478454) as it causes X11 BadMatch error there.
for (int i = 0; i < numConfigs; i++) {
int visid = X11None;
sGLXLibrary.fGetFBConfigAttrib(display, cfgs[i], LOCAL_GLX_VISUAL_ID, &visid);
if (visid) {
int depth;
Visual* visual;
FindVisualAndDepth(display, visid, &visual, &depth);
if (depth == windowAttrs.depth &&
AreCompatibleVisuals(windowAttrs.visual, visual)) {
*out_config = cfgs[i];
*out_visid = visid;
return true;
}
}
}
NS_WARNING("[GLX] Couldn't find a FBConfig matching window visual");
return false;
}
static already_AddRefed<GLContextGLX>
CreateOffscreenPixmapContext(CreateContextFlags flags, const IntSize& size,
const SurfaceCaps& minCaps, nsACString* const out_failureId)
{
GLXLibrary* glx = &sGLXLibrary;
if (!glx->EnsureInitialized())
return nullptr;
Display* display = DefaultXDisplay();
int screen = DefaultScreen(display);
ScopedXFree<GLXFBConfig> scopedConfigArr;
GLXFBConfig config;
int visid;
if (!ChooseConfig(glx, display, screen, minCaps, &scopedConfigArr, &config, &visid)) {
NS_WARNING("Failed to find a compatible config.");
return nullptr;
}
Visual* visual;
int depth;
FindVisualAndDepth(display, visid, &visual, &depth);
OffMainThreadScopedXErrorHandler xErrorHandler;
bool error = false;
gfx::IntSize dummySize(16, 16);
RefPtr<gfxXlibSurface> surface = gfxXlibSurface::Create(DefaultScreenOfDisplay(display),
visual,
dummySize);
if (surface->CairoStatus() != 0) {
mozilla::Unused << xErrorHandler.SyncAndGetError(display);
return nullptr;
}
// Handle slightly different signature between glXCreatePixmap and
// its pre-GLX-1.3 extension equivalent (though given the ABI, we
// might not need to).
const auto drawable = surface->XDrawable();
const auto pixmap = glx->fCreatePixmap(display, config, drawable, nullptr);
if (pixmap == 0) {
error = true;
}
bool serverError = xErrorHandler.SyncAndGetError(display);
if (error || serverError)
return nullptr;
return GLContextGLX::CreateGLContext(flags, minCaps, true, display, pixmap, config,
true, surface);
}
/*static*/ already_AddRefed<GLContext>
GLContextProviderGLX::CreateHeadless(CreateContextFlags flags,
nsACString* const out_failureId)
{
IntSize dummySize = IntSize(16, 16);
SurfaceCaps dummyCaps = SurfaceCaps::Any();
return CreateOffscreenPixmapContext(flags, dummySize, dummyCaps, out_failureId);
}
/*static*/ already_AddRefed<GLContext>
GLContextProviderGLX::CreateOffscreen(const IntSize& size,
const SurfaceCaps& minCaps,
CreateContextFlags flags,
nsACString* const out_failureId)
{
SurfaceCaps minBackbufferCaps = minCaps;
if (minCaps.antialias) {
minBackbufferCaps.antialias = false;
minBackbufferCaps.depth = false;
minBackbufferCaps.stencil = false;
}
RefPtr<GLContext> gl;
gl = CreateOffscreenPixmapContext(flags, size, minBackbufferCaps, out_failureId);
if (!gl)
return nullptr;
if (!gl->InitOffscreen(size, minCaps)) {
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_GLX_INIT");
return nullptr;
}
return gl.forget();
}
/*static*/ GLContext*
GLContextProviderGLX::GetGlobalContext()
{
// Context sharing not supported.
return nullptr;
}
/*static*/ void
GLContextProviderGLX::Shutdown()
{
}
} /* namespace gl */
} /* namespace mozilla */
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку