X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=f57093ea40fa2fd542059310eb2d7f8b288d39a1;hb=e51ceb95d5b90942fbc14a7070d786e089ce3186;hp=eca7b67e38d1b7e20e5419a96bf216fe6b7abec9;hpb=6535cd1b1dbab7cc59a356c81d92dbc2cf25333b;p=ardour.git diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc index eca7b67e38..f57093ea40 100644 --- a/libs/ardour/playlist.cc +++ b/libs/ardour/playlist.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2003 Paul Davis + Copyright (C) 2000-2003 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,7 +15,6 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include @@ -28,14 +27,17 @@ #include -#include -#include -#include +#include "pbd/failed_constructor.h" +#include "pbd/stl_delete.h" +#include "pbd/xml++.h" +#include "pbd/stacktrace.h" -#include -#include -#include -#include +#include "ardour/playlist.h" +#include "ardour/session.h" +#include "ardour/region.h" +#include "ardour/region_factory.h" +#include "ardour/playlist_factory.h" +#include "ardour/transient_detector.h" #include "i18n.h" @@ -43,14 +45,12 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -sigc::signal Playlist::PlaylistCreated; - struct ShowMeTheList { - ShowMeTheList (Playlist *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; }; - Playlist *playlist; + boost::shared_ptr playlist; string name; }; @@ -60,6 +60,23 @@ struct RegionSortByLayer { } }; +struct RegionSortByLayerWithPending { + bool operator () (boost::shared_ptr a, boost::shared_ptr b) { + + double p = a->layer (); + if (a->pending_explicit_relayer()) { + p += 0.5; + } + + double q = b->layer (); + if (b->pending_explicit_relayer()) { + q += 0.5; + } + + return p < q; + } +}; + struct RegionSortByPosition { bool operator() (boost::shared_ptr a, boost::shared_ptr b) { return a->position() < b->position(); @@ -72,74 +89,80 @@ struct RegionSortByLastLayerOp { } }; -Playlist::Playlist (Session& sess, string nom, bool hide) - : _session (sess) + +Playlist::Playlist (Session& sess, string nom, DataType type, bool hide) + : SessionObject(sess, nom) + , _type(type) { init (hide); + first_set_state = false; _name = nom; - + } -Playlist::Playlist (Session& sess, const XMLNode& node, bool hide) - : _session (sess) +Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide) + : SessionObject(sess, "unnamed playlist") + , _type(type) { + const XMLProperty* prop = node.property("type"); + assert(!prop || DataType(prop->value()) == _type); + init (hide); _name = "unnamed"; /* reset by set_state */ - - if (set_state (node)) { - throw failed_constructor(); - } + + /* set state called by derived class */ } -Playlist::Playlist (const Playlist& other, string namestr, bool hide) - : _name (namestr), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id) +Playlist::Playlist (boost::shared_ptr other, string namestr, bool hide) + : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id) { init (hide); RegionList tmp; - other.copy_regions (tmp); - - in_set_state = true; + other->copy_regions (tmp); + + in_set_state++; for (list >::iterator x = tmp.begin(); x != tmp.end(); ++x) { - add_region_internal( (*x), (*x)->position() ); + add_region_internal( (*x), (*x)->position()); } - in_set_state = false; + in_set_state--; - _splicing = other._splicing; - _nudging = other._nudging; - _edit_mode = other._edit_mode; + _splicing = other->_splicing; + _nudging = other->_nudging; + _edit_mode = other->_edit_mode; - in_set_state = false; + in_set_state = 0; + first_set_state = false; in_flush = false; in_partition = false; subcnt = 0; _read_data_count = 0; - _frozen = other._frozen; - save_on_thaw = false; - - layer_op_counter = other.layer_op_counter; - freeze_length = other.freeze_length; - + _frozen = other->_frozen; + + layer_op_counter = other->layer_op_counter; + freeze_length = other->freeze_length; } -Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t cnt, string str, bool hide) - : _name (str), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id) +Playlist::Playlist (boost::shared_ptr other, nframes_t start, nframes_t cnt, string str, bool hide) + : SessionObject(other->_session, str), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id) { - RegionLock rlock2 (&((Playlist&)other)); - - jack_nframes_t end = start + cnt - 1; + RegionLock rlock2 (const_cast (other.get())); + + nframes_t end = start + cnt - 1; init (hide); - for (RegionList::const_iterator i = other.regions.begin(); i != other.regions.end(); i++) { + in_set_state++; + + for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); i++) { boost::shared_ptr region; boost::shared_ptr new_region; - jack_nframes_t offset = 0; - jack_nframes_t position = 0; - jack_nframes_t len = 0; + nframes_t offset = 0; + nframes_t position = 0; + nframes_t len = 0; string new_name; OverlapType overlap; @@ -180,36 +203,34 @@ Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t new_region = RegionFactory::RegionFactory::create (region, offset, len, new_name, region->layer(), region->flags()); - add_region_internal (new_region, position, true); + add_region_internal (new_region, position); } - + + in_set_state--; + first_set_state = false; + /* this constructor does NOT notify others (session) */ } void -Playlist::ref () +Playlist::use () { ++_refcnt; - InUse (this, true); /* EMIT SIGNAL */ + InUse (true); /* EMIT SIGNAL */ } void -Playlist::unref () +Playlist::release () { if (_refcnt > 0) { - _refcnt--; + _refcnt--; } + if (_refcnt == 0) { - InUse (this, false); /* EMIT SIGNAL */ - - if (_hidden) { - /* nobody knows we exist */ - delete this; - } + InUse (false); /* EMIT SIGNAL */ } } - void Playlist::copy_regions (RegionList& newlist) const { @@ -227,42 +248,40 @@ Playlist::init (bool hide) g_atomic_int_set (&ignore_state_changes, 0); pending_modified = false; pending_length = false; + first_set_state = true; _refcnt = 0; _hidden = hide; _splicing = false; + _shuffling = false; _nudging = false; - in_set_state = false; - _edit_mode = _session.get_edit_mode(); + in_set_state = 0; + _edit_mode = Config->get_edit_mode(); in_flush = false; in_partition = false; subcnt = 0; _read_data_count = 0; _frozen = false; - save_on_thaw = false; layer_op_counter = 0; freeze_length = 0; + _explicit_relayering = false; Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty)); } -Playlist::Playlist (const Playlist& pl) - : _session (pl._session) +Playlist::~Playlist () { - fatal << _("playlist const copy constructor called") << endmsg; -} + { + RegionLock rl (this); -Playlist::Playlist (Playlist& pl) - : _session (pl._session) -{ - fatal << _("playlist non-const copy constructor called") << endmsg; -} + for (set >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) { + (*i)->set_playlist (boost::shared_ptr()); + } + } -Playlist::~Playlist () -{ /* GoingAway must be emitted by derived classes */ } -void +bool Playlist::set_name (const string& str) { /* in a typical situation, a playlist is being used @@ -272,16 +291,15 @@ Playlist::set_name (const string& str) */ if (_refcnt > 2) { - return; + return false; + } else { + return SessionObject::set_name(str); } - - _name = str; - NameChanged(); /* EMIT SIGNAL */ } /*********************************************************************** CHANGE NOTIFICATION HANDLING - + Notifications must be delayed till the region_lock is released. This is necessary because handlers for the signals may need to acquire the lock (e.g. to read from the playlist). @@ -312,12 +330,11 @@ Playlist::delay_notifications () void Playlist::release_notifications () { - if (g_atomic_int_dec_and_test (&block_notifications)) { + if (g_atomic_int_dec_and_test (&block_notifications)) { flush_notifications (); - } + } } - void Playlist::notify_modified () { @@ -333,28 +350,55 @@ void Playlist::notify_region_removed (boost::shared_ptr r) { if (holding_state ()) { - pending_removals.insert (pending_removals.end(), r); + pending_removes.insert (r); + pending_modified = true; + pending_length = true; } else { - RegionRemoved (r); /* EMIT SIGNAL */ /* this might not be true, but we have to act as though it could be. */ + pending_length = false; LengthChanged (); /* EMIT SIGNAL */ + pending_modified = false; + RegionRemoved (boost::weak_ptr (r)); /* EMIT SIGNAL */ Modified (); /* EMIT SIGNAL */ } } +void +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; + m.push_back (move); + RangesMoved (m); + } + +} + void Playlist::notify_region_added (boost::shared_ptr r) { + /* the length change might not be true, but we have to act + as though it could be. + */ + if (holding_state()) { - pending_adds.insert (pending_adds.end(), r); + pending_adds.insert (r); + pending_modified = true; + pending_length = true; } else { - RegionAdded (r); /* EMIT SIGNAL */ - /* this might not be true, but we have to act - as though it could be. - */ + pending_length = false; LengthChanged (); /* EMIT SIGNAL */ + pending_modified = false; + RegionAdded (boost::weak_ptr (r)); /* EMIT SIGNAL */ Modified (); /* EMIT SIGNAL */ } } @@ -365,7 +409,9 @@ Playlist::notify_length_changed () if (holding_state ()) { pending_length = true; } else { + pending_length = false; LengthChanged(); /* EMIT SIGNAL */ + pending_modified = false; Modified (); /* EMIT SIGNAL */ } } @@ -373,9 +419,8 @@ Playlist::notify_length_changed () void Playlist::flush_notifications () { - RegionList::iterator r; - RegionList::iterator a; set > dependent_checks_needed; + set >::iterator s; uint32_t n = 0; if (in_flush) { @@ -386,7 +431,7 @@ Playlist::flush_notifications () /* we have no idea what order the regions ended up in pending bounds (it could be based on selection order, for example). - so, to preserve layering in the "most recently moved is higher" + so, to preserve layering in the "most recently moved is higher" model, sort them by existing layer, then timestamp them. */ @@ -394,31 +439,25 @@ Playlist::flush_notifications () // pending_bounds.sort (cmp); for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) { - if (_session.get_layer_model() == Session::MoveAddHigher) { + if (_session.config.get_layer_model() == MoveAddHigher) { timestamp_layer_op (*r); } - pending_length = true; - n++; - } - for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) { + pending_length = true; dependent_checks_needed.insert (*r); - /* don't increment n again - its the same list */ - } - for (a = pending_adds.begin(); a != pending_adds.end(); ++a) { - dependent_checks_needed.insert (*a); - RegionAdded (*a); /* EMIT SIGNAL */ n++; } - for (set >::iterator x = dependent_checks_needed.begin(); x != dependent_checks_needed.end(); ++x) { - check_dependents (*x, false); + for (s = pending_removes.begin(); s != pending_removes.end(); ++s) { + remove_dependents (*s); + RegionRemoved (boost::weak_ptr (*s)); /* EMIT SIGNAL */ + n++; } - for (r = pending_removals.begin(); r != pending_removals.end(); ++r) { - remove_dependents (*r); - RegionRemoved (*r); /* EMIT SIGNAL */ + for (s = pending_adds.begin(); s != pending_adds.end(); ++s) { + RegionAdded (boost::weak_ptr (*s)); /* EMIT SIGNAL */ + dependent_checks_needed.insert (*s); n++; } @@ -430,22 +469,25 @@ Playlist::flush_notifications () if (n || pending_modified) { if (!in_set_state) { - possibly_splice (); relayer (); } pending_modified = false; Modified (); /* EMIT SIGNAL */ } + for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) { + check_dependents (*s, false); + } + + if (!pending_range_moves.empty ()) { + RangesMoved (pending_range_moves); + } + pending_adds.clear (); - pending_removals.clear (); + pending_removes.clear (); pending_bounds.clear (); + pending_range_moves.clear (); - if (save_on_thaw) { - save_on_thaw = false; - save_state (last_save_reason); - } - in_flush = false; } @@ -454,27 +496,25 @@ Playlist::flush_notifications () *************************************************************/ void -Playlist::add_region (boost::shared_ptr region, jack_nframes_t position, float times, bool with_save) -{ +Playlist::add_region (boost::shared_ptr region, nframes_t position, float times, bool auto_partition) +{ RegionLock rlock (this); - times = fabs (times); - + int itimes = (int) floor (times); - jack_nframes_t pos = position; - + nframes_t pos = position; + + if (times == 1 && auto_partition){ + partition(pos, (nframes_t) (pos + region->length()), true); + } + if (itimes >= 1) { - add_region_internal (region, pos, true); + add_region_internal (region, pos); pos += region->length(); --itimes; } - - /* later regions will all be spliced anyway */ - - if (!holding_state ()) { - possibly_splice_unlocked (); - } + /* note that itimes can be zero if we being asked to just insert a single fraction of the region. @@ -482,39 +522,63 @@ Playlist::add_region (boost::shared_ptr region, jack_nframes_t position, for (int i = 0; i < itimes; ++i) { boost::shared_ptr copy = RegionFactory::create (region); - add_region_internal (copy, pos, true); + add_region_internal (copy, pos); pos += region->length(); } - + + nframes_t length = 0; + if (floor (times) != times) { - jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times))); + length = (nframes_t) floor (region->length() * (times - floor (times))); string name; _session.region_name (name, region->name(), false); boost::shared_ptr sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags()); - add_region_internal (sub, pos, true); - } - - if (with_save) { - maybe_save_state (_("add region")); + add_region_internal (sub, pos); } + + possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr()); } void -Playlist::add_region_internal (boost::shared_ptr region, jack_nframes_t position, bool delay_sort) +Playlist::set_region_ownership () +{ + RegionLock rl (this); + RegionList::iterator i; + boost::weak_ptr pl (shared_from_this()); + + for (i = regions.begin(); i != regions.end(); ++i) { + (*i)->set_playlist (pl); + } +} + +bool +Playlist::add_region_internal (boost::shared_ptr region, nframes_t position) { + if (region->data_type() != _type){ + return false; + } + RegionSortByPosition cmp; - jack_nframes_t old_length = 0; + + nframes_t old_length = 0; if (!holding_state()) { old_length = _get_maximum_extent(); } - region->set_playlist (this); + if (!first_set_state) { + boost::shared_ptr foo (shared_from_this()); + region->set_playlist (boost::weak_ptr(foo)); + } + region->set_position (position, this); timestamp_layer_op (region); regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + all_regions.insert (region); + + possibly_splice_unlocked (position, region->length(), region); if (!holding_state () && !in_set_state) { /* layers get assigned from XML state */ @@ -524,30 +588,38 @@ Playlist::add_region_internal (boost::shared_ptr region, jack_nframes_t /* we need to notify the existence of new region before checking dependents. Ick. */ notify_region_added (region); - + if (!holding_state ()) { + check_dependents (region, false); + if (old_length != _get_maximum_extent()) { notify_length_changed (); } } - region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), region)); + region_state_changed_connections.push_back ( + region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), + boost::weak_ptr (region))) + ); + + return true; } void -Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr newr, jack_nframes_t pos) +Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr newr, nframes_t pos) { RegionLock rlock (this); + bool old_sp = _splicing; + _splicing = true; + remove_region_internal (old); add_region_internal (newr, pos); - if (!holding_state ()) { - possibly_splice_unlocked (); - } + _splicing = old_sp; - maybe_save_state (_("replace region")); + possibly_splice_unlocked (pos, (nframes64_t) old->length() - (nframes64_t) newr->length()); } void @@ -555,35 +627,37 @@ Playlist::remove_region (boost::shared_ptr region) { RegionLock rlock (this); remove_region_internal (region); - - if (!holding_state ()) { - possibly_splice_unlocked (); - } - - maybe_save_state (_("remove region")); } int -Playlist::remove_region_internal (boost::shared_ptrregion, bool delay_sort) +Playlist::remove_region_internal (boost::shared_ptr region) { RegionList::iterator i; - jack_nframes_t old_length = 0; - - // cerr << "removing region " << region->name() << endl; + nframes_t old_length = 0; if (!holding_state()) { old_length = _get_maximum_extent(); } + if (!in_set_state) { + /* unset playlist */ + region->set_playlist (boost::weak_ptr()); + } + for (i = regions.begin(); i != regions.end(); ++i) { if (*i == region) { + nframes_t pos = (*i)->position(); + nframes64_t distance = (*i)->length(); + regions.erase (i); + possibly_splice_unlocked (pos, -distance); + if (!holding_state ()) { relayer (); remove_dependents (region); - + if (old_length != _get_maximum_extent()) { notify_length_changed (); } @@ -593,17 +667,24 @@ Playlist::remove_region_internal (boost::shared_ptrregion, bool delay_so return 0; } } + + + return -1; } void Playlist::get_equivalent_regions (boost::shared_ptr other, vector >& results) { - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if (Config->get_use_overlap_equivalency()) { + if (Config->get_use_overlap_equivalency()) { + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { if ((*i)->overlap_equivalent (other)) { results.push_back ((*i)); - } else if ((*i)->equivalent (other)) { + } + } + } else { + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->equivalent (other)) { results.push_back ((*i)); } } @@ -622,69 +703,80 @@ Playlist::get_region_list_equivalent_regions (boost::shared_ptr other, v } void -Playlist::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level) +Playlist::partition (nframes_t start, nframes_t end, bool cut) { RegionList thawlist; - partition_internal (start, end, false, thawlist); + partition_internal (start, end, cut, thawlist); for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { (*i)->thaw ("separation"); } - - maybe_save_state (_("separate")); } void -Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist) +Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist) { - RegionLock rlock (this); - boost::shared_ptr region; - boost::shared_ptr current; - string new_name; - RegionList::iterator tmp; - OverlapType overlap; - jack_nframes_t pos1, pos2, pos3, pos4; RegionList new_regions; - in_partition = true; + { + RegionLock rlock (this); - /* need to work from a copy, because otherwise the regions we add during the process - get operated on as well. - */ + boost::shared_ptr region; + boost::shared_ptr current; + string new_name; + RegionList::iterator tmp; + OverlapType overlap; + nframes_t pos1, pos2, pos3, pos4; - RegionList copy = regions; + in_partition = true; - for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) { - - tmp = i; - ++tmp; + /* need to work from a copy, because otherwise the regions we add during the process + get operated on as well. + */ - current = *i; - - if (current->first_frame() == start && current->last_frame() == end) { - if (cutting) { - remove_region_internal (current); + RegionList copy = regions; + + for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) { + + tmp = i; + ++tmp; + + current = *i; + + if (current->first_frame() >= start && current->last_frame() < end) { + + if (cutting) { + remove_region_internal (current); + } + + continue; } - continue; - } - - if ((overlap = current->coverage (start, end)) == OverlapNone) { - continue; - } - - pos1 = current->position(); - pos2 = start; - pos3 = end; - pos4 = current->last_frame(); - - if (overlap == OverlapInternal) { - - /* split: we need 3 new regions, the front, middle and end. - cut: we need 2 regions, the front and end. + + /* coverage will return OverlapStart if the start coincides + with the end point. we do not partition such a region, + so catch this special case. */ - - /* + + if (current->first_frame() >= end) { + continue; + } + + if ((overlap = current->coverage (start, end)) == OverlapNone) { + continue; + } + + pos1 = current->position(); + pos2 = start; + pos3 = end; + pos4 = current->last_frame(); + + if (overlap == OverlapInternal) { + /* split: we need 3 new regions, the front, middle and end. + cut: we need 2 regions, the front and end. + */ + + /* start end ---------------*************************------------ P1 P2 P3 P4 @@ -692,191 +784,182 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut ---------------*****++++++++++++++++====------------ CUT ---------------*****----------------====------------ - - */ - if (!cutting) { - - /* "middle" ++++++ */ - + */ + + if (!cutting) { + /* "middle" ++++++ */ + + _session.region_name (new_name, current->name(), false); + region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name, + regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit)); + add_region_internal (region, start); + new_regions.push_back (region); + } + + /* "end" ====== */ + _session.region_name (new_name, current->name(), false); - region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name, - regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit)); - add_region_internal (region, start, true); + region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name, + regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit)); + + add_region_internal (region, end); new_regions.push_back (region); - } - - /* "end" ====== */ - - _session.region_name (new_name, current->name(), false); - region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name, - regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit)); - add_region_internal (region, end, true); - new_regions.push_back (region); + /* "front" ***** */ - /* "front" ***** */ - - current->freeze (); - thawlist.push_back (current); - current->trim_end (pos2, this); + current->freeze (); + thawlist.push_back (current); + current->trim_end (pos2, this); - } else if (overlap == OverlapEnd) { + } else if (overlap == OverlapEnd) { - /* + /* start end ---------------*************************------------ P1 P2 P4 P3 - SPLIT: + SPLIT: ---------------**************+++++++++++------------ - CUT: + CUT: ---------------**************----------------------- + */ - */ + if (!cutting) { - if (!cutting) { - - /* end +++++ */ - - _session.region_name (new_name, current->name(), false); - region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(), - Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit)); - add_region_internal (region, start, true); - new_regions.push_back (region); - } + /* end +++++ */ - /* front ****** */ + _session.region_name (new_name, current->name(), false); + region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(), + Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit)); - current->freeze (); - thawlist.push_back (current); - current->trim_end (pos2, this); + add_region_internal (region, start); + new_regions.push_back (region); + } - } else if (overlap == OverlapStart) { + /* front ****** */ - /* split: we need 2 regions: the front and the end. - cut: just trim current to skip the cut area - */ - - /* + current->freeze (); + thawlist.push_back (current); + current->trim_end (pos2, this); + + } else if (overlap == OverlapStart) { + + /* split: we need 2 regions: the front and the end. + cut: just trim current to skip the cut area + */ + + /* start end ---------------*************************------------ - P2 P1 P3 P4 + P2 P1 P3 P4 SPLIT: ---------------****+++++++++++++++++++++------------ CUT: -------------------*********************------------ - - */ - if (!cutting) { - - /* front **** */ - _session.region_name (new_name, current->name(), false); - region = RegionFactory::create (current, 0, pos3 - pos1, new_name, - regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit)); - add_region_internal (region, pos1, true); - new_regions.push_back (region); - } - - /* end */ - - current->freeze (); - thawlist.push_back (current); - current->trim_front (pos3, this); - - } else if (overlap == OverlapExternal) { - - /* split: no split required. - cut: remove the region. - */ - - /* + */ + + if (!cutting) { + /* front **** */ + _session.region_name (new_name, current->name(), false); + region = RegionFactory::create (current, 0, pos3 - pos1, new_name, + regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit)); + + add_region_internal (region, pos1); + new_regions.push_back (region); + } + + /* end */ + + current->freeze (); + thawlist.push_back (current); + current->trim_front (pos3, this); + } else if (overlap == OverlapExternal) { + + /* split: no split required. + cut: remove the region. + */ + + /* start end ---------------*************************------------ - P2 P1 P3 P4 + P2 P1 P3 P4 SPLIT: ---------------*************************------------ CUT: ---------------------------------------------------- - - */ - if (cutting) { - remove_region_internal (current); + */ + + if (cutting) { + remove_region_internal (current); + } + + new_regions.push_back (current); } - new_regions.push_back (current); } - } - in_partition = false; + in_partition = false; + } for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) { check_dependents (*i, false); } } -Playlist* -Playlist::cut_copy (Playlist* (Playlist::*pmf)(jack_nframes_t, jack_nframes_t,bool), list& ranges, bool result_is_hidden) +boost::shared_ptr +Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(nframes_t, nframes_t,bool), list& ranges, bool result_is_hidden) { - Playlist* ret; - Playlist* pl; - jack_nframes_t start; + boost::shared_ptr ret; + boost::shared_ptr pl; + nframes_t start; if (ranges.empty()) { - return 0; + return boost::shared_ptr(); } start = ranges.front().start; - for (list::iterator i = ranges.begin(); i != ranges.end(); ++i) { pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden); - + 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. */ - ret->paste (*pl, (*i).start - start, 1.0f); - delete pl; + ret->paste (pl, (*i).start - start, 1.0f); } } - if (ret) { - /* manually notify session of new playlist here - because the playlists were constructed without notifying - */ - PlaylistCreated (ret); - } - return ret; } -Playlist* +boost::shared_ptr Playlist::cut (list& ranges, bool result_is_hidden) { - Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::cut; + boost::shared_ptr (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::cut; return cut_copy (pmf, ranges, result_is_hidden); } -Playlist* +boost::shared_ptr Playlist::copy (list& ranges, bool result_is_hidden) { - Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::copy; + boost::shared_ptr (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::copy; return cut_copy (pmf, ranges, result_is_hidden); } -Playlist * -Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden) +boost::shared_ptr +Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden) { - Playlist *the_copy; + boost::shared_ptr the_copy; RegionList thawlist; char buf[32]; @@ -885,68 +968,64 @@ Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden) new_name += '.'; new_name += buf; - if ((the_copy = copyPlaylist (*this, start, cnt, new_name, result_is_hidden)) == 0) { - return 0; + if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) { + return boost::shared_ptr(); } partition_internal (start, start+cnt-1, true, thawlist); - possibly_splice (); for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { (*i)->thaw ("playlist cut"); } - maybe_save_state (_("cut")); - return the_copy; } -Playlist * -Playlist::copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden) +boost::shared_ptr +Playlist::copy (nframes_t start, nframes_t cnt, bool result_is_hidden) { char buf[32]; - + snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt); string new_name = _name; new_name += '.'; new_name += buf; cnt = min (_get_maximum_extent() - start, cnt); - return copyPlaylist (*this, start, cnt, new_name, result_is_hidden); + return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden); } int -Playlist::paste (Playlist& other, jack_nframes_t position, float times) +Playlist::paste (boost::shared_ptr other, nframes_t position, float times) { times = fabs (times); - jack_nframes_t old_length; + nframes_t old_length; { RegionLock rl1 (this); - RegionLock rl2 (&other); + RegionLock rl2 (other.get()); old_length = _get_maximum_extent(); - + int itimes = (int) floor (times); - jack_nframes_t pos = position; - jack_nframes_t shift = other._get_maximum_extent(); + nframes_t pos = position; + nframes_t shift = other->_get_maximum_extent(); layer_t top_layer = regions.size(); 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); /* put these new regions on top of all existing ones, but preserve the ordering they had in the original playlist. */ - + copy_of_region->set_layer (copy_of_region->layer() + top_layer); add_region_internal (copy_of_region, copy_of_region->position() + pos); } pos += shift; } - possibly_splice_unlocked (); /* XXX shall we handle fractional cases at some point? */ @@ -954,46 +1033,99 @@ Playlist::paste (Playlist& other, jack_nframes_t position, float times) notify_length_changed (); } - - } - maybe_save_state (_("paste")); + } return 0; } void -Playlist::duplicate (boost::shared_ptr region, jack_nframes_t position, float times) +Playlist::duplicate (boost::shared_ptr region, nframes_t position, float times) { times = fabs (times); RegionLock rl (this); int itimes = (int) floor (times); - jack_nframes_t pos = position; + nframes_t pos = position; while (itimes--) { boost::shared_ptr copy = RegionFactory::create (region); - add_region_internal (copy, pos, true); + add_region_internal (copy, pos); pos += region->length(); } if (floor (times) != times) { - jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times))); + nframes_t length = (nframes_t) floor (region->length() * (times - floor (times))); string name; _session.region_name (name, region->name(), false); boost::shared_ptr sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags()); - add_region_internal (sub, pos, true); + add_region_internal (sub, pos); + } +} + +void +Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bool ignore_music_glue) +{ + RegionLock rlock (this); + RegionList copy (regions); + RegionList fixup; + + for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { + + if ((*r)->last_frame() < at) { + /* too early */ + continue; + } + + if (at > (*r)->first_frame() && at < (*r)->last_frame()) { + /* intersected region */ + if (!move_intersected) { + continue; + } + } + + /* do not move regions glued to music time - that + has to be done separately. + */ + + if (!ignore_music_glue && (*r)->positional_lock_style() != Region::AudioTime) { + fixup.push_back (*r); + continue; + } + + (*r)->set_position ((*r)->position() + distance, this); + } + + for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) { + (*r)->recompute_position_from_lock_style (); } +} + +void +Playlist::split (nframes64_t at) +{ + RegionLock rlock (this); + RegionList copy (regions); + + /* use a copy since this operation can modify the region list + */ - maybe_save_state (_("duplicate")); + for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { + _split_region (*r, at); + } } void -Playlist::split_region (boost::shared_ptr region, jack_nframes_t playlist_position) +Playlist::split_region (boost::shared_ptr region, nframes_t playlist_position) { RegionLock rl (this); + _split_region (region, playlist_position); +} +void +Playlist::_split_region (boost::shared_ptr region, nframes_t playlist_position) +{ if (!region->covers (playlist_position)) { return; } @@ -1005,105 +1137,120 @@ Playlist::split_region (boost::shared_ptr region, jack_nframes_t playlis boost::shared_ptr left; boost::shared_ptr right; - jack_nframes_t before; - jack_nframes_t after; + nframes_t before; + nframes_t after; 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; + before = playlist_position - region->position(); after = region->length() - before; - - + _session.region_name (before_name, region->name(), false); left = RegionFactory::create (region, 0, before, before_name, region->layer(), Region::Flag (region->flags()|Region::LeftOfSplit)); _session.region_name (after_name, region->name(), false); right = RegionFactory::create (region, before, after, after_name, region->layer(), Region::Flag (region->flags()|Region::RightOfSplit)); - add_region_internal (left, region->position(), true); + add_region_internal (left, region->position()); add_region_internal (right, region->position() + before); - + uint64_t orig_layer_op = region->last_layer_op(); for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { if ((*i)->last_layer_op() > orig_layer_op) { (*i)->set_last_layer_op( (*i)->last_layer_op() + 1 ); } } - + left->set_last_layer_op ( orig_layer_op ); right->set_last_layer_op ( orig_layer_op + 1); layer_op_counter++; finalize_split_region (region, left, right); - - if (remove_region_internal (region, true)) { - return; - } - maybe_save_state (_("split")); + remove_region_internal (region); + + _splicing = old_sp; } void -Playlist::possibly_splice () +Playlist::possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) { + if (_splicing || in_set_state) { + /* don't respond to splicing moves or state setting */ + return; + } + if (_edit_mode == Splice) { - splice_locked (); + splice_locked (at, distance, exclude); } } void -Playlist::possibly_splice_unlocked () +Playlist::possibly_splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) { + if (_splicing || in_set_state) { + /* don't respond to splicing moves or state setting */ + return; + } + if (_edit_mode == Splice) { - splice_unlocked (); + splice_unlocked (at, distance, exclude); } } void -Playlist::splice_locked () +Playlist::splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) { { RegionLock rl (this); - core_splice (); + core_splice (at, distance, exclude); } - - notify_length_changed (); } void -Playlist::splice_unlocked () +Playlist::splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) { - core_splice (); - notify_length_changed (); + core_splice (at, distance, exclude); } void -Playlist::core_splice () +Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) { _splicing = true; - + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - - RegionList::iterator next; - - next = i; - ++next; - - if (next == regions.end()) { - break; + + if (exclude && (*i) == exclude) { + continue; + } + + if ((*i)->position() >= at) { + nframes64_t new_pos = (*i)->position() + distance; + if (new_pos < 0) { + new_pos = 0; + } else if (new_pos >= max_frames - (*i)->length()) { + new_pos = max_frames - (*i)->length(); + } + + (*i)->set_position (new_pos, this); } - - (*next)->set_position ((*i)->last_frame() + 1, this); } - + _splicing = false; + + notify_length_changed (); } void Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr region) { - if (in_set_state || _splicing || _nudging) { + if (in_set_state || _splicing || _nudging || _shuffling) { return; } @@ -1112,11 +1259,11 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr /* 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); - + if (i == regions.end()) { warning << string_compose (_("%1: bounds changed received for region (%2)not in playlist"), _name, region->name()) @@ -1126,30 +1273,49 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr regions.erase (i); regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); - } if (what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) { - + + nframes64_t delta = 0; + + if (what_changed & ARDOUR::PositionChanged) { + delta = (nframes64_t) region->position() - (nframes64_t) region->last_position(); + } + + if (what_changed & ARDOUR::LengthChanged) { + delta += (nframes64_t) region->length() - (nframes64_t) region->last_length(); + } + + if (delta) { + possibly_splice (region->last_position() + region->last_length(), delta, region); + } + if (holding_state ()) { pending_bounds.push_back (region); } else { - if (_session.get_layer_model() == Session::MoveAddHigher) { + if (_session.config.get_layer_model() == MoveAddHigher) { /* it moved or changed length, so change the timestamp */ timestamp_layer_op (region); } - - possibly_splice (); - check_dependents (region, false); + notify_length_changed (); relayer (); + check_dependents (region, false); } } } void -Playlist::region_changed_proxy (Change what_changed, boost::shared_ptr region) +Playlist::region_changed_proxy (Change what_changed, boost::weak_ptr weak_region) { + boost::shared_ptr region (weak_region.lock()); + + if (!region) { + return; + } + + /* this makes a virtual call to the right kind of playlist ... */ region_changed (what_changed, region); @@ -1165,44 +1331,63 @@ Playlist::region_changed (Change what_changed, boost::shared_ptr region) return false; } - { - if (what_changed & BoundsChanged) { - region_bounds_changed (what_changed, region); - save = !(_splicing || _nudging); - } - - if ((what_changed & Region::MuteChanged) && - !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) { - check_dependents (region, false); - } - - if (what_changed & our_interests) { - save = true; - } + if (what_changed & BoundsChanged) { + region_bounds_changed (what_changed, region); + save = !(_splicing || _nudging); + } + + if ((what_changed & our_interests) && + !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) { + check_dependents (region, false); + } + + if (what_changed & Change (ARDOUR::PositionChanged)) { + notify_region_moved (region); + } + + if (what_changed & our_interests) { + save = true; } return save; } void -Playlist::clear (bool with_save) +Playlist::drop_regions () { - RegionList::iterator i; - RegionList tmp; + RegionLock rl (this); + regions.clear (); + all_regions.clear (); +} - { +void +Playlist::clear (bool with_signals) +{ + { RegionLock rl (this); - tmp = regions; + + for ( + std::list::iterator i = region_state_changed_connections.begin (); + i != region_state_changed_connections.end (); + ++i + ) { + i->disconnect (); + } + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + pending_removes.insert (*i); + } + regions.clear (); } - - for (i = tmp.begin(); i != tmp.end(); ++i) { - notify_region_removed (*i); - } - if (with_save) { - maybe_save_state (_("clear")); + if (with_signals) { + pending_length = false; + LengthChanged (); + pending_modified = false; + Modified (); } + } /*********************************************************************** @@ -1210,34 +1395,170 @@ Playlist::clear (bool with_save) **********************************************************************/ Playlist::RegionList * -Playlist::regions_at (jack_nframes_t frame) +Playlist::regions_at (nframes_t frame) { RegionLock rlock (this); return find_regions_at (frame); -} +} boost::shared_ptr -Playlist::top_region_at (jack_nframes_t frame) +Playlist::top_region_at (nframes_t frame) { RegionLock rlock (this); RegionList *rlist = find_regions_at (frame); boost::shared_ptr region; - + if (rlist->size()) { RegionSortByLayer cmp; rlist->sort (cmp); region = rlist->back(); - } + } delete rlist; return region; -} +} + +boost::shared_ptr +Playlist::top_unmuted_region_at (nframes_t frame) + +{ + RegionLock rlock (this); + RegionList *rlist = find_regions_at (frame); + + for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) { + + RegionList::iterator tmp = i; + ++tmp; + + if ((*i)->muted()) { + rlist->erase (i); + } + + i = tmp; + } + + boost::shared_ptr region; + + if (rlist->size()) { + RegionSortByLayer cmp; + rlist->sort (cmp); + region = rlist->back(); + } + + delete rlist; + return region; +} + +Playlist::RegionList* +Playlist::regions_to_read (nframes_t start, nframes_t end) +{ + /* Caller must hold lock */ + + RegionList covering; + set to_check; + set > unique; + RegionList here; + + to_check.insert (start); + to_check.insert (end); + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + + /* find all/any regions that span start+end */ + + switch ((*i)->coverage (start, end)) { + case OverlapNone: + break; + + case OverlapInternal: + covering.push_back (*i); + break; + + case OverlapStart: + to_check.insert ((*i)->position()); + covering.push_back (*i); + break; + + case OverlapEnd: + to_check.insert ((*i)->last_frame()); + covering.push_back (*i); + break; + + case OverlapExternal: + covering.push_back (*i); + to_check.insert ((*i)->position()); + to_check.insert ((*i)->last_frame()); + break; + } + + /* don't go too far */ + + if ((*i)->position() > end) { + break; + } + } + + RegionList* rlist = new RegionList; + + /* find all the regions that cover each position .... */ + + if (covering.size() == 1) { + + rlist->push_back (covering.front()); + + } else { + + for (set::iterator t = to_check.begin(); t != to_check.end(); ++t) { + + here.clear (); + + for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) { + + if ((*x)->covers (*t)) { + here.push_back (*x); + } + } + + RegionSortByLayer cmp; + here.sort (cmp); + + /* ... and get the top/transparent regions at "here" */ + + for (RegionList::reverse_iterator c = here.rbegin(); c != here.rend(); ++c) { + + unique.insert (*c); + + if ((*c)->opaque()) { + + /* the other regions at this position are hidden by this one */ + + break; + } + } + } + + for (set >::iterator s = unique.begin(); s != unique.end(); ++s) { + rlist->push_back (*s); + } + + if (rlist->size() > 1) { + /* now sort by time order */ + + RegionSortByPosition cmp; + rlist->sort (cmp); + } + } + + return rlist; +} Playlist::RegionList * -Playlist::find_regions_at (jack_nframes_t frame) +Playlist::find_regions_at (nframes_t frame) { + /* Caller must hold lock */ + RegionList *rlist = new RegionList; for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { @@ -1250,7 +1571,7 @@ Playlist::find_regions_at (jack_nframes_t frame) } Playlist::RegionList * -Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end) +Playlist::regions_touched (nframes_t start, nframes_t end) { RegionLock rlock (this); RegionList *rlist = new RegionList; @@ -1264,19 +1585,82 @@ Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end) return rlist; } +nframes64_t +Playlist::find_next_transient (nframes64_t from, int dir) +{ + RegionLock rlock (this); + AnalysisFeatureList points; + AnalysisFeatureList these_points; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if (dir > 0) { + if ((*i)->last_frame() < from) { + continue; + } + } else { + if ((*i)->first_frame() > from) { + continue; + } + } + + (*i)->get_transients (these_points); + + /* add first frame, just, err, because */ + + these_points.push_back ((*i)->first_frame()); + + points.insert (points.end(), these_points.begin(), these_points.end()); + these_points.clear (); + } + + if (points.empty()) { + return -1; + } + + TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0); + bool reached = false; + + if (dir > 0) { + for (AnalysisFeatureList::iterator x = points.begin(); x != points.end(); ++x) { + if ((*x) >= from) { + reached = true; + } + + if (reached && (*x) > from) { + return *x; + } + } + } else { + for (AnalysisFeatureList::reverse_iterator x = points.rbegin(); x != points.rend(); ++x) { + if ((*x) <= from) { + reached = true; + } + + if (reached && (*x) < from) { + return *x; + } + } + } + + return -1; +} boost::shared_ptr -Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) +Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) { RegionLock rlock (this); boost::shared_ptr ret; - jack_nframes_t closest = max_frames; + nframes_t closest = max_frames; + + bool end_iter = false; for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - jack_nframes_t distance; + if(end_iter) break; + + nframes_t distance; boost::shared_ptr r = (*i); - jack_nframes_t pos = 0; + nframes_t pos = 0; switch (point) { case Start: @@ -1286,7 +1670,8 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) pos = r->last_frame (); break; case SyncPoint: - pos = r->adjust_to_sync (r->first_frame()); + pos = r->sync_position (); + // r->adjust_to_sync (r->first_frame()); break; } @@ -1297,6 +1682,7 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) if ((distance = pos - frame) < closest) { closest = distance; ret = r; + end_iter = true; } } @@ -1310,6 +1696,10 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) ret = r; } } + else { + end_iter = true; + } + break; } } @@ -1317,10 +1707,79 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) return ret; } +nframes64_t +Playlist::find_next_region_boundary (nframes64_t frame, int dir) +{ + RegionLock rlock (this); + + nframes64_t closest = max_frames; + nframes64_t ret = -1; + + if (dir > 0) { + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + + boost::shared_ptr r = (*i); + nframes64_t distance; + + if (r->first_frame() > frame) { + + distance = r->first_frame() - frame; + + if (distance < closest) { + ret = r->first_frame(); + closest = distance; + } + } + + if (r->last_frame () > frame) { + + distance = r->last_frame () - frame; + + if (distance < closest) { + ret = r->last_frame (); + closest = distance; + } + } + } + + } else { + + for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) { + + boost::shared_ptr r = (*i); + nframes64_t distance; + + if (r->last_frame() < frame) { + + distance = frame - r->last_frame(); + + if (distance < closest) { + ret = r->last_frame(); + closest = distance; + } + } + + if (r->first_frame() < frame) { + + distance = frame - r->first_frame(); + + if (distance < closest) { + ret = r->first_frame(); + closest = distance; + } + } + } + } + + return ret; +} + /***********************************************************************/ + void Playlist::mark_session_dirty () { @@ -1330,10 +1789,8 @@ Playlist::mark_session_dirty () } int -Playlist::set_state (const XMLNode& node) +Playlist::set_state (const XMLNode& node, int version) { - in_set_state = true; - XMLNode *child; XMLNodeList nlist; XMLNodeConstIterator niter; @@ -1343,90 +1800,115 @@ Playlist::set_state (const XMLNode& node) boost::shared_ptr region; string region_name; - clear (false); + in_set_state++; if (node.name() != "Playlist") { - in_set_state = false; + in_set_state--; return -1; } + freeze (); + plist = node.properties(); for (piter = plist.begin(); piter != plist.end(); ++piter) { prop = *piter; - + if (prop->name() == X_("name")) { _name = prop->value(); } else if (prop->name() == X_("orig_diskstream_id")) { _orig_diskstream_id = prop->value (); } else if (prop->name() == X_("frozen")) { - _frozen = (prop->value() == X_("yes")); + _frozen = string_is_affirmative (prop->value()); } } + clear (false); + nlist = node.children(); for (niter = nlist.begin(); niter != nlist.end(); ++niter) { child = *niter; - + if (child->name() == "Region") { - if ((region = RegionFactory::create (_session, *child, true)) == 0) { - error << _("Playlist: cannot create region from state file") << endmsg; + if ((prop = child->property ("id")) == 0) { + error << _("region state node has no ID, ignored") << endmsg; + continue; + } + + ID id = prop->value (); + + if ((region = region_by_id (id))) { + + Change what_changed = Change (0); + + if (region->set_live_state (*child, version, what_changed, true)) { + error << _("Playlist: cannot reset region state from XML") << endmsg; + continue; + } + + } else if ((region = RegionFactory::create (_session, *child, true)) == 0) { + error << _("Playlist: cannot create region from XML") << endmsg; continue; } - add_region (region, region->position(), 1.0, false); + add_region (region, region->position(), 1.0); // So that layer_op ordering doesn't get screwed up region->set_last_layer_op( region->layer()); - } + } } - - /* update dependents, which was not done during add_region_internal - due to in_set_state being true + notify_modified (); + + thaw (); + + /* update dependents, which was not done during add_region_internal + due to in_set_state being true */ for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) { check_dependents (*r, false); } - - in_set_state = false; + in_set_state--; + first_set_state = false; return 0; } XMLNode& Playlist::get_state() { - return state(true); + return state (true); } XMLNode& Playlist::get_template() { - return state(false); + return state (false); } +/** @param full_state true to include regions in the returned state, otherwise false. + */ XMLNode& Playlist::state (bool full_state) { XMLNode *node = new XMLNode (X_("Playlist")); char buf[64]; - + node->add_property (X_("name"), _name); + node->add_property (X_("type"), _type.to_string()); - _orig_diskstream_id.print (buf); + _orig_diskstream_id.print (buf, sizeof (buf)); node->add_property (X_("orig_diskstream_id"), buf); node->add_property (X_("frozen"), _frozen ? "yes" : "no"); if (full_state) { RegionLock rlock (this, false); - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { node->add_child_nocopy ((*i)->get_state()); } @@ -1442,22 +1924,30 @@ Playlist::state (bool full_state) bool Playlist::empty() const { + RegionLock rlock (const_cast(this), false); return regions.empty(); } -jack_nframes_t +uint32_t +Playlist::n_regions() const +{ + RegionLock rlock (const_cast(this), false); + return regions.size(); +} + +nframes_t Playlist::get_maximum_extent () const { - RegionLock rlock (const_cast(this)); + RegionLock rlock (const_cast(this), false); return _get_maximum_extent (); } -jack_nframes_t +ARDOUR::nframes_t Playlist::_get_maximum_extent () const { RegionList::const_iterator i; - jack_nframes_t max_extent = 0; - jack_nframes_t end = 0; + nframes_t max_extent = 0; + nframes_t end = 0; for (i = regions.begin(); i != regions.end(); ++i) { if ((end = (*i)->position() + (*i)->length()) > max_extent) { @@ -1468,40 +1958,18 @@ Playlist::_get_maximum_extent () const return max_extent; } -string +string Playlist::bump_name (string name, Session &session) { string newname = name; do { - newname = Playlist::bump_name_once (newname); - } while (session.playlist_by_name(newname)!=NULL); + newname = bump_name_once (newname); + } while (session.playlist_by_name (newname)!=NULL); return newname; } -string -Playlist::bump_name_once (string name) -{ - string::size_type period; - string newname; - - if ((period = name.find_last_of ('.')) == string::npos) { - newname = name; - newname += ".1"; - } else { - char buf[32]; - int version; - - sscanf (name.substr (period+1).c_str(), "%d", &version); - snprintf (buf, sizeof(buf), "%d", version+1); - - newname = name.substr (0, period+1); - newname += buf; - } - - return newname; -} layer_t Playlist::top_layer() const @@ -1528,34 +1996,108 @@ Playlist::set_edit_mode (EditMode mode) void Playlist::relayer () { - RegionList::iterator i; - uint32_t layer = 0; - /* don't send multiple Modified notifications when multiple regions are relayered. */ freeze (); - if (_session.get_layer_model() == Session::MoveAddHigher || - _session.get_layer_model() == Session::AddHigher) { + /* Build up a new list of regions on each layer, stored in a set of lists + each of which represent some period of time on some layer. The idea + is to avoid having to search the entire region list to establish whether + each region overlaps another */ - RegionSortByLastLayerOp cmp; - RegionList copy = regions; + /* how many pieces to divide this playlist's time up into */ + int const divisions = 512; + + /* find the start and end positions of the regions on this playlist */ + nframes_t start = UINT_MAX; + nframes_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); + + vector > layers; + layers.push_back (vector (divisions)); + + /* we want to go through regions from desired lowest to desired highest layer, + which depends on the layer model + */ + + RegionList copy = regions; + + /* sort according to the model and the layering mode that we're in */ + + if (_explicit_relayering) { + + copy.sort (RegionSortByLayerWithPending ()); + + } else if (_session.config.get_layer_model() == MoveAddHigher || _session.config.get_layer_model() == AddHigher) { - copy.sort (cmp); + copy.sort (RegionSortByLastLayerOp ()); - for (i = copy.begin(); i != copy.end(); ++i) { - (*i)->set_layer (layer++); + } + + for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { + + /* reset the pending explicit relayer flag for every region, now that we're relayering */ + (*i)->set_pending_explicit_relayer (false); + + /* find the time divisions that this region covers */ + int const start_division = floor ( ((*i)->position() - start) / division_size); + int end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size ); + if (end_division == divisions) { + end_division--; } - } else { - - /* Session::LaterHigher model */ + assert (end_division < divisions); - for (i = regions.begin(); i != regions.end(); ++i) { - (*i)->set_layer (layer++); + /* find the lowest layer that this region can go on */ + 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 + */ + + 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()) { + if ((*l)->overlap_equivalent (*i)) { + overlap = true; + break; + } + l++; + } + + if (overlap) { + break; + } + } + + if (overlap) { + /* overlap, so we must use layer j */ + break; + } + + --j; + } + + if (j == layers.size()) { + /* we need a new layer for this region */ + layers.push_back (vector (divisions)); + } + + /* put a reference to this region in each of the divisions that it exists in */ + for (int k = start_division; k <= end_division; ++k) { + layers[j][k].push_back (*i); } + + (*i)->set_layer (j); } /* sending Modified means that various kinds of layering @@ -1604,8 +2146,8 @@ void Playlist::raise_region_to_top (boost::shared_ptr region) { /* does nothing useful if layering mode is later=higher */ - if ((_session.get_layer_model() == Session::MoveAddHigher) || - (_session.get_layer_model() == Session::AddHigher)) { + if ((_session.config.get_layer_model() == MoveAddHigher) || + (_session.config.get_layer_model() == AddHigher)) { timestamp_layer_op (region); relayer (); } @@ -1615,8 +2157,8 @@ void Playlist::lower_region_to_bottom (boost::shared_ptr region) { /* does nothing useful if layering mode is later=higher */ - if ((_session.get_layer_model() == Session::MoveAddHigher) || - (_session.get_layer_model() == Session::AddHigher)) { + if ((_session.config.get_layer_model() == MoveAddHigher) || + (_session.config.get_layer_model() == AddHigher)) { region->set_last_layer_op (0); relayer (); } @@ -1632,9 +2174,9 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr { RegionLock rlock (const_cast (this)); - + for (i = regions.begin(); i != regions.end(); ++i) { - + if (region == *i) { continue; } @@ -1644,7 +2186,7 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr /* region is moving up, move all regions on intermediate layers down 1 */ - + if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) { dest = (*i)->layer() - 1; } else { @@ -1666,12 +2208,12 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr } LayerInfo newpair; - + newpair.first = *i; newpair.second = dest; - + layerinfo.push_back (newpair); - } + } } /* now reset the layers without holding the region lock */ @@ -1682,29 +2224,31 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr region->set_layer (target_layer); +#if 0 /* now check all dependents */ for (list::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) { check_dependents (x->first, false); } - + check_dependents (region, false); - +#endif + return 0; } void -Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards) +Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards) { RegionList::iterator i; - jack_nframes_t new_pos; + nframes_t new_pos; bool moved = false; _nudging = true; { RegionLock rlock (const_cast (this)); - + for (i = regions.begin(); i != regions.end(); ++i) { if ((*i)->position() >= start) { @@ -1716,9 +2260,9 @@ Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwa } else { new_pos = (*i)->position() + distance; } - + } else { - + if ((*i)->position() > distance) { new_pos = (*i)->position() - distance; } else { @@ -1734,7 +2278,6 @@ Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwa if (moved) { _nudging = false; - maybe_save_state (_("nudged")); notify_length_changed (); } @@ -1744,24 +2287,29 @@ boost::shared_ptr Playlist::find_region (const ID& id) const { RegionLock rlock (const_cast (this)); - RegionList::const_iterator i; - boost::shared_ptr ret; - for (i = regions.begin(); i != regions.end(); ++i) { + /* searches all regions currently in use by the playlist */ + + for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { if ((*i)->id() == id) { - ret = *i; + return *i; } } - return ret; + return boost::shared_ptr (); } - -void -Playlist::save_state (std::string why) + +boost::shared_ptr +Playlist::region_by_id (ID id) { - if (!in_set_state) { - StateManager::save_state (why); + /* searches all regions ever added to this playlist */ + + for (set >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) { + if ((*i)->id() == id) { + return *i; + } } + return boost::shared_ptr (); } void @@ -1775,9 +2323,9 @@ Playlist::dump () const for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { r = *i; - cerr << " " << r->name() << " [" - << r->start() << "+" << r->length() - << "] at " + cerr << " " << r->name() << " [" + << r->start() << "+" << r->length() + << "] at " << r->position() << " on layer " << r->layer () @@ -1799,13 +2347,175 @@ Playlist::timestamp_layer_op (boost::shared_ptr region) region->set_last_layer_op (++layer_op_counter); } + void -Playlist::maybe_save_state (string why) +Playlist::shuffle (boost::shared_ptr region, int dir) { - if (holding_state ()) { - save_on_thaw = true; - last_save_reason = why; - } else { - save_state (why); + bool moved = false; + nframes_t new_pos; + + if (region->locked()) { + return; } + + _shuffling = true; + + { + RegionLock rlock (const_cast (this)); + + + if (dir > 0) { + + RegionList::iterator next; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i) == region) { + next = i; + ++next; + + if (next != regions.end()) { + + if ((*next)->locked()) { + break; + } + + if ((*next)->position() != region->last_frame() + 1) { + /* they didn't used to touch, so after shuffle, + just have them swap positions. + */ + 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(); + } + + (*next)->set_position (region->position(), this); + region->set_position (new_pos, this); + + /* avoid a full sort */ + + regions.erase (i); // removes the region from the list */ + next++; + regions.insert (next, region); // adds it back after next + + moved = true; + } + break; + } + } + } else { + + RegionList::iterator prev = regions.end(); + + for (RegionList::iterator i = regions.begin(); i != regions.end(); prev = i, ++i) { + if ((*i) == region) { + + if (prev != regions.end()) { + + if ((*prev)->locked()) { + break; + } + + if (region->position() != (*prev)->last_frame() + 1) { + /* they didn't used to touch, so after shuffle, + just have them swap positions. + */ + 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(); + } + + region->set_position ((*prev)->position(), this); + (*prev)->set_position (new_pos, this); + + /* avoid a full sort */ + + regions.erase (i); // remove region + regions.insert (prev, region); // insert region before prev + + moved = true; + } + + break; + } + } + } + } + + _shuffling = false; + + if (moved) { + + relayer (); + check_dependents (region, false); + + notify_modified(); + } + +} + +bool +Playlist::region_is_shuffle_constrained (boost::shared_ptr) +{ + RegionLock rlock (const_cast (this)); + + if (regions.size() > 1) { + return true; + } + + return false; +} + +void +Playlist::update_after_tempo_map_change () +{ + RegionLock rlock (const_cast (this)); + RegionList copy (regions); + + freeze (); + + for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) { + (*i)->update_position_after_tempo_map_change (); + } + + thaw (); +} + +void +Playlist::foreach_region (sigc::slot > s) +{ + RegionLock rl (this, false); + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + s (*i); + } +} + +void +Playlist::set_explicit_relayering (bool e) +{ + if (e == false && _explicit_relayering == true) { + + /* We are changing from explicit to implicit relayering; layering may have been changed whilst + we were in explicit mode, and we don't want that to be undone next time an implicit relayer + occurs. Hence now we'll set up region last_layer_op values so that an implicit relayer + at this point would keep regions on the same layers. + + From then on in, it's just you and your towel. + */ + + RegionLock rl (this); + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + (*i)->set_last_layer_op ((*i)->layer ()); + } + } + + _explicit_relayering = e; }