/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
{
const int MINIMUM_DIMENSION_CHANGE( 1 ); ///< Minimum change for window to be considered to have moved
-const int TILE_SIZE = 16u; ///< Unit of tile size at GPU driver
#if defined(DEBUG_ENABLED)
Debug::Filter* gWindowRenderSurfaceLogFilter = Debug::Filter::New(Debug::Verbose, false, "LOG_WINDOW_RENDER_SURFACE");
mThreadSynchronization( NULL ),
mRenderNotification( NULL ),
mRotationTrigger( NULL ),
+ mFrameRenderedTrigger(),
mGraphics( nullptr ),
mEGLSurface( nullptr ),
mEGLContext( nullptr ),
mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ),
mOutputTransformedSignal(),
+ mFrameCallbackInfoContainer(),
mRotationAngle( 0 ),
mScreenRotationAngle( 0 ),
- mBufferAge( 0 ),
- mPreBufferAge( 0 ),
mOwnSurface( false ),
mRotationSupported( false ),
mRotationFinished( true ),
mScreenRotationFinished( true ),
mResizeFinished( true ),
mDpiHorizontal( 0 ),
- mDpiVertical( 0 ),
- mPreDamagedRect()
+ mDpiVertical( 0 )
{
DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n" );
Initialize( surface );
{
delete mRotationTrigger;
}
-
- if ( mEGLSurface )
- {
- DestroySurface();
- }
}
void WindowRenderSurface::Initialize( Any surface )
// Connect signals
mWindowBase->OutputTransformedSignal().Connect( this, &WindowRenderSurface::OutputTransformed );
-
- // Check screen rotation
- mScreenRotationAngle = mWindowBase->GetScreenRotationAngle();
- if( mScreenRotationAngle != 0 )
- {
- mScreenRotationFinished = false;
- mResizeFinished = false;
- }
}
Any WindowRenderSurface::GetNativeWindow()
void WindowRenderSurface::InitializeGraphics()
{
-
mGraphics = &mAdaptor->GetGraphicsInterface();
+ DALI_ASSERT_ALWAYS( mGraphics && "Graphics interface is not created" );
+
auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
mEGL = &eglGraphics->GetEglInterface();
{
DALI_LOG_TRACE_METHOD( gWindowRenderSurfaceLogFilter );
- int width, height;
- if( mScreenRotationAngle == 0 || mScreenRotationAngle == 180 )
- {
- width = mPositionSize.width;
- height = mPositionSize.height;
- }
- else
- {
- width = mPositionSize.height;
- height = mPositionSize.width;
- }
-
// Create the EGL window
- EGLNativeWindowType window = mWindowBase->CreateEglWindow( width, height );
+ EGLNativeWindowType window = mWindowBase->CreateEglWindow( mPositionSize.width, mPositionSize.height );
auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
DALI_LOG_TRACE_METHOD( gWindowRenderSurfaceLogFilter );
auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
+ if( eglGraphics )
+ {
+ DALI_LOG_RELEASE_INFO("WindowRenderSurface::DestroySurface: WinId (%d)\n", mWindowBase->GetNativeWindowId() );
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::DestroySurface: WinId (%d)\n", mWindowBase->GetNativeWindowId() );
+ Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- eglImpl.DestroySurface( mEGLSurface );
+ eglImpl.DestroySurface( mEGLSurface );
+ mEGLSurface = nullptr;
- mWindowBase->DestroyEglWindow();
+ // Destroy context also
+ eglImpl.DestroyContext( mEGLContext );
+ mEGLContext = nullptr;
+
+ mWindowBase->DestroyEglWindow();
+ }
}
bool WindowRenderSurface::ReplaceGraphicsSurface()
{
}
-bool WindowRenderSurface::PreRender( bool resizingSurface )
+bool WindowRenderSurface::PreRender( bool resizingSurface, const std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect )
{
+ Dali::Integration::Scene::FrameCallbackContainer callbacks;
+
+ Dali::Integration::Scene scene = mScene.GetHandle();
+ if( scene )
+ {
+ scene.GetFrameRenderedCallback( callbacks );
+ if( !callbacks.empty() )
+ {
+ int frameRenderedSync = mWindowBase->CreateFrameRenderedSyncFence();
+ if( frameRenderedSync != -1 )
+ {
+ DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: CreateFrameRenderedSyncFence [%d]\n", frameRenderedSync );
+
+ mFrameCallbackInfoContainer.push_back( std::unique_ptr< FrameCallbackInfo >( new FrameCallbackInfo( callbacks, frameRenderedSync ) ) );
+
+ if( !mFrameRenderedTrigger )
+ {
+ mFrameRenderedTrigger = std::unique_ptr< TriggerEventInterface >( TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &WindowRenderSurface::ProcessFrameCallback ),
+ TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER ) );
+ }
+ mFrameRenderedTrigger->Trigger();
+ }
+ else
+ {
+ DALI_LOG_ERROR( "WindowRenderSurface::PreRender: CreateFrameRenderedSyncFence is failed\n" );
+ }
+
+ // Clear callbacks
+ callbacks.clear();
+ }
+
+ scene.GetFramePresentedCallback( callbacks );
+ if( !callbacks.empty() )
+ {
+ int framePresentedSync = mWindowBase->CreateFramePresentedSyncFence();
+ if( framePresentedSync != -1 )
+ {
+ DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: CreateFramePresentedSyncFence [%d]\n", framePresentedSync );
+
+ mFrameCallbackInfoContainer.push_back( std::unique_ptr< FrameCallbackInfo >( new FrameCallbackInfo( callbacks, framePresentedSync ) ) );
+
+ if( !mFrameRenderedTrigger )
+ {
+ mFrameRenderedTrigger = std::unique_ptr< TriggerEventInterface >( TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &WindowRenderSurface::ProcessFrameCallback ),
+ TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER ) );
+ }
+ mFrameRenderedTrigger->Trigger();
+ }
+ else
+ {
+ DALI_LOG_ERROR( "WindowRenderSurface::PreRender: CreateFramePresentedSyncFence is failed\n" );
+ }
+
+ // Clear callbacks
+ callbacks.clear();
+ }
+ }
+
MakeContextCurrent();
+ auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
+
if( resizingSurface )
{
int totalAngle = (mRotationAngle + mScreenRotationAngle) % 360;
positionSize.width = mPositionSize.height;
positionSize.height = mPositionSize.width;
}
-
mWindowBase->ResizeEglWindow( positionSize );
mResizeFinished = true;
DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::PreRender: Set resize\n" );
}
- }
-
- auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
- if ( eglGraphics )
- {
- GlImplementation& mGLES = eglGraphics->GetGlesInterface();
- mGLES.PreRender();
- }
-
- return true;
-}
-
-std::vector<int32_t> WindowRenderSurface::MergeRect( const Rect<int32_t>& damagedRect, int bufferAge )
-{
- std::vector<int32_t> mergedRectArray;
- // merge bounding
- int dx1 = mPositionSize.width, dx2 = 0, dy1 = mPositionSize.height, dy2 = 0;
- int checkWidth = mPositionSize.width - TILE_SIZE;
- int checkHeight = mPositionSize.height - TILE_SIZE;
-
- dx1 = std::min( damagedRect.x, dx1 );
- dx2 = std::max( damagedRect.x + damagedRect.width, dx2);
- dy1 = std::min( damagedRect.y, dy1 );
- dy2 = std::max( damagedRect.y + damagedRect.height, dy2 );
- for( int j = 0; j <= bufferAge; j++ )
- {
- if( !mPreDamagedRect[j].IsEmpty() )
+ if (eglGraphics)
{
- dx1 = std::min( mPreDamagedRect[j].x, dx1 );
- dx2 = std::max( mPreDamagedRect[j].x + mPreDamagedRect[j].width, dx2);
- dy1 = std::min( mPreDamagedRect[j].y, dy1 );
- dy2 = std::max( mPreDamagedRect[j].y + mPreDamagedRect[j].height, dy2 );
-
- if( dx1 < TILE_SIZE && dx2 > checkWidth && dy1 < TILE_SIZE && dy2 > checkHeight )
- {
- dx1 = 0, dx2 = mPositionSize.width, dy1 = 0, dy2 = mPositionSize.height;
- break;
- }
+ Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
+ eglImpl.SetFullSwapNextFrame();
}
}
- dx1 = TILE_SIZE * (dx1 / TILE_SIZE);
- dy1 = TILE_SIZE * (dy1 / TILE_SIZE);
- dx2 = TILE_SIZE * ((dx2 + TILE_SIZE - 1) / TILE_SIZE);
- dy2 = TILE_SIZE * ((dy2 + TILE_SIZE - 1) / TILE_SIZE);
-
- mergedRectArray.push_back( dx1 );
- mergedRectArray.push_back( dy1 );
- mergedRectArray.push_back( dx2 - dx1 );
- mergedRectArray.push_back( dy2 - dy1 );
-
- return mergedRectArray;
-}
-
-
-void WindowRenderSurface::SetDamagedRect( const Dali::DamagedRect& damagedRect, Dali::DamagedRect& mergedRect )
-{
- auto eglGraphics = static_cast<EglGraphics *>( mGraphics );
- std::vector<int32_t> rectArray;
- if( eglGraphics )
+ if (eglGraphics)
{
Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
-
- rectArray = MergeRect( damagedRect, mBufferAge );
-
- mPreDamagedRect[4] = std::move( mPreDamagedRect[3] );
- mPreDamagedRect[3] = std::move( mPreDamagedRect[2] );
- mPreDamagedRect[2] = std::move( mPreDamagedRect[1] );
- mPreDamagedRect[1] = std::move( mPreDamagedRect[0] );
- mPreDamagedRect[0] = std::move( damagedRect );
-
- eglImpl.SetDamagedRect( rectArray, mEGLSurface );
+ eglImpl.SetDamage( mEGLSurface, damagedRects, clippingRect );
}
- if( !rectArray.empty() )
- {
- mergedRect.x = rectArray[0];
- mergedRect.y = rectArray[1];
- mergedRect.width = rectArray[2];
- mergedRect.height = rectArray[3];
- }
-}
-
-int32_t WindowRenderSurface::GetBufferAge()
-{
- int result = mBufferAge = 0;
- auto eglGraphics = static_cast<EglGraphics *>( mGraphics );
- if( eglGraphics )
- {
- Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
- mBufferAge = eglImpl.GetBufferAge( mEGLSurface );;
- result = ( mBufferAge != mPreBufferAge ) ? 0 : mBufferAge;
- mPreBufferAge = mBufferAge;
- }
- return result;
+ return true;
}
-void WindowRenderSurface::PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface )
+void WindowRenderSurface::PostRender( bool renderToFbo, bool replacingSurface, bool resizingSurface, const std::vector<Rect<int>>& damagedRects )
{
// Inform the gl implementation that rendering has finished before informing the surface
auto eglGraphics = static_cast<EglGraphics *>(mGraphics);
}
Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
-
- eglImpl.SwapBuffers( mEGLSurface );
+ eglImpl.SwapBuffers( mEGLSurface, damagedRects );
if( mRenderNotification )
{
// Nothing to do.
}
-Integration::RenderSurface::Type WindowRenderSurface::GetSurfaceType()
+Dali::RenderSurfaceInterface::Type WindowRenderSurface::GetSurfaceType()
{
- return RenderSurface::WINDOW_RENDER_SURFACE;
+ return Dali::RenderSurfaceInterface::WINDOW_RENDER_SURFACE;
}
void WindowRenderSurface::MakeContextCurrent()
mOutputTransformedSignal.Emit();
- DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::OutputTransformed: angle = %d screen rotation = %d\n", mRotationAngle, mScreenRotationAngle );
+ DALI_LOG_RELEASE_INFO( "WindowRenderSurface::OutputTransformed: window = %d screen = %d\n", mRotationAngle, mScreenRotationAngle );
}
else
{
- DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::OutputTransformed: Ignore output transform [%d]\n", mScreenRotationAngle );
+ DALI_LOG_RELEASE_INFO( "WindowRenderSurface::OutputTransformed: Ignore output transform [%d]\n", mScreenRotationAngle );
}
}
}
}
+void WindowRenderSurface::ProcessFrameCallback()
+{
+ for( auto&& iter : mFrameCallbackInfoContainer )
+ {
+ if( !iter->fileDescriptorMonitor )
+ {
+ iter->fileDescriptorMonitor = std::unique_ptr< FileDescriptorMonitor >( new FileDescriptorMonitor( iter->fileDescriptor,
+ MakeCallback( this, &WindowRenderSurface::OnFileDescriptorEventDispatched ), FileDescriptorMonitor::FD_READABLE ) );
+
+ DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::ProcessFrameCallback: Add handler [%d]\n", iter->fileDescriptor );
+ }
+ }
+}
+
+void WindowRenderSurface::OnFileDescriptorEventDispatched( FileDescriptorMonitor::EventType eventBitMask, int fileDescriptor )
+{
+ if( !( eventBitMask & FileDescriptorMonitor::FD_READABLE ) )
+ {
+ DALI_LOG_ERROR( "WindowRenderSurface::OnFileDescriptorEventDispatched: file descriptor error [%d]\n", eventBitMask );
+ close( fileDescriptor );
+ return;
+ }
+
+ DALI_LOG_INFO( gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::OnFileDescriptorEventDispatched: Frame rendered [%d]\n", fileDescriptor );
+
+ auto frameCallbackInfo = std::find_if( mFrameCallbackInfoContainer.begin(), mFrameCallbackInfoContainer.end(),
+ [fileDescriptor]( std::unique_ptr< FrameCallbackInfo >& callbackInfo )
+ {
+ return callbackInfo->fileDescriptor == fileDescriptor;
+ } );
+ if( frameCallbackInfo != mFrameCallbackInfoContainer.end() )
+ {
+ // Call the connected callback
+ for( auto&& iter : ( *frameCallbackInfo )->callbacks )
+ {
+ CallbackBase::Execute( *( iter.first ), iter.second );
+ }
+ mFrameCallbackInfoContainer.erase( frameCallbackInfo );
+ }
+}
+
} // namespace Adaptor
} // namespace internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff