{
namespace Internal
{
-RasterizingTask::RasterizingTask(SvgVisual* svgRenderer, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height)
-: mSvgVisual(svgRenderer),
+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;
+}
+
+SvgLoadingTask::SvgLoadingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi)
+: SvgTask(svgVisual, vectorRenderer),
mUrl(url),
- mDpi(dpi),
- mWidth(width),
- mHeight(height),
- mLoadSuccess(false)
+ mDpi(dpi)
{
}
-RasterizingTask::~RasterizingTask()
+SvgLoadingTask::~SvgLoadingTask()
{
}
-void RasterizingTask::Load()
+void SvgLoadingTask::Process()
{
- if(!mUrl.IsLocalResource())
+ if(mVectorRenderer.IsLoaded())
{
- Dali::Vector<uint8_t> remoteBuffer;
- if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), remoteBuffer))
- {
- DALI_LOG_ERROR("RasterizingTask::Load: Failed to download file! [%s]\n", mUrl.GetUrl().c_str());
- return;
- }
+ // Already loaded
+ mHasSucceeded = true;
+ return;
+ }
- remoteBuffer.PushBack('\0');
+ Dali::Vector<uint8_t> buffer;
- if(!mVectorRenderer.Load(remoteBuffer, mDpi))
+ if(!mUrl.IsLocalResource())
+ {
+ if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), buffer))
{
- DALI_LOG_ERROR("RasterizingTask::Load:Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
+ DALI_LOG_ERROR("Failed to download file! [%s]\n", mUrl.GetUrl().c_str());
return;
}
-
- mLoadSuccess = true;
}
else
{
- mLoadSuccess = true;
+ if(!Dali::FileLoader::ReadFile(mUrl.GetUrl(), buffer))
+ {
+ DALI_LOG_ERROR("Failed to read file! [%s]\n", mUrl.GetUrl().c_str());
+ return;
+ }
}
-}
-void RasterizingTask::Rasterize()
-{
- Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight);
- if(!pixelBuffer)
+ buffer.PushBack('\0');
+
+ if(!mVectorRenderer.Load(buffer, mDpi))
{
- DALI_LOG_ERROR("Rasterize is failed! [%s]\n", mUrl.GetUrl().c_str());
+ DALI_LOG_ERROR("Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
return;
}
- mPixelData = Devel::PixelBuffer::Convert(pixelBuffer);
+ mHasSucceeded = true;
}
-VectorImageRenderer RasterizingTask::GetVectorRenderer() const
+SvgRasterizingTask::SvgRasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, unsigned int width, unsigned int height)
+: SvgTask(svgVisual, vectorRenderer),
+ mWidth(width),
+ mHeight(height)
{
- return mVectorRenderer;
}
-bool RasterizingTask::IsLoaded() const
+SvgRasterizingTask::~SvgRasterizingTask()
{
- return mLoadSuccess;
}
-SvgVisual* RasterizingTask::GetSvgVisual() const
+void SvgRasterizingTask::Process()
{
- return mSvgVisual.Get();
+ if(!mVectorRenderer.IsLoaded())
+ {
+ DALI_LOG_ERROR("File is not loaded!\n");
+ return;
+ }
+
+ Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight);
+ if(!pixelBuffer)
+ {
+ DALI_LOG_ERROR("Rasterize is failed!\n");
+ return;
+ }
+
+ mPixelData = Devel::PixelBuffer::Convert(pixelBuffer);
+ mHasSucceeded = true;
}
-PixelData RasterizingTask::GetPixelData() const
+PixelData SvgRasterizingTask::GetPixelData() const
{
return mPixelData;
}
if(thread)
{
// add an empty task would stop the thread from conditional wait.
- thread->AddTask(RasterizingTaskPtr());
+ thread->AddTask(SvgTaskPtr());
// stop the thread
thread->Join();
// delete the thread
}
}
-void SvgRasterizeThread::AddTask(RasterizingTaskPtr task)
+void SvgRasterizeThread::AddTask(SvgTaskPtr task)
{
bool wasEmpty = false;
{
// 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<SvgTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
{
if((*it) && (*it)->GetSvgVisual() == task->GetSvgVisual())
{
- mRasterizeTasks.erase(it);
- break;
+ SvgRasterizingTask* oldTask = dynamic_cast<SvgRasterizingTask*>(it->Get());
+ SvgRasterizingTask* newTask = dynamic_cast<SvgRasterizingTask*>(task.Get());
+ if(oldTask && newTask)
+ {
+ mRasterizeTasks.erase(it);
+ break;
+ }
}
}
}
}
}
-RasterizingTaskPtr SvgRasterizeThread::NextCompletedTask()
+SvgTaskPtr SvgRasterizeThread::NextCompletedTask()
{
// Lock while popping task out from the queue
Mutex::ScopedLock lock(mMutex);
if(mCompletedTasks.empty())
{
- return RasterizingTaskPtr();
+ return SvgTaskPtr();
}
- std::vector<RasterizingTaskPtr>::iterator next = mCompletedTasks.begin();
- RasterizingTaskPtr nextTask = *next;
+ std::vector<SvgTaskPtr>::iterator next = mCompletedTasks.begin();
+ SvgTaskPtr nextTask = *next;
mCompletedTasks.erase(next);
return nextTask;
ConditionalWait::ScopedLock lock(mConditionalWait);
if(!mRasterizeTasks.empty())
{
- for(std::vector<RasterizingTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
+ for(std::vector<SvgTaskPtr>::iterator it = mRasterizeTasks.begin(), endIt = mRasterizeTasks.end(); it != endIt; ++it)
{
if((*it) && (*it)->GetSvgVisual() == visual)
{
mRasterizeTasks.erase(it);
- break;
}
}
}
UnregisterProcessor();
}
-RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess()
+SvgTaskPtr SvgRasterizeThread::NextTaskToProcess()
{
// Lock while popping task out from the queue
ConditionalWait::ScopedLock lock(mConditionalWait);
mIsThreadWaiting = false;
// pop out the next task from the queue
- std::vector<RasterizingTaskPtr>::iterator next = mRasterizeTasks.begin();
- RasterizingTaskPtr nextTask = *next;
+ std::vector<SvgTaskPtr>::iterator next = mRasterizeTasks.begin();
+ SvgTaskPtr nextTask = *next;
mRasterizeTasks.erase(next);
return nextTask;
}
-void SvgRasterizeThread::AddCompletedTask(RasterizingTaskPtr task)
+void SvgRasterizeThread::AddCompletedTask(SvgTaskPtr task)
{
// Lock while adding task to the queue
Mutex::ScopedLock lock(mMutex);
SetThreadName("SVGThread");
mLogFactory.InstallLogFunction();
- while(RasterizingTaskPtr task = NextTaskToProcess())
+ while(SvgTaskPtr task = NextTaskToProcess())
{
- task->Load();
- task->Rasterize();
+ task->Process();
AddCompletedTask(task);
}
}
void SvgRasterizeThread::ApplyRasterizedSVGToSampler()
{
- while(RasterizingTaskPtr task = NextCompletedTask())
+ while(SvgTaskPtr task = NextCompletedTask())
{
- task->GetSvgVisual()->ApplyRasterizedImage(task->GetVectorRenderer(), task->GetPixelData(), task->IsLoaded());
+ task->GetSvgVisual()->ApplyRasterizedImage(task->GetPixelData(), task->HasSucceeded());
}
UnregisterProcessor();