Replace POSIX unnamed semaphores by dali-core primitives

[platform/core/uifw/dali-adaptor.git] / dali / internal / adaptor / common / combined-update-render-controller.h

diff --git a/dali/internal/adaptor/common/combined-update-render-controller.h b/dali/internal/adaptor/common/combined-update-render-controller.h
index 7f6f007..8c2da95 100644 (file)
--- a/dali/internal/adaptor/common/combined-update-render-controller.h
+++ b/dali/internal/adaptor/common/combined-update-render-controller.h
@@ -21,8 +21,10 @@
 // EXTERNAL INCLUDES
 #include <pthread.h>
 #include <semaphore.h>
+#include <atomic>
 #include <stdint.h>
 #include <dali/devel-api/threading/conditional-wait.h>
+#include <dali/devel-api/threading/semaphore.h>
 #include <dali/integration-api/core.h>
 
 // INTERNAL INCLUDES
@@ -79,7 +81,7 @@ public:
   /**
    * Constructor
    */
-  CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions );
+  CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions, ThreadMode threadMode );
 
   /**
    * Non virtual destructor. Not intended as base class.
@@ -89,57 +91,62 @@ public:
   /**
    * @copydoc ThreadControllerInterface::Initialize()
    */
-  virtual void Initialize();
+  void Initialize() override;
 
   /**
    * @copydoc ThreadControllerInterface::Start()
    */
-  virtual void Start();
+  void Start() override;
 
   /**
    * @copydoc ThreadControllerInterface::Pause()
    */
-  virtual void Pause();
+  void Pause() override;
 
   /**
    * @copydoc ThreadControllerInterface::Resume()
    */
-  virtual void Resume();
+  void Resume() override;
 
   /**
    * @copydoc ThreadControllerInterface::Stop()
    */
-  virtual void Stop();
+  void Stop() override;
 
   /**
    * @copydoc ThreadControllerInterface::RequestUpdate()
    */
-  virtual void RequestUpdate();
+  void RequestUpdate() override;
 
   /**
    * @copydoc ThreadControllerInterface::RequestUpdateOnce()
    */
-  virtual void RequestUpdateOnce( UpdateMode updateMode );
+  void RequestUpdateOnce( UpdateMode updateMode ) override;
 
   /**
    * @copydoc ThreadControllerInterface::ReplaceSurface()
    */
-  virtual void ReplaceSurface( Dali::RenderSurfaceInterface* surface );
+  void ReplaceSurface( Dali::RenderSurfaceInterface* surface ) override;
+
+  /**
+   * @copydoc ThreadControllerInterface::DeleteSurface()
+   */
+  void DeleteSurface( Dali::RenderSurfaceInterface* surface ) override;
 
   /**
    * @copydoc ThreadControllerInterface::ResizeSurface()
    */
-  virtual void ResizeSurface();
+  void ResizeSurface() override;
 
   /**
    * @copydoc ThreadControllerInterface::WaitForGraphicsInitialization()
    */
-  virtual void WaitForGraphicsInitialization();
+  void WaitForGraphicsInitialization() override;
 
   /**
    * @copydoc ThreadControllerInterface::SetRenderRefreshRate()
    */
-  virtual void SetRenderRefreshRate( unsigned int numberOfFramesPerRender );
+  void SetRenderRefreshRate( unsigned int numberOfFramesPerRender ) override;
 
   /**
    * @copydoc ThreadControllerInterface::SetPreRenderCallback
@@ -149,7 +156,7 @@ public:
   /**
    * @copydoc ThreadControllerInterface::AddSurface()
    */
-  virtual void AddSurface( Dali::RenderSurfaceInterface* surface );
+  void AddSurface( Dali::RenderSurfaceInterface* surface ) override;
 
 private:
 
