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
 136   tvg::Result ret = mPicture->load(reinterpret_cast<char*>(data.Begin()), data.Size(), true);
 137
 138   if(ret != tvg::Result::Success)
 139   {
 140     switch(ret)
 141     {
 142       case tvg::Result::InvalidArguments:
 143       {
 144         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid arguments) Size:%d [%p]\n", data.Size(), this);
 145         break;
 146       }
 147       case tvg::Result::NonSupport:
 148       {
 149         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid SVG) Size:%d [%p]\n", data.Size(), this);
 150         break;
 151       }
 152       case tvg::Result::Unknown:
 153       {
 154         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Parse fail) Size:%d [%p]\n", data.Size(), this);
 155         break;
 156       }
 157       default:
 158       {
 159         DALI_LOG_ERROR("VectorImageRenderer::Load Load fail / Size:%d [%p]\n", data.Size(), this);
 160         break;
 161       }
 162     }
 163     return false;
 164   }
 165
 166   float w, h;
 167   mPicture->size(&w, &h);
 168   mDefaultWidth  = static_cast<uint32_t>(w);
 169   mDefaultHeight = static_cast<uint32_t>(h);
 170
 171   return true;
 172 #else
 173   mParsedImage = nsvgParse(reinterpret_cast<char*>(data.Begin()), UNITS, dpi);
 174   if(!mParsedImage || !mParsedImage->shapes)
 175   {
 176     DALI_LOG_ERROR("VectorImageRenderer::Load: nsvgParse failed\n");
 177     return false;
 178   }
 179
 180   mDefaultWidth  = mParsedImage->width;
 181   mDefaultHeight = mParsedImage->height;
 182
 183   return true;
 184 #endif
 185 }
 186
 187 Dali::Devel::PixelBuffer VectorImageRenderer::Rasterize(uint32_t width, uint32_t height)
 188 {
 189   if(width == 0)
 190   {
 191     if(mDefaultWidth == 0)
 192     {
 193       DALI_LOG_ERROR("Invalid size [%d, %d]\n", width, height);
 194       return Devel::PixelBuffer();
 195     }
 196     else
 197     {
 198       width = mDefaultWidth;
 199     }
 200   }
 201
 202   if(height == 0)
 203   {
 204     if(mDefaultHeight == 0)
 205     {
 206       DALI_LOG_ERROR("Invalid size [%d, %d]\n", width, height);
 207       return Devel::PixelBuffer();
 208     }
 209     else
 210     {
 211       height = mDefaultHeight;
 212     }
 213   }
 214
 215 #ifdef THORVG_SUPPORT
 216   if(!mSwCanvas || !mPicture)
 217   {
 218     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: either Canvas[%p] or Picture[%p] is invalid [%p]\n", mSwCanvas.get(), mPicture, this);
 219     return Devel::PixelBuffer();
 220   }
 221
 222   Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
 223
 224   mSwCanvas->clear(false);
 225
 226   auto pBuffer = pixelBuffer.GetBuffer();
 227   if(!pBuffer)
 228   {
 229     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: pixel buffer is null [%p]\n", this);
 230     return Devel::PixelBuffer();
 231   }
 232
 233   mSwCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), width, width, height, tvg::SwCanvas::ABGR8888);
 234
 235   DALI_LOG_INFO(gVectorImageLogFilter, Debug::Verbose, "Buffer[%p] size[%d x %d]! [%p]\n", pBuffer, width, height, this);
 236
 237   mPicture->size(width, height);
 238
 239   /* We can push everytime since we cleared the canvas just before. */
 240   if(mSwCanvas->push(std::unique_ptr<tvg::Picture>(mPicture)) != tvg::Result::Success)
 241   {
 242     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Picture push fail [%p]\n", this);
 243     return Devel::PixelBuffer();
 244   }
 245
 246   auto ret = mSwCanvas->draw();
 247   if(ret != tvg::Result::Success)
 248   {
 249     DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Draw fail %d [%p]\n", static_cast<int>(ret), this);
 250     return Devel::PixelBuffer();
 251   }
 252
 253   mSwCanvas->sync();
 254
 255   return pixelBuffer;
 256 #else
 257   if(mParsedImage != nullptr)
 258   {
 259     Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
 260
 261     float scaleX = static_cast<float>(width) / (mDefaultWidth > 0 ? static_cast<float>(mDefaultWidth) : 1.0f);
 262     float scaleY = static_cast<float>(height) / (mDefaultHeight > 0 ? static_cast<float>(mDefaultHeight) : 1.0f);
 263     float scale  = scaleX < scaleY ? scaleX : scaleY;
 264     int   stride = pixelBuffer.GetWidth() * Pixel::GetBytesPerPixel(Dali::Pixel::RGBA8888);
 265
 266     nsvgRasterize(mRasterizer, mParsedImage, 0.0f, 0.0f, scale, pixelBuffer.GetBuffer(), width, height, stride);
 267     return pixelBuffer;
 268   }
 269   return Devel::PixelBuffer();
 270 #endif
 271 }
 272
 273 void VectorImageRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
 274 {
 275   width  = mDefaultWidth;
 276   height = mDefaultHeight;
 277 }
 278
 279 } // namespace Adaptor
 280
 281 } // namespace Internal
 282
 283 } // namespace Dali