EffectBase.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_EFFECT_BASE_H
#define OPENSHOT_EFFECT_BASE_H
 
#include "ClipBase.h"
 
#include "Json.h"
#include "TrackedObjectBase.h"
 
#include <QImage>
#include <memory>
#include <map>
#include <string>
 
namespace openshot
{
    class ReaderBase;
 
    struct EffectInfoStruct
    {
        std::string class_name; 
        std::string name; 
        std::string description; 
        std::string parent_effect_id; 
        bool has_video; 
        bool has_audio; 
        bool has_tracked_object; 
        bool apply_before_clip; 
    };
 
    class EffectBase : public ClipBase
    {
    private:
        int order; 
        ReaderBase* mask_reader = nullptr; 
        std::string mask_source_id; 
        std::shared_ptr<QImage> cached_single_mask_image; 
        int cached_single_mask_width = 0; 
        int cached_single_mask_height = 0; 
 
        std::shared_ptr<QImage> GetMaskImage(std::shared_ptr<QImage> target_image, int64_t frame_number);
 
        void BlendWithMask(std::shared_ptr<QImage> original_image, std::shared_ptr<QImage> effected_image,
                       std::shared_ptr<QImage> mask_image) const;
 
        EffectBase* ResolveMaskSourceEffect();
 
    protected:
        openshot::ClipBase* clip; 
 
        ReaderBase* CreateReaderFromJson(const Json::Value& reader_json) const;
 
        int64_t MapMaskFrameNumber(int64_t frame_number);
 
        double ResolveMaskHostFps();
 
        double ResolveMaskSourceDuration() const;
 
        std::shared_ptr<QImage> ResolveMaskImage(std::shared_ptr<QImage> target_image, int64_t frame_number) {
            return GetMaskImage(target_image, frame_number);
        }
 
        virtual bool UseCustomMaskBlend(int64_t frame_number) const { return false; }
 
        virtual void ApplyCustomMaskBlend(std::shared_ptr<QImage> original_image, std::shared_ptr<QImage> effected_image,
                                  std::shared_ptr<QImage> mask_image, int64_t frame_number) const {}
 
        virtual bool HandlesMaskInternally() const { return false; }
 
    public:
        EffectBase* parentEffect;
 
        std::map<int, std::shared_ptr<openshot::TrackedObjectBase> > trackedObjects;
 
        EffectInfoStruct info;
        bool mask_invert = false; 
 
        enum MaskTimeMode {
            MASK_TIME_TIMELINE = 0,
            MASK_TIME_SOURCE_FPS = 1
        };
 
        enum MaskLoopMode {
            MASK_LOOP_PLAY_ONCE = 0,
            MASK_LOOP_REPEAT = 1,
            MASK_LOOP_PING_PONG = 2
        };
 
        int mask_time_mode = MASK_TIME_SOURCE_FPS; 
        int mask_loop_mode = MASK_LOOP_PLAY_ONCE; 
 
        void DisplayInfo(std::ostream* out=&std::cout);
 
        int constrain(int color_value);
 
        void InitEffectInfo();
 
        openshot::ClipBase* ParentClip();
 
        void ParentClip(openshot::ClipBase* new_clip);
 
        void SetParentEffect(std::string parentEffect_id);
 
        std::string ParentClipId() const;
 
        virtual std::string GetVisibleObjects(int64_t frame_number) const {return {}; };
 
        virtual std::shared_ptr<QImage> TrackedObjectMask(std::shared_ptr<QImage> target_image, int64_t frame_number) const;
 
        // Get and Set JSON methods
        virtual std::string Json() const; 
        virtual void SetJson(const std::string value); 
        virtual Json::Value JsonValue() const; 
        virtual void SetJsonValue(const Json::Value root); 
 
        virtual std::string Json(int64_t requested_frame) const{
            return "";
        };
        virtual void SetJson(int64_t requested_frame, const std::string value) {
            return;
        };
 
        Json::Value JsonInfo() const; 
 
        Json::Value BasePropertiesJSON(int64_t requested_frame) const;
 
        std::shared_ptr<openshot::Frame> ProcessFrame(std::shared_ptr<openshot::Frame> frame, int64_t frame_number);
 
        ReaderBase* MaskReader() { return mask_reader; }
        const ReaderBase* MaskReader() const { return mask_reader; }
 
        void MaskReader(ReaderBase* new_reader);
 
        std::string MaskSourceId() const { return mask_source_id; }
        void MaskSourceId(const std::string& new_mask_source_id);
 
        int Order() const { return order; }
 
        void Order(int new_order) { order = new_order; }
 
        virtual ~EffectBase();
    };
 
}
 
#endif