Refactor VectorImageRenderer

Change-Id: I5d6ed06df88d9052ab4741fabbb2a2f0e3120fe9

diff --git a/dali-extension/vector-image-renderer/tizen-vector-image-renderer.cpp b/dali-extension/vector-image-renderer/tizen-vector-image-renderer.cpp
index 0e442ac..a16381e 100755 (executable)
--- a/dali-extension/vector-image-renderer/tizen-vector-image-renderer.cpp
+++ b/dali-extension/vector-image-renderer/tizen-vector-image-renderer.cpp
@@ -33,8 +33,7 @@ namespace Dali
 namespace Plugin
 {
 
-static uint32_t engineInitCnt = 0;   //tvg engine intialize call count.
-
+uint32_t TizenVectorImageRenderer::mCount = 0;
 
 TizenVectorImageRenderer::TizenVectorImageRenderer()
 : mPicture(nullptr),
@@ -42,160 +41,114 @@ TizenVectorImageRenderer::TizenVectorImageRenderer()
   mDefaultHeight(0),
   mIsFirstRender(true)
 {
-  if (engineInitCnt == 0)
+  if(mCount++ == 0)
   {
     tvg::Initializer::init(tvg::CanvasEngine::Sw, 0);
   }
-  ++engineInitCnt;
 
   mSwCanvas = tvg::SwCanvas::gen();
 }
 
 TizenVectorImageRenderer::~TizenVectorImageRenderer()
 {
-   //Not yet pushed to Canvas
-  if (mIsFirstRender && mPicture)
+  //Not yet pushed to Canvas
+  if(mIsFirstRender && mPicture)
   {
     delete(mPicture);
   }
+
   mSwCanvas->clear();
 
-  if (engineInitCnt > 0)
+  if(--mCount == 0)
   {
-    --engineInitCnt;
-    if (engineInitCnt == 0)
-    {
-      tvg::Initializer::term(tvg::CanvasEngine::Sw);
-    }
+    tvg::Initializer::term(tvg::CanvasEngine::Sw);
   }
 }
 
-bool TizenVectorImageRenderer::Initialize()
-{
-  //DO NOTHING
-
-  return true;
-}
-
-void TizenVectorImageRenderer::SetBuffer( Dali::Devel::PixelBuffer &buffer )
+bool TizenVectorImageRenderer::Load(const Vector<uint8_t>& data)
 {
-  unsigned char *pBuffer;
-  pBuffer = buffer.GetBuffer();
-
-  if (!pBuffer)
+  if(!mSwCanvas)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::SetBuffer: pixel buffer is null [%p]\n", this);
-    return;
-  }
-
-  auto width = buffer.GetWidth();
-  auto height = buffer.GetHeight();
-
-  mSwCanvas->target((uint32_t *)pBuffer, width, width, height, tvg::SwCanvas::ABGR8888);
-
-  DALI_LOG_ERROR("TizenVectorImageRenderer::Buffer[%p] size[%d x %d]! [%p]\n", pBuffer, width, height, this);
-}
-
-bool TizenVectorImageRenderer::Render( float scale )
-{
-  if (!mSwCanvas || !mPicture)
-  {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Render: either Canvas[%p] or Picture[%p] is invalid [%p]\n", mSwCanvas.get(), mPicture, this);
+    DALI_LOG_ERROR("TizenVectorImageRenderer::Load Canvas Object is null [%p]\n", this);
     return false;
   }
 
-  mPicture->scale(scale);
-
-  /* We need to push picture first time, after that we only update its properties. */
-  if (mIsFirstRender)
+  if(!mPicture)
   {
-    if (mSwCanvas->push(std::unique_ptr<tvg::Picture>(mPicture)) != tvg::Result::Success)
-    {
-      DALI_LOG_ERROR("TizenVectorImageRenderer::Render: Picture push fail [%p]\n", this);
-      return false;
-    }
-    mIsFirstRender = false;
-  }
-  else
-  {
-    if (mSwCanvas->update(mPicture) != tvg::Result::Success)
+    mPicture = tvg::Picture::gen().release();
+    if(!mPicture)
     {
-      DALI_LOG_ERROR("TizenVectorImageRenderer::Render: Picture update fail [%p]\n", this);
+      DALI_LOG_ERROR("TizenVectorImageRenderer::Load: Picture gen Fail [%p]\n", this);
       return false;
     }
   }
 
-  if (mSwCanvas->draw() != tvg::Result::Success)
+  if(mPicture->load(reinterpret_cast<char*>(data.Begin()), data.Size()) != tvg::Result::Success)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Render: Draw fail [%p]\n", this);
+    DALI_LOG_ERROR("TizenVectorImageRenderer::Load Data load Fail %s [%p]\n", data, this);
     return false;
   }
 
-  mSwCanvas->sync();
+  float w, h;
+  mPicture->viewbox(nullptr, nullptr, &w, &h);
+  mDefaultWidth = static_cast<uint32_t>(w);
+  mDefaultHeight = static_cast<uint32_t>(h);
 
   return true;
 }
 
-bool TizenVectorImageRenderer::Load( const std::string &url )
+bool TizenVectorImageRenderer::Rasterize(Dali::Devel::PixelBuffer& buffer, float scale)
 {
-  if (!mSwCanvas)
+  if(!mSwCanvas || !mPicture)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Load Canvas Object is null [%p]\n", this);
+    DALI_LOG_ERROR("TizenVectorImageRenderer::Rasterize: either Canvas[%p] or Picture[%p] is invalid [%p]\n", mSwCanvas.get(), mPicture, this);
     return false;
   }
 
