2 * Copyright (c) 2019 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include <dali/internal/graphics/gles/egl-implementation.h>
24 #include <dali/integration-api/debug.h>
25 #include <dali/public-api/common/dali-vector.h>
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>
32 // EGL constants use C style casts
33 #pragma GCC diagnostic push
34 #pragma GCC diagnostic ignored "-Wold-style-cast"
38 const std::string EGL_KHR_SURFACELESS_CONTEXT = "EGL_KHR_surfaceless_context";
50 #define TEST_EGL_ERROR(lastCommand) \
52 EGLint err = eglGetError(); \
53 if (err != EGL_SUCCESS) \
55 DALI_LOG_ERROR("EGL error after %s\n", lastCommand); \
56 Egl::PrintError(err); \
57 DALI_ASSERT_ALWAYS(0 && "EGL error"); \
61 EglImplementation::EglImplementation( int multiSamplingLevel,
62 Integration::DepthBufferAvailable depthBufferRequired,
63 Integration::StencilBufferAvailable stencilBufferRequired )
65 mEglNativeDisplay( 0 ),
66 mEglNativeWindow( 0 ),
67 mCurrentEglNativePixmap( 0 ),
71 mCurrentEglSurface( 0 ),
72 mCurrentEglContext( EGL_NO_CONTEXT ),
73 mMultiSamplingLevel( multiSamplingLevel ),
75 mColorDepth( COLOR_DEPTH_24 ),
76 mGlesInitialized( false ),
77 mIsOwnSurface( true ),
79 mDepthBufferRequired( depthBufferRequired == Integration::DepthBufferAvailable::TRUE ),
80 mStencilBufferRequired( stencilBufferRequired == Integration::StencilBufferAvailable::TRUE ),
81 mIsSurfacelessContextSupported( false )
85 EglImplementation::~EglImplementation()
90 bool EglImplementation::InitializeGles( EGLNativeDisplayType display, bool isOwnSurface )
92 if ( !mGlesInitialized )
94 mEglNativeDisplay = display;
96 //@todo see if we can just EGL_DEFAULT_DISPLAY instead
97 mEglDisplay = eglGetDisplay(mEglNativeDisplay);
98 EGLint error = eglGetError();
100 if( mEglDisplay == NULL && error != EGL_SUCCESS )
102 throw Dali::DaliException( "", "OpenGL ES is not supported");
105 EGLint majorVersion = 0;
106 EGLint minorVersion = 0;
107 if ( !eglInitialize( mEglDisplay, &majorVersion, &minorVersion ) )
111 eglBindAPI(EGL_OPENGL_ES_API);
113 mGlesInitialized = true;
114 mIsOwnSurface = isOwnSurface;
117 // Query EGL extensions to check whether surfaceless context is supported
118 const char* const extensionStr = eglQueryString( mEglDisplay, EGL_EXTENSIONS );
119 std::istringstream stream(extensionStr);
120 std::string currentExtension;
121 while ( std::getline( stream, currentExtension, ' ' ) )
123 if ( currentExtension == EGL_KHR_SURFACELESS_CONTEXT )
125 mIsSurfacelessContextSupported = true;
130 // We want to display this information all the time, so use the LogMessage directly
131 Integration::Log::LogMessage(Integration::Log::DebugInfo, "EGL Information\n"
136 eglQueryString( mEglDisplay, EGL_VENDOR ),
137 eglQueryString( mEglDisplay, EGL_VERSION ),
138 eglQueryString( mEglDisplay, EGL_CLIENT_APIS ),
141 return mGlesInitialized;
144 bool EglImplementation::CreateContext()
146 // make sure a context isn't created twice
147 DALI_ASSERT_ALWAYS( (mEglContext == 0) && "EGL context recreated" );
149 mEglContext = eglCreateContext(mEglDisplay, mEglConfig, NULL, &(mContextAttribs[0]));
150 TEST_EGL_ERROR("eglCreateContext render thread");
152 DALI_ASSERT_ALWAYS( EGL_NO_CONTEXT != mEglContext && "EGL context not created" );
154 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VENDOR : %s ***\n", glGetString(GL_VENDOR));
155 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_RENDERER : %s ***\n", glGetString(GL_RENDERER));
156 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VERSION : %s ***\n", glGetString(GL_VERSION));
157 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_SHADING_LANGUAGE_VERSION : %s***\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
158 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** Supported Extensions ***\n%s\n\n", glGetString(GL_EXTENSIONS));
163 bool EglImplementation::CreateWindowContext( EGLContext& eglContext )
165 // make sure a context isn't created twice
166 DALI_ASSERT_ALWAYS( (eglContext == 0) && "EGL context recreated" );
168 eglContext = eglCreateContext(mEglDisplay, mEglConfig, mEglContext, &(mContextAttribs[0]));
169 TEST_EGL_ERROR("eglCreateContext render thread");
171 DALI_ASSERT_ALWAYS( EGL_NO_CONTEXT != eglContext && "EGL context not created" );
173 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VENDOR : %s ***\n", glGetString(GL_VENDOR));
174 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_RENDERER : %s ***\n", glGetString(GL_RENDERER));
175 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_VERSION : %s ***\n", glGetString(GL_VERSION));
176 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** GL_SHADING_LANGUAGE_VERSION : %s***\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
177 DALI_LOG_INFO(Debug::Filter::gShader, Debug::General, "*** Supported Extensions ***\n%s\n\n", glGetString(GL_EXTENSIONS));
179 mEglWindowContexts.push_back( eglContext );
184 void EglImplementation::DestroyContext( EGLContext& eglContext )
186 DALI_ASSERT_ALWAYS( mEglContext && "no EGL context" );
188 eglDestroyContext( mEglDisplay, eglContext );
192 void EglImplementation::DestroySurface( EGLSurface& eglSurface )
194 if(mIsOwnSurface && eglSurface)
196 // Make context null to prevent crash in driver side
198 eglDestroySurface( mEglDisplay, eglSurface );
203 void EglImplementation::MakeContextCurrent( EGLSurface eglSurface, EGLContext eglContext )
205 if (mCurrentEglContext == eglContext)
210 mCurrentEglSurface = eglSurface;
216 eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, eglContext );
218 mCurrentEglContext = eglContext;
221 EGLint error = eglGetError();
223 if ( error != EGL_SUCCESS )
225 Egl::PrintError(error);
227 DALI_ASSERT_ALWAYS(false && "MakeContextCurrent failed!");
231 void EglImplementation::MakeCurrent( EGLNativePixmapType pixmap, EGLSurface eglSurface )
233 if (mCurrentEglContext == mEglContext)
238 mCurrentEglNativePixmap = pixmap;
239 mCurrentEglSurface = eglSurface;
245 eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, mEglContext );
247 mCurrentEglContext = mEglContext;
250 EGLint error = eglGetError();
252 if ( error != EGL_SUCCESS )
254 Egl::PrintError(error);
256 DALI_ASSERT_ALWAYS(false && "MakeCurrent failed!");
260 void EglImplementation::MakeContextNull()
262 // clear the current context
263 eglMakeCurrent( mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
264 mCurrentEglContext = EGL_NO_CONTEXT;
267 void EglImplementation::TerminateGles()
269 if ( mGlesInitialized )
271 // Make context null to prevent crash in driver side
274 for ( auto eglSurface : mEglWindowSurfaces )
276 if(mIsOwnSurface && eglSurface)
278 eglDestroySurface(mEglDisplay, eglSurface);
281 eglDestroyContext(mEglDisplay, mEglContext);
282 for ( auto eglContext : mEglWindowContexts )
284 eglDestroyContext(mEglDisplay, eglContext);
287 eglTerminate(mEglDisplay);
292 mCurrentEglSurface = NULL;
293 mCurrentEglContext = EGL_NO_CONTEXT;
295 mGlesInitialized = false;
299 bool EglImplementation::IsGlesInitialized() const
301 return mGlesInitialized;
304 void EglImplementation::SwapBuffers( EGLSurface& eglSurface )
306 if ( eglSurface != EGL_NO_SURFACE ) // skip if using surfaceless context
308 eglSwapBuffers( mEglDisplay, eglSurface );
312 void EglImplementation::CopyBuffers( EGLSurface& eglSurface )
314 eglCopyBuffers( mEglDisplay, eglSurface, mCurrentEglNativePixmap );
317 void EglImplementation::WaitGL()
322 bool EglImplementation::ChooseConfig( bool isWindowType, ColorDepth depth )
324 if(mEglConfig && isWindowType == mIsWindow && mColorDepth == depth)
329 bool isTransparent = ( depth == COLOR_DEPTH_32 );
332 mIsWindow = isWindowType;
335 Vector<EGLint> configAttribs;
336 configAttribs.Reserve(31);
340 configAttribs.PushBack( EGL_SURFACE_TYPE );
341 configAttribs.PushBack( EGL_WINDOW_BIT );
345 configAttribs.PushBack( EGL_SURFACE_TYPE );
346 configAttribs.PushBack( EGL_PIXMAP_BIT );
349 configAttribs.PushBack( EGL_RENDERABLE_TYPE );
351 if( mGlesVersion >= 30 )
354 configAttribs.PushBack( EGL_OPENGL_ES3_BIT_KHR );
356 configAttribs.PushBack( EGL_OPENGL_ES2_BIT );
361 configAttribs.PushBack( EGL_OPENGL_ES2_BIT );
364 // TODO: enable this flag when it becomes supported
365 // configAttribs.PushBack( EGL_CONTEXT_FLAGS_KHR );
366 // configAttribs.PushBack( EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR );
368 configAttribs.PushBack( EGL_RED_SIZE );
369 configAttribs.PushBack( 8 );
370 configAttribs.PushBack( EGL_GREEN_SIZE );
371 configAttribs.PushBack( 8 );
372 configAttribs.PushBack( EGL_BLUE_SIZE );
373 configAttribs.PushBack( 8 );
377 configAttribs.PushBack( EGL_ALPHA_SIZE );
379 // For underlay video playback, we also need to set the alpha value of the 24/32bit window.
380 configAttribs.PushBack( 8 );
382 // There is a bug in the desktop emulator
383 // setting EGL_ALPHA_SIZE to 8 results in eglChooseConfig failing
384 configAttribs.PushBack( 8 );
388 configAttribs.PushBack( EGL_DEPTH_SIZE );
389 configAttribs.PushBack( mDepthBufferRequired ? 24 : 0 );
390 configAttribs.PushBack( EGL_STENCIL_SIZE );
391 configAttribs.PushBack( mStencilBufferRequired ? 8 : 0 );
393 #ifndef DALI_PROFILE_UBUNTU
394 if( mMultiSamplingLevel != EGL_DONT_CARE )
396 configAttribs.PushBack( EGL_SAMPLES );
397 configAttribs.PushBack( mMultiSamplingLevel );
398 configAttribs.PushBack( EGL_SAMPLE_BUFFERS );
399 configAttribs.PushBack( 1 );
401 #endif // DALI_PROFILE_UBUNTU
402 configAttribs.PushBack( EGL_NONE );
404 // Ensure number of configs is set to 1 as on some drivers,
405 // eglChooseConfig succeeds but does not actually create a proper configuration.
406 if ( ( eglChooseConfig( mEglDisplay, &(configAttribs[0]), &mEglConfig, 1, &numConfigs ) != EGL_TRUE ) ||
407 ( numConfigs != 1 ) )
409 if( mGlesVersion >= 30 )
412 DALI_LOG_ERROR("Fail to use OpenGL es 3.0. Retring to use OpenGL es 2.0.");
416 if ( numConfigs != 1 )
418 DALI_LOG_ERROR("No configurations found.\n");
420 TEST_EGL_ERROR("eglChooseConfig");
423 EGLint error = eglGetError();
426 case EGL_BAD_DISPLAY:
428 DALI_LOG_ERROR("Display is not an EGL display connection\n");
431 case EGL_BAD_ATTRIBUTE:
433 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");
436 case EGL_NOT_INITIALIZED:
438 DALI_LOG_ERROR("Display has not been initialized\n");
441 case EGL_BAD_PARAMETER:
443 DALI_LOG_ERROR("The parameter numConfig is NULL\n");
448 DALI_LOG_ERROR("Unknown error.\n");
451 DALI_ASSERT_ALWAYS(false && "eglChooseConfig failed!");
454 Integration::Log::LogMessage(Integration::Log::DebugInfo, "Using OpenGL es %d.%d.\n", mGlesVersion / 10, mGlesVersion % 10 );
456 mContextAttribs.Clear();
457 if( mGlesVersion >= 30 )
459 mContextAttribs.Reserve(5);
460 mContextAttribs.PushBack( EGL_CONTEXT_MAJOR_VERSION_KHR );
461 mContextAttribs.PushBack( mGlesVersion / 10 );
462 mContextAttribs.PushBack( EGL_CONTEXT_MINOR_VERSION_KHR );
463 mContextAttribs.PushBack( mGlesVersion % 10 );
467 mContextAttribs.Reserve(3);
468 mContextAttribs.PushBack( EGL_CONTEXT_CLIENT_VERSION );
469 mContextAttribs.PushBack( 2 );
471 mContextAttribs.PushBack( EGL_NONE );
476 EGLSurface EglImplementation::CreateSurfaceWindow( EGLNativeWindowType window, ColorDepth depth )
478 mEglNativeWindow = window;
483 ChooseConfig(mIsWindow, mColorDepth);
485 mCurrentEglSurface = eglCreateWindowSurface( mEglDisplay, mEglConfig, mEglNativeWindow, NULL );
486 TEST_EGL_ERROR("eglCreateWindowSurface");
488 DALI_ASSERT_ALWAYS( mCurrentEglSurface && "Create window surface failed" );
490 return mCurrentEglSurface;
493 EGLSurface EglImplementation::CreateSurfacePixmap( EGLNativePixmapType pixmap, ColorDepth depth )
495 mCurrentEglNativePixmap = pixmap;
500 ChooseConfig(mIsWindow, mColorDepth);
502 mCurrentEglSurface = eglCreatePixmapSurface( mEglDisplay, mEglConfig, mCurrentEglNativePixmap, NULL );
503 TEST_EGL_ERROR("eglCreatePixmapSurface");
505 DALI_ASSERT_ALWAYS( mCurrentEglSurface && "Create pixmap surface failed" );
507 return mCurrentEglSurface;
510 bool EglImplementation::ReplaceSurfaceWindow( EGLNativeWindowType window, EGLSurface& eglSurface, EGLContext& eglContext )
512 bool contextLost = false;
514 // display connection has not changed, then we can just create a new surface
515 // the surface is bound to the context, so set the context to null
518 // destroy the surface
519 DestroySurface( eglSurface );
521 // create the EGL surface
522 CreateSurfaceWindow( window, mColorDepth );
524 // set the context to be current with the new surface
525 MakeContextCurrent( eglSurface, eglContext );
530 bool EglImplementation::ReplaceSurfacePixmap( EGLNativePixmapType pixmap, EGLSurface& eglSurface )
532 bool contextLost = false;
534 // display connection has not changed, then we can just create a new surface
535 // create the EGL surface
536 eglSurface = CreateSurfacePixmap( pixmap, mColorDepth );
538 // set the eglSurface to be current
539 MakeCurrent( pixmap, eglSurface );
544 void EglImplementation::SetGlesVersion( const int32_t glesVersion )
546 mGlesVersion = glesVersion;
549 EGLDisplay EglImplementation::GetDisplay() const
554 EGLContext EglImplementation::GetContext() const
559 int32_t EglImplementation::GetGlesVersion() const
564 bool EglImplementation::IsSurfacelessContextSupported() const
566 return mIsSurfacelessContextSupported;
569 } // namespace Adaptor
571 } // namespace Internal
575 #pragma GCC diagnostic pop