dolphin/Source/Core/Common/GL/GLInterface/EGL.cpp

// Copyright 2012 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#include <array>
#include <cstdlib>
#include <sstream>
#include <vector>

#include "Common/GL/GLInterface/EGL.h"
#include "Common/Logging/Log.h"

#ifndef EGL_KHR_create_context
#define EGL_KHR_create_context 1
#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD
#define EGL_NO_RESET_NOTIFICATION_KHR 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
#define EGL_OPENGL_ES3_BIT_KHR 0x00000040
#endif /* EGL_KHR_create_context */

// Show the current FPS
void cInterfaceEGL::Swap()
{
  if (egl_surf != EGL_NO_SURFACE)
    eglSwapBuffers(egl_dpy, egl_surf);
}
void cInterfaceEGL::SwapInterval(int Interval)
{
  eglSwapInterval(egl_dpy, Interval);
}

void* cInterfaceEGL::GetFuncAddress(const std::string& name)
{
  return (void*)eglGetProcAddress(name.c_str());
}

void cInterfaceEGL::DetectMode()
{
  if (s_opengl_mode != GLInterfaceMode::MODE_DETECT)
    return;

  EGLint num_configs;
  bool supportsGL = false, supportsGLES2 = false, supportsGLES3 = false;
  std::array<int, 3> renderable_types = {
      EGL_OPENGL_BIT, (1 << 6), /* EGL_OPENGL_ES3_BIT_KHR */
      EGL_OPENGL_ES2_BIT,
  };

  for (auto renderable_type : renderable_types)
  {
    // attributes for a visual in RGBA format with at least
    // 8 bits per color
    int attribs[] = {EGL_RED_SIZE,  8, EGL_GREEN_SIZE,      8,
                     EGL_BLUE_SIZE, 8, EGL_RENDERABLE_TYPE, renderable_type,
                     EGL_NONE};

    // Get how many configs there are
    if (!eglChooseConfig(egl_dpy, attribs, nullptr, 0, &num_configs))
    {
      INFO_LOG(VIDEO, "Error: couldn't get an EGL visual config\n");
      continue;
    }

    EGLConfig* config = new EGLConfig[num_configs];

    // Get all the configurations
    if (!eglChooseConfig(egl_dpy, attribs, config, num_configs, &num_configs))
    {
      INFO_LOG(VIDEO, "Error: couldn't get an EGL visual config\n");
      delete[] config;
      continue;
    }

    for (int i = 0; i < num_configs; ++i)
    {
      EGLint attribVal;
      bool ret;
      ret = eglGetConfigAttrib(egl_dpy, config[i], EGL_RENDERABLE_TYPE, &attribVal);
      if (ret)
      {
        if (attribVal & EGL_OPENGL_BIT)
          supportsGL = true;
        if (attribVal & (1 << 6)) /* EGL_OPENGL_ES3_BIT_KHR */
          supportsGLES3 = true;
        if (attribVal & EGL_OPENGL_ES2_BIT)
          supportsGLES2 = true;
      }
    }
    delete[] config;
  }

  if (supportsGL)
    s_opengl_mode = GLInterfaceMode::MODE_OPENGL;
  else if (supportsGLES3)
    s_opengl_mode = GLInterfaceMode::MODE_OPENGLES3;
  else if (supportsGLES2)
    s_opengl_mode = GLInterfaceMode::MODE_OPENGLES2;

  if (s_opengl_mode == GLInterfaceMode::MODE_DETECT)  // Errored before we found a mode
    s_opengl_mode = GLInterfaceMode::MODE_OPENGL;     // Fall back to OpenGL
}

