OpenHarmony-v4.1-Release/s

/*
 * Copyright (C) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#if RENDER_HAS_GLES_BACKEND

#include "egl_state.h"

#include <EGL/egl.h>
#include <EGL/eglext.h>

#ifndef EGL_VERSION_1_5
// If egl 1.5 headers not available, just define the values here.
// (copied from khronos specifications)
#define EGL_CONTEXT_MAJOR_VERSION 0x3098
#define EGL_CONTEXT_MINOR_VERSION 0x30FB
#define EGL_OPENGL_ES3_BIT 0x00000040
#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
#define EGL_GL_COLORSPACE 0x309D
#define EGL_GL_COLORSPACE_SRGB 0x3089
#define EGL_GL_COLORSPACE_LINEAR 0x308A
typedef intptr_t EGLAttrib;
#endif

#ifndef EGL_KHR_create_context
// If EGL_KHR_create_context extension not defined in headers, so just define the values here.
// (copied from khronos specifications)
#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#define EGL_OPENGL_ES3_BIT_KHR 0x00000040
#endif

#ifndef EGL_KHR_gl_colorspace
// If EGL_KHR_gl_colorspace extension not defined in headers, so just define the values here.
// (copied from khronos specifications)
#define EGL_GL_COLORSPACE_KHR 0x309D
#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
#define EGL_GL_COLORSPACE_LINEAR_KHR 0x308A
#endif /* EGL_KHR_gl_colorspace */

#ifndef EGL_KHR_no_config_context
// If #ifndef EGL_KHR_no_config_context extension not defined in headers, so just define the values here.
// (copied from khronos specifications)
#define EGL_NO_CONFIG_KHR ((EGLConfig)0)
#endif

#include <securec.h>

#include <render/namespace.h>

#include "gles/gl_functions.h"
#include "util/log.h"
#define declare(a, b) a b = nullptr;
#include "gles/gl_functions.h"
#include "gles/surface_information.h"
#include "gles/swapchain_gles.h"

#if RENDER_GL_DEBUG
#define CHECK_EGL_ERROR() EGLHelpers::CheckEGLError(__FILE__, __LINE__)
#define CHECK_EGL_ERROR2() EGLHelpers::CheckEGLError2(__FILE__, __LINE__)
#else
#define CHECK_EGL_ERROR()
#define CHECK_EGL_ERROR2() EGLHelpers::CheckEGLError2(__FILE__, __LINE__)
#endif

RENDER_BEGIN_NAMESPACE()
using BASE_NS::string;
using BASE_NS::string_view;
using BASE_NS::vector;

