framework/egl/egluGLUtil.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Tester Core
   3  * ----------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief EGL utilities for interfacing with GL APIs.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "egluGLUtil.hpp"
  25
  26 #include "egluUtil.hpp"
  27 #include "eglwLibrary.hpp"
  28 #include "eglwEnums.hpp"
  29 #include "glwEnums.hpp"
  30
  31 #include <vector>
  32
  33 using std::vector;
  34
  35 namespace eglu
  36 {
  37
  38 using namespace eglw;
  39
  40 glw::GLenum getImageGLTarget (EGLenum source)
  41 {
  42         switch (source)
  43         {
  44                 case EGL_GL_TEXTURE_2D_KHR:                                             return GL_TEXTURE_2D;
  45                 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:    return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
  46                 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:    return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
  47                 case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:    return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
  48                 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:    return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
  49                 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:    return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
  50                 case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:    return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
  51                 case EGL_GL_TEXTURE_3D_KHR:                                             return GL_TEXTURE_3D;
  52                 case EGL_GL_RENDERBUFFER_KHR:                                   return GL_RENDERBUFFER;
  53                 default:        DE_FATAL("Impossible");                         return GL_NONE;
  54         }
  55 }
  56
  57 EGLint apiRenderableType (glu::ApiType apiType)
  58 {
  59         switch (apiType.getProfile())
  60         {
  61                 case glu::PROFILE_CORE:
  62                 case glu::PROFILE_COMPATIBILITY:
  63                         return EGL_OPENGL_BIT;
  64                 case glu::PROFILE_ES:
  65                         switch (apiType.getMajorVersion())
  66                         {
  67                                 case 1:         return EGL_OPENGL_ES_BIT;
  68                                 case 2:         return EGL_OPENGL_ES2_BIT;
  69                                 case 3:         return EGL_OPENGL_ES3_BIT_KHR;
  70                                 default:        DE_FATAL("Unknown OpenGL ES version");
  71                         }
  72                 default:
  73                         DE_FATAL("Unknown GL API");
  74         }
  75
  76         return 0;
  77 }
  78
  79 EGLContext createGLContext (const Library&                                      egl,
  80                                                         EGLDisplay                                              display,
  81                                                         EGLContext                                              eglConfig,
  82                                                         const glu::ContextType&                 contextType,
  83                                                         glu::ResetNotificationStrategy  resetNotificationStrategy)
  84 {
  85         const bool                      khrCreateContextSupported                       = hasExtension(egl, display, "EGL_KHR_create_context");
  86         const bool                      khrCreateContextNoErrorSupported        = hasExtension(egl, display, "EGL_KHR_create_context_no_error");
  87         EGLContext                      context                                                         = EGL_NO_CONTEXT;
  88         EGLenum                         api                                                                     = EGL_NONE;
  89         vector<EGLint>          attribList;
  90
  91         if (glu::isContextTypeES(contextType))
  92         {
  93                 api = EGL_OPENGL_ES_API;
  94
  95                 if (contextType.getMajorVersion() <= 2)
  96                 {
  97                         attribList.push_back(EGL_CONTEXT_CLIENT_VERSION);
  98                         attribList.push_back(contextType.getMajorVersion());
  99                 }
 100                 else
 101                 {
 102                         if (!khrCreateContextSupported)
 103                                 TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for OpenGL ES 3.0 and newer");
 104
 105                         attribList.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
 106                         attribList.push_back(contextType.getMajorVersion());
 107                         attribList.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
 108                         attribList.push_back(contextType.getMinorVersion());
 109                 }
 110         }
 111         else
 112         {
 113                 DE_ASSERT(glu::isContextTypeGLCore(contextType) || glu::isContextTypeGLCompatibility(contextType));
 114
 115                 if (!khrCreateContextSupported)
 116                         TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for OpenGL context creation");
 117
 118                 api = EGL_OPENGL_API;
 119
 120                 attribList.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
 121                 attribList.push_back(contextType.getMajorVersion());
 122                 attribList.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
 123                 attribList.push_back(contextType.getMinorVersion());
 124                 attribList.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
 125                 attribList.push_back(glu::isContextTypeGLCore(contextType) ? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
 126                                                                                                                                    : EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
 127         }
 128
 129         if (contextType.getFlags() != glu::ContextFlags(0))
 130         {
 131                 EGLint flags = 0;
 132
 133                 if (!khrCreateContextSupported)
 134                         TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for creating robust/debug/forward-compatible contexts");
 135
 136                 if ((contextType.getFlags() & glu::CONTEXT_DEBUG) != 0)
 137                         flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
 138
 139                 if ((contextType.getFlags() & glu::CONTEXT_ROBUST) != 0)
 140                 {
 141                         if (glu::isContextTypeES(contextType))
 142                         {
 143                                 if (!hasExtension(egl, display, "EGL_EXT_create_context_robustness") && (getVersion(egl, display) < Version(1, 5)))
 144                                         TCU_THROW(NotSupportedError, "EGL_EXT_create_context_robustness is required for creating robust context");
 145
 146                                 attribList.push_back(EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT);
 147                                 attribList.push_back(EGL_TRUE);
 148                         }
 149                         else
 150                                 flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
 151                 }
 152
 153                 if ((contextType.getFlags() & glu::CONTEXT_NO_ERROR) != 0)
 154                 {
 155                         if (khrCreateContextNoErrorSupported)
 156                         {
 157                                 attribList.push_back(EGL_CONTEXT_OPENGL_NO_ERROR_KHR);
 158                                 attribList.push_back(EGL_TRUE);
 159                         }
 160                         else
 161                                 throw tcu::NotSupportedError("EGL_KHR_create_context_no_error is required for creating no-error contexts");
 162                 }
 163
 164                 if ((contextType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
 165                 {
 166                         if (!glu::isContextTypeGLCore(contextType))
 167                                 TCU_THROW(InternalError, "Only OpenGL core contexts can be forward-compatible");
 168
 169                         flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
 170                 }
 171
 172                 attribList.push_back(EGL_CONTEXT_FLAGS_KHR);
 173                 attribList.push_back(flags);
 174
 175                 if (resetNotificationStrategy != glu::RESET_NOTIFICATION_STRATEGY_NOT_SPECIFIED)
 176                 {
 177                         if (getVersion(egl, display) >= Version(1, 5) || glu::isContextTypeGLCore(contextType) || glu::isContextTypeGLCompatibility(contextType))
 178                                 attribList.push_back(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR);
 179                         else if (hasExtension(egl, display, "EGL_EXT_create_context_robustness"))
 180                                 attribList.push_back(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT);
 181                         else
 182                                 TCU_THROW(NotSupportedError, "EGL 1.5 or EGL_EXT_create_context_robustness is required for creating robust context");
 183
 184                         if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_NO_RESET_NOTIFICATION)
 185                                 attribList.push_back(EGL_NO_RESET_NOTIFICATION_KHR);
 186                         else if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_LOSE_CONTEXT_ON_RESET)
 187                                 attribList.push_back(EGL_LOSE_CONTEXT_ON_RESET_KHR);
 188                         else
 189                                 TCU_THROW(InternalError, "Unknown reset notification strategy");
 190                 }
 191         }
 192
 193         attribList.push_back(EGL_NONE);
 194
 195         EGLU_CHECK_CALL(egl, bindAPI(api));
 196         context = egl.createContext(display, eglConfig, EGL_NO_CONTEXT, &(attribList[0]));
 197         EGLU_CHECK_MSG(egl, "eglCreateContext()");
 198
 199         return context;
 200 }
 201
 202 static bool configMatches (const eglw::Library& egl, eglw::EGLDisplay display, eglw::EGLConfig eglConfig, const glu::RenderConfig& renderConfig)
 203 {
 204         // \todo [2014-03-12 pyry] Check other attributes like double-buffer bit.
 205
 206         {
 207                 EGLint          renderableType          = 0;
 208                 EGLint          requiredRenderable      = apiRenderableType(renderConfig.type.getAPI());
 209
 210                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, EGL_RENDERABLE_TYPE, &renderableType));
 211
 212                 if ((renderableType & requiredRenderable) == 0)
 213                         return false;
 214         }
 215
 216         if (renderConfig.surfaceType != glu::RenderConfig::SURFACETYPE_DONT_CARE)
 217         {
 218                 EGLint          surfaceType             = 0;
 219                 EGLint          requiredSurface = 0;
 220
 221                 switch (renderConfig.surfaceType)
 222                 {
 223                         case glu::RenderConfig::SURFACETYPE_WINDOW:                             requiredSurface = EGL_WINDOW_BIT;       break;
 224                         case glu::RenderConfig::SURFACETYPE_OFFSCREEN_NATIVE:   requiredSurface = EGL_PIXMAP_BIT;       break;
 225                         case glu::RenderConfig::SURFACETYPE_OFFSCREEN_GENERIC:  requiredSurface = EGL_PBUFFER_BIT;      break;
 226                         default:
 227                                 DE_ASSERT(false);
 228                 }
 229
 230                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, EGL_SURFACE_TYPE, &surfaceType));
 231
 232                 if ((surfaceType & requiredSurface) == 0)
 233                         return false;
 234         }
 235
 236         {
 237                 static const struct
 238                 {
 239                         int     glu::RenderConfig::*field;
 240                         EGLint attrib;
 241                 } s_attribs[] =
 242                 {
 243                         { &glu::RenderConfig::id,                       EGL_CONFIG_ID           },
 244                         { &glu::RenderConfig::redBits,          EGL_RED_SIZE            },
 245                         { &glu::RenderConfig::greenBits,        EGL_GREEN_SIZE          },
 246                         { &glu::RenderConfig::blueBits,         EGL_BLUE_SIZE           },
 247                         { &glu::RenderConfig::alphaBits,        EGL_ALPHA_SIZE          },
 248                         { &glu::RenderConfig::depthBits,        EGL_DEPTH_SIZE          },
 249                         { &glu::RenderConfig::stencilBits,      EGL_STENCIL_SIZE        },
 250                         { &glu::RenderConfig::numSamples,       EGL_SAMPLES                     },
 251                 };
 252
 253                 for (int attribNdx = 0; attribNdx < DE_LENGTH_OF_ARRAY(s_attribs); attribNdx++)
 254                 {
 255                         if (renderConfig.*s_attribs[attribNdx].field != glu::RenderConfig::DONT_CARE)
 256                         {
 257                                 EGLint value = 0;
 258                                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, s_attribs[attribNdx].attrib, &value));
 259                                 if (value != renderConfig.*s_attribs[attribNdx].field)
 260                                         return false;
 261                         }
 262                 }
 263         }
 264
 265         return true;
 266 }
 267
 268 EGLConfig chooseConfig (const Library& egl, EGLDisplay display, const glu::RenderConfig& config)
 269 {
 270         const std::vector<EGLConfig> configs = eglu::getConfigs(egl, display);
 271
 272         for (vector<EGLConfig>::const_iterator iter = configs.begin(); iter != configs.end(); ++iter)
 273         {
 274                 if (configMatches(egl, display, *iter, config))
 275                         return *iter;
 276         }
 277
 278         throw tcu::NotSupportedError("Matching EGL config not found", DE_NULL, __FILE__, __LINE__);
 279 }
 280
 281 }