Clip.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_CLIP_H
#define OPENSHOT_CLIP_H
 
#ifdef USE_OPENCV
    #define int64 opencv_broken_int
    #define uint64 opencv_broken_uint
    #include <opencv2/opencv.hpp>
    #include <opencv2/core.hpp>
    #undef uint64
    #undef int64
 
#endif
 
#include <memory>
#include <string>
 
#include "AudioLocation.h"
#include "ClipBase.h"
#include "ReaderBase.h"
 
#include "Color.h"
#include "Enums.h"
#include "EffectBase.h"
#include "EffectInfo.h"
#include "KeyFrame.h"
#include "TrackedObjectBase.h"
 
namespace openshot {
    class AudioResampler;
    class EffectInfo;
    class Frame;
 
    struct CompareClipEffects{
        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;
    }};
 
    class Clip : public openshot::ClipBase, public openshot::ReaderBase {
    protected:
        std::recursive_mutex getFrameMutex;
 
        AudioLocation previous_location;
 
        void init_settings();
 
        void init_reader_settings();
 
        void init_reader_rotation();
 
    private:
        enum class ReaderOrientationMode {
            Reader,
            LegacyClipTransform
        };
 
        bool waveform; 
        int waveform_mode; 
        ReaderOrientationMode reader_orientation_mode; 
        std::list<openshot::EffectBase*> effects; 
        bool is_open;   
        std::string parentObjectId; 
        std::shared_ptr<openshot::TrackedObjectBase> parentTrackedObject; 
        openshot::Clip* parentClipObject; 
 
        CacheMemory final_cache;
        
        // Audio resampler (if time mapping)
        openshot::AudioResampler *resampler;
 
        // File Reader object
        openshot::ReaderBase* reader;
 
        openshot::ReaderBase* allocated_reader;
 
        int64_t adjust_frame_number_minimum(int64_t frame_number);
 
        void apply_background(std::shared_ptr<openshot::Frame> frame,
                              std::shared_ptr<openshot::Frame> background_frame,
                              bool update_frame_image = true);
 
        void apply_effects(std::shared_ptr<openshot::Frame> frame, int64_t timeline_frame_number, TimelineInfoStruct* options, bool before_keyframes);
 
        void apply_keyframes(std::shared_ptr<Frame> frame, QSize timeline_size);
 
        void apply_waveform(std::shared_ptr<Frame> frame, QSize timeline_size);
 
        int64_t adjust_timeline_framenumber(int64_t clip_frame_number);
        
        QTransform get_transform(std::shared_ptr<Frame> frame, int width, int height);
 
        static std::string get_file_extension(std::string path);
 
        std::shared_ptr<openshot::Frame> GetOrCreateFrame(int64_t number, bool enable_time=true);
 
        double resolve_timeline_fps() const;
 
        int64_t curve_extent_frames() const;
 
        int64_t trim_extent_frames(double fps_value) const;
 
        void apply_timemapping(std::shared_ptr<openshot::Frame> frame);
 
        bool isNear(double a, double b);
 
        void sort_effects();
 
        QSize scale_size(QSize source_size, ScaleType source_scale, int target_width, int target_height);
 
    public:
        openshot::GravityType gravity;   
        openshot::ScaleType scale;       
        openshot::AnchorType anchor;     
        openshot::FrameDisplayType display; 
        openshot::VolumeMixType mixing;  
        openshot::CompositeType composite; 
 
        #ifdef USE_OPENCV
            bool COMPILED_WITH_CV = true;
        #else
            bool COMPILED_WITH_CV = false;
        #endif
 
        Clip();
 
        Clip(std::string path);
 
        static openshot::ReaderBase* CreateReader(std::string path, bool inspect_reader=true);
 
        Clip(openshot::ReaderBase* new_reader);
 
        virtual ~Clip();
 
        openshot::CacheMemory* GetCache() override { return &final_cache; };
 
        bool IsOpen() override { return is_open; };
 
        std::string GetAttachedId() const { return parentObjectId; };
        void SetAttachedId(std::string value) { parentObjectId = value; };
 
        void AttachToObject(std::string object_id);
 
        void SetAttachedObject(std::shared_ptr<openshot::TrackedObjectBase> trackedObject);
        void SetAttachedClip(Clip* clipObject);
        std::shared_ptr<openshot::TrackedObjectBase> GetAttachedObject() const { return parentTrackedObject; };
        Clip* GetAttachedClip() const { return parentClipObject; };
 
        std::string Name() override { return "Clip"; };
 
        void AddEffect(openshot::EffectBase* effect);
 
        void Close() override;
 
        openshot::Clip* GetParentClip();
 
        std::shared_ptr<openshot::TrackedObjectBase> GetParentTrackedObject();
 
        std::list<openshot::EffectBase*> Effects() { return effects; };
 
        openshot::EffectBase* GetEffect(const std::string& id);
 
        std::shared_ptr<openshot::Frame> GetFrame(int64_t clip_frame_number) override;
 
        std::shared_ptr<openshot::Frame> GetFrame(std::shared_ptr<openshot::Frame> background_frame, int64_t clip_frame_number) override;
 
        std::shared_ptr<openshot::Frame> GetFrame(std::shared_ptr<openshot::Frame> background_frame, int64_t clip_frame_number, openshot::TimelineInfoStruct* options);
 
        void Open() override;
 
        void Reader(openshot::ReaderBase* new_reader);
 
        openshot::ReaderBase* Reader();
 
        // Override End() position (in seconds) of clip (trim end of video)
        float End() const override; 
        void End(float value) override; 
        openshot::TimelineBase* ParentTimeline() override { return timeline; } 
        void ParentTimeline(openshot::TimelineBase* new_timeline) override; 
 
        // 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; 
 
        std::string PropertiesJSON(int64_t requested_frame) const override;
 
        void RemoveEffect(openshot::EffectBase* effect);
 
        // Waveform property
        bool Waveform() { return waveform; } 
        void Waveform(bool value) { waveform = value; } 
        int WaveformMode() { return waveform_mode; } 
        void WaveformMode(int value) { waveform_mode = value; } 
 
        // Scale, Location, and Alpha curves
        openshot::Keyframe scale_x; 
        openshot::Keyframe scale_y; 
        openshot::Keyframe location_x; 
        openshot::Keyframe location_y; 
        openshot::Keyframe alpha; 
 
        // Rotation and Shear curves (origin point (x,y) is adjustable for both rotation and shear)
        openshot::Keyframe rotation; 
        openshot::Keyframe shear_x; 
        openshot::Keyframe shear_y; 
        openshot::Keyframe origin_x; 
        openshot::Keyframe origin_y; 
 
        // Time and Volume curves
        openshot::Keyframe time; 
        openshot::Keyframe volume; 
 
        openshot::Color wave_color;
 
        // Perspective curves
        openshot::Keyframe perspective_c1_x; 
        openshot::Keyframe perspective_c1_y; 
        openshot::Keyframe perspective_c2_x; 
        openshot::Keyframe perspective_c2_y; 
        openshot::Keyframe perspective_c3_x; 
        openshot::Keyframe perspective_c3_y; 
        openshot::Keyframe perspective_c4_x; 
        openshot::Keyframe perspective_c4_y; 
 
        // Audio channel filter and mappings
        openshot::Keyframe channel_filter; 
        openshot::Keyframe channel_mapping; 
 
        // Override has_video and has_audio properties of clip (and their readers)
        openshot::Keyframe has_audio; 
        openshot::Keyframe has_video; 
    };
}  // namespace
 
#endif  // OPENSHOT_CLIP_H