dali/internal/vector-image/common/vector-image-renderer-impl.cpp

   1 /*
   2  * Copyright (c) 2022 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 <dali/internal/vector-image/common/vector-image-renderer-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/object/type-registry.h>
  24
  25 #ifndef THORVG_SUPPORT
  26 // INTERNAL INCLUDES
  27 #include <third-party/nanosvg/nanosvg.h>
  28 #include <third-party/nanosvg/nanosvgrast.h>
  29 #endif
  30
  31 namespace Dali
  32 {
  33 namespace Internal
  34 {
  35 namespace Adaptor
  36 {
  37 namespace // unnamed namespace
  38 {
  39 const char* const UNITS("px");
  40
  41 // Type Registration
  42 Dali::BaseHandle Create()
  43 {
  44   return Dali::BaseHandle();
  45 }
  46
  47 Dali::TypeRegistration type(typeid(Dali::VectorImageRenderer), typeid(Dali::BaseHandle), Create);
  48
  49 #if defined(DEBUG_ENABLED)
  50 Debug::Filter* gVectorImageLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_IMAGE");
  51 #endif
  52
  53 } // unnamed namespace
  54
  55 VectorImageRendererPtr VectorImageRenderer::New()
  56 {
  57   VectorImageRendererPtr renderer = new VectorImageRenderer();
  58   if(renderer)
  59   {
  60     renderer->Initialize();
  61   }
  62   return renderer;
  63 }
  64
  65 VectorImageRenderer::VectorImageRenderer()
  66 #ifdef THORVG_SUPPORT
  67 : mPicture(nullptr)
  68 #else
  69 : mParsedImage(nullptr),
  70   mRasterizer(nullptr)
  71 #endif
  72 {
  73 }
  74
  75 VectorImageRenderer::~VectorImageRenderer()
  76 {
  77 #ifdef THORVG_SUPPORT
  78
  79   //NOTE: Initializer::term() will call clear() internally.
  80   //However, due to the delete on mPicture, a crash occurs for the paint
  81   //that has already been deleted in clear() of term().
  82   //Therefore, it temporarily performs a non-free clear().
  83   mSwCanvas->clear(false);
  84
  85   if(mPicture)
  86   {
  87     delete(mPicture);
  88   }
  89
  90   tvg::Initializer::term(tvg::CanvasEngine::Sw);
  91 #else
  92   if(mParsedImage)
  93   {
  94     nsvgDelete(mParsedImage);
  95   }
  96
  97   if(mRasterizer)
  98   {
  99     nsvgDeleteRasterizer(mRasterizer);
 100   }
 101 #endif
 102 }
 103
 104 void VectorImageRenderer::Initialize()
 105 {
 106 #ifdef THORVG_SUPPORT
 107   tvg::Initializer::init(tvg::CanvasEngine::Sw, 0);
 108
 109   mSwCanvas = tvg::SwCanvas::gen();
 110   mSwCanvas->mempool(tvg::SwCanvas::MempoolPolicy::Individual);
 111   mSwCanvas->reserve(1); //has one picture
 112 #else
 113   mRasterizer = nsvgCreateRasterizer();
 114 #endif
 115 }
 116
 117 bool VectorImageRenderer::Load(const Vector<uint8_t>& data, float dpi)
 118 {
 119 #ifdef THORVG_SUPPORT
 120   if(!mSwCanvas)
 121   {
 122     DALI_LOG_ERROR("VectorImageRenderer::Load Canvas Object is null [%p]\n", this);
 123     return false;
 124   }
 125
 126   if(!mPicture)
 127   {
 128     mPicture = tvg::Picture::gen().release();
 129     if(!mPicture)
 130     {
 131       DALI_LOG_ERROR("VectorImageRenderer::Load: Picture gen Fail [%p]\n", this);
 132       return false;
 133     }
 134   }
 135   else
 136   {
 137     return true;
 138   }
 139
 140   tvg::Result ret = mPicture->load(reinterpret_cast<char*>(data.Begin()), data.Size(), true);
 141
 142   if(ret != tvg::Result::Success)
 143   {
 144     switch(ret)
 145     {
 146       case tvg::Result::InvalidArguments:
 147       {
 148         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid arguments) Size:%d [%p]\n", data.Size(), this);
 149         break;
 150       }
 151       case tvg::Result::NonSupport:
 152       {
 153         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid SVG) Size:%d [%p]\n", data.Size(), this);
 154         break;
 155       }
 156       case tvg::Result::Unknown:
 157       {
 158         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Parse fail) Size:%d [%p]\n", data.Size(), this);
 159         break;
 160       }
 161       default:
 162       {
 163         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail / Size:%d [%p]\n", data.Size(), this);
 164         break;
 165       }
 166     }
 167     return false;
 168   }
 169
 170   float w, h;
 171   mPicture->size(&w, &h);
 172   mDefaultWidth  = static_cast<uint32_t>(w);
 173   mDefaultHeight = static_cast<uint32_t>(h);
 174
 175   return true;
 176 #else
 177   if(mParsedImage)
 178   {
 179     return true;
 180   }
 181
 182   mParsedImage = nsvgParse(reinterpret_cast<char*>(data.Begin()), UNITS, dpi);
 183   if(!mParsedImage || !mParsedImage->shapes)
 184   {
 185     DALI_LOG_ERROR("VectorImageRenderer::Load: nsvgParse failed\n");
 186     return false;
 187   }
 188
 189   mDefaultWidth  = mParsedImage->width;
 190   mDefaultHeight = mParsedImage->height;
 191
 192   return true;
 193 #endif
 194 }
 195
 196 bool VectorImageRenderer::IsLoaded() const
 197 {
 198 #ifdef THORVG_SUPPORT
 199   return mPicture ? true : false;
 200 #else
 201   return mParsedImage ? true : false;
 202 #endif
 203 }
 204
 205 Dali::Devel::PixelBuffer VectorImageRenderer::Rasterize(uint32_t width, uint32_t height)
 206 {
 207   if(width == 0)
 208   {
 209     if(mDefaultWidth == 0)
 210     {
 211       DALI_LOG_ERROR("Invalid size [%d, %d]\n", width, height);
 212       return Devel::PixelBuffer();
 213     }
 214     else
 215     {
 216       width = mDefaultWidth;
 217     }
 218   }
 219
 220   if(height == 0)
 221   {
 222     if(mDefaultHeight == 0)
 223     {
 224       DALI_LOG_ERROR("Invalid size [%d, %d]\n", width, height);
 225       return Devel::PixelBuffer();
 226     }
 227     else
 228     {
 229       height = mDefaultHeight;
 230     }
 231   }
 232
 233 #ifdef THORVG_SUPPORT
 234   if(!mSwCanvas || !mPicture)
 235   {
 236     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: either Canvas[%p] or Picture[%p] is invalid [%p]\n", mSwCanvas.get(), mPicture, this);
 237     return Devel::PixelBuffer();
 238   }
 239
 240   Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
 241
 242   mSwCanvas->clear(false);
 243
 244   auto pBuffer = pixelBuffer.GetBuffer();
 245   if(!pBuffer)
 246   {
 247     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: pixel buffer is null [%p]\n", this);
 248     return Devel::PixelBuffer();
 249   }
 250
 251   mSwCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), width, width, height, tvg::SwCanvas::ABGR8888);
 252
 253   DALI_LOG_INFO(gVectorImageLogFilter, Debug::Verbose, "Buffer[%p] size[%d x %d]! [%p]\n", pBuffer, width, height, this);
 254
 255   mPicture->size(width, height);
 256
 257   /* We can push everytime since we cleared the canvas just before. */
 258   if(mSwCanvas->push(std::unique_ptr<tvg::Picture>(mPicture)) != tvg::Result::Success)
 259   {
 260     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Picture push fail [%p]\n", this);
 261     return Devel::PixelBuffer();
 262   }
 263
 264   auto ret = mSwCanvas->draw();
 265   if(ret != tvg::Result::Success)
 266   {
 267     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Draw fail %d [%p]\n", static_cast<int>(ret), this);
 268     return Devel::PixelBuffer();
 269   }
 270
 271   mSwCanvas->sync();
 272
 273   return pixelBuffer;
 274 #else
 275   if(mParsedImage != nullptr)
 276   {
 277     Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
 278
 279     float scaleX = static_cast<float>(width) / (mDefaultWidth > 0 ? static_cast<float>(mDefaultWidth) : 1.0f);
 280     float scaleY = static_cast<float>(height) / (mDefaultHeight > 0 ? static_cast<float>(mDefaultHeight) : 1.0f);
 281     float scale  = scaleX < scaleY ? scaleX : scaleY;
 282     int   stride = pixelBuffer.GetWidth() * Pixel::GetBytesPerPixel(Dali::Pixel::RGBA8888);
 283
 284     nsvgRasterize(mRasterizer, mParsedImage, 0.0f, 0.0f, scale, pixelBuffer.GetBuffer(), width, height, stride);
 285     return pixelBuffer;
 286   }
 287   return Devel::PixelBuffer();
 288 #endif
 289 }
 290
 291 void VectorImageRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
 292 {
 293   width  = mDefaultWidth;
 294   height = mDefaultHeight;
 295 }
 296
 297 } // namespace Adaptor
 298
 299 } // namespace Internal
 300
 301 } // namespace Dali