dali/internal/graphics/gles/egl-implementation.cpp

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18
  19 // CLASS HEADER
  20 #include <dali/internal/graphics/gles/egl-implementation.h>
  21
  22 // EXTERNAL INCLUDES
  23 #include <sstream>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/public-api/common/dali-vector.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali/public-api/dali-adaptor-common.h>
  29 #include <dali/internal/graphics/gles/gl-implementation.h>
  30 #include <dali/internal/graphics/gles/egl-debug.h>
  31
  32 // EGL constants use C style casts
  33 #pragma GCC diagnostic push
  34 #pragma GCC diagnostic ignored "-Wold-style-cast"
  35
  36 namespace
  37 {
  38   const uint32_t CHECK_EXTENSION_NUMBER = 2;
  39   const std::string EGL_KHR_SURFACELESS_CONTEXT = "EGL_KHR_surfaceless_context";
  40   const std::string EGL_KHR_CREATE_CONTEXT = "EGL_KHR_create_context";
  41 }
  42
  43 namespace Dali
  44 {
  45
  46 namespace Internal
  47 {
  48
  49 namespace Adaptor
  50 {
  51
  52 #define TEST_EGL_ERROR(lastCommand) \
  53 { \
  54   EGLint err = eglGetError(); \
  55   if (err != EGL_SUCCESS) \
  56   { \
  57     DALI_LOG_ERROR("EGL error after %s\n", lastCommand); \
  58     Egl::PrintError(err); \
  59     DALI_ASSERT_ALWAYS(0 && "EGL error"); \
  60   } \
  61 }
  62
  63 EglImplementation::EglImplementation( int multiSamplingLevel,
  64                                       Integration::DepthBufferAvailable depthBufferRequired,
  65                                       Integration::StencilBufferAvailable stencilBufferRequired )
  66 : mContextAttribs(),
  67   mEglNativeDisplay( 0 ),
  68   mEglNativeWindow( 0 ),
  69   mCurrentEglNativePixmap( 0 ),
  70   mEglDisplay( 0 ),
  71   mEglConfig( 0 ),
  72   mEglContext( 0 ),
  73   mCurrentEglSurface( 0 ),
  74   mCurrentEglContext( EGL_NO_CONTEXT ),
  75   mMultiSamplingLevel( multiSamplingLevel ),
  76   mGlesVersion( 30 ),
  77   mColorDepth( COLOR_DEPTH_24 ),
  78   mGlesInitialized( false ),
  79   mIsOwnSurface( true ),
  80   mIsWindow( true ),
  81   mDepthBufferRequired( depthBufferRequired == Integration::DepthBufferAvailable::TRUE ),
  82   mStencilBufferRequired( stencilBufferRequired == Integration::StencilBufferAvailable::TRUE ),
  83   mIsSurfacelessContextSupported( false ),
  84   mIsKhrCreateContextSupported( false )
  85 {
  86 }
  87
  88 EglImplementation::~EglImplementation()
  89 {
  90   TerminateGles();
  91 }
  92
  93 bool EglImplementation::InitializeGles( EGLNativeDisplayType display, bool isOwnSurface )
  94 {
  95   if ( !mGlesInitialized )
  96   {
  97     mEglNativeDisplay = display;
  98
  99     //@todo see if we can just EGL_DEFAULT_DISPLAY instead
 100     mEglDisplay = eglGetDisplay(mEglNativeDisplay);
 101     EGLint error = eglGetError();
 102
 103     if( mEglDisplay == NULL && error != EGL_SUCCESS )
 104     {
 105       throw Dali::DaliException( "", "OpenGL ES is not supported");
 106     }
 107
 108     EGLint majorVersion = 0;
 109     EGLint minorVersion = 0;
 110     if ( !eglInitialize( mEglDisplay, &majorVersion, &minorVersion ) )
 111     {
 112       return false;
 113     }
 114     eglBindAPI(EGL_OPENGL_ES_API);
 115
 116     mGlesInitialized = true;
 117     mIsOwnSurface = isOwnSurface;
 118   }
 119
 120   // Query EGL extensions to check whether surfaceless context is supported
 121   const char* const extensionStr = eglQueryString( mEglDisplay, EGL_EXTENSIONS );
 122   std::istringstream stream( extensionStr );
 123   std::string currentExtension;
 124   uint32_t extensionCheckCount = 0;
 125   while( std::getline( stream, currentExtension, ' ' ) && extensionCheckCount < CHECK_EXTENSION_NUMBER )
 126   {
 127     if( currentExtension == EGL_KHR_SURFACELESS_CONTEXT )
 128     {
 129       mIsSurfacelessContextSupported = true;
 130       extensionCheckCount++;
 131     }
 132     if( currentExtension == EGL_KHR_CREATE_CONTEXT )
 133     {
 134       mIsKhrCreateContextSupported = true;
 135       extensionCheckCount++;
 136     }
 137   }
 138
 139   // We want to display this information all the time, so use the LogMessage directly
 140   Integration::Log::LogMessage(Integration::Log::DebugInfo, "EGL Information\n"
 141       "            Vendor:        %s\n"
 142       "            Version:       %s\n"
 143       "            Client APIs:   %s\n"
 144       "            Extensions:    %s\n",
 145       eglQueryString( mEglDisplay, EGL_VENDOR ),
 146       eglQueryString( mEglDisplay, EGL_VERSION ),
 147       eglQueryString( mEglDisplay, EGL_CLIENT_APIS ),
 148       extensionStr);
 149
 150   return mGlesInitialized;
 151 }
 152
 153 bool EglImplementation::CreateContext()
 154 {
 155   // make sure a context isn't created twice
 156   DALI_ASSERT_ALWAYS( (mEglContext == 0) && "EGL context recreated" );
 157
 158   mEglContext = eglCreateContext(mEglDisplay, mEglConfig, NULL, &(mContextAttribs[0]));
 159   TEST_EGL_ERROR("eglCreateContext render thread");
 160
 161   DALI_ASSERT_ALWAYS( EGL_NO_CONTEXT != mEglContext && "EGL context not created" );
 162
 163   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VENDOR : %s ***\n", glGetString(GL_VENDOR));
 164   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_RENDERER : %s ***\n", glGetString(GL_RENDERER));
 165   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VERSION : %s ***\n", glGetString(GL_VERSION));
 166   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_SHADING_LANGUAGE_VERSION : %s***\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
 167   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** Supported Extensions ***\n%s\n\n", glGetString(GL_EXTENSIONS));
 168
 169   return true;
 170 }
 171
 172 bool EglImplementation::CreateWindowContext( EGLContext& eglContext )
 173 {
 174   // make sure a context isn't created twice
 175   DALI_ASSERT_ALWAYS( (eglContext == 0) && "EGL context recreated" );
 176
 177   eglContext = eglCreateContext(mEglDisplay, mEglConfig, mEglContext, &(mContextAttribs[0]));
 178   TEST_EGL_ERROR("eglCreateContext render thread");
 179
 180   DALI_ASSERT_ALWAYS( EGL_NO_CONTEXT != eglContext && "EGL context not created" );
 181
 182   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VENDOR : %s ***\n", glGetString(GL_VENDOR));
 183   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_RENDERER : %s ***\n", glGetString(GL_RENDERER));
 184   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VERSION : %s ***\n", glGetString(GL_VERSION));
 185   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_SHADING_LANGUAGE_VERSION : %s***\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
 186   DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** Supported Extensions ***\n%s\n\n", glGetString(GL_EXTENSIONS));
 187
 188   mEglWindowContexts.push_back( eglContext );
 189
 190   return true;
 191 }
 192
 193 void EglImplementation::DestroyContext( EGLContext& eglContext )
 194 {
 195   DALI_ASSERT_ALWAYS( mEglContext && "no EGL context" );
 196
 197   eglDestroyContext( mEglDisplay, eglContext );
 198   eglContext = 0;
 199 }
 200
 201 void EglImplementation::DestroySurface( EGLSurface& eglSurface )
 202 {
 203   if(mIsOwnSurface && eglSurface)
 204   {
 205     // Make context null to prevent crash in driver side
 206     MakeContextNull();
 207     eglDestroySurface( mEglDisplay, eglSurface );
 208     eglSurface = 0;
 209   }
 210 }
 211
 212 void EglImplementation::MakeContextCurrent( EGLSurface eglSurface, EGLContext eglContext )
 213 {
 214   if (mCurrentEglContext == eglContext)
 215   {
 216     return;
 217   }
 218
 219   mCurrentEglSurface = eglSurface;
 220
 221   if(mIsOwnSurface)
 222   {
 223     if( mCurrentEglContext != EGL_NO_CONTEXT )
 224     {
 225       glFinish();
 226     }
 227
 228     eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, eglContext );
 229
 230     mCurrentEglContext = eglContext;
 231   }
 232
 233   EGLint error = eglGetError();
 234
 235   if ( error != EGL_SUCCESS )
 236   {
 237     Egl::PrintError(error);
 238
 239     DALI_ASSERT_ALWAYS(false && "MakeContextCurrent failed!");
 240   }
 241 }
 242
 243 void EglImplementation::MakeCurrent( EGLNativePixmapType pixmap, EGLSurface eglSurface )
 244 {
 245   if (mCurrentEglContext == mEglContext)
 246   {
 247     return;
 248   }
 249
 250   mCurrentEglNativePixmap = pixmap;
 251   mCurrentEglSurface = eglSurface;
 252
 253   if(mIsOwnSurface)
 254   {
 255     if( mCurrentEglContext != EGL_NO_CONTEXT )
 256     {
 257       glFinish();
 258     }
 259
 260     eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, mEglContext );
 261
 262     mCurrentEglContext = mEglContext;
 263   }
 264
 265   EGLint error = eglGetError();
 266
 267   if ( error != EGL_SUCCESS )
 268   {
 269     Egl::PrintError(error);
 270
 271     DALI_ASSERT_ALWAYS(false && "MakeCurrent failed!");
 272   }
 273 }
 274
 275 void EglImplementation::MakeContextNull()
 276 {
 277   // clear the current context
 278   eglMakeCurrent( mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
 279   mCurrentEglContext = EGL_NO_CONTEXT;
 280 }
 281
 282 void EglImplementation::TerminateGles()
 283 {
 284   if ( mGlesInitialized )
 285   {
 286     // Make context null to prevent crash in driver side
 287     MakeContextNull();
 288
 289     for ( auto eglSurface : mEglWindowSurfaces )
 290     {
 291       if(mIsOwnSurface && eglSurface)
 292       {
 293         eglDestroySurface(mEglDisplay, eglSurface);
 294       }
 295     }
 296     eglDestroyContext(mEglDisplay, mEglContext);
 297     for ( auto eglContext : mEglWindowContexts )
 298     {
 299       eglDestroyContext(mEglDisplay, eglContext);
 300     }
 301
 302     eglTerminate(mEglDisplay);
 303
 304     mEglDisplay = NULL;
 305     mEglConfig  = NULL;
 306     mEglContext = NULL;
 307     mCurrentEglSurface = NULL;
 308     mCurrentEglContext = EGL_NO_CONTEXT;
 309
 310     mGlesInitialized = false;
 311   }
 312 }
 313
 314 bool EglImplementation::IsGlesInitialized() const
 315 {
 316   return mGlesInitialized;
 317 }
 318
 319 void EglImplementation::SwapBuffers( EGLSurface& eglSurface )
 320 {
 321   if ( eglSurface != EGL_NO_SURFACE ) // skip if using surfaceless context
 322   {
 323     eglSwapBuffers( mEglDisplay, eglSurface );
 324   }
 325 }
 326
 327 void EglImplementation::CopyBuffers( EGLSurface& eglSurface )
 328 {
 329   eglCopyBuffers( mEglDisplay, eglSurface, mCurrentEglNativePixmap );
 330 }
 331
 332 void EglImplementation::WaitGL()
 333 {
 334   eglWaitGL();
 335 }
 336
 337 bool EglImplementation::ChooseConfig( bool isWindowType, ColorDepth depth )
 338 {
 339   if(mEglConfig && isWindowType == mIsWindow && mColorDepth == depth)
 340   {
 341     return true;
 342   }
 343
 344   bool isTransparent = ( depth == COLOR_DEPTH_32 );
 345
 346   mColorDepth = depth;
 347   mIsWindow = isWindowType;
 348
 349   EGLint numConfigs;
 350   Vector<EGLint> configAttribs;
 351   configAttribs.Reserve(31);
 352
 353   if(isWindowType)
 354   {
 355     configAttribs.PushBack( EGL_SURFACE_TYPE );
 356     configAttribs.PushBack( EGL_WINDOW_BIT );
 357   }
 358   else
 359   {
 360     configAttribs.PushBack( EGL_SURFACE_TYPE );
 361     configAttribs.PushBack( EGL_PIXMAP_BIT );
 362   }
 363
 364   configAttribs.PushBack( EGL_RENDERABLE_TYPE );
 365
 366   if( mGlesVersion >= 30 )
 367   {
 368     configAttribs.PushBack( EGL_OPENGL_ES3_BIT_KHR );
 369   }
 370   else
 371   {
 372     configAttribs.PushBack( EGL_OPENGL_ES2_BIT );
 373   }
 374
 375 // TODO: enable this flag when it becomes supported
 376 //  configAttribs.PushBack( EGL_CONTEXT_FLAGS_KHR );
 377 //  configAttribs.PushBack( EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR );
 378
 379   configAttribs.PushBack( EGL_RED_SIZE );
 380   configAttribs.PushBack( 8 );
 381   configAttribs.PushBack( EGL_GREEN_SIZE );
 382   configAttribs.PushBack( 8 );
 383   configAttribs.PushBack( EGL_BLUE_SIZE );
 384   configAttribs.PushBack( 8 );
 385
 386   if ( isTransparent )
 387   {
 388     configAttribs.PushBack( EGL_ALPHA_SIZE );
 389 #ifdef _ARCH_ARM_
 390     // For underlay video playback, we also need to set the alpha value of the 24/32bit window.
 391     configAttribs.PushBack( 8 );
 392 #else
 393     // There is a bug in the desktop emulator
 394     // setting EGL_ALPHA_SIZE to 8 results in eglChooseConfig failing
 395     configAttribs.PushBack( 8 );
 396 #endif // _ARCH_ARM_
 397   }
 398
 399   configAttribs.PushBack( EGL_DEPTH_SIZE );
 400   configAttribs.PushBack( mDepthBufferRequired ? 24 : 0 );
 401   configAttribs.PushBack( EGL_STENCIL_SIZE );
 402   configAttribs.PushBack( mStencilBufferRequired ? 8 : 0 );
 403
 404 #ifndef DALI_PROFILE_UBUNTU
 405   if( mMultiSamplingLevel != EGL_DONT_CARE )
 406   {
 407     configAttribs.PushBack( EGL_SAMPLES );
 408     configAttribs.PushBack( mMultiSamplingLevel );
 409     configAttribs.PushBack( EGL_SAMPLE_BUFFERS );
 410     configAttribs.PushBack( 1 );
 411   }
 412 #endif // DALI_PROFILE_UBUNTU
 413   configAttribs.PushBack( EGL_NONE );
 414
 415   // Ensure number of configs is set to 1 as on some drivers,
 416   // eglChooseConfig succeeds but does not actually create a proper configuration.
 417   if ( ( eglChooseConfig( mEglDisplay, &(configAttribs[0]), &mEglConfig, 1, &numConfigs ) != EGL_TRUE ) ||
 418        ( numConfigs != 1 ) )
 419   {
 420     if( mGlesVersion >= 30 )
 421     {
 422       mEglConfig = NULL;
 423       DALI_LOG_ERROR("Fail to use OpenGL es 3.0. Retrying to use OpenGL es 2.0.");
 424       return false;
 425     }
 426
 427     if ( numConfigs != 1 )
 428     {
 429       DALI_LOG_ERROR("No configurations found.\n");
 430
 431       TEST_EGL_ERROR("eglChooseConfig");
 432     }
 433
 434     EGLint error = eglGetError();
 435     switch (error)
 436     {
 437       case EGL_BAD_DISPLAY:
 438       {
 439         DALI_LOG_ERROR("Display is not an EGL display connection\n");
 440         break;
 441       }
 442       case EGL_BAD_ATTRIBUTE:
 443       {
 444         DALI_LOG_ERROR("The parameter configAttribs contains an invalid frame buffer configuration attribute or an attribute value that is unrecognized or out of range\n");
 445         break;
 446       }
 447       case EGL_NOT_INITIALIZED:
 448       {
 449         DALI_LOG_ERROR("Display has not been initialized\n");
 450         break;
 451       }
 452       case EGL_BAD_PARAMETER:
 453       {
 454         DALI_LOG_ERROR("The parameter numConfig is NULL\n");
 455         break;
 456       }
 457       default:
 458       {
 459         DALI_LOG_ERROR("Unknown error.\n");
 460       }
 461     }
 462     DALI_ASSERT_ALWAYS(false && "eglChooseConfig failed!");
 463     return false;
 464   }
 465   Integration::Log::LogMessage(Integration::Log::DebugInfo, "Using OpenGL es %d.%d.\n", mGlesVersion / 10, mGlesVersion % 10 );
 466
 467   mContextAttribs.Clear();
 468   if( mIsKhrCreateContextSupported )
 469   {
 470     mContextAttribs.Reserve(5);
 471     mContextAttribs.PushBack( EGL_CONTEXT_MAJOR_VERSION_KHR );
 472     mContextAttribs.PushBack( mGlesVersion / 10 );
 473     mContextAttribs.PushBack( EGL_CONTEXT_MINOR_VERSION_KHR );
 474     mContextAttribs.PushBack( mGlesVersion % 10 );
 475   }
 476   else
 477   {
 478     mContextAttribs.Reserve(3);
 479     mContextAttribs.PushBack( EGL_CONTEXT_CLIENT_VERSION );
 480     mContextAttribs.PushBack( mGlesVersion / 10 );
 481   }
 482   mContextAttribs.PushBack( EGL_NONE );
 483
 484   return true;
 485 }
 486
 487 EGLSurface EglImplementation::CreateSurfaceWindow( EGLNativeWindowType window, ColorDepth depth )
 488 {
 489   mEglNativeWindow = window;
 490   mColorDepth = depth;
 491   mIsWindow = true;
 492
 493   // egl choose config
 494   ChooseConfig(mIsWindow, mColorDepth);
 495
 496   mCurrentEglSurface = eglCreateWindowSurface( mEglDisplay, mEglConfig, mEglNativeWindow, NULL );
 497   TEST_EGL_ERROR("eglCreateWindowSurface");
 498
 499   DALI_ASSERT_ALWAYS( mCurrentEglSurface && "Create window surface failed" );
 500
 501   return mCurrentEglSurface;
 502 }
 503
 504 EGLSurface EglImplementation::CreateSurfacePixmap( EGLNativePixmapType pixmap, ColorDepth depth )
 505 {
 506   mCurrentEglNativePixmap = pixmap;
 507   mColorDepth = depth;
 508   mIsWindow = false;
 509
 510   // egl choose config
 511   ChooseConfig(mIsWindow, mColorDepth);
 512
 513   mCurrentEglSurface = eglCreatePixmapSurface( mEglDisplay, mEglConfig, mCurrentEglNativePixmap, NULL );
 514   TEST_EGL_ERROR("eglCreatePixmapSurface");
 515
 516   DALI_ASSERT_ALWAYS( mCurrentEglSurface && "Create pixmap surface failed" );
 517
 518   return mCurrentEglSurface;
 519 }
 520
 521 bool EglImplementation::ReplaceSurfaceWindow( EGLNativeWindowType window, EGLSurface& eglSurface, EGLContext& eglContext )
 522 {
 523   bool contextLost = false;
 524
 525   // display connection has not changed, then we can just create a new surface
 526   //  the surface is bound to the context, so set the context to null
 527   MakeContextNull();
 528
 529   // destroy the surface
 530   DestroySurface( eglSurface );
 531
 532   // create the EGL surface
 533   EGLSurface newEglSurface = CreateSurfaceWindow( window, mColorDepth );
 534
 535   // set the context to be current with the new surface
 536   MakeContextCurrent( newEglSurface, eglContext );
 537
 538   return contextLost;
 539 }
 540
 541 bool EglImplementation::ReplaceSurfacePixmap( EGLNativePixmapType pixmap, EGLSurface& eglSurface )
 542 {
 543   bool contextLost = false;
 544
 545   // display connection has not changed, then we can just create a new surface
 546   // create the EGL surface
 547   eglSurface = CreateSurfacePixmap( pixmap, mColorDepth );
 548
 549   // set the eglSurface to be current
 550   MakeCurrent( pixmap, eglSurface );
 551
 552   return contextLost;
 553 }
 554
 555 void EglImplementation::SetGlesVersion( const int32_t glesVersion )
 556 {
 557   mGlesVersion = glesVersion;
 558 }
 559
 560 EGLDisplay EglImplementation::GetDisplay() const
 561 {
 562   return mEglDisplay;
 563 }
 564
 565 EGLContext EglImplementation::GetContext() const
 566 {
 567   return mEglContext;
 568 }
 569
 570 int32_t EglImplementation::GetGlesVersion() const
 571 {
 572   return mGlesVersion;
 573 }
 574
 575 bool EglImplementation::IsSurfacelessContextSupported() const
 576 {
 577   return mIsSurfacelessContextSupported;
 578 }
 579
 580 } // namespace Adaptor
 581
 582 } // namespace Internal
 583
 584 } // namespace Dali
 585
 586 #pragma GCC diagnostic pop