dali/internal/adaptor/common/combined-update-render-controller.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 // CLASS HEADER
  19 #include <dali/internal/adaptor/common/combined-update-render-controller.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <errno.h>
  23 #include <dali/integration-api/platform-abstraction.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/integration-api/trigger-event-factory.h>
  27 #include <dali/internal/adaptor/common/combined-update-render-controller-debug.h>
  28 #include <dali/internal/system/common/environment-options.h>
  29 #include <dali/internal/system/common/time-service.h>
  30 #include <dali/internal/adaptor/common/adaptor-internal-services.h>
  31 #include <dali/devel-api/adaptor-framework/thread-settings.h>
  32 #include <dali/internal/graphics/gles/egl-graphics.h>
  33 #include <dali/internal/graphics/gles/egl-implementation.h>
  34 #include <dali/internal/graphics/common/graphics-interface.h>
  35
  36 namespace Dali
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 namespace Adaptor
  43 {
  44
  45 namespace
  46 {
  47
  48 const unsigned int CREATED_THREAD_COUNT = 1u;
  49
  50 const int CONTINUOUS = -1;
  51 const int ONCE = 1;
  52
  53 const unsigned int TRUE = 1u;
  54 const unsigned int FALSE = 0u;
  55
  56 const unsigned int MILLISECONDS_PER_SECOND( 1e+3 );
  57 const float        NANOSECONDS_TO_SECOND( 1e-9f );
  58 const unsigned int NANOSECONDS_PER_SECOND( 1e+9 );
  59 const unsigned int NANOSECONDS_PER_MILLISECOND( 1e+6 );
  60
  61 // The following values will get calculated at compile time
  62 const float        DEFAULT_FRAME_DURATION_IN_SECONDS( 1.0f / 60.0f );
  63 const uint64_t DEFAULT_FRAME_DURATION_IN_MILLISECONDS( DEFAULT_FRAME_DURATION_IN_SECONDS * MILLISECONDS_PER_SECOND );
  64 const uint64_t DEFAULT_FRAME_DURATION_IN_NANOSECONDS( DEFAULT_FRAME_DURATION_IN_SECONDS * NANOSECONDS_PER_SECOND );
  65
  66 /**
  67  * Handles the use case when an update-request is received JUST before we process a sleep-request. If we did not have an update-request count then
  68  * there is a danger that, on the event-thread we could have:
  69  *  1) An update-request where we do nothing as Update/Render thread still running.
  70  *  2) Quickly followed by a sleep-request being handled where we pause the Update/Render Thread (even though we have an update to process).
  71  *
  72  * Using a counter means we increment the counter on an update-request, and decrement it on a sleep-request. This handles the above scenario because:
  73  *  1) MAIN THREAD:           Update Request: COUNTER = 1
  74  *  2) UPDATE/RENDER THREAD:  Do Update/Render, then no Updates required -> Sleep Trigger
  75  *  3) MAIN THREAD:           Update Request: COUNTER = 2
  76  *  4) MAIN THREAD:           Sleep Request:  COUNTER = 1 -> We do not sleep just yet
  77  *
  78  * Also ensures we preserve battery life by only doing ONE update when the above use case is not triggered.
  79  *  1) MAIN THREAD:           Update Request: COUNTER = 1
  80  *  2) UPDATE/RENDER THREAD:  Do Update/Render, then no Updates required -> Sleep Trigger
  81  *  3) MAIN THREAD:           Sleep Request:  COUNTER = 0 -> Go to sleep
  82  */
  83 const unsigned int MAXIMUM_UPDATE_REQUESTS = 2;
  84 } // unnamed namespace
  85
  86 ///////////////////////////////////////////////////////////////////////////////////////////////////
  87 // EVENT THREAD
  88 ///////////////////////////////////////////////////////////////////////////////////////////////////
  89
  90 CombinedUpdateRenderController::CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions )
  91 : mFpsTracker( environmentOptions ),
  92   mUpdateStatusLogger( environmentOptions ),
  93   mEventThreadSemaphore(),
  94   mUpdateRenderThreadWaitCondition(),
  95   mAdaptorInterfaces( adaptorInterfaces ),
  96   mPerformanceInterface( adaptorInterfaces.GetPerformanceInterface() ),
  97   mCore( adaptorInterfaces.GetCore() ),
  98   mEnvironmentOptions( environmentOptions ),
  99   mNotificationTrigger( adaptorInterfaces.GetProcessCoreEventsTrigger() ),
 100   mSleepTrigger( NULL ),
 101   mPreRenderCallback( NULL ),
 102   mUpdateRenderThread( NULL ),
 103   mDefaultFrameDelta( 0.0f ),
 104   mDefaultFrameDurationMilliseconds( 0u ),
 105   mDefaultFrameDurationNanoseconds( 0u ),
 106   mDefaultHalfFrameNanoseconds( 0u ),
 107   mUpdateRequestCount( 0u ),
 108   mRunning( FALSE ),
 109   mUpdateRenderRunCount( 0 ),
 110   mDestroyUpdateRenderThread( FALSE ),
 111   mUpdateRenderThreadCanSleep( FALSE ),
 112   mPendingRequestUpdate( FALSE ),
 113   mUseElapsedTimeAfterWait( FALSE ),
 114   mNewSurface( NULL ),
 115   mDeletedSurface( nullptr ),
 116   mPostRendering( FALSE ),
 117   mSurfaceResized( FALSE ),
 118   mForceClear( FALSE ),
 119   mUploadWithoutRendering( FALSE )
 120 {
 121   LOG_EVENT_TRACE;
 122
 123   // Initialise frame delta/duration variables first
 124   SetRenderRefreshRate( environmentOptions.GetRenderRefreshRate() );
 125
 126   // Set the thread-synchronization interface on the render-surface
 127   Dali::RenderSurfaceInterface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 128   if( currentSurface )
 129   {
 130     currentSurface->SetThreadSynchronization( *this );
 131   }
 132
 133   TriggerEventFactoryInterface& triggerFactory = mAdaptorInterfaces.GetTriggerEventFactoryInterface();
 134   mSleepTrigger = triggerFactory.CreateTriggerEvent( MakeCallback( this, &CombinedUpdateRenderController::ProcessSleepRequest ), TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER );
 135
 136   sem_init( &mEventThreadSemaphore, 0, 0 ); // Initialize to 0 so that it just waits if sem_post has not been called
 137 }
 138
 139 CombinedUpdateRenderController::~CombinedUpdateRenderController()
 140 {
 141   LOG_EVENT_TRACE;
 142
 143   Stop();
 144
 145   delete mPreRenderCallback;
 146   delete mSleepTrigger;
 147 }
 148
 149 void CombinedUpdateRenderController::Initialize()
 150 {
 151   LOG_EVENT_TRACE;
 152
 153   // Ensure Update/Render Thread not already created
 154   DALI_ASSERT_ALWAYS( ! mUpdateRenderThread );
 155
 156   // Create Update/Render Thread
 157   mUpdateRenderThread = new pthread_t();
 158   int error = pthread_create( mUpdateRenderThread, NULL, InternalUpdateRenderThreadEntryFunc, this );
 159   DALI_ASSERT_ALWAYS( !error && "Return code from pthread_create() when creating UpdateRenderThread" );
 160
 161   // The Update/Render thread will now run and initialise the graphics interface etc. and will then wait for Start to be called
 162   // When this function returns, the application initialisation on the event thread should occur
 163 }
 164
 165 void CombinedUpdateRenderController::Start()
 166 {
 167   LOG_EVENT_TRACE;
 168
 169   DALI_ASSERT_ALWAYS( !mRunning && mUpdateRenderThread );
 170
 171   // Wait until all threads created in Initialise are up and running
 172   for( unsigned int i = 0; i < CREATED_THREAD_COUNT; ++i )
 173   {
 174     sem_wait( &mEventThreadSemaphore );
 175   }
 176
 177   Integration::RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 178   if( currentSurface )
 179   {
 180     currentSurface->StartRender();
 181   }
 182
 183   mRunning = TRUE;
 184
 185   LOG_EVENT( "Startup Complete, starting Update/Render Thread" );
 186
 187   RunUpdateRenderThread( CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL );
 188
 189   DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Start\n" );
 190 }
 191
 192 void CombinedUpdateRenderController::Pause()
 193 {
 194   LOG_EVENT_TRACE;
 195
 196   mRunning = FALSE;
 197
 198   PauseUpdateRenderThread();
 199
 200   AddPerformanceMarker( PerformanceInterface::PAUSED );
 201
 202   DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Pause\n" );
 203 }
 204
 205 void CombinedUpdateRenderController::Resume()
 206 {
 207   LOG_EVENT_TRACE;
 208
 209   if( !mRunning && IsUpdateRenderThreadPaused() )
 210   {
 211     LOG_EVENT( "Resuming" );
 212
 213     RunUpdateRenderThread( CONTINUOUS, AnimationProgression::USE_ELAPSED_TIME, UpdateMode::NORMAL );
 214
 215     AddPerformanceMarker( PerformanceInterface::RESUME );
 216
 217     mRunning = TRUE;
 218     mForceClear = TRUE;
 219
 220     DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Resume\n" );
 221   }
 222   else
 223   {
 224     DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Resume: Already resumed [%d, %d, %d]\n", mRunning, mUpdateRenderRunCount, mUpdateRenderThreadCanSleep );
 225   }
 226 }
 227
 228 void CombinedUpdateRenderController::Stop()
 229 {
 230   LOG_EVENT_TRACE;
 231
 232   // Stop Rendering and the Update/Render Thread
 233   Integration::RenderSurface* currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 234   if( currentSurface )
 235   {
 236     currentSurface->StopRender();
 237   }
 238
 239   StopUpdateRenderThread();
 240
 241   if( mUpdateRenderThread )
 242   {
 243     LOG_EVENT( "Destroying UpdateRenderThread" );
 244
 245     // wait for the thread to finish
 246     pthread_join( *mUpdateRenderThread, NULL );
 247
 248     delete mUpdateRenderThread;
 249     mUpdateRenderThread = NULL;
 250   }
 251
 252   mRunning = FALSE;
 253
 254   DALI_LOG_RELEASE_INFO( "CombinedUpdateRenderController::Stop\n" );
 255 }
 256
 257 void CombinedUpdateRenderController::RequestUpdate()
 258 {
 259   LOG_EVENT_TRACE;
 260
 261   // Increment the update-request count to the maximum
 262   if( mUpdateRequestCount < MAXIMUM_UPDATE_REQUESTS )
 263   {
 264     ++mUpdateRequestCount;
 265   }
 266
 267   if( mRunning && IsUpdateRenderThreadPaused() )
 268   {
 269     LOG_EVENT( "Processing" );
 270
 271     RunUpdateRenderThread( CONTINUOUS, AnimationProgression::NONE, UpdateMode::NORMAL );
 272   }
 273
 274   ConditionalWait::ScopedLock updateLock( mUpdateRenderThreadWaitCondition );
 275   mPendingRequestUpdate = TRUE;
 276 }
 277
 278 void CombinedUpdateRenderController::RequestUpdateOnce( UpdateMode updateMode )
 279 {
 280   // Increment the update-request count to the maximum
 281   if( mUpdateRequestCount < MAXIMUM_UPDATE_REQUESTS )
 282   {
 283     ++mUpdateRequestCount;
 284   }
 285
 286   if( IsUpdateRenderThreadPaused() )
 287   {
 288     LOG_EVENT_TRACE;
 289
 290     // Run Update/Render once
 291     RunUpdateRenderThread( ONCE, AnimationProgression::NONE, updateMode );
 292   }
 293 }
 294
 295 void CombinedUpdateRenderController::ReplaceSurface( Dali::RenderSurfaceInterface* newSurface )
 296 {
 297   LOG_EVENT_TRACE;
 298
 299   if( mUpdateRenderThread )
 300   {
 301     // Set the ThreadSyncronizationInterface on the new surface
 302     newSurface->SetThreadSynchronization( *this );
 303
 304     LOG_EVENT( "Starting to replace the surface, event-thread blocked" );
 305
 306     // Start replacing the surface.
 307     {
 308       ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 309       mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will replace the surface now
 310       mNewSurface = newSurface;
 311       mUpdateRenderThreadWaitCondition.Notify( lock );
 312     }
 313
 314     // Wait until the surface has been replaced
 315     sem_wait( &mEventThreadSemaphore );
 316
 317     LOG_EVENT( "Surface replaced, event-thread continuing" );
 318   }
 319 }
 320
 321 void CombinedUpdateRenderController::DeleteSurface( Dali::RenderSurfaceInterface* surface )
 322 {
 323   LOG_EVENT_TRACE;
 324
 325   if( mUpdateRenderThread )
 326   {
 327     LOG_EVENT( "Starting to delete the surface, event-thread blocked" );
 328
 329     // Start replacing the surface.
 330     {
 331       ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 332       mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will delete the surface now
 333       mDeletedSurface = surface;
 334       mUpdateRenderThreadWaitCondition.Notify( lock );
 335     }
 336
 337     // Wait until the surface has been deleted
 338     sem_wait( &mEventThreadSemaphore );
 339
 340     LOG_EVENT( "Surface deleted, event-thread continuing" );
 341   }
 342 }
 343
 344 void CombinedUpdateRenderController::ResizeSurface()
 345 {
 346   LOG_EVENT_TRACE;
 347
 348   LOG_EVENT( "Resize the surface" );
 349
 350   {
 351     ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 352     mPostRendering = FALSE; // Clear the post-rendering flag as Update/Render thread will resize the surface now
 353     mSurfaceResized = TRUE;
 354     mUpdateRenderThreadWaitCondition.Notify( lock );
 355   }
 356 }
 357
 358 void CombinedUpdateRenderController::SetRenderRefreshRate( unsigned int numberOfFramesPerRender )
 359 {
 360   // Not protected by lock, but written to rarely so not worth adding a lock when reading
 361   mDefaultFrameDelta                  = numberOfFramesPerRender * DEFAULT_FRAME_DURATION_IN_SECONDS;
 362   mDefaultFrameDurationMilliseconds   = uint64_t( numberOfFramesPerRender ) * DEFAULT_FRAME_DURATION_IN_MILLISECONDS;
 363   mDefaultFrameDurationNanoseconds    = uint64_t( numberOfFramesPerRender ) * DEFAULT_FRAME_DURATION_IN_NANOSECONDS;
 364   mDefaultHalfFrameNanoseconds        = mDefaultFrameDurationNanoseconds / 2u;
 365
 366   LOG_EVENT( "mDefaultFrameDelta(%.6f), mDefaultFrameDurationMilliseconds(%lld), mDefaultFrameDurationNanoseconds(%lld)", mDefaultFrameDelta, mDefaultFrameDurationMilliseconds, mDefaultFrameDurationNanoseconds );
 367 }
 368
 369 void CombinedUpdateRenderController::SetPreRenderCallback( CallbackBase* callback )
 370 {
 371   LOG_EVENT_TRACE;
 372   LOG_EVENT( "Set PreRender Callback" );
 373
 374   ConditionalWait::ScopedLock updateLock( mUpdateRenderThreadWaitCondition );
 375   if( mPreRenderCallback )
 376   {
 377     delete mPreRenderCallback;
 378   }
 379   mPreRenderCallback = callback;
 380 }
 381
 382 ///////////////////////////////////////////////////////////////////////////////////////////////////
 383 // EVENT THREAD
 384 ///////////////////////////////////////////////////////////////////////////////////////////////////
 385
 386 void CombinedUpdateRenderController::RunUpdateRenderThread( int numberOfCycles, AnimationProgression animationProgression, UpdateMode updateMode )
 387 {
 388   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 389   mUpdateRenderRunCount = numberOfCycles;
 390   mUpdateRenderThreadCanSleep = FALSE;
 391   mUseElapsedTimeAfterWait = ( animationProgression == AnimationProgression::USE_ELAPSED_TIME );
 392   mUploadWithoutRendering = ( updateMode == UpdateMode::SKIP_RENDER );
 393   LOG_COUNTER_EVENT( "mUpdateRenderRunCount: %d, mUseElapsedTimeAfterWait: %d", mUpdateRenderRunCount, mUseElapsedTimeAfterWait );
 394   mUpdateRenderThreadWaitCondition.Notify( lock );
 395 }
 396
 397 void CombinedUpdateRenderController::PauseUpdateRenderThread()
 398 {
 399   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 400   mUpdateRenderRunCount = 0;
 401 }
 402
 403 void CombinedUpdateRenderController::StopUpdateRenderThread()
 404 {
 405   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 406   mDestroyUpdateRenderThread = TRUE;
 407   mUpdateRenderThreadWaitCondition.Notify( lock );
 408 }
 409
 410 bool CombinedUpdateRenderController::IsUpdateRenderThreadPaused()
 411 {
 412   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 413   return ( mUpdateRenderRunCount != CONTINUOUS ) || // Report paused if NOT continuously running
 414          mUpdateRenderThreadCanSleep;               // Report paused if sleeping
 415 }
 416
 417 void CombinedUpdateRenderController::ProcessSleepRequest()
 418 {
 419   LOG_EVENT_TRACE;
 420
 421   // Decrement Update request count
 422   if( mUpdateRequestCount > 0 )
 423   {
 424     --mUpdateRequestCount;
 425   }
 426
 427   // Can sleep if our update-request count is 0
 428   // Update/Render thread can choose to carry on updating if it determines more update/renders are required
 429   if( mUpdateRequestCount == 0 )
 430   {
 431     LOG_EVENT( "Going to sleep" );
 432
 433     ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 434     mUpdateRenderThreadCanSleep = TRUE;
 435   }
 436 }
 437
 438 ///////////////////////////////////////////////////////////////////////////////////////////////////
 439 // UPDATE/RENDER THREAD
 440 ///////////////////////////////////////////////////////////////////////////////////////////////////
 441
 442 void CombinedUpdateRenderController::UpdateRenderThread()
 443 {
 444   SetThreadName("RenderThread\0");
 445
 446   // Install a function for logging
 447   mEnvironmentOptions.InstallLogFunction();
 448
 449   // Install a function for tracing
 450   mEnvironmentOptions.InstallTraceFunction();
 451
 452   LOG_UPDATE_RENDER( "THREAD CREATED" );
 453
 454   // Initialize EGL & OpenGL
 455   Dali::DisplayConnection& displayConnection = mAdaptorInterfaces.GetDisplayConnectionInterface();
 456   displayConnection.Initialize();
 457
 458   RenderSurfaceInterface* currentSurface = nullptr;
 459
 460   GraphicsInterface& graphics = mAdaptorInterfaces.GetGraphicsInterface();
 461   EglGraphics* eglGraphics = static_cast<EglGraphics *>(&graphics);
 462
 463   // This will only be created once
 464   EglInterface* eglInterface = &eglGraphics->GetEglInterface();
 465
 466   Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( *eglInterface );
 467
 468   // Try to use OpenGL es 3.0
 469   // ChooseConfig returns false here when the device only support gles 2.0.
 470   // Because eglChooseConfig with gles 3.0 setting fails when the device only support gles 2.0 and Our default setting is gles 3.0.
 471   if( !eglImpl.ChooseConfig( true, COLOR_DEPTH_32 ) )
 472   {
 473     // Retry to use OpenGL es 2.0
 474     eglGraphics->SetGlesVersion( 20 );
 475     eglImpl.ChooseConfig( true, COLOR_DEPTH_32 );
 476   }
 477
 478   // Check whether surfaceless context is supported
 479   bool isSurfacelessContextSupported = eglImpl.IsSurfacelessContextSupported();
 480   eglGraphics->SetIsSurfacelessContextSupported( isSurfacelessContextSupported );
 481
 482   if ( isSurfacelessContextSupported )
 483   {
 484     // Create a surfaceless OpenGL context for shared resources
 485     eglImpl.CreateContext();
 486     eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
 487   }
 488   else
 489   {
 490     currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 491     if( currentSurface )
 492     {
 493       currentSurface->InitializeGraphics();
 494       currentSurface->MakeContextCurrent();
 495     }
 496   }
 497
 498   eglGraphics->GetGlesInterface().ContextCreated();
 499
 500   // Tell core it has a context
 501   mCore.ContextCreated();
 502
 503   NotifyThreadInitialised();
 504
 505   // Update time
 506   uint64_t lastFrameTime;
 507   TimeService::GetNanoseconds( lastFrameTime );
 508
 509   LOG_UPDATE_RENDER( "THREAD INITIALISED" );
 510
 511   bool useElapsedTime = true;
 512   bool updateRequired = true;
 513   uint64_t timeToSleepUntil = 0;
 514   int extraFramesDropped = 0;
 515
 516   const unsigned int renderToFboInterval = mEnvironmentOptions.GetRenderToFboInterval();
 517   const bool renderToFboEnabled = 0u != renderToFboInterval;
 518   unsigned int frameCount = 0u;
 519
 520   while( UpdateRenderReady( useElapsedTime, updateRequired, timeToSleepUntil ) )
 521   {
 522     LOG_UPDATE_RENDER_TRACE;
 523
 524     // Performance statistics are logged upon a VSYNC tick so use this point for a VSync marker
 525     AddPerformanceMarker( PerformanceInterface::VSYNC );
 526
 527     uint64_t currentFrameStartTime = 0;
 528     TimeService::GetNanoseconds( currentFrameStartTime );
 529
 530     const uint64_t timeSinceLastFrame = currentFrameStartTime - lastFrameTime;
 531
 532     // Optional FPS Tracking when continuously rendering
 533     if( useElapsedTime && mFpsTracker.Enabled() )
 534     {
 535       float absoluteTimeSinceLastRender = timeSinceLastFrame * NANOSECONDS_TO_SECOND;
 536       mFpsTracker.Track( absoluteTimeSinceLastRender );
 537     }
 538
 539     lastFrameTime = currentFrameStartTime; // Store frame start time
 540
 541     //////////////////////////////
 542     // REPLACE SURFACE
 543     //////////////////////////////
 544
 545     Integration::RenderSurface* newSurface = ShouldSurfaceBeReplaced();
 546     if( DALI_UNLIKELY( newSurface ) )
 547     {
 548       LOG_UPDATE_RENDER_TRACE_FMT( "Replacing Surface" );
 549
 550       // This is designed for replacing pixmap surfaces, but should work for window as well
 551       // we need to delete the surface and renderable (pixmap / window)
 552       // Then create a new pixmap/window and new surface
 553       // If the new surface has a different display connection, then the context will be lost
 554
 555       mAdaptorInterfaces.GetDisplayConnectionInterface().Initialize();
 556       newSurface->InitializeGraphics();
 557       newSurface->ReplaceGraphicsSurface();
 558       SurfaceReplaced();
 559     }
 560
 561     const bool isRenderingToFbo = renderToFboEnabled && ( ( 0u == frameCount ) || ( 0u != frameCount % renderToFboInterval ) );
 562     ++frameCount;
 563
 564     //////////////////////////////
 565     // UPDATE
 566     //////////////////////////////
 567
 568     const unsigned int currentTime = currentFrameStartTime / NANOSECONDS_PER_MILLISECOND;
 569     const unsigned int nextFrameTime = currentTime + mDefaultFrameDurationMilliseconds;
 570
 571     uint64_t noOfFramesSinceLastUpdate = 1;
 572     float frameDelta = 0.0f;
 573     if( useElapsedTime )
 574     {
 575       // If using the elapsed time, then calculate frameDelta as a multiple of mDefaultFrameDelta
 576       noOfFramesSinceLastUpdate += extraFramesDropped;
 577
 578       frameDelta = mDefaultFrameDelta * noOfFramesSinceLastUpdate;
 579     }
 580     LOG_UPDATE_RENDER( "timeSinceLastFrame(%llu) noOfFramesSinceLastUpdate(%u) frameDelta(%.6f)", timeSinceLastFrame, noOfFramesSinceLastUpdate, frameDelta );
 581
 582     Integration::UpdateStatus updateStatus;
 583
 584     AddPerformanceMarker( PerformanceInterface::UPDATE_START );
 585     mCore.Update( frameDelta,
 586                   currentTime,
 587                   nextFrameTime,
 588                   updateStatus,
 589                   renderToFboEnabled,
 590                   isRenderingToFbo );
 591     AddPerformanceMarker( PerformanceInterface::UPDATE_END );
 592
 593     unsigned int keepUpdatingStatus = updateStatus.KeepUpdating();
 594
 595     // Tell the event-thread to wake up (if asleep) and send a notification event to Core if required
 596     if( updateStatus.NeedsNotification() )
 597     {
 598       mNotificationTrigger.Trigger();
 599       LOG_UPDATE_RENDER( "Notification Triggered" );
 600     }
 601
 602     // Check resize
 603     bool shouldSurfaceBeResized = ShouldSurfaceBeResized();
 604     if( DALI_UNLIKELY( shouldSurfaceBeResized ) )
 605     {
 606       if( updateStatus.SurfaceRectChanged() )
 607       {
 608         LOG_UPDATE_RENDER_TRACE_FMT( "Resizing Surface" );
 609         SurfaceResized();
 610       }
 611     }
 612
 613     // Optional logging of update/render status
 614     mUpdateStatusLogger.Log( keepUpdatingStatus );
 615
 616     //////////////////////////////
 617     // RENDER
 618     //////////////////////////////
 619
 620     mAdaptorInterfaces.GetDisplayConnectionInterface().ConsumeEvents();
 621
 622     if( mPreRenderCallback != NULL )
 623     {
 624       bool keepCallback = CallbackBase::ExecuteReturn<bool>(*mPreRenderCallback);
 625       if( ! keepCallback )
 626       {
 627         delete mPreRenderCallback;
 628         mPreRenderCallback = NULL;
 629       }
 630     }
 631
 632     if( eglImpl.IsSurfacelessContextSupported() )
 633     {
 634       // Make the shared surfaceless context as current before rendering
 635       eglImpl.MakeContextCurrent( EGL_NO_SURFACE, eglImpl.GetContext() );
 636     }
 637
 638     Integration::RenderStatus renderStatus;
 639
 640     AddPerformanceMarker( PerformanceInterface::RENDER_START );
 641     mCore.Render( renderStatus, mForceClear, mUploadWithoutRendering );
 642
 643     //////////////////////////////
 644     // DELETE SURFACE
 645     //////////////////////////////
 646
 647     Integration::RenderSurface* deletedSurface = ShouldSurfaceBeDeleted();
 648     if( DALI_UNLIKELY( deletedSurface ) )
 649     {
 650       LOG_UPDATE_RENDER_TRACE_FMT( "Deleting Surface" );
 651
 652       mCore.SurfaceDeleted( deletedSurface );
 653
 654       SurfaceDeleted();
 655     }
 656
 657     AddPerformanceMarker( PerformanceInterface::RENDER_END );
 658
 659     mForceClear = false;
 660
 661     // Trigger event thread to request Update/Render thread to sleep if update not required
 662     if( ( Integration::KeepUpdating::NOT_REQUESTED == keepUpdatingStatus ) && !renderStatus.NeedsUpdate() )
 663     {
 664       mSleepTrigger->Trigger();
 665       updateRequired = false;
 666       LOG_UPDATE_RENDER( "Sleep Triggered" );
 667     }
 668     else
 669     {
 670       updateRequired = true;
 671     }
 672
 673     //////////////////////////////
 674     // FRAME TIME
 675     //////////////////////////////
 676
 677     extraFramesDropped = 0;
 678
 679     if (timeToSleepUntil == 0)
 680     {
 681       // If this is the first frame after the thread is initialized or resumed, we
 682       // use the actual time the current frame starts from to calculate the time to
 683       // sleep until the next frame.
 684       timeToSleepUntil = currentFrameStartTime + mDefaultFrameDurationNanoseconds;
 685     }
 686     else
 687     {
 688       // Otherwise, always use the sleep-until time calculated in the last frame to
 689       // calculate the time to sleep until the next frame. In this way, if there is
 690       // any time gap between the current frame and the next frame, or if update or
 691       // rendering in the current frame takes too much time so that the specified
 692       // sleep-until time has already passed, it will try to keep the frames syncing
 693       // by shortening the duration of the next frame.
 694       timeToSleepUntil += mDefaultFrameDurationNanoseconds;
 695
 696       // Check the current time at the end of the frame
 697       uint64_t currentFrameEndTime = 0;
 698       TimeService::GetNanoseconds( currentFrameEndTime );
 699       while ( currentFrameEndTime > timeToSleepUntil + mDefaultFrameDurationNanoseconds )
 700       {
 701          // We are more than one frame behind already, so just drop the next frames
 702          // until the sleep-until time is later than the current time so that we can
 703          // catch up.
 704          timeToSleepUntil += mDefaultFrameDurationNanoseconds;
 705          extraFramesDropped++;
 706       }
 707     }
 708
 709     // Render to FBO is intended to measure fps above 60 so sleep is not wanted.
 710     if( 0u == renderToFboInterval )
 711     {
 712       // Sleep until at least the the default frame duration has elapsed. This will return immediately if the specified end-time has already passed.
 713       TimeService::SleepUntil( timeToSleepUntil );
 714     }
 715   }
 716
 717   // Inform core of context destruction & shutdown EGL
 718   mCore.ContextDestroyed();
 719   currentSurface = mAdaptorInterfaces.GetRenderSurfaceInterface();
 720   if( currentSurface )
 721   {
 722     currentSurface->DestroySurface();
 723     currentSurface = nullptr;
 724   }
 725
 726   LOG_UPDATE_RENDER( "THREAD DESTROYED" );
 727
 728   // Uninstall the logging function
 729   mEnvironmentOptions.UnInstallLogFunction();
 730 }
 731
 732 bool CombinedUpdateRenderController::UpdateRenderReady( bool& useElapsedTime, bool updateRequired, uint64_t& timeToSleepUntil )
 733 {
 734   useElapsedTime = true;
 735
 736   ConditionalWait::ScopedLock updateLock( mUpdateRenderThreadWaitCondition );
 737   while( ( ! mUpdateRenderRunCount || // Should try to wait if event-thread has paused the Update/Render thread
 738            ( mUpdateRenderThreadCanSleep && ! updateRequired && ! mPendingRequestUpdate ) ) && // Ensure we wait if we're supposed to be sleeping AND do not require another update
 739          ! mDestroyUpdateRenderThread && // Ensure we don't wait if the update-render-thread is supposed to be destroyed
 740          ! mNewSurface &&  // Ensure we don't wait if we need to replace the surface
 741          ! mDeletedSurface && // Ensure we don't wait if we need to delete the surface
 742          ! mSurfaceResized ) // Ensure we don't wait if we need to resize the surface
 743   {
 744     LOG_UPDATE_RENDER( "WAIT: mUpdateRenderRunCount:       %d", mUpdateRenderRunCount );
 745     LOG_UPDATE_RENDER( "      mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
 746     LOG_UPDATE_RENDER( "      mDestroyUpdateRenderThread:  %d", mDestroyUpdateRenderThread );
 747     LOG_UPDATE_RENDER( "      mNewSurface:                 %d", mNewSurface );
 748     LOG_UPDATE_RENDER( "      mDeletedSurface:             %d", mDeletedSurface );
 749     LOG_UPDATE_RENDER( "      mSurfaceResized:             %d", mSurfaceResized );
 750
 751     // Reset the time when the thread is waiting, so the sleep-until time for
 752     // the first frame after resuming should be based on the actual start time
 753     // of the first frame.
 754     timeToSleepUntil = 0;
 755
 756     mUpdateRenderThreadWaitCondition.Wait( updateLock );
 757
 758     if( ! mUseElapsedTimeAfterWait )
 759     {
 760       useElapsedTime = false;
 761     }
 762   }
 763
 764   LOG_COUNTER_UPDATE_RENDER( "mUpdateRenderRunCount:       %d", mUpdateRenderRunCount );
 765   LOG_COUNTER_UPDATE_RENDER( "mUpdateRenderThreadCanSleep: %d, updateRequired: %d, mPendingRequestUpdate: %d", mUpdateRenderThreadCanSleep, updateRequired, mPendingRequestUpdate );
 766   LOG_COUNTER_UPDATE_RENDER( "mDestroyUpdateRenderThread:  %d", mDestroyUpdateRenderThread );
 767   LOG_COUNTER_UPDATE_RENDER( "mNewSurface:                 %d", mNewSurface );
 768   LOG_COUNTER_UPDATE_RENDER( "mDeletedSurface:             %d", mDeletedSurface );
 769   LOG_COUNTER_UPDATE_RENDER( "mSurfaceResized:             %d", mSurfaceResized );
 770
 771   mUseElapsedTimeAfterWait = FALSE;
 772   mUpdateRenderThreadCanSleep = FALSE;
 773   mPendingRequestUpdate = FALSE;
 774
 775   // If we've been asked to run Update/Render cycles a finite number of times then decrement so we wait after the
 776   // requested number of cycles
 777   if( mUpdateRenderRunCount > 0 )
 778   {
 779     --mUpdateRenderRunCount;
 780   }
 781
 782   // Keep the update-render thread alive if this thread is NOT to be destroyed
 783   return ! mDestroyUpdateRenderThread;
 784 }
 785
 786 Integration::RenderSurface* CombinedUpdateRenderController::ShouldSurfaceBeReplaced()
 787 {
 788   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 789
 790   Integration::RenderSurface* newSurface = mNewSurface;
 791   mNewSurface = NULL;
 792
 793   return newSurface;
 794 }
 795
 796 void CombinedUpdateRenderController::SurfaceReplaced()
 797 {
 798   // Just increment the semaphore
 799   sem_post( &mEventThreadSemaphore );
 800 }
 801
 802 Integration::RenderSurface* CombinedUpdateRenderController::ShouldSurfaceBeDeleted()
 803 {
 804   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 805
 806   Integration::RenderSurface* deletedSurface = mDeletedSurface;
 807   mDeletedSurface = NULL;
 808
 809   return deletedSurface;
 810 }
 811
 812 void CombinedUpdateRenderController::SurfaceDeleted()
 813 {
 814   // Just increment the semaphore
 815   sem_post( &mEventThreadSemaphore );
 816 }
 817
 818 bool CombinedUpdateRenderController::ShouldSurfaceBeResized()
 819 {
 820   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 821   return mSurfaceResized;
 822 }
 823
 824 void CombinedUpdateRenderController::SurfaceResized()
 825 {
 826   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 827   mSurfaceResized = FALSE;
 828 }
 829
 830 ///////////////////////////////////////////////////////////////////////////////////////////////////
 831 // ALL THREADS
 832 ///////////////////////////////////////////////////////////////////////////////////////////////////
 833
 834 void CombinedUpdateRenderController::NotifyThreadInitialised()
 835 {
 836   // Just increment the semaphore
 837   sem_post( &mEventThreadSemaphore );
 838 }
 839
 840 void CombinedUpdateRenderController::AddPerformanceMarker( PerformanceInterface::MarkerType type )
 841 {
 842   if( mPerformanceInterface )
 843   {
 844     mPerformanceInterface->AddMarker( type );
 845   }
 846 }
 847
 848 /////////////////////////////////////////////////////////////////////////////////////////////////
 849 // POST RENDERING: EVENT THREAD
 850 /////////////////////////////////////////////////////////////////////////////////////////////////
 851
 852 void CombinedUpdateRenderController::PostRenderComplete()
 853 {
 854   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 855   mPostRendering = FALSE;
 856   mUpdateRenderThreadWaitCondition.Notify( lock );
 857 }
 858
 859 ///////////////////////////////////////////////////////////////////////////////////////////////////
 860 // POST RENDERING: RENDER THREAD
 861 ///////////////////////////////////////////////////////////////////////////////////////////////////
 862
 863 void CombinedUpdateRenderController::PostRenderStarted()
 864 {
 865   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 866   mPostRendering = TRUE;
 867 }
 868
 869 void CombinedUpdateRenderController::PostRenderWaitForCompletion()
 870 {
 871   ConditionalWait::ScopedLock lock( mUpdateRenderThreadWaitCondition );
 872   while( mPostRendering &&
 873          ! mNewSurface &&                // We should NOT wait if we're replacing the surface
 874          ! mDeletedSurface &&            // We should NOT wait if we're deleting the surface
 875          ! mSurfaceResized &&            // We should NOT wait if we're resizing the surface
 876          ! mDestroyUpdateRenderThread )
 877   {
 878     mUpdateRenderThreadWaitCondition.Wait( lock );
 879   }
 880 }
 881
 882 } // namespace Adaptor
 883
 884 } // namespace Internal
 885
 886 } // namespace Dali