Patch 1

Lottie

@@ -0,0 +1 @@
+

inc/rlottie.h

@@ -43,6 +43,15 @@ struct LOTLayerNode;
 
 namespace rlottie {
 
+enum class FitzModifier {
+    None,
+    Type12,
+    Type3,
+    Type4,
+    Type5,
+    Type6
+};
+
 /**
  *  @brief Configures rlottie model cache policy.
  *
@@ -293,7 +302,7 @@ class LOT_EXPORT Animation {
     loadFromData(std::string jsonData, const std::string &key,
                  const std::string &resourcePath="", bool cachePolicy=true,
 	             const std::vector<std::pair<std::uint32_t, std::uint32_t>>
-				     &colorReplacements = {});
+				     &colorReplacements = {}, FitzModifier fitzModifier = FitzModifier::None);
 
     /**
      *  @brief Returns default framerate of the Lottie resource.

src/lottie/lottieanimation.cpp

@@ -242,7 +242,7 @@ std::unique_ptr<Animation> Animation::loadFromData(
     std::string jsonData, const std::string &key,
     const std::string &resourcePath, bool cachePolicy,
     const std::vector<std::pair<std::uint32_t, std::uint32_t>>
-        &colorReplacements)
+        &colorReplacements, FitzModifier fitzModifier)
 {
     if (jsonData.empty()) {
         vWarning << "jason data is empty";
@@ -252,7 +252,7 @@ std::unique_ptr<Animation> Animation::loadFromData(
     LottieLoader loader;
     if (loader.loadFromData(std::move(jsonData), key,
                             (resourcePath.empty() ? " " : resourcePath),
-                            cachePolicy, colorReplacements)) {
+                            cachePolicy, colorReplacements, fitzModifier)) {
         auto animation = std::unique_ptr<Animation>(new Animation);
         animation->d->init(loader.model());
         return animation;

src/lottie/lottieitem.cpp

@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ -92,6 +92,7 @@ void LOTCompItem::setValue(const std::string &keypath, LOTVariant &value)
 {
     LOTKeyPath key(keypath);
     mRootLayer->resolveKeyPath(key, 0, value);
+    mCurFrameNo = -1;
 }
 
 std::unique_ptr<LOTLayerItem> LOTCompItem::createLayerItem(
@@ -518,6 +519,9 @@ LOTCompLayerItem::LOTCompLayerItem(LOTLayerData *layerModel)
 {
     // 1. create layer item
     for (auto &i : mLayerData->mChildren) {
+        if (i->type() != LOTData::Type::Layer) {
+            continue;
+        }
         auto model = static_cast<LOTLayerData *>(i.get());
         auto item = LOTCompItem::createLayerItem(model);
         if (item) mLayers.push_back(std::move(item));

src/lottie/lottieloader.cpp

@@ -71,7 +71,7 @@ class LottieModelCache {
 
     std::unordered_map<std::string, std::shared_ptr<LOTModel>>  mHash;
     std::mutex                                                  mMutex;
-    size_t                                                      mcacheSize{10};
+    size_t                                                      mcacheSize{10000};
 };
 
 #else
@@ -144,15 +144,16 @@ bool LottieLoader::loadFromData(
     std::string &&jsonData, const std::string &key,
     const std::string &resourcePath, bool cachePolicy,
     const std::vector<std::pair<std::uint32_t, std::uint32_t>>
-        &colorReplacements)
+        &colorReplacements, rlottie::FitzModifier fitzModifier)
 {
     if (cachePolicy) {
         mModel = LottieModelCache::instance().find(key);
-        if (mModel) return true;
+        if (mModel)
+            return true;
     }
 
     LottieParser parser(const_cast<char *>(jsonData.c_str()),
-                        resourcePath.c_str(), colorReplacements);
+                        resourcePath.c_str(), colorReplacements, fitzModifier);
     mModel = parser.model();
 
     if (!mModel) return false;

src/lottie/lottieloader.h

@@ -23,6 +23,8 @@
 #include<memory>
 #include<vector>
 
+#include "rlottie.h"
+
 class LOTModel;
 class LottieLoader
 {
@@ -32,7 +34,7 @@ class LottieLoader
    bool loadFromData(std::string &&jsonData, const std::string &key,
                      const std::string &resourcePath, bool cachePolicy,
                      const std::vector<std::pair<std::uint32_t, std::uint32_t>>
-                         &colorReplacements);
+                         &colorReplacements, rlottie::FitzModifier fitzModifier);
    std::shared_ptr<LOTModel> model();
 private:  
    std::shared_ptr<LOTModel>    mModel;

src/lottie/lottiemodel.cpp

@@ -184,11 +184,17 @@ void LOTGradient::populate(VGradientStops &stops, int frameNo)
     LottieGradient gradData = mGradient.value(frameNo);
     auto            size = gradData.mGradient.size();
     float *        ptr = gradData.mGradient.data();
+    if (!ptr) {
+        return;
+    }
     int            colorPoints = mColorPoints;
-    if (colorPoints == -1) {  // for legacy bodymovin (ref: lottie-android)
+    if (colorPoints < 0 || colorPoints > size / 4) {  // for legacy bodymovin (ref: lottie-android)
         colorPoints = int(size / 4);
     }
     auto    opacityArraySize = size - colorPoints * 4;
+    if ((opacityArraySize % 2 != 0) || (colorPoints > opacityArraySize / 2 && opacityArraySize < 4)) {
+        opacityArraySize = 0;
+    }
     float *opacityPtr = ptr + (colorPoints * 4);
     stops.clear();
     size_t j = 0;
@@ -242,6 +248,9 @@ void LOTGradient::populate(VGradientStops &stops, int frameNo)
         }
         ptr += 4;
     }
+    if (stops.empty()) {
+        stops.push_back(std::make_pair(0.0f, VColor(255, 255, 255, 255)));
+    }
 }
 
 void LOTGradient::update(std::unique_ptr<VGradient> &grad, int frameNo)

src/lottie/lottiemodel.h

@@ -225,11 +225,13 @@ class LOTAnimInfo
 {
 public:
     T value(int frameNo) const {
+        if (mKeyFrames.empty())
+            return T();
+
         if (mKeyFrames.front().mStartFrame >= frameNo)
             return mKeyFrames.front().mValue.mStartValue;
-        if(mKeyFrames.back().mEndFrame <= frameNo)
+        if (mKeyFrames.back().mEndFrame <= frameNo)
             return mKeyFrames.back().mValue.mEndValue;
-
         for(const auto &keyFrame : mKeyFrames) {
             if (frameNo >= keyFrame.mStartFrame && frameNo < keyFrame.mEndFrame)
                 return keyFrame.value(frameNo);
@@ -238,7 +240,8 @@ class LOTAnimInfo
     }
 
     float angle(int frameNo) const {
-        if ((mKeyFrames.front().mStartFrame >= frameNo) ||
+        if (mKeyFrames.empty() ||
+            (mKeyFrames.front().mStartFrame >= frameNo) ||
             (mKeyFrames.back().mEndFrame <= frameNo) )
             return 0;
 
@@ -250,6 +253,9 @@ class LOTAnimInfo
     }
 
     bool changed(int prevFrame, int curFrame) const {
+        if (mKeyFrames.empty())
+            return false;
+
         auto first = mKeyFrames.front().mStartFrame;
         auto last = mKeyFrames.back().mEndFrame;