@@ -244,6 +251,21 @@ private:
   void SurfaceReplaced();
 
   /**
+   * Checks to see if the surface needs to be deleted.
+   * This will lock the mutex in mUpdateRenderThreadWaitCondition.
+   *
+   * @return Pointer to the deleted surface, nullptr otherwise
+   */
+  Dali::RenderSurfaceInterface* ShouldSurfaceBeDeleted();
+
+  /**
+   * Called by the Update/Render thread after a surface has been deleted.
+   *
+   * This will lock the mutex in mEventThreadWaitCondition
+   */
+  void SurfaceDeleted();
+
+  /**
    * Checks to see if the surface needs to be resized.
    * This will lock the mutex in mUpdateRenderThreadWaitCondition.
    *
@@ -301,7 +323,7 @@ private:
   /**
    * @copydoc ThreadSynchronizationInterface::PostRenderComplete()
    */
-  virtual void PostRenderComplete();
+  void PostRenderComplete() override;
 
   /////////////////////////////////////////////////////////////////////////////////////////////////
   //// Called by the Render Thread if post-rendering is required
@@ -310,20 +332,21 @@ private:
   /**
    * @copydoc ThreadSynchronizationInterface::PostRenderStarted()
    */
-  virtual void PostRenderStarted();
+  void PostRenderStarted() override;
 
   /**
    * @copydoc ThreadSynchronizationInterface::PostRenderStarted()
    */
-  virtual void PostRenderWaitForCompletion();
+  void PostRenderWaitForCompletion() override;
 
 private:
 
   FpsTracker                        mFpsTracker;                       ///< Object that tracks the FPS
   UpdateStatusLogger                mUpdateStatusLogger;               ///< Object that logs the update-status as required.
 
-  sem_t                             mEventThreadSemaphore;             ///< Used by the event thread to ensure all threads have been initialised, and when replacing the surface.
-  sem_t                             mGraphicsInitializeSemaphore;      ///< Used by the render thread to ensure the graphics has been initialised.
+  Semaphore<>                       mEventThreadSemaphore;             ///< Used by the event thread to ensure all threads have been initialised, and when replacing the surface.
+  ConditionalWait                   mGraphicsInitializeWait;           ///< Used by the render thread to ensure the graphics has been initialised.
+  Semaphore<>                       mSurfaceSemaphore;                 ///< Used by the event thread to ensure the surface has been deleted or replaced.
 
   ConditionalWait                   mUpdateRenderThreadWaitCondition;  ///< The wait condition for the update-render-thread.
 
@@ -346,6 +369,8 @@ private:
   unsigned int                      mUpdateRequestCount;               ///< Count of update-requests we have received to ensure we do not go to sleep too early.
   unsigned int                      mRunning;                          ///< Read and set on the event-thread only to state whether we are running.
 
+  ThreadMode                        mThreadMode;                       ///< Whether the thread runs continuously or runs when it is requested.
+
   //
   // NOTE: cannot use booleans as these are used from multiple threads, must use variable with machine word size for atomic read/write
   //
@@ -359,6 +384,7 @@ private:
   volatile unsigned int             mUseElapsedTimeAfterWait;          ///< Whether we should use the elapsed time after waiting (set by the event-thread, read by the update-render-thread).
 
   Dali::RenderSurfaceInterface* volatile mNewSurface;                  ///< Will be set to the new-surface if requested (set by the event-thread, read & cleared by the update-render thread).
+  Dali::RenderSurfaceInterface* volatile mDeletedSurface;              ///< Will be set to the deleted surface if requested (set by the event-thread, read & cleared by the update-render thread).
 
   volatile unsigned int             mPostRendering;                    ///< Whether post-rendering is taking place (set by the event & render threads, read by the render-thread).
   volatile unsigned int             mSurfaceResized;                   ///< Will be set to resize the surface (set by the event-thread, read & cleared by the update-render thread).
@@ -367,6 +393,8 @@ private:
   volatile unsigned int             mUploadWithoutRendering;           ///< Will be set to upload the resource only (with no rendering)
 
   volatile unsigned int             mFirstFrameAfterResume;            ///< Will be set to check the first frame after resume (for log)
+
+  std::vector<Rect<int>>            mDamagedRects;                     ///< Keeps collected damaged render items rects for one render pass
 };
 
 } // namespace Adaptor