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 <set>
#include <atomic>
#include <cstdint>
#include <utility>
 
#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::atomic<uint64_t> cache_epoch; 
 
        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);
 
        std::pair<float, float> ResolveTransitionAudioGains(openshot::Clip* source_clip, int64_t timeline_frame_number, bool is_top_clip) const;
 
        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);
 
        void BumpCacheEpoch();
 
        void InvalidateCacheForClip(const openshot::Clip* clip);
 
    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);
 
        uint64_t CacheEpoch() const { return cache_epoch.load(std::memory_order_relaxed); };
 
        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