feat(thorvg): update thorvg to 0.15.3 (lvgl#7103)

Signed-off-by: lhdjply <[email protected]>

Author: lhdjply

src/libs/thorvg/config.h

@@ -11,5 +11,5 @@
 
 #define THORVG_LOTTIE_LOADER_SUPPORT LV_USE_LOTTIE
 
-#define THORVG_VERSION_STRING "0.13.5"
+#define THORVG_VERSION_STRING "0.15.3"
 

src/libs/thorvg/thorvg.h

@@ -15,7 +15,7 @@ namespace tvg
  *
  * @see Animation
  * 
- * @note Experimental API
+ * @since 0.15
  */
 
 #include "../../lv_conf_internal.h"
@@ -81,13 +81,13 @@ class TVG_API LottieAnimation final : public Animation
      * @note Experimental API
      */
     const char* marker(uint32_t idx) noexcept;
-    
+
     /**
      * @brief Creates a new LottieAnimation object.
      *
      * @return A new LottieAnimation object.
      *
-     * @note Experimental API
+     * @since 0.15
      */
     static std::unique_ptr<LottieAnimation> gen() noexcept;
 };

src/libs/thorvg/thorvg_capi.h

@@ -24,20 +24,21 @@
 #if LV_USE_THORVG_INTERNAL
 
 #include "tvgIteratorAccessor.h"
+#include "tvgCompressor.h"
 
 /************************************************************************/
 /* Internal Class Implementation                                        */
 /************************************************************************/
 