// Create rendering window.
// Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
bool cInterfaceEGL::Create(void* window_handle, bool core)
{
  EGLint egl_major, egl_minor;
  bool supports_core_profile = false;

  egl_dpy = OpenDisplay();
  m_host_window = (EGLNativeWindowType)window_handle;
  m_has_handle = !!window_handle;
  m_core = core;

  if (!egl_dpy)
  {
    INFO_LOG(VIDEO, "Error: eglGetDisplay() failed\n");
    return false;
  }

  if (!eglInitialize(egl_dpy, &egl_major, &egl_minor))
  {
    INFO_LOG(VIDEO, "Error: eglInitialize() failed\n");
    return false;
  }

  /* Detection code */
  EGLint num_configs;

  DetectMode();

  // attributes for a visual in RGBA format with at least
  // 8 bits per color
  int attribs[] = {EGL_RENDERABLE_TYPE,
                   EGL_OPENGL_ES2_BIT,
                   EGL_RED_SIZE,
                   8,
                   EGL_GREEN_SIZE,
                   8,
                   EGL_BLUE_SIZE,
                   8,
                   EGL_NONE};

  std::vector<EGLint> ctx_attribs;
  switch (s_opengl_mode)
  {
  case GLInterfaceMode::MODE_OPENGL:
    attribs[1] = EGL_OPENGL_BIT;
    ctx_attribs = {EGL_NONE};
    break;
  case GLInterfaceMode::MODE_OPENGLES2:
    attribs[1] = EGL_OPENGL_ES2_BIT;
    ctx_attribs = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
    break;
  case GLInterfaceMode::MODE_OPENGLES3:
    attribs[1] = (1 << 6); /* EGL_OPENGL_ES3_BIT_KHR */
    ctx_attribs = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
    break;
  default:
    ERROR_LOG(VIDEO, "Unknown opengl mode set\n");
    return false;
    break;
  }

  if (!eglChooseConfig(egl_dpy, attribs, &m_config, 1, &num_configs))
  {
    INFO_LOG(VIDEO, "Error: couldn't get an EGL visual config\n");
    return false;
  }

  if (s_opengl_mode == GLInterfaceMode::MODE_OPENGL)
    eglBindAPI(EGL_OPENGL_API);
  else
    eglBindAPI(EGL_OPENGL_ES_API);

  std::string tmp;
  std::istringstream buffer(eglQueryString(egl_dpy, EGL_EXTENSIONS));
  while (buffer >> tmp)
  {
    if (tmp == "EGL_KHR_surfaceless_context")
      m_supports_surfaceless = true;
    else if (tmp == "EGL_KHR_create_context")
      supports_core_profile = true;
  }

  if (supports_core_profile && core && s_opengl_mode == GLInterfaceMode::MODE_OPENGL)
  {
    std::array<std::pair<int, int>, 7> versions_to_try = {{
        {4, 5}, {4, 4}, {4, 3}, {4, 2}, {4, 1}, {4, 0}, {3, 3},
    }};

    for (const auto& version : versions_to_try)
    {
      std::vector<EGLint> core_attribs = {EGL_CONTEXT_MAJOR_VERSION_KHR,
                                          version.first,
                                          EGL_CONTEXT_MINOR_VERSION_KHR,
                                          version.second,
                                          EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR,
                                          EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR,
                                          EGL_CONTEXT_FLAGS_KHR,
                                          EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR,
                                          EGL_NONE};

      egl_ctx = eglCreateContext(egl_dpy, m_config, EGL_NO_CONTEXT, &core_attribs[0]);
      if (egl_ctx)
        break;
    }
  }

  if (!egl_ctx)
  {
    m_core = false;
    egl_ctx = eglCreateContext(egl_dpy, m_config, EGL_NO_CONTEXT, &ctx_attribs[0]);
  }

  if (!egl_ctx)
  {
    INFO_LOG(VIDEO, "Error: eglCreateContext failed\n");
    return false;
  }

  if (!CreateWindowSurface())
  {
    ERROR_LOG(VIDEO, "Error: CreateWindowSurface failed 0x%04x\n", eglGetError());
    return false;
  }
  return true;
}

std::unique_ptr<cInterfaceBase> cInterfaceEGL::CreateSharedContext()
{
  std::unique_ptr<cInterfaceBase> context = std::make_unique<cInterfaceEGL>();
  if (!context->Create(this))
    return nullptr;
  return context;
}

