optimization: refactor renderTree() api support to reduce lottie object size.

Moving all the data structure under LOTCApiData and allocationg it when needed
we will incur only a pointer overhead when renderApi() is not used.

Change-Id: I846cfabd14ba85397fa2ab8b3ee2caba41cd87cb

diff --git a/src/lottie/lottieitem.cpp b/src/lottie/lottieitem.cpp
index 011f9fa063dbcd22fe452d6ab38397e3839b3dcd..b68755e9bb2b1345865faf6710452874c1fc3dac 100644 (file)
--- a/src/lottie/lottieitem.cpp
+++ b/src/lottie/lottieitem.cpp
@@ -149,7 +149,7 @@ void LOTCompItem::buildRenderTree()
 
 const LOTLayerNode *LOTCompItem::renderTree() const
 {
-    return mRootLayer->layerNode();
+    return &mRootLayer->clayer();
 }
 
 bool LOTCompItem::render(const rlottie::Surface &surface)
@@ -210,82 +210,87 @@ VRle LOTMaskItem::rle()
     return mRasterizer.rle();
 }
 
+LOTCApiData::LOTCApiData()
+{
+    mLayer.mMaskList.ptr = nullptr;
+    mLayer.mMaskList.size = 0;
+    mLayer.mLayerList.ptr = nullptr;
+    mLayer.mLayerList.size = 0;
+    mLayer.mNodeList.ptr = nullptr;
+    mLayer.mNodeList.size = 0;
+    mLayer.mMatte = MatteNone;
+    mLayer.mVisible = 0;
+    mLayer.mAlpha = 255;
+    mLayer.mClipPath.ptPtr = nullptr;
+    mLayer.mClipPath.elmPtr = nullptr;
+    mLayer.mClipPath.ptCount = 0;
+    mLayer.mClipPath.elmCount = 0;
+    mLayer.keypath = nullptr;
+}
+
 void LOTLayerItem::buildLayerNode()
 {
-    if (!mLayerCNode) {
-        mLayerCNode = std::make_unique<LOTLayerNode>();
-        mLayerCNode->mMaskList.ptr = nullptr;
-        mLayerCNode->mMaskList.size = 0;
-        mLayerCNode->mLayerList.ptr = nullptr;
-        mLayerCNode->mLayerList.size = 0;
-        mLayerCNode->mNodeList.ptr = nullptr;
-        mLayerCNode->mNodeList.size = 0;
-        mLayerCNode->mMatte = MatteNone;
-        mLayerCNode->mVisible = 0;
-        mLayerCNode->mAlpha = 255;
-        mLayerCNode->mClipPath.ptPtr = nullptr;
-        mLayerCNode->mClipPath.elmPtr = nullptr;
-        mLayerCNode->mClipPath.ptCount = 0;
-        mLayerCNode->mClipPath.elmCount = 0;
-        mLayerCNode->keypath = name();
-    }
-    if (complexContent()) mLayerCNode->mAlpha = uchar(combinedAlpha() * 255.f);
-    mLayerCNode->mVisible = visible();
+    if (!mCApiData) {
+        mCApiData = std::make_unique<LOTCApiData>();
+        clayer().keypath = name();
+    }
+    if (complexContent()) clayer().mAlpha = uchar(combinedAlpha() * 255.f);
+    clayer().mVisible = visible();
     // update matte
     if (hasMatte()) {
         switch (mLayerData->mMatteType) {
         case MatteType::Alpha:
-            mLayerCNode->mMatte = MatteAlpha;
+            clayer().mMatte = MatteAlpha;
             break;
         case MatteType::AlphaInv:
-            mLayerCNode->mMatte = MatteAlphaInv;
+            clayer().mMatte = MatteAlphaInv;
             break;
         case MatteType::Luma:
-            mLayerCNode->mMatte = MatteLuma;
+            clayer().mMatte = MatteLuma;
             break;
         case MatteType::LumaInv:
-            mLayerCNode->mMatte = MatteLumaInv;
+            clayer().mMatte = MatteLumaInv;
             break;
         default:
-            mLayerCNode->mMatte = MatteNone;
+            clayer().mMatte = MatteNone;
             break;
         }
     }
     if (mLayerMask) {
-        mMasksCNode.clear();
-        mMasksCNode.resize(mLayerMask->mMasks.size());
+        cmasks().clear();
+        cmasks().resize(mLayerMask->mMasks.size());
         size_t i = 0;
         for (const auto &mask : mLayerMask->mMasks) {
-            LOTMask *                          cNode = &mMasksCNode[i++];
-            const std::vector<VPath::Element> &elm = mask.mFinalPath.elements();
-            const std::vector<VPointF> &       pts = mask.mFinalPath.points();
+            auto       &cNode = cmasks()[i++];
+            const auto &elm = mask.mFinalPath.elements();
+            const auto &pts = mask.mFinalPath.points();
             auto ptPtr = reinterpret_cast<const float *>(pts.data());
             auto elmPtr = reinterpret_cast<const char *>(elm.data());
-            cNode->mPath.ptPtr = ptPtr;
-            cNode->mPath.ptCount = pts.size();
-            cNode->mPath.elmPtr = elmPtr;
-            cNode->mPath.elmCount = elm.size();
-            cNode->mAlpha = uchar(mask.mCombinedAlpha * 255.0f);
+            cNode.mPath.ptPtr = ptPtr;
+            cNode.mPath.ptCount = pts.size();
+            cNode.mPath.elmPtr = elmPtr;
+            cNode.mPath.elmCount = elm.size();
+            cNode.mAlpha = uchar(mask.mCombinedAlpha * 255.0f);
             switch (mask.maskMode()) {
             case LOTMaskData::Mode::Add:
-                cNode->mMode = MaskAdd;
+                cNode.mMode = MaskAdd;
                 break;
             case LOTMaskData::Mode::Substarct:
-                cNode->mMode = MaskSubstract;
+                cNode.mMode = MaskSubstract;
                 break;
             case LOTMaskData::Mode::Intersect:
-                cNode->mMode = MaskIntersect;
+                cNode.mMode = MaskIntersect;
                 break;
             case LOTMaskData::Mode::Difference:
-                cNode->mMode = MaskDifference;
+                cNode.mMode = MaskDifference;
                 break;
             default:
-                cNode->mMode = MaskAdd;
+                cNode.mMode = MaskAdd;
                 break;
             }
         }
-        mLayerCNode->mMaskList.ptr = mMasksCNode.data();
-        mLayerCNode->mMaskList.size = mMasksCNode.size();
+        clayer().mMaskList.ptr = cmasks().data();
+        clayer().mMaskList.size = cmasks().size();
     }
 }
 