namespace EGLHelpers {
namespace {
bool FilterError(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar*, const void*) noexcept
{
    return false;
}

const char* EglErrorStr(EGLint aError)
{
    switch (aError) {
        case EGL_SUCCESS:
            return "The last function succeeded without error.";
        case EGL_NOT_INITIALIZED:
            return "EGL is not initialized, or could not be initialized, for the specified EGL display connection.";
        case EGL_BAD_ACCESS:
            return "EGL cannot access a requested resource(for example a context is bound in another thread).";
        case EGL_BAD_ALLOC:
            return "EGL failed to allocate resources for the requested operation.";
        case EGL_BAD_ATTRIBUTE:
            return "An unrecognized attribute or attribute value was passed in the attribute list.";
        case EGL_BAD_CONTEXT:
            return "An EGLContext argument does not name a valid EGL rendering context.";
        case EGL_BAD_CONFIG:
            return "An EGLConfig argument does not name a valid EGL frame buffer configuration.";
        case EGL_BAD_CURRENT_SURFACE:
            return "The current surface of the calling thread is a window, pixel buffer or pixmap that is no longer "
                   "valid.";
        case EGL_BAD_DISPLAY:
            return "An EGLDisplay argument does not name a valid EGL display connection.";
        case EGL_BAD_SURFACE:
            return "An EGLSurface argument does not name a valid surface(window, pixel buffer or pixmap) configured "
                   "for GL rendering.";
        case EGL_BAD_MATCH:
            return "Arguments are inconsistent (for example, a valid context requires buffers not supplied by a valid "
                   "surface).";
        case EGL_BAD_PARAMETER:
            return "One or more argument values are invalid.";
        case EGL_BAD_NATIVE_PIXMAP:
            return "A NativePixmapType argument does not refer to a valid native pixmap.";
        case EGL_BAD_NATIVE_WINDOW:
            return "A NativeWindowType argument does not refer to a valid native window.";
        case EGL_CONTEXT_LOST:
            return "A power management event has occurred.The application must destroy all contexts and reinitialise "
                   "OpenGL ES state and objects to continue rendering.";
        default:
            break;
    }

    static char error[64];
    if (sprintf_s(error, sizeof(error), "Unknown error %x", aError) < 0) {
        PLUGIN_LOG_E("EglErrorStr: sprintf_s failed");
    }
    return error;
}

void CheckEGLError(const char* const file, int line)
{
    EGLint error = eglGetError();
    if (error != EGL_SUCCESS) {
        PLUGIN_LOG_E("eglGetError failed : %s (%s %d)", EglErrorStr(error), file, line);
        PLUGIN_ASSERT(false);
    }
}

void CheckEGLError2(const char* const file, int line)
{
    EGLint error = eglGetError();
    if (error != EGL_SUCCESS) {
        PLUGIN_LOG_E("eglGetError failed : %s (%s %d)", EglErrorStr(error), file, line);
    }
}

#define ATTRIBUTE(_attr) \
    {                    \
        _attr, #_attr    \
    }

struct Attribute {
    EGLint attribute;
    char const* const Name;
};

void DumpEGLStrings(EGLDisplay dpy)
{
    // extensions dumped later.
    static constexpr Attribute strings[] = { ATTRIBUTE(EGL_CLIENT_APIS), ATTRIBUTE(EGL_VENDOR),
        ATTRIBUTE(EGL_VERSION) };
    for (size_t attr = 0; attr < sizeof(strings) / sizeof(Attribute); attr++) {
        const char* const value = eglQueryString(dpy, strings[attr].attribute);
        if (value) {
            PLUGIN_LOG_D("\t%-32s: %s", strings[attr].Name, value);
        } else {
            PLUGIN_LOG_D("\t%-32s:", strings[attr].Name);
        }
    }
}

#ifdef PLUGIN_UNUSED_EGL_HELPERS
void DumpEGLConfigs(EGLDisplay dpy)
{
    EGLConfig* configs = nullptr;
    EGLint n = 0;

    eglGetConfigs(dpy, NULL, 0, &n);
    configs = new EGLConfig[(size_t)n];
    eglGetConfigs(dpy, configs, n, &n);
    for (EGLint i = 0; i < n; i++) {
        PLUGIN_LOG_V("EGLConfig[%d]", i);
        DumpEGLConfig(dpy, configs[i]);
    }
    delete[] configs;
}
#endif

bool stringToUInt(string_view string, EGLint& value)
{
    value = 0;
    for (auto digit : string) {
        value *= 10;
        if ((digit >= '0') && (digit <= '9')) {
            value += digit - '0';
        } else {
            return false;
        }
    }
    return true;
}
} // namespace

void DumpEGLSurface(EGLDisplay dpy, EGLSurface surf)
{
    static constexpr Attribute attribs[] = {
        // Returns the ID of the EGL frame buffer configuration with respect to which the surface was created.
        ATTRIBUTE(EGL_CONFIG_ID),
        // Returns the color space used by OpenGL and OpenGL ES when rendering to the surface, either
        // EGL_GL_COLORSPACE_SRGB or EGL_GL_COLORSPACE_LINEAR.
        ATTRIBUTE(EGL_GL_COLORSPACE),
        // Returns the height of the surface in pixels
        ATTRIBUTE(EGL_HEIGHT),
        // Returns the horizontal dot pitch of the display on which a window surface is  visible.The value returned is
        // equal to the actual dot pitch, in pixels meter, multiplied by the constant value EGL_DISPLAY_SCALING.
        ATTRIBUTE(EGL_HORIZONTAL_RESOLUTION),
        // Returns the same attribute value specified when the surface was created with  eglCreatePbufferSurface.For a
        // window or pixmap surface, value is not modified.
        ATTRIBUTE(EGL_LARGEST_PBUFFER),
        ATTRIBUTE(EGL_MIPMAP_LEVEL),   // Returns which level of the mipmap to render to, if texture has mipmaps.
        ATTRIBUTE(EGL_MIPMAP_TEXTURE), // Returns EGL_TRUE if texture has mipmaps, EGL_FALSE otherwise.
        // Returns the filter used when resolving the multisample buffer.The filter may be either
        // EGL_MULTISAMPLE_RESOLVE_DEFAULT or EGL_MULTISAMPLE_RESOLVE_BOX, as described for eglSurfaceAttrib.
        ATTRIBUTE(EGL_MULTISAMPLE_RESOLVE),
        // Returns the aspect ratio of an individual pixel(the ratio of a pixel's width to its height). The value
        // returned is equal to the actual aspect ratio multiplied by the constant value EGL_DISPLAY_SCALING.
        ATTRIBUTE(EGL_PIXEL_ASPECT_RATIO),
        // Returns the buffer which client API rendering is requested to use.For a window surface, this is the same
        // attribute value specified when the surface was created.For a pbuffer surface, it is always
        // EGL_BACK_BUFFER.For a pixmap surface, it is always EGL_SINGLE_BUFFER.To determine the actual buffer being
        // rendered to by a context, call eglQueryContext.
        ATTRIBUTE(EGL_RENDER_BUFFER),
        // Returns the effect on the color buffer when posting a surface with eglSwapBuffers.Swap behavior may be either
        // EGL_BUFFER_PRESERVED or EGL_BUFFER_DESTROYED, as described for eglSurfaceAttrib.
        ATTRIBUTE(EGL_SWAP_BEHAVIOR),
        // Returns format of texture.Possible values are EGL_NO_TEXTURE, EGL_TEXTURE_RGB, and EGL_TEXTURE_RGBA.
        ATTRIBUTE(EGL_TEXTURE_FORMAT),
        ATTRIBUTE(EGL_TEXTURE_TARGET), // Returns type of texture.Possible values are EGL_NO_TEXTURE, or EGL_TEXTURE_2D.
        // Returns the vertical dot pitch of the display on which a window surface is visible.The value returned is
        // equal to the actual dot pitch, in pixels  / meter, multiplied by the constant value EGL_DISPLAY_SCALING.
        ATTRIBUTE(EGL_VERTICAL_RESOLUTION),
        // Returns the interpretation of alpha values used by OpenVG when rendering to the surface, either
        // EGL_VG_ALPHA_FORMAT_NONPRE or EGL_VG_ALPHA_FORMAT_PRE.
        ATTRIBUTE(EGL_VG_ALPHA_FORMAT),
        // Returns the color space used by OpenVG when rendering to the surface, either EGL_VG_COLORSPACE_sRGB or
        // EGL_VG_COLORSPACE_LINEAR.
        ATTRIBUTE(EGL_VG_COLORSPACE),
        ATTRIBUTE(EGL_WIDTH), // Returns the width of the surface in pixels.
    };
    for (size_t attr = 0; attr < sizeof(attribs) / sizeof(Attribute); attr++) {
        EGLint value;
        if (EGL_TRUE == eglQuerySurface(dpy, surf, attribs[attr].attribute, &value)) {
            PLUGIN_LOG_V("\t%-32s: %10d (0x%08x)", attribs[attr].Name, value, value);
        }
    }
}

void DumpEGLConfig(EGLDisplay dpy, const EGLConfig& config)
{
    static constexpr Attribute attributes[] = {
        ATTRIBUTE(EGL_ALPHA_SIZE),      // Returns the number of bits of alpha stored in the color buffer.
        ATTRIBUTE(EGL_ALPHA_MASK_SIZE), // Returns the number of bits in the alpha mask buffer.
        // Returns EGL_TRUE if color buffers can be bound to an RGB texture,  EGL_FALSE otherwise.
        ATTRIBUTE(EGL_BIND_TO_TEXTURE_RGB),
        // Returns EGL_TRUE if color buffers can be bound to an RGBA texture, EGL_FALSE otherwise.
        ATTRIBUTE(EGL_BIND_TO_TEXTURE_RGBA),
        ATTRIBUTE(EGL_BLUE_SIZE), // Returns the number of bits of blue stored in the color buffer.
        // Returns the depth of the color buffer.It is the sum of EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, and
        // EGL_ALPHA_SIZE.
        ATTRIBUTE(EGL_BUFFER_SIZE),
        // Returns the color buffer type.Possible types are EGL_RGB_BUFFER and  EGL_LUMINANCE_BUFFER.
        ATTRIBUTE(EGL_COLOR_BUFFER_TYPE),
        // Returns the caveats for the frame buffer configuration.Possible caveat values  are EGL_NONE, EGL_SLOW_CONFIG,
        // and EGL_NON_CONFORMANT.
        ATTRIBUTE(EGL_CONFIG_CAVEAT),
        ATTRIBUTE(EGL_CONFIG_ID), // Returns the ID of the frame buffer configuration.
        // Returns a bitmask indicating which client API contexts created with respect to this
        // config are conformant.
        ATTRIBUTE(EGL_CONFORMANT),
        ATTRIBUTE(EGL_DEPTH_SIZE), // Returns the number of bits in the depth buffer.
        ATTRIBUTE(EGL_GREEN_SIZE), // Returns the number of bits of green stored in the color buffer.
        // Returns the frame buffer level.Level zero is the default frame buffer.Positive levels correspond to frame
        // buffers that overlay the default buffer and negative levels correspond to frame buffers that underlay the
        // default buffer.
        ATTRIBUTE(EGL_LEVEL),
        ATTRIBUTE(EGL_LUMINANCE_SIZE),     // Returns the number of bits of luminance stored in the luminance buffer.
        ATTRIBUTE(EGL_MAX_PBUFFER_WIDTH),  // Returns the maximum width of a pixel buffer surface in pixels.
        ATTRIBUTE(EGL_MAX_PBUFFER_HEIGHT), // Returns the maximum height of a pixel buffer surface in pixels.
        ATTRIBUTE(EGL_MAX_PBUFFER_PIXELS), // Returns the maximum size of a pixel buffer surface in pixels.
        ATTRIBUTE(EGL_MAX_SWAP_INTERVAL),  // Returns the maximum value that can be passed to eglSwapInterval.
        ATTRIBUTE(EGL_MIN_SWAP_INTERVAL),  // Returns the minimum value that can be passed to eglSwapInterval.
        // Returns EGL_TRUE if native rendering APIs can render into the surface, EGL_FALSE otherwise.
        ATTRIBUTE(EGL_NATIVE_RENDERABLE),
        ATTRIBUTE(EGL_NATIVE_VISUAL_ID),   // Returns the ID of the associated native visual.
        ATTRIBUTE(EGL_NATIVE_VISUAL_TYPE), // Returns the type of the associated native visual.
        ATTRIBUTE(EGL_RED_SIZE),           // Returns the number of bits of red stored in the color buffer.
        ATTRIBUTE(EGL_RENDERABLE_TYPE),    // Returns a bitmask indicating the types of supported client API contexts.
        ATTRIBUTE(EGL_SAMPLE_BUFFERS),     // Returns the number of multisample buffers.
        ATTRIBUTE(EGL_SAMPLES),            // Returns the number of samples per pixel.
        ATTRIBUTE(EGL_STENCIL_SIZE),       // Returns the number of bits in the stencil buffer.
        ATTRIBUTE(EGL_SURFACE_TYPE),       // Returns a bitmask indicating the types of supported EGL surfaces.
        // Returns the type of supported transparency.Possible transparency values are  EGL_NONE, and
        // EGL_TRANSPARENT_RGB.
        ATTRIBUTE(EGL_TRANSPARENT_TYPE),
        ATTRIBUTE(EGL_TRANSPARENT_RED_VALUE),   // Returns the transparent red value.
        ATTRIBUTE(EGL_TRANSPARENT_GREEN_VALUE), // Returns the transparent green value.
        ATTRIBUTE(EGL_TRANSPARENT_BLUE_VALUE),  // Returns the transparent blue value.
        // ATTRIBUTE(EGL_MATCH_NATIVE_PIXMAP),  While EGL_MATCH_NATIVE_PIXMAP can be specified in the attribute list
        // passed to eglChooseConfig, it is not an attribute of the resulting config and cannot be queried using
        // eglGetConfigAttrib.
    };
    for (size_t attr = 0; attr < sizeof(attributes) / sizeof(Attribute); attr++) {
        EGLint value;
        if (EGL_TRUE == eglGetConfigAttrib(dpy, config, attributes[attr].attribute, &value)) {
            PLUGIN_LOG_V("\t%-32s: %10d (0x%08x)", attributes[attr].Name, value, value);
        }
    }
}

void ParseExtensions(const string& extensions, vector<string_view>& extensionList)
{
    size_t start = 0;
    for (auto end = extensions.find(' '); end != string::npos; end = extensions.find(' ', start)) {
        extensionList.emplace_back(extensions.data() + start, end - start);
        start = end + 1;
    }
    if (start < extensions.size()) {
        extensionList.emplace_back(extensions.data() + start);
    }
}

#undef ATTRIBUTE
void EGLState::HandleExtensions()
{
    if (plat_.minorVersion > 4) {
        cextensions_ = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
        CHECK_EGL_ERROR();
        PLUGIN_LOG_D("\t%-32s: %s", "EGL_EXTENSIONS (CLIENT)", cextensions_.c_str());
        ParseExtensions(cextensions_, cextensionList_);
    }

    dextensions_ = eglQueryString(plat_.display, EGL_EXTENSIONS);
    CHECK_EGL_ERROR();
    ParseExtensions(dextensions_, dextensionList_);
    PLUGIN_LOG_D("\t%-32s: %s", "EGL_EXTENSIONS (DISPLAY)", dextensions_.c_str());
}

uint32_t EGLState::MajorVersion() const
{
    return plat_.majorVersion;
}

uint32_t EGLState::MinorVersion() const
{
    return plat_.minorVersion;
}

void EGLState::ChooseConfiguration(const BackendExtraGLES* backendConfig)
{
    EGLint num_configs;
    // construct attribute list dynamically
    vector<EGLint> attributes;
    const size_t ATTRIBUTE_RESERVE = 16;       // reserve 16 attributes
    attributes.reserve(ATTRIBUTE_RESERVE * 2); // 2 EGLints per attribute
    auto addAttribute = [&attributes](EGLint a, EGLint b) {
        attributes.push_back(a);
        attributes.push_back(b);
    };
    // Request OpenGL ES 3.x configs
    if (IsVersionGreaterOrEqual(1, 5)) {
        // EGL 1.5+
        addAttribute(EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT);
        addAttribute(EGL_CONFORMANT, EGL_OPENGL_ES3_BIT);
    } else if (HasExtension("EGL_KHR_create_context")) {
        // "EGL_KHR_create_context"
        addAttribute(EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR);
        addAttribute(EGL_CONFORMANT, EGL_OPENGL_ES3_BIT_KHR);
    } else {
        // We might be in trouble now.
        addAttribute(EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT);
        addAttribute(EGL_CONFORMANT, EGL_OPENGL_ES2_BIT);
    }
    addAttribute(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT);
    addAttribute(EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER);
    addAttribute(EGL_RED_SIZE, 8);
    addAttribute(EGL_GREEN_SIZE, 8);
    addAttribute(EGL_BLUE_SIZE, 8);
    addAttribute(EGL_CONFIG_CAVEAT, EGL_NONE);
    if (backendConfig) {
        if (backendConfig->MSAASamples > 1) {
            addAttribute(EGL_SAMPLES, (EGLint)backendConfig->MSAASamples);
            addAttribute(EGL_SAMPLE_BUFFERS, 1);
        }
        addAttribute(EGL_ALPHA_SIZE, (EGLint)backendConfig->alphaBits);
        addAttribute(EGL_DEPTH_SIZE, (EGLint)backendConfig->depthBits);
        addAttribute(EGL_STENCIL_SIZE, (EGLint)backendConfig->stencilBits);
        PLUGIN_LOG_I("Samples:%d Alpha:%d Depth:%d Stencil:%d", backendConfig->MSAASamples, backendConfig->alphaBits,
            backendConfig->depthBits, backendConfig->stencilBits);
    }
    addAttribute(EGL_NONE, EGL_NONE); // terminate list
    eglChooseConfig(plat_.display, attributes.data(), &plat_.config, 1, &num_configs);
    CheckEGLError(__FILE__, __LINE__);
#if RENDER_GL_DEBUG
    PLUGIN_LOG_I("eglChooseConfig returned:");
    DumpEGLConfig(plat_.display, plat_.config);
#endif
}

void EGLState::CreateContext(const BackendExtraGLES* backendConfig)
{
    vector<EGLint> context_attributes;
    const size_t ATTRIBUTE_RESERVE = 16;               // reserve 16 attributes
    context_attributes.reserve(ATTRIBUTE_RESERVE * 2); // 2 EGLints per attribute
    auto addAttribute = [&context_attributes](EGLint a, EGLint b) {
        context_attributes.push_back(a);
        context_attributes.push_back(b);
    };
    if (IsVersionGreaterOrEqual(1, 5)) {
        // egl 1.5 or greater.
        addAttribute(EGL_CONTEXT_MAJOR_VERSION, 3); // Select an OpenGL ES 3.x context
        addAttribute(EGL_CONTEXT_MINOR_VERSION, 2); // Select an OpenGL ES x.2 context
#if RENDER_GL_DEBUG
        // should use EGL_CONTEXT_OPENGL_DEBUG , but at least PowerVR simulator fails with this
        if (HasExtension("EGL_KHR_create_context")) {
            // Setting up debug context with the extension seems to work.
            addAttribute(EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR);
        }
#endif
    } else if (HasExtension("EGL_KHR_create_context")) {
        // egl 1.4 with EGL_KHR_create_context
        addAttribute(EGL_CONTEXT_MAJOR_VERSION_KHR, 3); // Select an OpenGL ES 3.x context
        addAttribute(EGL_CONTEXT_MINOR_VERSION_KHR, 2); // Select an OpenGL ES x.2 context
#if RENDER_GL_DEBUG
        addAttribute(EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR);
#endif
    } else {
        // fallback to non-extended or pre 1.5 EGL, we expect 3.2 OpenGL context, this is now checked later.
        addAttribute(EGL_CONTEXT_CLIENT_VERSION, 3); // Select an OpenGL ES 3.x context
    }
    addAttribute(EGL_NONE, EGL_NONE);

    EGLContext sharedContext = EGL_NO_CONTEXT;
    if (backendConfig) {
        sharedContext = backendConfig->sharedContext;
    }
    plat_.context = eglCreateContext(plat_.display, plat_.config, sharedContext, context_attributes.data());
    CheckEGLError(__FILE__, __LINE__);

    if (plat_.context == EGL_NO_CONTEXT) {
        PLUGIN_LOG_E("eglCreateContext failed : %s", EglErrorStr(eglGetError()));
        PLUGIN_ASSERT(false);
        return;
    }
}

bool EGLState::IsVersionGreaterOrEqual(uint32_t major, uint32_t minor) const
{
    if (plat_.majorVersion < major) {
        return false;
    }
    if (plat_.majorVersion > major) {
        return true;
    }
    if (plat_.minorVersion >= minor) {
        return true;
    }
    return false;
}

bool EGLState::VerifyVersion()
{
    // Verify that we have atleast 3.2 context.
    EGLint glMajor = 0;
    EGLint glMinor = 0;
    SaveContext();
    SetContext(nullptr); // activate the context with the dummy PBuffer.
    string_view string((char*)glGetString(GL_VERSION));
    // the format according to spec pdf is "OpenGL ES N.M vendor-specific information"
    bool fail = false;
    if (string.substr(0, 10) == "OpenGL ES ") {
        // Must be OpenGL ES FULL. Trust this information. (even if it might mismatch with the eglQueryContext results)
        string_view version = string.substr(10);
        version = version.substr(0, version.find_first_of(' '));
        auto dot = version.find_first_of('.');
        auto majorS = version.substr(0, dot);
        if (dot != string_view::npos) {
            auto minorS = version.substr(dot + 1);
            fail = (stringToUInt(minorS, glMinor)) ? fail : false;
        }
        fail = (stringToUInt(majorS, glMajor)) ? fail : false;
    }
    if (fail) {
        // Try these then, if parsing the GL_VERSION string failed
        glMajor = glMinor = 0;
        eglQueryContext(plat_.display, plat_.context, EGL_CONTEXT_MAJOR_VERSION, &glMajor);
        eglQueryContext(plat_.display, plat_.context, EGL_CONTEXT_MINOR_VERSION_KHR, &glMinor);
    }

    if (glMajor < 3) {
        fail = true;
    } else if (glMajor == 3) {
        if (glMinor < 2) {
            // We do NOT support 3.0 or 3.1
            fail = true;
        }
    }

    if (fail) {
        // restore contexts and cleanup.
        PLUGIN_LOG_E(
            "Could not to Initialize required OpenGL ES version [%d.%d] [%s]", glMajor, glMinor, string.data());
        RestoreContext();
        // destroy the dummy surface also.
        eglDestroySurface(plat_.display, dummySurface_);
        dummyContext_.context = EGL_NO_CONTEXT;
        dummyContext_.drawSurface = dummyContext_.readSurface = EGL_NO_SURFACE;
        dummyContext_.display = EGL_NO_DISPLAY;
    }
    return !fail;
}
bool EGLState::CreateContext(DeviceCreateInfo const& createInfo)
{
    auto backendConfig = static_cast<const BackendExtraGLES*>(createInfo.backendConfiguration);
    EGLint major, minor;

    plat_.display = eglGetDisplay(backendConfig->display);

    EGLContext appContext = EGL_NO_CONTEXT;
    if (backendConfig) {
        appContext = backendConfig->applicationContext;
    }
    if (appContext == EGL_NO_CONTEXT && backendConfig->sharedContext == EGL_NO_CONTEXT) {
        if (!eglInitialize(plat_.display, &major, &minor)) {
            PLUGIN_LOG_E("EGL initialization failed");
            CHECK_EGL_ERROR();
            PLUGIN_ASSERT(false);
            return false;
        }
        plat_.eglInitialized = true;
    } else {
        major = 0;
        minor = 0;

        // Check version from display as we don't call eglInitialize ourselves
        const string_view version = eglQueryString(plat_.display, EGL_VERSION);
        if (!version.empty()) {
            const auto dot = version.find_first_of('.');
            if (dot != string_view::npos) {
                const auto majorS = version.substr(0, dot);
                if (!stringToUInt(majorS, major)) {
                    major = 0;
                }
                const auto space = version.find_first_of(' ', dot + 1);
                if (space != string_view::npos) {
                    auto minorS = version.substr(dot + 1, space - (dot + 1));
                    if (!stringToUInt(minorS, minor)) {
                        minor = 0;
                    }
                }
            }
        } else {
            CHECK_EGL_ERROR();
        }
    }
    plat_.majorVersion = static_cast<uint32_t>(major);
    plat_.minorVersion = static_cast<uint32_t>(minor);
    PLUGIN_LOG_I("EGL %d.%d Initialized", major, minor);

    if (!IsVersionGreaterOrEqual(1, 4)) {
        // we need atleast egl 1.4
        PLUGIN_LOG_F("EGL version too old. 1.4 or later requried.");
        if (plat_.eglInitialized) {
            eglTerminate(plat_.display);
        }
        return false;
    }

    eglBindAPI(EGL_OPENGL_ES_API);
    CHECK_EGL_ERROR();

    DumpEGLStrings(plat_.display);

    HandleExtensions();

    plat_.hasColorSpaceExt = hasColorSpaceExt_ = HasExtension("EGL_KHR_gl_colorspace");
    // NOTE: "EGL_KHR_no_config_context" and "EGL_KHR_surfaceless_context" is technically working, but disabled for now.
    hasConfiglessExt_ = false;
    hasSurfacelessExt_ = false;
    plat_.config = EGL_NO_CONFIG_KHR;
    if (!hasConfiglessExt_) {
        // we need a config for the context..
        ChooseConfiguration(backendConfig);
    }

    if (appContext) {
        // use applications context
        PLUGIN_LOG_I("Using application context in DeviceGLES");
        plat_.context = appContext;
    } else {
        // Create a new context
        CreateContext(backendConfig);
        plat_.contextCreated = true;
    }
    if (plat_.context == EGL_NO_CONTEXT) {
        // we have failed then.
        if (plat_.eglInitialized) {
            eglTerminate(plat_.display);
        }
        return false;
    }

    if (!hasSurfacelessExt_) {
        // Create a placeholder pbuffer, since we do NOT have a surface yet.
        if (plat_.config == EGL_NO_CONFIG_KHR) {
            // we need to choose a config for the surface..
            ChooseConfiguration(backendConfig);
        }
        GLint surface_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
        dummySurface_ = eglCreatePbufferSurface(plat_.display, plat_.config, surface_attribs);
        CheckEGLError(__FILE__, __LINE__);
#if RENDER_GL_DEBUG
        DumpEGLSurface(plat_.display, dummySurface_);
#endif
    }

    dummyContext_.context = plat_.context;
    dummyContext_.drawSurface = dummyContext_.readSurface = dummySurface_;
    dummyContext_.display = plat_.display;

    if (!VerifyVersion()) {
        if (plat_.contextCreated) {
            eglDestroyContext(plat_.display, plat_.context);
            plat_.context = EGL_NO_CONTEXT;
        }
        if (plat_.eglInitialized) {
            eglTerminate(plat_.display);
        }
        return false;
    }
    return true;
}

void EGLState::GlInitialize()
{
#define declare(a, b)                                                                     \
    if (b == nullptr) {                                                                   \
        *(reinterpret_cast<void**>(&b)) = reinterpret_cast<void*>(eglGetProcAddress(#b)); \
    }                                                                                     \
    if (b == nullptr) {                                                                   \
        PLUGIN_LOG_E("Missing %s\n", #b);                                                 \
    }

#include "gles/gl_functions.h"

    vSync_ = true;
    SetSwapInterval(1); // default to vsync enabled.
}

bool EGLState::IsValid()
{
    return (plat_.context != EGL_NO_CONTEXT);
}

void EGLState::SaveContext()
{
    PLUGIN_ASSERT(!oldIsSet_);
    oldIsSet_ = true;
    GetContext(oldContext_);
}

void EGLState::SetContext(Swapchain* swapChain)
{
    if (swapChain == nullptr) {
        SetContext(dummyContext_, true);
    } else {
        SwapchainGLES* swap = static_cast<SwapchainGLES*>(swapChain);
        ContextState newContext;
        const auto& plat = (const SwapchainPlatformDataGL&)swap->GetPlatformData();
        newContext.display = plat_.display;
        newContext.context = plat_.context;
        newContext.drawSurface = (EGLSurface)plat.surface;
        newContext.readSurface = (EGLSurface)plat.surface;
        SetContext(newContext, false);

        if (vSync_ != plat.vsync) {
            vSync_ = plat.vsync;
            SetSwapInterval(plat.vsync ? 1u : 0u);
        }
    }
}

void EGLState::RestoreContext()
{
    PLUGIN_ASSERT(oldIsSet_);
    SetContext(oldContext_, true);
    oldIsSet_ = false;
}

void EGLState::GetContext(ContextState& state)
{
    state.display = eglGetCurrentDisplay();
    CHECK_EGL_ERROR();
    if (state.display != EGL_NO_DISPLAY) {
        state.context = eglGetCurrentContext();
        CHECK_EGL_ERROR();
        state.readSurface = eglGetCurrentSurface(EGL_READ);
        CHECK_EGL_ERROR();
        state.drawSurface = eglGetCurrentSurface(EGL_DRAW);
        CHECK_EGL_ERROR();
    } else {
        state.context = EGL_NO_CONTEXT;
        state.readSurface = EGL_NO_SURFACE;
        state.drawSurface = EGL_NO_SURFACE;
    }
}

void EGLState::SetContext(const ContextState& state, bool aForce)
{
    PLUGIN_ASSERT(oldIsSet_);
    if (state.display != EGL_NO_DISPLAY) {
        if ((aForce) || (oldContext_.display != state.display) || (oldContext_.drawSurface != state.drawSurface) ||
            (oldContext_.readSurface != state.readSurface) || (oldContext_.context != state.context)) {
            if (eglMakeCurrent(state.display, state.drawSurface, state.readSurface, state.context) == EGL_FALSE) {
                CHECK_EGL_ERROR2();
            }
        }
    } else {
        // Okay, do nothing.
        // no display was active, so there can be no surface and no context.
        // We need a display to deactivate context. (EGL_NO_DISPLAY is not a valid argument to eglMakeCurrent)
        // so what to do, leak context?
        // Or just disconnect context/surface from plat_.display (which currently is EGL_DEFAULT_DISPLAY...)
        if (eglMakeCurrent(plat_.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) == EGL_FALSE) {
            CHECK_EGL_ERROR2();
        }
    }
}

void EGLState::DestroyContext()
{
    if (plat_.display != EGL_NO_DISPLAY) {
        eglMakeCurrent(plat_.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
        CHECK_EGL_ERROR();
        if (dummySurface_ != EGL_NO_SURFACE) {
            eglDestroySurface(plat_.display, dummySurface_);
        }
        CHECK_EGL_ERROR();
        if (plat_.contextCreated) {
            if (plat_.context != EGL_NO_CONTEXT) {
                eglDestroyContext(plat_.display, plat_.context);
                CHECK_EGL_ERROR();
            }
        }
        if (plat_.eglInitialized) {
            eglTerminate(plat_.display);
            CHECK_EGL_ERROR();
        }
    }
}

bool EGLState::HasExtension(const string_view extension) const
{
    for (const auto& e : dextensionList_) {
        if (extension == e)
            return true;
    }
    for (const auto& e : cextensionList_) {
        if (extension == e)
            return true;
    }
    return false;
}

void EGLState::SetSwapInterval(uint32_t interval)
{
    eglSwapInterval(plat_.display, (EGLint)interval);
}

const DevicePlatformData& EGLState::GetPlatformData() const
{
    return plat_;
}

void* EGLState::ErrorFilter() const
{
    return reinterpret_cast<void*>(FilterError);
}

bool EGLState::GetSurfaceInformation(
    const DevicePlatformDataGLES& plat, EGLSurface surface, GlesImplementation::SurfaceInfo& res) const
{
    EGLDisplay display = plat.display;

#ifndef NDEBUG
    PLUGIN_LOG_V("EGLState::GetSurfaceInformation: input surface information:");
    EGLHelpers::DumpEGLSurface(display, surface);
#endif
    EGLint configId;
    // Get configId from surface
    if (eglQuerySurface(display, surface, EGL_CONFIG_ID, &configId) == false) {
        PLUGIN_LOG_E("EGLState::GetSurfaceInformation: Could not fetch surface config_id.");
        return false;
    }

    EGLConfig config = EGL_NO_CONFIG_KHR;
    EGLint numconfigs = 0;
    EGLint attrs[] = { EGL_CONFIG_ID, configId, EGL_NONE };
    if (eglChooseConfig(display, attrs, &config, 1, &numconfigs) == false) {
        PLUGIN_LOG_E("EGLState::GetSurfaceInformation: Could not fetch surface config.");
        return false;
    }

    PLUGIN_LOG_V("EGLState::GetSurfaceInformation: input surface configuration:");
    EGLHelpers::DumpEGLConfig(display, config);

#ifndef NDEBUG
    if (!hasConfiglessExt_) {
        // Check that it matches the config id from "system config"
        EGLConfig plat_config = plat.config;
        if ((plat_config != EGL_NO_CONFIG_KHR) && (plat_config != config)) {
            PLUGIN_ASSERT_MSG(plat_config == config, "display config and surface config should match!");
            PLUGIN_LOG_V("EGLState::GetSurfaceInformation: plat surface configuration:");
            EGLHelpers::DumpEGLConfig(display, plat_config);
        }
    }
#endif

    // Fetch surface parameters
    EGLint width = 0;
    EGLint height = 0;
    EGLint red_size = 0;
    EGLint green_size = 0;
    EGLint blue_size = 0;
    EGLint alpha_size = 0;
    EGLint samples = 0;
    EGLint depth_size = 0;
    EGLint stencil_size = 0;
    eglQuerySurface(display, surface, EGL_WIDTH, &width);
    eglQuerySurface(display, surface, EGL_HEIGHT, &height);
    eglGetConfigAttrib(display, config, EGL_RED_SIZE, &red_size);
    eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &green_size);
    eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blue_size);
    eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alpha_size);
    eglGetConfigAttrib(display, config, EGL_SAMPLES, &samples);
    eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depth_size);
    eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencil_size);

