X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fplaylist.h;h=9e15b9cf5d10795f2d283d93eb866a3d12e296ea;hb=cd2047cbffc5e0270acab555364bb9d958fe7927;hp=4640a8e32fbed7b3e54063b31db2a093b8389f47;hpb=859e9106e72a7908fa093d946111d148223225a0;p=ardour.git

diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h
index 4640a8e32f..9e15b9cf5d 100644
--- a/libs/ardour/ardour/playlist.h
+++ b/libs/ardour/ardour/playlist.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000 Paul Davis 
+    Copyright (C) 2000 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
@@ -26,38 +26,78 @@
 #include <list>
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
+#include <boost/utility.hpp>
 
 #include <sys/stat.h>
 
 #include <glib.h>
 
-#include <sigc++/signal.h>
 
-#include <pbd/undo.h>
-#include <pbd/stateful.h> 
-#include <pbd/statefuldestructible.h> 
+#include "pbd/undo.h"
+#include "pbd/stateful.h"
+#include "pbd/statefuldestructible.h"
+#include "pbd/sequence_property.h"
 
-#include <ardour/ardour.h>
-#include <ardour/session_object.h>
-#include <ardour/crossfade_compare.h>
-#include <ardour/location.h>
-#include <ardour/data_type.h>
+#include "evoral/types.hpp"
+
+#include "ardour/ardour.h"
+#include "ardour/session_object.h"
+#include "ardour/data_type.h"
 
 namespace ARDOUR  {
 
 class Session;
 class Region;
+class Playlist;
+class Crossfade;
+
+namespace Properties {
+	/* fake the type, since regions are handled by SequenceProperty which doesn't
+	   care about such things.
+	*/
+	extern PBD::PropertyDescriptor<bool> regions;
+}
 
-class Playlist : public SessionObject, public boost::enable_shared_from_this<Playlist> {
+class RegionListProperty : public PBD::SequenceProperty<std::list<boost::shared_ptr<Region> > >
+{
   public:
-	typedef list<boost::shared_ptr<Region> >    RegionList;
+	RegionListProperty (Playlist&);
+
+	RegionListProperty* clone () const;
+	void get_content_as_xml (boost::shared_ptr<Region>, XMLNode &) const;
+	boost::shared_ptr<Region> get_content_from_xml (XMLNode const &) const;
+
+  private:
+	RegionListProperty* create () const;
+
+	/* copy construction only by ourselves */
+	RegionListProperty (RegionListProperty const & p);
+
+	friend class Playlist;
+	/* we live and die with our playlist, no lifetime management needed */
+	Playlist& _playlist;
+};
+
+class Playlist : public SessionObject , public boost::enable_shared_from_this<Playlist>
+{
+public:
+	typedef std::list<boost::shared_ptr<Region> > RegionList;
+	static void make_property_quarks ();
 
 	Playlist (Session&, const XMLNode&, DataType type, bool hidden = false);
-	Playlist (Session&, string name, DataType type, bool hidden = false);
-	Playlist (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
-	Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
+	Playlist (Session&, std::string name, DataType type, bool hidden = false);
+	Playlist (boost::shared_ptr<const Playlist>, std::string name, bool hidden = false);
+	Playlist (boost::shared_ptr<const Playlist>, framepos_t start, framecnt_t cnt, std::string name, bool hidden = false);
+
+	virtual ~Playlist ();
 
-	virtual ~Playlist ();  
+	void update (const RegionListProperty::ChangeRecord&);
+	void clear_owned_changes ();
+	void rdiff (std::vector<Command*>&) const;
+
+	boost::shared_ptr<Region> region_by_id (const PBD::ID&) const;
+
+	uint32_t max_source_level () const;
 
 	void set_region_ownership ();
 
@@ -68,7 +108,8 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	void release();
 	bool used () const { return _refcnt != 0; }
 
-	bool set_name (const string& str);
+	bool set_name (const std::string& str);
+	int sort_id() { return _sort_id; }
 
 	const DataType& data_type() const { return _type; }
 
@@ -78,7 +119,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	bool hidden() const { return _hidden; }
 	bool empty() const;
 	uint32_t n_regions() const;
-	nframes_t get_maximum_extent () const;
+	std::pair<framepos_t, framepos_t> get_extent () const;
 	layer_t top_layer() const;
 
 	EditMode get_edit_mode() const { return _edit_mode; }
@@ -86,107 +127,158 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 
 	/* Editing operations */
 
-	void add_region (boost::shared_ptr<Region>, nframes_t position, float times = 1);
+	void add_region (boost::shared_ptr<Region>, framepos_t position, float times = 1, bool auto_partition = false);
 	void remove_region (boost::shared_ptr<Region>);
+	void remove_region_by_source (boost::shared_ptr<Source>);
 	void get_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
 	void get_region_list_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
-	void replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, nframes_t pos);
-	void split_region (boost::shared_ptr<Region>, nframes_t position);
-	void partition (nframes_t start, nframes_t end, bool just_top_level);
-	void duplicate (boost::shared_ptr<Region>, nframes_t position, float times);
-	void nudge_after (nframes_t start, nframes_t distance, bool forwards);
+	void replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos);
+	void split_region (boost::shared_ptr<Region>, framepos_t position);
+	void split (framepos_t at);
+	void shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue);
+	void partition (framepos_t start, framepos_t end, bool cut = false);
+	void duplicate (boost::shared_ptr<Region>, framepos_t position, float times);
+	void nudge_after (framepos_t start, framecnt_t distance, bool forwards);
+	boost::shared_ptr<Region> combine (const RegionList&);
+	void uncombine (boost::shared_ptr<Region>);
+
 	void shuffle (boost::shared_ptr<Region>, int dir);
 	void update_after_tempo_map_change ();
 
-	boost::shared_ptr<Playlist> cut  (list<AudioRange>&, bool result_is_hidden = true);
-	boost::shared_ptr<Playlist> copy (list<AudioRange>&, bool result_is_hidden = true);
-	int                         paste (boost::shared_ptr<Playlist>, nframes_t position, float times);
+	boost::shared_ptr<Playlist> cut  (std::list<AudioRange>&, bool result_is_hidden = true);
+	boost::shared_ptr<Playlist> copy (std::list<AudioRange>&, bool result_is_hidden = true);
+	int                         paste (boost::shared_ptr<Playlist>, framepos_t position, float times);
 
-	RegionList*                regions_at (nframes_t frame);
-	RegionList*                regions_touched (nframes_t start, nframes_t end);
-	RegionList*                regions_to_read (nframes_t start, nframes_t end);
+	const RegionListProperty& region_list () const { return regions; }
+
+	RegionList*                regions_at (framepos_t frame);
+	uint32_t                   count_regions_at (framepos_t) const;
+	uint32_t                   count_joined_regions () const;
+	RegionList*                regions_touched (framepos_t start, framepos_t end);
+	RegionList*                regions_to_read (framepos_t start, framepos_t end);
+	uint32_t                   region_use_count (boost::shared_ptr<Region>) const;
 	boost::shared_ptr<Region>  find_region (const PBD::ID&) const;
-	boost::shared_ptr<Region>  top_region_at (nframes_t frame);
-	boost::shared_ptr<Region>  find_next_region (nframes_t frame, RegionPoint point, int dir);
-	nframes64_t                find_next_region_boundary (nframes64_t frame, int dir);
+	boost::shared_ptr<Region>  top_region_at (framepos_t frame);
+	boost::shared_ptr<Region>  top_unmuted_region_at (framepos_t frame);
+	boost::shared_ptr<Region>  find_next_region (framepos_t frame, RegionPoint point, int dir);
+	framepos_t                 find_next_region_boundary (framepos_t frame, int dir);
 	bool                       region_is_shuffle_constrained (boost::shared_ptr<Region>);
+	bool                       has_region_at (framepos_t const) const;
+
+	bool uses_source (boost::shared_ptr<const Source> src) const;
 
-	nframes64_t find_next_transient (nframes64_t position, int dir);
+	framepos_t find_next_transient (framepos_t position, int dir);
 
-	template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>, void *), void *arg);
-	template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>));
+	void foreach_region (boost::function<void (boost::shared_ptr<Region>)>);
 
 	XMLNode& get_state ();