@@ -540,22 +545,22 @@ void LOTCompLayerItem::buildLayerNode()
 {
     LOTLayerItem::buildLayerNode();
     if (mClipper) {
-        const std::vector<VPath::Element> &elm = mClipper->mPath.elements();
-        const std::vector<VPointF> &       pts = mClipper->mPath.points();
+        const auto &elm = mClipper->mPath.elements();
+        const auto &pts = mClipper->mPath.points();
         auto ptPtr = reinterpret_cast<const float *>(pts.data());
         auto elmPtr = reinterpret_cast<const char *>(elm.data());
-        layerNode()->mClipPath.ptPtr = ptPtr;
-        layerNode()->mClipPath.elmPtr = elmPtr;
-        layerNode()->mClipPath.ptCount = 2 * pts.size();
-        layerNode()->mClipPath.elmCount = elm.size();
+        clayer().mClipPath.ptPtr = ptPtr;
+        clayer().mClipPath.elmPtr = elmPtr;
+        clayer().mClipPath.ptCount = 2 * pts.size();
+        clayer().mClipPath.elmCount = elm.size();
     }
-    if (mLayers.size() != mLayersCNode.size()) {
+    if (mLayers.size() != clayers().size()) {
         for (const auto &layer : mLayers) {
             layer->buildLayerNode();
-            mLayersCNode.push_back(layer->layerNode());
+            clayers().push_back(&layer->clayer());
         }
-        layerNode()->mLayerList.ptr = mLayersCNode.data();
-        layerNode()->mLayerList.size = mLayersCNode.size();
+        clayer().mLayerList.ptr = clayers().data();
+        clayer().mLayerList.size = clayers().size();
     } else {
         for (const auto &layer : mLayers) {
             layer->buildLayerNode();
@@ -766,8 +771,8 @@ void LOTSolidLayerItem::buildLayerNode()
         lotDrawable->sync();
         mCNodeList.push_back(lotDrawable->mCNode.get());
     }
-    layerNode()->mNodeList.ptr = mCNodeList.data();
-    layerNode()->mNodeList.size = mCNodeList.size();
+    clayer().mNodeList.ptr = mCNodeList.data();
+    clayer().mNodeList.size = mCNodeList.size();
 }
 
 void LOTSolidLayerItem::renderList(std::vector<VDrawable *> &list)
@@ -845,8 +850,8 @@ void LOTImageLayerItem::buildLayerNode()
 
         mCNodeList.push_back(lotDrawable->mCNode.get());
     }
-    layerNode()->mNodeList.ptr = mCNodeList.data();
-    layerNode()->mNodeList.size = mCNodeList.size();
+    clayer().mNodeList.ptr = mCNodeList.data();
+    clayer().mNodeList.size = mCNodeList.size();
 }
 
 LOTNullLayerItem::LOTNullLayerItem(LOTLayerData *layerData)