-static bool accessChildren(Iterator* it, function<bool(const Paint* paint)> func)
+static bool accessChildren(Iterator* it, function<bool(const Paint* paint, void* data)> func, void* data)
 {
     while (auto child = it->next()) {
         //Access the child
-        if (!func(child)) return false;
+        if (!func(child, data)) return false;
 
         //Access the children of the child
         if (auto it2 = IteratorAccessor::iterator(child)) {
-            if (!accessChildren(it2, func)) {
+            if (!accessChildren(it2, func, data)) {
                 delete(it2);
                 return false;
             }
@@ -47,26 +48,46 @@ static bool accessChildren(Iterator* it, function<bool(const Paint* paint)> func
     return true;
 }
 
+
 /************************************************************************/
 /* External Class Implementation                                        */
 /************************************************************************/
 
-unique_ptr<Picture> Accessor::set(unique_ptr<Picture> picture, function<bool(const Paint* paint)> func) noexcept
+TVG_DEPRECATED unique_ptr<Picture> Accessor::set(unique_ptr<Picture> picture, function<bool(const Paint* paint)> func) noexcept
+{
+    auto backward = [](const tvg::Paint* paint, void* data) -> bool
+    {
+        auto func = reinterpret_cast<function<bool(const Paint* paint)>*>(data);
+        if (!(*func)(paint)) return false;
+        return true;
+    };
+
+    set(picture.get(), backward, reinterpret_cast<void*>(&func));
+    return picture;
+}
+
+
+Result Accessor::set(const Picture* picture, function<bool(const Paint* paint, void* data)> func, void* data) noexcept
 {
-    auto p = picture.get();
-    if (!p || !func) return picture;
+    if (!picture || !func) return Result::InvalidArguments;
 
     //Use the Preorder Tree-Search
 
     //Root
-    if (!func(p)) return picture;
+    if (!func(picture, data)) return Result::Success;
 
     //Children
-    if (auto it = IteratorAccessor::iterator(p)) {
-        accessChildren(it, func);
+    if (auto it = IteratorAccessor::iterator(picture)) {
+        accessChildren(it, func, data);
         delete(it);
     }
-    return picture;
+    return Result::Success;
+}
+
+
+uint32_t Accessor::id(const char* name) noexcept
+{
+    return djb2Encode(name);
 }
 
 

src/libs/thorvg/thorvg_lottie.h

@@ -98,7 +98,7 @@ float Animation::duration() const noexcept
 
 Result Animation::segment(float begin, float end) noexcept
 {
-    if (begin < 0.0 || end > 1.0 || begin >= end) return Result::InvalidArguments;
+    if (begin < 0.0 || end > 1.0 || begin > end) return Result::InvalidArguments;
 
     auto loader = pImpl->picture->pImpl->loader;
     if (!loader) return Result::InsufficientCondition;

src/libs/thorvg/tvgAccessor.cpp

@@ -62,7 +62,7 @@ struct Array
         data[count++] = element;
     }
 
-    void push(Array<T>& rhs)
+    void push(const Array<T>& rhs)
     {
         if (rhs.count == 0) return;
         grow(rhs.count);

src/libs/thorvg/tvgAnimation.cpp

@@ -39,7 +39,7 @@ using TvgBinFlag = TvgBinByte;
 #define TVG_HEADER_SIZE 33                //TVG_HEADER_SIGNATURE_LENGTH + TVG_HEADER_VERSION_LENGTH + 2*SIZE(float) + TVG_HEADER_RESERVED_LENGTH + TVG_HEADER_COMPRESS_SIZE
 #define TVG_HEADER_SIGNATURE "ThorVG"
 #define TVG_HEADER_SIGNATURE_LENGTH 6
-#define TVG_HEADER_VERSION "001200"       //Major 00, Minor 12, Micro 00
+#define TVG_HEADER_VERSION "001500"       //Major 00, Minor 15, Micro 00
 #define TVG_HEADER_VERSION_LENGTH 6
 #define TVG_HEADER_RESERVED_LENGTH 1      //Storing flags for extensions
 #define TVG_HEADER_COMPRESS_SIZE 12       //TVG_HEADER_UNCOMPRESSED_SIZE + TVG_HEADER_COMPRESSED_SIZE + TVG_HEADER_COMPRESSED_SIZE_BITS

src/libs/thorvg/tvgArray.h

@@ -29,17 +29,15 @@
 #include "tvgPaint.h"
 
 
+enum Status : uint8_t {Synced = 0, Updating, Drawing, Damaged};
+
 struct Canvas::Impl
 {
-    enum Status : uint8_t {Synced = 0, Updating, Drawing};
-
     list<Paint*> paints;
     RenderMethod* renderer;
     RenderRegion vport = {0, 0, INT32_MAX, INT32_MAX};
     Status status = Status::Synced;
 
-    bool refresh = false;   //if all paints should be updated by force.
-
     Impl(RenderMethod* pRenderer) : renderer(pRenderer)
     {
         renderer->ref();
@@ -90,33 +88,30 @@ struct Canvas::Impl
         return Result::Success;
     }
 
-    void needRefresh()
-    {
-        refresh = true;
-    }
-
     Result update(Paint* paint, bool force)
     {
         if (paints.empty() || status == Status::Drawing) return Result::InsufficientCondition;
 
         Array<RenderData> clips;
         auto flag = RenderUpdateFlag::None;
-        if (refresh || force) flag = RenderUpdateFlag::All;
+        if (status == Status::Damaged || force) flag = RenderUpdateFlag::All;
+
+        auto m = Matrix{1, 0, 0, 0, 1, 0, 0, 0, 1};
 
         if (paint) {
-            paint->pImpl->update(renderer, nullptr, clips, 255, flag);
+            paint->pImpl->update(renderer, m, clips, 255, flag);
         } else {
             for (auto paint : paints) {
-                paint->pImpl->update(renderer, nullptr, clips, 255, flag);
+                paint->pImpl->update(renderer, m, clips, 255, flag);
             }
-            refresh = false;
         }
         status = Status::Updating;
         return Result::Success;
     }
 
     Result draw()
     {
+        if (status == Status::Damaged) update(nullptr, false);
         if (status == Status::Drawing || paints.empty() || !renderer->preRender()) return Result::InsufficientCondition;
 
         bool rendered = false;
@@ -132,19 +127,20 @@ struct Canvas::Impl
 
     Result sync()
     {
-        if (status == Status::Synced) return Result::InsufficientCondition;
+        if (status == Status::Synced || status == Status::Damaged) return Result::InsufficientCondition;
 
         if (renderer->sync()) {
             status = Status::Synced;
             return Result::Success;
         }
 
-        return Result::InsufficientCondition;
+        return Result::Unknown;
     }
 
     Result viewport(int32_t x, int32_t y, int32_t w, int32_t h)
     {
-        if (status != Status::Synced) return Result::InsufficientCondition;
+        if (status != Status::Damaged && status != Status::Synced) return Result::InsufficientCondition;
+
         RenderRegion val = {x, y, w, h};
         //intersect if the target buffer is already set.
         auto surface = renderer->mainSurface();
@@ -154,7 +150,7 @@ struct Canvas::Impl
         if (vport == val) return Result::Success;
         renderer->viewport(val);
         vport = val;
-        needRefresh();
+        status = Status::Damaged;
         return Result::Success;
     }
 };