-	int set_state (const XMLNode&);
+	int set_state (const XMLNode&, int version);
 	XMLNode& get_template ();
 
-	sigc::signal<void,bool> InUse;
-	sigc::signal<void>      Modified;
-	sigc::signal<void>      NameChanged;
-	sigc::signal<void>      LengthChanged;
+	PBD::Signal1<void,bool> InUse;
+	PBD::Signal0<void>      ContentsChanged;
+	PBD::Signal1<void,boost::weak_ptr<Region> > RegionAdded;
+	PBD::Signal1<void,boost::weak_ptr<Region> > RegionRemoved;
+	PBD::Signal0<void>      NameChanged;
+	PBD::Signal0<void>      LengthChanged;
+	PBD::Signal0<void>      LayeringChanged;
 
-	static string bump_name (string old_name, Session&);
+	/** Emitted when regions have moved (not when regions have only been trimmed) */
+	PBD::Signal2<void,std::list< Evoral::RangeMove<framepos_t> > const &, bool> RangesMoved;
+
+	/** Emitted when regions are extended; the ranges passed are the new extra time ranges
+	    that these regions now occupy.
+	*/
+	PBD::Signal1<void,std::list< Evoral::Range<framepos_t> > const &> RegionsExtended;
+
+	static std::string bump_name (std::string old_name, Session&);
 
 	void freeze ();
