dali-toolkit/internal/visuals/svg/svg-task.cpp

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "svg-task.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/file-loader.h>
  23 #include <dali/integration-api/adaptor-framework/adaptor.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/integration-api/trace.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  29
  30 #ifdef TRACE_ENABLED
  31 #include <sstream>
  32 #endif
  33
  34 namespace Dali
  35 {
  36 namespace Toolkit
  37 {
  38 namespace Internal
  39 {
  40 namespace
  41 {
  42 DALI_INIT_TRACE_FILTER(gTraceFilter, DALI_TRACE_IMAGE_PERFORMANCE_MARKER, false);
  43 }
  44
  45 SvgTask::SvgTask(VectorImageRenderer vectorRenderer, CallbackBase* callback, AsyncTask::PriorityType priorityType)
  46 : AsyncTask(callback, priorityType),
  47   mVectorRenderer(vectorRenderer),
  48   mHasSucceeded(false)
  49 {
  50 }
  51
  52 PixelData SvgTask::GetPixelData() const
  53 {
  54   return PixelData();
  55 }
  56
  57 bool SvgTask::HasSucceeded() const
  58 {
  59   return mHasSucceeded;
  60 }
  61
  62 VectorImageRenderer SvgTask::GetRenderer()
  63 {
  64   return mVectorRenderer;
  65 }
  66
  67 SvgLoadingTask::SvgLoadingTask(VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, CallbackBase* callback)
  68 : SvgTask(vectorRenderer, callback, url.GetProtocolType() == VisualUrl::ProtocolType::REMOTE ? AsyncTask::PriorityType::LOW : AsyncTask::PriorityType::HIGH),
  69   mUrl(url),
  70   mDpi(dpi)
  71 {
  72 }
  73
  74 SvgLoadingTask::~SvgLoadingTask()
  75 {
  76 }
  77
  78 void SvgLoadingTask::Process()
  79 {
  80   if(mVectorRenderer.IsLoaded())
  81   {
  82     // Already loaded
  83     mHasSucceeded = true;
  84     return;
  85   }
  86
  87   DALI_TRACE_SCOPE(gTraceFilter, "DALI_SVG_LOADING_TASK");
  88
  89   Dali::Vector<uint8_t> buffer;
  90
  91   if(!mUrl.IsLocalResource())
  92   {
  93     if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), buffer))
  94     {
  95       DALI_LOG_ERROR("Failed to download file! [%s]\n", mUrl.GetUrl().c_str());
  96       return;
  97     }
  98   }
  99   else
 100   {
 101     if(!Dali::FileLoader::ReadFile(mUrl.GetUrl(), buffer))
 102     {
 103       DALI_LOG_ERROR("Failed to read file! [%s]\n", mUrl.GetUrl().c_str());
 104       return;
 105     }
 106   }
 107
 108   buffer.PushBack('\0');
 109
 110   if(!mVectorRenderer.Load(buffer, mDpi))
 111   {
 112     DALI_LOG_ERROR("Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
 113     return;
 114   }
 115
 116   mHasSucceeded = true;
 117 }
 118
 119 bool SvgLoadingTask::IsReady()
 120 {
 121   return true;
 122 }
 123
 124 SvgRasterizingTask::SvgRasterizingTask(VectorImageRenderer vectorRenderer, uint32_t width, uint32_t height, CallbackBase* callback)
 125 : SvgTask(vectorRenderer, callback),
 126   mWidth(width),
 127   mHeight(height)
 128 {
 129 }
 130
 131 SvgRasterizingTask::~SvgRasterizingTask()
 132 {
 133 }
 134
 135 void SvgRasterizingTask::Process()
 136 {
 137   if(!mVectorRenderer.IsLoaded())
 138   {
 139     DALI_LOG_ERROR("File is not loaded!\n");
 140     return;
 141   }
 142
 143 #ifdef TRACE_ENABLED
 144   if(gTraceFilter && gTraceFilter->IsTraceEnabled())
 145   {
 146     std::ostringstream oss;
 147     oss << "[size: " << mWidth << " x " << mHeight << "]";
 148     DALI_TRACE_BEGIN_WITH_MESSAGE(gTraceFilter, "DALI_SVG_RASTERIZE_TASK", oss.str().c_str());
 149   }
 150 #endif
 151
 152   Devel::PixelBuffer pixelBuffer = mVectorRenderer.Rasterize(mWidth, mHeight);
 153   if(!pixelBuffer)
 154   {
 155     DALI_LOG_ERROR("Rasterize is failed!\n");
 156     DALI_TRACE_END(gTraceFilter, "DALI_SVG_RASTERIZE_TASK");
 157     return;
 158   }
 159
 160   mPixelData    = Devel::PixelBuffer::Convert(pixelBuffer);
 161   mHasSucceeded = true;
 162   DALI_TRACE_END(gTraceFilter, "DALI_SVG_RASTERIZE_TASK");
 163 }
 164
 165 bool SvgRasterizingTask::IsReady()
 166 {
 167   return mVectorRenderer.IsLoaded();
 168 }
 169
 170 PixelData SvgRasterizingTask::GetPixelData() const
 171 {
 172   return mPixelData;
 173 }
 174
 175 } // namespace Internal
 176
 177 } // namespace Toolkit
 178
 179 } // namespace Dali