-  if (!mPicture)
-  {
-    mPicture = tvg::Picture::gen().release();
-    if (!mPicture)
-    {
-      DALI_LOG_ERROR("TizenVectorImageRenderer::Load: Picture gen Fail [%p]\n", this);
-      return false;
-    }
-  }
+  unsigned char* pBuffer;
+  pBuffer = buffer.GetBuffer();
 
-  if (mPicture->load(url) != tvg::Result::Success)
+  if(!pBuffer)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Load File load Fail %s [%p]\n", url.c_str(), this);
+    DALI_LOG_ERROR("TizenVectorImageRenderer::Rasterize: pixel buffer is null [%p]\n", this);
     return false;
   }
 
-  float w, h;
-  mPicture->viewbox(nullptr, nullptr, &w, &h);
-  mDefaultWidth = static_cast<uint32_t>(w);
-  mDefaultHeight = static_cast<uint32_t>(h);
+  auto width = buffer.GetWidth();
+  auto height = buffer.GetHeight();
 
-  return true;
-}
+  mSwCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), width, width, height, tvg::SwCanvas::ABGR8888);
 
-bool TizenVectorImageRenderer::Load( const char *data, uint32_t size )
-{
-  if (!mSwCanvas)
+  DALI_LOG_RELEASE_INFO("TizenVectorImageRenderer::Rasterize: Buffer[%p] size[%d x %d]! [%p]\n", pBuffer, width, height, this);
+
+  mPicture->scale(scale);
+
+  /* We need to push picture first time, after that we only update its properties. */
+  if(mIsFirstRender)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Load Canvas Object is null [%p]\n", this);
-    return false;
+    if(mSwCanvas->push(std::unique_ptr<tvg::Picture>(mPicture)) != tvg::Result::Success)
+    {
+      DALI_LOG_ERROR("TizenVectorImageRenderer::Rasterize: Picture push fail [%p]\n", this);
+      return false;
+    }
+    mIsFirstRender = false;
   }
-
-  if (!mPicture)
+  else
   {
-    mPicture = tvg::Picture::gen().release();
-    if (!mPicture)
+    if(mSwCanvas->update(mPicture) != tvg::Result::Success)
     {
-      DALI_LOG_ERROR("TizenVectorImageRenderer::Load: Picture gen Fail [%p]\n", this);
+      DALI_LOG_ERROR("TizenVectorImageRenderer::Rasterize: Picture update fail [%p]\n", this);
       return false;
     }
   }
 
-  if (mPicture->load(data, size) != tvg::Result::Success)
+  if(mSwCanvas->draw() != tvg::Result::Success)
   {
-    DALI_LOG_ERROR("TizenVectorImageRenderer::Load Data load Fail %s [%p]\n", data, this);
+    DALI_LOG_ERROR("TizenVectorImageRenderer::Rasterize: Draw fail [%p]\n", this);
     return false;
   }
 
-  float w, h;
-  mPicture->viewbox(nullptr, nullptr, &w, &h);
-  mDefaultWidth = static_cast<uint32_t>(w);
-  mDefaultHeight = static_cast<uint32_t>(h);
+  mSwCanvas->sync();
 
   return true;
 }

diff --git a/dali-extension/vector-image-renderer/tizen-vector-image-renderer.h b/dali-extension/vector-image-renderer/tizen-vector-image-renderer.h
index 24cf0e2..d92c2bf 100755 (executable)
--- a/dali-extension/vector-image-renderer/tizen-vector-image-renderer.h
+++ b/dali-extension/vector-image-renderer/tizen-vector-image-renderer.h
@@ -48,43 +48,30 @@ public:
   virtual ~TizenVectorImageRenderer();
 
   /**
-   * @copydoc Dali::VectorImageRendererPlugin::Initialize()
-   */
-  bool Initialize() override;
-
-  /**
-   * @copydoc Dali::VectorImageRendererPlugin::SetBuffer()
-   */
-  void SetBuffer( Dali::Devel::PixelBuffer &buffer ) override;
-
-  /**
-   * @copydoc Dali::VectorImageRendererPlugin::Render()
-   */
-  bool Render( float scale ) override;
-
-  /**
    * @copydoc Dali::VectorImageRendererPlugin::Load()
    */
-  bool Load( const std::string& url ) override;
+  bool Load(const Vector<uint8_t>& data) override;
 
   /**
-   * @copydoc Dali::VectorImageRendererPlugin::Load()
+   * @copydoc Dali::VectorImageRendererPlugin::Render()
    */
-  bool Load( const char *data, uint32_t size ) override;
+  bool Rasterize(Dali::Devel::PixelBuffer& buffer, float scale) override;
 
   /**
    * @copydoc Dali::VectorImageRendererPlugin::GetDefaultSize()
    */
-  void GetDefaultSize( uint32_t& width, uint32_t& height ) const override;
+  void GetDefaultSize(uint32_t& width, uint32_t& height) const override;
 
 private:
 
   std::unique_ptr< tvg::SwCanvas >       mSwCanvas;
-  tvg::Picture*                          mPicture;               ///< The pointer to the picture
+  tvg::Picture*                          mPicture;        ///< The pointer to the picture
 
-  uint32_t                               mDefaultWidth;          ///< The width of the surface
-  uint32_t                               mDefaultHeight;         ///< The height of the surface
+  uint32_t                               mDefaultWidth;   ///< The width of the surface
+  uint32_t                               mDefaultHeight;  ///< The height of the surface
   bool                                   mIsFirstRender;
+
+  static uint32_t                        mCount;          ///< tvg engine intialize call count
 };
 
 } // namespace Plugin