-#ifndef __DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H__
-#define __DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H__
+#ifndef DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H
+#define DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H
/*
- * Copyright (c) 2017 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 <pthread.h>
#include <semaphore.h>
+#include <atomic>
#include <stdint.h>
-#include <dali/integration-api/core.h>
#include <dali/devel-api/threading/conditional-wait.h>
+#include <dali/devel-api/threading/semaphore.h>
+#include <dali/integration-api/core.h>
// INTERNAL INCLUDES
-#include <dali/integration-api/thread-synchronization-interface.h>
-#include <dali/internal/system/common/performance-interface.h>
-#include <dali/internal/system/common/fps-tracker.h>
-#include <dali/internal/graphics/common/render-helper.h>
+#include <dali/integration-api/adaptor-framework/thread-synchronization-interface.h>
#include <dali/internal/adaptor/common/thread-controller-interface.h>
+#include <dali/internal/system/common/fps-tracker.h>
+#include <dali/internal/system/common/performance-interface.h>
#include <dali/internal/system/common/update-status-logger.h>
+#include <dali/internal/window-system/common/display-connection.h>
namespace Dali
{
-class RenderSurface;
+class RenderSurfaceInterface;
class TriggerEventInterface;
namespace Internal
/**
* Constructor
*/
- CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions );
+ CombinedUpdateRenderController( AdaptorInternalServices& adaptorInterfaces, const EnvironmentOptions& environmentOptions, ThreadMode threadMode );
/**
* Non virtual destructor. Not intended as base class.
/**
* @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( RenderSurface* 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:
// 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.
*
* @return Pointer to the new surface, NULL otherwise
*/
- RenderSurface* ShouldSurfaceBeReplaced();
+ Dali::RenderSurfaceInterface* ShouldSurfaceBeReplaced();
/**
* Called by the Update/Render thread after a surface has been replaced.
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.
*
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
*/
/**
* @copydoc ThreadSynchronizationInterface::PostRenderComplete()
*/
- virtual void PostRenderComplete();
+ void PostRenderComplete() override;
/////////////////////////////////////////////////////////////////////////////////////////////////
//// Called by the Render Thread if post-rendering is required
/**
* @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.
- RenderHelper mRenderHelper; ///< Helper class for EGL, pre & post rendering
-
- sem_t mEventThreadSemaphore; ///< Used by the event thread to ensure all threads have been initialised, and when replacing the surface.
+ 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.
const EnvironmentOptions& mEnvironmentOptions; ///< Environment options
TriggerEventInterface& mNotificationTrigger; ///< Reference to notification event trigger
TriggerEventInterface* mSleepTrigger; ///< Used by the update-render thread to trigger the event thread when it no longer needs to do any updates
+ CallbackBase* mPreRenderCallback; ///< Used by Update/Render thread when PreRender is about to be called on graphics.
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.
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
//
volatile unsigned int mUseElapsedTimeAfterWait; ///< Whether we should use the elapsed time after waiting (set by the event-thread, read by the update-render-thread).
- 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 forcely
+ 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<Rect<int>> mDamagedRects; ///< Keeps collected damaged render items rects for one render pass
};
} // namespace Adaptor
} // namespace Dali
-#endif // __DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H__
+#endif // DALI_INTERNAL_COMBINED_UPDATE_RENDER_CONTROLLER_H
projects / platform / core / uifw / dali-adaptor.git / blobdiff