-	void thaw ();
+	void thaw (bool from_undo = false);
 
 	void raise_region (boost::shared_ptr<Region>);
 	void lower_region (boost::shared_ptr<Region>);
 	void raise_region_to_top (boost::shared_ptr<Region>);
 	void lower_region_to_bottom (boost::shared_ptr<Region>);
 
-	uint32_t read_data_count() const { return _read_data_count; }
-
+	/* XXX: use of diskstream here is a little unfortunate */
 	const PBD::ID& get_orig_diskstream_id () const { return _orig_diskstream_id; }
-	void set_orig_diskstream_id (const PBD::ID& did) { _orig_diskstream_id = did; }  
+	void set_orig_diskstream_id (const PBD::ID& did) { _orig_diskstream_id = did; }
 
 	/* destructive editing */
-	
+
 	virtual bool destroy_region (boost::shared_ptr<Region>) = 0;
 
+	void sync_all_regions_with_regions ();
+
 	/* special case function used by UI selection objects, which have playlists that actually own the regions
 	   within them.
 	*/
 
 	void drop_regions ();
 
+	bool explicit_relayering () const {
+		return _explicit_relayering;
+	}
+
+	void set_explicit_relayering (bool e);
+
+	virtual boost::shared_ptr<Crossfade> find_crossfade (const PBD::ID &) const {
+		return boost::shared_ptr<Crossfade> ();
+	}
+
+	framepos_t find_next_top_layer_position (framepos_t) const;
+	uint32_t combine_ops() const { return _combine_ops; }
+
   protected:
 	friend class Session;
 
   protected:
 	struct RegionLock {
-	    RegionLock (Playlist *pl, bool do_block_notify = true) : playlist (pl), block_notify (do_block_notify) {
-		    playlist->region_lock.lock();
-		    if (block_notify) {
-			    playlist->delay_notifications();
-		    }
-	    }
-	    ~RegionLock() { 
-		    playlist->region_lock.unlock();
-		    if (block_notify) {
-			    playlist->release_notifications ();
-		    }
-	    }
-	    Playlist *playlist;
-	    bool block_notify;
+		RegionLock (Playlist *pl, bool do_block_notify = true) : playlist (pl), block_notify (do_block_notify) {
+			playlist->region_lock.lock();
+			if (block_notify) {
+				playlist->delay_notifications();
+			}
+		}
+		~RegionLock() {
+			playlist->region_lock.unlock();
+			if (block_notify) {
+				playlist->release_notifications ();
+			}
+		}
+		Playlist *playlist;
+		bool block_notify;
 	};
 
 	friend class RegionLock;
 
