init

Telegram/ThirdParty/rlottie/example/lottieview.h

@@ -0,0 +1,579 @@
+/* 
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef LOTTIEVIEW_H
+#define LOTTIEVIEW_H
+
+#ifndef EFL_BETA_API_SUPPORT
+#define EFL_BETA_API_SUPPORT
+#endif
+
+#ifndef EFL_EO_API_SUPPORT
+#define EFL_EO_API_SUPPORT
+#endif
+
+#include <Eo.h>
+#include <Efl.h>
+#include <Evas.h>
+#include <Ecore.h>
+#include <Ecore_Evas.h>
+#include "rlottie.h"
+#include "rlottie_capi.h"
+#include<future>
+#include <cmath>
+
+class RenderStrategy {
+public:
+    virtual ~RenderStrategy() {
+        evas_object_del(renderObject());
+    }
+    RenderStrategy(Evas_Object *obj):_renderObject(obj){
+        addCallback();
+    }
+    virtual rlottie::Animation *player() {return nullptr;}
+    virtual void loadFromFile(const char *filePath) = 0;
+    virtual void loadFromData(const std::string &jsonData, const std::string &key, const std::string &resourcePath) = 0;
+    virtual size_t totalFrame() = 0;
+    virtual double frameRate() = 0;
+    virtual size_t frameAtPos(double pos) = 0;
+    virtual double duration() = 0;
+    void render(int frame) {
+        _redraw = renderRequest(frame);
+        if (_redraw)
+            evas_object_image_pixels_dirty_set(renderObject(), EINA_TRUE);
+    }
+    void dataCb() {
+        if (_redraw) {
+            evas_object_image_data_set(renderObject(), buffer());
+        }
+        _redraw = false;
+    }
+    virtual void resize(int width, int height) = 0;
+    virtual void setPos(int x, int y) {evas_object_move(renderObject(), x, y);}
+    void show() {evas_object_show(_renderObject);}
+    void hide() {evas_object_hide(_renderObject);}
+    void addCallback();
+    Evas_Object* renderObject() const {return _renderObject;}
+protected:
+    virtual bool renderRequest(int) = 0;
+    virtual uint32_t* buffer() = 0;
+private:
+    bool         _redraw{false};
+    Evas_Object *_renderObject;
+};
+
+class CppApiBase : public RenderStrategy {
+public:
+    CppApiBase(Evas_Object *renderObject): RenderStrategy(renderObject) {}
+    rlottie::Animation *player() {return mPlayer.get();}
+    void loadFromFile(const char *filePath)
+    {
+        mPlayer = rlottie::Animation::loadFromFile(filePath);
+
+        if (!mPlayer) {
+            printf("load failed file %s\n", filePath);
+        }
+    }
+
+    void loadFromData(const std::string &jsonData, const std::string &key, const std::string &resourcePath)
+    {
+        mPlayer = rlottie::Animation::loadFromData(jsonData, key, resourcePath);
+        if (!mPlayer) {
+            printf("load failed from data\n");
+        }
+    }
+
+    size_t totalFrame() {
+        return mPlayer->totalFrame();
+
+    }
+    double duration() {
+        return mPlayer->duration();
+    }
+
+    double frameRate() {
+        return mPlayer->frameRate();
+    }
+
+    size_t frameAtPos(double pos) {
+        return  mPlayer->frameAtPos(pos);
+    }
+protected:
+   std::unique_ptr<rlottie::Animation>       mPlayer;
+};
+
+class RlottieRenderStrategyCBase : public RenderStrategy {
+public:
+    RlottieRenderStrategyCBase(Evas *evas):RenderStrategy(evas_object_image_filled_add(evas)) {
+        evas_object_image_colorspace_set(renderObject(), EVAS_COLORSPACE_ARGB8888);
+        evas_object_image_alpha_set(renderObject(), EINA_TRUE);
+    }
+    void resize(int width, int height) {
+        evas_object_resize(renderObject(), width, height);
+        evas_object_image_size_set(renderObject(), width, height);
+    }
+};
+
+class RlottieRenderStrategy : public CppApiBase {
+public:
+    RlottieRenderStrategy(Evas *evas):CppApiBase(evas_object_image_filled_add(evas)) {
+        evas_object_image_colorspace_set(renderObject(), EVAS_COLORSPACE_ARGB8888);
+        evas_object_image_alpha_set(renderObject(), EINA_TRUE);
+    }
+    void resize(int width, int height) {
+        evas_object_resize(renderObject(), width, height);
+        evas_object_image_size_set(renderObject(), width, height);
+    }
+};
+
+class RlottieRenderStrategy_CPP : public RlottieRenderStrategy {
+public:
+    RlottieRenderStrategy_CPP(Evas *evas):RlottieRenderStrategy(evas) {}
+
+    bool renderRequest(int frame) {
+        int width , height;
+        Evas_Object *image = renderObject();
+        evas_object_image_size_get(image, &width, &height);
+        mBuffer = (uint32_t *)evas_object_image_data_get(image, EINA_TRUE);
+        size_t bytesperline =  evas_object_image_stride_get(image);
+        rlottie::Surface surface(mBuffer, width, height, bytesperline);
+        mPlayer->renderSync(frame, surface);
+        return true;
+    }
+    uint32_t* buffer() {
+        return mBuffer;
+    }
+
+private:
+    uint32_t *              mBuffer;
+};
+
+class RlottieRenderStrategy_CPP_ASYNC : public RlottieRenderStrategy {
+public:
+    RlottieRenderStrategy_CPP_ASYNC(Evas *evas):RlottieRenderStrategy(evas) {}
+    ~RlottieRenderStrategy_CPP_ASYNC() {
+        if (mRenderTask.valid())
+            mRenderTask.get();
+    }
+    bool renderRequest(int frame) {
+        //addCallback();
+        if (mRenderTask.valid()) return true;
+        int width , height;
+        Evas_Object *image = renderObject();
+        evas_object_image_size_get(image, &width, &height);
+        auto buffer = (uint32_t *)evas_object_image_data_get(image, EINA_TRUE);
+        size_t bytesperline =  evas_object_image_stride_get(image);
+        rlottie::Surface surface(buffer, width, height, bytesperline);
+        mRenderTask = mPlayer->render(frame, surface);
+        return true;
+    }
+
+    uint32_t* buffer() {
+        auto surface = mRenderTask.get();
+        return surface.buffer();
+    }
+private:
+   std::future<rlottie::Surface>        mRenderTask;
+};
+
+
+class RlottieRenderStrategy_C : public RlottieRenderStrategyCBase {
+public:
+    RlottieRenderStrategy_C(Evas *evas):RlottieRenderStrategyCBase(evas) {}
+    ~RlottieRenderStrategy_C() {
+        if (mPlayer) lottie_animation_destroy(mPlayer);
+    }
+    void loadFromFile(const char *filePath)
+    {
+        mPlayer = lottie_animation_from_file(filePath);
+
+        if (!mPlayer) {
+            printf("load failed file %s\n", filePath);
+        }
+    }
+
+    void loadFromData(const std::string &jsonData, const std::string &key, const std::string &resourcePath)
+    {
+        mPlayer = lottie_animation_from_data(jsonData.c_str(), key.c_str(), resourcePath.c_str());
+        if (!mPlayer) {
+            printf("load failed from data\n");
+        }
+    }
+
+    size_t totalFrame() {
+        return lottie_animation_get_totalframe(mPlayer);
+
+    }
+
+    double frameRate() {
+        return lottie_animation_get_framerate(mPlayer);
+    }
+
+    size_t frameAtPos(double pos) {
+        return  lottie_animation_get_frame_at_pos(mPlayer, pos);
+    }
+
+    double duration() {
+        return lottie_animation_get_duration(mPlayer);
+    }
+
+    bool renderRequest(int frame) {
+        int width , height;
+        Evas_Object *image = renderObject();
+        evas_object_image_size_get(image, &width, &height);
+        mBuffer = (uint32_t *)evas_object_image_data_get(image, EINA_TRUE);
+        size_t bytesperline =  evas_object_image_stride_get(image);
+        lottie_animation_render(mPlayer, frame, mBuffer, width, height, bytesperline);
+        return true;
+    }
+
+    uint32_t* buffer() {
+        return mBuffer;
+    }
+
+private:
+    uint32_t *              mBuffer;
+protected:
+   Lottie_Animation       *mPlayer;
+};
+
+class RlottieRenderStrategy_C_ASYNC : public RlottieRenderStrategy_C {
+public:
+    RlottieRenderStrategy_C_ASYNC(Evas *evas):RlottieRenderStrategy_C(evas) {}
+    ~RlottieRenderStrategy_C_ASYNC() {
+        if (mDirty) lottie_animation_render_flush(mPlayer);
+    }
+    bool renderRequest(int frame) {
+        if (mDirty) return true;
+        mDirty = true;
+        Evas_Object *image = renderObject();
+        evas_object_image_size_get(image, &mWidth, &mHeight);
+        mBuffer = (uint32_t *)evas_object_image_data_get(image, EINA_TRUE);
+        size_t bytesperline =  evas_object_image_stride_get(image);
+        lottie_animation_render_async(mPlayer, frame, mBuffer, mWidth, mHeight, bytesperline);
+        return true;
+    }
+
+    uint32_t* buffer() {
+       lottie_animation_render_flush(mPlayer);
+       mDirty =false;
+       return mBuffer;
+    }
+
+private:
+   uint32_t *              mBuffer;
+   int                     mWidth;
+   int                     mHeight;
+   bool                    mDirty{false};
+};
+
+enum class  Strategy {
+  renderCpp = 0,
+  renderCppAsync,
+  renderC,
+  renderCAsync,
+  eflVg
+};
+
+class LottieView
+{
+public:
+    enum class RepeatMode {
+        Restart,
+        Reverse
+    };
+    LottieView(Evas *evas, Strategy s = Strategy::renderCppAsync);
+    ~LottieView();
+    rlottie::Animation *player(){return mRenderDelegate->player();}
+    Evas_Object *getImage();
+    void setSize(int w, int h);
+    void setPos(int x, int y);
+    void setFilePath(const char *filePath);
+    void loadFromData(const std::string &jsonData, const std::string &key, const std::string &resourcePath="");
+    void show();
+    void hide();
+    void loop(bool loop);
+    void setSpeed(float speed) { mSpeed = speed;}
+    void setRepeatCount(int count);
+    void setRepeatMode(LottieView::RepeatMode mode);
+    float getFrameRate() const { return mRenderDelegate->frameRate(); }
+    long getTotalFrame() const { return mRenderDelegate->totalFrame(); }
+public:
+    void seek(float pos);
+    float getPos();
+    void finished();
+    void play();
+    void pause();
+    void stop();
+    void initializeBufferObject(Evas *evas);
+    void setMinProgress(float progress)
+    {
+        //clamp it to [0,1]
+        mMinProgress = progress;
+    }
+    void setMaxProgress(float progress)
+    {
+        //clamp it to [0,1]
+        mMaxprogress = progress;
+    }
+private:
+    float mapProgress(float progress) {
+        //clamp it to the segment
+        progress = (mMinProgress + (mMaxprogress - mMinProgress) * progress);
+
+        // currently playing and in reverse mode
+        if (mPalying && mReverse)
+            progress = mMaxprogress > mMinProgress ?
+                        mMaxprogress - progress : mMinProgress - progress;
+
+
+        return progress;
+    }
+    float duration() const {
+        // usually we run the animation for mPlayer->duration()
+        // but now run animation for segmented duration.
+        return  mRenderDelegate->duration() * fabs(mMaxprogress - mMinProgress);
+    }
+    void createVgNode(LOTNode *node, Efl_VG *root);
+    void update(const std::vector<LOTNode *> &);
+    void updateTree(const LOTLayerNode *);
+    void update(const LOTLayerNode *, Efl_VG *parent);
+    void restart();
+public:
+    int                      mRepeatCount;
+    LottieView::RepeatMode   mRepeatMode;
+    size_t                   mCurFrame{UINT_MAX};
+    Ecore_Animator          *mAnimator{nullptr};
+    bool                     mLoop;
+    int                      mCurCount;
+    bool                     mReverse;
+    bool                     mPalying;
+    float                    mSpeed;
+    float                    mPos;
+    //keep a segment of the animation default is [0, 1]
+    float                   mMinProgress{0};
+    float                   mMaxprogress{1};
+    std::unique_ptr<RenderStrategy>  mRenderDelegate;
+};
+
+#include<assert.h>
+class EflVgRenderStrategy : public CppApiBase {
+    int mW;
+    int mH;
+public:
+    EflVgRenderStrategy(Evas *evas):CppApiBase(evas_object_vg_add(evas)) {}
+
+    void resize(int width, int height) {
+        mW = width;
+        mH = height;
+        evas_object_resize(renderObject(), width, height);
+    }
+
+    uint32_t *buffer() {
+        assert(false);
+    }
+
+    bool renderRequest(int frame) {
+        const LOTLayerNode *root = mPlayer->renderTree(frame, mW, mH);
+        updateTree(root);
+        return false;
+    }
+
+    void updateTree(const LOTLayerNode * node)
+    {
+        Efl_VG *root = evas_vg_container_add(renderObject());
+        update(node, root);
+        evas_object_vg_root_node_set(renderObject(), root);
+    }
+
+    void createVgNode(LOTNode *node, Efl_VG *root)
+    {
+        Efl_VG *shape = evas_vg_shape_add(root);
+
+        //0: Path
+        const float *data = node->mPath.ptPtr;
+        if (!data) return;
+
+        for (size_t i = 0; i < node->mPath.elmCount; i++) {
+            switch (node->mPath.elmPtr[i]) {
+            case 0:
+                evas_vg_shape_append_move_to(shape, data[0], data[1]);
+                data += 2;
+                break;
+            case 1:
+                evas_vg_shape_append_line_to(shape, data[0], data[1]);
+                data += 2;
+                break;
+            case 2:
+                evas_vg_shape_append_cubic_to(shape, data[0], data[1], data[2], data[3], data[4], data[5]);
+                data += 6;
+                break;
+            case 3:
+                evas_vg_shape_append_close(shape);
+                break;
+            default:
+                break;
+            }
+        }
+
+        //1: Stroke
+        if (node->mStroke.enable) {
+            //Stroke Width
+            evas_vg_shape_stroke_width_set(shape, node->mStroke.width);
+
+            //Stroke Cap
+            Efl_Gfx_Cap cap;
+            switch (node->mStroke.cap) {
+            case CapFlat: cap = EFL_GFX_CAP_BUTT; break;
+            case CapSquare: cap = EFL_GFX_CAP_SQUARE; break;
+            case CapRound: cap = EFL_GFX_CAP_ROUND; break;
+            default: cap = EFL_GFX_CAP_BUTT; break;
+            }
+            evas_vg_shape_stroke_cap_set(shape, cap);
+
+            //Stroke Join
+            Efl_Gfx_Join join;
+            switch (node->mStroke.join) {
+            case JoinMiter: join = EFL_GFX_JOIN_MITER; break;
+            case JoinBevel: join = EFL_GFX_JOIN_BEVEL; break;
+            case JoinRound: join = EFL_GFX_JOIN_ROUND; break;
+            default: join = EFL_GFX_JOIN_MITER; break;
+            }
+            evas_vg_shape_stroke_join_set(shape, join);
+
+            //Stroke Dash
+            if (node->mStroke.dashArraySize > 0) {
+                int size = (node->mStroke.dashArraySize / 2);
+                Efl_Gfx_Dash *dash = static_cast<Efl_Gfx_Dash*>(malloc(sizeof(Efl_Gfx_Dash) * size));
+                if (dash) {
+                    for (int i = 0; i <= size; i+=2) {
+                        dash[i].length = node->mStroke.dashArray[i];
+                        dash[i].gap = node->mStroke.dashArray[i + 1];
+                    }
+                    evas_vg_shape_stroke_dash_set(shape, dash, size);
+                    free(dash);
+                }
+            }
+        }
+
+        //2: Fill Method
+        switch (node->mBrushType) {
+        case BrushSolid: {
+            float pa = ((float)node->mColor.a) / 255;
+            int r = (int)(((float) node->mColor.r) * pa);
+            int g = (int)(((float) node->mColor.g) * pa);
+            int b = (int)(((float) node->mColor.b) * pa);
+            int a = node->mColor.a;
+            if (node->mStroke.enable)
+              evas_vg_shape_stroke_color_set(shape, r, g, b, a);
+            else
+              evas_vg_node_color_set(shape, r, g, b, a);
+            break;
+        }
+        case BrushGradient: {
+            Efl_VG* grad = NULL;
+            if (node->mGradient.type == GradientLinear) {
+                grad = evas_vg_gradient_linear_add(root);
+                evas_vg_gradient_linear_start_set(grad, node->mGradient.start.x, node->mGradient.start.y);
+                evas_vg_gradient_linear_end_set(grad, node->mGradient.end.x, node->mGradient.end.y);
+
+            }
+            else if (node->mGradient.type == GradientRadial) {
+                grad = evas_vg_gradient_radial_add(root);
+                evas_vg_gradient_radial_center_set(grad, node->mGradient.center.x, node->mGradient.center.y);
+                evas_vg_gradient_radial_focal_set(grad, node->mGradient.focal.x, node->mGradient.focal.y);
+                evas_vg_gradient_radial_radius_set(grad, node->mGradient.cradius);
+            }
+
+            if (grad) {
+                //Gradient Stop
+                Efl_Gfx_Gradient_Stop* stops = static_cast<Efl_Gfx_Gradient_Stop*>(malloc(sizeof(Efl_Gfx_Gradient_Stop) * node->mGradient.stopCount));
+                if (stops) {
+                    for (unsigned int i = 0; i < node->mGradient.stopCount; i++) {
+                        stops[i].offset = node->mGradient.stopPtr[i].pos;
+                        float pa = ((float)node->mGradient.stopPtr[i].a) / 255;
+                        stops[i].r = (int)(((float)node->mGradient.stopPtr[i].r) * pa);
+                        stops[i].g = (int)(((float)node->mGradient.stopPtr[i].g) * pa);
+                        stops[i].b = (int)(((float)node->mGradient.stopPtr[i].b) * pa);
+                        stops[i].a = node->mGradient.stopPtr[i].a;
+                    }
+                    evas_vg_gradient_stop_set(grad, stops, node->mGradient.stopCount);
+                    free(stops);
+                }
+                if (node->mStroke.enable)
+                  evas_vg_shape_stroke_fill_set(shape, grad);
+                else
+                  evas_vg_shape_fill_set(shape, grad);
+            }
+            break;
+        }
+        default:
+          break;
+        }
+
+        //3: Fill Rule
+//        if (node->mFillRule == FillEvenOdd)
+//          efl_gfx_shape_fill_rule_set(shape, EFL_GFX_FILL_RULE_ODD_EVEN);
+//        else if (node->mFillRule == FillWinding)
+//          efl_gfx_shape_fill_rule_set(shape, EFL_GFX_FILL_RULE_WINDING);
+    }
+
+    void update(const std::vector<LOTNode *> &renderList)
+    {
+        Efl_VG *root = evas_vg_container_add(renderObject());
+        for(auto i : renderList) {
+            createVgNode(i, root);
+        }
+        evas_object_vg_root_node_set(renderObject(), root);
+    }
+
+    void update(const LOTLayerNode * node, Efl_VG *parent)
+    {
+        // if the layer is invisible return
+        if (!node->mVisible) return;
+
+        // check if this layer is a container layer
+        bool hasMatte = false;
+        if (node->mLayerList.size) {
+            for (unsigned int i = 0; i < node->mLayerList.size; i++) {
+                if (hasMatte) {
+                    hasMatte = false;
+                    continue;
+                }
+                // if the layer has matte then
+                // the next layer has to be rendered using this layer
+                // as matte source
+                if (node->mLayerList.ptr[i]->mMatte != MatteNone) {
+                    hasMatte = true;
+                    printf("Matte is not supported Yet\n");
+                    continue;
+                }
+                update(node->mLayerList.ptr[i], parent);
+            }
+        }
+
+        // check if this layer has drawable
+        if (node->mNodeList.size) {
+            for (unsigned int i = 0; i < node->mNodeList.size; i++) {
+                createVgNode(node->mNodeList.ptr[i], parent);
+            }
+        }
+    }
+};
+
+#endif //LOTTIEVIEW_H