X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fregion.h;h=ef86dce4b2c3984d6d9923920f07042c4e107c10;hb=ba0458cf1f6c69366e89631d8fff916ad183d768;hp=8ab99fa1514268b6c32c329511ea101837e9ffe3;hpb=45d3ec1437cf661533bc7750c623865def4424df;p=ardour.git diff --git a/libs/ardour/ardour/region.h b/libs/ardour/ardour/region.h index 8ab99fa151..ef86dce4b2 100644 --- a/libs/ardour/ardour/region.h +++ b/libs/ardour/ardour/region.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2001 Paul Davis + Copyright (C) 2000-2001 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -20,19 +20,57 @@ #ifndef __ardour_region_h__ #define __ardour_region_h__ +#include #include #include +#include -#include -#include +#include "pbd/undo.h" +#include "pbd/signals.h" -#include +#include "ardour/ardour.h" +#include "ardour/data_type.h" +#include "ardour/automatable.h" +#include "ardour/movable.h" +#include "ardour/readable.h" +#include "ardour/session_object.h" +#include "ardour/trimmable.h" class XMLNode; + namespace ARDOUR { +namespace Properties { + extern PBD::PropertyDescriptor muted; + extern PBD::PropertyDescriptor opaque; + extern PBD::PropertyDescriptor locked; + extern PBD::PropertyDescriptor automatic; + extern PBD::PropertyDescriptor whole_file; + extern PBD::PropertyDescriptor import; + extern PBD::PropertyDescriptor external; + extern PBD::PropertyDescriptor sync_marked; + extern PBD::PropertyDescriptor left_of_split; + extern PBD::PropertyDescriptor right_of_split; + extern PBD::PropertyDescriptor hidden; + extern PBD::PropertyDescriptor position_locked; + extern PBD::PropertyDescriptor valid_transients; + extern PBD::PropertyDescriptor start; + extern PBD::PropertyDescriptor length; + extern PBD::PropertyDescriptor position; + extern PBD::PropertyDescriptor sync_position; + extern PBD::PropertyDescriptor layer; + extern PBD::PropertyDescriptor ancestral_start; + extern PBD::PropertyDescriptor ancestral_length; + extern PBD::PropertyDescriptor stretch; + extern PBD::PropertyDescriptor shift; + extern PBD::PropertyDescriptor position_lock_style; +}; + class Playlist; +class Filter; +class ExportSpecification; +class Progress; enum RegionEditState { EditChangesNothing = 0, @@ -40,185 +78,313 @@ enum RegionEditState { EditChangesID = 2 }; -class Region : public PBD::StatefulDestructible, public boost::enable_shared_from_this + +class Region + : public SessionObject + , public boost::enable_shared_from_this + , public Readable + , public Trimmable + , public Movable { public: - enum Flag { - Muted = 0x1, - Opaque = 0x2, - EnvelopeActive = 0x4, - DefaultFadeIn = 0x8, - DefaultFadeOut = 0x10, - Locked = 0x20, - Automatic = 0x40, - WholeFile = 0x80, - FadeIn = 0x100, - FadeOut = 0x200, - Copied = 0x400, - Import = 0x800, - External = 0x1000, - SyncMarked = 0x2000, - LeftOfSplit = 0x4000, - RightOfSplit = 0x8000, - Hidden = 0x10000, - DoNotSaveState = 0x20000, - // - range_guarantoor = USHRT_MAX - }; - - static const Flag DefaultFlags = Flag (Opaque|DefaultFadeIn|DefaultFadeOut|FadeIn|FadeOut); - - static Change FadeChanged; - static Change SyncOffsetChanged; - static Change MuteChanged; - static Change OpacityChanged; - static Change LockChanged; - static Change LayerChanged; - static Change HiddenChanged; - - sigc::signal StateChanged; + typedef std::vector > SourceList; + + static void make_property_quarks (); + + static PBD::Signal2, const PBD::PropertyChange&> RegionPropertyChanged; virtual ~Region(); + + /** Note: changing the name of a Region does not constitute an edit */ + bool set_name (const std::string& str); - /* Note: changing the name of a Region does not constitute an edit */ + const DataType& data_type() const { return _type; } + + AnalysisFeatureList transients () { return _transients; }; - string name() const { return _name; } - void set_name (string str); + /** How the region parameters play together: + * + * POSITION: first frame of the region along the timeline + * START: first frame of the region within its source(s) + * LENGTH: number of frames the region represents + */ + framepos_t position () const { return _position; } + framepos_t start () const { return _start; } + framecnt_t length() const { return _length; } + layer_t layer () const { return _layer; } - nframes_t position () const { return _position; } - nframes_t start () const { return _start; } - nframes_t length() const { return _length; } - layer_t layer () const { return _layer; } - - nframes_t sync_offset(int& dir) const; - nframes_t sync_position() const; + framecnt_t source_length(uint32_t n) const; - nframes_t adjust_to_sync (nframes_t); - - /* first_frame() is an alias; last_frame() just hides some math */ + /* these two are valid ONLY during a StateChanged signal handler */ - nframes_t first_frame() const { return _position; } - nframes_t last_frame() const { return _position + _length - 1; } + framepos_t last_position() const { return _last_position; } + framecnt_t last_length() const { return _last_length; } - bool hidden() const { return _flags & Hidden; } - bool muted() const { return _flags & Muted; } - bool opaque () const { return _flags & Opaque; } - bool locked() const { return _flags & Locked; } - bool automatic() const { return _flags & Automatic; } - bool whole_file() const { return _flags & WholeFile ; } - Flag flags() const { return _flags; } + framepos_t ancestral_start () const { return _ancestral_start; } + framecnt_t ancestral_length () const { return _ancestral_length; } + float stretch() const { return _stretch; } + float shift() const { return _shift; } - virtual bool should_save_state () const { return !(_flags & DoNotSaveState); }; + void set_ancestral_data (framepos_t start, framepos_t length, float stretch, float shift); + + frameoffset_t sync_offset(int& dir) const; + framepos_t sync_position() const; + framepos_t sync_point () const; + + framepos_t adjust_to_sync (framepos_t) const; - void freeze (); - void thaw (const string& why); + /* first_frame() is an alias; last_frame() just hides some math */ - bool covers (nframes_t frame) const { - return first_frame() <= frame && frame < last_frame(); + framepos_t first_frame() const { return _position; } + framepos_t last_frame() const { return _position + _length - 1; } + + bool hidden() const { return _hidden; } + bool muted() const { return _muted; } + bool opaque () const { return _opaque; } + bool locked() const { return _locked; } + bool position_locked() const { return _position_locked; } + bool valid_transients() const { return _valid_transients; } + bool automatic() const { return _automatic; } + bool whole_file() const { return _whole_file; } + bool captured() const { return !(_import || _external); } + bool can_move() const { return !_position_locked; } + bool sync_marked() const { return _sync_marked; } + bool external() const { return _external; } + bool import() const { return _import; } + + Trimmable::CanTrim can_trim() const; + + PositionLockStyle position_lock_style() const { return _position_lock_style; } + void set_position_lock_style (PositionLockStyle ps); + void recompute_position_from_lock_style (); + + void suspend_property_changes (); + + bool covers (framepos_t frame) const { + return first_frame() <= frame && frame <= last_frame(); } - OverlapType coverage (nframes_t start, nframes_t end) const { + OverlapType coverage (framepos_t start, framepos_t end) const { return ARDOUR::coverage (first_frame(), last_frame(), start, end); } - + bool equivalent (boost::shared_ptr) const; bool size_equivalent (boost::shared_ptr) const; bool overlap_equivalent (boost::shared_ptr) const; bool region_list_equivalent (boost::shared_ptr) const; - virtual bool source_equivalent (boost::shared_ptr) const = 0; - - virtual bool speed_mismatch (float) const = 0; + bool source_equivalent (boost::shared_ptr) const; + bool uses_source (boost::shared_ptr) const; /* EDITING OPERATIONS */ - void set_length (nframes_t, void *src); - void set_start (nframes_t, void *src); - void set_position (nframes_t, void *src); - void set_position_on_top (nframes_t, void *src); - void special_set_position (nframes_t); - void nudge_position (long, void *src); + void set_length (framecnt_t, void *src); + void set_start (framepos_t, void *src); + void set_position (framepos_t, void *src); + void set_position_on_top (framepos_t, void *src); + void special_set_position (framepos_t); + void update_position_after_tempo_map_change (); + void nudge_position (frameoffset_t, void *src); bool at_natural_position () const; void move_to_natural_position (void *src); - void trim_start (nframes_t new_position, void *src); - void trim_front (nframes_t new_position, void *src); - void trim_end (nframes_t new_position, void *src); - void trim_to (nframes_t position, nframes_t length, void *src); - + void trim_start (framepos_t new_position, void *src); + void trim_front (framepos_t new_position, void *src); + void trim_end (framepos_t new_position, void *src); + void trim_to (framepos_t position, framecnt_t length, void *src); + + void cut_front (nframes_t new_position, void *src); + void cut_end (nframes_t new_position, void *src); + void set_layer (layer_t l); /* ONLY Playlist can call this */ void raise (); void lower (); void raise_to_top (); void lower_to_bottom (); - void set_sync_position (nframes_t n); + void set_sync_position (framepos_t n); void clear_sync_position (); void set_hidden (bool yn); void set_muted (bool yn); + void set_whole_file (bool yn); + void set_automatic (bool yn); void set_opaque (bool yn); void set_locked (bool yn); + void set_position_locked (bool yn); + + int apply (Filter &, Progress* progress = 0); - virtual uint32_t read_data_count() const { return _read_data_count; } + virtual uint64_t read_data_count() const { return _read_data_count; } boost::shared_ptr playlist() const { return _playlist.lock(); } virtual void set_playlist (boost::weak_ptr); + void source_deleted (boost::weak_ptr); + + boost::shared_ptr source (uint32_t n=0) const { return _sources[ (n < _sources.size()) ? n : 0 ]; } + uint32_t n_channels() const { return _sources.size(); } + + const SourceList& sources() const { return _sources; } + const SourceList& master_sources() const { return _master_sources; } + + std::vector master_source_names(); + void set_master_sources (const SourceList&); + + /* automation */ + + virtual boost::shared_ptr + control(const Evoral::Parameter& id, bool create=false) = 0; + + virtual boost::shared_ptr + control(const Evoral::Parameter& id) const = 0; + /* serialization */ - + XMLNode& get_state (); - virtual XMLNode& state (bool); - virtual int set_state (const XMLNode&); - virtual int set_live_state (const XMLNode&, Change&, bool send); + virtual XMLNode& state (); + virtual int set_state (const XMLNode&, int version); + + virtual boost::shared_ptr get_parent() const; - virtual boost::shared_ptr get_parent() const = 0; - uint64_t last_layer_op() const { return _last_layer_op; } void set_last_layer_op (uint64_t when); + virtual bool is_dependent() const { return false; } + virtual bool depends_on (boost::shared_ptr /*other*/) const { return false; } + + virtual int exportme (ARDOUR::Session&, ARDOUR::ExportSpecification&) = 0; + + virtual void add_transient (framepos_t) { + // no transients, but its OK + } + + virtual int update_transient (framepos_t /* old_position */, framepos_t /* new_position */) { + // no transients, but its OK + return 0; + } + + virtual void remove_transient (framepos_t /* where */) { + // no transients, but its OK + } + + virtual int set_transients (AnalysisFeatureList&) { + // no transients, but its OK + return 0; + } + + virtual int get_transients (AnalysisFeatureList&, bool force_new = false) { + (void) force_new; + // no transients, but its OK + return 0; + } + + virtual int adjust_transients (framepos_t /*delta*/) { + // no transients, but its OK + return 0; + } + + virtual int separate_by_channel (ARDOUR::Session&, + std::vector< boost::shared_ptr >&) const { + return 0; + } + + void invalidate_transients (); + + void set_pending_explicit_relayer (bool p) { + _pending_explicit_relayer = p; + } + + bool pending_explicit_relayer () const { + return _pending_explicit_relayer; + } + + void drop_sources (); + protected: friend class RegionFactory; - Region (nframes_t start, nframes_t length, - const string& name, layer_t = 0, Flag flags = DefaultFlags); - Region (boost::shared_ptr, nframes_t start, nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags); + /** Construct a region from multiple sources*/ + Region (const SourceList& srcs); + /** Construct a region from another region, at an offset within that region */ + Region (boost::shared_ptr, frameoffset_t start_offset = 0, bool start_relative = true); + /** Construct a region as a copy of another region, but with different sources */ + Region (boost::shared_ptr, const SourceList&); + /** normal Region copy constructor */ Region (boost::shared_ptr); - Region (const XMLNode&); + /** Constructor for derived types only */ + Region (Session& s, framepos_t start, framecnt_t length, const std::string& name, DataType); protected: - XMLNode& get_short_state (); /* used only by Session */ - - void send_change (Change); + void send_change (const PBD::PropertyChange&); + void mid_thaw (const PBD::PropertyChange&); - void trim_to_internal (nframes_t position, nframes_t length, void *src); + void trim_to_internal (framepos_t position, framecnt_t length, void *src); + virtual void set_position_internal (framepos_t pos, bool allow_bbt_recompute); + void modify_front (nframes_t new_position, bool reset_fade, void* src); + void modify_end (nframes_t new_position, bool reset_fade, void* src); - bool copied() const { return _flags & Copied; } void maybe_uncopy (); void first_edit (); - - virtual bool verify_start (nframes_t) = 0; - virtual bool verify_start_and_length (nframes_t, nframes_t) = 0; - virtual bool verify_start_mutable (nframes_t&_start) = 0; - virtual bool verify_length (nframes_t) = 0; + + bool verify_start (framepos_t); + bool verify_start_and_length (framepos_t, framecnt_t&); + bool verify_start_mutable (framepos_t&_start); + bool verify_length (framecnt_t); + virtual void recompute_at_start () = 0; virtual void recompute_at_end () = 0; - - nframes_t _start; - nframes_t _length; - nframes_t _position; - Flag _flags; - nframes_t _sync_position; - layer_t _layer; - string _name; + DataType _type; + + PBD::Property _muted; + PBD::Property _opaque; + PBD::Property _locked; + PBD::Property _automatic; + PBD::Property _whole_file; + PBD::Property _import; + PBD::Property _external; + PBD::Property _sync_marked; + PBD::Property _left_of_split; + PBD::Property _right_of_split; + PBD::Property _hidden; + PBD::Property _position_locked; + PBD::Property _valid_transients; + PBD::Property _start; + PBD::Property _length; + PBD::Property _position; + /** Sync position relative to the start of our file */ + PBD::Property _sync_position; + PBD::Property _layer; + PBD::Property _ancestral_start; + PBD::Property _ancestral_length; + PBD::Property _stretch; + PBD::Property _shift; + PBD::EnumProperty _position_lock_style; + + framecnt_t _last_length; + framepos_t _last_position; mutable RegionEditState _first_edit; - int _frozen; - Glib::Mutex lock; + BBT_Time _bbt_time; + AnalysisFeatureList _transients; + + mutable uint64_t _read_data_count; ///< modified in read() + uint64_t _last_layer_op; ///< timestamp + SourceList _sources; + /** Used when timefx are applied, so we can always use the original source */ + SourceList _master_sources; + + /** true if this region has had its layer explicitly set since the playlist last relayered */ + bool _pending_explicit_relayer; + boost::weak_ptr _playlist; - mutable uint32_t _read_data_count; // modified in read() - Change pending_changed; - uint64_t _last_layer_op; // timestamp + + virtual int _set_state (const XMLNode&, int version, PBD::PropertyChange& what_changed, bool send_signal); + + void register_properties (); + +protected: + void use_sources (SourceList const &); }; } /* namespace ARDOUR */