X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fadaptor%2Fcommon%2Fcombined-update-render-controller.h;h=6d0cb3786204e50b9ca3d0f0ae1e5ae548e6caa5;hb=97568a209c309d5f99bf288afa951a77f7fdcddd;hp=bdb51b013fa53f56cd5481f5a91ca3c819a9c94e;hpb=a588a60f8808b305babc5a94664bfa1b59cdc930;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/dali/internal/adaptor/common/combined-update-render-controller.h b/dali/internal/adaptor/common/combined-update-render-controller.h index bdb51b0..6d0cb37 100644 --- a/dali/internal/adaptor/common/combined-update-render-controller.h +++ b/dali/internal/adaptor/common/combined-update-render-controller.h @@ -2,7 +2,7 @@ #define DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H /* - * 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. @@ -19,20 +19,21 @@ */ // EXTERNAL INCLUDES +#include #include +#include #include -#include #include +#include // INTERNAL INCLUDES -#include -#include -#include +#include #include +#include +#include #include #include - namespace Dali { @@ -79,7 +80,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,58 +90,73 @@ 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(); + 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() + */ + void WaitForGraphicsInitialization() override; /** * @copydoc ThreadControllerInterface::SetRenderRefreshRate() */ - virtual void SetRenderRefreshRate( unsigned int numberOfFramesPerRender ); + void SetRenderRefreshRate( unsigned int numberOfFramesPerRender ) override; /** * @copydoc ThreadControllerInterface::SetPreRenderCallback */ void SetPreRenderCallback( CallbackBase* callback ) override; + /** + * @copydoc ThreadControllerInterface::AddSurface() + */ + void AddSurface( Dali::RenderSurfaceInterface* surface ) override; + private: // Undefined copy constructor. @@ -153,14 +169,21 @@ private: // EventThread ///////////////////////////////////////////////////////////////////////////////////////////////// + enum AnimationProgression + { + USE_ELAPSED_TIME, ///< Animation progression using elapsed time + NONE ///< No animation progression + }; + /** * Runs the Update/Render Thread. * This will lock the mutex in mUpdateRenderThreadWaitCondition. * * @param[in] numberOfCycles The number of times the update/render cycle should run. If -1, then it will run continuously. - * @param[in] useElapsedTimeAfterWait If true, then the elapsed time during wait is used for animations, otherwise no animation progression is made. + * @param[in] animationProgression Whether to progress animation using time elapsed since the last frame. + * @param[in] updateMode The update mode (i.e. either update & render or skip rendering) */ - inline void RunUpdateRenderThread( int numberOfCycles, bool useElapsedTimeAfterWait ); + inline void RunUpdateRenderThread( int numberOfCycles, AnimationProgression animationProgression, UpdateMode updateMode ); /** * Pauses the Update/Render Thread. @@ -217,7 +240,7 @@ private: * * @return Pointer to the new surface, NULL otherwise */ - Integration::RenderSurface* ShouldSurfaceBeReplaced(); + Dali::RenderSurfaceInterface* ShouldSurfaceBeReplaced(); /** * Called by the Update/Render thread after a surface has been replaced. @@ -227,6 +250,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. * @@ -263,6 +301,11 @@ private: void NotifyThreadInitialised(); /** + * Called by the update-render thread when graphics has been initialised. + */ + void NotifyGraphicsInitialised(); + + /** * Helper to add a performance marker to the performance server (if it's active) * @param[in] type performance marker type */ @@ -279,7 +322,7 @@ private: /** * @copydoc ThreadSynchronizationInterface::PostRenderComplete() */ - virtual void PostRenderComplete(); + void PostRenderComplete() override; ///////////////////////////////////////////////////////////////////////////////////////////////// //// Called by the Render Thread if post-rendering is required @@ -288,12 +331,12 @@ private: /** * @copydoc ThreadSynchronizationInterface::PostRenderStarted() */ - virtual void PostRenderStarted(); + void PostRenderStarted() override; /** * @copydoc ThreadSynchronizationInterface::PostRenderStarted() */ - virtual void PostRenderWaitForCompletion(); + void PostRenderWaitForCompletion() override; private: @@ -301,6 +344,7 @@ private: 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. ConditionalWait mUpdateRenderThreadWaitCondition; ///< The wait condition for the update-render-thread. @@ -315,6 +359,7 @@ private: pthread_t* mUpdateRenderThread; ///< The Update/Render thread. float mDefaultFrameDelta; ///< Default time delta between each frame (used for animations). Not protected by lock, but written to rarely so not worth adding a lock when reading. + // TODO: mDefaultFrameDurationMilliseconds is defined as uint64_t, the only place where it is used, it is converted to an unsigned int!!! uint64_t mDefaultFrameDurationMilliseconds; ///< Default duration of a frame (used for predicting the time of the next frame). Not protected by lock, but written to rarely so not worth adding a lock when reading. uint64_t mDefaultFrameDurationNanoseconds; ///< Default duration of a frame (used for sleeping if not enough time elapsed). Not protected by lock, but written to rarely so not worth adding a lock when reading. uint64_t mDefaultHalfFrameNanoseconds; ///< Is half of mDefaultFrameDurationNanoseconds. Using a member variable avoids having to do the calculation every frame. Not protected by lock, but written to rarely so not worth adding a lock when reading. @@ -322,6 +367,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 // @@ -334,11 +381,18 @@ 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). - Integration::RenderSurface* 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 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). volatile unsigned int mForceClear; ///< Will be set to clear forcibly + + 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> mDamagedRects; ///< Keeps collected damaged render items rects for one render pass }; } // namespace Adaptor