-	RegionList       regions;  /* the current list of regions in the playlist */
+	RegionListProperty   regions;  /* the current list of regions in the playlist */
 	std::set<boost::shared_ptr<Region> > all_regions; /* all regions ever added to this playlist */
+	PBD::ScopedConnectionList region_state_changed_connections;
 	DataType        _type;
+	int             _sort_id;
 	mutable gint    block_notifications;
 	mutable gint    ignore_state_changes;
-	mutable Glib::Mutex region_lock;
+	mutable Glib::RecMutex region_lock;
 	std::set<boost::shared_ptr<Region> > pending_adds;
 	std::set<boost::shared_ptr<Region> > pending_removes;
 	RegionList       pending_bounds;
-	bool             pending_modified;
+	bool             pending_contents_change;
+	bool             pending_layering;
 	bool             pending_length;
+
+	/** Movements of time ranges caused by region moves; note that
+	 *  region trims are not included in this list; it is used to
+	 *  do automation-follows-regions.
+	 */
+	std::list< Evoral::RangeMove<framepos_t> > pending_range_moves;
+	/** Extra sections added to regions during trims */
+	std::list< Evoral::Range<framepos_t> >     pending_region_extensions;
 	bool             save_on_thaw;
-	string           last_save_reason;
+	std::string      last_save_reason;
 	uint32_t         in_set_state;
+	bool             in_update;
 	bool             first_set_state;
 	bool            _hidden;
 	bool            _splicing;
@@ -198,82 +290,111 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	bool             in_partition;
 	bool            _frozen;
 	uint32_t         subcnt;
-	uint32_t        _read_data_count;
 	PBD::ID         _orig_diskstream_id;
 	uint64_t         layer_op_counter;
-	nframes_t   freeze_length;
+	framecnt_t       freeze_length;
+	bool             auto_partition;
+	uint32_t        _combine_ops;
+
+	/** true if relayering should be done using region's current layers and their `pending explicit relayer'
+	 *  flags; otherwise false if relayering should be done using the layer-model (most recently moved etc.)
+	 *  Explicit relayering is used by tracks in stacked regionview mode.
+	 */
+	bool            _explicit_relayering;
 
 	void init (bool hide);
 
-	bool holding_state () const { 
+	bool holding_state () const {
 		return g_atomic_int_get (&block_notifications) != 0 ||
 			g_atomic_int_get (&ignore_state_changes) != 0;
 	}
 
-	/* prevent the compiler from ever generating these */
-
-	Playlist (const Playlist&);
-	Playlist (Playlist&);
-
 	void delay_notifications ();
-	void release_notifications ();
-	virtual void flush_notifications ();
+	void release_notifications (bool from_undo = false);
+	virtual void flush_notifications (bool from_undo = false);
+	void clear_pending ();
+
+	void _set_sort_id ();
 
 	void notify_region_removed (boost::shared_ptr<Region>);
 	void notify_region_added (boost::shared_ptr<Region>);
 	void notify_length_changed ();
 	void notify_layering_changed ();
-	void notify_modified ();
-	void notify_state_changed (Change);
+	void notify_contents_changed ();
+	void notify_state_changed (const PBD::PropertyChange&);
+	void notify_region_moved (boost::shared_ptr<Region>);
+	void notify_region_start_trimmed (boost::shared_ptr<Region>);
+	void notify_region_end_trimmed (boost::shared_ptr<Region>);
 
 	void mark_session_dirty();
 
-	void region_changed_proxy (Change, boost::weak_ptr<Region>);
-	virtual bool region_changed (Change, boost::shared_ptr<Region>);
+	void region_changed_proxy (const PBD::PropertyChange&, boost::weak_ptr<Region>);
+	virtual bool region_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
 
-	void region_bounds_changed (Change, boost::shared_ptr<Region>);
+	void region_bounds_changed (const PBD::PropertyChange&, boost::shared_ptr<Region>);
 	void region_deleted (boost::shared_ptr<Region>);
 
 	void sort_regions ();
 
-	void possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude = boost::shared_ptr<Region>());
-	void possibly_splice_unlocked(nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude = boost::shared_ptr<Region>());
+	void possibly_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude = boost::shared_ptr<Region>());
+	void possibly_splice_unlocked(framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude = boost::shared_ptr<Region>());
+
+	void core_splice (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude);
+	void splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude);
+	void splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr<Region> exclude);
 