@@ -946,8 +951,8 @@ void LOTShapeLayerItem::buildLayerNode()
         lotDrawable->sync();
         mCNodeList.push_back(lotDrawable->mCNode.get());
     }
-    layerNode()->mNodeList.ptr = mCNodeList.data();
-    layerNode()->mNodeList.size = mCNodeList.size();
+    clayer().mNodeList.ptr = mCNodeList.data();
+    clayer().mNodeList.size = mCNodeList.size();
 }
 
 void LOTShapeLayerItem::renderList(std::vector<VDrawable *> &list)

diff --git a/src/lottie/lottieitem.h b/src/lottie/lottieitem.h
index 8d51afee337c17798b89fef6e5cd7454f14ebdee..f17aa6c2ad99c87faac904acf3e87ead451f09df 100644 (file)
--- a/src/lottie/lottieitem.h
+++ b/src/lottie/lottieitem.h
@@ -98,6 +98,14 @@ public:
 
 typedef vFlag<DirtyFlagBit> DirtyFlag;
 
+struct LOTCApiData
+{
+    LOTCApiData();
+    LOTLayerNode                  mLayer;
+    std::vector<LOTMask>          mMasks;
+    std::vector<LOTLayerNode *>   mLayers;
+};
+
 class LOTLayerItem
 {
 public:
@@ -117,7 +125,9 @@ public:
    MatteType matteType() const { return mLayerData->mMatteType;}
    bool visible() const;
    virtual void buildLayerNode();
-   LOTLayerNode * layerNode() const {return mLayerCNode.get();}
+   LOTLayerNode& clayer() {return mCApiData->mLayer;}
+   std::vector<LOTLayerNode *>& clayers() {return mCApiData->mLayers;}
+   std::vector<LOTMask>& cmasks() {return mCApiData->mMasks;}
    const char* name() const {return mLayerData->name();}
    virtual bool resolveKeyPath(LOTKeyPath &keyPath, uint depth, LOTVariant &value);
    VBitmap& bitmap() {return mRenderBuffer;}
@@ -130,8 +140,6 @@ protected:
    float opacity(int frameNo) const {return mLayerData->opacity(frameNo);}
    inline DirtyFlag flag() const {return mDirtyFlag;}
 protected:
-   std::vector<LOTMask>                        mMasksCNode;
-   std::unique_ptr<LOTLayerNode>               mLayerCNode;
    std::vector<VDrawable *>                    mDrawableList;
    std::unique_ptr<LOTLayerMaskItem>           mLayerMask;
    LOTLayerData                               *mLayerData{nullptr};
@@ -142,6 +150,7 @@ protected:
    int                                         mFrameNo{-1};
    DirtyFlag                                   mDirtyFlag{DirtyFlagBit::All};
    bool                                        mComplexContent{false};
+   std::unique_ptr<LOTCApiData>                mCApiData;
 };
 
 class LOTCompLayerItem: public LOTLayerItem
@@ -159,7 +168,6 @@ private:
     void renderMatteLayer(VPainter *painter, const VRle &inheritMask, const VRle &matteRle,
                           LOTLayerItem *layer, LOTLayerItem *src);
 private:
-   std::vector<LOTLayerNode *>                  mLayersCNode;
    std::vector<std::unique_ptr<LOTLayerItem>>   mLayers;
    std::unique_ptr<LOTClipperItem>              mClipper;
 };