Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 368 insertions, 0 deletions

diff --git a/gfx/gl/GLContextProviderCGL.mm b/gfx/gl/GLContextProviderCGL.mm
new file mode 100644
index 0000000000..2e205c1434
--- /dev/null
+++ b/gfx/gl/GLContextProviderCGL.mm
@@ -0,0 +1,368 @@
+/* -*- 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 "GLLibraryLoader.h"
+#include "nsDebug.h"
+#include "nsIWidget.h"
+#include <OpenGL/gl.h>
+#include "gfxFailure.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/StaticPrefs_gfx.h"
+#include "mozilla/StaticPrefs_gl.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "prenv.h"
+#include "prlink.h"
+#include "mozilla/ProfilerLabels.h"
+#include "MozFramebuffer.h"
+#include "mozilla/layers/CompositorOptions.h"
+#include "mozilla/widget/CompositorWidget.h"
+#include "ScopedGLHelpers.h"
+
+#include <OpenGL/OpenGL.h>
+
+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;
+      }
+    }
+
+    mInitialized = true;
+    return true;
+  }
+
+  const auto& Library() const { return mOGLLibrary; }
+
+ private:
+  bool mInitialized = false;
+  PRLibrary* mOGLLibrary = nullptr;
+};
+
+CGLLibrary sCGLLibrary;
+
+GLContextCGL::GLContextCGL(const GLContextDesc& desc, NSOpenGLContext* context)
+    : GLContext(desc), mContext(context) {
+  CGDisplayRegisterReconfigurationCallback(DisplayReconfigurationCallback,
+                                           this);
+}
+
+GLContextCGL::~GLContextCGL() {
+  MarkDestroyed();
+
+  CGDisplayRemoveReconfigurationCallback(DisplayReconfigurationCallback, this);
+
+  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];
+  }
+}
+
+CGLContextObj GLContextCGL::GetCGLContext() const {
+  return static_cast<CGLContextObj>([mContext CGLContextObj]);
+}
+
+bool GLContextCGL::MakeCurrentImpl() const {
+  if (mContext) {
+    GLContext::ResetTLSCurrentContext();
+
+    [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;
+}
+
+/* static */ void GLContextCGL::DisplayReconfigurationCallback(
+    CGDirectDisplayID aDisplay, CGDisplayChangeSummaryFlags aFlags,
+    void* aUserInfo) {
+  if (aFlags & kCGDisplaySetModeFlag) {
+    static_cast<GLContextCGL*>(aUserInfo)->mActiveGPUSwitchMayHaveOccurred =
+        true;
+  }
+}
+
+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;
+}
+
+// Get the "OpenGL display mask" for a fresh context. The return value of this
+// function depends on the time at which this function is called.
+// In practice, on a Macbook Pro with an integrated and a discrete GPU, this
+// function returns the display mask for the GPU that currently drives the
+// internal display.
+//
+// Quick reference of the concepts involved in the code below:
+//   GPU switch: On Mac devices with an integrated and a discrete GPU, a GPU
+//   switch changes which
+//     GPU drives the internal display. Both GPUs are still usable at all times.
+//     (When the integrated GPU is driving the internal display, using the
+//     discrete GPU can incur a longer warm-up cost.)
+//   Virtual screen: A CGL concept. A "virtual screen" corresponds to a GL
+//   renderer. There's one
+//     for the integrated GPU, one for each discrete GPU, and one for the Apple
+//     software renderer. The list of virtual screens is
+//     per-NSOpenGLPixelFormat; it is filtered down to only the renderers that
+//     support the requirements from the pixel format attributes. Indexes into
+//     this list (such as currentVirtualScreen) cannot be used interchangably
+//     across different NSOpenGLPixelFormat instances.
+//   Display mask: A bitset per GL renderer. Different renderers have disjoint
+//   display masks. The
+//     Apple software renderer has all bits zeroed. For each CGDirectDisplayID,
+//     CGDisplayIDToOpenGLDisplayMask(displayID) returns a single bit in the
+//     display mask.
+//   CGDirectDisplayID: An ID for each (physical screen, GPU which can drive
+//   this screen) pair. The
+//     current CGDirectDisplayID for an NSScreen object can be obtained using
+//     [[[screen deviceDescription] objectForKey:@"NSScreenNumber"]
+//     unsignedIntValue]; it changes depending on which GPU is currently driving
+//     the screen.
+static CGOpenGLDisplayMask GetFreshContextDisplayMask() {
+  NSOpenGLPixelFormatAttribute attribs[] = {NSOpenGLPFAAllowOfflineRenderers,
+                                            0};
+  NSOpenGLPixelFormat* pixelFormat =
+      [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
+  MOZ_RELEASE_ASSERT(pixelFormat);
+  NSOpenGLContext* context = [[NSOpenGLContext alloc] initWithFormat:pixelFormat
+                                                        shareContext:nullptr];
+  GLint displayMask = 0;
+  [pixelFormat getValues:&displayMask
+            forAttribute:NSOpenGLPFAScreenMask
+        forVirtualScreen:[context currentVirtualScreen]];
+  [pixelFormat release];
+  [context release];
+  return static_cast<CGOpenGLDisplayMask>(displayMask);
+}
+
+static bool IsSameGPU(CGOpenGLDisplayMask mask1, CGOpenGLDisplayMask mask2) {
+  if ((mask1 & mask2) != 0) {
+    return true;
+  }
+  // Both masks can be zero, when using the Apple software renderer.
+  return !mask1 && !mask2;
+}
+
+void GLContextCGL::MigrateToActiveGPU() {
+  if (!mActiveGPUSwitchMayHaveOccurred.compareExchange(true, false)) {
+    return;
+  }
+
+  CGOpenGLDisplayMask newPreferredDisplayMask = GetFreshContextDisplayMask();
+  NSOpenGLPixelFormat* pixelFormat = [mContext pixelFormat];
+  GLint currentVirtualScreen = [mContext currentVirtualScreen];
+  GLint currentDisplayMask = 0;
+  [pixelFormat getValues:&currentDisplayMask
+            forAttribute:NSOpenGLPFAScreenMask
+        forVirtualScreen:currentVirtualScreen];
+  if (IsSameGPU(currentDisplayMask, newPreferredDisplayMask)) {
+    // No "virtual screen" change needed.
+    return;
+  }
+
+  // Find the "virtual screen" with a display mask that matches
+  // newPreferredDisplayMask, if available, and switch the context over to it.
+  // This code was inspired by equivalent functionality in -[NSOpenGLContext
+  // update] which only kicks in for contexts that present via a CAOpenGLLayer.
+  for (const auto i : IntegerRange([pixelFormat numberOfVirtualScreens])) {
+    GLint displayMask = 0;
+    [pixelFormat getValues:&displayMask
+              forAttribute:NSOpenGLPFAScreenMask
+          forVirtualScreen:i];
+    if (IsSameGPU(displayMask, newPreferredDisplayMask)) {
+      CGLSetVirtualScreen([mContext CGLContextObj], i);
+      return;
+    }
+  }
+}
+
+GLenum GLContextCGL::GetPreferredARGB32Format() const { return LOCAL_GL_BGRA; }
+
+bool GLContextCGL::SwapBuffers() {
+  AUTO_PROFILER_LABEL("GLContextCGL::SwapBuffers", GRAPHICS);
+
+  // We do not have a default framebuffer. Just do a flush.
+  // Flushing is necessary if we want our IOSurfaces to have the correct
+  // content once they're picked up by the WindowServer from our CALayers.
+  fFlush();
+
+  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));
+}
+
+already_AddRefed<GLContext> GLContextProviderCGL::CreateForCompositorWidget(
+    CompositorWidget* aCompositorWidget, bool aHardwareWebRender,
+    bool aForceAccelerated) {
+  CreateContextFlags flags = CreateContextFlags::ALLOW_OFFLINE_RENDERER;
+  if (aForceAccelerated) {
+    flags |= CreateContextFlags::FORBID_SOFTWARE;
+  }
+  if (!aHardwareWebRender) {
+    flags |= CreateContextFlags::REQUIRE_COMPAT_PROFILE;
+  }
+  nsCString failureUnused;
+  return CreateHeadless({flags}, &failureUnused);
+}
+
+static RefPtr<GLContextCGL> CreateOffscreenFBOContext(
+    GLContextCreateDesc desc) {
+  if (!sCGLLibrary.EnsureInitialized()) {
+    return nullptr;
+  }
+
+  NSOpenGLContext* context = nullptr;
+
+  std::vector<NSOpenGLPixelFormatAttribute> attribs;
+  auto& flags = desc.flags;
+
+  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 (flags & CreateContextFlags::FORBID_SOFTWARE) {
+    if (flags & CreateContextFlags::FORBID_HARDWARE) {
+      NS_WARNING("Both !hardware and !software.");
+      return nullptr;
+    }
+    attribs.push_back(NSOpenGLPFAAccelerated);
+  }
+  if (flags & CreateContextFlags::FORBID_HARDWARE) {
+    /* NSOpenGLPFARendererID:
+     * > OpenGL renderers that match the specified ID are preferred.
+     * > Constants to select specific renderers are provided in the
+     * > GLRenderers.h header of the OpenGL framework.
+     * > Of note is kCGLRendererGenericID which selects the Apple software
+     * > renderer.
+     * > The other constants select renderers for specific hardware vendors.
+     */
+    attribs.push_back(NSOpenGLPFARendererID);
+    attribs.push_back(kCGLRendererGenericID);
+  }
+
+  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({desc, true}, context);
+
+  if (flags & CreateContextFlags::PREFER_MULTITHREADED) {
+    CGLEnable(glContext->GetCGLContext(), kCGLCEMPEngine);
+  }
+  return glContext;
+}
+
+already_AddRefed<GLContext> GLContextProviderCGL::CreateHeadless(
+    const GLContextCreateDesc& desc, nsACString* const out_failureId) {
+  auto gl = CreateOffscreenFBOContext(desc);
+  if (!gl) {
+    *out_failureId = "FEATURE_FAILURE_CGL_FBO"_ns;
+    return nullptr;
+  }
+
+  if (!gl->Init()) {
+    *out_failureId = "FEATURE_FAILURE_CGL_INIT"_ns;
+    NS_WARNING("Failed during 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({}, &discardFailureId);
+    gGlobalContext = temp;
+
+    if (!gGlobalContext) {
+      NS_WARNING("Couldn't init gGlobalContext.");
+    }
+  }
+
+  return gGlobalContext;
+}
+
+void GLContextProviderCGL::Shutdown() { gGlobalContext = nullptr; }
+
+} /* namespace gl */
+} /* namespace mozilla */