    res.configId = (uint32_t)configId;
    res.alpha_size = (uint32_t)alpha_size;
    res.blue_size = (uint32_t)blue_size;
    res.depth_size = (uint32_t)depth_size;
    res.green_size = (uint32_t)green_size;
    res.height = (uint32_t)height;
    res.red_size = (uint32_t)red_size;
    res.samples = (uint32_t)samples;
    res.stencil_size = (uint32_t)stencil_size;
    res.width = (uint32_t)width;

    EGLint colorspace = 0;
    EGLint COLOR_SPACE = 0;
    EGLint COLOR_SPACE_SRGB = 0;
    if (IsVersionGreaterOrEqual(1, 5)) {
        COLOR_SPACE = EGL_GL_COLORSPACE;
        COLOR_SPACE_SRGB = EGL_GL_COLORSPACE_SRGB;
    } else if (hasColorSpaceExt_) {
        COLOR_SPACE = EGL_GL_COLORSPACE_KHR;
        COLOR_SPACE_SRGB = EGL_GL_COLORSPACE_SRGB_KHR;
    }

    if (COLOR_SPACE > 0) {
        if (eglQuerySurface(display, surface, COLOR_SPACE, &colorspace)) {
            // EGL_GL_COLORSPACE_SRGB or EGL_GL_COLORSPACE_LINEAR.
            res.srgb = (colorspace == COLOR_SPACE_SRGB);
        }
    }

    if (colorspace == 0) {
        // surface is linear (no conversion made during read/write)
        // data should be srgb though.
        PLUGIN_LOG_E("EGL_GL_COLORSPACE query failed (or not available). Defaulting to linear buffer with srgb data");
        res.srgb = false;
    }

    return true;
}
} // namespace EGLHelpers
RENDER_END_NAMESPACE()
#endif