From: JunsuChoi Date: Thu, 9 Sep 2021 06:04:22 +0000 (+0900) Subject: VectorImageRenderer: Remove TizenVectorImageRenderer dependency X-Git-Tag: dali_2.0.49~6^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=0e6af8d122d2298de184d77c801a18f310d69ac3;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git VectorImageRenderer: Remove TizenVectorImageRenderer dependency 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 --- diff --git a/dali/internal/vector-image/common/vector-image-renderer-impl.cpp b/dali/internal/vector-image/common/vector-image-renderer-impl.cpp index 858201e..f8ecca5 100644 --- a/dali/internal/vector-image/common/vector-image-renderer-impl.cpp +++ b/dali/internal/vector-image/common/vector-image-renderer-impl.cpp @@ -22,9 +22,11 @@ #include #include +#ifndef THORVG_SUPPORT // INTERNAL INCLUDES #include #include +#endif namespace Dali { @@ -57,14 +59,34 @@ VectorImageRendererPtr VectorImageRenderer::New() } 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); @@ -74,66 +96,154 @@ VectorImageRenderer::~VectorImageRenderer() { 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& 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(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(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(w); + mDefaultHeight = static_cast(h); + + return true; +#else + mParsedImage = nsvgParse(reinterpret_cast(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(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(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 diff --git a/dali/internal/vector-image/common/vector-image-renderer-impl.h b/dali/internal/vector-image/common/vector-image-renderer-impl.h index 2bfc1e0..f2cce44 100644 --- a/dali/internal/vector-image/common/vector-image-renderer-impl.h +++ b/dali/internal/vector-image/common/vector-image-renderer-impl.h @@ -21,14 +21,18 @@ // EXTERNAL INCLUDES #include #include +#ifdef THORVG_SUPPORT +#include +#endif // INTERNAL INCLUDES #include #include -#include +#ifndef THORVG_SUPPORT struct NSVGrasterizer; struct NSVGimage; +#endif namespace Dali { @@ -89,9 +93,15 @@ private: 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 diff --git a/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.cpp b/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.cpp deleted file mode 100644 index 324dfb7..0000000 --- a/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.cpp +++ /dev/null @@ -1,130 +0,0 @@ -/* - * 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 - -// EXTERNAL INCLUDES -#include -#include - -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(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& 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 diff --git a/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.h b/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.h deleted file mode 100644 index 13527a3..0000000 --- a/dali/internal/vector-image/common/vector-image-renderer-plugin-proxy.h +++ /dev/null @@ -1,96 +0,0 @@ -#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 -#include - -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& 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 diff --git a/dali/internal/vector-image/file.list b/dali/internal/vector-image/file.list index f2c5f92..3a64bf8 100644 --- a/dali/internal/vector-image/file.list +++ b/dali/internal/vector-image/file.list @@ -2,6 +2,5 @@ # 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 )