bool cInterfaceEGL::Create(cInterfaceBase* main_context)
{
  cInterfaceEGL* egl_context = static_cast<cInterfaceEGL*>(main_context);

  egl_dpy = egl_context->egl_dpy;
  m_core = egl_context->m_core;
  m_config = egl_context->m_config;
  m_supports_surfaceless = egl_context->m_supports_surfaceless;
  m_is_shared = true;
  m_has_handle = false;

  EGLint ctx_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};

  switch (egl_context->GetMode())
  {
  case GLInterfaceMode::MODE_OPENGL:
    ctx_attribs[0] = EGL_NONE;
    break;
  case GLInterfaceMode::MODE_OPENGLES2:
    ctx_attribs[1] = 2;
    break;
  case GLInterfaceMode::MODE_OPENGLES3:
    ctx_attribs[1] = 3;
    break;
  default:
    INFO_LOG(VIDEO, "Unknown opengl mode set\n");
    return false;
    break;
  }

  if (egl_context->GetMode() == GLInterfaceMode::MODE_OPENGL)
    eglBindAPI(EGL_OPENGL_API);
  else
    eglBindAPI(EGL_OPENGL_ES_API);

  egl_ctx = eglCreateContext(egl_dpy, m_config, egl_context->egl_ctx, ctx_attribs);
  if (!egl_ctx)
  {
    INFO_LOG(VIDEO, "Error: eglCreateContext failed 0x%04x\n", eglGetError());
    return false;
  }

  if (!CreateWindowSurface())
  {
    ERROR_LOG(VIDEO, "Error: CreateWindowSurface failed 0x%04x\n", eglGetError());
    return false;
  }
  return true;
}

bool cInterfaceEGL::CreateWindowSurface()
{
  if (m_has_handle)
  {
    EGLNativeWindowType native_window = InitializePlatform(m_host_window, m_config);
    egl_surf = eglCreateWindowSurface(egl_dpy, m_config, native_window, nullptr);
    if (!egl_surf)
    {
      INFO_LOG(VIDEO, "Error: eglCreateWindowSurface failed\n");
      return false;
    }
  }
  else if (!m_supports_surfaceless)
  {
    EGLint attrib_list[] = {
        EGL_NONE,
    };
    egl_surf = eglCreatePbufferSurface(egl_dpy, m_config, attrib_list);
    if (!egl_surf)
    {
      INFO_LOG(VIDEO, "Error: eglCreatePbufferSurface failed");
      return false;
    }
  }
  else
  {
    egl_surf = EGL_NO_SURFACE;
  }
  return true;
}

void cInterfaceEGL::DestroyWindowSurface()
{
  if (egl_surf != EGL_NO_SURFACE && !eglDestroySurface(egl_dpy, egl_surf))
    NOTICE_LOG(VIDEO, "Could not destroy window surface.");
  egl_surf = EGL_NO_SURFACE;
}

bool cInterfaceEGL::MakeCurrent()
{
  return eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx);
}

void cInterfaceEGL::UpdateHandle(void* window_handle)
{
  m_host_window = (EGLNativeWindowType)window_handle;
  m_has_handle = !!window_handle;
}

void cInterfaceEGL::UpdateSurface()
{
  ClearCurrent();
  DestroyWindowSurface();
  CreateWindowSurface();
  MakeCurrent();
}

bool cInterfaceEGL::ClearCurrent()
{
  return eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}

// Close backend
void cInterfaceEGL::Shutdown()
{
  ShutdownPlatform();
  if (egl_ctx)
  {
    if (!eglMakeCurrent(egl_dpy, egl_surf, egl_surf, egl_ctx))
      NOTICE_LOG(VIDEO, "Could not release drawing context.");
    eglMakeCurrent(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    if (!eglDestroyContext(egl_dpy, egl_ctx))
      NOTICE_LOG(VIDEO, "Could not destroy drawing context.");
    DestroyWindowSurface();
    if (!m_is_shared && !eglTerminate(egl_dpy))
      NOTICE_LOG(VIDEO, "Could not destroy display connection.");
    egl_ctx = nullptr;
  }
}