X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=d635819963434fd95353efc2b9a0acdcc991f803;hb=be830adccba524b4a22587340c6fe2bb31be5cd8;hp=a4a0a62e981d9916fecb047bcd02aeea77778a63;hpb=0d36301907afd612f93a7bfa53724cc9a17724de;p=ardour.git diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc index a4a0a62e98..d635819963 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 @@ -17,6 +17,7 @@ */ +#include #include #include #include @@ -25,19 +26,22 @@ #include #include -#include +#include +#include "pbd/convert.h" #include "pbd/failed_constructor.h" -#include "pbd/stl_delete.h" +#include "pbd/stateful_diff_command.h" #include "pbd/xml++.h" -#include "pbd/stacktrace.h" +#include "ardour/debug.h" #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 "ardour/session_playlists.h" +#include "ardour/source_factory.h" #include "i18n.h" @@ -45,10 +49,16 @@ using namespace std; using namespace ARDOUR; using namespace PBD; +namespace ARDOUR { +namespace Properties { +PBD::PropertyDescriptor regions; +} +} + 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 () { + cerr << ">>>>" << name << endl; playlist->dump(); cerr << "<<<<" << name << endl << endl; }; boost::shared_ptr playlist; string name; @@ -60,6 +70,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,38 +99,106 @@ struct RegionSortByLastLayerOp { } }; +void +Playlist::make_property_quarks () +{ + Properties::regions.property_id = g_quark_from_static_string (X_("regions")); + DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for regions = %1\n", + Properties::regions.property_id)); +} + +RegionListProperty::RegionListProperty (Playlist& pl) + : SequenceProperty > > (Properties::regions.property_id, boost::bind (&Playlist::update, &pl, _1)) + , _playlist (pl) +{ + +} + +RegionListProperty::RegionListProperty (RegionListProperty const & p) + : PBD::SequenceProperty > > (p) + , _playlist (p._playlist) +{ + +} + +RegionListProperty * +RegionListProperty::clone () const +{ + return new RegionListProperty (*this); +} + +RegionListProperty * +RegionListProperty::create () const +{ + return new RegionListProperty (_playlist); +} + +void +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.add_property ("id", region->id().to_s ()); +} + +boost::shared_ptr +RegionListProperty::get_content_from_xml (XMLNode const & node) const +{ + XMLProperty const * prop = node.property ("id"); + assert (prop); + + PBD::ID id (prop->value ()); + + boost::shared_ptr ret = _playlist.region_by_id (id); + + if (!ret) { + ret = RegionFactory::region_by_id (id); + } + + return ret; +} Playlist::Playlist (Session& sess, string nom, DataType type, bool hide) : SessionObject(sess, nom) + , regions (*this) , _type(type) { init (hide); first_set_state = false; _name = nom; - + _set_sort_id (); } Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide) : SessionObject(sess, "unnamed playlist") + , regions (*this) , _type(type) { +#ifndef NDEBUG const XMLProperty* prop = node.property("type"); assert(!prop || DataType(prop->value()) == _type); +#endif init (hide); _name = "unnamed"; /* reset by set_state */ + _set_sort_id (); /* set state called by derived class */ } Playlist::Playlist (boost::shared_ptr other, string namestr, bool hide) - : SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id) + : SessionObject(other->_session, namestr) + , regions (*this) + , _type(other->_type) + , _orig_diskstream_id (other->_orig_diskstream_id) { init (hide); RegionList tmp; other->copy_regions (tmp); - + in_set_state++; for (list >::iterator x = tmp.begin(); x != tmp.end(); ++x) { @@ -123,29 +218,32 @@ Playlist::Playlist (boost::shared_ptr other, string namestr, boo subcnt = 0; _read_data_count = 0; _frozen = other->_frozen; - + layer_op_counter = other->layer_op_counter; freeze_length = other->freeze_length; } -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) +Playlist::Playlist (boost::shared_ptr other, framepos_t start, framecnt_t cnt, string str, bool hide) + : SessionObject(other->_session, str) + , regions (*this) + , _type(other->_type) + , _orig_diskstream_id (other->_orig_diskstream_id) { RegionLock rlock2 (const_cast (other.get())); - nframes_t end = start + cnt - 1; + framepos_t end = start + cnt - 1; init (hide); in_set_state++; - 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; - nframes_t offset = 0; - nframes_t position = 0; - nframes_t len = 0; + frameoffset_t offset = 0; + framepos_t position = 0; + framecnt_t len = 0; string new_name; OverlapType overlap; @@ -182,13 +280,20 @@ Playlist::Playlist (boost::shared_ptr other, nframes_t start, nf break; } - _session.region_name (new_name, region->name(), false); + RegionFactory::region_name (new_name, region->name(), false); + + PropertyList plist; - new_region = RegionFactory::RegionFactory::create (region, offset, len, new_name, region->layer(), region->flags()); + plist.add (Properties::start, region->start() + offset); + plist.add (Properties::length, len); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, region->layer()); + + new_region = RegionFactory::RegionFactory::create (region, plist); add_region_internal (new_region, position); } - + in_set_state--; first_set_state = false; @@ -206,7 +311,7 @@ void Playlist::release () { if (_refcnt > 0) { - _refcnt--; + _refcnt--; } if (_refcnt == 0) { @@ -220,17 +325,21 @@ Playlist::copy_regions (RegionList& newlist) const RegionLock rlock (const_cast (this)); for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - newlist.push_back (RegionFactory::RegionFactory::create (*i)); + newlist.push_back (RegionFactory::RegionFactory::create (*i, true)); } } void Playlist::init (bool hide) { + add_property (regions); + _xml_node_name = X_("Playlist"); + g_atomic_int_set (&block_notifications, 0); g_atomic_int_set (&ignore_state_changes, 0); - pending_modified = false; + pending_contents_change = false; pending_length = false; + pending_layering = false; first_set_state = true; _refcnt = 0; _hidden = hide; @@ -238,6 +347,7 @@ Playlist::init (bool hide) _shuffling = false; _nudging = false; in_set_state = 0; + in_update = false; _edit_mode = Config->get_edit_mode(); in_flush = false; in_partition = false; @@ -246,12 +356,19 @@ Playlist::init (bool hide) _frozen = false; layer_op_counter = 0; freeze_length = 0; + _explicit_relayering = false; + _combine_ops = 0; - Modified.connect (mem_fun (*this, &Playlist::mark_session_dirty)); + _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)); } Playlist::~Playlist () { + DEBUG_TRACE (DEBUG::Destruction, string_compose ("Playlist %1 destructor\n", _name)); + { RegionLock rl (this); @@ -263,6 +380,32 @@ Playlist::~Playlist () /* GoingAway must be emitted by derived classes */ } +void +Playlist::_set_sort_id () +{ + /* + Playlists are given names like . + or .. where id + is an integer. We extract the id and sort by that. + */ + + 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); + + try { + _sort_id = boost::lexical_cast(t); + } + + catch (boost::bad_lexical_cast e) { + _sort_id = 0; + } + } +} + bool Playlist::set_name (const string& str) { @@ -274,19 +417,37 @@ Playlist::set_name (const string& str) if (_refcnt > 2) { return false; - } else { - return SessionObject::set_name(str); + } + + bool ret = SessionObject::set_name(str); + if (ret) { + _set_sort_id (); } + return ret; } /*********************************************************************** 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). ***********************************************************************/ +void +Playlist::begin_undo () +{ + in_update = true; + freeze (); +} + +void +Playlist::end_undo () +{ + thaw (true); + in_update = false; +} + void Playlist::freeze () { @@ -294,11 +455,12 @@ Playlist::freeze () g_atomic_int_inc (&ignore_state_changes); } +/** @param from_undo true if this thaw is triggered by the end of an undo on this playlist */ void -Playlist::thaw () +Playlist::thaw (bool from_undo) { g_atomic_int_dec_and_test (&ignore_state_changes); - release_notifications (); + release_notifications (from_undo); } @@ -306,25 +468,37 @@ void Playlist::delay_notifications () { g_atomic_int_inc (&block_notifications); - freeze_length = _get_maximum_extent(); + freeze_length = _get_extent().second; } +/** @param from_undo true if this release is triggered by the end of an undo on this playlist */ void -Playlist::release_notifications () +Playlist::release_notifications (bool from_undo) { - if (g_atomic_int_dec_and_test (&block_notifications)) { - flush_notifications (); - } + if (g_atomic_int_dec_and_test (&block_notifications)) { + flush_notifications (from_undo); + } +} + +void +Playlist::notify_contents_changed () +{ + if (holding_state ()) { + pending_contents_change = true; + } else { + pending_contents_change = false; + ContentsChanged(); /* EMIT SIGNAL */ + } } void -Playlist::notify_modified () +Playlist::notify_layering_changed () { if (holding_state ()) { - pending_modified = true; + pending_layering = true; } else { - pending_modified = false; - Modified(); /* EMIT SIGNAL */ + pending_layering = false; + LayeringChanged(); /* EMIT SIGNAL */ } } @@ -333,7 +507,7 @@ Playlist::notify_region_removed (boost::shared_ptr r) { if (holding_state ()) { pending_removes.insert (r); - pending_modified = true; + pending_contents_change = true; pending_length = true; } else { /* this might not be true, but we have to act @@ -341,30 +515,75 @@ Playlist::notify_region_removed (boost::shared_ptr r) */ pending_length = false; LengthChanged (); /* EMIT SIGNAL */ - pending_modified = false; - Modified (); /* EMIT SIGNAL */ + pending_contents_change = false; + RegionRemoved (boost::weak_ptr (r)); /* EMIT SIGNAL */ + ContentsChanged (); /* EMIT SIGNAL */ } } void Playlist::notify_region_moved (boost::shared_ptr r) { - Evoral::RangeMove const move (r->last_position (), r->length (), r->position ()); - + 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< Evoral::RangeMove > m; m.push_back (move); - RangesMoved (m); + RangesMoved (m, false); + } +} + +void +Playlist::notify_region_start_trimmed (boost::shared_ptr r) +{ + if (r->position() >= r->last_position()) { + /* trimmed shorter */ + return; + } + + 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()) { + /* trimmed shorter */ } + 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) { @@ -374,13 +593,15 @@ Playlist::notify_region_added (boost::shared_ptr r) if (holding_state()) { pending_adds.insert (r); - pending_modified = true; + pending_contents_change = true; pending_length = true; } else { + r->clear_changes (); pending_length = false; LengthChanged (); /* EMIT SIGNAL */ - pending_modified = false; - Modified (); /* EMIT SIGNAL */ + pending_contents_change = false; + RegionAdded (boost::weak_ptr (r)); /* EMIT SIGNAL */ + ContentsChanged (); /* EMIT SIGNAL */ } } @@ -392,17 +613,20 @@ Playlist::notify_length_changed () } else { pending_length = false; LengthChanged(); /* EMIT SIGNAL */ - pending_modified = false; - Modified (); /* EMIT SIGNAL */ + pending_contents_change = false; + ContentsChanged (); /* EMIT SIGNAL */ } } +/** @param from_undo true if this flush is triggered by the end of an undo on this playlist */ void -Playlist::flush_notifications () +Playlist::flush_notifications (bool from_undo) { set > dependent_checks_needed; set >::iterator s; - uint32_t n = 0; + uint32_t regions_changed = false; + bool check_length = false; + framecnt_t old_length = 0; if (in_flush) { return; @@ -410,9 +634,17 @@ Playlist::flush_notifications () in_flush = true; + if (!pending_bounds.empty() || !pending_removes.empty() || !pending_adds.empty()) { + regions_changed = true; + if (!pending_length) { + old_length = _get_extent ().second; + check_length = true; + } + } + /* 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. */ @@ -420,37 +652,53 @@ Playlist::flush_notifications () // pending_bounds.sort (cmp); for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) { - if (Config->get_layer_model() == MoveAddHigher) { + if (_session.config.get_layer_model() == MoveAddHigher) { timestamp_layer_op (*r); } - pending_length = true; dependent_checks_needed.insert (*r); - n++; + } + + for (s = pending_removes.begin(); s != pending_removes.end(); ++s) { + remove_dependents (*s); + // cerr << _name << " sends RegionRemoved\n"; + RegionRemoved (boost::weak_ptr (*s)); /* EMIT SIGNAL */ } for (s = pending_adds.begin(); s != pending_adds.end(); ++s) { + // cerr << _name << " sends RegionAdded\n"; + /* don't emit RegionAdded signal until relayering is done, + so that the region is fully setup by the time + anyone hear's that its been added + */ dependent_checks_needed.insert (*s); - n++; } - for (s = pending_removes.begin(); s != pending_removes.end(); ++s) { - remove_dependents (*s); - n++; + if (check_length) { + if (old_length != _get_extent().second) { + pending_length = true; + // cerr << _name << " length has changed\n"; + } } - if ((freeze_length != _get_maximum_extent()) || pending_length) { - pending_length = 0; + if (pending_length || (freeze_length != _get_extent().second)) { + pending_length = false; + // cerr << _name << " sends LengthChanged\n"; LengthChanged(); /* EMIT SIGNAL */ - n++; } - if (n || pending_modified) { + if (regions_changed || pending_contents_change) { if (!in_set_state) { relayer (); } - pending_modified = false; - Modified (); /* EMIT SIGNAL */ - + pending_contents_change = false; + // cerr << _name << " sends 5 contents change @ " << get_microseconds() << endl; + ContentsChanged (); /* EMIT SIGNAL */ + // cerr << _name << "done contents change @ " << get_microseconds() << endl; + } + + for (s = pending_adds.begin(); s != pending_adds.end(); ++s) { + (*s)->clear_changes (); + RegionAdded (boost::weak_ptr (*s)); /* EMIT SIGNAL */ } for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) { @@ -458,15 +706,28 @@ Playlist::flush_notifications () } if (!pending_range_moves.empty ()) { - RangesMoved (pending_range_moves); + RangesMoved (pending_range_moves, from_undo); } + if (!pending_region_extensions.empty ()) { + RegionsExtended (pending_region_extensions); + } + + clear_pending (); + + in_flush = false; +} + +void +Playlist::clear_pending () +{ pending_adds.clear (); pending_removes.clear (); pending_bounds.clear (); pending_range_moves.clear (); - - in_flush = false; + pending_region_extensions.clear (); + pending_contents_change = false; + pending_length = false; } /************************************************************* @@ -474,44 +735,54 @@ Playlist::flush_notifications () *************************************************************/ void -Playlist::add_region (boost::shared_ptr region, nframes_t position, float times, bool auto_partition) +Playlist::add_region (boost::shared_ptr region, framepos_t position, float times, bool auto_partition) { RegionLock rlock (this); times = fabs (times); - + int itimes = (int) floor (times); - nframes_t pos = position; + framepos_t pos = position; - if(times == 1 && auto_partition){ - partition(pos, (nframes_t) (pos + region->length()), true); + if (times == 1 && auto_partition){ + partition(pos - 1, (pos + region->length()), true); } - + if (itimes >= 1) { add_region_internal (region, pos); pos += region->length(); --itimes; } - - + + /* note that itimes can be zero if we being asked to just insert a single fraction of the region. */ for (int i = 0; i < itimes; ++i) { - boost::shared_ptr copy = RegionFactory::create (region); + boost::shared_ptr copy = RegionFactory::create (region, true); add_region_internal (copy, pos); pos += region->length(); } - - nframes_t length = 0; + + framecnt_t length = 0; if (floor (times) != times) { - length = (nframes_t) floor (region->length() * (times - floor (times))); + length = (framecnt_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); + RegionFactory::region_name (name, region->name(), false); + + { + PropertyList plist; + + plist.add (Properties::start, region->start()); + plist.add (Properties::length, length); + plist.add (Properties::name, name); + plist.add (Properties::layer, region->layer()); + + boost::shared_ptr sub = RegionFactory::create (region, plist); + add_region_internal (sub, pos); + } } possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr()); @@ -530,23 +801,24 @@ Playlist::set_region_ownership () } bool -Playlist::add_region_internal (boost::shared_ptr region, nframes_t position) +Playlist::add_region_internal (boost::shared_ptr region, framepos_t position) { if (region->data_type() != _type){ return false; } RegionSortByPosition cmp; - nframes_t old_length = 0; + + framecnt_t old_length = 0; if (!holding_state()) { - old_length = _get_maximum_extent(); + old_length = _get_extent().second; } if (!first_set_state) { boost::shared_ptr foo (shared_from_this()); region->set_playlist (boost::weak_ptr(foo)); - } + } region->set_position (position, this); @@ -557,32 +829,31 @@ Playlist::add_region_internal (boost::shared_ptr region, nframes_t posit possibly_splice_unlocked (position, region->length(), region); - if (!holding_state () && !in_set_state) { - /* layers get assigned from XML state */ + if (!holding_state ()) { + /* layers get assigned from XML state, and are not reset during undo/redo */ relayer (); } /* 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()) { + + if (old_length != _get_extent().second) { notify_length_changed (); } } - region_state_changed_connections.push_back ( - region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), - boost::weak_ptr (region))) - ); + region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr (region))); return true; } void -Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr newr, nframes_t pos) +Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr newr, framepos_t pos) { RegionLock rlock (this); @@ -594,7 +865,7 @@ Playlist::replace_region (boost::shared_ptr old, boost::shared_ptrlength() - (nframes64_t) newr->length()); + possibly_splice_unlocked (pos, old->length() - newr->length()); } void @@ -608,10 +879,11 @@ int Playlist::remove_region_internal (boost::shared_ptr region) { RegionList::iterator i; - nframes_t old_length = 0; + framecnt_t old_length = 0; + int ret = -1; if (!holding_state()) { - old_length = _get_maximum_extent(); + old_length = _get_extent().second; } if (!in_set_state) { @@ -619,11 +891,13 @@ Playlist::remove_region_internal (boost::shared_ptr region) region->set_playlist (boost::weak_ptr()); } + /* XXX should probably freeze here .... */ + for (i = regions.begin(); i != regions.end(); ++i) { if (*i == region) { - nframes_t pos = (*i)->position(); - nframes64_t distance = (*i)->length(); + framepos_t pos = (*i)->position(); + framecnt_t distance = (*i)->length(); regions.erase (i); @@ -632,19 +906,18 @@ Playlist::remove_region_internal (boost::shared_ptr region) if (!holding_state ()) { relayer (); remove_dependents (region); - - if (old_length != _get_maximum_extent()) { + + if (old_length != _get_extent().second) { notify_length_changed (); } } notify_region_removed (region); - return 0; + ret = 0; + break; } } - - return -1; } @@ -678,19 +951,19 @@ Playlist::get_region_list_equivalent_regions (boost::shared_ptr other, v } void -Playlist::partition (nframes_t start, nframes_t end, bool cut) +Playlist::partition (framepos_t start, framepos_t end, bool cut) { RegionList thawlist; partition_internal (start, end, cut, thawlist); for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { - (*i)->thaw ("separation"); + (*i)->resume_property_changes (); } } void -Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist) +Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist) { RegionList new_regions; @@ -702,21 +975,21 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi string new_name; RegionList::iterator tmp; OverlapType overlap; - nframes_t pos1, pos2, pos3, pos4; - + framepos_t pos1, pos2, pos3, pos4; + in_partition = true; - + /* need to work from a copy, because otherwise the regions we add during the process get operated on as well. */ - - RegionList copy = regions; - + + RegionList copy = regions.rlist(); + 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) { @@ -727,7 +1000,7 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi continue; } - + /* coverage will return OverlapStart if the start coincides with the end point. we do not partition such a region, so catch this special case. @@ -745,12 +1018,12 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi 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 ---------------*************************------------ @@ -759,33 +1032,52 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi ---------------*****++++++++++++++++====------------ CUT ---------------*****----------------====------------ - + */ if (!cutting) { /* "middle" ++++++ */ + + RegionFactory::region_name (new_name, current->name(), false); + + PropertyList plist; - _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)); + plist.add (Properties::start, current->start() + (pos2 - pos1)); + plist.add (Properties::length, pos3 - pos2); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, regions.size()); + plist.add (Properties::automatic, true); + plist.add (Properties::left_of_split, true); + plist.add (Properties::right_of_split, true); + + region = RegionFactory::create (current, plist); add_region_internal (region, start); 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)); + + RegionFactory::region_name (new_name, current->name(), false); + + PropertyList plist; + + plist.add (Properties::start, current->start() + (pos3 - pos1)); + plist.add (Properties::length, pos4 - pos3); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, regions.size()); + plist.add (Properties::automatic, true); + plist.add (Properties::right_of_split, true); + + region = RegionFactory::create (current, plist); add_region_internal (region, end); new_regions.push_back (region); - + /* "front" ***** */ - - current->freeze (); + + current->suspend_property_changes (); thawlist.push_back (current); - current->trim_end (pos2, this); + current->cut_end (pos2 - 1, this); } else if (overlap == OverlapEnd) { @@ -793,61 +1085,79 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi start end ---------------*************************------------ P1 P2 P4 P3 - SPLIT: + SPLIT: ---------------**************+++++++++++------------ - CUT: + CUT: ---------------**************----------------------- */ - + if (!cutting) { /* end +++++ */ + + RegionFactory::region_name (new_name, current->name(), false); - _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)); + PropertyList plist; + + plist.add (Properties::start, current->start() + (pos2 - pos1)); + plist.add (Properties::length, pos4 - pos2); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, regions.size()); + plist.add (Properties::automatic, true); + plist.add (Properties::left_of_split, true); + + region = RegionFactory::create (current, plist); add_region_internal (region, start); new_regions.push_back (region); } - + /* front ****** */ - - current->freeze (); + + current->suspend_property_changes (); thawlist.push_back (current); - current->trim_end (pos2, this); + current->cut_end (pos2 - 1, 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)); + RegionFactory::region_name (new_name, current->name(), false); + + PropertyList plist; + + plist.add (Properties::start, current->start()); + plist.add (Properties::length, pos3 - pos1); + plist.add (Properties::name, new_name); + plist.add (Properties::layer, regions.size()); + plist.add (Properties::automatic, true); + plist.add (Properties::right_of_split, true); + + region = RegionFactory::create (current, plist); add_region_internal (region, pos1); new_regions.push_back (region); - } - + } + /* end */ - - current->freeze (); + + current->suspend_property_changes (); thawlist.push_back (current); current->trim_front (pos3, this); } else if (overlap == OverlapExternal) { @@ -855,19 +1165,19 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi /* 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); } @@ -885,11 +1195,11 @@ Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, Regi } boost::shared_ptr -Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(nframes_t, nframes_t,bool), list& ranges, bool result_is_hidden) +Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(framepos_t, framecnt_t,bool), list& ranges, bool result_is_hidden) { boost::shared_ptr ret; boost::shared_ptr pl; - nframes_t start; + framepos_t start; if (ranges.empty()) { return boost::shared_ptr(); @@ -900,11 +1210,11 @@ Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(nframes_t, nfra 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. @@ -920,19 +1230,19 @@ Playlist::cut_copy (boost::shared_ptr (Playlist::*pmf)(nframes_t, nfra boost::shared_ptr Playlist::cut (list& ranges, bool result_is_hidden) { - boost::shared_ptr (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::cut; + boost::shared_ptr (Playlist::*pmf)(framepos_t,framecnt_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)(nframes_t,nframes_t,bool) = &Playlist::copy; + boost::shared_ptr (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::copy; return cut_copy (pmf, ranges, result_is_hidden); } boost::shared_ptr -Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden) +Playlist::cut (framepos_t start, framecnt_t cnt, bool result_is_hidden) { boost::shared_ptr the_copy; RegionList thawlist; @@ -950,53 +1260,52 @@ Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden) partition_internal (start, start+cnt-1, true, thawlist); for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { - (*i)->thaw ("playlist cut"); + (*i)->resume_property_changes(); } return the_copy; } boost::shared_ptr -Playlist::copy (nframes_t start, nframes_t cnt, bool result_is_hidden) +Playlist::copy (framepos_t start, framecnt_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); + cnt = min (_get_extent().second - start, cnt); return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden); } int -Playlist::paste (boost::shared_ptr other, nframes_t position, float times) +Playlist::paste (boost::shared_ptr other, framepos_t position, float times) { times = fabs (times); - nframes_t old_length; { RegionLock rl1 (this); RegionLock rl2 (other.get()); - old_length = _get_maximum_extent(); - + framecnt_t const old_length = _get_extent().second; + int itimes = (int) floor (times); - nframes_t pos = position; - nframes_t shift = other->_get_maximum_extent(); + framepos_t pos = position; + framecnt_t const shift = other->_get_extent().second; layer_t top_layer = regions.size(); while (itimes--) { for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) { - boost::shared_ptr copy_of_region = RegionFactory::create (*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. */ - + copy_of_region->set_layer (copy_of_region->layer() + top_layer); - add_region_internal (copy_of_region, copy_of_region->position() + pos); + add_region_internal (copy_of_region, (*i)->position() + pos); } pos += shift; } @@ -1004,11 +1313,11 @@ Playlist::paste (boost::shared_ptr other, nframes_t position, float ti /* XXX shall we handle fractional cases at some point? */ - if (old_length != _get_maximum_extent()) { + if (old_length != _get_extent().second) { notify_length_changed (); } - + } return 0; @@ -1016,34 +1325,43 @@ Playlist::paste (boost::shared_ptr other, nframes_t position, float ti void -Playlist::duplicate (boost::shared_ptr region, nframes_t position, float times) +Playlist::duplicate (boost::shared_ptr region, framepos_t position, float times) { times = fabs (times); RegionLock rl (this); int itimes = (int) floor (times); - nframes_t pos = position; + framepos_t pos = position + 1; while (itimes--) { - boost::shared_ptr copy = RegionFactory::create (region); + boost::shared_ptr copy = RegionFactory::create (region, true); add_region_internal (copy, pos); pos += region->length(); } if (floor (times) != times) { - nframes_t length = (nframes_t) floor (region->length() * (times - floor (times))); + framecnt_t length = (framecnt_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); + RegionFactory::region_name (name, region->name(), false); + + { + PropertyList plist; + + 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, pos); + } } } void -Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bool ignore_music_glue) +Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue) { RegionLock rlock (this); - RegionList copy (regions); + RegionList copy (regions.rlist()); RegionList fixup; for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { @@ -1052,19 +1370,19 @@ Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bo /* 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) { + if (!ignore_music_glue && (*r)->position_lock_style() != AudioTime) { fixup.push_back (*r); continue; } @@ -1078,10 +1396,10 @@ Playlist::shift (nframes64_t at, nframes64_t distance, bool move_intersected, bo } void -Playlist::split (nframes64_t at) +Playlist::split (framepos_t at) { RegionLock rlock (this); - RegionList copy (regions); + RegionList copy (regions.rlist()); /* use a copy since this operation can modify the region list */ @@ -1092,14 +1410,14 @@ Playlist::split (nframes64_t at) } void -Playlist::split_region (boost::shared_ptr region, nframes_t playlist_position) +Playlist::split_region (boost::shared_ptr region, framepos_t playlist_position) { RegionLock rl (this); _split_region (region, playlist_position); } void -Playlist::_split_region (boost::shared_ptr region, nframes_t playlist_position) +Playlist::_split_region (boost::shared_ptr region, framepos_t playlist_position) { if (!region->covers (playlist_position)) { return; @@ -1112,24 +1430,49 @@ Playlist::_split_region (boost::shared_ptr region, nframes_t playlist_po boost::shared_ptr left; boost::shared_ptr right; - nframes_t before; - nframes_t after; + frameoffset_t before; + frameoffset_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)); + RegionFactory::region_name (before_name, region->name(), false); + + { + PropertyList plist; + + plist.add (Properties::position, region->position ()); + plist.add (Properties::length, before); + plist.add (Properties::name, before_name); + plist.add (Properties::left_of_split, true); + + /* note: we must use the version of ::create with an offset here, + since it supplies that offset to the Region constructor, which + is necessary to get audio region gain envelopes right. + */ + left = RegionFactory::create (region, 0, plist); + } + + RegionFactory::region_name (after_name, region->name(), false); + + { + PropertyList plist; + + plist.add (Properties::position, region->position() + before); + plist.add (Properties::length, after); + plist.add (Properties::name, after_name); + plist.add (Properties::right_of_split, true); + + /* same note as above */ + right = RegionFactory::create (region, before, plist); + } add_region_internal (left, region->position()); add_region_internal (right, region->position() + before); @@ -1140,21 +1483,21 @@ Playlist::_split_region (boost::shared_ptr region, nframes_t playlist_po (*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); - + remove_region_internal (region); _splicing = old_sp; } void -Playlist::possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) +Playlist::possibly_splice (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) { if (_splicing || in_set_state) { /* don't respond to splicing moves or state setting */ @@ -1167,7 +1510,7 @@ Playlist::possibly_splice (nframes_t at, nframes64_t distance, boost::shared_ptr } void -Playlist::possibly_splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) +Playlist::possibly_splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) { if (_splicing || in_set_state) { /* don't respond to splicing moves or state setting */ @@ -1180,7 +1523,7 @@ Playlist::possibly_splice_unlocked (nframes_t at, nframes64_t distance, boost::s } void -Playlist::splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) +Playlist::splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) { { RegionLock rl (this); @@ -1189,13 +1532,13 @@ Playlist::splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) +Playlist::splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) { core_splice (at, distance, exclude); } void -Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr exclude) +Playlist::core_splice (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) { _splicing = true; @@ -1206,13 +1549,13 @@ Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptrposition() >= at) { - nframes64_t new_pos = (*i)->position() + distance; + framepos_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(); - } - + } else if (new_pos >= max_framepos - (*i)->length()) { + new_pos = max_framepos - (*i)->length(); + } + (*i)->set_position (new_pos, this); } } @@ -1223,26 +1566,27 @@ Playlist::core_splice (nframes_t at, nframes64_t distance, boost::shared_ptr region) +Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr region) { if (in_set_state || _splicing || _nudging || _shuffling) { return; } - if (what_changed & ARDOUR::PositionChanged) { + 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); - + if (i == regions.end()) { - warning << string_compose (_("%1: bounds changed received for region (%2)not in playlist"), - _name, region->name()) - << endmsg; + /* 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 + */ return; } @@ -1250,17 +1594,17 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr 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 (what_changed.contains (Properties::position) || what_changed.contains (Properties::length)) { + + frameoffset_t delta = 0; + + if (what_changed.contains (Properties::position)) { + delta = region->position() - region->last_position(); + } + + if (what_changed.contains (Properties::length)) { + delta += region->length() - region->last_length(); + } if (delta) { possibly_splice (region->last_position() + region->last_length(), delta, region); @@ -1269,11 +1613,11 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr if (holding_state ()) { pending_bounds.push_back (region); } else { - if (Config->get_layer_model() == MoveAddHigher) { + if (_session.config.get_layer_model() == MoveAddHigher) { /* it moved or changed length, so change the timestamp */ timestamp_layer_op (region); } - + notify_length_changed (); relayer (); check_dependents (region, false); @@ -1282,7 +1626,7 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr } void -Playlist::region_changed_proxy (Change what_changed, boost::weak_ptr weak_region) +Playlist::region_changed_proxy (const PropertyChange& what_changed, boost::weak_ptr weak_region) { boost::shared_ptr region (weak_region.lock()); @@ -1290,37 +1634,56 @@ Playlist::region_changed_proxy (Change what_changed, boost::weak_ptr wea return; } - /* this makes a virtual call to the right kind of playlist ... */ region_changed (what_changed, region); } bool -Playlist::region_changed (Change what_changed, boost::shared_ptr region) +Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr region) { - Change our_interests = Change (Region::MuteChanged|Region::LayerChanged|Region::OpacityChanged); + PropertyChange our_interests; + PropertyChange bounds; + PropertyChange pos_and_length; bool save = false; if (in_set_state || in_flush) { return false; } - if (what_changed & BoundsChanged) { + our_interests.add (Properties::muted); + our_interests.add (Properties::layer); + our_interests.add (Properties::opaque); + + bounds.add (Properties::start); + bounds.add (Properties::position); + bounds.add (Properties::length); + + pos_and_length.add (Properties::position); + pos_and_length.add (Properties::length); + + if (what_changed.contains (bounds)) { region_bounds_changed (what_changed, region); save = !(_splicing || _nudging); } - - if ((what_changed & our_interests) && - !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) { + + if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) { check_dependents (region, false); } - if (what_changed & Change (ARDOUR::PositionChanged)) { + if (what_changed.contains (Properties::position) && !what_changed.contains (Properties::length)) { notify_region_moved (region); + } else if (!what_changed.contains (Properties::position) && what_changed.contains (Properties::length)) { + notify_region_end_trimmed (region); + } else if (what_changed.contains (Properties::position) && what_changed.contains (Properties::length)) { + notify_region_start_trimmed (region); } - - if (what_changed & our_interests) { + + /* don't notify about layer changes, since we are the only object that can initiate + them, and we notify in ::relayer() + */ + + if (what_changed.contains (our_interests)) { save = true; } @@ -1335,33 +1698,48 @@ Playlist::drop_regions () all_regions.clear (); } +void +Playlist::sync_all_regions_with_regions () +{ + RegionLock rl (this); + + all_regions.clear (); + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + all_regions.insert (*i); + } +} + void Playlist::clear (bool with_signals) { { RegionLock rl (this); - for ( - std::list::iterator i = region_state_changed_connections.begin (); - i != region_state_changed_connections.end (); - ++i - ) { + region_state_changed_connections.drop_connections (); - i->disconnect (); - - } - 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) { + remove_dependents (*s); + } } if (with_signals) { + + for (set >::iterator s = pending_removes.begin(); s != pending_removes.end(); ++s) { + RegionRemoved (boost::weak_ptr (*s)); /* EMIT SIGNAL */ + } + + pending_removes.clear (); pending_length = false; LengthChanged (); - pending_modified = false; - Modified (); + pending_contents_change = false; + ContentsChanged (); } } @@ -1371,44 +1749,91 @@ Playlist::clear (bool with_signals) **********************************************************************/ Playlist::RegionList * -Playlist::regions_at (nframes_t frame) +Playlist::regions_at (framepos_t frame) { RegionLock rlock (this); return find_regions_at (frame); -} +} + +uint32_t +Playlist::count_regions_at (framepos_t frame) const +{ + RegionLock rlock (const_cast(this)); + uint32_t cnt = 0; + + for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->covers (frame)) { + cnt++; + } + } + + return cnt; +} boost::shared_ptr -Playlist::top_region_at (nframes_t frame) +Playlist::top_region_at (framepos_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 (framepos_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) +Playlist::regions_to_read (framepos_t start, framepos_t end) { /* Caller must hold lock */ RegionList covering; - set to_check; + set to_check; set > unique; - RegionList here; to_check.insert (start); to_check.insert (end); + DEBUG_TRACE (DEBUG::AudioPlayback, ">>>>> REGIONS TO READ\n"); + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { /* find all/any regions that span start+end */ @@ -1419,22 +1844,38 @@ Playlist::regions_to_read (nframes_t start, nframes_t end) case OverlapInternal: covering.push_back (*i); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OInternal)\n", (*i)->name())); break; case OverlapStart: to_check.insert ((*i)->position()); + if ((*i)->position() != 0) { + to_check.insert ((*i)->position()-1); + } + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will check %1 for %2\n", (*i)->position(), (*i)->name())); covering.push_back (*i); break; case OverlapEnd: to_check.insert ((*i)->last_frame()); + to_check.insert ((*i)->last_frame()+1); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OEnd)\n", (*i)->name())); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name())); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name())); covering.push_back (*i); break; case OverlapExternal: covering.push_back (*i); to_check.insert ((*i)->position()); + if ((*i)->position() != 0) { + to_check.insert ((*i)->position()-1); + } to_check.insert ((*i)->last_frame()); + to_check.insert ((*i)->last_frame()+1); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OExt)\n", (*i)->name())); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->position(), (*i)->name())); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("\ttoread: will check %1 for %2\n", (*i)->last_frame(), (*i)->name())); break; } @@ -1452,55 +1893,70 @@ Playlist::regions_to_read (nframes_t start, nframes_t end) if (covering.size() == 1) { rlist->push_back (covering.front()); - + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("Just one covering region (%1)\n", covering.front()->name())); + } else { - - for (set::iterator t = to_check.begin(); t != to_check.end(); ++t) { - + + RegionList here; + for (set::iterator t = to_check.begin(); t != to_check.end(); ++t) { + here.clear (); - + + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("++++ Considering %1\n", *t)); + for (RegionList::iterator x = covering.begin(); x != covering.end(); ++x) { - + if ((*x)->covers (*t)) { here.push_back (*x); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 covers %2\n", + (*x)->name(), + (*t))); + } else { + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("region %1 does NOT covers %2\n", + (*x)->name(), + (*t))); } + } - + 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 */ - + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("%1 is opaque, ignore all others\n", + (*c)->name())); 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); } } + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("<<<<< REGIONS TO READ returns %1\n", rlist->size())); + return rlist; } Playlist::RegionList * -Playlist::find_regions_at (nframes_t frame) +Playlist::find_regions_at (framepos_t frame) { /* Caller must hold lock */ @@ -1516,7 +1972,7 @@ Playlist::find_regions_at (nframes_t frame) } Playlist::RegionList * -Playlist::regions_touched (nframes_t start, nframes_t end) +Playlist::regions_touched (framepos_t start, framepos_t end) { RegionLock rlock (this); RegionList *rlist = new RegionList; @@ -1530,8 +1986,8 @@ Playlist::regions_touched (nframes_t start, nframes_t end) return rlist; } -nframes64_t -Playlist::find_next_transient (nframes64_t from, int dir) +framepos_t +Playlist::find_next_transient (framepos_t from, int dir) { RegionLock rlock (this); AnalysisFeatureList points; @@ -1551,26 +2007,26 @@ Playlist::find_next_transient (nframes64_t from, int dir) (*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; } @@ -1580,7 +2036,7 @@ Playlist::find_next_transient (nframes64_t from, int dir) if ((*x) <= from) { reached = true; } - + if (reached && (*x) < from) { return *x; } @@ -1591,11 +2047,11 @@ Playlist::find_next_transient (nframes64_t from, int dir) } boost::shared_ptr -Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) +Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir) { RegionLock rlock (this); boost::shared_ptr ret; - nframes_t closest = max_frames; + framepos_t closest = max_framepos; bool end_iter = false; @@ -1603,9 +2059,9 @@ Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) if(end_iter) break; - nframes_t distance; + frameoffset_t distance; boost::shared_ptr r = (*i); - nframes_t pos = 0; + framepos_t pos = 0; switch (point) { case Start: @@ -1616,7 +2072,6 @@ Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) break; case SyncPoint: pos = r->sync_position (); - // r->adjust_to_sync (r->first_frame()); break; } @@ -1634,7 +2089,7 @@ Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) break; default: /* backwards */ - + if (pos < frame) { if ((distance = frame - pos) < closest) { closest = distance; @@ -1652,25 +2107,25 @@ Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir) return ret; } -nframes64_t -Playlist::find_next_region_boundary (nframes64_t frame, int dir) +framepos_t +Playlist::find_next_region_boundary (framepos_t frame, int dir) { RegionLock rlock (this); - nframes64_t closest = max_frames; - nframes64_t ret = -1; + framepos_t closest = max_framepos; + framepos_t ret = -1; if (dir > 0) { for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { boost::shared_ptr r = (*i); - nframes64_t distance; - + frameoffset_t distance; + if (r->first_frame() > frame) { distance = r->first_frame() - frame; - + if (distance < closest) { ret = r->first_frame(); closest = distance; @@ -1678,9 +2133,9 @@ Playlist::find_next_region_boundary (nframes64_t frame, int dir) } if (r->last_frame () > frame) { - + distance = r->last_frame () - frame; - + if (distance < closest) { ret = r->last_frame (); closest = distance; @@ -1691,14 +2146,14 @@ Playlist::find_next_region_boundary (nframes64_t frame, int dir) } else { for (RegionList::reverse_iterator i = regions.rbegin(); i != regions.rend(); ++i) { - + boost::shared_ptr r = (*i); - nframes64_t distance; + frameoffset_t distance; if (r->last_frame() < frame) { distance = frame - r->last_frame(); - + if (distance < closest) { ret = r->last_frame(); closest = distance; @@ -1706,7 +2161,7 @@ Playlist::find_next_region_boundary (nframes64_t frame, int dir) } if (r->first_frame() < frame) { - + distance = frame - r->first_frame(); if (distance < closest) { @@ -1720,6 +2175,7 @@ Playlist::find_next_region_boundary (nframes64_t frame, int dir) return ret; } + /***********************************************************************/ @@ -1733,8 +2189,61 @@ Playlist::mark_session_dirty () } } +void +Playlist::rdiff (vector& cmds) const +{ + RegionLock rlock (const_cast (this)); + Stateful::rdiff (cmds); +} + +void +Playlist::clear_owned_changes () +{ + RegionLock rlock (this); + Stateful::clear_owned_changes (); +} + +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())); + + freeze (); + /* add the added regions */ + for (RegionListProperty::ChangeContainer::iterator i = change.added.begin(); i != change.added.end(); ++i) { + add_region ((*i), (*i)->position()); + } + /* remove the removed regions */ + for (RegionListProperty::ChangeContainer::iterator i = change.removed.begin(); i != change.removed.end(); ++i) { + remove_region (*i); + } + + thaw (); +} + +void +Playlist::load_nested_sources (const XMLNode& node) +{ + XMLNodeList nlist; + XMLNodeConstIterator niter; + + nlist = node.children(); + + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + if ((*niter)->name() == "Source") { + try { + SourceFactory::create (_session, **niter, true); + } + catch (failed_constructor& err) { + error << string_compose (_("Cannot reconstruct nested source for playlist %1"), name()) << endmsg; + } + } + } +} + int -Playlist::set_state (const XMLNode& node) +Playlist::set_state (const XMLNode& node, int version) { XMLNode *child; XMLNodeList nlist; @@ -1759,24 +2268,42 @@ Playlist::set_state (const XMLNode& node) for (piter = plist.begin(); piter != plist.end(); ++piter) { prop = *piter; - + if (prop->name() == X_("name")) { _name = prop->value(); + _set_sort_id (); + } else if (prop->name() == X_("id")) { + _id = 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()); + } else if (prop->name() == X_("combine-ops")) { + _combine_ops = atoi (prop->value()); } } - clear (false); - + clear (true); + nlist = node.children(); + /* find the "Nested" node, if any, and recreate the PlaylistSources + listed there + */ + + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + child = *niter; + + if (child->name() == "Nested") { + load_nested_sources (*child); + break; + } + } + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { child = *niter; - + if (child->name() == "Region") { if ((prop = child->property ("id")) == 0) { @@ -1785,41 +2312,43 @@ Playlist::set_state (const XMLNode& node) } ID id = prop->value (); - + if ((region = region_by_id (id))) { - Change what_changed = Change (0); + region->suspend_property_changes (); - if (region->set_live_state (*child, what_changed, true)) { - error << _("Playlist: cannot reset region state from XML") << endmsg; + if (region->set_state (*child, version)) { + region->resume_property_changes (); continue; } - - } else if ((region = RegionFactory::create (_session, *child, true)) == 0) { + + } else if ((region = RegionFactory::create (_session, *child, true)) != 0) { + region->suspend_property_changes (); + } else { error << _("Playlist: cannot create region from XML") << endmsg; continue; } + add_region (region, region->position(), 1.0); // So that layer_op ordering doesn't get screwed up region->set_last_layer_op( region->layer()); - - } + region->resume_property_changes (); + } } - - notify_modified (); - - thaw (); - /* update dependents, which was not done during add_region_internal - due to in_set_state being true + /* 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); } + thaw (); + notify_contents_changed (); + in_set_state--; first_set_state = false; return 0; @@ -1828,21 +2357,24 @@ Playlist::set_state (const XMLNode& node) 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_("id"), id().to_s()); node->add_property (X_("name"), _name); node->add_property (X_("type"), _type.to_string()); @@ -1852,6 +2384,35 @@ Playlist::state (bool full_state) if (full_state) { RegionLock rlock (this, false); + XMLNode* nested_node = 0; + + snprintf (buf, sizeof (buf), "%u", _combine_ops); + node->add_property ("combine-ops", buf); + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->max_source_level() > 0) { + + if (!nested_node) { + nested_node = new XMLNode (X_("Nested")); + } + + /* region is compound - get its playlist and + store that before we list the region that + needs it ... + */ + + const SourceList& sl ((*i)->sources()); + + for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) { + nested_node->add_child_nocopy ((*s)->get_state ()); + } + } + } + + if (nested_node) { + node->add_child_nocopy (*nested_node); + } + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { node->add_child_nocopy ((*i)->get_state()); } @@ -1878,37 +2439,39 @@ Playlist::n_regions() const return regions.size(); } -nframes_t -Playlist::get_maximum_extent () const +pair +Playlist::get_extent () const { RegionLock rlock (const_cast(this), false); - return _get_maximum_extent (); + return _get_extent (); } -ARDOUR::nframes_t -Playlist::_get_maximum_extent () const +pair +Playlist::_get_extent () const { - RegionList::const_iterator i; - nframes_t max_extent = 0; - nframes_t end = 0; + pair ext (max_framepos, 0); - for (i = regions.begin(); i != regions.end(); ++i) { - if ((end = (*i)->position() + (*i)->length()) > max_extent) { - max_extent = end; + 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; + } + if (e.second > ext.second) { + ext.second = e.second; } } - return max_extent; + return ext; } -string +string Playlist::bump_name (string name, Session &session) { string newname = name; do { - newname = bump_name_once (newname); - } while (session.playlist_by_name (newname)!=NULL); + newname = bump_name_once (newname, '.'); + } while (session.playlists->by_name (newname)!=NULL); return newname; } @@ -1917,7 +2480,7 @@ Playlist::bump_name (string name, Session &session) layer_t Playlist::top_layer() const { - RegionLock rlock (const_cast (this)); + RegionLock rlock (const_cast (this)); layer_t top = 0; for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { @@ -1939,79 +2502,128 @@ Playlist::set_edit_mode (EditMode mode) void Playlist::relayer () { - /* don't send multiple Modified notifications - when multiple regions are relayered. - */ - - freeze (); + /* never compute layers when changing state for undo/redo or setting from XML */ + + if (in_update || in_set_state) { + return; + } + + bool changed = false; + + /* 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 */ + + /* 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 */ + framepos_t start = INT64_MAX; + framepos_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()); + } - /* build up a new list of regions on each layer */ + /* hence the size of each time division */ + double const division_size = (end - start) / double (divisions); - std::vector layers; + 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; + RegionList copy = regions.rlist(); - /* sort according to the model */ + /* 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 (RegionSortByLastLayerOp ()); - if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) { - RegionSortByLastLayerOp cmp; - copy.sort (cmp); } - + + 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; 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; + + if (division_size > 0) { + start_division = floor ( ((*i)->position() - start) / division_size); + end_division = floor ( ((*i)->position() + (*i)->length() - start) / division_size ); + if (end_division == divisions) { + end_division--; + } + } + + assert (divisions == 0 || end_division < divisions); + /* 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 */ - RegionList::iterator k = layers[j - 1].begin(); - while (k != layers[j - 1].end()) { - if ((*k)->overlap_equivalent (*i)) { + + 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; } - k++; } - if (k != layers[j - 1].end()) { - /* no overlap, so we can use this layer */ + if (overlap) { + /* overlap, so we must use layer j */ break; } - - j--; + + --j; } if (j == layers.size()) { /* we need a new layer for this region */ - layers.push_back (RegionList ()); + layers.push_back (vector (divisions)); } - layers[j].push_back (*i); - } - - /* first pass: set up the layer numbers in the regions */ - for (size_t j = 0; j < layers.size(); ++j) { - for (RegionList::iterator i = layers[j].begin(); i != layers[j].end(); ++i) { - (*i)->set_layer (j); + /* 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); + } + + if ((*i)->layer() != j) { + changed = true; } - } - - /* sending Modified means that various kinds of layering - models operate correctly at the GUI - level. slightly inefficient, but only slightly. - - We force a Modified signal here in case no layers actually - changed. - */ - notify_modified (); + (*i)->set_layer (j); + } - thaw (); + if (changed) { + notify_layering_changed (); + } } /* XXX these layer functions are all deprecated */ @@ -2019,10 +2631,10 @@ Playlist::relayer () void Playlist::raise_region (boost::shared_ptr region) { - uint32_t rsz = regions.size(); + uint32_t top = regions.size() - 1; layer_t target = region->layer() + 1U; - if (target >= rsz) { + if (target >= top) { /* its already at the effective top */ return; } @@ -2047,22 +2659,48 @@ void Playlist::raise_region_to_top (boost::shared_ptr region) { /* does nothing useful if layering mode is later=higher */ - if ((Config->get_layer_model() == MoveAddHigher) || - (Config->get_layer_model() == AddHigher)) { - timestamp_layer_op (region); - relayer (); + switch (_session.config.get_layer_model()) { + case LaterHigher: + return; + default: + break; + } + + layer_t top = regions.size() - 1; + + if (region->layer() >= top) { + /* already on the top */ + return; } + + move_region_to_layer (top, region, 1); + /* mark the region's last_layer_op as now, so that it remains on top when + doing future relayers (until something else takes over) + */ + timestamp_layer_op (region); } void Playlist::lower_region_to_bottom (boost::shared_ptr region) { /* does nothing useful if layering mode is later=higher */ - if ((Config->get_layer_model() == MoveAddHigher) || - (Config->get_layer_model() == AddHigher)) { - region->set_last_layer_op (0); - relayer (); + switch (_session.config.get_layer_model()) { + case LaterHigher: + return; + default: + break; + } + + if (region->layer() == 0) { + /* already on the bottom */ + return; } + + move_region_to_layer (0, region, -1); + /* force region's last layer op to zero so that it stays at the bottom + when doing future relayers + */ + region->set_last_layer_op (0); } int @@ -2071,23 +2709,24 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr RegionList::iterator i; typedef pair,layer_t> LayerInfo; list layerinfo; - layer_t dest; { RegionLock rlock (const_cast (this)); - + for (i = regions.begin(); i != regions.end(); ++i) { - + if (region == *i) { continue; } + layer_t dest; + if (dir > 0) { /* 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 { @@ -2109,14 +2748,16 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr } LayerInfo newpair; - + newpair.first = *i; newpair.second = dest; - + layerinfo.push_back (newpair); - } + } } + freeze (); + /* now reset the layers without holding the region lock */ for (list::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) { @@ -2125,45 +2766,47 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr region->set_layer (target_layer); -#if 0 - /* now check all dependents */ + /* now check all dependents, since we changed the layering */ for (list::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) { check_dependents (x->first, false); } - + check_dependents (region, false); -#endif - + notify_layering_changed (); + + thaw (); + return 0; } void -Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards) +Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards) { RegionList::iterator i; - 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) { + framepos_t new_pos; + if (forwards) { - if ((*i)->last_frame() > max_frames - distance) { - new_pos = max_frames - (*i)->length(); + if ((*i)->last_frame() > max_framepos - distance) { + new_pos = max_framepos - (*i)->length(); } else { new_pos = (*i)->position() + distance; } - + } else { - + if ((*i)->position() > distance) { new_pos = (*i)->position() - distance; } else { @@ -2184,6 +2827,20 @@ Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards) } +bool +Playlist::uses_source (boost::shared_ptr src) const +{ + RegionLock rlock (const_cast (this)); + + for (set >::iterator r = all_regions.begin(); r != all_regions.end(); ++r) { + if ((*r)->uses_source (src)) { + return true; + } + } + + return false; +} + boost::shared_ptr Playlist::find_region (const ID& id) const { @@ -2200,8 +2857,23 @@ Playlist::find_region (const ID& id) const return boost::shared_ptr (); } +uint32_t +Playlist::region_use_count (boost::shared_ptr r) const +{ + RegionLock rlock (const_cast (this)); + uint32_t cnt = 0; + + for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i) == r) { + cnt++; + } + } + + return cnt; +} + boost::shared_ptr -Playlist::region_by_id (ID id) +Playlist::region_by_id (const ID& id) const { /* searches all regions ever added to this playlist */ @@ -2212,7 +2884,7 @@ Playlist::region_by_id (ID id) } return boost::shared_ptr (); } - + void Playlist::dump () const { @@ -2224,9 +2896,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 () @@ -2243,8 +2915,6 @@ Playlist::set_frozen (bool yn) void Playlist::timestamp_layer_op (boost::shared_ptr region) { -// struct timeval tv; -// gettimeofday (&tv, 0); region->set_last_layer_op (++layer_op_counter); } @@ -2253,7 +2923,6 @@ void Playlist::shuffle (boost::shared_ptr region, int dir) { bool moved = false; - nframes_t new_pos; if (region->locked()) { return; @@ -2263,13 +2932,13 @@ Playlist::shuffle (boost::shared_ptr region, int dir) { RegionLock 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; @@ -2280,6 +2949,8 @@ Playlist::shuffle (boost::shared_ptr region, int dir) break; } + framepos_t new_pos; + if ((*next)->position() != region->last_frame() + 1) { /* they didn't used to touch, so after shuffle, just have them swap positions. @@ -2309,10 +2980,10 @@ Playlist::shuffle (boost::shared_ptr region, int dir) } } } else { - + 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()) { @@ -2321,6 +2992,7 @@ Playlist::shuffle (boost::shared_ptr region, int dir) break; } + framepos_t new_pos; if (region->position() != (*prev)->last_frame() + 1) { /* they didn't used to touch, so after shuffle, just have them swap positions. @@ -2336,7 +3008,7 @@ Playlist::shuffle (boost::shared_ptr region, int dir) region->set_position ((*prev)->position(), this); (*prev)->set_position (new_pos, this); - + /* avoid a full sort */ regions.erase (i); // remove region @@ -2357,17 +3029,17 @@ Playlist::shuffle (boost::shared_ptr region, int dir) relayer (); check_dependents (region, false); - - notify_modified(); + + notify_contents_changed(); } } bool -Playlist::region_is_shuffle_constrained (boost::shared_ptr) +Playlist::region_is_shuffle_constrained (boost::shared_ptr) { RegionLock rlock (const_cast (this)); - + if (regions.size() > 1) { return true; } @@ -2379,13 +3051,216 @@ void Playlist::update_after_tempo_map_change () { RegionLock rlock (const_cast (this)); - RegionList copy (regions); + 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) { (*i)->update_position_after_tempo_map_change (); } thaw (); } + +void +Playlist::foreach_region (boost::function)> 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; +} + + +bool +Playlist::has_region_at (framepos_t const p) const +{ + RegionLock (const_cast (this)); + + RegionList::const_iterator i = regions.begin (); + while (i != regions.end() && !(*i)->covers (p)) { + ++i; + } + + return (i != regions.end()); +} + +/** Remove any region that uses a given source */ +void +Playlist::remove_region_by_source (boost::shared_ptr s) +{ + RegionLock rl (this); + + RegionList::iterator i = regions.begin(); + while (i != regions.end()) { + RegionList::iterator j = i; + ++j; + + if ((*i)->uses_source (s)) { + remove_region_internal (*i); + } + + i = j; + } +} + +/** Look from a session frame time and find the start time of the next region + * which is on the top layer of this playlist. + * @param t Time to look from. + * @return Position of next top-layered region, or max_framepos if there isn't one. + */ +framepos_t +Playlist::find_next_top_layer_position (framepos_t t) const +{ + RegionLock 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(); + } + } + + return max_framepos; +} + +void +Playlist::join (const RegionList& r, const std::string& name) +{ + PropertyList plist; + uint32_t channels = 0; + uint32_t layer = 0; + framepos_t earliest_position = max_framepos; + vector old_and_new_regions; + + boost::shared_ptr pl = PlaylistFactory::create (_type, _session, name, true); + + 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 + * regions + */ + + pl->in_partition = true; + + for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + + /* copy the region */ + + boost::shared_ptr original_region = (*i); + boost::shared_ptr copied_region = RegionFactory::create (original_region, false); + + old_and_new_regions.push_back (TwoRegions (original_region,copied_region)); + + /* make position relative to zero */ + + pl->add_region (copied_region, original_region->position() - earliest_position); + + /* use the maximum number of channels for any region */ + + channels = max (channels, original_region->n_channels()); + + /* it will go above the layer of the highest existing region */ + + layer = max (layer, original_region->layer()); + } + + pl->in_partition = false; + + /* now create a new PlaylistSource for each channel in the new playlist */ + + SourceList sources; + pair extent = pl->get_extent(); + + for (uint32_t chn = 0; chn < channels; ++chn) { + sources.push_back (SourceFactory::createFromPlaylist (_type, _session, pl, name, chn, 0, extent.second, false, false)); + } + + /* now a new region using the list of sources */ + + plist.add (Properties::start, 0); + plist.add (Properties::length, extent.second); + plist.add (Properties::name, name); + plist.add (Properties::layer, layer+1); + + boost::shared_ptr compound_region = RegionFactory::create (sources, plist, true); + + /* add any dependent regions to the new playlist */ + + copy_dependents (old_and_new_regions, pl); + + /* remove all the selected regions from the current playlist + */ + + freeze (); + + for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + remove_region (*i); + } + + /* add the new region at the right location */ + + add_region (compound_region, earliest_position); + + _combine_ops++; + + thaw (); +} + +uint32_t +Playlist::max_source_level () const +{ + RegionLock 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()); + } + + return lvl; +} + + +uint32_t +Playlist::count_joined_regions () const +{ + RegionLock rlock (const_cast (this)); + uint32_t cnt = 0; + + for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->max_source_level() > 0) { + cnt++; + } + } + + return cnt; +} +