swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-11-07 01:53:24 +09:00
Code Issues Packages Projects Releases Wiki Activity
Files
8024b645cb06bba85442d0698e5e5b0dfe15a3e2
MobileGL/MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp
T

1690 lines
77 KiB
C++
Raw Blame History

// MobileGL - MobileGL/MG_Impl/EGLImpl/EGLImpl.cpp
// Copyright (c) 2025-2026 MobileGL-Dev
// Licensed under the GNU Lesser General Public License v3.0:
// https://www.gnu.org/licenses/gpl-3.0.txt
// https://www.gnu.org/licenses/lgpl-3.0.txt
// SPDX-License-Identifier: LGPL-3.0-only
// End of Source File Header
#include "EGLImpl.h"
#include "EGLPlatformExtensions.h"
#include "WaylandWindow.h"
#include "../GetProcAddress.h"
#include <Init.h>
#include <MG_Backend/BackendObjects.h>
#include <MG_State/EGLState/Core.h>
#if MOBILEGL_BUILD_DISAGGREGATED
// MG_Config::ServerOwnedWindowSurfaces (P12, MOBILEGL_IPC_SURFACE). Split-only: the pull build's
// translation unit is unchanged (G1).
#include <Config.h>
// P14 S1 (docs/Disaggregated/design/11-state-ownership.md). The EGL context lifecycle's
// client half: eglCreateContext/eglDestroyContext cross as two control frames, and a
// context switch emits the in-band bind_context record. Reached through MG_Remote::Client
// because that is the seam MG_Impl already uses for its other wire producers
// (PipeFill.cpp's emitters) and because the frame channel belongs to the server role - this
// file must not name ServerLoop's forwarders directly.
#include <MG_Remote/Client/WireTables.h>
// The recovery after a device loss (RecoverLostSession below): the session, the remote backend's
// surface book, and the GL framebuffer 0 that is rebuilt on the fresh session.
#include <MG_Remote/Client/BackendObject_Remote.h>
#include <MG_Remote/Client/ClientSession.h>
#include <MG_Impl/GLImpl/Framebuffer/GL_Framebuffer.h>
#include <MG_State/GLState/Core.h>
#include <optional>
#endif
#include <cstring>
#include <mutex>
#include <sstream>
#if defined(__linux__) && !defined(__ANDROID__)
#include <dlfcn.h>
#endif
#include <algorithm>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
namespace MobileGL::MG_Impl::EGLImpl {
namespace {
using EGLStateContext = MG_State::EGLState::EGLContext;
EGLStateContext* GetState() {
if (!MG_State::pEGLContext) {
// Not an error by itself: a dispatcher calls every vendor's per-thread and error
// entry points, including a vendor that never served this process.
MGLOG_D("pEGLContext is null. MG_State may not be initialized.");
}
return MG_State::pEGLContext.get();
}
// Entry points that can legitimately be an application's FIRST EGL
// call (display/proc-address/string queries) lazily bring MobileGL
// up here, so the library needs no static constructor and can
// re-initialize after the last eglTerminate tore everything down.
// Teardown-ish entry points keep using GetState() and fail benignly
// when MobileGL is not initialized.
//
// Bringing MobileGL up dials its server, and with none reachable that waits out the
// bring-up's whole budget. So it is not attempted then: the entry point fails at once, as
// it would on any implementation without a display to offer.
EGLStateContext* GetStateEnsureInitialized() {
if (!MG_State::pEGLContext && !MobileGL::ImplementationAvailable()) {
return nullptr;
}
MobileGL::EnsureInitialized();
return GetState();
}
MG_Backend::BackendObject* GetBackendObject(EGLStateContext* state) {
auto* backendObject = MG_Backend::pActiveBackendObject.get();
if (!backendObject && state) {
state->SetError(EGL_NOT_INITIALIZED);
}
return backendObject;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// P14 S1 (docs/Disaggregated/design/11-state-ownership.md). THE CONTEXT BINDING, AND
// THE ONE PLACE IT IS EMITTED.
//
// `bind_context` is the ring's half of eglMakeCurrent: the MakeCurrent control frame
// tells the server which native tuple to hold, and this record tells it which CONTEXT
// every record after it belongs to - the attribution the session table was built for.
//
// IT IS EMITTED AFTER THE SWITCH HAS SUCCEEDED AND BEFORE eglMakeCurrent RETURNS, and
// that is the whole ordering argument: the app thread cannot publish a record of the
// new context until this call has returned, and the ring is FIFO, so the binding is
// behind no verb of the context it names and ahead of every one that follows. Waiting
// for the first verb instead would need the emitter to know which context the tracker
// is about to prime; this needs only the token EGLState already holds.
//
// An unchanged token emits NOTHING: an identical eglMakeCurrent is a legal no-op in
// EGL and the session is already bound to that context.
//
// THE COMPARISON IS AGAINST THE BINDING LAST SENT, NOT THIS THREAD'S PREVIOUS CONTEXT
// (GLStreamScope in EGLImpl.h): the session has one current context and another thread
// may have moved it since this one last bound. The caller holds EGLOperationMutex.
thread_local Uint64 t_threadContextToken = 0;
Uint64 g_boundContextToken = 0; // guarded by EGLOperationMutex
// P14: the share groups of the two tokens above, kept beside them so the client can say
// which group's object records a record written now lands in (StreamBoundShareGroupToken).
thread_local Uint64 t_threadShareGroupToken = 0;
Uint64 g_boundShareGroupToken = 0; // guarded by EGLOperationMutex
void EmitContextBinding(EGLStateContext* state, EGLContext switched, Uint64 previousToken) {
(void)previousToken;
if (MG_Config::Transport == MG_Config::TransportMode::Monolith) return;
// The apply thread IS the server in this process; a record emitted there would
// wait on the thread that has to apply it (EmitAndWait), which is a deadlock and
// not a slow path.
if (MG_Remote::Client::RunsAsTheServerRole()) return;
t_threadContextToken = switched == EGL_NO_CONTEXT ? 0 : state->GetContextClientToken(switched);
t_threadShareGroupToken = switched == EGL_NO_CONTEXT ? 0 : state->GetContextShareGroupToken(switched);
StreamBindCallingThreadLocked();
}
#endif
std::recursive_mutex& EGLOperationMutex() {
static std::recursive_mutex mutex;
return mutex;
}
#if MOBILEGL_BUILD_DISAGGREGATED
} // namespace
Bool StreamGateActive() {
return MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole();
}
std::recursive_mutex& StreamMutex() { return EGLOperationMutex(); }
void StreamBindCallingThreadLocked() {
const Uint64 token = t_threadContextToken;
if (token == g_boundContextToken) return;
if (MG_Remote::Client::EmitBindContextRecord(token)) {
g_boundContextToken = token;
g_boundShareGroupToken = t_threadShareGroupToken;
}
}
Bool StreamBoundShareGroupToken(Uint64* outToken) {
if (!StreamGateActive()) return false;
*outToken = g_boundShareGroupToken;
return true;
}
namespace {
#endif
String CurrentThreadIdString() {
std::ostringstream stream;
stream << std::this_thread::get_id();
return stream.str();
}
MG_Backend::WindowBackend DetectWindowBackend() {
#if defined(ANDROID) || defined(__ANDROID__)
return MG_Backend::WindowBackend::Android;
#elif defined(__APPLE__)
return MG_Backend::WindowBackend::MetalLayer;
#elif defined(_WIN32)
return MG_Backend::WindowBackend::Win32;
#elif defined(__linux__)
return MG_Backend::WindowBackend::X11;
#else
return MG_Backend::WindowBackend::Unknown;
#endif
}
EGLint GetAttribValue(const EGLint* attribList, EGLint attrib, EGLint defaultValue) {
if (!attribList) {
return defaultValue;
}
for (SizeT i = 0; attribList[i] != EGL_NONE; i += 2) {
if (attribList[i] == attrib) {
return attribList[i + 1];
}
}
return defaultValue;
}
EGLint GetAttribValueAttrib(const EGLAttrib* attribList, EGLint attrib, EGLint defaultValue) {
if (!attribList) {
return defaultValue;
}
for (SizeT i = 0; attribList[i] != EGL_NONE; i += 2) {
if (attribList[i] == attrib) {
return static_cast<EGLint>(attribList[i + 1]);
}
}
return defaultValue;
}
template <typename NativeType>
Bool IsNullNativeHandle(NativeType nativeHandle) {
if constexpr (std::is_pointer_v<NativeType>) {
return nativeHandle == nullptr;
} else {
return nativeHandle == 0;
}
}
template <typename NativeType>
void* ToVoidHandle(NativeType nativeHandle) {
if constexpr (std::is_pointer_v<NativeType>) {
return reinterpret_cast<void*>(nativeHandle);
} else {
return reinterpret_cast<void*>(static_cast<SizeT>(nativeHandle));
}
}
// EGL_KHR_partial_update: the surfaces whose application has declared a damage region. Their
// buffer-age query tells the server the region follows (a driver whose age is only
// partial_update's is then asked). Guarded by EGLOperationMutex; a destroyed surface leaves.
std::unordered_set<EGLSurface>& DamageRegionSurfaces() {
static auto* surfaces = new std::unordered_set<EGLSurface>();
return *surfaces;
}
// EGL_KHR_surfaceless_context. The EGL state records a surfaceless binding as exactly that
// (eglGetCurrentSurface answers EGL_NO_SURFACE), but every backend renders into the surface
// it was bound to, and a session's capabilities are published on its first bind to one. So
// the backend is bound to a 1x1 pbuffer of the display's own instead: one per display, made
// on the first surfaceless bind, never handed to the application, and gone with the display
// (eglTerminate). Guarded by EGLOperationMutex.
std::unordered_map<EGLDisplay, EGLSurface>& SurfacelessStandIns() {
static auto* standIns = new std::unordered_map<EGLDisplay, EGLSurface>();
return *standIns;
}
// eglCreatePbufferSurface for the stand-in, except that a split client creates it on the
// server as a stand-in, which takes no surface mode there (a server-owned window may follow).
EGLSurface CreateSurfacelessStandInPbuffer(EGLStateContext* state, EGLDisplay dpy, EGLConfig config,
const EGLint* attribs);
// The display's stand-in, made now if it has none (or the one it had did not survive).
// EGL_NO_SURFACE when the backend could not make a pbuffer; the EGL error is then set.
EGLSurface SurfacelessStandIn(EGLStateContext* state, EGLDisplay dpy) {
auto& standIns = SurfacelessStandIns();
if (const auto it = standIns.find(dpy); it != standIns.end()) {
if (state->ValidateSurfaceOnDisplay(dpy, it->second)) return it->second;
standIns.erase(it);
}
// Any of the display's configs will do: a stand-in is never read back or presented.
EGLConfig config = nullptr;
EGLint count = 0;
if (!state->GetConfigs(dpy, &config, 1, &count) || count < 1 || config == nullptr) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SURFACE;
}
const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
const EGLSurface standIn = CreateSurfacelessStandInPbuffer(state, dpy, config, attribs);
if (standIn != EGL_NO_SURFACE) standIns[dpy] = standIn;
return standIn;
}
#if MOBILEGL_WAYLAND_WINDOWS
// Every Wayland window surface's presentation, by surface. Guarded by EGLOperationMutex,
// which every entry point that reaches it holds.
UnorderedMap<EGLSurface, UniquePtr<Wayland::WindowSurface>>& WaylandSurfaces() {
static auto* surfaces = new UnorderedMap<EGLSurface, UniquePtr<Wayland::WindowSurface>>();
return *surfaces;
}
// A WINDOW ON A WAYLAND DISPLAY. Whatever MOBILEGL_IPC_SURFACE says, the window is this
// application's own wl_surface, so neither the server's window nor the display host's frame
// is what it shows: the backend draws into a pbuffer of the window's size, and each swap
// reads the frame back and attaches it to the wl_surface (WaylandWindow.h). Answers false
// when the display is not a Wayland one; otherwise *out is the surface, or EGL_NO_SURFACE
// with the error set.
// A gbm_surface is scanout memory of a device this library does not draw with; a window
// on a GBM display is refused rather than taken for some other kind of window.
template <typename State>
Bool RefuseGbmWindow(State* state, EGLDisplay dpy) {
constexpr EGLenum kPlatformGbm = 0x31D7; // EGL_PLATFORM_GBM_KHR == EGL_PLATFORM_GBM_MESA
Uint64 nativeDisplay = 0;
EGLenum platform = EGL_NONE;
if (!state->GetDisplayNative(dpy, &nativeDisplay, &platform) || platform != kPlatformGbm) return false;
MGLOG_W_ONCE("EGL: window surfaces on a GBM display are not supported (offscreen display only)");
state->SetError(EGL_BAD_NATIVE_WINDOW);
return true;
}
template <typename State>
Bool CreateWaylandWindowSurface(State* state, EGLDisplay dpy, EGLConfig config, void* window,
Bool platformWindow, EGLSurface* out) {
Uint64 nativeDisplay = 0;
EGLenum platform = EGL_NONE;
if (!state->GetDisplayNative(dpy, &nativeDisplay, &platform) ||
!Wayland::IsWaylandDisplay(nativeDisplay, platform)) {
return false;
}
*out = EGL_NO_SURFACE;
if (!state->IsDisplayInitialized(dpy)) {
state->SetError(EGL_NOT_INITIALIZED);
return true;
}
if (!state->ValidateConfigOnDisplay(dpy, config)) {
state->SetError(EGL_BAD_CONFIG);
return true;
}
EGLint width = 0;
EGLint height = 0;
if (!Wayland::WindowSize(window, &width, &height)) {
state->SetError(EGL_BAD_NATIVE_WINDOW);
return true;
}
EGLint alpha = 0;
(void)state->GetConfigAttrib(dpy, config, EGL_ALPHA_SIZE, &alpha);
auto presentation =
Wayland::WindowSurface::Create(reinterpret_cast<void*>(static_cast<uintptr_t>(nativeDisplay)), window,
width, height, alpha > 0);
if (!presentation) {
state->SetError(EGL_BAD_NATIVE_WINDOW);
return true;
}
const EGLSurface surface =
platformWindow ? state->CreatePlatformWindowSurface(dpy, config, window, nullptr)
: state->CreateWindowSurface(
dpy, config, (NativeWindowType)(reinterpret_cast<uintptr_t>(window)), nullptr);
if (surface == EGL_NO_SURFACE) return true;
(void)state->ResizeSurface(dpy, surface, width, height);
auto* backendObject = GetBackendObject(state);
if (!backendObject || !backendObject->CreateEGLPbufferSurface(surface, width, height)) {
MGLOG_E("eglCreateWindowSurface: the backend refused the %dx%d drawable behind a Wayland window",
width, height);
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_ALLOC);
return true;
}
WaylandSurfaces()[surface] = std::move(presentation);
*out = surface;
return true;
}
// A WAYLAND WINDOW THE APPLICATION RESIZED (wl_egl_window_resize). As with a driver's own
// window surface, the new size takes effect at the next make-current or swap: the EGL
// surface reports it, the wl_shm presentation adopts it, and the drawable behind it is
// resized so the frame rendered at the new size is the frame read back. Qt resizes the
// window and then makes the context current, so the make-current arm is the one it hits.
void ApplyWaylandResize(EGLStateContext* state, EGLDisplay dpy, EGLSurface surface) {
const auto it = WaylandSurfaces().find(surface);
if (it == WaylandSurfaces().end()) return;
EGLint width = 0;
EGLint height = 0;
if (!it->second->TakeResize(&width, &height)) return;
(void)state->ResizeSurface(dpy, surface, width, height);
auto* backendObject = MG_Backend::pActiveBackendObject.get();
if (backendObject == nullptr ||
!backendObject->ResizeEGLWindowSurface(surface, static_cast<Uint32>(width), static_cast<Uint32>(height))) {
MGLOG_E("Wayland: the drawable behind a %dx%d window could not be resized", width, height);
}
}
#endif
#if MOBILEGL_BUILD_DISAGGREGATED
using MG_Remote::Client::ClientSession;
// IS `context` LOST. It was built against a server session that has since ended (a device
// loss, recovered), or it lives on the session that is lost right now: either way its
// objects are on no server this process can reach, and EGL's answer for it is
// EGL_CONTEXT_LOST until the application destroys it.
Bool ContextIsLost(EGLStateContext* state, EGLContext context) {
if (!StreamGateActive() || context == EGL_NO_CONTEXT) return false;
const SharedPtr<MG_State::GLState::GLContext> glState = state->GetContextGLState(context);
if (!glState) return false;
return glState->IsFromEndedWireSession() || ClientSession::SessionLatchedLost();
}
// THE RECOVERY'S EGL HALF. The caller holds EGLOperationMutex - which every GL entry point
// takes too (GLStreamScope), so no other thread is in the middle of a GL call - and is an
// entry point an application reaches when it rebuilds after a loss: eglCreateContext,
// eglCreate*Surface, eglInitialize. A no-op unless the session is latched lost.
//
// 1. ClientSession ends the lost session and dials a fresh one; its FinishStartup forgets
// every client cache of the old one and moves the wire epoch, which is what makes every
// context built before lost (their objects die later without a word on the new wire).
// 2. The process default context and GL framebuffer 0 are rebuilt on the fresh session:
// every context created from now on starts with framebuffer 0 bound, and the old one's
// attachments are textures the fresh server never heard of.
// 3. The remote backend initializes the display again on the new server and forgets which
// surfaces and shared images the old one had; each surface is re-created there when it
// is next made current (EGL keeps surfaces across a power-management loss).
// 4. Wayland presentations drop the lost session's shared images and allocate new ones.
Bool RecoverLostSession() {
if (!StreamGateActive() || !ClientSession::SessionLatchedLost()) return true;
ClientSession* session = ClientSession::Active();
{
const ClientSession::ScopedWireMute mute;
if (session->RecoverAfterDeviceLoss() != MOBILEGL_OK) return false;
}
// Nothing is bound on the fresh session: the next thread that writes binds its own.
g_boundContextToken = 0;
g_boundShareGroupToken = 0;
const ClientSession::ScopedCurrentSessionWork work;
SharedPtr<MG_State::GLState::GLContext> lostDefault = MG_State::ReplaceProcessDefaultGLContext();
UniquePtr<MG_Impl::GLImpl::FramebufferImpl::DefaultFramebufferInfo> lostFramebuffer =
Move(MG_Impl::GLImpl::FramebufferImpl::pDefaultFramebufferInfo);
{
// Built into the new default context, whatever this thread has current (a lost
// context stays this thread's GL state until the application releases it).
SharedPtr<MG_State::GLState::GLContext> caller = MG_State::pGLContext;
MG_State::pGLContext = MG_State::ProcessDefaultGLContext();
MG_Impl::BuildDefaultFramebuffer();
MG_State::pGLContext = Move(caller);
}
{
const ClientSession::ScopedWireMute mute;
lostFramebuffer.reset();
lostDefault.reset();
}
if (auto* remote = dynamic_cast<MG_Remote::Client::BackendObject_Remote*>(MG_Backend::pActiveBackendObject.get()))
remote->OnSessionReplaced();
#if MOBILEGL_WAYLAND_WINDOWS
for (auto& [surface, presentation] : WaylandSurfaces()) presentation->OnSessionReplaced();
#endif
return true;
}
// THE SHARE GROUPS THAT REPLACE LOST ONES, by the lost group's token. An application that
// keeps one long-lived context to share with (Qt's global share context) recreates its
// other contexts after a loss still naming that context, which is lost and stays so. Those
// contexts are put in ONE new share group instead of each in a group of its own: the first
// starts it, the later ones share with a live member of it. Without this, every window of
// such an application lands in a separate share group after the loss, a shape the
// application never asked for. Guarded by EGLOperationMutex.
std::unordered_map<Uint64, Vector<EGLContext>>& ReplacementShareContexts() {
static auto* replacements = new std::unordered_map<Uint64, Vector<EGLContext>>();
return *replacements;
}
// The context a new context should share with in place of the lost `shareCtx`: a live
// member of the group that replaces the lost one, or EGL_NO_CONTEXT to start that group.
EGLContext ReplacementShareContext(EGLStateContext* state, EGLDisplay dpy, Uint64 lostGroup) {
Vector<EGLContext>& members = ReplacementShareContexts()[lostGroup];
members.erase(std::remove_if(members.begin(), members.end(),
[&](EGLContext member) {
return !state->ValidateContextOnDisplay(dpy, member) ||
ContextIsLost(state, member);
}),
members.end());
return members.empty() ? EGL_NO_CONTEXT : members.front();
}
void ForgetReplacementShareContext(EGLContext context) {
for (auto& [group, members] : ReplacementShareContexts())
members.erase(std::remove(members.begin(), members.end(), context), members.end());
}
// The surface entry points' guard: a surface created after a loss is created on a fresh
// session. EGL_BAD_ALLOC when no session could be brought up.
Bool RecoverBeforeCreatingSurface(EGLStateContext* state) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
if (RecoverLostSession()) return true;
state->SetError(EGL_BAD_ALLOC);
return false;
}
#endif
EGLSurface CreateSurfacelessStandInPbuffer(EGLStateContext* state, EGLDisplay dpy, EGLConfig config,
const EGLint* attribs) {
#if MOBILEGL_BUILD_DISAGGREGATED
auto* remote = dynamic_cast<MG_Remote::Client::BackendObject_Remote*>(GetBackendObject(state));
if (remote == nullptr) return CreatePbufferSurface(dpy, config, attribs);
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
const EGLSurface surface = state->CreatePbufferSurface(dpy, config, attribs);
if (surface == EGL_NO_SURFACE) return EGL_NO_SURFACE;
if (!remote->CreateEGLSurfacelessStandIn(surface, GetAttribValue(attribs, EGL_WIDTH, 1),
GetAttribValue(attribs, EGL_HEIGHT, 1))) {
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SURFACE;
}
return surface;
#else
return CreatePbufferSurface(dpy, config, attribs);
#endif
}
} // namespace
EGLSurface CreateWindowSurface(EGLDisplay dpy, EGLConfig config, NativeWindowType window,
const EGLint* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (RefuseGbmWindow(state, dpy)) return EGL_NO_SURFACE;
{
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
EGLSurface waylandSurface = EGL_NO_SURFACE;
if (CreateWaylandWindowSurface(state, dpy, config, ToVoidHandle(window), /*platformWindow=*/false,
&waylandSurface)) {
return waylandSurface;
}
}
#endif
if (!state->IsDisplayInitialized(dpy)) {
state->SetError(EGL_NOT_INITIALIZED);
return EGL_NO_SURFACE;
}
if (!state->ValidateConfigOnDisplay(dpy, config)) {
state->SetError(EGL_BAD_CONFIG);
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// P12 (on-screen server window), D1. With MOBILEGL_IPC_SURFACE=server and a remote server,
// the window is the SERVER's: a headless client passes none, so NULL is not
// EGL_BAD_NATIVE_WINDOW here. Whatever the client passed never reaches the wire - the
// remote backend sends WindowKind::ServerOwned with token 0 (BackendObject_Remote).
const Bool serverOwnedWindow = MG_Config::ServerOwnedWindowSurfaces();
if (IsNullNativeHandle(window) && !serverOwnedWindow) {
#else
if (IsNullNativeHandle(window)) {
#endif
state->SetError(EGL_BAD_NATIVE_WINDOW);
return EGL_NO_SURFACE;
}
Uint32 requestedWidth = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_WIDTH, 0), 0));
Uint32 requestedHeight = static_cast<Uint32>(std::max<EGLint>(GetAttribValue(attrib_list, EGL_HEIGHT, 0), 0));
#if MOBILEGL_BUILD_DISAGGREGATED && defined(__ANDROID__)
// P12: A GAME'S OWN WINDOW SIZE IS THE SIZE OF THE FRAMES IT RENDERS, and a server-owned
// window has to take that size or clip. SDL (Minecraft's Android backend) creates the EGL
// window surface with no EGL_WIDTH / EGL_HEIGHT, so the request went out as 0x0 - "use the
// server window's own size" - and a landscape 2620x1280 game drawn into a portrait 1280x2620
// server window came out clipped to its bottom-left 1280x1280 corner (Espryt and Magma
// alike; the same game in a landscape window was right). The native window it handed us
// knows the size the game believes it has: ask for THAT, and the server fixes its window
// buffer to it and aspect-fits the view (MobileGLDisplayActivity), letterboxed.
if (serverOwnedWindow && requestedWidth == 0 && requestedHeight == 0 && !IsNullNativeHandle(window)) {
auto* native = reinterpret_cast<ANativeWindow*>(ToVoidHandle(window));
const int32_t nativeWidth = ANativeWindow_getWidth(native);
const int32_t nativeHeight = ANativeWindow_getHeight(native);
if (nativeWidth > 0 && nativeHeight > 0) {
requestedWidth = static_cast<Uint32>(nativeWidth);
requestedHeight = static_cast<Uint32>(nativeHeight);
MGLOG_I("eglCreateWindowSurface: no EGL_WIDTH/EGL_HEIGHT; the server-owned window is asked for the "
"native window's %dx%d", nativeWidth, nativeHeight);
}
}
#endif
const MG_Backend::WindowHandle windowHandle = {
.Backend = DetectWindowBackend(),
.Handle = ToVoidHandle(window),
.Width = requestedWidth,
.Height = requestedHeight,
};
#if MOBILEGL_BUILD_DISAGGREGATED
EGLSurface surface = serverOwnedWindow
? state->CreateServerOwnedWindowSurface(
dpy, config, windowHandle.Handle, static_cast<EGLint>(windowHandle.Width),
static_cast<EGLint>(windowHandle.Height), /*platformWindow=*/false)
: state->CreateWindowSurface(dpy, config, window, attrib_list);
#else
EGLSurface surface = state->CreateWindowSurface(dpy, config, window, attrib_list);
#endif
if (surface == EGL_NO_SURFACE) {
return EGL_NO_SURFACE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
state->DestroySurface(dpy, surface);
return EGL_NO_SURFACE;
}
if (!backendObject->CreateEGLWindowSurface(surface, windowHandle)) {
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_NATIVE_WINDOW);
return EGL_NO_SURFACE;
}
return surface;
}
EGLBoolean SwapBuffers(EGLDisplay dpy, EGLSurface draw) { return SwapBuffersWithDamage(dpy, draw, nullptr, 0); }
// EGL_KHR/EXT_swap_buffers_with_damage. The rectangles (GL window coordinates, origin
// bottom-left; none = the whole surface) are clipped to the surface and fitted into a record.
// A Wayland window copies only what its shared image missed and damages only the frame's
// rectangles; a server-owned window hands them to the native present. Either way they are a
// hint about what changed, never a limit on what is shown.
EGLBoolean SwapBuffersWithDamage(EGLDisplay dpy, EGLSurface draw, const EGLint* rects, EGLint n_rects) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
#if MOBILEGL_BUILD_DISAGGREGATED
// The present is this thread's context's (GLStreamScope in EGLImpl.h).
if (StreamGateActive()) StreamBindCallingThreadLocked();
#endif
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, draw)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// A swap of a lost context's frame: EGL_CONTEXT_LOST (EGL 1.5 3.2), and nothing presented.
if (ContextIsLost(state, state->GetCurrentContext())) {
state->SetError(EGL_CONTEXT_LOST);
return EGL_FALSE;
}
#endif
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
return EGL_FALSE;
}
if (n_rects < 0 || (n_rects > 0 && rects == nullptr)) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
MG_Util::Damage::Region damage = MG_Util::Damage::Region::FromEglRects(rects, n_rects);
if (!damage.IsFull()) {
EGLint width = 0;
EGLint height = 0;
if (state->QuerySurface(dpy, draw, EGL_WIDTH, &width) && state->QuerySurface(dpy, draw, EGL_HEIGHT, &height)) {
damage.Normalize(width, height);
} else {
damage.SetFull();
}
}
#if MOBILEGL_WAYLAND_WINDOWS
// A Wayland window shows what is attached to it: the frame is read back and attached
// BEFORE the swap, while it is still the drawable's content.
if (auto it = WaylandSurfaces().find(draw);
it != WaylandSurfaces().end() && !it->second->Present(damage, state->GetSwapInterval(dpy))) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#endif
const Bool swapped = damage.IsFull() ? backendObject->SwapEGLBuffers(dpy, draw)
: backendObject->SwapEGLBuffersWithDamage(dpy, draw, damage);
if (!swapped) {
MGLOG_E_ONCE("eglSwapBuffers failed on thread=%s dpy=%p draw=%p", CurrentThreadIdString().c_str(), dpy, draw);
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#if MOBILEGL_WAYLAND_WINDOWS
// A resize made between frames takes effect for the next one.
ApplyWaylandResize(state, dpy, draw);
#endif
return EGL_TRUE;
}
EGLBoolean ChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size,
EGLint* num_config) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->ChooseConfig(dpy, attrib_list, configs, config_size, num_config) ? EGL_TRUE : EGL_FALSE;
}
EGLContext CreateContext(EGLDisplay dpy, EGLConfig config, EGLContext shareCtx, const EGLint* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_CONTEXT;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// AFTER A DEVICE LOSS THIS IS WHERE AN APPLICATION REBUILDS, so this is where a fresh
// session comes up (RecoverLostSession) - before the context's GL state is built, because
// building it already emits the creates of its default objects. Sharing with a lost
// context would share objects no reachable server holds.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
// The lost share group this context replaces (ReplacementShareContexts), 0 for none.
Uint64 replacedGroup = 0;
if (StreamGateActive()) {
if (!RecoverLostSession()) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_CONTEXT;
}
if (shareCtx != EGL_NO_CONTEXT && ContextIsLost(state, shareCtx)) {
// Its objects are on no server, so the context does not share them: it joins the
// group that replaces the lost one (the other contexts recreated in its place).
if (!state->ValidateContextOnDisplay(dpy, shareCtx)) {
state->SetError(EGL_BAD_CONTEXT);
return EGL_NO_CONTEXT;
}
replacedGroup = state->GetContextShareGroupToken(shareCtx);
const EGLContext lostShare = shareCtx;
shareCtx = ReplacementShareContext(state, dpy, replacedGroup);
MGLOG_I_ONCE("eglCreateContext: the share context %p was lost with its session (device loss); "
"contexts that name it share with each other in a new share group instead",
lostShare);
}
}
// The calling thread may still have a lost context current: what is built here is the
// fresh session's all the same.
const ClientSession::ScopedCurrentSessionWork currentSession;
#endif
EGLContext context = state->CreateContext(dpy, config, shareCtx, attrib_list);
if (context == EGL_NO_CONTEXT) {
return EGL_NO_CONTEXT;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (replacedGroup != 0) ReplacementShareContexts()[replacedGroup].push_back(context);
#endif
#if MOBILEGL_BUILD_DISAGGREGATED
// P14 S1 (docs/Disaggregated/design/11-state-ownership.md). THE TOKEN CROSSES BEFORE
// eglCreateContext RETURNS. EGLState minted it, together with the share group it was
// derived into (the sharing context's group, or a fresh one), and the server tables it
// here through the same blocking handshake the surface forwarders use - so the first
// bind_context after this call names a context the session already has, and the
// sink's "this session never created that token" refusal is unreachable on the
// well-behaved path.
//
// A REFUSAL DROPS THE CLIENT'S CONTEXT AGAIN. Keeping it would hand the application a
// handle whose first verb the server refuses - a late failure where an early one is
// available, and EGL_NO_CONTEXT with EGL_BAD_ACCESS is the early one. NoWire (the
// pre-Start bring-up, the server role) keeps it: there is no server to refuse.
if (MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole()) {
auto emitted = MG_Remote::Client::SendCreateContextFrame(
state->GetContextClientToken(context), state->GetContextShareGroupToken(context), 0);
// THE LOSS CAN BE FOUND OUT HERE: a session whose server is gone, which nothing had
// noticed yet, refuses the create by hanging up on it. That is the loss, not a refusal:
// the half-built context goes (its objects silently - they were never on any server),
// a fresh session comes up, and the context is built again on it, once.
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused && ClientSession::SessionLatchedLost()) {
{
const ClientSession::ScopedWireMute mute;
state->DestroyContext(dpy, context);
}
context = EGL_NO_CONTEXT;
if (RecoverLostSession()) {
// The context it was to share with went with the session, too.
if (shareCtx != EGL_NO_CONTEXT && ContextIsLost(state, shareCtx)) {
replacedGroup = state->GetContextShareGroupToken(shareCtx);
shareCtx = ReplacementShareContext(state, dpy, replacedGroup);
}
context = state->CreateContext(dpy, config, shareCtx, attrib_list);
}
if (context == EGL_NO_CONTEXT) {
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_CONTEXT;
}
if (replacedGroup != 0) ReplacementShareContexts()[replacedGroup].push_back(context);
emitted = MG_Remote::Client::SendCreateContextFrame(state->GetContextClientToken(context),
state->GetContextShareGroupToken(context), 0);
}
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused) {
state->DestroyContext(dpy, context);
state->SetError(EGL_BAD_ACCESS);
return EGL_NO_CONTEXT;
}
}
#endif
return context;
}
EGLBoolean Initialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
auto* state = GetStateEnsureInitialized();
if (!state) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// An application that re-initializes a display after a loss (without the eglTerminate that
// would have torn the library down) gets a fresh session here, as eglCreateContext would.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
(void)RecoverLostSession();
#endif
if (!state->InitializeDisplay(dpy, major, minor)) {
return EGL_FALSE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
return EGL_FALSE;
}
if (!backendObject->InitializeEGLDisplay(dpy, major, minor)) {
state->SetError(EGL_NOT_INITIALIZED);
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLDisplay GetDisplay(NativeDisplayType display) {
// Before the bring-up, which would wait for a configured server that is not there: no
// display is better than one that cannot draw, and the caller may have another EGL.
if (!MobileGL::ImplementationAvailable()) {
return EGL_NO_DISPLAY;
}
auto* state = GetStateEnsureInitialized();
if (!state) {
return EGL_NO_DISPLAY;
}
return state->GetDisplay(display);
}
EGLint GetError() {
auto* state = GetState();
if (!state) {
return EGL_NOT_INITIALIZED;
}
return state->ConsumeError();
}
EGLBoolean MakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
const auto oldDisplay = state->GetCurrentDisplay();
const auto oldDraw = state->GetCurrentSurface(EGL_DRAW);
const auto oldRead = state->GetCurrentSurface(EGL_READ);
const auto oldContext = state->GetCurrentContext();
#if MOBILEGL_BUILD_DISAGGREGATED
// P14 S1. The context the calling thread had current BEFORE this call, as the wire
// knows it. Read here because `state->MakeCurrent` below has already committed the
// new one by the time the emission points are reached.
const Uint64 oldContextToken = state->GetContextClientToken(oldContext);
#endif
const String threadId = CurrentThreadIdString();
MGLOG_D("eglMakeCurrent begin thread=%s dpy=%p draw=%p read=%p ctx=%p oldDpy=%p oldDraw=%p oldRead=%p oldCtx=%p",
threadId.c_str(), dpy, draw, read, ctx, oldDisplay, oldDraw, oldRead, oldContext);
#if MOBILEGL_BUILD_DISAGGREGATED
// EGL 1.5 3.7.3 / 3.2: after a power-management event - a lost device, here - making a
// context created before it current fails with EGL_CONTEXT_LOST. The application destroys
// it and creates another; a release, and every context created since, go on as usual.
if (ctx != EGL_NO_CONTEXT && ContextIsLost(state, ctx)) {
// Once per process: an application that keeps binding the context it lost (instead of
// destroying it and creating another) never reaches the recovery.
MGLOG_I_ONCE("eglMakeCurrent: context %p was lost with its session (device loss): EGL_CONTEXT_LOST "
"until the application destroys it; a context created after the loss gets a fresh session",
ctx);
state->SetError(EGL_CONTEXT_LOST);
return EGL_FALSE;
}
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (draw != EGL_NO_SURFACE) ApplyWaylandResize(state, dpy, draw);
#endif
if (!state->MakeCurrent(dpy, draw, read, ctx)) {
const EGLint error = state->ConsumeError();
MGLOG_D("eglMakeCurrent rejected by EGLState thread=%s error=0x%04x", threadId.c_str(), error);
state->SetError(error);
return EGL_FALSE;
}
const Bool releaseCurrentRequest =
draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE && ctx == EGL_NO_CONTEXT;
if (releaseCurrentRequest) {
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
if (!backendObject->MakeEGLCurrent(dpy, draw, read, ctx)) {
MGLOG_E_ONCE("eglMakeCurrent release failed in backend thread=%s", threadId.c_str());
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
state->SetError(EGL_BAD_ACCESS);
return EGL_FALSE;
}
}
MGLOG_D("eglMakeCurrent release succeeded thread=%s", threadId.c_str());
#if MOBILEGL_BUILD_DISAGGREGATED
EmitContextBinding(state, EGL_NO_CONTEXT, oldContextToken);
#endif
return EGL_TRUE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
return EGL_FALSE;
}
// A surfaceless binding (EGL_KHR_surfaceless_context; EGLState took it above and records
// EGL_NO_SURFACE): the backend gets the display's stand-in pbuffer to render into.
EGLSurface backendDraw = draw;
EGLSurface backendRead = read;
if (draw == EGL_NO_SURFACE && read == EGL_NO_SURFACE) {
backendDraw = backendRead = SurfacelessStandIn(state, dpy);
if (backendDraw == EGL_NO_SURFACE) {
const EGLint error = state->ConsumeError();
MGLOG_E_ONCE("eglMakeCurrent: no stand-in pbuffer for a surfaceless binding thread=%s (error=0x%04x)",
threadId.c_str(), error);
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
state->SetError(error != EGL_SUCCESS ? error : EGL_BAD_ALLOC);
return EGL_FALSE;
}
}
if (!backendObject->MakeEGLCurrent(dpy, backendDraw, backendRead, ctx)) {
MGLOG_E_ONCE("eglMakeCurrent backend attach failed thread=%s dpy=%p draw=%p read=%p ctx=%p", threadId.c_str(),
dpy, draw, read, ctx);
state->SetError(EGL_BAD_ACCESS);
state->MakeCurrent(oldDisplay, oldDraw, oldRead, oldContext);
return EGL_FALSE;
}
MGLOG_D("eglMakeCurrent attach succeeded thread=%s dpy=%p draw=%p read=%p ctx=%p", threadId.c_str(), dpy, draw,
read, ctx);
#if MOBILEGL_BUILD_DISAGGREGATED
EmitContextBinding(state, ctx, oldContextToken);
#endif
return EGL_TRUE;
}
EGLBoolean DestroyContext(EGLDisplay dpy, EGLContext ctx) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
// P14 S1. Read BEFORE the client's own book drops the context: after DestroyContext
// the handle no longer resolves and the token is unrecoverable. The frame is sent
// AFTER the client's state machine has accepted the destroy, so one EGL refused (a
// context still current on some thread, EGL_BAD_ACCESS) never reaches the server - the
// two ends stay in step without the server having to guess why a token vanished.
const Uint64 contextToken = state->GetContextClientToken(ctx);
// A LOST CONTEXT IS DESTROYED IN SILENCE. Its objects die here, and a death that reached
// the wire would land on whichever session is current now - a fresh one after a recovery,
// which never created them. Under the operation lock, like every GL call.
const std::lock_guard<std::recursive_mutex> destroyLock(EGLOperationMutex());
const Bool lost = ContextIsLost(state, ctx);
std::optional<ClientSession::ScopedWireMute> silence;
if (lost) silence.emplace();
#endif
if (!state->DestroyContext(dpy, ctx)) {
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
ForgetReplacementShareContext(ctx);
if (contextToken != 0 && !lost && MG_Config::Transport != MG_Config::TransportMode::Monolith &&
!MG_Remote::Client::RunsAsTheServerRole()) {
const std::lock_guard<std::recursive_mutex> streamLock(EGLOperationMutex());
// The server drops its binding to 0 when the current context is destroyed
// (ServerSession::DestroyContext's compare-and-swap); the gate mirrors it so the next
// write re-binds.
if (g_boundContextToken == contextToken) {
g_boundContextToken = 0;
g_boundShareGroupToken = 0;
}
const auto emitted = MG_Remote::Client::SendDestroyContextFrame(contextToken);
if (emitted == MG_Remote::Client::ContextFrameEmit::Refused) {
MGLOG_E_ONCE("eglDestroyContext: the server holds no context token %llu; the "
"session's table and this client's EGL book have drifted apart",
static_cast<unsigned long long>(contextToken));
}
}
#endif
return EGL_TRUE;
}
EGLBoolean DestroySurface(EGLDisplay dpy, EGLSurface surface) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->DestroySurface(dpy, surface)) {
return EGL_FALSE;
}
DamageRegionSurfaces().erase(surface);
#if MOBILEGL_WAYLAND_WINDOWS
WaylandSurfaces().erase(surface);
#endif
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
backendObject->ReleaseEGLSurface(surface);
}
return EGL_TRUE;
}
EGLBoolean Terminate(EGLDisplay dpy) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->TerminateDisplay(dpy)) {
return EGL_FALSE;
}
{
// The display's surfaces went with it, its surfaceless stand-in among them; the backend
// side goes with ReleaseEGLResources below.
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
SurfacelessStandIns().erase(dpy);
}
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
// The display's dma-buf EGLImages went with it; so do their shared-image references.
for (const Uint64 sharedImageId : state->TakeOrphanedSharedImages()) {
(void)backendObject->ReleaseSharedImage(sharedImageId);
}
backendObject->ReleaseEGLResources();
}
// The last initialized display is gone and nothing is current on any
// thread: tear the whole library down deterministically inside the
// EGL lifecycle (backend, GL/EGL state, glslang). A later EGL call
// re-initializes lazily via GetStateEnsureInitialized(); process exit
// then has nothing left to destroy.
if (!state->HasAnyInitializedDisplay() && !state->HasAnyCurrentContext()) {
// P14 S3: the process default context (and with it the GL objects the frontend
// built while no EGL context was current) goes before Destroy() does, so nothing
// it owns outlives glslang::FinalizeProcess() through a thread's fallback binding.
MG_State::ReleaseProcessDefaultGLContext();
MobileGL::Destroy();
}
return EGL_TRUE;
}
EGLBoolean ReleaseThread() {
// Always succeeds (EGL 1.4 §3.11): after the last eglTerminate tore MobileGL down there is
// simply nothing of this thread's left to release.
if (!MG_State::pEGLContext) return EGL_TRUE;
auto* state = GetState();
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
(void)backendObject->MakeEGLCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
state->ReleaseThread();
return EGL_TRUE;
}
EGLContext GetCurrentContext() {
auto* state = GetState();
if (!state) {
return EGL_NO_CONTEXT;
}
return state->GetCurrentContext();
}
EGLBoolean GetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->GetConfigAttrib(dpy, config, attribute, value) ? EGL_TRUE : EGL_FALSE;
}
EGLBoolean BindAPI(EGLenum api) {
auto* state = GetStateEnsureInitialized();
if (!state) {
return EGL_FALSE;
}
switch (api) {
case EGL_OPENGL_API:
case EGL_OPENGL_ES_API:
case EGL_OPENVG_API:
state->SetBoundAPI(api);
return EGL_TRUE;
default:
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
}
EGLSurface GetCurrentSurface(EGLint readdraw) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
return state->GetCurrentSurface(readdraw);
}
EGLBoolean QuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
// EGL_EXT_buffer_age. The buffers are the server's, so the server answers - in the stream,
// behind the records already written, for the buffer the next frame draws into. Only for the
// calling thread's draw surface: that is the buffer the question is about (and the stream is
// bound to its context).
if (attribute == EGL_BUFFER_AGE_EXT) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
if (!SharedImagesAvailable()) {
state->SetError(EGL_BAD_ATTRIBUTE);
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(display, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (value == nullptr) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
if (state->GetCurrentSurface(EGL_DRAW) != surface) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (StreamGateActive()) StreamBindCallingThreadLocked();
#endif
EGLint age = 0;
auto* backendObject = MG_Backend::pActiveBackendObject.get();
const Bool regionFollows = DamageRegionSurfaces().count(surface) != 0;
if (backendObject == nullptr || !backendObject->QueryBufferAge(regionFollows, &age)) age = 0;
*value = age;
return EGL_TRUE;
}
// A size that changes under the application (a server-owned window resized) arrives from the
// backend: let it bring the surface's record up to date first, so a caller that polls the size
// while it draws nothing still sees the change.
if (attribute == EGL_WIDTH || attribute == EGL_HEIGHT) {
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) backendObject->RefreshSurfaceExtent(surface);
}
return state->QuerySurface(display, surface, attribute, value) ? EGL_TRUE : EGL_FALSE;
}
// EGL_KHR_partial_update: the region this frame draws, before it draws (GL window coordinates;
// none = the whole surface). Forwarded in the stream to the server's native surface. More than
// kMaxRects rectangles are merged, so an application declaring that many draws their bounds.
EGLBoolean SetDamageRegion(EGLDisplay dpy, EGLSurface surface, const EGLint* rects, EGLint n_rects) {
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
auto* state = GetState();
if (!state) return EGL_FALSE;
if (!SharedImagesAvailable()) {
state->SetError(EGL_BAD_DISPLAY);
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (state->GetCurrentSurface(EGL_DRAW) != surface) {
state->SetError(EGL_BAD_MATCH);
return EGL_FALSE;
}
if (n_rects < 0 || (n_rects > 0 && rects == nullptr)) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
MG_Util::Damage::Region region = MG_Util::Damage::Region::FromEglRects(rects, n_rects);
if (!region.IsFull()) {
EGLint width = 0;
EGLint height = 0;
if (state->QuerySurface(dpy, surface, EGL_WIDTH, &width) && state->QuerySurface(dpy, surface, EGL_HEIGHT, &height))
region.Normalize(width, height);
else
region.SetFull();
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (StreamGateActive()) StreamBindCallingThreadLocked();
#endif
DamageRegionSurfaces().insert(surface);
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) (void)backendObject->SetDamageRegion(region);
return EGL_TRUE;
}
char const* QueryString(EGLDisplay display, EGLint name) {
// THE CLIENT QUERIES BRING NOTHING UP. A dispatcher with several vendors asks every one of
// them for its client extensions before it picks one, so answering this must not cost a
// session - nor wait for a server that is not there.
if (display == EGL_NO_DISPLAY) {
switch (name) {
case EGL_VENDOR:
return "MobileGL";
case EGL_VERSION:
return "1.5 MobileGL";
case EGL_CLIENT_APIS:
return "OpenGL OpenGL_ES";
case EGL_EXTENSIONS:
return kClientExtensionString;
default:
if (auto* state = MG_State::pEGLContext.get()) state->SetError(EGL_BAD_PARAMETER);
return nullptr;
}
}
auto* state = GetStateEnsureInitialized();
if (!state) {
return nullptr;
}
if (display != EGL_NO_DISPLAY && !state->ValidateDisplay(display)) {
state->SetError(EGL_BAD_DISPLAY);
return nullptr;
}
switch (name) {
case EGL_VENDOR:
return "MobileGL";
case EGL_VERSION:
return "1.5 MobileGL";
case EGL_CLIENT_APIS:
return "OpenGL OpenGL_ES";
case EGL_EXTENSIONS:
// One list, in EGLPlatformExtensions.h, because the vendor string glvnd reads and
// this query an application reads have to agree: an application that does not see the
// platform extension here never asks for a platform display at all.
if (display == EGL_NO_DISPLAY) return kClientExtensionString;
return SharedImagesAvailable() ? kDisplayExtensionStringWithSharedImages : kDisplayExtensionString;
default:
state->SetError(EGL_BAD_PARAMETER);
return nullptr;
}
}
EGLBoolean SwapInterval(EGLDisplay dpy, EGLint interval) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->SwapInterval(dpy, interval)) {
return EGL_FALSE;
}
// Forward the request to the backend's native presentation path; without this
// the app's vsync setting only ever reaches MobileGL's shadow state and the
// native surface stays at the driver default (interval 1 = always vsynced).
auto* backendObject = GetBackendObject(state);
if (backendObject) {
backendObject->SetEGLSwapInterval(static_cast<Int>(interval));
}
return EGL_TRUE;
}
EGLSurface CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
const EGLint width = GetAttribValue(attrib_list, EGL_WIDTH, 1);
const EGLint height = GetAttribValue(attrib_list, EGL_HEIGHT, 1);
EGLSurface surface = state->CreatePbufferSurface(dpy, config, attrib_list);
if (surface == EGL_NO_SURFACE) {
return EGL_NO_SURFACE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
return EGL_NO_SURFACE;
}
if (!backendObject->CreateEGLPbufferSurface(surface, width, height)) {
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_ALLOC);
return EGL_NO_SURFACE;
}
return surface;
}
EGLBoolean BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (buffer != EGL_BACK_BUFFER) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLBoolean ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (buffer != EGL_BACK_BUFFER) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLBoolean CopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
if (IsNullNativeHandle(target)) {
state->SetError(EGL_BAD_NATIVE_PIXMAP);
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLSurface CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config,
const EGLint* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
return state->CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
}
EGLSurface CreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap,
const EGLint* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
return state->CreatePixmapSurface(dpy, config, pixmap, attrib_list);
}
EGLBoolean GetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->GetConfigs(dpy, configs, config_size, num_config) ? EGL_TRUE : EGL_FALSE;
}
EGLDisplay GetCurrentDisplay() {
auto* state = GetState();
if (!state) {
return EGL_NO_DISPLAY;
}
return state->GetCurrentDisplay();
}
EGLenum QueryAPI() {
auto* state = GetState();
if (!state) {
return EGL_OPENGL_API;
}
return state->GetBoundAPI();
}
EGLBoolean QueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->QueryContext(dpy, ctx, attribute, value) ? EGL_TRUE : EGL_FALSE;
}
EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
(void)value;
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ValidateSurfaceOnDisplay(dpy, surface)) {
state->SetError(EGL_BAD_SURFACE);
return EGL_FALSE;
}
switch (attribute) {
case EGL_MIPMAP_LEVEL:
case EGL_SWAP_BEHAVIOR:
case EGL_TEXTURE_FORMAT:
case EGL_TEXTURE_TARGET:
case EGL_MIPMAP_TEXTURE:
return EGL_TRUE;
default:
state->SetError(EGL_BAD_ATTRIBUTE);
return EGL_FALSE;
}
}
EGLBoolean WaitClient() {
return EGL_TRUE;
}
EGLBoolean WaitGL() {
return EGL_TRUE;
}
EGLBoolean WaitNative(EGLint engine) {
(void)engine;
return EGL_TRUE;
}
EGLSync CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SYNC;
}
return state->CreateSync(dpy, type, attrib_list);
}
EGLBoolean DestroySync(EGLDisplay dpy, EGLSync sync) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->DestroySync(dpy, sync) ? EGL_TRUE : EGL_FALSE;
}
EGLint ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->ClientWaitSync(dpy, sync, flags, timeout);
}
EGLBoolean GetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib* value) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->GetSyncAttrib(dpy, sync, attribute, value) ? EGL_TRUE : EGL_FALSE;
}
Bool SharedImagesAvailable() {
#if MOBILEGL_BUILD_DISAGGREGATED
// A split client's backend is the remote one, which forwards the shared-image verbs to
// the server; the server's own apply thread and a monolith have no allocator behind them.
return StreamGateActive() && MG_Backend::pActiveBackendObject != nullptr;
#else
return false;
#endif
}
Bool LookupSharedImage(EGLImage image, Uint64* id, EGLint* width, EGLint* height) {
auto* state = GetState();
MG_State::EGLState::EGLContext::SharedImageInfo info;
if (!state || !state->GetSharedImage(image, &info)) return false;
*id = info.Id;
*width = info.Width;
*height = info.Height;
return true;
}
EGLImage CreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer,
const EGLAttrib* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_IMAGE;
}
if (target != EGL_LINUX_DMA_BUF_EXT) {
return state->CreateImage(dpy, ctx, target, buffer, attrib_list);
}
// EGL_EXT_image_dma_buf_import. The only dma-bufs this library can bind are the server's
// own shared images (a client's linux-dmabuf wl_buffer): the descriptor goes to the
// server, which names the image it was exported from, or refuses it.
if (!SharedImagesAvailable()) {
state->SetError(EGL_BAD_PARAMETER);
return EGL_NO_IMAGE;
}
MG_State::EGLState::EGLContext::DmaBufImportAttribs request;
if (!state->PrepareDmaBufImport(dpy, ctx, buffer, attrib_list, &request)) {
return EGL_NO_IMAGE;
}
auto* backendObject = GetBackendObject(state);
Uint64 sharedImageId = 0;
if (!backendObject ||
!backendObject->ImportSharedImage(request.Fd, static_cast<Uint32>(request.Width),
static_cast<Uint32>(request.Height), request.Fourcc, &sharedImageId) ||
sharedImageId == 0) {
MGLOG_I_ONCE("eglCreateImage: a %dx%d dma-buf is not one of the server's shared images; refused "
"(EGL_BAD_MATCH)",
request.Width, request.Height);
state->SetError(EGL_BAD_MATCH);
return EGL_NO_IMAGE;
}
const EGLImage image = state->CreateSharedImage(
dpy, {.Id = sharedImageId, .Width = request.Width, .Height = request.Height, .Fourcc = request.Fourcc});
if (image == EGL_NO_IMAGE) (void)backendObject->ReleaseSharedImage(sharedImageId);
return image;
}
EGLBoolean DestroyImage(EGLDisplay dpy, EGLImage image) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
Uint64 sharedImageId = 0;
if (!state->DestroyImage(dpy, image, &sharedImageId)) {
return EGL_FALSE;
}
// A texture the image was bound to keeps its own reference on the server (EGLImage
// siblings outlive the image), so only this handle's goes.
if (sharedImageId != 0) {
if (auto* backendObject = MG_Backend::pActiveBackendObject.get()) {
(void)backendObject->ReleaseSharedImage(sharedImageId);
}
}
return EGL_TRUE;
}
EGLBoolean QueryDmaBufFormats(EGLDisplay dpy, EGLint max_formats, EGLint* formats, EGLint* num_formats) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->QueryDmaBufFormats(dpy, SharedImagesAvailable(), max_formats, formats, num_formats)
? EGL_TRUE
: EGL_FALSE;
}
EGLBoolean QueryDmaBufModifiers(EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR* modifiers,
EGLBoolean* external_only, EGLint* num_modifiers) {
static_assert(sizeof(EGLuint64KHR) == sizeof(Uint64));
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->QueryDmaBufModifiers(dpy, SharedImagesAvailable(), format, max_modifiers,
reinterpret_cast<Uint64*>(modifiers), external_only, num_modifiers)
? EGL_TRUE
: EGL_FALSE;
}
EGLDisplay GetPlatformDisplay(EGLenum platform, void* native_display, const EGLAttrib* attrib_list) {
(void)attrib_list;
// As GetDisplay.
constexpr EGLenum kPlatformGbm = 0x31D7;
#if MOBILEGL_WAYLAND_WINDOWS
// A "GBM" display whose native display is a wl_display is a Wayland one: Chromium's
// Wayland GL layer names the GBM platform for every display it asks for, including the
// one on its own Wayland connection whose windows are wl_egl_windows.
if (platform == kPlatformGbm && native_display != nullptr &&
Wayland::IsWaylandDisplay(reinterpret_cast<Uint64>(native_display), EGL_NONE)) {
platform = Wayland::kPlatformWayland;
}
#endif
#if defined(__linux__) && !defined(__ANDROID__)
// A GBM device some other backend created (the system's own driver's) is not one this
// implementation can draw for: its buffers come from that driver, never from the server.
// Declined before anything is brought up, so a loader with more than one EGL vendor hands
// the device to the one it belongs to. Only a device whose backend names itself is asked
// about; one from a loader too old to say is served as before.
if (platform == kPlatformGbm && native_display != nullptr) {
using BackendNameFn = const char* (*)(void*);
static const auto backendName =
reinterpret_cast<BackendNameFn>(dlsym(RTLD_DEFAULT, "gbm_device_get_backend_name"));
const char* name = backendName != nullptr ? backendName(native_display) : nullptr;
if (name != nullptr && std::strcmp(name, "mobilegl") != 0) {
return EGL_NO_DISPLAY;
}
}
#endif
if (!MobileGL::ImplementationAvailable()) {
return EGL_NO_DISPLAY;
}
auto* state = GetStateEnsureInitialized();
if (!state) {
return EGL_NO_DISPLAY;
}
return state->GetPlatformDisplay(platform, native_display);
}
EGLSurface CreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void* native_window,
const EGLAttrib* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
#if MOBILEGL_BUILD_DISAGGREGATED
if (!RecoverBeforeCreatingSurface(state)) return EGL_NO_SURFACE;
#endif
#if MOBILEGL_WAYLAND_WINDOWS
if (RefuseGbmWindow(state, dpy)) return EGL_NO_SURFACE;
{
const std::lock_guard<std::recursive_mutex> operationLock(EGLOperationMutex());
EGLSurface waylandSurface = EGL_NO_SURFACE;
if (CreateWaylandWindowSurface(state, dpy, config, native_window, /*platformWindow=*/true,
&waylandSurface)) {
return waylandSurface;
}
}
#endif
#if MOBILEGL_BUILD_DISAGGREGATED
// P12 (on-screen server window), D1: as CreateWindowSurface - with MOBILEGL_IPC_SURFACE=server
// the window is the server's, and a headless client's NULL is accepted.
const Bool serverOwnedWindow = MG_Config::ServerOwnedWindowSurfaces();
if (native_window == nullptr && !serverOwnedWindow) {
#else
if (native_window == nullptr) {
#endif
state->SetError(EGL_BAD_NATIVE_WINDOW);
return EGL_NO_SURFACE;
}
if (!state->IsDisplayInitialized(dpy)) {
state->SetError(EGL_NOT_INITIALIZED);
return EGL_NO_SURFACE;
}
if (!state->ValidateConfigOnDisplay(dpy, config)) {
state->SetError(EGL_BAD_CONFIG);
return EGL_NO_SURFACE;
}
const MG_Backend::WindowHandle windowHandle = {
.Backend = DetectWindowBackend(),
.Handle = native_window,
.Width = static_cast<Uint32>(std::max<EGLint>(GetAttribValueAttrib(attrib_list, EGL_WIDTH, 0), 0)),
.Height = static_cast<Uint32>(std::max<EGLint>(GetAttribValueAttrib(attrib_list, EGL_HEIGHT, 0), 0)),
};
#if MOBILEGL_BUILD_DISAGGREGATED
EGLSurface surface = serverOwnedWindow
? state->CreateServerOwnedWindowSurface(
dpy, config, native_window, static_cast<EGLint>(windowHandle.Width),
static_cast<EGLint>(windowHandle.Height), /*platformWindow=*/true)
: state->CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
#else
EGLSurface surface = state->CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
#endif
if (surface == EGL_NO_SURFACE) {
return EGL_NO_SURFACE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
state->DestroySurface(dpy, surface);
return EGL_NO_SURFACE;
}
if (!backendObject->CreateEGLWindowSurface(surface, windowHandle)) {
state->DestroySurface(dpy, surface);
state->SetError(EGL_BAD_NATIVE_WINDOW);
return EGL_NO_SURFACE;
}
return surface;
}
EGLBoolean ResizePlatformWindowSurface(EGLDisplay dpy, EGLSurface surface, EGLint width, EGLint height) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
if (!state->ResizeSurface(dpy, surface, width, height)) {
return EGL_FALSE;
}
auto* backendObject = GetBackendObject(state);
if (!backendObject) {
MGLOG_E_ONCE("activeBackendObject not initialized!");
return EGL_FALSE;
}
width = std::max<EGLint>(width, 1);
height = std::max<EGLint>(height, 1);
if (!backendObject->ResizeEGLWindowSurface(surface, static_cast<Uint32>(width), static_cast<Uint32>(height))) {
state->SetError(EGL_BAD_NATIVE_WINDOW);
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLSurface CreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void* native_pixmap,
const EGLAttrib* attrib_list) {
auto* state = GetState();
if (!state) {
return EGL_NO_SURFACE;
}
return state->CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
}
EGLBoolean WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) {
auto* state = GetState();
if (!state) {
return EGL_FALSE;
}
return state->WaitSync(dpy, sync, flags) ? EGL_TRUE : EGL_FALSE;
}
__eglMustCastToProperFunctionPointerType GetProcAddress(const char* name) {
if (!name) {
return nullptr;
}
// The answer is a static table; the bring-up is only the lazy-initialization contract, and
// it is skipped when there is no server to bring up against (see GetStateEnsureInitialized).
if (MobileGL::ImplementationAvailable()) {
MobileGL::EnsureInitialized();
}
MGLOG_D("eglGetProcAddress(%s)", name);
void* proc = MG_Impl::GetProcAddress(name);
if (!proc) {
MGLOG_D("Failed to get function: %s", name);
return nullptr;
}
return (__eglMustCastToProperFunctionPointerType)proc;
}
} // namespace MobileGL::MG_Impl::EGLImpl
Reference in New Issue View Git Blame Copy Permalink