/*
- * Copyright (c) 2018 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.
// EXTERNAL INCLUDES
#include <errno.h>
#include <dali/integration-api/platform-abstraction.h>
+#include <unistd.h>
+#include "dali/public-api/common/dali-common.h"
// INTERNAL INCLUDES
-#include <dali/integration-api/trigger-event-factory.h>
+#include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
+#include <dali/devel-api/adaptor-framework/thread-settings.h>
+#include <dali/internal/adaptor/common/adaptor-internal-services.h>
#include <dali/internal/adaptor/common/combined-update-render-controller-debug.h>
+#include <dali/internal/graphics/gles/egl-graphics.h>
+#include <dali/internal/graphics/gles/egl-implementation.h>
+#include <dali/internal/graphics/common/graphics-interface.h>
#include <dali/internal/system/common/environment-options.h>
#include <dali/internal/system/common/time-service.h>
-#include <dali/internal/adaptor/common/adaptor-internal-services.h>
-#include <dali/devel-api/adaptor-framework/thread-settings.h>
+#include <dali/internal/window-system/common/window-impl.h>
namespace Dali
{
// EVENT THREAD
///////////////////////////////////////////////////////////////////////////////////////////////////
-CombinedUpdateRenderController::CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions )
+CombinedUpdateRenderController::CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions, ThreadMode threadMode )
: mFpsTracker( environmentOptions ),
mUpdateStatusLogger( environmentOptions ),
- mEventThreadSemaphore(),
+ mEventThreadSemaphore(0),
+ mSurfaceSemaphore(0),
mUpdateRenderThreadWaitCondition(),
mAdaptorInterfaces( adaptorInterfaces ),
mPerformanceInterface( adaptorInterfaces.GetPerformanceInterface() ),
mDefaultHalfFrameNanoseconds( 0u ),
mUpdateRequestCount( 0u ),
mRunning( FALSE ),
+ mThreadMode( threadMode ),
mUpdateRenderRunCount( 0 ),
mDestroyUpdateRenderThread( FALSE ),
mUpdateRenderThreadCanSleep( FALSE ),
mPendingRequestUpdate( FALSE ),
mUseElapsedTimeAfterWait( FALSE ),
mNewSurface( NULL ),
+ mDeletedSurface( nullptr ),
mPostRendering( FALSE ),
mSurfaceResized( FALSE ),
- mForceClear( FALSE )
+ mForceClear( FALSE ),
+ mUploadWithoutRendering( FALSE ),
+ mFirstFrameAfterResume( FALSE )
{
LOG_EVENT_TRACE;
SetRenderRefreshRate( environmentOptions.GetRenderRefreshRate() );
// Set the thread-synchronization interface on the render-surface
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
+ Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
if( currentSurface )
{
currentSurface->SetThreadSynchronization( *this );
}
- TriggerEventFactoryInterface& triggerFactory = mAdaptorInterfaces.GetTriggerEventFactoryInterface();
- mSleepTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
-
- sem_init( &mEventThreadSemaphore, 0, 0 ); // Initialize to 0 so that it just waits if sem_post has not been called
+ mSleepTrigger = TriggerEventFactory::CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
}
CombinedUpdateRenderController::~CombinedUpdateRenderController()
DALI_ASSERT_ALWAYS( ! mUpdateRenderThread );
// Create Update/Render Thread
+ ConditionalWait::ScopedLock lock(mGraphicsInitializeWait);
mUpdateRenderThread = new pthread_t();
int error = pthread_create( mUpdateRenderThread, NULL, InternalUpdateRenderThreadEntryFunc, this );
DALI_ASSERT_ALWAYS( !error && "Return code from pthread_create() when creating UpdateRenderThread" );
// Wait until all threads created in Initialise are up and running
for( unsigned int i = 0; i < CREATED_THREAD_COUNT; ++i )
{
- sem_wait( &mEventThreadSemaphore );
+ mEventThreadSemaphore.Acquire();
}
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
+ mRunning = TRUE;
+
+ LOG_EVENT( "Startup Complete, starting Update/Render Thread" );
+
+ RunUpdateRenderThread( CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL );
+
+ Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
if( currentSurface )
{
currentSurface->StartRender();
}
- mRunning = TRUE;
-
- LOG_EVENT( "Startup Complete, starting Update/Render Thread" );
-
- RunUpdateRenderThread( CONTINUOUS, false /* No animation progression */ );
+ DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Start\n" );
}
void CombinedUpdateRenderController::Pause()
PauseUpdateRenderThread();
AddPerformanceMarker( PerformanceInterface::PAUSED );
+
+ DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Pause\n" );
}
void CombinedUpdateRenderController::Resume()
{
LOG_EVENT( "Resuming" );
- RunUpdateRenderThread( CONTINUOUS, true /* Animation progression required while we were paused */ );
+ RunUpdateRenderThread( CONTINUOUS, AnimationProgression::USE_ELAPSED_TIME, UpdateMode::NORMAL );
AddPerformanceMarker( PerformanceInterface::RESUME );
mRunning = TRUE;
mForceClear = TRUE;
+ mFirstFrameAfterResume = TRUE;
+
+ DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Resume\n" );
+ }
+ else
+ {
+ DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Resume: Already resumed [%d, %d, %d]\n", mRunning, mUpdateRenderRunCount, mUpdateRenderThreadCanSleep );
}
}
LOG_EVENT_TRACE;
// Stop Rendering and the Update/Render Thread
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
+ Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
if( currentSurface )
{
currentSurface->StopRender();
}
mRunning = FALSE;
+
+ DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Stop\n" );
}
void CombinedUpdateRenderController::RequestUpdate()
{
LOG_EVENT( "Processing" );
- RunUpdateRenderThread( CONTINUOUS, false /* No animation progression */ );
+ RunUpdateRenderThread( CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL );
}
ConditionalWait::ScopedLock updateLock( mUpdateRenderThreadWaitCondition );
mPendingRequestUpdate = TRUE;
}
-void CombinedUpdateRenderController::RequestUpdateOnce()
+void CombinedUpdateRenderController::RequestUpdateOnce( UpdateMode updateMode )
{
// Increment the update-request count to the maximum
if( mUpdateRequestCount < MAXIMUM_UPDATE_REQUESTS )
++mUpdateRequestCount;
}
- if( IsUpdateRenderThreadPaused() )
+ if( IsUpdateRenderThreadPaused() || updateMode == UpdateMode::FORCE_RENDER )
{
LOG_EVENT_TRACE;
// Run Update/Render once
- RunUpdateRenderThread( ONCE, false /* No animation progression */ );
+ RunUpdateRenderThread( ONCE, AnimationProgression::NONE, updateMode );
}
}
-void CombinedUpdateRenderController::ReplaceSurface( RenderSurface* newSurface )
+void CombinedUpdateRenderController::ReplaceSurface( Dali::RenderSurfaceInterface* newSurface )
{
LOG_EVENT_TRACE;
- // Set the ThreadSyncronizationInterface on the new surface
- newSurface->SetThreadSynchronization( *this );
+ if( mUpdateRenderThread )
+ {
+ // Set the ThreadSyncronizationInterface on the new surface
+ newSurface->SetThreadSynchronization( *this );
- LOG_EVENT( "Starting to replace the surface, event-thread blocked" );
+ LOG_EVENT( "Starting to replace the surface, event-thread blocked" );
- // Start replacing the surface.
+ // Start replacing the surface.
+ {
+ ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
+ mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will replace the surface now
+ mNewSurface = newSurface;
+ mUpdateRenderThreadWaitCondition.Notify( lock );
+ }
+
+ // Wait until the surface has been replaced
+ mSurfaceSemaphore.Acquire();
+
+ LOG_EVENT( "Surface replaced, event-thread continuing" );
+ }
+}
+
+void CombinedUpdateRenderController::DeleteSurface( Dali::RenderSurfaceInterface* surface )
+{
+ LOG_EVENT_TRACE;
+
+ if( mUpdateRenderThread )
{
- ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
- mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will replace the surface now
- mNewSurface = newSurface;
- mUpdateRenderThreadWaitCondition.Notify( lock );
+ LOG_EVENT( "Starting to delete the surface, event-thread blocked" );
+
+ // Start replacing the surface.
+ {
+ ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
+ mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will delete the surface now
+ mDeletedSurface = surface;
+ mUpdateRenderThreadWaitCondition.Notify( lock );
+ }
+
+ // Wait until the surface has been deleted
+ mSurfaceSemaphore.Acquire();
+
+ LOG_EVENT( "Surface deleted, event-thread continuing" );
}
+}
+
+void CombinedUpdateRenderController::WaitForGraphicsInitialization()
+{
+ ConditionalWait::ScopedLock lk(mGraphicsInitializeWait);
+ LOG_EVENT_TRACE;
+
+ if( mUpdateRenderThread )
+ {
+ LOG_EVENT( "Waiting for graphics initialisation, event-thread blocked" );
- // Wait until the surface has been replaced
- sem_wait( &mEventThreadSemaphore );
+ // Wait until the graphics has been initialised
+ mGraphicsInitializeWait.Wait(lk);
- LOG_EVENT( "Surface replaced, event-thread continuing" );
+ LOG_EVENT( "graphics initialised, event-thread continuing" );
+ }
}
void CombinedUpdateRenderController::ResizeSurface()
mPreRenderCallback = callback;
}
+void CombinedUpdateRenderController::AddSurface( Dali::RenderSurfaceInterface* surface )
+{
+ LOG_EVENT_TRACE;
+ LOG_EVENT( "Surface is added" );
+ if( mUpdateRenderThread )
+ {
+ // Set the ThreadSyncronizationInterface on the added surface
+ surface->SetThreadSynchronization( *this );
+ }
+}
+
///////////////////////////////////////////////////////////////////////////////////////////////////
// EVENT THREAD
///////////////////////////////////////////////////////////////////////////////////////////////////
-void CombinedUpdateRenderController::RunUpdateRenderThread( int numberOfCycles, bool useElapsedTime )
+void CombinedUpdateRenderController::RunUpdateRenderThread( int numberOfCycles, AnimationProgression animationProgression, UpdateMode updateMode )
{
ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
- mUpdateRenderRunCount = numberOfCycles;
+
+ switch( mThreadMode )
+ {
+ case ThreadMode::NORMAL:
+ {
+ mUpdateRenderRunCount = numberOfCycles;
+ mUseElapsedTimeAfterWait = ( animationProgression == AnimationProgression::USE_ELAPSED_TIME );
+ break;
+ }
+ case ThreadMode::RUN_IF_REQUESTED:
+ {
+ if( updateMode != UpdateMode::FORCE_RENDER )
+ {
+ // Render only if the update mode is FORCE_RENDER which means the application requests it.
+ // We don't want to awake the update thread.
+ return;
+ }
+
+ mUpdateRenderRunCount++; // Increase the update request count
+ mUseElapsedTimeAfterWait = TRUE; // The elapsed time should be used. We want animations to proceed.
+ break;
+ }
+ }
+
mUpdateRenderThreadCanSleep = FALSE;
- mUseElapsedTimeAfterWait = useElapsedTime;
+ mUploadWithoutRendering = ( updateMode == UpdateMode::SKIP_RENDER );
LOG_COUNTER_EVENT( "mUpdateRenderRunCount: %d, mUseElapsedTimeAfterWait: %d", mUpdateRenderRunCount, mUseElapsedTimeAfterWait );
mUpdateRenderThreadWaitCondition.Notify( lock );
}
bool CombinedUpdateRenderController::IsUpdateRenderThreadPaused()
{
ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
+
+ if( mThreadMode == ThreadMode::RUN_IF_REQUESTED )
+ {
+ return !mRunning || mUpdateRenderThreadCanSleep;
+ }
+
return ( mUpdateRenderRunCount != CONTINUOUS ) || // Report paused if NOT continuously running
mUpdateRenderThreadCanSleep; // Report paused if sleeping
}
LOG_UPDATE_RENDER( "THREAD CREATED" );
- RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
- if( currentSurface )
+ // Initialize EGL & OpenGL
+ Dali::DisplayConnection& displayConnection = mAdaptorInterfaces.GetDisplayConnectionInterface();
+ displayConnection.Initialize();
+
+ // EGL has been initialised at this point
+ NotifyGraphicsInitialised();
+
+ RenderSurfaceInterface* currentSurface = nullptr;
+
+ GraphicsInterface& graphics = mAdaptorInterfaces.GetGraphicsInterface();
+ EglGraphics* eglGraphics = static_cast<EglGraphics *>(&graphics);
+
+ // This will only be created once
+ EglInterface* eglInterface = &eglGraphics->GetEglInterface();
+
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( *eglInterface );
+
+ // Try to use OpenGL es 3.0
+ // ChooseConfig returns false here when the device only support gles 2.0.
+ // Because eglChooseConfig with gles 3.0 setting fails when the device only support gles 2.0 and Our default setting is gles 3.0.
+ if( !eglImpl.ChooseConfig( true, COLOR_DEPTH_32 ) )
+ {
+ // Retry to use OpenGL es 2.0
+ eglGraphics->SetGlesVersion( 20 );
+ eglImpl.ChooseConfig( true, COLOR_DEPTH_32 );
+ }
+
+ // Check whether surfaceless context is supported
+ bool isSurfacelessContextSupported = eglImpl.IsSurfacelessContextSupported();
+ eglGraphics->SetIsSurfacelessContextSupported( isSurfacelessContextSupported );
+
+ if ( isSurfacelessContextSupported )
{
- currentSurface->InitializeGraphics( mAdaptorInterfaces.GetGraphicsInterface(), mAdaptorInterfaces.GetDisplayConnectionInterface() );
+ // Create a surfaceless OpenGL context for shared resources
+ eglImpl.CreateContext();
+ eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
+ }
+ else
+ {
+ currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
+ if( currentSurface )
+ {
+ currentSurface->InitializeGraphics();
+ currentSurface->MakeContextCurrent();
+ }
}
+ GlImplementation& gles = eglGraphics->GetGlesInterface();
+ gles.ContextCreated();
+ eglGraphics->SetGlesVersion( gles.GetGlesVersion() );
+
// Tell core it has a context
mCore.ContextCreated();
uint64_t currentFrameStartTime = 0;
TimeService::GetNanoseconds( currentFrameStartTime );
- const uint64_t timeSinceLastFrame = currentFrameStartTime - lastFrameTime;
+ uint64_t timeSinceLastFrame = currentFrameStartTime - lastFrameTime;
// Optional FPS Tracking when continuously rendering
if( useElapsedTime && mFpsTracker.Enabled() )
// REPLACE SURFACE
//////////////////////////////
- RenderSurface* newSurface = ShouldSurfaceBeReplaced();
+ Dali::RenderSurfaceInterface* newSurface = ShouldSurfaceBeReplaced();
if( DALI_UNLIKELY( newSurface ) )
{
LOG_UPDATE_RENDER_TRACE_FMT( "Replacing Surface" );
-
// This is designed for replacing pixmap surfaces, but should work for window as well
// we need to delete the surface and renderable (pixmap / window)
// Then create a new pixmap/window and new surface
// If the new surface has a different display connection, then the context will be lost
-
mAdaptorInterfaces.GetDisplayConnectionInterface().Initialize();
- newSurface->InitializeGraphics( mAdaptorInterfaces.GetGraphicsInterface(), mAdaptorInterfaces.GetDisplayConnectionInterface() );
- newSurface->ReplaceGraphicsSurface();
+ newSurface->InitializeGraphics();
+ newSurface->MakeContextCurrent();
+ // TODO: ReplaceGraphicsSurface doesn't work, InitializeGraphics()
+ // already creates new surface window, the surface and the context.
+ // We probably don't need ReplaceGraphicsSurface at all.
+ // newSurface->ReplaceGraphicsSurface();
SurfaceReplaced();
}
float frameDelta = 0.0f;
if( useElapsedTime )
{
+ if( mThreadMode == ThreadMode::RUN_IF_REQUESTED )
+ {
+ extraFramesDropped = 0;
+ while( timeSinceLastFrame >= mDefaultFrameDurationNanoseconds )
+ {
+ timeSinceLastFrame -= mDefaultFrameDurationNanoseconds;
+ extraFramesDropped++;
+ }
+ }
+
// If using the elapsed time, then calculate frameDelta as a multiple of mDefaultFrameDelta
noOfFramesSinceLastUpdate += extraFramesDropped;
}
}
- currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
- if( currentSurface )
+ if( eglImpl.IsSurfacelessContextSupported() )
+ {
+ // Make the shared surfaceless context as current before rendering
+ eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
+ }
+
+ if( mFirstFrameAfterResume )
{
- currentSurface->PreRender( surfaceResized );
+ // mFirstFrameAfterResume is set to true when the thread is resumed
+ // Let eglImplementation know the first frame after thread initialized or resumed.
+ eglImpl.SetFirstFrameAfterResume();
+ mFirstFrameAfterResume = FALSE;
}
Integration::RenderStatus renderStatus;
AddPerformanceMarker( PerformanceInterface::RENDER_START );
- mCore.Render( renderStatus, mForceClear );
- AddPerformanceMarker( PerformanceInterface::RENDER_END );
- mForceClear = false;
+ // Upload shared resources
+ mCore.PreRender( renderStatus, mForceClear, mUploadWithoutRendering );
- if( renderStatus.NeedsPostRender() )
+ if ( !mUploadWithoutRendering )
{
- if( currentSurface )
+ // Go through each window
+ WindowContainer windows;
+ mAdaptorInterfaces.GetWindowContainerInterface( windows );
+
+ for( auto&& window : windows )
{
- currentSurface->PostRender( isRenderingToFbo, ( mNewSurface != NULL ), surfaceResized );
+ Dali::Integration::Scene scene = window->GetScene();
+ Dali::RenderSurfaceInterface* windowSurface = window->GetSurface();
+
+ if ( scene && windowSurface )
+ {
+ Integration::RenderStatus windowRenderStatus;
+
+ windowSurface->InitializeGraphics();
+
+ // clear previous frame damaged render items rects, buffer history is tracked on surface level
+ mDamagedRects.clear();
+
+ // Collect damage rects
+ mCore.PreRender( scene, mDamagedRects );
+
+ // Render off-screen frame buffers first if any
+ mCore.RenderScene( windowRenderStatus, scene, true );
+
+ Rect<int> clippingRect; // Empty for fbo rendering
+
+ // Switch to the EGL context of the surface, merge damaged areas for previous frames
+ windowSurface->PreRender( surfaceResized, mDamagedRects, clippingRect ); // Switch GL context
+
+ if (clippingRect.IsEmpty())
+ {
+ mDamagedRects.clear();
+ }
+
+ // Render the surface
+ mCore.RenderScene( windowRenderStatus, scene, false, clippingRect );
+
+ if( windowRenderStatus.NeedsPostRender() )
+ {
+ windowSurface->PostRender( false, false, surfaceResized, mDamagedRects ); // Swap Buffer with damage
+ }
+ }
}
}
+ mCore.PostRender( mUploadWithoutRendering );
+
+ //////////////////////////////
+ // DELETE SURFACE
+ //////////////////////////////
+
+ Dali::RenderSurfaceInterface* deletedSurface = ShouldSurfaceBeDeleted();
+ if( DALI_UNLIKELY( deletedSurface ) )
+ {
+ LOG_UPDATE_RENDER_TRACE_FMT( "Deleting Surface" );
+
+ deletedSurface->DestroySurface();
+
+ SurfaceDeleted();
+ }
+
+ AddPerformanceMarker( PerformanceInterface::RENDER_END );
+
+ mForceClear = false;
+
// Trigger event thread to request Update/Render thread to sleep if update not required
if( ( Integration::KeepUpdating::NOT_REQUESTED == keepUpdatingStatus ) && !renderStatus.NeedsUpdate() )
{
}
}
- // Inform core of context destruction & shutdown EGL
+ // Inform core of context destruction
mCore.ContextDestroyed();
- currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
- if( currentSurface )
+
+ WindowContainer windows;
+ mAdaptorInterfaces.GetWindowContainerInterface( windows );
+
+ // Destroy surfaces
+ for( auto&& window : windows )
{
- currentSurface->DestroySurface();
- currentSurface = nullptr;
+ Dali::RenderSurfaceInterface* surface = window->GetSurface();
+ surface->DestroySurface();
}
+ // Shutdown EGL
+ eglInterface->TerminateGles();
+
LOG_UPDATE_RENDER( "THREAD DESTROYED" );
// Uninstall the logging function
( mUpdateRenderThreadCanSleep && ! updateRequired && ! mPendingRequestUpdate ) ) && // Ensure we wait if we're supposed to be sleeping AND do not require another update
! mDestroyUpdateRenderThread && // Ensure we don't wait if the update-render-thread is supposed to be destroyed
! mNewSurface && // Ensure we don't wait if we need to replace the surface
+ ! mDeletedSurface && // Ensure we don't wait if we need to delete the surface
! mSurfaceResized ) // Ensure we don't wait if we need to resize the surface
{
LOG_UPDATE_RENDER( "WAIT: mUpdateRenderRunCount: %d", mUpdateRenderRunCount );
LOG_UPDATE_RENDER( " mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
LOG_UPDATE_RENDER( " mDestroyUpdateRenderThread: %d", mDestroyUpdateRenderThread );
LOG_UPDATE_RENDER( " mNewSurface: %d", mNewSurface );
+ LOG_UPDATE_RENDER( " mDeletedSurface: %d", mDeletedSurface );
LOG_UPDATE_RENDER( " mSurfaceResized: %d", mSurfaceResized );
// Reset the time when the thread is waiting, so the sleep-until time for
LOG_COUNTER_UPDATE_RENDER( "mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
LOG_COUNTER_UPDATE_RENDER( "mDestroyUpdateRenderThread: %d", mDestroyUpdateRenderThread );
LOG_COUNTER_UPDATE_RENDER( "mNewSurface: %d", mNewSurface );
+ LOG_COUNTER_UPDATE_RENDER( "mDeletedSurface: %d", mDeletedSurface );
LOG_COUNTER_UPDATE_RENDER( "mSurfaceResized: %d", mSurfaceResized );
mUseElapsedTimeAfterWait = FALSE;
return ! mDestroyUpdateRenderThread;
}
-RenderSurface* CombinedUpdateRenderController::ShouldSurfaceBeReplaced()
+Dali::RenderSurfaceInterface* CombinedUpdateRenderController::ShouldSurfaceBeReplaced()
{
ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
- RenderSurface* newSurface = mNewSurface;
+ Dali::RenderSurfaceInterface* newSurface = mNewSurface;
mNewSurface = NULL;
return newSurface;
void CombinedUpdateRenderController::SurfaceReplaced()
{
// Just increment the semaphore
- sem_post( &mEventThreadSemaphore );
+ mSurfaceSemaphore.Release(1);
+}
+
+Dali::RenderSurfaceInterface* CombinedUpdateRenderController::ShouldSurfaceBeDeleted()
+{
+ ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
+
+ Dali::RenderSurfaceInterface* deletedSurface = mDeletedSurface;
+ mDeletedSurface = NULL;
+
+ return deletedSurface;
+}
+
+void CombinedUpdateRenderController::SurfaceDeleted()
+{
+ // Just increment the semaphore
+ mSurfaceSemaphore.Release(1);
}
bool CombinedUpdateRenderController::ShouldSurfaceBeResized()
void CombinedUpdateRenderController::NotifyThreadInitialised()
{
// Just increment the semaphore
- sem_post( &mEventThreadSemaphore );
+ mEventThreadSemaphore.Release(1);
+}
+
+void CombinedUpdateRenderController::NotifyGraphicsInitialised()
+{
+ mGraphicsInitializeWait.Notify();
}
void CombinedUpdateRenderController::AddPerformanceMarker( PerformanceInterface::MarkerType type )
ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
while( mPostRendering &&
! mNewSurface && // We should NOT wait if we're replacing the surface
- ! mSurfaceResized && // We should NOT wait if we're resizing the surface
+ ! mDeletedSurface && // We should NOT wait if we're deleting the surface
! mDestroyUpdateRenderThread )
{
mUpdateRenderThreadWaitCondition.Wait( lock );