gl-state-egl.cpp

//
// Copyright © 2012 Linaro Limited
//
// This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
//
// glmark2 is free software: you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// glmark2.  If not, see <http://www.gnu.org/licenses/>.
//
// Authors:
//  Jesse Barker
//
#include "gl-state-egl.h"
#include "log.h"
#include "options.h"
#include "gl-headers.h"
#include "limits.h"
#include "gl-headers.h"
#include <iomanip>
#include <sstream>
#include <cstring>

using std::vector;
using std::string;

GLADapiproc load_egl_func(void *userdata, const char *name)
{
    SharedLibrary *lib = reinterpret_cast<SharedLibrary *>(userdata);
    return reinterpret_cast<GLADapiproc>(lib->load(name));
}

/****************************
 * EGLConfig public methods *
 ****************************/

EglConfig::EglConfig(EGLDisplay dpy, EGLConfig config) :
    handle_(config),
    bufferSize_(0),
    redSize_(0),
    greenSize_(0),
    blueSize_(0),
    luminanceSize_(0),
    alphaSize_(0),
    alphaMaskSize_(0),
    bindTexRGB_(false),
    bindTexRGBA_(false),
    bufferType_(EGL_RGB_BUFFER),
    caveat_(0),
    configID_(0),
    conformant_(0),
    depthSize_(0),
    level_(0),
    pbufferWidth_(0),
    pbufferHeight_(0),
    pbufferPixels_(0),
    minSwapInterval_(0),
    maxSwapInterval_(0),
    nativeID_(0),
    nativeType_(0),
    nativeRenderable_(false),
    sampleBuffers_(0),
    samples_(0),
    stencilSize_(0),
    surfaceType_(0),
    xparentType_(0),
    xparentRedValue_(0),
    xparentGreenValue_(0),
    xparentBlueValue_(0)
{
    vector<string> badAttribVec;
    if (!eglGetConfigAttrib(dpy, handle_, EGL_CONFIG_ID, &configID_))
    {
        badAttribVec.push_back("EGL_CONFIG_ID");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_CONFIG_CAVEAT, &caveat_))
    {
        badAttribVec.push_back("EGL_CONFIG_CAVEAT");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_CONFORMANT, &conformant_))
    {
        badAttribVec.push_back("EGL_CONFORMANT");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_COLOR_BUFFER_TYPE, &bufferType_))
    {
        badAttribVec.push_back("EGL_COLOR_BUFFER_TYPE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_BUFFER_SIZE, &bufferSize_))
    {
        badAttribVec.push_back("EGL_BUFFER_SIZE");
    }

    if (bufferType_ == EGL_RGB_BUFFER)
    {
        if (!eglGetConfigAttrib(dpy, handle_, EGL_RED_SIZE, &redSize_))
        {
            badAttribVec.push_back("EGL_RED_SIZE");
        }
        if (!eglGetConfigAttrib(dpy, handle_, EGL_GREEN_SIZE, &greenSize_))
        {
            badAttribVec.push_back("EGL_GREEN_SIZE");
        }
        if (!eglGetConfigAttrib(dpy, handle_, EGL_BLUE_SIZE, &blueSize_))
        {
            badAttribVec.push_back("EGL_BLUE_SIZE");
        }
    }
    else
    {
        if (!eglGetConfigAttrib(dpy, handle_, EGL_LUMINANCE_SIZE, &luminanceSize_))
        {
            badAttribVec.push_back("EGL_LUMINANCE_SIZE");
        }
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_ALPHA_SIZE, &alphaSize_))
    {
        badAttribVec.push_back("EGL_ALPHA_SIZE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_ALPHA_MASK_SIZE, &alphaMaskSize_))
    {
        badAttribVec.push_back("EGL_ALPHA_MASK_SIZE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_DEPTH_SIZE, &depthSize_))
    {
        badAttribVec.push_back("EGL_DEPTH_SIZE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_STENCIL_SIZE, &stencilSize_))
    {
        badAttribVec.push_back("EGL_STENCIL_SIZE");
    }
    EGLint doBind(EGL_FALSE);
    if (!eglGetConfigAttrib(dpy, handle_, EGL_BIND_TO_TEXTURE_RGB, &doBind))
    {
        badAttribVec.push_back("EGL_BIND_TO_TEXTURE_RGB");
    }
    bindTexRGB_ = (doBind == EGL_TRUE);
    if (!eglGetConfigAttrib(dpy, handle_, EGL_BIND_TO_TEXTURE_RGBA, &doBind))
    {
        badAttribVec.push_back("EGL_BIND_TO_TEXTURE_RGBA");
    }
    bindTexRGBA_ = (doBind == EGL_TRUE);
    if (!eglGetConfigAttrib(dpy, handle_, EGL_LEVEL, &level_))
    {
        badAttribVec.push_back("EGL_LEVEL");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_MAX_PBUFFER_WIDTH, &pbufferWidth_))
    {
        badAttribVec.push_back("EGL_MAX_PBUFFER_WIDTH");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_MAX_PBUFFER_HEIGHT, &pbufferHeight_))
    {
        badAttribVec.push_back("EGL_MAX_PBUFFER_HEIGHT");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_MAX_PBUFFER_PIXELS, &pbufferPixels_))
    {
        badAttribVec.push_back("EGL_MAX_PBUFFER_PIXELS");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_MIN_SWAP_INTERVAL, &minSwapInterval_))
    {
        badAttribVec.push_back("EGL_MIN_SWAP_INTERVAL");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_MAX_SWAP_INTERVAL, &maxSwapInterval_))
    {
        badAttribVec.push_back("EGL_MAX_SWAP_INTERVAL");
    }
    EGLint doNative(EGL_FALSE);
    if (!eglGetConfigAttrib(dpy, handle_, EGL_NATIVE_RENDERABLE, &doNative))
    {
        badAttribVec.push_back("EGL_NATIVE_RENDERABLE");
    }
    nativeRenderable_ = (doNative == EGL_TRUE);
    if (!eglGetConfigAttrib(dpy, handle_, EGL_NATIVE_VISUAL_TYPE, &nativeType_))
    {
        badAttribVec.push_back("EGL_NATIVE_VISUAL_TYPE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_NATIVE_VISUAL_ID, &nativeID_))
    {
        badAttribVec.push_back("EGL_NATIVE_VISUAL_ID");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_SURFACE_TYPE, &surfaceType_))
    {
        badAttribVec.push_back("EGL_SURFACE_TYPE");
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_SAMPLE_BUFFERS, &sampleBuffers_))
    {
        badAttribVec.push_back("EGL_SAMPLE_BUFFERS");
    }
    if (sampleBuffers_)
    {
        if (!eglGetConfigAttrib(dpy, handle_, EGL_SAMPLES, &samples_))
        {
            badAttribVec.push_back("EGL_SAMPLES");
        }
    }
    if (!eglGetConfigAttrib(dpy, handle_, EGL_TRANSPARENT_TYPE, &xparentType_))
    {
        badAttribVec.push_back("EGL_TRANSPARENT_TYPE");
    }
    //if (xparentType_ != EGL_NONE)
    {
        if (!eglGetConfigAttrib(dpy, handle_, EGL_TRANSPARENT_RED_VALUE, &xparentRedValue_))
        {
            badAttribVec.push_back("EGL_TRANSPARENT_RED_VALUE");
        }
        if (!eglGetConfigAttrib(dpy, handle_, EGL_TRANSPARENT_GREEN_VALUE, &xparentGreenValue_))
        {
            badAttribVec.push_back("EGL_TRANSPARENT_GREEN_VALUE");
        }
        if (!eglGetConfigAttrib(dpy, handle_, EGL_TRANSPARENT_BLUE_VALUE, &xparentBlueValue_))
        {
            badAttribVec.push_back("EGL_TRANSPARENT_BLUE_VALUE");
        }
    }

    if (!badAttribVec.empty())
    {
        Log::error("Failed to get the following config attributes for config 0x%x:\n",
                    config);
        for (vector<string>::const_iterator attribIt = badAttribVec.begin();
             attribIt != badAttribVec.end();
             attribIt++)
        {
            Log::error("%s\n", attribIt->c_str());
        }
    }
}

void
EglConfig::print_header()
{
    Log::debug("\n");
    Log::debug("    cfg buf  rgb  colorbuffer dp st config native support surface sample\n");
    Log::debug("     id  sz  lum  r  g  b  a  th cl caveat render  visid    type  buf ns\n");
    Log::debug("------------------------------------------------------------------------\n");
}

void
EglConfig::print() const
{
    std::ostringstream s;
    s.setf(std::ios::showbase);
    s.fill(' ');
    s << std::setw(7) << std::hex << configID_;
    s << std::setw(4) << std::dec << bufferSize_;
    if (bufferType_ == EGL_RGB_BUFFER)
    {
        s << std::setw(5) << "rgb";
        s << std::setw(3) << redSize_;
        s << std::setw(3) << greenSize_;
        s << std::setw(3) << blueSize_;
    }
    else
    {
        s << std::setw(5) << "lum";
        s << std::setw(3) << luminanceSize_;
        s << std::setw(3) << 0;
        s << std::setw(3) << 0;
    }
    s << std::setw(3) << alphaSize_;
    s << std::setw(4) << depthSize_;
    s << std::setw(3) << stencilSize_;
    string caveat("None");
    switch (caveat_)
    {
        case EGL_SLOW_CONFIG:
            caveat = string("Slow");
            break;
        case EGL_NON_CONFORMANT_CONFIG:
            caveat = string("Ncon");
            break;
        case EGL_NONE:
            // Initialized to none.
            break;
    }
    s << std::setw(7) << caveat;
    string doNative(nativeRenderable_ ? "true" : "false");
    s << std::setw(7) << doNative;
    s << std::setw(8) << std::hex << nativeID_;
    s << std::setw(8) << std::hex << surfaceType_;
    s << std::setw(4) << std::dec << sampleBuffers_;
    s << std::setw(3) << std::dec << samples_;
    Log::debug("%s\n", s.str().c_str());
}

/*****************************
 * GLStateEGL public methods *
 ****************************/

GLStateEGL::~GLStateEGL()
{
    reset();

    if(egl_display_ != nullptr){
        if(!eglTerminate(egl_display_))
            Log::error("eglTerminate failed\n");
    }

    if(eglReleaseThread && !eglReleaseThread())
       Log::error("eglReleaseThread failed\n");
}

bool
GLStateEGL::init_display(void* native_display, GLVisualConfig& visual_config)
{
#if defined(WIN32)
    if (!egl_lib_.open("libEGL.dll")) {
#else
    if (!egl_lib_.open_from_alternatives({"libEGL.so", "libEGL.so.1" })) {
#endif
        Log::error("Error loading EGL library\n");
        return false;
    }

    native_display_ = reinterpret_cast<EGLNativeDisplayType>(native_display);
    requested_visual_config_ = visual_config;

    return gotValidDisplay();
}

bool
GLStateEGL::init_surface(void* native_window)
{
    native_window_ = reinterpret_cast<EGLNativeWindowType>(native_window);

    return gotValidSurface();
}

bool
GLStateEGL::init_gl_extensions()
{
#if GLMARK2_USE_GLESv2
    if (!gladLoadGLES2UserPtr(load_proc, this)) {
        Log::error("Loading GLESv2 entry points failed.\n");
        return false;
    }

    GLExtensions::MapBuffer = glMapBufferOES;
    GLExtensions::UnmapBuffer = glUnmapBufferOES;

    GLExtensions::GenFramebuffers = glGenFramebuffers;
    GLExtensions::DeleteFramebuffers = glDeleteFramebuffers;
    GLExtensions::BindFramebuffer = glBindFramebuffer;
    GLExtensions::FramebufferTexture2D = glFramebufferTexture2D;
    GLExtensions::FramebufferRenderbuffer = glFramebufferRenderbuffer;
    GLExtensions::CheckFramebufferStatus = glCheckFramebufferStatus;

    GLExtensions::GenRenderbuffers = glGenRenderbuffers;
    GLExtensions::DeleteRenderbuffers = glDeleteRenderbuffers;
    GLExtensions::BindRenderbuffer = glBindRenderbuffer;
    GLExtensions::RenderbufferStorage = glRenderbufferStorage;

    GLExtensions::GenerateMipmap = glGenerateMipmap;
#elif GLMARK2_USE_GL
    if (!gladLoadGLUserPtr(load_proc, this)) {
        Log::error("Loading GL entry points failed.\n");
        return false;
    }
    GLExtensions::MapBuffer = glMapBuffer;
    GLExtensions::UnmapBuffer = glUnmapBuffer;

    GLExtensions::GenFramebuffers = glGenFramebuffersEXT;
    GLExtensions::DeleteFramebuffers = glDeleteFramebuffersEXT;
    GLExtensions::BindFramebuffer = glBindFramebufferEXT;
    GLExtensions::FramebufferTexture2D = glFramebufferTexture2DEXT;
    GLExtensions::FramebufferRenderbuffer = glFramebufferRenderbufferEXT;
    GLExtensions::CheckFramebufferStatus = glCheckFramebufferStatusEXT;

    GLExtensions::GenRenderbuffers = glGenRenderbuffersEXT;
    GLExtensions::DeleteRenderbuffers = glDeleteRenderbuffersEXT;
    GLExtensions::BindRenderbuffer = glBindRenderbufferEXT;
    GLExtensions::RenderbufferStorage = glRenderbufferStorageEXT;

    GLExtensions::GenerateMipmap = glGenerateMipmapEXT;
#endif
    return true;
}

bool
GLStateEGL::valid()
{
    if (!gotValidDisplay())
        return false;

    if (!gotValidConfig())
        return false;

    if (!gotValidSurface())
        return false;

    if (!gotValidContext())
        return false;

    if (eglGetCurrentContext && egl_context_ == eglGetCurrentContext())
        return true;

    if (!eglMakeCurrent(egl_display_, egl_surface_, egl_surface_, egl_context_)) {
        Log::error("eglMakeCurrent failed with error: 0x%x\n", eglGetError());
        return false;
    }

    if (Options::swap_mode != Options::SwapModeFIFO &&
        (!eglSwapInterval || !eglSwapInterval(egl_display_, 0))) {
        Log::info("** Failed to set swap interval. Results may be bounded above by refresh rate.\n");
    }

    if (!init_gl_extensions()) {
        return false;
    }

    return true;
}

bool
GLStateEGL::reset()
{
    if (!gotValidDisplay()) {
        return false;
    }

    if (!egl_context_) {
        return true;
    }

    if (eglGetCurrentContext && egl_context_ == eglGetCurrentContext()) {
        eglMakeCurrent(egl_display_, 0, 0, 0);
    }

    if (EGL_FALSE == eglDestroyContext(egl_display_, egl_context_)) {
        Log::debug("eglDestroyContext failed with error: 0x%x\n", eglGetError());
    }

    egl_context_ = 0;

    return true;
}

void
GLStateEGL::swap()
{
    eglSwapBuffers(egl_display_, egl_surface_);
}

bool
GLStateEGL::gotNativeConfig(intptr_t& vid)
{
    if (!gotValidConfig())
        return false;

    EGLint native_id;
    if (!eglGetConfigAttrib(egl_display_, egl_config_, EGL_NATIVE_VISUAL_ID,
        &native_id))
    {
        Log::debug("Failed to get native visual id for EGLConfig 0x%x\n", egl_config_);
        return false;
    }

    vid = native_id;
    return true;
}

void
GLStateEGL::getVisualConfig(GLVisualConfig& vc)
{
    if (!gotValidConfig())
        return;

    get_glvisualconfig(egl_config_, vc);
}

/******************************
 * GLStateEGL private methods *
 *****************************/

#ifdef GLMARK2_USE_X11
#define GLMARK2_NATIVE_EGL_DISPLAY_ENUM EGL_PLATFORM_X11_KHR
#elif  GLMARK2_USE_WAYLAND
#define GLMARK2_NATIVE_EGL_DISPLAY_ENUM EGL_PLATFORM_WAYLAND_KHR
#elif  GLMARK2_USE_DRM
#define GLMARK2_NATIVE_EGL_DISPLAY_ENUM EGL_PLATFORM_GBM_KHR
#else
// Platforms not in the above platform enums fall back to eglGetDisplay.
#define GLMARK2_NATIVE_EGL_DISPLAY_ENUM 0
#endif

bool
GLStateEGL::gotValidDisplay()
{
    if (egl_display_)
        return true;

    /* Until we initialize glad EGL, load and use our own function pointers. */
    PFNEGLQUERYSTRINGPROC egl_query_string =
        reinterpret_cast<PFNEGLQUERYSTRINGPROC>(egl_lib_.load("eglQueryString"));
    PFNEGLGETPROCADDRESSPROC egl_get_proc_address =
        reinterpret_cast<PFNEGLGETPROCADDRESSPROC>(egl_lib_.load("eglGetProcAddress"));
    PFNEGLGETERRORPROC egl_get_error =
        reinterpret_cast<PFNEGLGETERRORPROC>(egl_lib_.load("eglGetError"));
    PFNEGLGETDISPLAYPROC egl_get_display =
        reinterpret_cast<PFNEGLGETDISPLAYPROC>(egl_lib_.load("eglGetDisplay"));
    PFNEGLINITIALIZEPROC egl_initialize =
        reinterpret_cast<PFNEGLINITIALIZEPROC>(egl_lib_.load("eglInitialize"));

    if (!egl_query_string || !egl_get_proc_address || !egl_get_error ||
        !egl_get_display || !egl_initialize)
    {
        return false;
    }

    char const * __restrict const supported_extensions =
        egl_query_string(EGL_NO_DISPLAY, EGL_EXTENSIONS);

    if (GLMARK2_NATIVE_EGL_DISPLAY_ENUM != 0 && supported_extensions
        && strstr(supported_extensions, "EGL_EXT_platform_base"))
    {
        Log::debug("Using eglGetPlatformDisplayEXT()\n");
        PFNEGLGETPLATFORMDISPLAYEXTPROC egl_get_platform_display =
            reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(
                egl_get_proc_address("eglGetPlatformDisplayEXT"));

        if (egl_get_platform_display != nullptr) {
            egl_display_ = egl_get_platform_display(
                GLMARK2_NATIVE_EGL_DISPLAY_ENUM,
                reinterpret_cast<void*>(native_display_),
                nullptr);
        }

        if (!egl_display_) {
            Log::debug("eglGetPlatformDisplayEXT() failed with error: 0x%x\n",
                       egl_get_error());
        }
    }
    else
    {
        Log::debug("eglGetPlatformDisplayEXT() seems unsupported\n");
    }

    /* Just in case get_platform_display failed... */
    if (!egl_display_) {
        Log::debug("Falling back to eglGetDisplay()\n");
        egl_display_ = egl_get_display(native_display_);
    }

    if (!egl_display_) {
        Log::error("eglGetDisplay() failed with error: 0x%x\n", egl_get_error());
        return false;
    }

    int egl_major(-1);
    int egl_minor(-1);
    if (!egl_initialize(egl_display_, &egl_major, &egl_minor)) {
        Log::error("eglInitialize() failed with error: 0x%x\n", egl_get_error());
        egl_display_ = 0;
        return false;
    }

    /* Reinitialize GLAD with a known display */
    if (gladLoadEGLUserPtr(egl_display_, load_egl_func, &egl_lib_) == 0) {
        Log::error("Loading EGL entry points failed\n");
        return false;
    }

    /* From this point on we can use the normal EGL function calls. */

#if GLMARK2_USE_GLESv2
    EGLenum apiType(EGL_OPENGL_ES_API);
#if defined(WIN32)
    std::initializer_list<const char *> libNames = { "libGLESv2.dll" };
#else
    std::initializer_list<const char *> libNames = { "libGLESv2.so", "libGLESv2.so.2" };
#endif
#elif GLMARK2_USE_GL
    EGLenum apiType(EGL_OPENGL_API);
    std::initializer_list<const char *> libNames = { "libGL.so", "libGL.so.1" };
    if (!GLAD_EGL_VERSION_1_4) {
        Log::error("EGL version %d.%d does not support the OpenGL API\n",
                   egl_major, egl_minor);
        return false;
    }
#endif

    if (eglBindAPI && !eglBindAPI(apiType)) {
        Log::error("Failed to bind api\n");
        return false;
    }

    if (!gl_lib_.open_from_alternatives(libNames)) {
        Log::error("Error loading GL library\n");
        return false;
    }

    return true;
}

void
GLStateEGL::get_glvisualconfig(EGLConfig config, GLVisualConfig& visual_config)
{
    eglGetConfigAttrib(egl_display_, config, EGL_CONFIG_ID, &visual_config.id);
    eglGetConfigAttrib(egl_display_, config, EGL_BUFFER_SIZE, &visual_config.buffer);
    eglGetConfigAttrib(egl_display_, config, EGL_RED_SIZE, &visual_config.red);
    eglGetConfigAttrib(egl_display_, config, EGL_GREEN_SIZE, &visual_config.green);
    eglGetConfigAttrib(egl_display_, config, EGL_BLUE_SIZE, &visual_config.blue);
    eglGetConfigAttrib(egl_display_, config, EGL_ALPHA_SIZE, &visual_config.alpha);
    eglGetConfigAttrib(egl_display_, config, EGL_DEPTH_SIZE, &visual_config.depth);
    eglGetConfigAttrib(egl_display_, config, EGL_STENCIL_SIZE, &visual_config.stencil);
    eglGetConfigAttrib(egl_display_, config, EGL_SAMPLES, &visual_config.samples);
}

EGLConfig
GLStateEGL::select_best_config(std::vector<EGLConfig>& configs)
{
    int best_score(INT_MIN);
    EGLConfig best_config(0);

    /*
     * Go through all the configs and choose the one with the best score,
     * i.e., the one better matching the requested config.
     */
    for (std::vector<EGLConfig>::const_iterator iter = configs.begin();
         iter != configs.end();
         iter++)
    {
        const EGLConfig config(*iter);
        GLVisualConfig vc;
        int score;

        get_glvisualconfig(config, vc);

        score = vc.match_score(requested_visual_config_);

        if (score > best_score) {
            best_score = score;
            best_config = config;
        }
    }

    if (best_score <= 0) {
        if (Options::good_config)
            return NULL;
        Log::warning("Unable to find a good EGL config, will continue with the best match,\n"
                     "but you should verify that the config values are acceptable.\n"
                     "Tip: Use --visual-config to request a different config\n");
    }

    return best_config;
}

bool
GLStateEGL::gotValidConfig()
{
    if (egl_config_)
        return true;

    if (!gotValidDisplay())
        return false;

    const EGLint config_attribs[] = {
#if GLMARK2_USE_GLESv2
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#elif GLMARK2_USE_GL
        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
#endif
        EGL_NONE
    };

    // Find out how many configs match the attributes.
    EGLint num_configs(0);
    if (!eglChooseConfig(egl_display_, config_attribs, 0, 0, &num_configs)) {
        Log::error("eglChooseConfig() (count query) failed with error: %d\n",
                   eglGetError());
        return false;
    }

    if (num_configs == 0) {
        Log::error("eglChooseConfig() didn't return any configs\n");
        return false;
    }

    // Get all the matching configs
    vector<EGLConfig> configs(num_configs);
    if (!eglChooseConfig(egl_display_, config_attribs, &configs.front(),
                         num_configs, &num_configs))
    {
        Log::error("eglChooseConfig() failed with error: %d\n",
                     eglGetError());
        return false;
    }

    // Select the best matching config
    egl_config_ = select_best_config(configs);
    if (!egl_config_) {
        Log::error("Failed to find suitable EGL config\n");
        return false;
    }

    vector<EglConfig> configVec;
    for (vector<EGLConfig>::const_iterator configIt = configs.begin();
         configIt != configs.end();
         configIt++)
    {
        EglConfig cfg(egl_display_, *configIt);
        configVec.push_back(cfg);
        if (*configIt == egl_config_) {
            best_config_ = cfg;
        }
    }

    // Print out the config information, and let the user know the decision
    // about the "best" one with respect to the options.
    unsigned int lineNumber(0);
    Log::debug("Got %u suitable EGLConfigs:\n", num_configs);
    for (vector<EglConfig>::const_iterator configIt = configVec.begin();
         configIt != configVec.end();
         configIt++, lineNumber++)
    {
        if (!(lineNumber % 32))
        {
            configIt->print_header();
        }
        configIt->print();
    }
    Log::debug("\n");
    Log::debug("Best EGLConfig ID: 0x%x\n", best_config_.configID());

    return true;
}

bool
GLStateEGL::gotValidSurface()
{
    if (egl_surface_)
        return true;

    if (!gotValidDisplay())
        return false;

    if (!gotValidConfig())
        return false;

    egl_surface_ = eglCreateWindowSurface(egl_display_, egl_config_, native_window_, 0);
    if (!egl_surface_) {
        Log::error("eglCreateWindowSurface failed with error: 0x%x\n", eglGetError());
        return false;
    }

    return true;
}

bool
GLStateEGL::gotValidContext()
{
    if (egl_context_)
        return true;

    if (!gotValidDisplay())
        return false;

    if (!gotValidConfig())
        return false;

    static const EGLint context_attribs[] = {
#ifdef GLMARK2_USE_GLESv2
        EGL_CONTEXT_CLIENT_VERSION, 2,
#endif
        EGL_NONE
    };

    egl_context_ = eglCreateContext(egl_display_, egl_config_,
                                    EGL_NO_CONTEXT, context_attribs);
    if (!egl_context_) {
        Log::error("eglCreateContext() failed with error: 0x%x\n",
                   eglGetError());
        return false;
    }

    return true;
}

GLADapiproc
GLStateEGL::load_proc(void *userptr, const char* name)
{
    if (eglGetProcAddress) {
        GLADapiproc sym = reinterpret_cast<GLADapiproc>(eglGetProcAddress(name));
        if (sym) {
            return sym;
        }
    }

    GLStateEGL* state = reinterpret_cast<GLStateEGL*>(userptr);
    return reinterpret_cast<GLADapiproc>(state->gl_lib_.load(name));
}