Whether to use the thorvg library is already known.
Therefore, you can no longer use the TizenVectorImageRenderer PlugIn
made for the ThorVG library.
Change-Id: Ic147f093e64fb4872c7d5fa1e32be584b0a9f9ce
#include <dali/integration-api/debug.h>
#include <dali/public-api/object/type-registry.h>
+#ifndef THORVG_SUPPORT
// INTERNAL INCLUDES
#include <third-party/nanosvg/nanosvg.h>
#include <third-party/nanosvg/nanosvgrast.h>
+#endif
namespace Dali
{
}
VectorImageRenderer::VectorImageRenderer()
-: mPlugin(std::string()),
- mParsedImage(nullptr),
+#ifdef THORVG_SUPPORT
+: mPicture(nullptr),
+ mDefaultWidth(0),
+ mDefaultHeight(0)
+#else
+: mParsedImage(nullptr),
mRasterizer(nullptr)
+#endif
{
}
VectorImageRenderer::~VectorImageRenderer()
{
+#ifdef THORVG_SUPPORT
+
+ //NOTE: Initializer::term() will call clear() internally.
+ //However, due to the delete on mPicture, a crash occurs for the paint
+ //that has already been deleted in clear() of term().
+ //Therefore, it temporarily performs a non-free clear().
+ mSwCanvas->clear(false);
+
+ if(mPicture)
+ {
+ delete(mPicture);
+ }
+
+ tvg::Initializer::term(tvg::CanvasEngine::Sw);
+#else
if(mParsedImage)
{
nsvgDelete(mParsedImage);
{
nsvgDeleteRasterizer(mRasterizer);
}
+#endif
}
void VectorImageRenderer::Initialize()
{
- if(!mPlugin.IsValid())
- {
- mRasterizer = nsvgCreateRasterizer();
- }
+#ifdef THORVG_SUPPORT
+ tvg::Initializer::init(tvg::CanvasEngine::Sw, 0);
+
+ mSwCanvas = tvg::SwCanvas::gen();
+ mSwCanvas->mempool(tvg::SwCanvas::MempoolPolicy::Individual);
+ mSwCanvas->reserve(1); //has one picture
+#else
+ mRasterizer = nsvgCreateRasterizer();
+#endif
}
bool VectorImageRenderer::Load(const Vector<uint8_t>& data, float dpi)
{
- if(mPlugin.IsValid())
+#ifdef THORVG_SUPPORT
+ if(!mSwCanvas)
{
- return mPlugin.Load(data);
+ DALI_LOG_ERROR("VectorImageRenderer::Load Canvas Object is null [%p]\n", this);
+ return false;
}
- else
+
+ if(!mPicture)
{
- mParsedImage = nsvgParse(reinterpret_cast<char*>(data.Begin()), UNITS, dpi);
- if(!mParsedImage || !mParsedImage->shapes)
+ mPicture = tvg::Picture::gen().release();
+ if(!mPicture)
{
- DALI_LOG_ERROR("VectorImageRenderer::Load: nsvgParse failed\n");
+ DALI_LOG_ERROR("VectorImageRenderer::Load: Picture gen Fail [%p]\n", this);
return false;
}
- return true;
}
+
+ tvg::Result ret = mPicture->load(reinterpret_cast<char*>(data.Begin()), data.Size(), false);
+
+ if(ret != tvg::Result::Success)
+ {
+ switch (ret)
+ {
+ case tvg::Result::InvalidArguments:
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid arguments) Size:%d [%p]\n", data.Size(), this);
+ break;
+ }
+ case tvg::Result::NonSupport:
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Invalid SVG) Size:%d [%p]\n", data.Size(), this);
+ break;
+ }
+ case tvg::Result::Unknown:
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Load Load fail(Parse fail) Size:%d [%p]\n", data.Size(), this);
+ break;
+ }
+ default:
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Load Load fail / Size:%d [%p]\n", data.Size(), this);
+ break;
+ }
+ }
+ return false;
+ }
+
+ float w, h;
+ mPicture->size(&w, &h);
+ mDefaultWidth = static_cast<uint32_t>(w);
+ mDefaultHeight = static_cast<uint32_t>(h);
+
+ return true;
+#else
+ mParsedImage = nsvgParse(reinterpret_cast<char*>(data.Begin()), UNITS, dpi);
+ if(!mParsedImage || !mParsedImage->shapes)
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Load: nsvgParse failed\n");
+ return false;
+ }
+ return true;
+#endif
}
bool VectorImageRenderer::Rasterize(Dali::Devel::PixelBuffer& buffer, float scale)
{
- if(mPlugin.IsValid())
+#ifdef THORVG_SUPPORT
+ if(!mSwCanvas || !mPicture)
{
- return mPlugin.Rasterize(buffer);
+ DALI_LOG_ERROR("VectorImageRenderer::Rasterize: either Canvas[%p] or Picture[%p] is invalid [%p]\n", mSwCanvas.get(), mPicture, this);
+ return false;
}
- else
+
+ mSwCanvas->clear(false);
+
+ auto pBuffer = buffer.GetBuffer();
+ if(!pBuffer)
{
- if(mParsedImage != nullptr)
- {
- int stride = buffer.GetWidth() * Pixel::GetBytesPerPixel(buffer.GetPixelFormat());
- nsvgRasterize(mRasterizer, mParsedImage, 0.0f, 0.0f, scale, buffer.GetBuffer(), buffer.GetWidth(), buffer.GetHeight(), stride);
- return true;
- }
+ DALI_LOG_ERROR("VectorImageRenderer::Rasterize: pixel buffer is null [%p]\n", this);
+ return false;
+ }
+
+ auto width = buffer.GetWidth();
+ auto height = buffer.GetHeight();
+
+ mSwCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), width, width, height, tvg::SwCanvas::ABGR8888);
+
+ DALI_LOG_RELEASE_INFO("VectorImageRenderer::Rasterize: Buffer[%p] size[%d x %d]! [%p]\n", pBuffer, width, height, this);
+
+ mPicture->size(width, height);
+
+ /* We can push everytime since we cleared the canvas just before. */
+ if(mSwCanvas->push(std::unique_ptr<tvg::Picture>(mPicture)) != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Picture push fail [%p]\n", this);
+ return false;
+ }
+
+ if(mSwCanvas->draw() != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("VectorImageRenderer::Rasterize: Draw fail [%p]\n", this);
return false;
}
+
+ mSwCanvas->sync();
+
+ return true;
+#else
+ if(mParsedImage != nullptr)
+ {
+ int stride = buffer.GetWidth() * Pixel::GetBytesPerPixel(buffer.GetPixelFormat());
+ nsvgRasterize(mRasterizer, mParsedImage, 0.0f, 0.0f, scale, buffer.GetBuffer(), buffer.GetWidth(), buffer.GetHeight(), stride);
+ return true;
+ }
+ return false;
+#endif
}
void VectorImageRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
{
- if(mPlugin.IsValid())
- {
- mPlugin.GetDefaultSize(width, height);
- }
- else
+#ifdef THORVG_SUPPORT
+ width = mDefaultWidth;
+ height = mDefaultHeight;
+#else
+ if(mParsedImage)
{
- if(mParsedImage)
- {
- width = mParsedImage->width;
- height = mParsedImage->height;
- }
+ width = mParsedImage->width;
+ height = mParsedImage->height;
}
+#endif
}
} // namespace Adaptor
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-object.h>
#include <dali/public-api/signals/connection-tracker.h>
+#ifdef THORVG_SUPPORT
+#include <thorvg.h>
+#endif
// INTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
#include <dali/devel-api/adaptor-framework/vector-image-renderer.h>
-#include <dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.h>
+#ifndef THORVG_SUPPORT
struct NSVGrasterizer;
struct NSVGimage;
+#endif
namespace Dali
{
void Initialize();
private:
- VectorImageRendererPluginProxy mPlugin;
+#ifdef THORVG_SUPPORT
+ std::unique_ptr< tvg::SwCanvas > mSwCanvas;
+ tvg::Picture* mPicture; ///< The pointer to the picture
+ uint32_t mDefaultWidth; ///< The width of the surface
+ uint32_t mDefaultHeight; ///< The height of the surface
+#else
NSVGimage* mParsedImage;
NSVGrasterizer* mRasterizer;
+#endif
};
} // namespace Adaptor
+++ /dev/null
-/*
- * Copyright (c) 2021 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include <dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.h>
-
-// EXTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
-#include <dlfcn.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace Adaptor
-{
-namespace
-{
-// The default plugin name
-const char* DEFAULT_OBJECT_NAME("libdali2-vector-image-renderer-plugin.so");
-
-} // namespace
-
-VectorImageRendererPluginProxy::VectorImageRendererPluginProxy(std::string sharedObjectName)
-: mSharedObjectName(std::move(sharedObjectName)),
- mLibHandle(nullptr),
- mPlugin(nullptr),
- mCreateVectorImageRendererPtr(nullptr)
-{
- if(mSharedObjectName.empty())
- {
- mSharedObjectName = DEFAULT_OBJECT_NAME;
- }
-
- InitializePlugin();
-}
-
-VectorImageRendererPluginProxy::~VectorImageRendererPluginProxy()
-{
- if(mPlugin)
- {
- delete mPlugin;
- mPlugin = nullptr;
-
- if(mLibHandle && dlclose(mLibHandle))
- {
- DALI_LOG_ERROR("Error closing vector image renderer plugin library: %s\n", dlerror());
- }
- }
-}
-
-void VectorImageRendererPluginProxy::InitializePlugin()
-{
- mLibHandle = dlopen(mSharedObjectName.c_str(), RTLD_LAZY);
-
- char* error = dlerror();
- if(mLibHandle == nullptr || error != nullptr)
- {
- DALI_LOG_WARNING("VectorImageRendererPluginProxy::Initialize: dlopen error [%s]\n", error);
- return;
- }
-
- // load plugin
- mCreateVectorImageRendererPtr = reinterpret_cast<CreateVectorImageRendererFunction>(dlsym(mLibHandle, "CreateVectorImageRendererPlugin"));
-
- error = dlerror();
- if(mCreateVectorImageRendererPtr == nullptr || error != nullptr)
- {
- DALI_LOG_ERROR("VectorImageRendererPluginProxy::Initialize: Cannot load symbol: %s\n", error);
- return;
- }
-
- mPlugin = mCreateVectorImageRendererPtr();
- if(!mPlugin)
- {
- DALI_LOG_ERROR("VectorImageRendererPluginProxy::Initialize: Plugin creation failed\n");
- return;
- }
-}
-
-bool VectorImageRendererPluginProxy::IsValid() const
-{
- return (mPlugin != nullptr);
-}
-
-bool VectorImageRendererPluginProxy::Load(const Vector<uint8_t>& data)
-{
- if(mPlugin)
- {
- return mPlugin->Load(data);
- }
- return false;
-}
-
-bool VectorImageRendererPluginProxy::Rasterize(Dali::Devel::PixelBuffer& buffer)
-{
- if(mPlugin)
- {
- return mPlugin->Rasterize(buffer);
- }
- return false;
-}
-
-void VectorImageRendererPluginProxy::GetDefaultSize(uint32_t& width, uint32_t& height) const
-{
- if(mPlugin)
- {
- mPlugin->GetDefaultSize(width, height);
- }
-}
-
-} // namespace Adaptor
-
-} // namespace Internal
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_VECTOR_IMAGE_RENDERER_PLUGIN_PROXY_H
-#define DALI_INTERNAL_VECTOR_IMAGE_RENDERER_PLUGIN_PROXY_H
-
-/*
- * Copyright (c) 2021 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// INTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
-#include <dali/devel-api/adaptor-framework/vector-image-renderer-plugin.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace Adaptor
-{
-/**
- * Proxy class to dynamically load, use and unload vector image renderer plugin.
- */
-class VectorImageRendererPluginProxy
-{
-public:
- /**
- * @brief Constructor
- */
- VectorImageRendererPluginProxy(std::string sharedObjectName);
-
- /**
- * @brief Destructor
- */
- ~VectorImageRendererPluginProxy();
-
- /**
- * @brief Query whether the plugin is valid or not.
- * @return True if valid, false otherwise
- */
- bool IsValid() const;
-
- /**
- * @copydoc Dali::VectorImageRendererPlugin::Load()
- */
- bool Load(const Vector<uint8_t>& data);
-
- /**
- * @copydoc Dali::VectorImageRendererPlugin::Rasterize()
- */
- bool Rasterize(Dali::Devel::PixelBuffer& buffer);
-
- /**
- * @copydoc Dali::VectorImageRendererPlugin::GetDefaultSize()
- */
- void GetDefaultSize(uint32_t& width, uint32_t& height) const;
-
- // Not copyable or movable
- VectorImageRendererPluginProxy(const VectorImageRendererPluginProxy&) = delete; ///< Deleted copy constructor
- VectorImageRendererPluginProxy(VectorImageRendererPluginProxy&&) = delete; ///< Deleted move constructor
- VectorImageRendererPluginProxy& operator=(const VectorImageRendererPluginProxy&) = delete; ///< Deleted copy assignment operator
- VectorImageRendererPluginProxy& operator=(VectorImageRendererPluginProxy&&) = delete; ///< Deleted move assignment operator
-
-private:
- /**
- * Dynamically loads the plugin.
- */
- void InitializePlugin();
-
-private:
- using CreateVectorImageRendererFunction = Dali::VectorImageRendererPlugin* (*)();
-
- std::string mSharedObjectName; ///< Shared object name
- void* mLibHandle; ///< Handle for the loaded library
- Dali::VectorImageRendererPlugin* mPlugin; ///< Plugin handle
-
- CreateVectorImageRendererFunction mCreateVectorImageRendererPtr; ///< Function pointer called in adaptor to create a plugin instance
-};
-
-} // namespace Adaptor
-
-} // namespace Internal
-
-} // namespace Dali
-
-#endif // DALI_INTERNAL_VECTOR_IMAGE_RENDERER_PLUGIN_PROXY_H
# module: vector-image, backend: common
SET( adaptor_vector_image_common_src_files
${adaptor_vector_image_dir}/common/vector-image-renderer-impl.cpp
- ${adaptor_vector_image_dir}/common/vector-image-renderer-plugin-proxy.cpp
)
projects / platform / core / uifw / dali-adaptor.git / commitdiff