namespace
{
+ const uint32_t THRESHOLD_SWAPBUFFER_COUNT = 5;
+ const uint32_t CHECK_EXTENSION_NUMBER = 3;
const std::string EGL_KHR_SURFACELESS_CONTEXT = "EGL_KHR_surfaceless_context";
+ const std::string EGL_KHR_CREATE_CONTEXT = "EGL_KHR_create_context";
+ const std::string EGL_KHR_PARTIAL_UPDATE = "EGL_KHR_partial_update";
}
namespace Dali
EglImplementation::EglImplementation( int multiSamplingLevel,
Integration::DepthBufferAvailable depthBufferRequired,
- Integration::StencilBufferAvailable stencilBufferRequired )
+ Integration::StencilBufferAvailable stencilBufferRequired,
+ Integration::PartialUpdateAvailable partialUpdateAvailable )
: mContextAttribs(),
mEglNativeDisplay( 0 ),
mEglNativeWindow( 0 ),
mCurrentEglContext( EGL_NO_CONTEXT ),
mMultiSamplingLevel( multiSamplingLevel ),
mGlesVersion( 30 ),
+ mDamagedRectArray( 0 ),
mColorDepth( COLOR_DEPTH_24 ),
mGlesInitialized( false ),
mIsOwnSurface( true ),
mIsWindow( true ),
mDepthBufferRequired( depthBufferRequired == Integration::DepthBufferAvailable::TRUE ),
mStencilBufferRequired( stencilBufferRequired == Integration::StencilBufferAvailable::TRUE ),
- mIsSurfacelessContextSupported( false )
+ mIsSurfacelessContextSupported( false ),
+ mIsKhrCreateContextSupported( false ),
+ mSwapBufferCountAfterResume( 0 ),
+ mIsKhrPartialUpdateSupported( false ),
+ mPartialUpdateAvailable( partialUpdateAvailable == Integration::PartialUpdateAvailable::TRUE ),
+ mEglSetDamageRegionKHR( nullptr ),
+ mSwapBuffersWithDamage( nullptr )
{
+ if( mPartialUpdateAvailable )
+ {
+ mEglSetDamageRegionKHR = reinterpret_cast< PFNEGLSETDAMAGEREGIONKHRPROC >( eglGetProcAddress( "eglSetDamageRegionKHR" ) );
+ mSwapBuffersWithDamage = reinterpret_cast< PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC >( eglGetProcAddress( "eglSwapBuffersWithDamageEXT" ) );
+ if( !mEglSetDamageRegionKHR || !mSwapBuffersWithDamage )
+ {
+ mPartialUpdateAvailable = false;
+ DALI_LOG_ERROR("Initialization of partial update failed.\n");
+ }
+ else
+ {
+ DALI_LOG_RELEASE_INFO("Initialization of partial update success!\n");
+ }
+ }
}
EglImplementation::~EglImplementation()
// Query EGL extensions to check whether surfaceless context is supported
const char* const extensionStr = eglQueryString( mEglDisplay, EGL_EXTENSIONS );
- std::istringstream stream(extensionStr);
+ std::istringstream stream( extensionStr );
std::string currentExtension;
- while ( std::getline( stream, currentExtension, ' ' ) )
+ uint32_t extensionCheckCount = 0;
+ while( std::getline( stream, currentExtension, ' ' ) && extensionCheckCount < CHECK_EXTENSION_NUMBER )
{
- if ( currentExtension == EGL_KHR_SURFACELESS_CONTEXT )
+ if( currentExtension == EGL_KHR_SURFACELESS_CONTEXT )
{
mIsSurfacelessContextSupported = true;
- break;
+ extensionCheckCount++;
+ }
+ if( currentExtension == EGL_KHR_CREATE_CONTEXT )
+ {
+ mIsKhrCreateContextSupported = true;
+ extensionCheckCount++;
}
+ if( currentExtension == EGL_KHR_PARTIAL_UPDATE )
+ {
+ mIsKhrPartialUpdateSupported = true;
+ extensionCheckCount++;
+ }
+ }
+
+ if( !mIsKhrPartialUpdateSupported )
+ {
+ mPartialUpdateAvailable = false;
}
// We want to display this information all the time, so use the LogMessage directly
if(mIsOwnSurface)
{
- glFinish();
-
eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, eglContext );
mCurrentEglContext = eglContext;
if(mIsOwnSurface)
{
- glFinish();
-
eglMakeCurrent( mEglDisplay, eglSurface, eglSurface, mEglContext );
mCurrentEglContext = mEglContext;
return mGlesInitialized;
}
+
+const char* GetEglErrorString(EGLint error)
+{
+ switch(error)
+ {
+ case EGL_SUCCESS: return "No error";
+ case EGL_NOT_INITIALIZED: return "EGL not initialized or failed to initialize";
+ case EGL_BAD_ACCESS: return "Resource inaccessible";
+ case EGL_BAD_ALLOC: return "Cannot allocate resources";
+ case EGL_BAD_ATTRIBUTE: return "Unrecognized attribute or attribute value";
+ case EGL_BAD_CONTEXT: return "Invalid EGL context";
+ case EGL_BAD_CONFIG: return "Invalid EGL frame buffer configuration";
+ case EGL_BAD_CURRENT_SURFACE: return "Current surface is no longer valid";
+ case EGL_BAD_DISPLAY: return "Invalid EGL display";
+ case EGL_BAD_SURFACE: return "Invalid surface";
+ case EGL_BAD_MATCH: return "Inconsistent arguments";
+ case EGL_BAD_PARAMETER: return "Invalid argument";
+ case EGL_BAD_NATIVE_PIXMAP: return "Invalid native pixmap";
+ case EGL_BAD_NATIVE_WINDOW: return "Invalid native window";
+ case EGL_CONTEXT_LOST: return "Context lost";
+ }
+ return "Unknown error ";
+}
+
void EglImplementation::SwapBuffers( EGLSurface& eglSurface )
{
if ( eglSurface != EGL_NO_SURFACE ) // skip if using surfaceless context
{
- eglSwapBuffers( mEglDisplay, eglSurface );
+#ifndef DALI_PROFILE_UBUNTU
+ if( mSwapBufferCountAfterResume < THRESHOLD_SWAPBUFFER_COUNT )
+ {
+ DALI_LOG_RELEASE_INFO( "EglImplementation::SwapBuffers started.\n" );
+ }
+#endif //DALI_PROFILE_UBUNTU+
+
+ if( mPartialUpdateAvailable && mSwapBuffersWithDamage )
+ {
+ mSwapBuffersWithDamage( mEglDisplay, eglSurface, &mDamagedRectArray[0], mDamagedRectArray.size()/4 );
+ }
+ else
+ {
+ eglSwapBuffers( mEglDisplay, eglSurface );
+ }
+
+#ifndef DALI_PROFILE_UBUNTU
+ if( mSwapBufferCountAfterResume < THRESHOLD_SWAPBUFFER_COUNT )
+ {
+ DALI_LOG_RELEASE_INFO( "EglImplementation::SwapBuffers finished.\n" );
+ mSwapBufferCountAfterResume++;
+ }
+#endif //DALI_PROFILE_UBUNTU
+ }
+}
+
+
+int EglImplementation::GetBufferAge( EGLSurface& eglSurface )
+{
+ int bufferAge = 0;
+ if ( eglSurface != EGL_NO_SURFACE && mIsKhrPartialUpdateSupported )
+ {
+ if( !eglQuerySurface(mEglDisplay, eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge) )
+ {
+ DALI_LOG_ERROR("EglImplementation::GetBufferAge() eglQuerySurface %s ", GetEglErrorString(eglGetError()) );
+ }
+ }
+ return bufferAge;
+}
+
+void EglImplementation::SetDamagedRect( std::vector<int> damagedRectArray, EGLSurface& eglSurface )
+{
+ mDamagedRectArray = damagedRectArray;
+ if ( eglSurface != EGL_NO_SURFACE && mPartialUpdateAvailable && mEglSetDamageRegionKHR )
+ {
+ if( !mEglSetDamageRegionKHR( mEglDisplay, eglSurface, &damagedRectArray[0], damagedRectArray.size() / 4 ) )
+ {
+ DALI_LOG_ERROR("EglImplementation::mEglSetDamageRegionKHR() error %s ", GetEglErrorString(eglGetError()) );
+ }
}
}
return true;
}
- bool isTransparent = ( depth == COLOR_DEPTH_32 );
-
mColorDepth = depth;
mIsWindow = isWindowType;
if( mGlesVersion >= 30 )
{
-#ifdef _ARCH_ARM_
configAttribs.PushBack( EGL_OPENGL_ES3_BIT_KHR );
-#else
- configAttribs.PushBack( EGL_OPENGL_ES2_BIT );
-#endif // _ARCH_ARM_
}
else
{
configAttribs.PushBack( EGL_BLUE_SIZE );
configAttribs.PushBack( 8 );
- if ( isTransparent )
- {
- configAttribs.PushBack( EGL_ALPHA_SIZE );
-#ifdef _ARCH_ARM_
- // For underlay video playback, we also need to set the alpha value of the 24/32bit window.
- configAttribs.PushBack( 8 );
-#else
- // There is a bug in the desktop emulator
- // setting EGL_ALPHA_SIZE to 8 results in eglChooseConfig failing
- configAttribs.PushBack( 8 );
-#endif // _ARCH_ARM_
- }
+// For underlay video playback, we also need to set the alpha value of the 24/32bit window.
+ configAttribs.PushBack( EGL_ALPHA_SIZE );
+ configAttribs.PushBack( 8 );
configAttribs.PushBack( EGL_DEPTH_SIZE );
configAttribs.PushBack( mDepthBufferRequired ? 24 : 0 );
}
#endif // DALI_PROFILE_UBUNTU
configAttribs.PushBack( EGL_NONE );
+
+ // Ensure number of configs is set to 1 as on some drivers,
+ // eglChooseConfig succeeds but does not actually create a proper configuration.
if ( ( eglChooseConfig( mEglDisplay, &(configAttribs[0]), &mEglConfig, 1, &numConfigs ) != EGL_TRUE ) ||
( numConfigs != 1 ) )
{
if( mGlesVersion >= 30 )
{
mEglConfig = NULL;
- DALI_LOG_ERROR("Fail to use OpenGL es 3.0. Retring to use OpenGL es 2.0.");
+ DALI_LOG_ERROR("Fail to use OpenGL es 3.0. Retrying to use OpenGL es 2.0.");
return false;
}
Integration::Log::LogMessage(Integration::Log::DebugInfo, "Using OpenGL es %d.%d.\n", mGlesVersion / 10, mGlesVersion % 10 );
mContextAttribs.Clear();
- if( mGlesVersion >= 30 )
+ if( mIsKhrCreateContextSupported )
{
mContextAttribs.Reserve(5);
mContextAttribs.PushBack( EGL_CONTEXT_MAJOR_VERSION_KHR );
{
mContextAttribs.Reserve(3);
mContextAttribs.PushBack( EGL_CONTEXT_CLIENT_VERSION );
- mContextAttribs.PushBack( 2 );
+ mContextAttribs.PushBack( mGlesVersion / 10 );
}
mContextAttribs.PushBack( EGL_NONE );
DestroySurface( eglSurface );
// create the EGL surface
- CreateSurfaceWindow( window, mColorDepth );
+ EGLSurface newEglSurface = CreateSurfaceWindow( window, mColorDepth );
// set the context to be current with the new surface
- MakeContextCurrent( eglSurface, eglContext );
+ MakeContextCurrent( newEglSurface, eglContext );
return contextLost;
}
mGlesVersion = glesVersion;
}
+void EglImplementation::SetFirstFrameAfterResume()
+{
+ mSwapBufferCountAfterResume = 0;
+}
+
EGLDisplay EglImplementation::GetDisplay() const
{
return mEglDisplay;
return mIsSurfacelessContextSupported;
}
+void EglImplementation::WaitClient()
+{
+ // Wait for EGL to finish executing all rendering calls for the current context
+ if ( eglWaitClient() != EGL_TRUE )
+ {
+ TEST_EGL_ERROR("eglWaitClient");
+ }
+}
+
} // namespace Adaptor
} // namespace Internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff