/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
// INTERNAL INCLUDES
#include <base/interfaces/adaptor-internal-services.h>
-#include <base/update-render-synchronization.h>
+#include <base/thread-synchronization.h>
#include <base/environment-options.h>
#include <base/display-connection.h>
}
-RenderThread::RenderThread( UpdateRenderSynchronization& sync,
+RenderThread::RenderThread( ThreadSynchronization& sync,
AdaptorInternalServices& adaptorInterfaces,
const EnvironmentOptions& environmentOptions )
-: mUpdateRenderSync( sync ),
+: mThreadSynchronization( sync ),
mCore( adaptorInterfaces.GetCore() ),
mGLES( adaptorInterfaces.GetGlesInterface() ),
mEglFactory( &adaptorInterfaces.GetEGLFactoryInterface()),
DALI_ASSERT_ALWAYS( !mEGL && "Egl already initialized" );
// create the render thread, initially we are rendering
- mThread = new boost::thread(boost::bind(&RenderThread::Run, this));
+ mThread = new pthread_t();
+ int error = pthread_create( mThread, NULL, InternalThreadEntryFunc, this );
+ DALI_ASSERT_ALWAYS( !error && "Return code from pthread_create() in RenderThread" );
- mSurface->StartRender();
+ if( mSurface )
+ {
+ mSurface->StartRender();
+ }
}
void RenderThread::Stop()
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Stop()\n");
- // shutdown the render thread and destroy the opengl context
- if( mThread )
+ if( mSurface )
{
// Tell surface we have stopped rendering
mSurface->StopRender();
+ // The surface will be destroyed soon; this pointer will become invalid
+ mSurface = NULL;
+ }
+
+ // shutdown the render thread and destroy the opengl context
+ if( mThread )
+ {
// wait for the thread to finish
- mThread->join();
+ pthread_join(*mThread, NULL);
delete mThread;
mThread = NULL;
bool RenderThread::Run()
{
- // install a function for logging
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run\n");
+
+ // Install a function for logging
mEnvironmentOptions.InstallLogFunction();
InitializeEgl();
- bool running( true );
-
Dali::Integration::RenderStatus renderStatus;
+ RenderRequest* request = NULL;
- uint64_t currentTime( 0 );
-
- // render loop, we stay inside here when rendering
- while( running )
+ // Render loop, we stay inside here when rendering
+ while( mThreadSynchronization.RenderReady( request ) )
{
- // Sync with update thread and get any outstanding requests from UpdateRenderSynchronization
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 1 - RenderSyncWithUpdate()\n");
- RenderRequest* request = NULL;
- running = mUpdateRenderSync.RenderSyncWithUpdate( request );
-
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 2 - Process requests\n");
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 1 - RenderReady\n");
// Consume any pending events to avoid memory leaks
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 2 - ConsumeEvents\n");
mDisplayConnection->ConsumeEvents();
- bool processRequests = true;
- bool requestProcessed = false;
- while( processRequests && running)
+ // Check if we've got a request from the main thread (e.g. replace surface)
+ if( request )
{
- // Check if we've got any requests from the main thread (e.g. replace surface)
- requestProcessed = ProcessRequest( request );
-
- // perform any pre-render operations
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - PreRender\n");
- bool preRendered = PreRender(); // Returns false if no surface onto which to render
- if( preRendered )
- {
- processRequests = false;
- }
- else
- {
- // Block until new surface... - cleared by ReplaceSurface code in UpdateRenderController
- running = mUpdateRenderSync.RenderSyncWithRequest(request);
- }
+ // Process the request, we should NOT render when we have a request
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Process requests\n");
+ ProcessRequest( request );
}
-
- if( running )
+ else
{
- // Render
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 4 - Core.Render()\n");
- mCore.Render( renderStatus );
-
- // Notify the update-thread that a render has completed
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 5 - Sync.RenderFinished()\n");
- mUpdateRenderSync.RenderFinished( renderStatus.NeedsUpdate(), requestProcessed );
-
- uint64_t newTime( mUpdateRenderSync.GetTimeMicroseconds() );
-
- // perform any post-render operations
- if ( renderStatus.HasRendered() )
+ // No request to process so we render
+ if( PreRender() ) // Returns false if no surface onto which to render
{
- DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 6 - PostRender()\n");
- PostRender( static_cast< unsigned int >(newTime - currentTime) );
+ // Render
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Core.Render()\n");
+
+ mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_START );
+ mCore.Render( renderStatus );
+ mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_END );
+
+ // Decrement the count of how far update is ahead of render
+ mThreadSynchronization.RenderFinished();
+
+ // Perform any post-render operations
+ if ( renderStatus.HasRendered() )
+ {
+ DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 4 - PostRender()\n");
+ PostRender();
+ }
}
-
- currentTime = newTime;
}
+
+ request = NULL; // Clear the request if it was set, no need to release memory
}
- // shut down egl
+ // Shut down EGL
ShutdownEgl();
- // install a function for logging
+ // Uninstall the logging function
mEnvironmentOptions.UnInstallLogFunction();
return true;
}
-bool RenderThread::ProcessRequest( RenderRequest* request )
+void RenderThread::ProcessRequest( RenderRequest* request )
{
- bool processedRequest = false;
-
if( request != NULL )
{
switch(request->GetType())
ReplaceSurfaceRequest* replaceSurfaceRequest = static_cast<ReplaceSurfaceRequest*>(request);
ReplaceSurface( replaceSurfaceRequest->GetSurface() );
replaceSurfaceRequest->ReplaceCompleted();
- processedRequest = true;
+ mThreadSynchronization.RenderInformSurfaceReplaced();
break;
}
}
}
- return processedRequest;
}
void RenderThread::ReplaceSurface( RenderSurface* newSurface )
mDisplayConnection->InitializeEgl(*mEGL);
- bool contextLost = newSurface->ReplaceEGLSurface(*mEGL);
- if( contextLost )
- {
- DALI_LOG_WARNING("Context lost\n");
- mCore.ContextDestroyed();
- mCore.ContextCreated();
- }
+ newSurface->ReplaceEGLSurface(*mEGL);
// use the new surface from now on
mSurface = newSurface;
mSurfaceReplaced = true;
}
-
void RenderThread::ShutdownEgl()
{
// inform core of context destruction
mCore.ContextDestroyed();
- // give a chance to destroy the OpenGL surface that created externally
- mSurface->DestroyEglSurface( *mEGL );
+ if( mSurface )
+ {
+ // give a chance to destroy the OpenGL surface that created externally
+ mSurface->DestroyEglSurface( *mEGL );
+ }
// delete the GL context / egl surface
mEGL->TerminateGles();
bool RenderThread::PreRender()
{
- bool success = mSurface->PreRender( *mEGL, mGLES );
+ bool success( false );
+ if( mSurface )
+ {
+ success = mSurface->PreRender( *mEGL, mGLES );
+ }
+
if( success )
{
mGLES.PreRender();
return success;
}
-void RenderThread::PostRender( unsigned int timeDelta )
+void RenderThread::PostRender()
{
// Inform the gl implementation that rendering has finished before informing the surface
- mGLES.PostRender(timeDelta);
+ mGLES.PostRender();
- // Inform the surface that rendering this frame has finished.
- mSurface->PostRender( *mEGL, mGLES, mDisplayConnection, timeDelta, mSurfaceReplaced );
+ if( mSurface )
+ {
+ // Inform the surface that rendering this frame has finished.
+ mSurface->PostRender( *mEGL, mGLES, mDisplayConnection, mSurfaceReplaced );
+ }
mSurfaceReplaced = false;
}
-
} // namespace Adaptor
} // namespace Internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff