зеркало из https://github.com/mozilla/gecko-dev.git
380 строки
12 KiB
Plaintext
380 строки
12 KiB
Plaintext
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* 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 "GLContextProvider.h"
|
|
#include "GLContextCGL.h"
|
|
#include "nsDebug.h"
|
|
#include "nsIWidget.h"
|
|
#include <OpenGL/gl.h>
|
|
#include "gfxFailure.h"
|
|
#include "mozilla/StaticPrefs.h"
|
|
#include "prenv.h"
|
|
#include "GeckoProfiler.h"
|
|
#include "MozFramebuffer.h"
|
|
#include "mozilla/gfx/MacIOSurface.h"
|
|
#include "mozilla/layers/CompositorOptions.h"
|
|
#include "mozilla/widget/CompositorWidget.h"
|
|
#include "ScopedGLHelpers.h"
|
|
|
|
#include <OpenGL/OpenGL.h>
|
|
|
|
// When running inside a VM, creating an accelerated OpenGL context usually
|
|
// fails. Uncomment this line to emulate that behavior.
|
|
// #define EMULATE_VM
|
|
|
|
namespace mozilla {
|
|
namespace gl {
|
|
|
|
using namespace mozilla::gfx;
|
|
using namespace mozilla::widget;
|
|
|
|
class CGLLibrary {
|
|
public:
|
|
bool EnsureInitialized() {
|
|
if (mInitialized) {
|
|
return true;
|
|
}
|
|
if (!mOGLLibrary) {
|
|
mOGLLibrary = PR_LoadLibrary("/System/Library/Frameworks/OpenGL.framework/OpenGL");
|
|
if (!mOGLLibrary) {
|
|
NS_WARNING("Couldn't load OpenGL Framework.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const char* db = PR_GetEnv("MOZ_CGL_DB");
|
|
if (db) {
|
|
mUseDoubleBufferedWindows = *db != '0';
|
|
}
|
|
|
|
mInitialized = true;
|
|
return true;
|
|
}
|
|
|
|
bool UseDoubleBufferedWindows() const {
|
|
MOZ_ASSERT(mInitialized);
|
|
return mUseDoubleBufferedWindows;
|
|
}
|
|
|
|
const auto& Library() const { return mOGLLibrary; }
|
|
|
|
private:
|
|
bool mInitialized = false;
|
|
bool mUseDoubleBufferedWindows = true;
|
|
PRLibrary* mOGLLibrary = nullptr;
|
|
};
|
|
|
|
CGLLibrary sCGLLibrary;
|
|
|
|
GLContextCGL::GLContextCGL(CreateContextFlags flags, const SurfaceCaps& caps,
|
|
NSOpenGLContext* context, bool isOffscreen)
|
|
: GLContext(flags, caps, nullptr, isOffscreen), mContext(context) {}
|
|
|
|
GLContextCGL::~GLContextCGL() {
|
|
MarkDestroyed();
|
|
|
|
if (mContext) {
|
|
if ([NSOpenGLContext currentContext] == mContext) {
|
|
// Clear the current context before releasing. If we don't do
|
|
// this, the next time we call [NSOpenGLContext currentContext],
|
|
// "invalid context" will be printed to the console.
|
|
[NSOpenGLContext clearCurrentContext];
|
|
}
|
|
[mContext release];
|
|
}
|
|
}
|
|
|
|
void GLContextCGL::OnMarkDestroyed() {
|
|
mRegisteredIOSurfaceFramebuffers.clear();
|
|
|
|
mDefaultFramebuffer = 0;
|
|
}
|
|
|
|
CGLContextObj GLContextCGL::GetCGLContext() const {
|
|
return static_cast<CGLContextObj>([mContext CGLContextObj]);
|
|
}
|
|
|
|
bool GLContextCGL::MakeCurrentImpl() const {
|
|
if (mContext) {
|
|
[mContext makeCurrentContext];
|
|
MOZ_ASSERT(IsCurrentImpl());
|
|
// Use non-blocking swap in "ASAP mode".
|
|
// ASAP mode means that rendering is iterated as fast as possible.
|
|
// ASAP mode is entered when layout.frame_rate=0 (requires restart).
|
|
// If swapInt is 1, then glSwapBuffers will block and wait for a vblank signal.
|
|
// When we're iterating as fast as possible, however, we want a non-blocking
|
|
// glSwapBuffers, which will happen when swapInt==0.
|
|
GLint swapInt = StaticPrefs::layout_frame_rate() == 0 ? 0 : 1;
|
|
[mContext setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool GLContextCGL::IsCurrentImpl() const { return [NSOpenGLContext currentContext] == mContext; }
|
|
|
|
GLenum GLContextCGL::GetPreferredARGB32Format() const { return LOCAL_GL_BGRA; }
|
|
|
|
bool GLContextCGL::IsDoubleBuffered() const { return sCGLLibrary.UseDoubleBufferedWindows(); }
|
|
|
|
bool GLContextCGL::SwapBuffers() {
|
|
AUTO_PROFILER_LABEL("GLContextCGL::SwapBuffers", GRAPHICS);
|
|
|
|
[mContext flushBuffer];
|
|
|
|
return true;
|
|
}
|
|
|
|
void GLContextCGL::GetWSIInfo(nsCString* const out) const { out->AppendLiteral("CGL"); }
|
|
|
|
Maybe<SymbolLoader> GLContextCGL::GetSymbolLoader() const {
|
|
const auto& lib = sCGLLibrary.Library();
|
|
return Some(SymbolLoader(*lib));
|
|
}
|
|
|
|
GLuint GLContextCGL::GetDefaultFramebuffer() { return mDefaultFramebuffer; }
|
|
|
|
void GLContextCGL::UseRegisteredIOSurfaceForDefaultFramebuffer(IOSurfaceRef aSurface) {
|
|
MakeCurrent();
|
|
|
|
auto fb = mRegisteredIOSurfaceFramebuffers.find(aSurface);
|
|
MOZ_RELEASE_ASSERT(fb != mRegisteredIOSurfaceFramebuffers.end(),
|
|
"IOSurface has not been registered with this GLContext");
|
|
|
|
mDefaultFramebuffer = fb->second->mFB;
|
|
}
|
|
|
|
void GLContextCGL::RegisterIOSurface(IOSurfaceRef aSurface) {
|
|
MOZ_RELEASE_ASSERT(
|
|
mRegisteredIOSurfaceFramebuffers.find(aSurface) == mRegisteredIOSurfaceFramebuffers.end(),
|
|
"double-registering IOSurface");
|
|
|
|
uint32_t width = IOSurfaceGetWidth(aSurface);
|
|
uint32_t height = IOSurfaceGetHeight(aSurface);
|
|
|
|
MakeCurrent();
|
|
GLuint tex = CreateTexture();
|
|
|
|
{
|
|
const ScopedBindTexture bindTex(this, tex, LOCAL_GL_TEXTURE_RECTANGLE_ARB);
|
|
CGLTexImageIOSurface2D([mContext CGLContextObj], LOCAL_GL_TEXTURE_RECTANGLE_ARB, LOCAL_GL_RGBA,
|
|
width, height, LOCAL_GL_BGRA, LOCAL_GL_UNSIGNED_INT_8_8_8_8_REV,
|
|
aSurface, 0);
|
|
}
|
|
|
|
auto fb = MozFramebuffer::CreateWith(this, IntSize(width, height), 0, mCaps.depth,
|
|
LOCAL_GL_TEXTURE_RECTANGLE_ARB, tex);
|
|
mRegisteredIOSurfaceFramebuffers.insert({aSurface, std::move(fb)});
|
|
}
|
|
|
|
void GLContextCGL::UnregisterIOSurface(IOSurfaceRef aSurface) {
|
|
size_t removeCount = mRegisteredIOSurfaceFramebuffers.erase(aSurface);
|
|
MOZ_RELEASE_ASSERT(removeCount == 1, "Unregistering IOSurface that's not registered");
|
|
}
|
|
|
|
already_AddRefed<GLContext> GLContextProviderCGL::CreateWrappingExisting(void*, void*) {
|
|
return nullptr;
|
|
}
|
|
|
|
static const NSOpenGLPixelFormatAttribute kAttribs_singleBuffered[] = {
|
|
NSOpenGLPFAAllowOfflineRenderers, 0};
|
|
|
|
static const NSOpenGLPixelFormatAttribute kAttribs_singleBuffered_accel[] = {
|
|
NSOpenGLPFAAccelerated, NSOpenGLPFAAllowOfflineRenderers, 0};
|
|
|
|
static const NSOpenGLPixelFormatAttribute kAttribs_doubleBuffered[] = {
|
|
NSOpenGLPFAAllowOfflineRenderers, NSOpenGLPFADoubleBuffer, 0};
|
|
|
|
static const NSOpenGLPixelFormatAttribute kAttribs_doubleBuffered_accel[] = {
|
|
NSOpenGLPFAAccelerated, NSOpenGLPFAAllowOfflineRenderers, NSOpenGLPFADoubleBuffer, 0};
|
|
|
|
static const NSOpenGLPixelFormatAttribute kAttribs_doubleBuffered_accel_webrender[] = {
|
|
NSOpenGLPFAAccelerated,
|
|
NSOpenGLPFAAllowOfflineRenderers,
|
|
NSOpenGLPFADoubleBuffer,
|
|
NSOpenGLPFAOpenGLProfile,
|
|
NSOpenGLProfileVersion3_2Core,
|
|
NSOpenGLPFADepthSize,
|
|
24,
|
|
0};
|
|
|
|
static NSOpenGLContext* CreateWithFormat(const NSOpenGLPixelFormatAttribute* attribs) {
|
|
NSOpenGLPixelFormat* format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
|
|
if (!format) {
|
|
NS_WARNING("Failed to create NSOpenGLPixelFormat.");
|
|
return nullptr;
|
|
}
|
|
|
|
NSOpenGLContext* context = [[NSOpenGLContext alloc] initWithFormat:format shareContext:nullptr];
|
|
|
|
[format release];
|
|
|
|
return context;
|
|
}
|
|
|
|
already_AddRefed<GLContext> GLContextProviderCGL::CreateForCompositorWidget(
|
|
CompositorWidget* aCompositorWidget, bool aWebRender, bool aForceAccelerated) {
|
|
if (!aCompositorWidget) {
|
|
MOZ_ASSERT(false);
|
|
return nullptr;
|
|
}
|
|
return CreateForWindow(aCompositorWidget->RealWidget(), aWebRender, aForceAccelerated);
|
|
}
|
|
|
|
already_AddRefed<GLContext> GLContextProviderCGL::CreateForWindow(nsIWidget* aWidget,
|
|
bool aWebRender,
|
|
bool aForceAccelerated) {
|
|
if (!sCGLLibrary.EnsureInitialized()) {
|
|
return nullptr;
|
|
}
|
|
|
|
#ifdef EMULATE_VM
|
|
if (aForceAccelerated) {
|
|
return nullptr;
|
|
}
|
|
#endif
|
|
|
|
const NSOpenGLPixelFormatAttribute* attribs;
|
|
SurfaceCaps caps = SurfaceCaps::ForRGBA();
|
|
if (sCGLLibrary.UseDoubleBufferedWindows()) {
|
|
if (aWebRender) {
|
|
MOZ_RELEASE_ASSERT(aForceAccelerated,
|
|
"At the moment, aForceAccelerated is always true if aWebRender is true. "
|
|
"If this changes, please update the code here.");
|
|
attribs = kAttribs_doubleBuffered_accel_webrender;
|
|
caps.depth = true;
|
|
} else {
|
|
attribs = aForceAccelerated ? kAttribs_doubleBuffered_accel : kAttribs_doubleBuffered;
|
|
}
|
|
} else {
|
|
attribs = aForceAccelerated ? kAttribs_singleBuffered_accel : kAttribs_singleBuffered;
|
|
}
|
|
NSOpenGLContext* context = CreateWithFormat(attribs);
|
|
if (!context) {
|
|
return nullptr;
|
|
}
|
|
|
|
GLint opaque = StaticPrefs::gfx_compositor_glcontext_opaque();
|
|
[context setValues:&opaque forParameter:NSOpenGLCPSurfaceOpacity];
|
|
|
|
RefPtr<GLContextCGL> glContext = new GLContextCGL(CreateContextFlags::NONE, caps, context, false);
|
|
|
|
if (!glContext->Init()) {
|
|
glContext = nullptr;
|
|
[context release];
|
|
return nullptr;
|
|
}
|
|
|
|
return glContext.forget();
|
|
}
|
|
|
|
static already_AddRefed<GLContextCGL> CreateOffscreenFBOContext(CreateContextFlags flags) {
|
|
if (!sCGLLibrary.EnsureInitialized()) {
|
|
return nullptr;
|
|
}
|
|
|
|
NSOpenGLContext* context = nullptr;
|
|
|
|
std::vector<NSOpenGLPixelFormatAttribute> attribs;
|
|
|
|
if (!StaticPrefs::gl_allow_high_power()) {
|
|
flags &= ~CreateContextFlags::HIGH_POWER;
|
|
}
|
|
if (flags & CreateContextFlags::ALLOW_OFFLINE_RENDERER ||
|
|
!(flags & CreateContextFlags::HIGH_POWER)) {
|
|
// This is really poorly named on Apple's part, but "AllowOfflineRenderers" means
|
|
// that we want to allow running on the iGPU instead of requiring the dGPU.
|
|
attribs.push_back(NSOpenGLPFAAllowOfflineRenderers);
|
|
}
|
|
|
|
if (StaticPrefs::gl_require_hardware()) {
|
|
attribs.push_back(NSOpenGLPFAAccelerated);
|
|
}
|
|
|
|
if (!(flags & CreateContextFlags::REQUIRE_COMPAT_PROFILE)) {
|
|
auto coreAttribs = attribs;
|
|
coreAttribs.push_back(NSOpenGLPFAOpenGLProfile);
|
|
coreAttribs.push_back(NSOpenGLProfileVersion3_2Core);
|
|
coreAttribs.push_back(0);
|
|
context = CreateWithFormat(coreAttribs.data());
|
|
}
|
|
|
|
if (!context) {
|
|
attribs.push_back(0);
|
|
context = CreateWithFormat(attribs.data());
|
|
}
|
|
|
|
if (!context) {
|
|
NS_WARNING("Failed to create NSOpenGLContext.");
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<GLContextCGL> glContext = new GLContextCGL(flags, SurfaceCaps::Any(), context, true);
|
|
|
|
if (StaticPrefs::gl_multithreaded()) {
|
|
CGLEnable(glContext->GetCGLContext(), kCGLCEMPEngine);
|
|
}
|
|
return glContext.forget();
|
|
}
|
|
|
|
already_AddRefed<GLContext> GLContextProviderCGL::CreateHeadless(CreateContextFlags flags,
|
|
nsACString* const out_failureId) {
|
|
RefPtr<GLContextCGL> gl;
|
|
gl = CreateOffscreenFBOContext(flags);
|
|
if (!gl) {
|
|
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_CGL_FBO");
|
|
return nullptr;
|
|
}
|
|
|
|
if (!gl->Init()) {
|
|
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_CGL_INIT");
|
|
NS_WARNING("Failed during Init.");
|
|
return nullptr;
|
|
}
|
|
|
|
return gl.forget();
|
|
}
|
|
|
|
already_AddRefed<GLContext> GLContextProviderCGL::CreateOffscreen(const IntSize& size,
|
|
const SurfaceCaps& minCaps,
|
|
CreateContextFlags flags,
|
|
nsACString* const out_failureId) {
|
|
RefPtr<GLContext> gl = CreateHeadless(flags, out_failureId);
|
|
if (!gl) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!gl->InitOffscreen(size, minCaps)) {
|
|
*out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_CGL_INIT");
|
|
return nullptr;
|
|
}
|
|
|
|
return gl.forget();
|
|
}
|
|
|
|
static RefPtr<GLContext> gGlobalContext;
|
|
|
|
GLContext* GLContextProviderCGL::GetGlobalContext() {
|
|
static bool triedToCreateContext = false;
|
|
if (!triedToCreateContext) {
|
|
triedToCreateContext = true;
|
|
|
|
MOZ_RELEASE_ASSERT(!gGlobalContext);
|
|
nsCString discardFailureId;
|
|
RefPtr<GLContext> temp = CreateHeadless(CreateContextFlags::NONE, &discardFailureId);
|
|
gGlobalContext = temp;
|
|
|
|
if (!gGlobalContext) {
|
|
NS_WARNING("Couldn't init gGlobalContext.");
|
|
}
|
|
}
|
|
|
|
return gGlobalContext;
|
|
}
|
|
|
|
void GLContextProviderCGL::Shutdown() { gGlobalContext = nullptr; }
|
|
|
|
} /* namespace gl */
|
|
} /* namespace mozilla */
|