X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fvisuals%2Fsvg%2Fsvg-rasterize-thread.cpp;h=c1ebd67efe7047ba6ffb63edf5e146ac22891f7a;hp=f0dc4a4399bb49150506d239e63d269baabca8ab;hb=35a7fe4e9b45558b58e365c637e704e2a51a5212;hpb=4cc02f3e2045755c2c65e64a6f5e126a4c6208ea diff --git a/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp b/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp index f0dc4a4..c1ebd67 100644 --- a/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp +++ b/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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,259 +19,418 @@ #include "svg-rasterize-thread.h" // EXTERNAL INCLUDES -#include +#include #include +#include +#include #include // INTERNAL INCLUDES -#include #include namespace Dali { - namespace Toolkit { - namespace Internal { - namespace { -const char * const UNITS("px"); +constexpr auto DEFAULT_NUMBER_OF_SVG_RASTERIZE_THREADS = size_t{4u}; +constexpr auto NUMBER_OF_SVG_RASTERIZE_THREADS_ENV = "DALI_SVG_RASTERIZE_THREADS"; + +size_t GetNumberOfThreads(const char* environmentVariable, size_t defaultValue) +{ + auto numberString = EnvironmentVariable::GetEnvironmentVariable(environmentVariable); + auto numberOfThreads = numberString ? std::strtoul(numberString, nullptr, 10) : 0; + constexpr auto MAX_NUMBER_OF_THREADS = 10u; + DALI_ASSERT_DEBUG(numberOfThreads < MAX_NUMBER_OF_THREADS); + return (numberOfThreads > 0 && numberOfThreads < MAX_NUMBER_OF_THREADS) ? numberOfThreads : defaultValue; +} + +#if defined(DEBUG_ENABLED) +Debug::Filter* gVectorImageLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_IMAGE"); +#endif + +} // unnamed namespace + +SvgTask::SvgTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer) +: mSvgVisual(svgVisual), + mVectorRenderer(vectorRenderer), + mHasSucceeded(false) +{ +} + +SvgVisual* SvgTask::GetSvgVisual() const +{ + return mSvgVisual.Get(); +} + +PixelData SvgTask::GetPixelData() const +{ + return PixelData(); +} + +bool SvgTask::HasSucceeded() const +{ + return mHasSucceeded; } -RasterizingTask::RasterizingTask( SvgVisual* svgRenderer, NSVGimage* parsedSvg, const VisualUrl& url, float dpi, unsigned int width, unsigned int height) -: mSvgVisual( svgRenderer ), - mParsedSvg( parsedSvg ), - mUrl( url ), - mDpi( dpi ), - mWidth( width ), - mHeight( height ) +SvgLoadingTask::SvgLoadingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi) +: SvgTask(svgVisual, vectorRenderer), + mUrl(url), + mDpi(dpi) { - mRasterizer = nsvgCreateRasterizer(); } -RasterizingTask::~RasterizingTask() +SvgLoadingTask::~SvgLoadingTask() { - nsvgDeleteRasterizer( mRasterizer ); } -void RasterizingTask::Load() +void SvgLoadingTask::Process() { - if( mParsedSvg != NULL) + if(mVectorRenderer.IsLoaded()) { + // Already loaded + mHasSucceeded = true; return; } - if( !mUrl.IsLocalResource() ) - { - Dali::Vector remoteBuffer; + Dali::Vector buffer; - if( !Dali::FileLoader::DownloadFileSynchronously( mUrl.GetUrl(), remoteBuffer )) + if(!mUrl.IsLocalResource()) + { + if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), buffer)) { - DALI_LOG_ERROR("Failed to download file!\n"); + DALI_LOG_ERROR("Failed to download file! [%s]\n", mUrl.GetUrl().c_str()); return; } + } + else + { + if(!Dali::FileLoader::ReadFile(mUrl.GetUrl(), buffer)) + { + DALI_LOG_ERROR("Failed to read file! [%s]\n", mUrl.GetUrl().c_str()); + return; + } + } - remoteBuffer.PushBack( '\0' ); - mParsedSvg = nsvgParse( reinterpret_cast(remoteBuffer.begin()), UNITS, mDpi ); + buffer.PushBack('\0'); + + if(!mVectorRenderer.Load(buffer, mDpi)) + { + DALI_LOG_ERROR("Failed to load data! [%s]\n", mUrl.GetUrl().c_str()); + return; } + + mHasSucceeded = true; } -void RasterizingTask::Rasterize( ) +SvgRasterizingTask::SvgRasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, unsigned int width, unsigned int height) +: SvgTask(svgVisual, vectorRenderer), + mWidth(width), + mHeight(height) { - if( mParsedSvg != NULL && mWidth > 0u && mHeight > 0u ) - { - float scaleX = static_cast( mWidth ) / mParsedSvg->width; - float scaleY = static_cast( mHeight ) / mParsedSvg->height; - float scale = scaleX < scaleY ? scaleX : scaleY; - unsigned int bufferStride = mWidth*Pixel::GetBytesPerPixel( Pixel::RGBA8888 ); - unsigned int bufferSize = bufferStride * mHeight; - - unsigned char* buffer = new unsigned char [bufferSize]; - nsvgRasterize(mRasterizer, mParsedSvg, 0.f,0.f,scale, - buffer, mWidth, mHeight, - bufferStride ); - - mPixelData = Dali::PixelData::New( buffer, bufferSize, mWidth, mHeight, Pixel::RGBA8888, Dali::PixelData::DELETE_ARRAY ); - } } -NSVGimage* RasterizingTask::GetParsedImage() const +SvgRasterizingTask::~SvgRasterizingTask() { - return mParsedSvg; } -SvgVisual* RasterizingTask::GetSvgVisual() const +void SvgRasterizingTask::Process() { - return mSvgVisual.Get(); + if(!mVectorRenderer.IsLoaded()) + { + DALI_LOG_ERROR("File is not loaded!\n"); + return; + } + + DALI_LOG_INFO(gVectorImageLogFilter, Debug::Verbose, "Rasterize: (%d x %d) [%p]\n", mWidth, mHeight, this); + + Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight); + if(!pixelBuffer) + { + DALI_LOG_ERROR("Rasterize is failed!\n"); + return; + } + + mPixelData = Devel::PixelBuffer::Convert(pixelBuffer); + mHasSucceeded = true; +} + +bool SvgRasterizingTask::IsReady() +{ + return mVectorRenderer.IsLoaded(); } -PixelData RasterizingTask::GetPixelData() const +PixelData SvgRasterizingTask::GetPixelData() const { return mPixelData; } -SvgRasterizeThread::SvgRasterizeThread( EventThreadCallback* trigger ) -: mTrigger( trigger ), - mIsThreadWaiting( false ) +SvgRasterizeThread::SvgRasterizeThread(SvgRasterizeManager& svgRasterizeManager) +: mConditionalWait(), + mLogFactory(Dali::Adaptor::Get().GetLogFactory()), + mSvgRasterizeManager(svgRasterizeManager), + mDestroyThread(false), + mIsThreadStarted(false), + mIsThreadIdle(true) { } SvgRasterizeThread::~SvgRasterizeThread() { - delete mTrigger; + // Stop the thread + { + ConditionalWait::ScopedLock lock(mConditionalWait); + mDestroyThread = true; + mConditionalWait.Notify(lock); + } + + Join(); } -void SvgRasterizeThread::TerminateThread( SvgRasterizeThread*& thread ) +bool SvgRasterizeThread::RequestRasterize() { - if( thread ) + if(!mIsThreadStarted) + { + Start(); + mIsThreadStarted = true; + } + { - // add an empty task would stop the thread from conditional wait. - thread->AddTask( RasterizingTaskPtr() ); - // stop the thread - thread->Join(); - // delete the thread - delete thread; - thread = NULL; + // Lock while adding task to the queue + ConditionalWait::ScopedLock lock(mConditionalWait); + + if(mIsThreadIdle) + { + mIsThreadIdle = false; + + // wake up the thread + mConditionalWait.Notify(lock); + return true; + } } + + return false; } -void SvgRasterizeThread::AddTask( RasterizingTaskPtr task ) +void SvgRasterizeThread::Run() { - bool wasEmpty = false; + SetThreadName("SvgRasterizeThread"); + mLogFactory.InstallLogFunction(); + while(!mDestroyThread) + { + SvgTaskPtr task = mSvgRasterizeManager.NextTaskToProcess(); + if(!task) + { + ConditionalWait::ScopedLock lock(mConditionalWait); + mIsThreadIdle = true; + mConditionalWait.Wait(lock); + } + else + { + task->Process(); + + mSvgRasterizeManager.AddCompletedTask(task); + } + } +} + +SvgRasterizeManager::SvgRasterizeManager() +: mRasterizers(GetNumberOfThreads(NUMBER_OF_SVG_RASTERIZE_THREADS_ENV, DEFAULT_NUMBER_OF_SVG_RASTERIZE_THREADS), [&]() { return RasterizeHelper(*this); }), + mTrigger(new EventThreadCallback(MakeCallback(this, &SvgRasterizeManager::ApplyRasterizedSVGToSampler))), + mProcessorRegistered(false) +{ +} + +SvgRasterizeManager::~SvgRasterizeManager() +{ + if(mProcessorRegistered) + { + Adaptor::Get().UnregisterProcessor(*this); + } + + mRasterizers.Clear(); +} + +void SvgRasterizeManager::AddTask(SvgTaskPtr task) +{ { // Lock while adding task to the queue - ConditionalWait::ScopedLock lock( mConditionalWait ); - wasEmpty = mRasterizeTasks.empty(); - if( !wasEmpty && task != NULL) + Mutex::ScopedLock lock(mMutex); + + // There are other tasks waiting for the rasterization + if(!mRasterizeTasks.empty()) { // Remove the tasks with the same renderer. // Older task which waiting to rasterize and apply the svg to the same renderer is expired. - for( std::vector< RasterizingTaskPtr >::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it ) + // Rasterizing task only, loading task is not duplicated. + for(std::vector::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it) { - if( (*it) && (*it)->GetSvgVisual() == task->GetSvgVisual() ) + if((*it) && (*it)->GetSvgVisual() == task->GetSvgVisual()) { - mRasterizeTasks.erase( it ); - break; + SvgRasterizingTask* oldTask = dynamic_cast(it->Get()); + SvgRasterizingTask* newTask = dynamic_cast(task.Get()); + if(oldTask && newTask) + { + mRasterizeTasks.erase(it); + break; + } } } } - mRasterizeTasks.push_back( task ); + + mRasterizeTasks.push_back(task); } - if( wasEmpty) + size_t count = mRasterizers.GetElementCount(); + size_t index = 0; + while(index++ < count) { - // wake up the image loading thread - mConditionalWait.Notify(); + auto rasterizerHelperIt = mRasterizers.GetNext(); + DALI_ASSERT_ALWAYS(rasterizerHelperIt != mRasterizers.End()); + + if(rasterizerHelperIt->RequestRasterize()) + { + break; + } + // If all threads are busy, then it's ok just to push the task because they will try to get the next job. + } + + if(!mProcessorRegistered) + { + Adaptor::Get().RegisterProcessor(*this); + mProcessorRegistered = true; } + + return; } -RasterizingTaskPtr SvgRasterizeThread::NextCompletedTask() +SvgTaskPtr SvgRasterizeManager::NextCompletedTask() { // Lock while popping task out from the queue - Mutex::ScopedLock lock( mMutex ); + Mutex::ScopedLock lock(mMutex); - if( mCompletedTasks.empty() ) + if(mCompletedTasks.empty()) { - return RasterizingTaskPtr(); + return SvgTaskPtr(); } - std::vector< RasterizingTaskPtr >::iterator next = mCompletedTasks.begin(); - RasterizingTaskPtr nextTask = *next; - mCompletedTasks.erase( next ); + std::vector::iterator next = mCompletedTasks.begin(); + SvgTaskPtr nextTask = *next; + mCompletedTasks.erase(next); return nextTask; } -void SvgRasterizeThread::RemoveTask( SvgVisual* visual ) +void SvgRasterizeManager::RemoveTask(SvgVisual* visual) { - // Lock while remove task from the queue - ConditionalWait::ScopedLock lock( mConditionalWait ); - if( !mRasterizeTasks.empty() ) { - for( std::vector< RasterizingTaskPtr >::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it ) + // Lock while remove task from the queue + Mutex::ScopedLock lock(mMutex); + if(!mRasterizeTasks.empty()) { - if( (*it) && (*it)->GetSvgVisual() == visual ) + for(std::vector::iterator it = mRasterizeTasks.begin(); it != mRasterizeTasks.end();) { - mRasterizeTasks.erase( it ); - break; + if((*it) && (*it)->GetSvgVisual() == visual) + { + it = mRasterizeTasks.erase(it); + } + else + { + it++; + } } } } -} - -void SvgRasterizeThread::DeleteImage( NSVGimage* parsedSvg ) -{ - // Lock while adding image to the delete queue - ConditionalWait::ScopedLock lock( mConditionalWait ); - if( mIsThreadWaiting ) // no rasterization is ongoing, save to delete - { - nsvgDelete( parsedSvg ); - } - else // wait to delete until current rasterization completed. - { - mDeleteSvg.PushBack( parsedSvg ); - } + UnregisterProcessor(); } -RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess() +SvgTaskPtr SvgRasterizeManager::NextTaskToProcess() { // Lock while popping task out from the queue - ConditionalWait::ScopedLock lock( mConditionalWait ); + Mutex::ScopedLock lock(mMutex); + + // pop out the next task from the queue + SvgTaskPtr nextTask = nullptr; - // Delete the image here to make sure that it is not used in the nsvgRasterize() - if( !mDeleteSvg.Empty() ) + for(auto iter = mRasterizeTasks.begin(), endIter = mRasterizeTasks.end(); iter != endIter; ++iter) { - for( Vector< NSVGimage* >::Iterator it = mDeleteSvg.Begin(), endIt = mDeleteSvg.End(); - it != endIt; - ++it ) + if((*iter)->IsReady()) { - nsvgDelete( *it ); + nextTask = *iter; + mRasterizeTasks.erase(iter); + break; } - mDeleteSvg.Clear(); } - // conditional wait - while( mRasterizeTasks.empty() ) - { - mIsThreadWaiting = true; - mConditionalWait.Wait( lock ); - } - mIsThreadWaiting = false; - - // pop out the next task from the queue - std::vector< RasterizingTaskPtr >::iterator next = mRasterizeTasks.begin(); - RasterizingTaskPtr nextTask = *next; - mRasterizeTasks.erase( next ); - return nextTask; } -void SvgRasterizeThread::AddCompletedTask( RasterizingTaskPtr task ) +void SvgRasterizeManager::AddCompletedTask(SvgTaskPtr task) { // Lock while adding task to the queue - Mutex::ScopedLock lock( mMutex ); - mCompletedTasks.push_back( task ); + Mutex::ScopedLock lock(mMutex); + mCompletedTasks.push_back(task); // wake up the main thread mTrigger->Trigger(); } -void SvgRasterizeThread::Run() +void SvgRasterizeManager::ApplyRasterizedSVGToSampler() { - SetThreadName( "SVGThread" ); - while( RasterizingTaskPtr task = NextTaskToProcess() ) + while(SvgTaskPtr task = NextCompletedTask()) { - task->Load( ); - task->Rasterize( ); - AddCompletedTask( task ); + DALI_LOG_INFO(gVectorImageLogFilter, Debug::Verbose, "task = %p\n", task.Get()); + + task->GetSvgVisual()->ApplyRasterizedImage(task->GetPixelData(), task->HasSucceeded()); } + + UnregisterProcessor(); +} + +void SvgRasterizeManager::Process(bool postProcessor) +{ + ApplyRasterizedSVGToSampler(); } +void SvgRasterizeManager::UnregisterProcessor() +{ + Mutex::ScopedLock lock(mMutex); + + if(mProcessorRegistered) + { + if(mRasterizeTasks.empty() && mCompletedTasks.empty()) + { + Adaptor::Get().UnregisterProcessor(*this); + mProcessorRegistered = false; + } + } +} + +SvgRasterizeManager::RasterizeHelper::RasterizeHelper(SvgRasterizeManager& svgRasterizeManager) +: RasterizeHelper(std::unique_ptr(new SvgRasterizeThread(svgRasterizeManager)), svgRasterizeManager) +{ +} + +SvgRasterizeManager::RasterizeHelper::RasterizeHelper(RasterizeHelper&& rhs) +: RasterizeHelper(std::move(rhs.mRasterizer), rhs.mSvgRasterizeManager) +{ +} + +SvgRasterizeManager::RasterizeHelper::RasterizeHelper(std::unique_ptr rasterizer, SvgRasterizeManager& svgRasterizeManager) +: mRasterizer(std::move(rasterizer)), + mSvgRasterizeManager(svgRasterizeManager) +{ +} + +bool SvgRasterizeManager::RasterizeHelper::RequestRasterize() +{ + return mRasterizer->RequestRasterize(); +} } // namespace Internal } // namespace Toolkit