Timeline.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_TIMELINE_H
#define OPENSHOT_TIMELINE_H
 
#include <list>
#include <memory>
#include <mutex>
#include <set>
#include <QtGui/QImage>
#include <QtGui/QPainter>
#include <QtCore/QRegularExpression>
 
#include "TimelineBase.h"
#include "ReaderBase.h"
 
#include "Color.h"
#include "Clip.h"
#include "EffectBase.h"
#include "Fraction.h"
#include "Frame.h"
#include "KeyFrame.h"
#ifdef USE_OPENCV
#include "TrackedObjectBBox.h"
#endif
#include "TrackedObjectBase.h"
 
 
 
namespace openshot {
 
    // Forward decls
    class FrameMapper;
    class CacheBase;

    struct CompareClips {
        bool operator()(openshot::Clip* lhs, openshot::Clip* rhs) const {
            // Strict-weak ordering (no <=) to keep sort well-defined
            if (lhs == rhs) return false; // irreflexive
            if (lhs->Layer() != rhs->Layer())
                return lhs->Layer() < rhs->Layer();
            if (lhs->Position() != rhs->Position())
                return lhs->Position() < rhs->Position();
            // Stable tie-breaker on address to avoid equivalence when layer/position match
            return std::less<openshot::Clip*>()(lhs, rhs);
        }
    };

    struct CompareEffects{
        bool operator()( openshot::EffectBase* lhs, openshot::EffectBase* rhs){
            if( lhs->Layer() < rhs->Layer() ) return true;
            if( lhs->Layer() == rhs->Layer() && lhs->Position() < rhs->Position() ) return true;
            if( lhs->Layer() == rhs->Layer() && lhs->Position() == rhs->Position() && lhs->Order() > rhs->Order() ) return true;
            return false;
    }};

    struct CompareClipEndFrames {
        bool operator()(const openshot::Clip* lhs, const openshot::Clip* rhs) {
            return (lhs->Position() + lhs->Duration()) <= (rhs->Position() + rhs->Duration());
    }};

    struct CompareEffectEndFrames {
        bool operator()(const openshot::EffectBase* lhs, const openshot::EffectBase* rhs) {
            return (lhs->Position() + lhs->Duration()) <= (rhs->Position() + rhs->Duration());
    }};

    class Timeline : public openshot::TimelineBase, public openshot::ReaderBase {
    private:
        bool is_open; 
        bool auto_map_clips; 
        std::list<openshot::Clip*> clips; 
        std::list<openshot::Clip*> closing_clips; 
        std::map<openshot::Clip*, openshot::Clip*> open_clips; 
        std::set<openshot::Clip*> allocated_clips; 
        std::list<openshot::EffectBase*> effects; 
        std::set<openshot::EffectBase*> allocated_effects; 
        openshot::CacheBase *final_cache; 
        std::set<openshot::FrameMapper*> allocated_frame_mappers; 
        bool managed_cache; 
        std::string path; 
        double max_time; 
        double min_time; 
 
        std::map<std::string, std::shared_ptr<openshot::TrackedObjectBase>> tracked_objects; 

        void add_layer(std::shared_ptr<openshot::Frame> new_frame, openshot::Clip* source_clip, int64_t clip_frame_number, bool is_top_clip, float max_volume);

        void apply_mapper_to_clip(openshot::Clip* clip);
 
        // Apply JSON Diffs to various objects contained in this timeline
        void apply_json_to_clips(Json::Value change); 
        void apply_json_to_effects(Json::Value change); 
        void apply_json_to_effects(Json::Value change, openshot::EffectBase* existing_effect); 
        void apply_json_to_timeline(Json::Value change); 

        void calculate_max_duration();

        double calculate_time(int64_t number, openshot::Fraction rate);

        std::vector<openshot::Clip*> find_intersecting_clips(int64_t requested_frame, int number_of_frames, bool include);

        std::shared_ptr<openshot::Frame> GetOrCreateFrame(std::shared_ptr<Frame> background_frame, openshot::Clip* clip, int64_t number, openshot::TimelineInfoStruct* options);

        bool isEqual(double a, double b);

        void sort_clips();

        void sort_effects();

        void update_open_clips(openshot::Clip *clip, bool does_clip_intersect);
 
    public:

        Timeline(int width, int height, openshot::Fraction fps, int sample_rate, int channels, openshot::ChannelLayout channel_layout);

        Timeline(ReaderInfo info);

        Timeline(const std::string& projectPath, bool convert_absolute_paths);
 
        virtual ~Timeline();

        void AddTrackedObject(std::shared_ptr<openshot::TrackedObjectBase> trackedObject);
        std::shared_ptr<openshot::TrackedObjectBase> GetTrackedObject(std::string id) const;
        std::list<std::string> GetTrackedObjectsIds() const;
        #ifdef USE_OPENCV
        std::string GetTrackedObjectValues(std::string id, int64_t frame_number) const;
        #endif

        void AddClip(openshot::Clip* clip);

        void AddEffect(openshot::EffectBase* effect);

        std::shared_ptr<openshot::Frame> apply_effects(std::shared_ptr<openshot::Frame> frame, int64_t timeline_frame_number, int layer, TimelineInfoStruct* options);

        void ApplyMapperToClips();

        bool AutoMapClips() { return auto_map_clips; };

        void AutoMapClips(bool auto_map) { auto_map_clips = auto_map; };

        void Clear();

        void ClearAllCache(bool deep=false);

        std::list<openshot::Clip*> Clips() override { return clips; };

        openshot::Clip* GetClip(const std::string& id);

        openshot::EffectBase* GetClipEffect(const std::string& id);

        openshot::EffectBase* GetEffect(const std::string& id);

        double GetMaxTime();
        int64_t GetMaxFrame();

        double GetMinTime();
        int64_t GetMinFrame();

        void Close() override;

        std::list<openshot::EffectBase*> Effects() { return effects; };

        std::list<openshot::EffectBase*> ClipEffects() const;

        openshot::CacheBase* GetCache() override { return final_cache; };

        void SetCache(openshot::CacheBase* new_cache);

        std::shared_ptr<openshot::Frame> GetFrame(int64_t requested_frame) override;
 
        // Curves for the viewport
        openshot::Keyframe viewport_scale; 
        openshot::Keyframe viewport_x; 
        openshot::Keyframe viewport_y; 
 
        // Background color
        openshot::Color color; 

        bool IsOpen() override { return is_open; };

        std::string Name() override { return "Timeline"; };
 
        // Get and Set JSON methods
        std::string Json() const override; 
        void SetJson(const std::string value) override; 
        Json::Value JsonValue() const override; 
        void SetJsonValue(const Json::Value root) override; 

        void SetMaxSize(int width, int height);

        void ApplyJsonDiff(std::string value);

        void Open() override;

        void RemoveClip(openshot::Clip* clip);

        void RemoveEffect(openshot::EffectBase* effect);

        void SortTimeline() { sort_clips(); sort_effects(); }
    };
 
}
 
#endif // OPENSHOT_TIMELINE_H