-	void core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
-	void splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
-	void splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
+	virtual void finalize_split_region (boost::shared_ptr<Region> /*original*/, boost::shared_ptr<Region> /*left*/, boost::shared_ptr<Region> /*right*/) {}
 
-	virtual void finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right) {}
-	
-	virtual void check_dependents (boost::shared_ptr<Region> region, bool norefresh) {}
-	virtual void refresh_dependents (boost::shared_ptr<Region> region) {}
-	virtual void remove_dependents (boost::shared_ptr<Region> region) {}
+	virtual void check_dependents (boost::shared_ptr<Region> /*region*/, bool /*norefresh*/) {}
+	virtual void refresh_dependents (boost::shared_ptr<Region> /*region*/) {}
+	virtual void remove_dependents (boost::shared_ptr<Region> /*region*/) {}
 
 	virtual XMLNode& state (bool);
 
-	boost::shared_ptr<Region> region_by_id (PBD::ID);
+	bool add_region_internal (boost::shared_ptr<Region>, framepos_t position);
 
-	void add_region_internal (boost::shared_ptr<Region>, nframes_t position);
-	
 	int remove_region_internal (boost::shared_ptr<Region>);
-	RegionList *find_regions_at (nframes_t frame);
+	RegionList *find_regions_at (framepos_t);
 	void copy_regions (RegionList&) const;
-	void partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist);
+	void partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist);
 
-	nframes_t _get_maximum_extent() const;
+	std::pair<framepos_t, framepos_t> _get_extent() const;
 
-	boost::shared_ptr<Playlist> cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t, bool), 
-					      list<AudioRange>& ranges, bool result_is_hidden);
-	boost::shared_ptr<Playlist> cut (nframes_t start, nframes_t cnt, bool result_is_hidden);
-	boost::shared_ptr<Playlist> copy (nframes_t start, nframes_t cnt, bool result_is_hidden);
+	boost::shared_ptr<Playlist> cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t, framecnt_t, bool),
+					      std::list<AudioRange>& ranges, bool result_is_hidden);
+	boost::shared_ptr<Playlist> cut (framepos_t start, framecnt_t cnt, bool result_is_hidden);
+	boost::shared_ptr<Playlist> copy (framepos_t start, framecnt_t cnt, bool result_is_hidden);
 
 	int move_region_to_layer (layer_t, boost::shared_ptr<Region> r, int dir);
 	void relayer ();
-	
+
+	void begin_undo ();
+	void end_undo ();
 	void unset_freeze_parent (Playlist*);
 	void unset_freeze_child (Playlist*);
 
 	void timestamp_layer_op (boost::shared_ptr<Region>);
+
+	void _split_region (boost::shared_ptr<Region>, framepos_t position);
+
+	typedef std::pair<boost::shared_ptr<Region>, boost::shared_ptr<Region> > TwoRegions;
+	virtual void copy_dependents (const std::vector<TwoRegions>&, Playlist*) const { }
+
+	struct RegionInfo {
+	    boost::shared_ptr<Region> region;
+	    framepos_t position;
+	    framecnt_t length;
+	    framepos_t start;
+	};
+
+	/* this is called before we create a new compound region */
+	virtual void pre_combine (std::vector<boost::shared_ptr<Region> >&) {}
+	/* this is called before we create a new compound region */
+	virtual void post_combine (std::vector<boost::shared_ptr<Region> >&, boost::shared_ptr<Region>) {}
+	/* this is called before we remove a compound region and replace it
+	   with its constituent regions
+	*/
+	virtual void pre_uncombine (std::vector<boost::shared_ptr<Region> >&, boost::shared_ptr<Region>) {}
 };
 
 } /* namespace ARDOUR */