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=c6e0a2c23f7d092cf2b7b78dfd6f5bc06deb4189;hp=aed445d42a8dc112a57eab5bb7b112df82266138;hb=e8a53a0a591085c6b7470feac4f9cea85cc8ae6e;hpb=d52cfe949a764d4ab0584b99d1322f06c8acd92f

diff --git a/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp b/dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp
index aed445d..c6e0a2c 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) 2021 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.
@@ -33,90 +33,109 @@ namespace Toolkit
 {
 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),
-  mUrl(url),
-  mDpi(dpi),
-  mWidth(width),
-  mHeight(height),
-  mLoadSuccess(false)
+  mHasSucceeded(false)
 {
 }
 
-RasterizingTask::~RasterizingTask()
+SvgVisual* SvgTask::GetSvgVisual() const
 {
+  return mSvgVisual.Get();
 }
 
-void RasterizingTask::Load()
+PixelData SvgTask::GetPixelData() const
 {
-  if(!mUrl.IsLocalResource())
-  {
-    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;
-    }
+  return PixelData();
+}
 
-    remoteBuffer.PushBack('\0');
+bool SvgTask::HasSucceeded() const
+{
+  return mHasSucceeded;
+}
 
-    if(!mVectorRenderer.Load(remoteBuffer, mDpi))
-    {
-      DALI_LOG_ERROR("RasterizingTask::Load:Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
-      return;
-    }
+SvgLoadingTask::SvgLoadingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi)
+: SvgTask(svgVisual, vectorRenderer),
+  mUrl(url),
+  mDpi(dpi)
+{
+}
 
-    mLoadSuccess = true;
-  }
-  else
-  {
-    mLoadSuccess = true;
-  }
+SvgLoadingTask::~SvgLoadingTask()
+{
 }
 
-void RasterizingTask::Rasterize()
+void SvgLoadingTask::Process()
 {
-  if(mWidth <= 0u || mHeight <= 0u)
+  if(mVectorRenderer.IsLoaded())
   {
-    DALI_LOG_ERROR("RasterizingTask::Rasterize: Size is zero!\n");
+    // Already loaded
+    mHasSucceeded = true;
     return;
   }
 
-  Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(mWidth, mHeight, Dali::Pixel::RGBA8888);
+  Dali::Vector<uint8_t> buffer;
 
-  uint32_t defaultWidth, defaultHeight;
-  mVectorRenderer.GetDefaultSize(defaultWidth, defaultHeight);
+  if(!mUrl.IsLocalResource())
+  {
+    if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), buffer))
+    {
+      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;
+    }
+  }
 
-  float scaleX = static_cast<float>(mWidth) / static_cast<float>(defaultWidth);
-  float scaleY = static_cast<float>(mHeight) / static_cast<float>(defaultHeight);
-  float scale  = scaleX < scaleY ? scaleX : scaleY;
+  buffer.PushBack('\0');
 
-  if(!mVectorRenderer.Rasterize(pixelBuffer, scale))
+  if(!mVectorRenderer.Load(buffer, mDpi))
   {
-    DALI_LOG_ERROR("RasterizingTask::Rasterize: 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;
 }
@@ -142,7 +161,7 @@ void SvgRasterizeThread::TerminateThread(SvgRasterizeThread*& thread)
   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
@@ -151,7 +170,7 @@ void SvgRasterizeThread::TerminateThread(SvgRasterizeThread*& thread)
   }
 }
 
-void SvgRasterizeThread::AddTask(RasterizingTaskPtr task)
+void SvgRasterizeThread::AddTask(SvgTaskPtr task)
 {
   bool wasEmpty = false;
 
@@ -163,12 +182,18 @@ void SvgRasterizeThread::AddTask(RasterizingTaskPtr task)
     {
       // 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;
+          }
         }
       }
     }
@@ -188,18 +213,18 @@ void SvgRasterizeThread::AddTask(RasterizingTaskPtr task)
   }
 }
 
-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;
@@ -211,12 +236,11 @@ void SvgRasterizeThread::RemoveTask(SvgVisual* visual)
   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;
       }
     }
   }
@@ -224,7 +248,7 @@ void SvgRasterizeThread::RemoveTask(SvgVisual* visual)
   UnregisterProcessor();
 }
 
-RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess()
+SvgTaskPtr SvgRasterizeThread::NextTaskToProcess()
 {
   // Lock while popping task out from the queue
   ConditionalWait::ScopedLock lock(mConditionalWait);
@@ -238,14 +262,14 @@ RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess()
   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);
@@ -260,19 +284,18 @@ void SvgRasterizeThread::Run()
   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();