From 548db7a9a4192e021425957d91be053806663061 Mon Sep 17 00:00:00 2001 From: Robin Gareus Date: Fri, 8 Jan 2021 17:16:38 +0100 Subject: [PATCH] NO-OP: code formatting and cleanup, thanks clang-format --- libs/ardour/ardour/playlist.h | 341 ++++---- libs/ardour/playlist.cc | 1396 ++++++++++++++++----------------- 2 files changed, 848 insertions(+), 889 deletions(-) diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h index 47b3438966..283b58aa0e 100644 --- a/libs/ardour/ardour/playlist.h +++ b/libs/ardour/ardour/playlist.h @@ -27,33 +27,33 @@ #ifndef __ardour_playlist_h__ #define __ardour_playlist_h__ -#include -#include -#include -#include -#include #include #include +#include #include +#include +#include +#include +#include #include #include -#include "pbd/undo.h" -#include "pbd/stateful.h" -#include "pbd/statefuldestructible.h" #include "pbd/sequence_property.h" #include "pbd/stacktrace.h" +#include "pbd/stateful.h" +#include "pbd/statefuldestructible.h" +#include "pbd/undo.h" #include "evoral/Range.h" #include "ardour/ardour.h" +#include "ardour/data_type.h" #include "ardour/region.h" #include "ardour/session_object.h" -#include "ardour/data_type.h" -namespace ARDOUR { +namespace ARDOUR { class Session; class Playlist; @@ -71,22 +71,22 @@ class LIBARDOUR_API RegionListProperty : public PBD::SequenceProperty, XMLNode &) const; - boost::shared_ptr get_content_from_xml (XMLNode const &) const; + RegionListProperty* clone () const; + void get_content_as_xml (boost::shared_ptr, XMLNode&) const; + boost::shared_ptr get_content_from_xml (XMLNode const&) const; private: RegionListProperty* create () const; /* copy construction only by ourselves */ - RegionListProperty (RegionListProperty const & p); + RegionListProperty (RegionListProperty const& p); friend class Playlist; /* we live and die with our playlist, no lifetime management needed */ Playlist& _playlist; }; -class LIBARDOUR_API Playlist : public SessionObject , public boost::enable_shared_from_this +class LIBARDOUR_API Playlist : public SessionObject, public boost::enable_shared_from_this { public: static void make_property_quarks (); @@ -106,45 +106,42 @@ public: uint32_t max_source_level () const; + bool set_name (const std::string& str); void set_region_ownership (); - virtual void clear (bool with_signals=true); + virtual void clear (bool with_signals = true); virtual void dump () const; - void use(); - void release(); - bool used () const { return _refcnt != 0; } + void use (); + void release (); - bool set_name (const std::string& str); - int sort_id() { return _sort_id; } + bool empty () const; + bool used () const { return _refcnt != 0; } + int sort_id () const { return _sort_id; } + bool frozen () const { return _frozen; } + const DataType& data_type () const { return _type; } + bool hidden () const { return _hidden; } + bool shared () const { return !_shared_with_ids.empty (); } + EditMode get_edit_mode () const { return _edit_mode; } - const DataType& data_type() const { return _type; } - - bool frozen() const { return _frozen; } void set_frozen (bool yn); + void set_edit_mode (EditMode); - void AddToSoloSelectedList(const Region*); - void RemoveFromSoloSelectedList(const Region*); - bool SoloSelectedListIncludes(const Region*); - bool SoloSelectedActive(); + void AddToSoloSelectedList (const Region*); + void RemoveFromSoloSelectedList (const Region*); + bool SoloSelectedListIncludes (const Region*); + bool SoloSelectedActive (); - bool hidden() const { return _hidden; } - bool empty() const; - - bool shared () const { return !_shared_with_ids.empty(); } void share_with (const PBD::ID&); void unshare_with (const PBD::ID&); bool shared_with (const PBD::ID&) const; void reset_shares (); - uint32_t n_regions() const; - bool all_regions_empty() const; + uint32_t n_regions () const; + bool all_regions_empty () const; std::pair get_extent () const; - std::pair get_extent_with_endspace() const; - layer_t top_layer() const; - - EditMode get_edit_mode() const { return _edit_mode; } - void set_edit_mode (EditMode); + std::pair get_extent_with_endspace () const; + layer_t top_layer () const; /* Editing operations */ @@ -164,27 +161,34 @@ public: void duplicate_range (AudioRange&, float times); void duplicate_ranges (std::list&, float times); void nudge_after (samplepos_t start, samplecnt_t distance, bool forwards); - boost::shared_ptr combine (const RegionList&); - void uncombine (boost::shared_ptr); void fade_range (std::list&); + boost::shared_ptr combine (const RegionList&); + void uncombine (boost::shared_ptr); + void shuffle (boost::shared_ptr, int dir); - void ripple (samplepos_t at, samplecnt_t distance, RegionList *exclude); - void ripple (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude) { - RegionList el; - if (exclude) - el.push_back (exclude); - ripple (at, distance, &el); + void ripple (samplepos_t at, samplecnt_t distance, RegionList* exclude); + void ripple (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude) + { + RegionList el; + if (exclude) { + el.push_back (exclude); + } + ripple (at, distance, &el); } void update_after_tempo_map_change (); - boost::shared_ptr cut (std::list&, bool result_is_hidden = true); + boost::shared_ptr cut (std::list&, bool result_is_hidden = true); boost::shared_ptr copy (std::list&, bool result_is_hidden = true); int paste (boost::shared_ptr, samplepos_t position, float times, const int32_t sub_num); - const RegionListProperty& region_list_property () const { return regions; } - boost::shared_ptr region_list(); + const RegionListProperty& region_list_property () const + { + return regions; + } + + boost::shared_ptr region_list (); boost::shared_ptr regions_at (samplepos_t sample); uint32_t count_regions_at (samplepos_t) const; @@ -196,40 +200,40 @@ public: boost::shared_ptr regions_touched (samplepos_t start, samplepos_t end); boost::shared_ptr regions_with_start_within (Evoral::Range); boost::shared_ptr regions_with_end_within (Evoral::Range); - uint32_t region_use_count (boost::shared_ptr) const; - boost::shared_ptr find_region (const PBD::ID&) const; - boost::shared_ptr top_region_at (samplepos_t sample); - boost::shared_ptr top_unmuted_region_at (samplepos_t sample); - boost::shared_ptr find_next_region (samplepos_t sample, RegionPoint point, int dir); - samplepos_t find_next_region_boundary (samplepos_t sample, int dir); - bool region_is_shuffle_constrained (boost::shared_ptr); - bool has_region_at (samplepos_t const) const; + uint32_t region_use_count (boost::shared_ptr) const; + boost::shared_ptr find_region (const PBD::ID&) const; + boost::shared_ptr top_region_at (samplepos_t sample); + boost::shared_ptr top_unmuted_region_at (samplepos_t sample); + boost::shared_ptr find_next_region (samplepos_t sample, RegionPoint point, int dir); + samplepos_t find_next_region_boundary (samplepos_t sample, int dir); + bool region_is_shuffle_constrained (boost::shared_ptr); + bool has_region_at (samplepos_t const) const; bool uses_source (boost::shared_ptr src, bool shallow = false) const; void deep_sources (std::set >&) const; samplepos_t find_next_transient (samplepos_t position, int dir); - void foreach_region (boost::function)>); + void foreach_region (boost::function)>); - XMLNode& get_state (); + XMLNode& get_state (); virtual int set_state (const XMLNode&, int version); - XMLNode& get_template (); + XMLNode& get_template (); - PBD::Signal1 InUse; - PBD::Signal0 ContentsChanged; - PBD::Signal1 > RegionAdded; - PBD::Signal1 > RegionRemoved; - PBD::Signal0 NameChanged; - PBD::Signal0 LayeringChanged; + PBD::Signal1 InUse; + PBD::Signal0 ContentsChanged; + PBD::Signal1 > RegionAdded; + PBD::Signal1 > RegionRemoved; + PBD::Signal0 NameChanged; + PBD::Signal0 LayeringChanged; /** Emitted when regions have moved (not when regions have only been trimmed) */ - PBD::Signal2 > const &, bool> RangesMoved; + PBD::Signal2 > const&, bool> RangesMoved; /** Emitted when regions are extended; the ranges passed are the new extra time ranges that these regions now occupy. */ - PBD::Signal1 > const &> RegionsExtended; + PBD::Signal1 > const&> RegionsExtended; static std::string bump_name (std::string old_name, Session&); @@ -241,8 +245,8 @@ public: void raise_region_to_top (boost::shared_ptr); void lower_region_to_bottom (boost::shared_ptr); - const PBD::ID& get_orig_track_id () const { return _orig_track_id; } void set_orig_track_id (const PBD::ID& did); + const PBD::ID& get_orig_track_id () const { return _orig_track_id; } /* destructive editing */ @@ -256,12 +260,16 @@ public: void drop_regions (); - virtual boost::shared_ptr find_crossfade (const PBD::ID &) const { + virtual boost::shared_ptr find_crossfade (const PBD::ID&) const + { return boost::shared_ptr (); } samplepos_t find_next_top_layer_position (samplepos_t) const; - uint32_t combine_ops() const { return _combine_ops; } + uint32_t combine_ops () const + { + return _combine_ops; + } void set_layer (boost::shared_ptr, double); @@ -271,109 +279,120 @@ protected: friend class Session; protected: - class ThawList : public RegionList { - public: - void add (boost::shared_ptr r) - { - if (std::find (begin(), end(), r) != end ()) { - return; - } - r->suspend_property_changes (); - push_back (r); + class ThawList : public RegionList + { + public: + void add (boost::shared_ptr r) + { + if (std::find (begin (), end (), r) != end ()) { + return; } + r->suspend_property_changes (); + push_back (r); + } - void release () - { - for (RegionList::iterator i = begin(); i != end(); ++i) { - (*i)->resume_property_changes (); - } - clear (); + void release () + { + for (RegionList::iterator i = begin (); i != end (); ++i) { + (*i)->resume_property_changes (); } + clear (); + } }; - class RegionReadLock : public Glib::Threads::RWLock::ReaderLock { - public: - RegionReadLock (Playlist *pl) : Glib::Threads::RWLock::ReaderLock (pl->region_lock) {} - ~RegionReadLock() {} + class RegionReadLock : public Glib::Threads::RWLock::ReaderLock + { + public: + RegionReadLock (Playlist* pl) + : Glib::Threads::RWLock::ReaderLock (pl->region_lock) + { + } + ~RegionReadLock () {} }; - class RegionWriteLock : public Glib::Threads::RWLock::WriterLock { - public: - RegionWriteLock (Playlist *pl, bool do_block_notify = true) - : Glib::Threads::RWLock::WriterLock (pl->region_lock) - , playlist (pl) - , block_notify (do_block_notify) { - if (block_notify) { - playlist->delay_notifications(); - } - } - - ~RegionWriteLock() { - Glib::Threads::RWLock::WriterLock::release (); - if (block_notify) { - playlist->release_notifications (); - } - thawlist.release (); + class RegionWriteLock : public Glib::Threads::RWLock::WriterLock + { + public: + RegionWriteLock (Playlist* pl, bool do_block_notify = true) + : Glib::Threads::RWLock::WriterLock (pl->region_lock) + , playlist (pl) + , block_notify (do_block_notify) + { + if (block_notify) { + playlist->delay_notifications (); } + } - ThawList thawlist; - Playlist *playlist; - bool block_notify; + ~RegionWriteLock () + { + Glib::Threads::RWLock::WriterLock::release (); + if (block_notify) { + playlist->release_notifications (); + } + thawlist.release (); + } + + ThawList thawlist; + Playlist* playlist; + bool block_notify; }; - RegionListProperty regions; /* the current list of regions in the playlist */ + RegionListProperty regions; /* the current list of regions in the playlist */ std::set > all_regions; /* all regions ever added to this playlist */ - PBD::ScopedConnectionList region_state_changed_connections; - PBD::ScopedConnectionList region_drop_references_connections; - DataType _type; - uint32_t _sort_id; - mutable gint block_notifications; - mutable gint ignore_state_changes; + PBD::ScopedConnectionList region_state_changed_connections; + PBD::ScopedConnectionList region_drop_references_connections; + DataType _type; + uint32_t _sort_id; + mutable gint block_notifications; + mutable gint ignore_state_changes; std::set > pending_adds; std::set > pending_removes; - RegionList pending_bounds; - bool pending_contents_change; - bool pending_layering; + RegionList pending_bounds; + bool pending_contents_change; + bool pending_layering; - std::set _soloSelectedRegions; + std::set _soloSelectedRegions; /** 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 > pending_range_moves; + std::list > pending_range_moves; + /** Extra sections added to regions during trims */ - std::list< Evoral::Range > pending_region_extensions; - uint32_t in_set_state; - bool in_undo; - bool first_set_state; - bool _hidden; - bool _splicing; - bool _rippling; - bool _shuffling; - bool _nudging; - uint32_t _refcnt; - EditMode _edit_mode; - bool in_flush; - bool in_partition; - bool _frozen; - bool _capture_insertion_underway; - uint32_t subcnt; - PBD::ID _orig_track_id; - uint32_t _combine_ops; + std::list > pending_region_extensions; + + uint32_t in_set_state; + bool in_undo; + bool first_set_state; + bool _hidden; + bool _splicing; + bool _rippling; + bool _shuffling; + bool _nudging; + uint32_t _refcnt; + EditMode _edit_mode; + bool in_flush; + bool in_partition; + bool _frozen; + bool _capture_insertion_underway; + uint32_t subcnt; + PBD::ID _orig_track_id; + uint32_t _combine_ops; std::list _shared_with_ids; 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; + g_atomic_int_get (&ignore_state_changes) != 0; } - void delay_notifications (); - void release_notifications (bool from_undo = false); + void delay_notifications (); + void release_notifications (bool from_undo = false); virtual void flush_notifications (bool from_undo = false); - void clear_pending (); + void clear_pending (); void _set_sort_id (); @@ -388,9 +407,9 @@ protected: void notify_region_start_trimmed (boost::shared_ptr); void notify_region_end_trimmed (boost::shared_ptr); - void mark_session_dirty(); + void mark_session_dirty (); - void region_changed_proxy (const PBD::PropertyChange&, boost::weak_ptr); + void region_changed_proxy (const PBD::PropertyChange&, boost::weak_ptr); virtual bool region_changed (const PBD::PropertyChange&, boost::shared_ptr); void region_bounds_changed (const PBD::PropertyChange&, boost::shared_ptr); @@ -398,14 +417,14 @@ protected: void sort_regions (); - void possibly_splice (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude = boost::shared_ptr()); + void possibly_splice (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude = boost::shared_ptr ()); void possibly_splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude, ThawList& thawlist); void splice_locked (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude); void splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude, ThawList& thawlist); - void ripple_locked (samplepos_t at, samplecnt_t distance, RegionList *exclude); - void ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList *exclude, ThawList& thawlist); + void ripple_locked (samplepos_t at, samplecnt_t distance, RegionList* exclude); + void ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList* exclude, ThawList& thawlist); virtual void remove_dependents (boost::shared_ptr /*region*/) {} virtual void region_going_away (boost::weak_ptr /*region*/) {} @@ -414,14 +433,14 @@ protected: bool add_region_internal (boost::shared_ptr, samplepos_t position, ThawList& thawlist, int32_t sub_num = 0, double quarter_note = 0.0, bool for_music = false); - int remove_region_internal (boost::shared_ptr, ThawList& thawlist); + int remove_region_internal (boost::shared_ptr, ThawList& thawlist); void copy_regions (RegionList&) const; void partition_internal (samplepos_t start, samplepos_t end, bool cutting, ThawList& thawlist); - std::pair _get_extent() const; + std::pair _get_extent () const; - boost::shared_ptr cut_copy (boost::shared_ptr (Playlist::*pmf)(samplepos_t, samplecnt_t, bool), - std::list& ranges, bool result_is_hidden); + boost::shared_ptr cut_copy (boost::shared_ptr (Playlist::*pmf) (samplepos_t, samplecnt_t, bool), + std::list& ranges, bool result_is_hidden); boost::shared_ptr cut (samplepos_t start, samplecnt_t cnt, bool result_is_hidden); boost::shared_ptr copy (samplepos_t start, samplecnt_t cnt, bool result_is_hidden); @@ -439,24 +458,26 @@ protected: /* this is called before we create a new compound region */ virtual void post_combine (std::vector >&, boost::shared_ptr) {} /* this is called before we remove a compound region and replace it - with its constituent regions - */ + * with its constituent regions + */ virtual void pre_uncombine (std::vector >&, boost::shared_ptr) {} private: friend class RegionReadLock; friend class RegionWriteLock; + mutable Glib::Threads::RWLock region_lock; private: - void setup_layering_indices (RegionList const &); + void setup_layering_indices (RegionList const&); void coalesce_and_check_crossfades (std::list >); + boost::shared_ptr find_regions_at (samplepos_t); mutable boost::optional > _cached_extent; - samplepos_t _end_space; //this is used when we are pasting a range with extra space at the end - bool _playlist_shift_active; + samplepos_t _end_space; //this is used when we are pasting a range with extra space at the end + bool _playlist_shift_active; }; } /* namespace ARDOUR */ diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc index 9d30782eb3..57bc44806e 100644 --- a/libs/ardour/playlist.cc +++ b/libs/ardour/playlist.cc @@ -25,14 +25,14 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include -#include #include +#include +#include #include -#include "pbd/types_convert.h" #include "pbd/stateful_diff_command.h" #include "pbd/strsplit.h" +#include "pbd/types_convert.h" #include "pbd/unwind.h" #include "pbd/xml++.h" @@ -42,7 +42,6 @@ #include "ardour/playlist_factory.h" #include "ardour/playlist_source.h" #include "ardour/region.h" -#include "ardour/midi_region.h" #include "ardour/region_factory.h" #include "ardour/region_sorters.h" #include "ardour/session.h" @@ -65,12 +64,20 @@ namespace ARDOUR { } struct ShowMeTheList { - ShowMeTheList (boost::shared_ptr pl, const string& n) : playlist (pl), name (n) {} - ~ShowMeTheList () { - cerr << ">>>>" << name << endl; playlist->dump(); cerr << "<<<<" << name << endl << endl; + ShowMeTheList (boost::shared_ptr pl, const string& n) + : playlist (pl) + , name (n) + {} + + ~ShowMeTheList () + { + cerr << ">>>>" << name << endl; + playlist->dump (); + cerr << "<<<<" << name << endl << endl; }; + boost::shared_ptr playlist; - string name; + string name; }; void @@ -85,40 +92,38 @@ RegionListProperty::RegionListProperty (Playlist& pl) : SequenceProperty > > (Properties::regions.property_id, boost::bind (&Playlist::update, &pl, _1)) , _playlist (pl) { - } -RegionListProperty::RegionListProperty (RegionListProperty const & p) +RegionListProperty::RegionListProperty (RegionListProperty const& p) : PBD::SequenceProperty > > (p) , _playlist (p._playlist) { - } -RegionListProperty * +RegionListProperty* RegionListProperty::clone () const { return new RegionListProperty (*this); } -RegionListProperty * +RegionListProperty* RegionListProperty::create () const { return new RegionListProperty (_playlist); } void -RegionListProperty::get_content_as_xml (boost::shared_ptr region, XMLNode & node) const +RegionListProperty::get_content_as_xml (boost::shared_ptr region, XMLNode& node) const { /* All regions (even those which are deleted) have their state * saved by other code, so we can just store ID here. */ - node.set_property ("id", region->id()); + node.set_property ("id", region->id ()); } boost::shared_ptr -RegionListProperty::get_content_from_xml (XMLNode const & node) const +RegionListProperty::get_content_from_xml (XMLNode const& node) const { PBD::ID id; if (!node.get_property ("id", id)) { @@ -135,24 +140,24 @@ RegionListProperty::get_content_from_xml (XMLNode const & node) const } Playlist::Playlist (Session& sess, string nom, DataType type, bool hide) - : SessionObject(sess, nom) + : SessionObject (sess, nom) , regions (*this) - , _type(type) + , _type (type) { init (hide); first_set_state = false; - _name = nom; + _name = nom; _set_sort_id (); } Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide) - : SessionObject(sess, "unnamed playlist") + : SessionObject (sess, "unnamed playlist") , regions (*this) - , _type(type) + , _type (type) { #ifndef NDEBUG - XMLProperty const * prop = node.property("type"); - assert(!prop || DataType(prop->value()) == _type); + XMLProperty const* prop = node.property ("type"); + assert (!prop || DataType (prop->value ()) == _type); #endif init (hide); @@ -163,22 +168,22 @@ Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide } Playlist::Playlist (boost::shared_ptr other, string namestr, bool hide) - : SessionObject(other->_session, namestr) + : SessionObject (other->_session, namestr) , regions (*this) - , _type(other->_type) + , _type (other->_type) , _orig_track_id (other->_orig_track_id) , _shared_with_ids (other->_shared_with_ids) { init (hide); RegionList tmp; - ThawList thawlist; + ThawList thawlist; other->copy_regions (tmp); in_set_state++; - for (list >::iterator x = tmp.begin(); x != tmp.end(); ++x) { - add_region_internal ((*x), (*x)->position(), thawlist); + for (list >::iterator x = tmp.begin (); x != tmp.end (); ++x) { + add_region_internal ((*x), (*x)->position (), thawlist); } thawlist.release (); @@ -189,22 +194,22 @@ Playlist::Playlist (boost::shared_ptr other, string namestr, boo _nudging = other->_nudging; _edit_mode = other->_edit_mode; - in_set_state = 0; + in_set_state = 0; first_set_state = false; - in_flush = false; - in_partition = false; - subcnt = 0; - _frozen = other->_frozen; + in_flush = false; + in_partition = false; + subcnt = 0; + _frozen = other->_frozen; } Playlist::Playlist (boost::shared_ptr other, samplepos_t start, samplecnt_t cnt, string str, bool hide) - : SessionObject(other->_session, str) + : SessionObject (other->_session, str) , regions (*this) - , _type(other->_type) + , _type (other->_type) , _orig_track_id (other->_orig_track_id) , _shared_with_ids (other->_shared_with_ids) { - RegionReadLock rlock2 (const_cast (other.get())); + RegionReadLock rlock2 (const_cast (other.get ())); samplepos_t end = start + cnt - 1; @@ -213,73 +218,71 @@ Playlist::Playlist (boost::shared_ptr other, samplepos_t start, in_set_state++; ThawList thawlist; - for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); ++i) { - + for (RegionList::const_iterator i = other->regions.begin (); i != other->regions.end (); ++i) { boost::shared_ptr region; boost::shared_ptr new_region; - sampleoffset_t offset = 0; - samplepos_t position = 0; - samplecnt_t len = 0; - string new_name; - Evoral::OverlapType overlap; + sampleoffset_t offset = 0; + samplepos_t position = 0; + samplecnt_t len = 0; + string new_name; + Evoral::OverlapType overlap; region = *i; overlap = region->coverage (start, end); switch (overlap) { - case Evoral::OverlapNone: - continue; + case Evoral::OverlapNone: + continue; - case Evoral::OverlapInternal: - offset = start - region->position(); - position = 0; - len = cnt; - break; + case Evoral::OverlapInternal: + offset = start - region->position (); + position = 0; + len = cnt; + break; - case Evoral::OverlapStart: - offset = 0; - position = region->position() - start; - len = end - region->position(); - break; + case Evoral::OverlapStart: + offset = 0; + position = region->position () - start; + len = end - region->position (); + break; - case Evoral::OverlapEnd: - offset = start - region->position(); - position = 0; - len = region->length() - offset; - break; + case Evoral::OverlapEnd: + offset = start - region->position (); + position = 0; + len = region->length () - offset; + break; - case Evoral::OverlapExternal: - offset = 0; - position = region->position() - start; - len = region->length(); - break; + case Evoral::OverlapExternal: + offset = 0; + position = region->position () - start; + len = region->length (); + break; } - RegionFactory::region_name (new_name, region->name(), false); + RegionFactory::region_name (new_name, region->name (), false); PropertyList plist; if (_type == DataType::MIDI) { boost::shared_ptr mregion = boost::dynamic_pointer_cast (region); - if ( mregion && offset ) { - int32_t division = 1; /*magic value that ignores the meter (right?)*/ - const double start_quarter_note =_session.tempo_map().exact_qn_at_sample (start, division ); - const double start_offset_quarter_note = start_quarter_note - region->quarter_note(); - const double end_samples = (overlap == Evoral::OverlapStart ? - end : /*end the new region at the end of the selection*/ - region->position() + region->length() -1); /*use the region's end*/ - const double length_quarter_note = _session.tempo_map().exact_qn_at_sample ( end_samples, division ) - start_quarter_note; - plist.add (Properties::start_beats, mregion->start_beats() + start_offset_quarter_note); + if (mregion && offset) { + int32_t division = 1; /*magic value that ignores the meter (right?)*/ + const double start_quarter_note = _session.tempo_map ().exact_qn_at_sample (start, division); + const double start_offset_quarter_note = start_quarter_note - region->quarter_note (); + const double end_samples = (overlap == Evoral::OverlapStart ? end : /*end the new region at the end of the selection*/ + region->position () + region->length () - 1); /*use the region's end*/ + const double length_quarter_note = _session.tempo_map ().exact_qn_at_sample (end_samples, division) - start_quarter_note; + plist.add (Properties::start_beats, mregion->start_beats () + start_offset_quarter_note); plist.add (Properties::length_beats, length_quarter_note); } } - plist.add (Properties::start, region->start() + offset); + plist.add (Properties::start, region->start () + offset); plist.add (Properties::length, len); plist.add (Properties::name, new_name); - plist.add (Properties::layer, region->layer()); - plist.add (Properties::layering_index, region->layering_index()); + plist.add (Properties::layer, region->layer ()); + plist.add (Properties::layering_index, region->layering_index ()); new_region = RegionFactory::create (region, plist); @@ -288,9 +291,10 @@ Playlist::Playlist (boost::shared_ptr other, samplepos_t start, thawlist.release (); - //keep track of any dead space at end (for pasting into Ripple or Splice mode) - //at the end of construction, any length of cnt beyond the extents of the regions is end_space - _end_space = cnt - (get_extent().second - get_extent().first); + /* keep track of any dead space at end (for pasting into Ripple or Splice mode) + * at the end of construction, any length of cnt beyond the extents of the regions is end_space + */ + _end_space = cnt - (get_extent ().second - get_extent ().first); in_set_state--; first_set_state = false; @@ -318,9 +322,9 @@ Playlist::release () void Playlist::copy_regions (RegionList& newlist) const { - RegionReadLock rlock (const_cast (this)); + RegionReadLock rlock (const_cast (this)); - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { newlist.push_back (RegionFactory::create (*i, true, true)); } } @@ -333,29 +337,29 @@ Playlist::init (bool hide) g_atomic_int_set (&block_notifications, 0); g_atomic_int_set (&ignore_state_changes, 0); - pending_contents_change = false; - pending_layering = false; - first_set_state = true; - _refcnt = 0; - _hidden = hide; - _splicing = false; - _rippling = false; - _shuffling = false; - _nudging = false; - in_set_state = 0; - in_undo = false; - _edit_mode = Config->get_edit_mode(); - in_flush = false; - in_partition = false; - subcnt = 0; - _frozen = false; + pending_contents_change = false; + pending_layering = false; + first_set_state = true; + _refcnt = 0; + _hidden = hide; + _splicing = false; + _rippling = false; + _shuffling = false; + _nudging = false; + in_set_state = 0; + in_undo = false; + _edit_mode = Config->get_edit_mode (); + in_flush = false; + in_partition = false; + subcnt = 0; + _frozen = false; _capture_insertion_underway = false; - _combine_ops = 0; - _end_space = 0; - _playlist_shift_active = false; + _combine_ops = 0; + _end_space = 0; + _playlist_shift_active = false; - _session.history().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this)); - _session.history().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this)); + _session.history ().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this)); + _session.history ().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this)); ContentsChanged.connect_same_thread (*this, boost::bind (&Playlist::mark_session_dirty, this)); } @@ -367,8 +371,8 @@ Playlist::~Playlist () { RegionReadLock rl (this); - for (set >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) { - (*i)->set_playlist (boost::shared_ptr()); + for (set >::iterator i = all_regions.begin (); i != all_regions.end (); ++i) { + (*i)->set_playlist (boost::shared_ptr ()); } } @@ -383,12 +387,12 @@ Playlist::_set_sort_id () * is an integer. We extract the id and sort by that. */ - size_t dot_position = _name.val().find_last_of("."); + size_t dot_position = _name.val ().find_last_of ("."); if (dot_position == string::npos) { _sort_id = 0; } else { - string t = _name.val().substr(dot_position + 1); + string t = _name.val ().substr (dot_position + 1); if (!string_to_uint32 (t, _sort_id)) { _sort_id = 0; @@ -409,7 +413,7 @@ Playlist::set_name (const string& str) return false; } - bool ret = SessionObject::set_name(str); + bool ret = SessionObject::set_name (str); if (ret) { _set_sort_id (); } @@ -453,7 +457,6 @@ Playlist::thaw (bool from_undo) release_notifications (from_undo); } - void Playlist::delay_notifications () { @@ -476,7 +479,7 @@ Playlist::notify_contents_changed () pending_contents_change = true; } else { pending_contents_change = false; - ContentsChanged(); /* EMIT SIGNAL */ + ContentsChanged (); /* EMIT SIGNAL */ } } @@ -487,7 +490,7 @@ Playlist::notify_layering_changed () pending_layering = true; } else { pending_layering = false; - LayeringChanged(); /* EMIT SIGNAL */ + LayeringChanged (); /* EMIT SIGNAL */ } } @@ -503,7 +506,7 @@ Playlist::notify_region_removed (boost::shared_ptr r) */ pending_contents_change = false; RegionRemoved (boost::weak_ptr (r)); /* EMIT SIGNAL */ - ContentsChanged (); /* EMIT SIGNAL */ + ContentsChanged (); /* EMIT SIGNAL */ } } @@ -513,63 +516,54 @@ Playlist::notify_region_moved (boost::shared_ptr r) Evoral::RangeMove const move (r->last_position (), r->length (), r->position ()); if (holding_state ()) { - pending_range_moves.push_back (move); } else { - - list< Evoral::RangeMove > m; + list > m; m.push_back (move); RangesMoved (m, false); } - } void Playlist::notify_region_start_trimmed (boost::shared_ptr r) { - if (r->position() >= r->last_position()) { + if (r->position () >= r->last_position ()) { /* trimmed shorter */ return; } - Evoral::Range const extra (r->position(), r->last_position()); + Evoral::Range const extra (r->position (), r->last_position ()); if (holding_state ()) { - pending_region_extensions.push_back (extra); } else { - list > r; r.push_back (extra); RegionsExtended (r); - } } void Playlist::notify_region_end_trimmed (boost::shared_ptr r) { - if (r->length() < r->last_length()) { + if (r->length () < r->last_length ()) { /* trimmed shorter */ } - Evoral::Range const extra (r->position() + r->last_length(), r->position() + r->length()); + Evoral::Range const extra (r->position () + r->last_length (), r->position () + r->length ()); if (holding_state ()) { - pending_region_extensions.push_back (extra); } else { - list > r; r.push_back (extra); RegionsExtended (r); } } - void Playlist::notify_region_added (boost::shared_ptr r) { @@ -577,15 +571,14 @@ Playlist::notify_region_added (boost::shared_ptr r) * as though it could be. */ - if (holding_state()) { + if (holding_state ()) { pending_adds.insert (r); pending_contents_change = true; } else { r->clear_changes (); pending_contents_change = false; RegionAdded (boost::weak_ptr (r)); /* EMIT SIGNAL */ - ContentsChanged (); /* EMIT SIGNAL */ - + ContentsChanged (); /* EMIT SIGNAL */ } } @@ -602,7 +595,7 @@ Playlist::flush_notifications (bool from_undo) in_flush = true; - if (!pending_bounds.empty() || !pending_removes.empty() || !pending_adds.empty()) { + if (!pending_bounds.empty () || !pending_removes.empty () || !pending_adds.empty ()) { regions_changed = true; } @@ -616,24 +609,21 @@ Playlist::flush_notifications (bool from_undo) * model, sort them by existing layer, then timestamp them. */ - // RegionSortByLayer cmp; - // pending_bounds.sort (cmp); - list > crossfade_ranges; - for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) { + for (RegionList::iterator r = pending_bounds.begin (); r != pending_bounds.end (); ++r) { crossfade_ranges.push_back ((*r)->last_range ()); crossfade_ranges.push_back ((*r)->range ()); } - for (s = pending_removes.begin(); s != pending_removes.end(); ++s) { + for (s = pending_removes.begin (); s != pending_removes.end (); ++s) { crossfade_ranges.push_back ((*s)->range ()); remove_dependents (*s); RegionRemoved (boost::weak_ptr (*s)); /* EMIT SIGNAL */ - Region::RegionPropertyChanged(*s, Properties::hidden); + Region::RegionPropertyChanged (*s, Properties::hidden); } - for (s = pending_adds.begin(); s != pending_adds.end(); ++s) { + for (s = pending_adds.begin (); s != pending_adds.end (); ++s) { crossfade_ranges.push_back ((*s)->range ()); /* don't emit RegionAdded signal until relayering is done, so that the region is fully setup by the time @@ -650,7 +640,7 @@ Playlist::flush_notifications (bool from_undo) ContentsChanged (); /* EMIT SIGNAL */ } - for (s = pending_adds.begin(); s != pending_adds.end(); ++s) { + for (s = pending_adds.begin (); s != pending_adds.end (); ++s) { (*s)->clear_changes (); RegionAdded (boost::weak_ptr (*s)); /* EMIT SIGNAL */ } @@ -686,7 +676,7 @@ Playlist::clear_pending () pending_range_moves.clear (); pending_region_extensions.clear (); pending_contents_change = false; - pending_layering = false; + pending_layering = false; } /************************************************************* @@ -700,14 +690,14 @@ Playlist::add_region (boost::shared_ptr region, samplepos_t position, fl RegionWriteLock rlock (this); times = fabs (times); - int itimes = (int) floor (times); + int itimes = (int)floor (times); samplepos_t pos = position; - if (times == 1 && auto_partition){ + if (times == 1 && auto_partition) { RegionList thawlist; - partition_internal (pos - 1, (pos + region->length()), true, rlock.thawlist); - for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { + partition_internal (pos - 1, (pos + region->length ()), true, rlock.thawlist); + for (RegionList::iterator i = thawlist.begin (); i != thawlist.end (); ++i) { (*i)->resume_property_changes (); _session.add_command (new StatefulDiffCommand (*i)); } @@ -716,7 +706,7 @@ Playlist::add_region (boost::shared_ptr region, samplepos_t position, fl if (itimes >= 1) { add_region_internal (region, pos, rlock.thawlist, sub_num, quarter_note, for_music); set_layer (region, DBL_MAX); - pos += region->length(); + pos += region->length (); --itimes; } @@ -728,23 +718,23 @@ Playlist::add_region (boost::shared_ptr region, samplepos_t position, fl boost::shared_ptr copy = RegionFactory::create (region, true); add_region_internal (copy, pos, rlock.thawlist, sub_num); set_layer (copy, DBL_MAX); - pos += region->length(); + pos += region->length (); } samplecnt_t length = 0; if (floor (times) != times) { - length = (samplecnt_t) floor (region->length() * (times - floor (times))); + length = (samplecnt_t)floor (region->length () * (times - floor (times))); string name; - RegionFactory::region_name (name, region->name(), false); + RegionFactory::region_name (name, region->name (), false); { PropertyList plist; - plist.add (Properties::start, region->start()); + plist.add (Properties::start, region->start ()); plist.add (Properties::length, length); plist.add (Properties::name, name); - plist.add (Properties::layer, region->layer()); + plist.add (Properties::layer, region->layer ()); boost::shared_ptr sub = RegionFactory::create (region, plist); add_region_internal (sub, pos, rlock.thawlist, sub_num); @@ -758,11 +748,11 @@ Playlist::add_region (boost::shared_ptr region, samplepos_t position, fl void Playlist::set_region_ownership () { - RegionWriteLock rl (this); - RegionList::iterator i; - boost::weak_ptr pl (shared_from_this()); + RegionWriteLock rl (this); + RegionList::iterator i; + boost::weak_ptr pl (shared_from_this ()); - for (i = regions.begin(); i != regions.end(); ++i) { + for (i = regions.begin (); i != regions.end (); ++i) { (*i)->set_playlist (pl); } } @@ -770,7 +760,7 @@ Playlist::set_region_ownership () bool Playlist::add_region_internal (boost::shared_ptr region, samplepos_t position, ThawList& thawlist, int32_t sub_num, double quarter_note, bool for_music) { - if (region->data_type() != _type) { + if (region->data_type () != _type) { return false; } @@ -782,8 +772,8 @@ Playlist::add_region_internal (boost::shared_ptr region, samplepos_t pos RegionSortByPosition cmp; if (!first_set_state) { - boost::shared_ptr foo (shared_from_this()); - region->set_playlist (boost::weak_ptr(foo)); + boost::shared_ptr foo (shared_from_this ()); + region->set_playlist (boost::weak_ptr (foo)); } if (for_music) { region->set_position_music (quarter_note); @@ -791,10 +781,10 @@ Playlist::add_region_internal (boost::shared_ptr region, samplepos_t pos region->set_position (position, sub_num); } - regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + regions.insert (upper_bound (regions.begin (), regions.end (), region, cmp), region); all_regions.insert (region); - possibly_splice_unlocked (position, region->length(), region, thawlist); + possibly_splice_unlocked (position, region->length (), region, thawlist); if (!holding_state ()) { /* layers get assigned from XML state, and are not reset during undo/redo */ @@ -817,7 +807,7 @@ Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr old, boost::shared_ptrlength() - newr->length(), boost::shared_ptr(), rlock.thawlist); + possibly_splice_unlocked (pos, old->length () - newr->length (), boost::shared_ptr (), rlock.thawlist); } void @@ -842,20 +832,19 @@ Playlist::remove_region_internal (boost::shared_ptr region, ThawList& th if (!in_set_state) { /* unset playlist */ - region->set_playlist (boost::weak_ptr()); + region->set_playlist (boost::weak_ptr ()); } /* XXX should probably freeze here .... */ - for (i = regions.begin(); i != regions.end(); ++i) { + for (i = regions.begin (); i != regions.end (); ++i) { if (*i == region) { - - samplepos_t pos = (*i)->position(); - samplecnt_t distance = (*i)->length(); + samplepos_t pos = (*i)->position (); + samplecnt_t distance = (*i)->length (); regions.erase (i); - possibly_splice_unlocked (pos, -distance, boost::shared_ptr(), thawlist); + possibly_splice_unlocked (pos, -distance, boost::shared_ptr (), thawlist); if (!holding_state ()) { relayer (); @@ -873,43 +862,42 @@ Playlist::remove_region_internal (boost::shared_ptr region, ThawList& th void Playlist::get_equivalent_regions (boost::shared_ptr other, vector >& results) { - switch (Config->get_region_equivalence()) { - case Exact: - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->exact_equivalent (other)) { - results.push_back (*i); - } - } - break; - case LayerTime: - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->layer_and_time_equivalent (other)) { - results.push_back (*i); - } - } - break; - case Enclosed: - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->enclosed_equivalent (other)) { - results.push_back (*i); - } - } - break; - case Overlap: - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->overlap_equivalent (other)) { - results.push_back (*i); - } - } - break; + switch (Config->get_region_equivalence ()) { + case Exact: + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->exact_equivalent (other)) { + results.push_back (*i); + } + } + break; + case LayerTime: + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->layer_and_time_equivalent (other)) { + results.push_back (*i); + } + } + break; + case Enclosed: + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->enclosed_equivalent (other)) { + results.push_back (*i); + } + } + break; + case Overlap: + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->overlap_equivalent (other)) { + results.push_back (*i); + } + } + break; } } void Playlist::get_region_list_equivalent_regions (boost::shared_ptr other, vector >& results) { - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i) && (*i)->region_list_equivalent (other)) { results.push_back (*i); } @@ -919,8 +907,7 @@ Playlist::get_region_list_equivalent_regions (boost::shared_ptr other, v void Playlist::get_source_equivalent_regions (boost::shared_ptr other, vector >& results) { - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i) && (*i)->any_source_equivalent (other)) { results.push_back (*i); } @@ -930,7 +917,7 @@ Playlist::get_source_equivalent_regions (boost::shared_ptr other, vector void Playlist::partition (samplepos_t start, samplepos_t end, bool cut) { - RegionWriteLock lock(this); + RegionWriteLock lock (this); partition_internal (start, end, cut, lock.thawlist); } @@ -938,9 +925,10 @@ Playlist::partition (samplepos_t start, samplepos_t end, bool cut) * and _start is overwritten using Properties::start_beats in * add_region_internal() -> Region::set_position() -> MidiRegion::set_position_internal() */ -static void maybe_add_start_beats (TempoMap const& tm, PropertyList& plist, boost::shared_ptr r, samplepos_t start, samplepos_t end) +static void +maybe_add_start_beats (TempoMap const& tm, PropertyList& plist, boost::shared_ptr r, samplepos_t start, samplepos_t end) { - boost::shared_ptr mr = boost::dynamic_pointer_cast(r); + boost::shared_ptr mr = boost::dynamic_pointer_cast (r); if (!mr) { return; } @@ -958,13 +946,12 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, RegionList new_regions; { - boost::shared_ptr region; boost::shared_ptr current; - string new_name; - RegionList::iterator tmp; - Evoral::OverlapType overlap; - samplepos_t pos1, pos2, pos3, pos4; + string new_name; + RegionList::iterator tmp; + Evoral::OverlapType overlap; + samplepos_t pos1, pos2, pos3, pos4; in_partition = true; @@ -972,17 +959,15 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, * during the process get operated on as well. */ - RegionList copy = regions.rlist(); - - for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) { + RegionList copy = regions.rlist (); + for (RegionList::iterator i = copy.begin (); i != copy.end (); i = tmp) { tmp = i; ++tmp; current = *i; - if (current->first_sample() >= start && current->last_sample() < end) { - + if (current->first_sample () >= start && current->last_sample () < end) { if (cutting) { remove_region_internal (current, thawlist); } @@ -995,7 +980,7 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, * so catch this special case. */ - if (current->first_sample() >= end) { + if (current->first_sample () >= end) { continue; } @@ -1003,10 +988,10 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, continue; } - pos1 = current->position(); + pos1 = current->position (); pos2 = start; pos3 = end; - pos4 = current->last_sample(); + pos4 = current->last_sample (); if (overlap == Evoral::OverlapInternal) { /* split: we need 3 new regions, the front, middle and end. @@ -1025,11 +1010,11 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, if (!cutting) { /* "middle" ++++++ */ - RegionFactory::region_name (new_name, current->name(), false); + RegionFactory::region_name (new_name, current->name (), false); PropertyList plist; - plist.add (Properties::start, current->start() + (pos2 - pos1)); + plist.add (Properties::start, current->start () + (pos2 - pos1)); plist.add (Properties::length, pos3 - pos2); plist.add (Properties::name, new_name); plist.add (Properties::layer, current->layer ()); @@ -1037,7 +1022,7 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, plist.add (Properties::automatic, true); plist.add (Properties::left_of_split, true); plist.add (Properties::right_of_split, true); - maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos2 - pos1)); + maybe_add_start_beats (_session.tempo_map (), plist, current, current->start (), current->start () + (pos2 - pos1)); /* see note in :_split_region() * for MusicSample is needed to offset region-gain @@ -1049,18 +1034,18 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, /* "end" ====== */ - RegionFactory::region_name (new_name, current->name(), false); + RegionFactory::region_name (new_name, current->name (), false); PropertyList plist; - plist.add (Properties::start, current->start() + (pos3 - pos1)); + plist.add (Properties::start, current->start () + (pos3 - pos1)); plist.add (Properties::length, pos4 - pos3); plist.add (Properties::name, new_name); plist.add (Properties::layer, current->layer ()); plist.add (Properties::layering_index, current->layering_index ()); plist.add (Properties::automatic, true); plist.add (Properties::right_of_split, true); - maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos3 - pos1)); + maybe_add_start_beats (_session.tempo_map (), plist, current, current->start (), current->start () + (pos3 - pos1)); region = RegionFactory::create (current, MusicSample (pos3 - pos1, 0), plist); @@ -1074,7 +1059,6 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, current->cut_end (pos2 - 1); } else if (overlap == Evoral::OverlapEnd) { - /* start end ---------------*************************------------ @@ -1086,23 +1070,22 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, */ if (!cutting) { - /* end +++++ */ - RegionFactory::region_name (new_name, current->name(), false); + RegionFactory::region_name (new_name, current->name (), false); PropertyList plist; - plist.add (Properties::start, current->start() + (pos2 - pos1)); + plist.add (Properties::start, current->start () + (pos2 - pos1)); plist.add (Properties::length, pos4 - pos2); plist.add (Properties::name, new_name); plist.add (Properties::layer, current->layer ()); plist.add (Properties::layering_index, current->layering_index ()); plist.add (Properties::automatic, true); plist.add (Properties::left_of_split, true); - maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start() + (pos2 - pos1)); + maybe_add_start_beats (_session.tempo_map (), plist, current, current->start (), current->start () + (pos2 - pos1)); - region = RegionFactory::create (current, MusicSample(pos2 - pos1, 0), plist); + region = RegionFactory::create (current, MusicSample (pos2 - pos1, 0), plist); add_region_internal (region, start, thawlist); new_regions.push_back (region); @@ -1115,7 +1098,6 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, current->cut_end (pos2 - 1); } else if (overlap == Evoral::OverlapStart) { - /* split: we need 2 regions: the front and the end. * cut: just trim current to skip the cut area * @@ -1132,18 +1114,18 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, if (!cutting) { /* front **** */ - RegionFactory::region_name (new_name, current->name(), false); + RegionFactory::region_name (new_name, current->name (), false); PropertyList plist; - plist.add (Properties::start, current->start()); + plist.add (Properties::start, current->start ()); plist.add (Properties::length, pos3 - pos1); plist.add (Properties::name, new_name); plist.add (Properties::layer, current->layer ()); plist.add (Properties::layering_index, current->layering_index ()); plist.add (Properties::automatic, true); plist.add (Properties::right_of_split, true); - maybe_add_start_beats (_session.tempo_map(), plist, current, current->start(), current->start()); + maybe_add_start_beats (_session.tempo_map (), plist, current, current->start (), current->start ()); region = RegionFactory::create (current, plist); @@ -1157,7 +1139,6 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, thawlist.add (current); current->trim_front (pos3); } else if (overlap == Evoral::OverlapExternal) { - /* split: no split required. * cut: remove the region. * @@ -1185,32 +1166,30 @@ Playlist::partition_internal (samplepos_t start, samplepos_t end, bool cutting, in_partition = false; } - //keep track of any dead space at end (for pasting into Ripple or Splice mode) - samplepos_t wanted_length = end-start; - _end_space = wanted_length - _get_extent().second - _get_extent().first; + /* keep track of any dead space at end (for pasting into Ripple or Splice mode) */ + samplepos_t wanted_length = end - start; + _end_space = wanted_length - _get_extent ().second - _get_extent ().first; } boost::shared_ptr -Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(samplepos_t, samplecnt_t,bool), list& ranges, bool result_is_hidden) +Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf) (samplepos_t, samplecnt_t, bool), list& ranges, bool result_is_hidden) { boost::shared_ptr ret; boost::shared_ptr pl; - samplepos_t start; + samplepos_t start; - if (ranges.empty()) { - return boost::shared_ptr(); + if (ranges.empty ()) { + return boost::shared_ptr (); } - start = ranges.front().start; + start = ranges.front ().start; - for (list::iterator i = ranges.begin(); i != ranges.end(); ++i) { + for (list::iterator i = ranges.begin (); i != ranges.end (); ++i) { + pl = (this->*pmf) ((*i).start, (*i).length (), result_is_hidden); - pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden); - - if (i == ranges.begin()) { + if (i == ranges.begin ()) { ret = pl; } else { - /* paste the next section into the nascent playlist, * offset to reflect the start of the first range we * chopped. @@ -1226,14 +1205,14 @@ Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(samplepos_t, sa boost::shared_ptr Playlist::cut (list& ranges, bool result_is_hidden) { - boost::shared_ptr (Playlist::*pmf)(samplepos_t,samplecnt_t,bool) = &Playlist::cut; + boost::shared_ptr (Playlist::*pmf) (samplepos_t, samplecnt_t, bool) = &Playlist::cut; return cut_copy (pmf, ranges, result_is_hidden); } boost::shared_ptr Playlist::copy (list& ranges, bool result_is_hidden) { - boost::shared_ptr (Playlist::*pmf)(samplepos_t,samplecnt_t,bool) = &Playlist::copy; + boost::shared_ptr (Playlist::*pmf) (samplepos_t, samplecnt_t, bool) = &Playlist::copy; return cut_copy (pmf, ranges, result_is_hidden); } @@ -1241,20 +1220,20 @@ boost::shared_ptr Playlist::cut (samplepos_t start, samplecnt_t cnt, bool result_is_hidden) { boost::shared_ptr the_copy; - char buf[32]; + char buf[32]; snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt); string new_name = _name; new_name += '.'; new_name += buf; - if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) { - return boost::shared_ptr(); + if ((the_copy = PlaylistFactory::create (shared_from_this (), start, cnt, new_name, result_is_hidden)) == 0) { + return boost::shared_ptr (); } { RegionWriteLock rlock (this); - partition_internal (start, start+cnt-1, true, rlock.thawlist); + partition_internal (start, start + cnt - 1, true, rlock.thawlist); } return the_copy; @@ -1272,7 +1251,7 @@ Playlist::copy (samplepos_t start, samplecnt_t cnt, bool result_is_hidden) // cnt = min (_get_extent().second - start, cnt); (We need the full range length when copy/pasting in Ripple. Why was this limit here? It's not in CUT... ) - return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden); + return PlaylistFactory::create (shared_from_this (), start, cnt, new_name, result_is_hidden); } int @@ -1281,25 +1260,25 @@ Playlist::paste (boost::shared_ptr other, samplepos_t position, float times = fabs (times); { - RegionReadLock rl2 (other.get()); + RegionReadLock rl2 (other.get ()); - int itimes = (int) floor (times); - samplepos_t pos = position; - samplecnt_t const shift = other->_get_extent().second; - layer_t top = top_layer (); + int itimes = (int)floor (times); + samplepos_t pos = position; + samplecnt_t const shift = other->_get_extent ().second; + layer_t top = top_layer (); { RegionWriteLock rl1 (this); while (itimes--) { - for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) { + for (RegionList::iterator i = other->regions.begin (); i != other->regions.end (); ++i) { boost::shared_ptr copy_of_region = RegionFactory::create (*i, true); /* put these new regions on top of all existing ones, but preserve the ordering they had in the original playlist. */ - add_region_internal (copy_of_region, (*i)->position() + pos, rl1.thawlist, sub_num); - set_layer (copy_of_region, copy_of_region->layer() + top); + add_region_internal (copy_of_region, (*i)->position () + pos, rl1.thawlist, sub_num); + set_layer (copy_of_region, copy_of_region->layer () + top); } pos += shift; } @@ -1309,11 +1288,10 @@ Playlist::paste (boost::shared_ptr other, samplepos_t position, float return 0; } - void Playlist::duplicate (boost::shared_ptr region, samplepos_t position, float times) { - duplicate(region, position, region->length(), times); + duplicate (region, position, region->length (), times); } /** @param gap from the beginning of the region to the next beginning */ @@ -1323,7 +1301,7 @@ Playlist::duplicate (boost::shared_ptr region, samplepos_t position, sam times = fabs (times); RegionWriteLock rl (this); - int itimes = (int) floor (times); + int itimes = (int)floor (times); while (itimes--) { boost::shared_ptr copy = RegionFactory::create (region, true); @@ -1333,14 +1311,14 @@ Playlist::duplicate (boost::shared_ptr region, samplepos_t position, sam } if (floor (times) != times) { - samplecnt_t length = (samplecnt_t) floor (region->length() * (times - floor (times))); - string name; - RegionFactory::region_name (name, region->name(), false); + samplecnt_t length = (samplecnt_t)floor (region->length () * (times - floor (times))); + string name; + RegionFactory::region_name (name, region->name (), false); { PropertyList plist; - plist.add (Properties::start, region->start()); + plist.add (Properties::start, region->start ()); plist.add (Properties::length, length); plist.add (Properties::name, name); @@ -1356,54 +1334,54 @@ Playlist::duplicate (boost::shared_ptr region, samplepos_t position, sam void Playlist::duplicate_until (boost::shared_ptr region, samplepos_t position, samplecnt_t gap, samplepos_t end) { - RegionWriteLock rl (this); + RegionWriteLock rl (this); - while (position + region->length() - 1 < end) { - boost::shared_ptr copy = RegionFactory::create (region, true); - add_region_internal (copy, position, rl.thawlist); - set_layer (copy, DBL_MAX); - position += gap; - } + while (position + region->length () - 1 < end) { + boost::shared_ptr copy = RegionFactory::create (region, true); + add_region_internal (copy, position, rl.thawlist); + set_layer (copy, DBL_MAX); + position += gap; + } - if (position < end) { - samplecnt_t length = min (region->length(), end - position); - string name; - RegionFactory::region_name (name, region->name(), false); + if (position < end) { + samplecnt_t length = min (region->length (), end - position); + string name; + RegionFactory::region_name (name, region->name (), false); - { - PropertyList plist; + { + PropertyList plist; - plist.add (Properties::start, region->start()); - plist.add (Properties::length, length); - plist.add (Properties::name, name); + plist.add (Properties::start, region->start ()); + plist.add (Properties::length, length); + plist.add (Properties::name, name); - boost::shared_ptr sub = RegionFactory::create (region, plist); - add_region_internal (sub, position, rl.thawlist); - set_layer (sub, DBL_MAX); - } - } + boost::shared_ptr sub = RegionFactory::create (region, plist); + add_region_internal (sub, position, rl.thawlist); + set_layer (sub, DBL_MAX); + } + } } void Playlist::duplicate_range (AudioRange& range, float times) { - boost::shared_ptr pl = copy (range.start, range.length(), true); - samplecnt_t offset = range.end - range.start; + boost::shared_ptr pl = copy (range.start, range.length (), true); + samplecnt_t offset = range.end - range.start; paste (pl, range.start + offset, times, 0); } void Playlist::duplicate_ranges (std::list& ranges, float times) { - if (ranges.empty()) { + if (ranges.empty ()) { return; } samplepos_t min_pos = max_samplepos; samplepos_t max_pos = 0; - for (std::list::const_iterator i = ranges.begin(); - i != ranges.end(); + for (std::list::const_iterator i = ranges.begin (); + i != ranges.end (); ++i) { min_pos = min (min_pos, (*i).start); max_pos = max (max_pos, (*i).end); @@ -1411,8 +1389,8 @@ Playlist::duplicate_ranges (std::list& ranges, float times) samplecnt_t offset = max_pos - min_pos; - int count = 1; - int itimes = (int) floor (times); + int count = 1; + int itimes = (int)floor (times); while (itimes--) { for (list::iterator i = ranges.begin (); i != ranges.end (); ++i) { boost::shared_ptr pl = copy ((*i).start, (*i).length (), true); @@ -1426,18 +1404,17 @@ void Playlist::shift (samplepos_t at, sampleoffset_t distance, bool move_intersected, bool ignore_music_glue) { PBD::Unwinder uw (_playlist_shift_active, true); - RegionWriteLock rlock (this); - RegionList copy (regions.rlist()); - RegionList fixup; + RegionWriteLock rlock (this); + RegionList copy (regions.rlist ()); + RegionList fixup; - for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { - - if ((*r)->last_sample() < at) { + for (RegionList::iterator r = copy.begin (); r != copy.end (); ++r) { + if ((*r)->last_sample () < at) { /* too early */ continue; } - if (at > (*r)->first_sample() && at < (*r)->last_sample()) { + if (at > (*r)->first_sample () && at < (*r)->last_sample ()) { /* intersected region */ if (!move_intersected) { continue; @@ -1448,17 +1425,17 @@ Playlist::shift (samplepos_t at, sampleoffset_t distance, bool move_intersected, * has to be done separately. */ - if (!ignore_music_glue && (*r)->position_lock_style() != AudioTime) { + if (!ignore_music_glue && (*r)->position_lock_style () != AudioTime) { fixup.push_back (*r); continue; } rlock.thawlist.add (*r); - (*r)->set_position ((*r)->position() + distance); + (*r)->set_position ((*r)->position () + distance); } /* XXX: may not be necessary; Region::post_set should do this, I think */ - for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) { + for (RegionList::iterator r = fixup.begin (); r != fixup.end (); ++r) { (*r)->recompute_position_from_lock_style (0); } } @@ -1467,11 +1444,11 @@ void Playlist::split (const MusicSample& at) { RegionWriteLock rlock (this); - RegionList copy (regions.rlist()); + RegionList copy (regions.rlist ()); /* use a copy since this operation can modify the region list */ - for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { + for (RegionList::iterator r = copy.begin (); r != copy.end (); ++r) { _split_region (*r, at, rlock.thawlist); } } @@ -1490,25 +1467,25 @@ Playlist::_split_region (boost::shared_ptr region, const MusicSample& pl return; } - if (region->position() == playlist_position.sample || - region->last_sample() == playlist_position.sample) { + if (region->position () == playlist_position.sample || + region->last_sample () == playlist_position.sample) { return; } boost::shared_ptr left; boost::shared_ptr right; - MusicSample before (playlist_position.sample - region->position(), playlist_position.division); - MusicSample after (region->length() - before.sample, 0); - string before_name; - string after_name; + MusicSample before (playlist_position.sample - region->position (), playlist_position.division); + MusicSample after (region->length () - before.sample, 0); + string before_name; + string after_name; /* split doesn't change anything about length, so don't try to splice */ bool old_sp = _splicing; - _splicing = true; + _splicing = true; - RegionFactory::region_name (before_name, region->name(), false); + RegionFactory::region_name (before_name, region->name (), false); { PropertyList plist; @@ -1526,7 +1503,7 @@ Playlist::_split_region (boost::shared_ptr region, const MusicSample& pl left = RegionFactory::create (region, MusicSample (0, 0), plist, true); } - RegionFactory::region_name (after_name, region->name(), false); + RegionFactory::region_name (after_name, region->name (), false); { PropertyList plist; @@ -1541,8 +1518,8 @@ Playlist::_split_region (boost::shared_ptr region, const MusicSample& pl right = RegionFactory::create (region, before, plist, true); } - add_region_internal (left, region->position(), thawlist, 0); - add_region_internal (right, region->position() + before.sample, thawlist, before.division); + add_region_internal (left, region->position (), thawlist, 0); + add_region_internal (right, region->position () + before.sample, thawlist, before.division); remove_region_internal (region, thawlist); @@ -1550,34 +1527,31 @@ Playlist::_split_region (boost::shared_ptr region, const MusicSample& pl } void -Playlist::AddToSoloSelectedList(const Region* r) +Playlist::AddToSoloSelectedList (const Region* r) { _soloSelectedRegions.insert (r); } - void -Playlist::RemoveFromSoloSelectedList(const Region* r) +Playlist::RemoveFromSoloSelectedList (const Region* r) { _soloSelectedRegions.erase (r); } - bool -Playlist::SoloSelectedListIncludes(const Region* r) +Playlist::SoloSelectedListIncludes (const Region* r) { - std::set::iterator i = _soloSelectedRegions.find(r); + std::set::iterator i = _soloSelectedRegions.find (r); - return ( i != _soloSelectedRegions.end() ); + return (i != _soloSelectedRegions.end ()); } bool -Playlist::SoloSelectedActive() +Playlist::SoloSelectedActive () { - return !_soloSelectedRegions.empty(); + return !_soloSelectedRegions.empty (); } - void Playlist::possibly_splice (samplepos_t at, samplecnt_t distance, boost::shared_ptr exclude) { @@ -1616,18 +1590,17 @@ Playlist::splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_p { _splicing = true; - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if (exclude && (*i) == exclude) { continue; } - if ((*i)->position() >= at) { - samplepos_t new_pos = (*i)->position() + distance; + if ((*i)->position () >= at) { + samplepos_t new_pos = (*i)->position () + distance; if (new_pos < 0) { new_pos = 0; - } else if (new_pos >= max_samplepos - (*i)->length()) { - new_pos = max_samplepos - (*i)->length(); + } else if (new_pos >= max_samplepos - (*i)->length ()) { + new_pos = max_samplepos - (*i)->length (); } thawlist.add (*i); @@ -1641,36 +1614,36 @@ Playlist::splice_unlocked (samplepos_t at, samplecnt_t distance, boost::shared_p } void -Playlist::ripple_locked (samplepos_t at, samplecnt_t distance, RegionList *exclude) +Playlist::ripple_locked (samplepos_t at, samplecnt_t distance, RegionList* exclude) { RegionWriteLock rl (this); ripple_unlocked (at, distance, exclude, rl.thawlist); } void -Playlist::ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList *exclude, ThawList& thawlist) +Playlist::ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList* exclude, ThawList& thawlist) { if (distance == 0) { return; } - _rippling = true; + _rippling = true; RegionListProperty copy = regions; - for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { - assert (i != copy.end()); + for (RegionList::iterator i = copy.begin (); i != copy.end (); ++i) { + assert (i != copy.end ()); if (exclude) { - if (std::find(exclude->begin(), exclude->end(), (*i)) != exclude->end()) { + if (std::find (exclude->begin (), exclude->end (), (*i)) != exclude->end ()) { continue; } } - if ((*i)->position() >= at) { - samplepos_t new_pos = (*i)->position() + distance; - samplepos_t limit = max_samplepos - (*i)->length(); + if ((*i)->position () >= at) { + samplepos_t new_pos = (*i)->position () + distance; + samplepos_t limit = max_samplepos - (*i)->length (); if (new_pos < 0) { new_pos = 0; - } else if (new_pos >= limit ) { + } else if (new_pos >= limit) { new_pos = limit; } @@ -1683,7 +1656,6 @@ Playlist::ripple_unlocked (samplepos_t at, samplecnt_t distance, RegionList *exc notify_contents_changed (); } - void Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr region) { @@ -1692,16 +1664,15 @@ Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shar } if (what_changed.contains (Properties::position)) { - /* remove it from the list then add it back in * the right place again. */ RegionSortByPosition cmp; - RegionList::iterator i = find (regions.begin(), regions.end(), region); + RegionList::iterator i = find (regions.begin (), regions.end (), region); - if (i == regions.end()) { + if (i == regions.end ()) { /* the region bounds are being modified but its not currently * in the region list. we will use its bounds correctly when/if * it is added @@ -1710,23 +1681,22 @@ Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shar } regions.erase (i); - regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + regions.insert (upper_bound (regions.begin (), regions.end (), region, cmp), region); } if (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) { - sampleoffset_t delta = 0; if (what_changed.contains (Properties::position)) { - delta = region->position() - region->last_position(); + delta = region->position () - region->last_position (); } if (what_changed.contains (Properties::length)) { - delta += region->length() - region->last_length(); + delta += region->length () - region->last_length (); } if (delta) { - possibly_splice (region->last_position() + region->last_length(), delta, region); + possibly_splice (region->last_position () + region->last_length (), delta, region); } if (holding_state ()) { @@ -1735,8 +1705,8 @@ Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shar notify_contents_changed (); relayer (); list > xf; - xf.push_back (Evoral::Range (region->last_range())); - xf.push_back (Evoral::Range (region->range())); + xf.push_back (Evoral::Range (region->last_range ())); + xf.push_back (Evoral::Range (region->range ())); coalesce_and_check_crossfades (xf); } } @@ -1745,7 +1715,7 @@ Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shar void Playlist::region_changed_proxy (const PropertyChange& what_changed, boost::weak_ptr weak_region) { - boost::shared_ptr region (weak_region.lock()); + boost::shared_ptr region (weak_region.lock ()); if (!region) { return; @@ -1761,7 +1731,7 @@ Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr< { PropertyChange our_interests; PropertyChange bounds; - bool save = false; + bool save = false; if (in_set_state || in_flush) { return false; @@ -1780,7 +1750,7 @@ Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr< if (what_changed.contains (bounds)) { region_bounds_changed (what_changed, region); - save = !(_splicing || _nudging); + save = !(_splicing || _nudging); send_contents = true; } @@ -1828,7 +1798,7 @@ Playlist::sync_all_regions_with_regions () all_regions.clear (); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { all_regions.insert (*i); } } @@ -1842,20 +1812,19 @@ Playlist::clear (bool with_signals) region_state_changed_connections.drop_connections (); region_drop_references_connections.drop_connections (); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { pending_removes.insert (*i); } regions.clear (); - for (set >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) { + for (set >::iterator s = pending_removes.begin (); s != pending_removes.end (); ++s) { remove_dependents (*s); } } if (with_signals) { - - for (set >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) { + for (set >::iterator s = pending_removes.begin (); s != pending_removes.end (); ++s) { RegionRemoved (boost::weak_ptr (*s)); /* EMIT SIGNAL */ } @@ -1863,7 +1832,6 @@ Playlist::clear (bool with_signals) pending_contents_change = false; ContentsChanged (); } - } /* ********************************************************************* @@ -1871,9 +1839,9 @@ FINDING THINGS **********************************************************************/ boost::shared_ptr -Playlist::region_list() +Playlist::region_list () { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr rlist (new RegionList (regions.rlist ())); return rlist; } @@ -1881,9 +1849,9 @@ Playlist::region_list() void Playlist::deep_sources (std::set >& sources) const { - RegionReadLock rlock (const_cast(this)); + RegionReadLock rlock (const_cast (this)); - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { (*i)->deep_sources (sources); } } @@ -1898,10 +1866,10 @@ Playlist::regions_at (samplepos_t sample) uint32_t Playlist::count_regions_at (samplepos_t sample) const { - RegionReadLock rlock (const_cast(this)); - uint32_t cnt = 0; + RegionReadLock rlock (const_cast (this)); + uint32_t cnt = 0; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i)->covers (sample)) { cnt++; } @@ -1913,14 +1881,14 @@ Playlist::count_regions_at (samplepos_t sample) const boost::shared_ptr Playlist::top_region_at (samplepos_t sample) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr rlist = find_regions_at (sample); - boost::shared_ptr region; + boost::shared_ptr region; - if (rlist->size()) { + if (rlist->size ()) { RegionSortByLayer cmp; rlist->sort (cmp); - region = rlist->back(); + region = rlist->back (); } return region; @@ -1929,16 +1897,15 @@ Playlist::top_region_at (samplepos_t sample) boost::shared_ptr Playlist::top_unmuted_region_at (samplepos_t sample) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr rlist = find_regions_at (sample); - for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) { - + for (RegionList::iterator i = rlist->begin (); i != rlist->end ();) { RegionList::iterator tmp = i; ++tmp; - if ((*i)->muted()) { + if ((*i)->muted ()) { rlist->erase (i); } @@ -1947,10 +1914,10 @@ Playlist::top_unmuted_region_at (samplepos_t sample) boost::shared_ptr region; - if (rlist->size()) { + if (rlist->size ()) { RegionSortByLayer cmp; rlist->sort (cmp); - region = rlist->back(); + region = rlist->back (); } return region; @@ -1963,7 +1930,7 @@ Playlist::find_regions_at (samplepos_t sample) boost::shared_ptr rlist (new RegionList); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i)->covers (sample)) { rlist->push_back (*i); } @@ -1975,11 +1942,11 @@ Playlist::find_regions_at (samplepos_t sample) boost::shared_ptr Playlist::regions_with_start_within (Evoral::Range range) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr rlist (new RegionList); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->first_sample() >= range.from && (*i)->first_sample() <= range.to) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->first_sample () >= range.from && (*i)->first_sample () <= range.to) { rlist->push_back (*i); } } @@ -1990,11 +1957,11 @@ Playlist::regions_with_start_within (Evoral::Range range) boost::shared_ptr Playlist::regions_with_end_within (Evoral::Range range) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr rlist (new RegionList); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->last_sample() >= range.from && (*i)->last_sample() <= range.to) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->last_sample () >= range.from && (*i)->last_sample () <= range.to) { rlist->push_back (*i); } } @@ -2014,7 +1981,7 @@ Playlist::regions_touched_locked (samplepos_t start, samplepos_t end) { boost::shared_ptr rlist (new RegionList); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i)->coverage (start, end) != Evoral::OverlapNone) { rlist->push_back (*i); } @@ -2026,17 +1993,17 @@ Playlist::regions_touched_locked (samplepos_t start, samplepos_t end) samplepos_t Playlist::find_next_transient (samplepos_t from, int dir) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); AnalysisFeatureList points; AnalysisFeatureList these_points; - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if (dir > 0) { - if ((*i)->last_sample() < from) { + if ((*i)->last_sample () < from) { continue; } } else { - if ((*i)->first_sample() > from) { + if ((*i)->first_sample () > from) { continue; } } @@ -2045,21 +2012,21 @@ Playlist::find_next_transient (samplepos_t from, int dir) /* add first sample, just, err, because */ - these_points.push_back ((*i)->first_sample()); + these_points.push_back ((*i)->first_sample ()); - points.insert (points.end(), these_points.begin(), these_points.end()); + points.insert (points.end (), these_points.begin (), these_points.end ()); these_points.clear (); } - if (points.empty()) { + if (points.empty ()) { return -1; } - TransientDetector::cleanup_transients (points, _session.sample_rate(), 3.0); + TransientDetector::cleanup_transients (points, _session.sample_rate (), 3.0); bool reached = false; if (dir > 0) { - for (AnalysisFeatureList::const_iterator x = points.begin(); x != points.end(); ++x) { + for (AnalysisFeatureList::const_iterator x = points.begin (); x != points.end (); ++x) { if ((*x) >= from) { reached = true; } @@ -2069,7 +2036,7 @@ Playlist::find_next_transient (samplepos_t from, int dir) } } } else { - for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) { + for (AnalysisFeatureList::reverse_iterator x = points.rbegin (); x != points.rend (); ++x) { if ((*x) <= from) { reached = true; } @@ -2086,57 +2053,57 @@ Playlist::find_next_transient (samplepos_t from, int dir) boost::shared_ptr Playlist::find_next_region (samplepos_t sample, RegionPoint point, int dir) { - RegionReadLock rlock (this); + RegionReadLock rlock (this); boost::shared_ptr ret; - samplepos_t closest = max_samplepos; + samplepos_t closest = max_samplepos; bool end_iter = false; - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + if (end_iter) + break; - if(end_iter) break; - - sampleoffset_t distance; - boost::shared_ptr r = (*i); - samplepos_t pos = 0; + sampleoffset_t distance; + boost::shared_ptr r = (*i); + samplepos_t pos = 0; switch (point) { - case Start: - pos = r->first_sample (); - break; - case End: - pos = r->last_sample (); - break; - case SyncPoint: - pos = r->sync_position (); - break; + case Start: + pos = r->first_sample (); + break; + case End: + pos = r->last_sample (); + break; + case SyncPoint: + pos = r->sync_position (); + break; } switch (dir) { - case 1: /* forwards */ + case 1: /* forwards */ - if (pos > sample) { - if ((distance = pos - sample) < closest) { - closest = distance; - ret = r; + if (pos > sample) { + if ((distance = pos - sample) < closest) { + closest = distance; + ret = r; + end_iter = true; + } + } + + break; + + default: /* backwards */ + + if (pos < sample) { + if ((distance = sample - pos) < closest) { + closest = distance; + ret = r; + } + } else { end_iter = true; } - } - break; - - default: /* backwards */ - - if (pos < sample) { - if ((distance = sample - pos) < closest) { - closest = distance; - ret = r; - } - } else { - end_iter = true; - } - - break; + break; } } @@ -2149,63 +2116,55 @@ Playlist::find_next_region_boundary (samplepos_t sample, int dir) RegionReadLock rlock (this); samplepos_t closest = max_samplepos; - samplepos_t ret = -1; + samplepos_t ret = -1; if (dir > 0) { - - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { boost::shared_ptr r = (*i); - sampleoffset_t distance; - const samplepos_t first_sample = r->first_sample(); - const samplepos_t last_sample = r->last_sample(); + sampleoffset_t distance; + const samplepos_t first_sample = r->first_sample (); + const samplepos_t last_sample = r->last_sample (); if (first_sample > sample) { - distance = first_sample - sample; if (distance < closest) { - ret = first_sample; + ret = first_sample; closest = distance; } } if (last_sample > sample) { - distance = last_sample - sample; if (distance < closest) { - ret = last_sample; + ret = last_sample; closest = distance; } } } } else { - - for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) { - + for (RegionList::reverse_iterator i = regions.rbegin (); i != regions.rend (); ++i) { boost::shared_ptr r = (*i); - sampleoffset_t distance; - const samplepos_t first_sample = r->first_sample(); - const samplepos_t last_sample = r->last_sample(); + sampleoffset_t distance; + const samplepos_t first_sample = r->first_sample (); + const samplepos_t last_sample = r->last_sample (); if (last_sample < sample) { - distance = sample - last_sample; if (distance < closest) { - ret = last_sample; + ret = last_sample; closest = distance; } } if (first_sample < sample) { - distance = sample - first_sample; if (distance < closest) { - ret = first_sample; + ret = first_sample; closest = distance; } } @@ -2223,14 +2182,14 @@ Playlist::mark_session_dirty () _cached_extent.reset (); if (!in_set_state && !holding_state ()) { - _session.set_dirty(); + _session.set_dirty (); } } void Playlist::rdiff (vector& cmds) const { - RegionReadLock rlock (const_cast (this)); + RegionReadLock rlock (const_cast (this)); Stateful::rdiff (cmds); } @@ -2245,17 +2204,17 @@ void Playlist::update (const RegionListProperty::ChangeRecord& change) { DEBUG_TRACE (DEBUG::Properties, string_compose ("Playlist %1 updates from a change record with %2 adds %3 removes\n", - name(), change.added.size(), change.removed.size())); + name (), change.added.size (), change.removed.size ())); freeze (); { RegionWriteLock rlock (this); /* add the added regions */ - for (RegionListProperty::ChangeContainer::const_iterator i = change.added.begin(); i != change.added.end(); ++i) { - add_region_internal ((*i), (*i)->position(), rlock.thawlist); + for (RegionListProperty::ChangeContainer::const_iterator i = change.added.begin (); i != change.added.end (); ++i) { + add_region_internal ((*i), (*i)->position (), rlock.thawlist); } /* remove the removed regions */ - for (RegionListProperty::ChangeContainer::const_iterator i = change.removed.begin(); i != change.removed.end(); ++i) { + for (RegionListProperty::ChangeContainer::const_iterator i = change.removed.begin (); i != change.removed.end (); ++i) { remove_region_internal (*i, rlock.thawlist); } } @@ -2266,18 +2225,18 @@ Playlist::update (const RegionListProperty::ChangeRecord& change) int Playlist::set_state (const XMLNode& node, int version) { - XMLNode *child; - XMLNodeList nlist; - XMLNodeConstIterator niter; - XMLPropertyConstIterator piter; + XMLNode* child; + XMLNodeList nlist; + XMLNodeConstIterator niter; + XMLPropertyConstIterator piter; boost::shared_ptr region; - string region_name; - bool seen_region_nodes = false; - int ret = 0; + string region_name; + bool seen_region_nodes = false; + int ret = 0; in_set_state++; - if (node.name() != "Playlist") { + if (node.name () != "Playlist") { in_set_state--; return -1; } @@ -2303,26 +2262,24 @@ Playlist::set_state (const XMLNode& node, int version) string shared_ids; if (node.get_property (X_("shared-with-ids"), shared_ids)) { - if (!shared_ids.empty()) { + if (!shared_ids.empty ()) { vector result; ::split (shared_ids, result, ','); - vector::iterator it = result.begin(); - for (; it != result.end(); ++it) { - _shared_with_ids.push_back (PBD::ID(*it)); + vector::iterator it = result.begin (); + for (; it != result.end (); ++it) { + _shared_with_ids.push_back (PBD::ID (*it)); } } } clear (true); - nlist = node.children(); - - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + nlist = node.children (); + for (niter = nlist.begin (); niter != nlist.end (); ++niter) { child = *niter; - if (child->name() == "Region") { - + if (child->name () == "Region") { seen_region_nodes = true; ID id; @@ -2332,7 +2289,6 @@ Playlist::set_state (const XMLNode& node, int version) } if ((region = region_by_id (id))) { - region->suspend_property_changes (); if (region->set_state (*child, version)) { @@ -2349,15 +2305,14 @@ Playlist::set_state (const XMLNode& node, int version) { RegionWriteLock rlock (this); - add_region_internal (region, region->position(), rlock.thawlist); + add_region_internal (region, region->position (), rlock.thawlist); } region->resume_property_changes (); - } } - if (seen_region_nodes && regions.empty()) { + if (seen_region_nodes && regions.empty ()) { ret = -1; } @@ -2371,13 +2326,13 @@ Playlist::set_state (const XMLNode& node, int version) } XMLNode& -Playlist::get_state() +Playlist::get_state () { return state (true); } XMLNode& -Playlist::get_template() +Playlist::get_template () { return state (false); } @@ -2387,20 +2342,20 @@ Playlist::get_template() XMLNode& Playlist::state (bool full_state) { - XMLNode *node = new XMLNode (X_("Playlist")); + XMLNode* node = new XMLNode (X_("Playlist")); - node->set_property (X_("id"), id()); - node->set_property (X_("name"), name()); + node->set_property (X_("id"), id ()); + node->set_property (X_("name"), name ()); node->set_property (X_("type"), _type); node->set_property (X_("orig-track-id"), _orig_track_id); - string shared_ids; - list::const_iterator it = _shared_with_ids.begin(); - for (; it != _shared_with_ids.end(); ++it) { - shared_ids += "," + (*it).to_s(); + string shared_ids; + list::const_iterator it = _shared_with_ids.begin (); + for (; it != _shared_with_ids.end (); ++it) { + shared_ids += "," + (*it).to_s (); } - if (!shared_ids.empty()) { - shared_ids.erase(0,1); + if (!shared_ids.empty ()) { + shared_ids.erase (0, 1); } node->set_property (X_("shared-with-ids"), shared_ids); @@ -2411,9 +2366,9 @@ Playlist::state (bool full_state) node->set_property ("combine-ops", _combine_ops); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - assert ((*i)->sources().size() > 0 && (*i)->master_sources().size() > 0); - node->add_child_nocopy ((*i)->get_state()); + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { + assert ((*i)->sources ().size () > 0 && (*i)->master_sources ().size () > 0); + node->add_child_nocopy ((*i)->get_state ()); } } @@ -2425,27 +2380,27 @@ Playlist::state (bool full_state) } bool -Playlist::empty() const +Playlist::empty () const { - RegionReadLock rlock (const_cast(this)); - return regions.empty(); + RegionReadLock rlock (const_cast (this)); + return regions.empty (); } uint32_t -Playlist::n_regions() const +Playlist::n_regions () const { - RegionReadLock rlock (const_cast(this)); - return regions.size(); + RegionReadLock rlock (const_cast (this)); + return regions.size (); } /** @return true if the all_regions list is empty, ie this playlist * has never had a region added to it. */ bool -Playlist::all_regions_empty() const +Playlist::all_regions_empty () const { - RegionReadLock rl (const_cast (this)); - return all_regions.empty(); + RegionReadLock rl (const_cast (this)); + return all_regions.empty (); } pair @@ -2455,7 +2410,7 @@ Playlist::get_extent () const return _cached_extent.value (); } - RegionReadLock rlock (const_cast(this)); + RegionReadLock rlock (const_cast (this)); _cached_extent = _get_extent (); return _cached_extent.value (); } @@ -2463,7 +2418,7 @@ Playlist::get_extent () const pair Playlist::get_extent_with_endspace () const { - pair l = get_extent(); + pair l = get_extent (); l.second += _end_space; return l; } @@ -2473,13 +2428,13 @@ Playlist::_get_extent () const { pair ext (max_samplepos, 0); - if (regions.empty()) { + if (regions.empty ()) { ext.first = 0; return ext; } - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - pair const e ((*i)->position(), (*i)->position() + (*i)->length()); + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { + pair const e ((*i)->position (), (*i)->position () + (*i)->length ()); if (e.first < ext.first) { ext.first = e.first; } @@ -2492,26 +2447,25 @@ Playlist::_get_extent () const } string -Playlist::bump_name (string name, Session &session) +Playlist::bump_name (string name, Session& session) { string newname = name; do { newname = bump_name_once (newname, '.'); - } while (session.playlists()->by_name (newname)!=NULL); + } while (session.playlists ()->by_name (newname) != NULL); return newname; } - layer_t -Playlist::top_layer() const +Playlist::top_layer () const { - RegionReadLock rlock (const_cast (this)); - layer_t top = 0; + RegionReadLock rlock (const_cast (this)); + layer_t top = 0; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - top = max (top, (*i)->layer()); + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { + top = max (top, (*i)->layer ()); } return top; } @@ -2523,8 +2477,9 @@ Playlist::set_edit_mode (EditMode mode) } struct RelayerSort { - bool operator () (boost::shared_ptr a, boost::shared_ptr b) { - return a->layering_index() < b->layering_index(); + bool operator() (boost::shared_ptr a, boost::shared_ptr b) + { + return a->layering_index () < b->layering_index (); } }; @@ -2539,14 +2494,14 @@ Playlist::set_layer (boost::shared_ptr region, double new_layer) * using the layer indeces. */ - RegionList copy = regions.rlist(); + RegionList copy = regions.rlist (); copy.remove (region); copy.sort (RelayerSort ()); /* Put region back in the right place */ - RegionList::iterator i = copy.begin(); + RegionList::iterator i = copy.begin (); while (i != copy.end ()) { - if ((*i)->layer() > new_layer) { + if ((*i)->layer () > new_layer) { break; } ++i; @@ -2558,18 +2513,19 @@ Playlist::set_layer (boost::shared_ptr region, double new_layer) } void -Playlist::setup_layering_indices (RegionList const & regions) +Playlist::setup_layering_indices (RegionList const& regions) { uint64_t j = 0; - for (RegionList::const_iterator k = regions.begin(); k != regions.end(); ++k) { + for (RegionList::const_iterator k = regions.begin (); k != regions.end (); ++k) { (*k)->set_layering_index (j++); } } struct LaterHigherSort { - bool operator () (boost::shared_ptr a, boost::shared_ptr b) { - return a->position() < b->position(); + bool operator() (boost::shared_ptr a, boost::shared_ptr b) + { + return a->position () < b->position (); } }; @@ -2595,21 +2551,21 @@ Playlist::relayer () /* find the start and end positions of the regions on this playlist */ samplepos_t start = INT64_MAX; - samplepos_t end = 0; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - start = min (start, (*i)->position()); - end = max (end, (*i)->position() + (*i)->length()); + samplepos_t end = 0; + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { + start = min (start, (*i)->position ()); + end = max (end, (*i)->position () + (*i)->length ()); } /* hence the size of each time division */ - double const division_size = (end - start) / double (divisions); + double const division_size = (end - start) / double(divisions); vector > layers; layers.push_back (vector (divisions)); /* Sort our regions into layering index order (for manual layering) or position order (for later is higher)*/ - RegionList copy = regions.rlist(); - switch (Config->get_layer_model()) { + RegionList copy = regions.rlist (); + switch (Config->get_layer_model ()) { case LaterHigher: copy.sort (LaterHigherSort ()); break; @@ -2619,22 +2575,21 @@ Playlist::relayer () } DEBUG_TRACE (DEBUG::Layering, "relayer() using:\n"); - for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { - DEBUG_TRACE (DEBUG::Layering, string_compose ("\t%1 %2\n", (*i)->name(), (*i)->layering_index())); + for (RegionList::iterator i = copy.begin (); i != copy.end (); ++i) { + DEBUG_TRACE (DEBUG::Layering, string_compose ("\t%1 %2\n", (*i)->name (), (*i)->layering_index ())); } - for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { - + for (RegionList::iterator i = copy.begin (); i != copy.end (); ++i) { /* find the time divisions that this region covers; if there are no regions on the list, * division_size will equal 0 and in this case we'll just say that * start_division = end_division = 0. */ int start_division = 0; - int end_division = 0; + int end_division = 0; if (division_size > 0) { - start_division = floor ( ((*i)->position() - start) / division_size); - end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size ); + start_division = floor (((*i)->position () - start) / division_size); + end_division = floor (((*i)->position () + (*i)->length () - start) / division_size); if (end_division == divisions) { end_division--; } @@ -2643,7 +2598,7 @@ Playlist::relayer () assert (divisions == 0 || end_division < divisions); /* find the lowest layer that this region can go on */ - size_t j = layers.size(); + size_t j = layers.size (); while (j > 0) { /* try layer j - 1; it can go on if it overlaps no other region * that is already on that layer @@ -2651,8 +2606,8 @@ Playlist::relayer () bool overlap = false; for (int k = start_division; k <= end_division; ++k) { - RegionList::iterator l = layers[j-1][k].begin (); - while (l != layers[j-1][k].end()) { + RegionList::iterator l = layers[j - 1][k].begin (); + while (l != layers[j - 1][k].end ()) { if ((*l)->overlap_equivalent (*i)) { overlap = true; break; @@ -2673,7 +2628,7 @@ Playlist::relayer () --j; } - if (j == layers.size()) { + if (j == layers.size ()) { /* we need a new layer for this region */ layers.push_back (vector (divisions)); } @@ -2704,14 +2659,14 @@ Playlist::relayer () void Playlist::raise_region (boost::shared_ptr region) { - set_layer (region, region->layer() + 1.5); + set_layer (region, region->layer () + 1.5); relayer (); } void Playlist::lower_region (boost::shared_ptr region) { - set_layer (region, region->layer() - 1.5); + set_layer (region, region->layer () - 1.5); relayer (); } @@ -2733,31 +2688,27 @@ void Playlist::nudge_after (samplepos_t start, samplecnt_t distance, bool forwards) { RegionList::iterator i; - bool moved = false; + bool moved = false; _nudging = true; { - RegionWriteLock rlock (const_cast (this)); - - for (i = regions.begin(); i != regions.end(); ++i) { - - if ((*i)->position() >= start) { + RegionWriteLock rlock (const_cast (this)); + for (i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->position () >= start) { samplepos_t new_pos; if (forwards) { - - if ((*i)->last_sample() > max_samplepos - distance) { - new_pos = max_samplepos - (*i)->length(); + if ((*i)->last_sample () > max_samplepos - distance) { + new_pos = max_samplepos - (*i)->length (); } else { - new_pos = (*i)->position() + distance; + new_pos = (*i)->position () + distance; } } else { - - if ((*i)->position() > distance) { - new_pos = (*i)->position() - distance; + if ((*i)->position () > distance) { + new_pos = (*i)->position () - distance; } else { new_pos = 0; } @@ -2774,7 +2725,6 @@ Playlist::nudge_after (samplepos_t start, samplecnt_t distance, bool forwards) _nudging = false; notify_contents_changed (); } - } bool @@ -2782,7 +2732,7 @@ Playlist::uses_source (boost::shared_ptr src, bool shallow) const { RegionReadLock rlock (const_cast (this)); - for (set >::const_iterator r = all_regions.begin(); r != all_regions.end(); ++r) { + for (set >::const_iterator r = all_regions.begin (); r != all_regions.end (); ++r) { /* Note: passing the second argument as false can cause at best * incredibly deep and time-consuming recursion, and at worst * cycles if the user has managed to create cycles of reference @@ -2797,7 +2747,6 @@ Playlist::uses_source (boost::shared_ptr src, bool shallow) const return false; } - boost::shared_ptr Playlist::find_region (const ID& id) const { @@ -2805,8 +2754,8 @@ Playlist::find_region (const ID& id) const /* searches all regions currently in use by the playlist */ - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->id() == id) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { + if ((*i)->id () == id) { return *i; } } @@ -2818,32 +2767,33 @@ uint32_t Playlist::region_use_count (boost::shared_ptr r) const { RegionReadLock rlock (const_cast (this)); - uint32_t cnt = 0; + uint32_t cnt = 0; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i) == r) { cnt++; } } - RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations()); - for (RegionFactory::CompoundAssociations::iterator it = cassocs.begin(); it != cassocs.end(); ++it) { + RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations ()); + for (RegionFactory::CompoundAssociations::iterator it = cassocs.begin (); it != cassocs.end (); ++it) { /* check if region is used in a compound */ if (it->second == r) { /* region is referenced as 'original' of a compound */ ++cnt; break; } - if (r->whole_file() && r->max_source_level() > 0) { + if (r->whole_file () && r->max_source_level () > 0) { /* region itself ia a compound. * the compound regions are not referenced -> check regions inside compound */ - const SourceList& sl = r->sources(); - for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) { - boost::shared_ptr ps = boost::dynamic_pointer_cast(*s); - if (!ps) continue; - if (ps->playlist()->region_use_count(it->first)) { - // break out of both loops + const SourceList& sl = r->sources (); + for (SourceList::const_iterator s = sl.begin (); s != sl.end (); ++s) { + boost::shared_ptr ps = boost::dynamic_pointer_cast (*s); + if (!ps) + continue; + if (ps->playlist ()->region_use_count (it->first)) { + /* break out of both loops */ return ++cnt; } } @@ -2857,8 +2807,8 @@ Playlist::region_by_id (const ID& id) const { /* searches all regions ever added to this playlist */ - for (set >::const_iterator i = all_regions.begin(); i != all_regions.end(); ++i) { - if ((*i)->id() == id) { + for (set >::const_iterator i = all_regions.begin (); i != all_regions.end (); ++i) { + if ((*i)->id () == id) { return *i; } } @@ -2871,15 +2821,15 @@ Playlist::dump () const boost::shared_ptr r; cerr << "Playlist \"" << _name << "\" " << endl - << regions.size() << " regions " + << regions.size () << " regions " << endl; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { r = *i; - cerr << " " << r->name() << " [" - << r->start() << "+" << r->length() + cerr << " " << r->name () << " [" + << r->start () << "+" << r->length () << "] at " - << r->position() + << r->position () << " on layer " << r->layer () << endl; @@ -2897,7 +2847,7 @@ Playlist::shuffle (boost::shared_ptr region, int dir) { bool moved = false; - if (region->locked()) { + if (region->locked ()) { return; } @@ -2906,49 +2856,46 @@ Playlist::shuffle (boost::shared_ptr region, int dir) { RegionWriteLock rlock (const_cast (this)); - if (dir > 0) { - RegionList::iterator next; - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { if ((*i) == region) { next = i; ++next; - if (next != regions.end()) { - - if ((*next)->locked()) { + if (next != regions.end ()) { + if ((*next)->locked ()) { break; } samplepos_t new_pos; - if ((*next)->position() != region->last_sample() + 1) { + if ((*next)->position () != region->last_sample () + 1) { /* they didn't used to touch, so after shuffle, * just have them swap positions. */ - new_pos = (*next)->position(); + new_pos = (*next)->position (); } else { /* they used to touch, so after shuffle, * make sure they still do. put the earlier * region where the later one will end after * it is moved. */ - new_pos = region->position() + (*next)->length(); + new_pos = region->position () + (*next)->length (); } rlock.thawlist.add (*next); rlock.thawlist.add (region); - (*next)->set_position (region->position()); + (*next)->set_position (region->position ()); region->set_position (new_pos); /* avoid a full sort */ - regions.erase (i); // removes the region from the list */ + regions.erase (i); /* removes the region from the list */ next++; - regions.insert (next, region); // adds it back after next + regions.insert (next, region); /* adds it back after next */ moved = true; } @@ -2956,42 +2903,39 @@ Playlist::shuffle (boost::shared_ptr region, int dir) } } } else { + RegionList::iterator prev = regions.end (); - RegionList::iterator prev = regions.end(); - - for (RegionList::iterator i = regions.begin(); i != regions.end(); prev = i, ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); prev = i, ++i) { if ((*i) == region) { - - if (prev != regions.end()) { - - if ((*prev)->locked()) { + if (prev != regions.end ()) { + if ((*prev)->locked ()) { break; } samplepos_t new_pos; - if (region->position() != (*prev)->last_sample() + 1) { + if (region->position () != (*prev)->last_sample () + 1) { /* they didn't used to touch, so after shuffle, * just have them swap positions. */ - new_pos = region->position(); + new_pos = region->position (); } else { /* they used to touch, so after shuffle, * make sure they still do. put the earlier * one where the later one will end after */ - new_pos = (*prev)->position() + region->length(); + new_pos = (*prev)->position () + region->length (); } rlock.thawlist.add (region); rlock.thawlist.add (*prev); - region->set_position ((*prev)->position()); + region->set_position ((*prev)->position ()); (*prev)->set_position (new_pos); /* avoid a full sort */ - regions.erase (i); // remove region - regions.insert (prev, region); // insert region before prev + regions.erase (i); /* remove region */ + regions.insert (prev, region); /* insert region before prev */ moved = true; } @@ -3005,19 +2949,17 @@ Playlist::shuffle (boost::shared_ptr region, int dir) _shuffling = false; if (moved) { - relayer (); - notify_contents_changed(); + notify_contents_changed (); } - } bool -Playlist::region_is_shuffle_constrained (boost::shared_ptr) + Playlist::region_is_shuffle_constrained (boost::shared_ptr) { RegionReadLock rlock (const_cast (this)); - if (regions.size() > 1) { + if (regions.size () > 1) { return true; } @@ -3025,7 +2967,7 @@ Playlist::region_is_shuffle_constrained (boost::shared_ptr) } void -Playlist::ripple (samplepos_t at, samplecnt_t distance, RegionList *exclude) +Playlist::ripple (samplepos_t at, samplecnt_t distance, RegionList* exclude) { ripple_locked (at, distance, exclude); } @@ -3034,11 +2976,11 @@ void Playlist::update_after_tempo_map_change () { RegionWriteLock rlock (const_cast (this)); - RegionList copy (regions.rlist()); + RegionList copy (regions.rlist ()); freeze (); - for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { + for (RegionList::iterator i = copy.begin (); i != copy.end (); ++i) { rlock.thawlist.add (*i); (*i)->update_after_tempo_map_change (); } @@ -3050,7 +2992,7 @@ void Playlist::foreach_region (boost::function)> s) { RegionReadLock rl (this); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + for (RegionList::iterator i = regions.begin (); i != regions.end (); ++i) { s (*i); } } @@ -3058,14 +3000,14 @@ Playlist::foreach_region (boost::function)> s) bool Playlist::has_region_at (samplepos_t const p) const { - RegionReadLock (const_cast (this)); + RegionReadLock (const_cast (this)); RegionList::const_iterator i = regions.begin (); - while (i != regions.end() && !(*i)->covers (p)) { + while (i != regions.end () && !(*i)->covers (p)) { ++i; } - return (i != regions.end()); + return (i != regions.end ()); } /** Look from a session sample time and find the start time of the next region @@ -3076,16 +3018,16 @@ Playlist::has_region_at (samplepos_t const p) const samplepos_t Playlist::find_next_top_layer_position (samplepos_t t) const { - RegionReadLock rlock (const_cast (this)); + RegionReadLock rlock (const_cast (this)); layer_t const top = top_layer (); RegionList copy = regions.rlist (); copy.sort (RegionSortByPosition ()); - for (RegionList::const_iterator i = copy.begin(); i != copy.end(); ++i) { - if ((*i)->position() >= t && (*i)->layer() == top) { - return (*i)->position(); + for (RegionList::const_iterator i = copy.begin (); i != copy.end (); ++i) { + if ((*i)->position () >= t && (*i)->layer () == top) { + return (*i)->position (); } } @@ -3095,30 +3037,30 @@ Playlist::find_next_top_layer_position (samplepos_t t) const boost::shared_ptr Playlist::combine (const RegionList& r) { - PropertyList plist; - uint32_t channels = 0; - uint32_t layer = 0; - samplepos_t earliest_position = max_samplepos; - vector old_and_new_regions; + PropertyList plist; + uint32_t channels = 0; + uint32_t layer = 0; + samplepos_t earliest_position = max_samplepos; + vector old_and_new_regions; vector > originals; vector > copies; - string parent_name; - string child_name; - uint32_t max_level = 0; + string parent_name; + string child_name; + uint32_t max_level = 0; /* find the maximum depth of all the regions we're combining */ - for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { - max_level = max (max_level, (*i)->max_source_level()); + for (RegionList::const_iterator i = r.begin (); i != r.end (); ++i) { + max_level = max (max_level, (*i)->max_source_level ()); } - parent_name = RegionFactory::compound_region_name (name(), combine_ops(), max_level, true); - child_name = RegionFactory::compound_region_name (name(), combine_ops(), max_level, false); + parent_name = RegionFactory::compound_region_name (name (), combine_ops (), max_level, true); + child_name = RegionFactory::compound_region_name (name (), combine_ops (), max_level, false); boost::shared_ptr pl = PlaylistFactory::create (_type, _session, parent_name, true); - for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { - earliest_position = min (earliest_position, (*i)->position()); + for (RegionList::const_iterator i = r.begin (); i != r.end (); ++i) { + earliest_position = min (earliest_position, (*i)->position ()); } /* enable this so that we do not try to create xfades etc. as we add @@ -3131,17 +3073,16 @@ Playlist::combine (const RegionList& r) * route_time_axis passes 'selected_regions' - which is not sorted. * here we need the top-most first, then every layer's region sorted by position. */ - RegionList sorted(r); - sorted.sort(RegionSortByLayerAndPosition()); - - for (RegionList::const_iterator i = sorted.begin(); i != sorted.end(); ++i) { + RegionList sorted (r); + sorted.sort (RegionSortByLayerAndPosition ()); + for (RegionList::const_iterator i = sorted.begin (); i != sorted.end (); ++i) { /* copy the region */ boost::shared_ptr original_region = (*i); - boost::shared_ptr copied_region = RegionFactory::create (original_region, false); + boost::shared_ptr copied_region = RegionFactory::create (original_region, false); - old_and_new_regions.push_back (TwoRegions (original_region,copied_region)); + old_and_new_regions.push_back (TwoRegions (original_region, copied_region)); originals.push_back (original_region); copies.push_back (copied_region); @@ -3149,16 +3090,16 @@ Playlist::combine (const RegionList& r) /* make position relative to zero */ - pl->add_region (copied_region, original_region->position() - earliest_position); + pl->add_region (copied_region, original_region->position () - earliest_position); copied_region->set_layer (original_region->layer ()); /* use the maximum number of channels for any region */ - channels = max (channels, original_region->n_channels()); + channels = max (channels, original_region->n_channels ()); /* it will go above the layer of the highest existing region */ - layer = max (layer, original_region->layer()); + layer = max (layer, original_region->layer ()); } pl->in_partition = false; @@ -3167,12 +3108,11 @@ Playlist::combine (const RegionList& r) /* now create a new PlaylistSource for each channel in the new playlist */ - SourceList sources; - pair extent = pl->get_extent(); + SourceList sources; + pair extent = pl->get_extent (); for (uint32_t chn = 0; chn < channels; ++chn) { - sources.push_back (SourceFactory::createFromPlaylist (_type, _session, pl, id(), parent_name, chn, 0, extent.second, false, false)); - + sources.push_back (SourceFactory::createFromPlaylist (_type, _session, pl, id (), parent_name, chn, 0, extent.second, false, false)); } /* now a new whole-file region using the list of sources */ @@ -3190,19 +3130,19 @@ Playlist::combine (const RegionList& r) plist.add (Properties::start, 0); plist.add (Properties::length, extent.second); plist.add (Properties::name, child_name); - plist.add (Properties::layer, layer+1); + plist.add (Properties::layer, layer + 1); boost::shared_ptr compound_region = RegionFactory::create (parent_region, plist, true); - for (SourceList::iterator s = sources.begin(); s != sources.end(); ++s) { - boost::dynamic_pointer_cast(*s)->set_owner (compound_region->id()); + for (SourceList::iterator s = sources.begin (); s != sources.end (); ++s) { + boost::dynamic_pointer_cast (*s)->set_owner (compound_region->id ()); } /* remove all the selected regions from the current playlist */ freeze (); - for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + for (RegionList::const_iterator i = r.begin (); i != r.end (); ++i) { remove_region (*i); } @@ -3224,21 +3164,21 @@ Playlist::combine (const RegionList& r) void Playlist::uncombine (boost::shared_ptr target) { - boost::shared_ptr pls; - boost::shared_ptr pl; + boost::shared_ptr pls; + boost::shared_ptr pl; vector > originals; - vector old_and_new_regions; + vector old_and_new_regions; - // (1) check that its really a compound region + /* (1) check that its really a compound region */ - if ((pls = boost::dynamic_pointer_cast(target->source (0))) == 0) { + if ((pls = boost::dynamic_pointer_cast (target->source (0))) == 0) { return; } - pl = pls->playlist(); + pl = pls->playlist (); - samplepos_t adjusted_start = 0; // gcc isn't smart enough - samplepos_t adjusted_end = 0; // gcc isn't smart enough + samplepos_t adjusted_start = 0; /* gcc isn't smart enough */ + samplepos_t adjusted_end = 0; /* gcc isn't smart enough */ /* the leftmost (earliest) edge of the compound region * starts at zero in its source, or larger if it @@ -3249,11 +3189,11 @@ Playlist::uncombine (boost::shared_ptr target) * the length of the region. */ - // (2) get all the original regions + /* (2) get all the original regions */ - const RegionList& rl (pl->region_list_property().rlist()); - RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations()); - sampleoffset_t move_offset = 0; + const RegionList& rl (pl->region_list_property ().rlist ()); + RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations ()); + sampleoffset_t move_offset = 0; /* there are three possibilities here: 1) the playlist that the playlist source was based on @@ -3270,16 +3210,15 @@ Playlist::uncombine (boost::shared_ptr target) the original regions, and add them instead. */ - const bool need_copies = (boost::dynamic_pointer_cast (pls)->owner() != target->id()) || - (pls->original() != id()); - - for (RegionList::const_iterator i = rl.begin(); i != rl.end(); ++i) { + const bool need_copies = (boost::dynamic_pointer_cast (pls)->owner () != target->id ()) || + (pls->original () != id ()); + for (RegionList::const_iterator i = rl.begin (); i != rl.end (); ++i) { boost::shared_ptr current (*i); RegionFactory::CompoundAssociations::iterator ca = cassocs.find (*i); - if (ca == cassocs.end()) { + if (ca == cassocs.end ()) { continue; } @@ -3287,14 +3226,14 @@ Playlist::uncombine (boost::shared_ptr target) bool modified_region; - if (i == rl.begin()) { - move_offset = (target->position() - original->position()) - target->start(); - adjusted_start = original->position() + target->start(); - adjusted_end = adjusted_start + target->length(); + if (i == rl.begin ()) { + move_offset = (target->position () - original->position ()) - target->start (); + adjusted_start = original->position () + target->start (); + adjusted_end = adjusted_start + target->length (); } if (need_copies) { - samplepos_t pos = original->position(); + samplepos_t pos = original->position (); /* make a copy, but don't announce it */ original = RegionFactory::create (original, false); /* the pure copy constructor resets position() to zero, so fix that up. */ @@ -3310,42 +3249,42 @@ Playlist::uncombine (boost::shared_ptr target) modified_region = false; switch (original->coverage (adjusted_start, adjusted_end)) { - case Evoral::OverlapNone: - /* original region does not cover any part + case Evoral::OverlapNone: + /* original region does not cover any part * of the current state of the compound region */ - continue; + continue; - case Evoral::OverlapInternal: - /* overlap is just a small piece inside the + case Evoral::OverlapInternal: + /* overlap is just a small piece inside the * original so trim both ends */ - original->trim_to (adjusted_start, adjusted_end - adjusted_start); - modified_region = true; - break; + original->trim_to (adjusted_start, adjusted_end - adjusted_start); + modified_region = true; + break; - case Evoral::OverlapExternal: - /* overlap fully covers original, so leave it as is */ - break; + case Evoral::OverlapExternal: + /* overlap fully covers original, so leave it as is */ + break; - case Evoral::OverlapEnd: - /* overlap starts within but covers end, so trim the front of the region */ - original->trim_front (adjusted_start); - modified_region = true; - break; + case Evoral::OverlapEnd: + /* overlap starts within but covers end, so trim the front of the region */ + original->trim_front (adjusted_start); + modified_region = true; + break; - case Evoral::OverlapStart: - /* overlap covers start but ends within, so + case Evoral::OverlapStart: + /* overlap covers start but ends within, so * trim the end of the region. */ - original->trim_end (adjusted_end); - modified_region = true; - break; + original->trim_end (adjusted_end); + modified_region = true; + break; } if (move_offset) { /* fix the position to match any movement of the compound region. */ - original->set_position (original->position() + move_offset); + original->set_position (original->position () + move_offset); modified_region = true; } @@ -3366,17 +3305,17 @@ Playlist::uncombine (boost::shared_ptr target) in_partition = true; freeze (); - // (3) remove the compound region + /* (3) remove the compound region */ remove_region (target); - // (4) add the constituent regions + /* (4) add the constituent regions */ - for (vector >::iterator i = originals.begin(); i != originals.end(); ++i) { - add_region ((*i), (*i)->position()); - set_layer((*i), (*i)->layer()); - if (!RegionFactory::region_by_id((*i)->id())) { - RegionFactory::map_add(*i); + for (vector >::iterator i = originals.begin (); i != originals.end (); ++i) { + add_region ((*i), (*i)->position ()); + set_layer ((*i), (*i)->layer ()); + if (!RegionFactory::region_by_id ((*i)->id ())) { + RegionFactory::map_add (*i); } } @@ -3388,10 +3327,10 @@ void Playlist::fade_range (list& ranges) { RegionReadLock rlock (this); - for (list::iterator r = ranges.begin(); r != ranges.end(); ) { + for (list::iterator r = ranges.begin (); r != ranges.end ();) { list::iterator tmpr = r; ++tmpr; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ) { + for (RegionList::const_iterator i = regions.begin (); i != regions.end ();) { RegionList::const_iterator tmpi = i; ++tmpi; (*i)->fade_range ((*r).start, (*r).end); @@ -3404,11 +3343,11 @@ Playlist::fade_range (list& ranges) uint32_t Playlist::max_source_level () const { - RegionReadLock rlock (const_cast (this)); - uint32_t lvl = 0; + RegionReadLock rlock (const_cast (this)); + uint32_t lvl = 0; - for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - lvl = max (lvl, (*i)->max_source_level()); + for (RegionList::const_iterator i = regions.begin (); i != regions.end (); ++i) { + lvl = max (lvl, (*i)->max_source_level ()); } return lvl; @@ -3417,8 +3356,8 @@ Playlist::max_source_level () const void Playlist::set_orig_track_id (const PBD::ID& id) { - if (shared_with(id)) { - // Swap 'shared_id' / origin_track_id + if (shared_with (id)) { + /* Swap 'shared_id' / origin_track_id */ unshare_with (id); share_with (_orig_track_id); } @@ -3428,7 +3367,7 @@ Playlist::set_orig_track_id (const PBD::ID& id) void Playlist::share_with (const PBD::ID& id) { - if (!shared_with(id)) { + if (!shared_with (id)) { _shared_with_ids.push_back (id); } } @@ -3437,7 +3376,7 @@ void Playlist::unshare_with (const PBD::ID& id) { list::iterator it = _shared_with_ids.begin (); - while (it != _shared_with_ids.end()) { + while (it != _shared_with_ids.end ()) { if (*it == id) { _shared_with_ids.erase (it); break; @@ -3449,9 +3388,9 @@ Playlist::unshare_with (const PBD::ID& id) bool Playlist::shared_with (const PBD::ID& id) const { - bool shared = false; - list::const_iterator it = _shared_with_ids.begin (); - while (it != _shared_with_ids.end() && !shared) { + bool shared = false; + list::const_iterator it = _shared_with_ids.begin (); + while (it != _shared_with_ids.end () && !shared) { if (*it == id) { shared = true; } @@ -3464,7 +3403,7 @@ Playlist::shared_with (const PBD::ID& id) const void Playlist::reset_shares () { - _shared_with_ids.clear(); + _shared_with_ids.clear (); } /** Take a list of ranges, coalesce any that can be coalesced, then call @@ -3480,17 +3419,16 @@ Playlist::coalesce_and_check_crossfades (list > range /* XXX: xfade: this is implemented in Evoral::RangeList */ restart: - for (list >::iterator i = ranges.begin(); i != ranges.end(); ++i) { - for (list >::iterator j = ranges.begin(); j != ranges.end(); ++j) { - + for (list >::iterator i = ranges.begin (); i != ranges.end (); ++i) { + for (list >::iterator j = ranges.begin (); j != ranges.end (); ++j) { if (i == j) { continue; } - // XXX i->from can be > i->to - is this right? coverage() will return OverlapNone in this case + /* XXX i->from can be > i->to - is this right? coverage() will return OverlapNone in this case */ if (Evoral::coverage (i->from, i->to, j->from, j->to) != Evoral::OverlapNone) { i->from = min (i->from, j->from); - i->to = max (i->to, j->to); + i->to = max (i->to, j->to); ranges.erase (j); goto restart; }