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                                                         eglw::EGLContext                                sharedContext,
  84                                                         glu::ResetNotificationStrategy  resetNotificationStrategy)
  85 {
  86         const bool                      khrCreateContextSupported                       = hasExtension(egl, display, "EGL_KHR_create_context");
  87         const bool                      khrCreateContextNoErrorSupported        = hasExtension(egl, display, "EGL_KHR_create_context_no_error");
  88         EGLContext                      context                                                         = EGL_NO_CONTEXT;
  89         EGLenum                         api                                                                     = EGL_NONE;
  90         vector<EGLint>          attribList;
  91
  92         if (glu::isContextTypeES(contextType))
  93         {
  94                 api = EGL_OPENGL_ES_API;
  95
  96                 if (contextType.getMajorVersion() <= 2)
  97                 {
  98                         attribList.push_back(EGL_CONTEXT_CLIENT_VERSION);
  99                         attribList.push_back(contextType.getMajorVersion());
 100                 }
 101                 else
 102                 {
 103                         if (!khrCreateContextSupported)
 104                                 TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for OpenGL ES 3.0 and newer");
 105
 106                         attribList.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
 107                         attribList.push_back(contextType.getMajorVersion());
 108                         attribList.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
 109                         attribList.push_back(contextType.getMinorVersion());
 110                 }
 111         }
 112         else
 113         {
 114                 DE_ASSERT(glu::isContextTypeGLCore(contextType) || glu::isContextTypeGLCompatibility(contextType));
 115
 116                 if (!khrCreateContextSupported)
 117                         TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for OpenGL context creation");
 118
 119                 api = EGL_OPENGL_API;
 120
 121                 attribList.push_back(EGL_CONTEXT_MAJOR_VERSION_KHR);
 122                 attribList.push_back(contextType.getMajorVersion());
 123                 attribList.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
 124                 attribList.push_back(contextType.getMinorVersion());
 125                 attribList.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
 126                 attribList.push_back(glu::isContextTypeGLCore(contextType) ? EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
 127                                                                                                                                    : EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR);
 128         }
 129
 130         if (contextType.getFlags() != glu::ContextFlags(0))
 131         {
 132                 EGLint flags = 0;
 133
 134                 if (!khrCreateContextSupported)
 135                         TCU_THROW(NotSupportedError, "EGL_KHR_create_context is required for creating robust/debug/forward-compatible contexts");
 136
 137                 if ((contextType.getFlags() & glu::CONTEXT_DEBUG) != 0)
 138                         flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
 139
 140                 if ((contextType.getFlags() & glu::CONTEXT_ROBUST) != 0)
 141                 {
 142                         if (glu::isContextTypeES(contextType))
 143                         {
 144                                 if (!hasExtension(egl, display, "EGL_EXT_create_context_robustness") && (getVersion(egl, display) < Version(1, 5)))
 145                                         TCU_THROW(NotSupportedError, "EGL_EXT_create_context_robustness is required for creating robust context");
 146
 147                                 attribList.push_back(EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT);
 148                                 attribList.push_back(EGL_TRUE);
 149                         }
 150                         else
 151                                 flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
 152                 }
 153
 154                 if ((contextType.getFlags() & glu::CONTEXT_NO_ERROR) != 0)
 155                 {
 156                         if (khrCreateContextNoErrorSupported)
 157                         {
 158                                 attribList.push_back(EGL_CONTEXT_OPENGL_NO_ERROR_KHR);
 159                                 attribList.push_back(EGL_TRUE);
 160                         }
 161                         else
 162                                 throw tcu::NotSupportedError("EGL_KHR_create_context_no_error is required for creating no-error contexts");
 163                 }
 164
 165                 if ((contextType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
 166                 {
 167                         if (!glu::isContextTypeGLCore(contextType))
 168                                 TCU_THROW(InternalError, "Only OpenGL core contexts can be forward-compatible");
 169
 170                         flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
 171                 }
 172
 173                 attribList.push_back(EGL_CONTEXT_FLAGS_KHR);
 174                 attribList.push_back(flags);
 175
 176                 if (resetNotificationStrategy != glu::RESET_NOTIFICATION_STRATEGY_NOT_SPECIFIED)
 177                 {
 178                         if (getVersion(egl, display) >= Version(1, 5) || glu::isContextTypeGLCore(contextType) || glu::isContextTypeGLCompatibility(contextType))
 179                                 attribList.push_back(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR);
 180                         else if (hasExtension(egl, display, "EGL_EXT_create_context_robustness"))
 181                                 attribList.push_back(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT);
 182                         else
 183                                 TCU_THROW(NotSupportedError, "EGL 1.5 or EGL_EXT_create_context_robustness is required for creating robust context");
 184
 185                         if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_NO_RESET_NOTIFICATION)
 186                                 attribList.push_back(EGL_NO_RESET_NOTIFICATION_KHR);
 187                         else if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_LOSE_CONTEXT_ON_RESET)
 188                                 attribList.push_back(EGL_LOSE_CONTEXT_ON_RESET_KHR);
 189                         else
 190                                 TCU_THROW(InternalError, "Unknown reset notification strategy");
 191                 }
 192         }
 193
 194         attribList.push_back(EGL_NONE);
 195
 196         EGLU_CHECK_CALL(egl, bindAPI(api));
 197         context = egl.createContext(display, eglConfig, sharedContext, &(attribList[0]));
 198         EGLU_CHECK_MSG(egl, "eglCreateContext()");
 199
 200         return context;
 201 }
 202
 203 static bool configMatches (const eglw::Library& egl, eglw::EGLDisplay display, eglw::EGLConfig eglConfig, const glu::RenderConfig& renderConfig)
 204 {
 205         // \todo [2014-03-12 pyry] Check other attributes like double-buffer bit.
 206
 207         {
 208                 EGLint          renderableType          = 0;
 209                 EGLint          requiredRenderable      = apiRenderableType(renderConfig.type.getAPI());
 210
 211                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, EGL_RENDERABLE_TYPE, &renderableType));
 212
 213                 if ((renderableType & requiredRenderable) == 0)
 214                         return false;
 215         }
 216
 217         if (renderConfig.surfaceType != glu::RenderConfig::SURFACETYPE_DONT_CARE)
 218         {
 219                 EGLint          surfaceType             = 0;
 220                 EGLint          requiredSurface = 0;
 221
 222                 switch (renderConfig.surfaceType)
 223                 {
 224                         case glu::RenderConfig::SURFACETYPE_WINDOW:                             requiredSurface = EGL_WINDOW_BIT;       break;
 225                         case glu::RenderConfig::SURFACETYPE_OFFSCREEN_NATIVE:   requiredSurface = EGL_PIXMAP_BIT;       break;
 226                         case glu::RenderConfig::SURFACETYPE_OFFSCREEN_GENERIC:  requiredSurface = EGL_PBUFFER_BIT;      break;
 227                         default:
 228                                 DE_ASSERT(false);
 229                 }
 230
 231                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, EGL_SURFACE_TYPE, &surfaceType));
 232
 233                 if ((surfaceType & requiredSurface) == 0)
 234                         return false;
 235         }
 236
 237         {
 238                 static const struct
 239                 {
 240                         int     glu::RenderConfig::*field;
 241                         EGLint attrib;
 242                 } s_attribs[] =
 243                 {
 244                         { &glu::RenderConfig::id,                       EGL_CONFIG_ID           },
 245                         { &glu::RenderConfig::redBits,          EGL_RED_SIZE            },
 246                         { &glu::RenderConfig::greenBits,        EGL_GREEN_SIZE          },
 247                         { &glu::RenderConfig::blueBits,         EGL_BLUE_SIZE           },
 248                         { &glu::RenderConfig::alphaBits,        EGL_ALPHA_SIZE          },
 249                         { &glu::RenderConfig::depthBits,        EGL_DEPTH_SIZE          },
 250                         { &glu::RenderConfig::stencilBits,      EGL_STENCIL_SIZE        },
 251                         { &glu::RenderConfig::numSamples,       EGL_SAMPLES                     },
 252                 };
 253
 254                 for (int attribNdx = 0; attribNdx < DE_LENGTH_OF_ARRAY(s_attribs); attribNdx++)
 255                 {
 256                         if (renderConfig.*s_attribs[attribNdx].field != glu::RenderConfig::DONT_CARE)
 257                         {
 258                                 EGLint value = 0;
 259                                 EGLU_CHECK_CALL(egl, getConfigAttrib(display, eglConfig, s_attribs[attribNdx].attrib, &value));
 260                                 if (value != renderConfig.*s_attribs[attribNdx].field)
 261                                         return false;
 262                         }
 263                 }
 264         }
 265
 266         return true;
 267 }
 268
 269 EGLConfig chooseConfig (const Library& egl, EGLDisplay display, const glu::RenderConfig& config)
 270 {
 271         const std::vector<EGLConfig> configs = eglu::getConfigs(egl, display);
 272
 273         for (vector<EGLConfig>::const_iterator iter = configs.begin(); iter != configs.end(); ++iter)
 274         {
 275                 if (configMatches(egl, display, *iter, config))
 276                         return *iter;
 277         }
 278
 279         throw tcu::NotSupportedError("Matching EGL config not found", DE_NULL, __FILE__, __LINE__);
 280 }
 281
 282 }