X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=3bc5f57577d7349d0647880245adf7d05dfd67d9;hb=cfe9ae636e0ee61cafdff43b3bd6967d835ef629;hp=6d5e8f7847d5f0287cb96bbc21f540810b8d2a98;hpb=79986643c0c904f6574bb5323e2233a43a9e622e;p=ardour.git diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc index 6d5e8f7847..3bc5f57577 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,9 +15,9 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ +#include #include #include #include @@ -26,16 +26,24 @@ #include #include -#include - -#include -#include -#include - -#include -#include -#include -#include +#include + +#include "pbd/convert.h" +#include "pbd/failed_constructor.h" +#include "pbd/stateful_diff_command.h" +#include "pbd/xml++.h" + +#include "ardour/debug.h" +#include "ardour/playlist.h" +#include "ardour/session.h" +#include "ardour/region.h" +#include "ardour/region_factory.h" +#include "ardour/region_sorters.h" +#include "ardour/playlist_factory.h" +#include "ardour/playlist_source.h" +#include "ardour/transient_detector.h" +#include "ardour/session_playlists.h" +#include "ardour/source_factory.h" #include "i18n.h" @@ -43,103 +51,167 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -sigc::signal Playlist::PlaylistCreated; +namespace ARDOUR { +namespace Properties { +PBD::PropertyDescriptor regions; +} +} 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; }; -struct RegionSortByLayer { - bool operator() (Region *a, Region *b) { - return a->layer() < b->layer(); - } -}; -struct RegionSortByPosition { - bool operator() (Region *a, Region *b) { - return a->position() < b->position(); - } -}; -struct RegionSortByLastLayerOp { - bool operator() (Region *a, Region *b) { - return a->last_layer_op() < b->last_layer_op(); - } -}; +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); -Playlist::Playlist (Session& sess, string nom, bool hide) - : _session (sess) + 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, bool hide) - : _session (sess) +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 */ - - if (set_state (node)) { - throw failed_constructor(); - } + _set_sort_id (); + + /* 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) + , regions (*this) + , _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); - for (list::iterator x = tmp.begin(); x != tmp.end(); ++x) { - add_region_internal( (*x), (*x)->position() ); + in_set_state++; + + for (list >::iterator x = tmp.begin(); x != tmp.end(); ++x) { + 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, 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 (&((Playlist&)other)); - - jack_nframes_t end = start + cnt - 1; + RegionLock rlock2 (const_cast (other.get())); + + framepos_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) { - Region *region; - Region *new_region; - jack_nframes_t offset = 0; - jack_nframes_t position = 0; - jack_nframes_t len = 0; + boost::shared_ptr region; + boost::shared_ptr new_region; + frameoffset_t offset = 0; + framepos_t position = 0; + framecnt_t len = 0; string new_name; OverlapType overlap; @@ -176,92 +248,130 @@ Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t break; } - _session.region_name (new_name, region->name(), false); + RegionFactory::region_name (new_name, region->name(), false); + + PropertyList plist; + + 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 = createRegion (*region, offset, len, new_name, region->layer(), region->flags()); + new_region = RegionFactory::RegionFactory::create (region, plist); - add_region_internal (new_region, position, true); + add_region_internal (new_region, position); } - - /* this constructor does NOT notify others (session) */ + + in_set_state--; + first_set_state = false; } 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 { RegionLock rlock (const_cast (this)); for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) { - newlist.push_back (createRegion (**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; _splicing = false; + _shuffling = false; _nudging = false; - in_set_state = false; - _edit_mode = _session.get_edit_mode(); + in_set_state = 0; + in_update = false; + _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; + _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)); -Playlist::Playlist (const Playlist& pl) - : _session (pl._session) -{ - fatal << _("playlist const copy constructor called") << endmsg; + ContentsChanged.connect_same_thread (*this, boost::bind (&Playlist::mark_session_dirty, this)); } -Playlist::Playlist (Playlist& pl) - : _session (pl._session) +Playlist::~Playlist () { - fatal << _("playlist non-const copy constructor called") << endmsg; + DEBUG_TRACE (DEBUG::Destruction, string_compose ("Playlist %1 destructor\n", _name)); + + { + RegionLock rl (this); + + for (set >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) { + (*i)->set_playlist (boost::shared_ptr()); + } + } + + /* GoingAway must be emitted by derived classes */ } -Playlist::~Playlist () +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; + } + } } -void +bool Playlist::set_name (const string& str) { /* in a typical situation, a playlist is being used @@ -271,21 +381,38 @@ Playlist::set_name (const string& str) */ if (_refcnt > 2) { - return; + return false; } - _name = str; - NameChanged(); /* EMIT SIGNAL */ + 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 () { @@ -293,11 +420,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); } @@ -305,56 +433,140 @@ 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 */ } } void -Playlist::notify_region_removed (Region *r) +Playlist::notify_region_removed (boost::shared_ptr r) { if (holding_state ()) { - pending_removals.insert (pending_removals.end(), r); + pending_removes.insert (r); + pending_contents_change = 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 */ - 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 ()); + + if (holding_state ()) { + + pending_range_moves.push_back (move); + + } else { + + list< Evoral::RangeMove > m; + m.push_back (move); + 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 (Region *r) +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_contents_change = true; + pending_length = true; } else { - RegionAdded (r); /* EMIT SIGNAL */ - /* this might not be true, but we have to act - as though it could be. - */ + r->clear_changes (); + pending_length = false; LengthChanged (); /* EMIT SIGNAL */ - Modified (); /* EMIT SIGNAL */ + pending_contents_change = false; + RegionAdded (boost::weak_ptr (r)); /* EMIT SIGNAL */ + ContentsChanged (); /* EMIT SIGNAL */ } } @@ -364,18 +576,22 @@ Playlist::notify_length_changed () if (holding_state ()) { pending_length = true; } else { + pending_length = false; LengthChanged(); /* EMIT SIGNAL */ - 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) { - RegionList::iterator r; - RegionList::iterator a; - set dependent_checks_needed; - uint32_t n = 0; + set > dependent_checks_needed; + set >::iterator s; + uint32_t regions_changed = false; + bool check_length = false; + framecnt_t old_length = 0; if (in_flush) { return; @@ -383,9 +599,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. */ @@ -393,1047 +617,1717 @@ 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) { - timestamp_layer_op (**r); + 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) { 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 (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); + } + + if (check_length) { + if (old_length != _get_extent().second) { + pending_length = true; + // cerr << _name << " length has changed\n"; + } + } + + if (pending_length || (freeze_length != _get_extent().second)) { + pending_length = false; + // cerr << _name << " sends LengthChanged\n"; + LengthChanged(); /* EMIT SIGNAL */ + } + + if (regions_changed || pending_contents_change) { + if (!in_set_state) { + relayer (); + } + 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) { + check_dependents (*s, false); + } + + if (!pending_range_moves.empty ()) { + 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 (); + pending_region_extensions.clear (); + pending_contents_change = false; + pending_length = false; + } + + /************************************************************* + PLAYLIST OPERATIONS + *************************************************************/ + + void + 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); - for (set::iterator x = dependent_checks_needed.begin(); x != dependent_checks_needed.end(); ++x) { - check_dependents (**x, false); - } + framepos_t pos = position; - for (r = pending_removals.begin(); r != pending_removals.end(); ++r) { - remove_dependents (**r); - RegionRemoved (*r); /* EMIT SIGNAL */ - n++; - } + if (times == 1 && auto_partition){ + partition(pos - 1, (pos + region->length()), true); + } - if ((freeze_length != _get_maximum_extent()) || pending_length) { - pending_length = 0; - LengthChanged(); /* EMIT SIGNAL */ - n++; - } + if (itimes >= 1) { + add_region_internal (region, pos); + pos += region->length(); + --itimes; + } - if (n || pending_modified) { - if (!in_set_state) { - possibly_splice (); - relayer (); - } - pending_modified = false; - Modified (); /* EMIT SIGNAL */ - } - pending_adds.clear (); - pending_removals.clear (); - pending_bounds.clear (); + /* 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, true); + add_region_internal (copy, pos); + pos += region->length(); + } + + framecnt_t length = 0; - if (save_on_thaw) { - save_on_thaw = false; - save_state (last_save_reason); - } - - in_flush = false; -} + if (floor (times) != times) { + length = (framecnt_t) floor (region->length() * (times - floor (times))); + string name; + RegionFactory::region_name (name, region->name(), false); -/************************************************************* - PLAYLIST OPERATIONS - *************************************************************/ + { + PropertyList plist; -void -Playlist::add_region (const Region& region, jack_nframes_t position, float times, bool with_save) -{ - RegionLock rlock (this); - - times = fabs (times); - - int itimes = (int) floor (times); - - jack_nframes_t pos = position; - - if (itimes >= 1) { - add_region_internal (const_cast(®ion), pos, true); - 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. - */ + plist.add (Properties::start, region->start()); + plist.add (Properties::length, length); + plist.add (Properties::name, name); + plist.add (Properties::layer, region->layer()); - for (int i = 0; i < itimes; ++i) { - Region *copy = createRegion (region); - add_region_internal (copy, pos, true); - pos += region.length(); - } - - if (floor (times) != times) { - jack_nframes_t length = (jack_nframes_t) floor (region.length() * (times - floor (times))); - string name; - _session.region_name (name, region.name(), false); - Region *sub = createRegion (region, 0, length, name, region.layer(), region.flags()); - add_region_internal (sub, pos, true); - } - - if (with_save) { - maybe_save_state (_("add region")); - } -} + boost::shared_ptr sub = RegionFactory::create (region, plist); + add_region_internal (sub, pos); + } + } -void -Playlist::add_region_internal (Region *region, jack_nframes_t position, bool delay_sort) -{ - RegionSortByPosition cmp; - jack_nframes_t old_length = 0; + possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr()); + } - // cerr << "adding region " << region->name() << " at " << position << endl; + void + Playlist::set_region_ownership () + { + RegionLock rl (this); + RegionList::iterator i; + boost::weak_ptr pl (shared_from_this()); - if (!holding_state()) { - old_length = _get_maximum_extent(); - } + for (i = regions.begin(); i != regions.end(); ++i) { + (*i)->set_playlist (pl); + } + } - region->set_playlist (this); - region->set_position (position, this); - region->lock_sources (); + bool + Playlist::add_region_internal (boost::shared_ptr region, framepos_t position) + { + if (region->data_type() != _type){ + return false; + } - timestamp_layer_op (*region); + RegionSortByPosition cmp; - regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + framecnt_t old_length = 0; - if (!holding_state () && !in_set_state) { - /* layers get assigned from XML state */ - relayer (); - } + if (!holding_state()) { + old_length = _get_extent().second; + } - /* we need to notify the existence of new region before checking dependents. Ick. */ + if (!first_set_state) { + boost::shared_ptr foo (shared_from_this()); + region->set_playlist (boost::weak_ptr(foo)); + } - notify_region_added (region); - - if (!holding_state ()) { - check_dependents (*region, false); - if (old_length != _get_maximum_extent()) { - notify_length_changed (); - } - } + region->set_position (position); - region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), region)); -} + timestamp_layer_op (region); -void -Playlist::replace_region (Region& old, Region& newr, jack_nframes_t pos) -{ - RegionLock rlock (this); + regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + all_regions.insert (region); - remove_region_internal (&old); - add_region_internal (&newr, pos); + possibly_splice_unlocked (position, region->length(), region); - if (!holding_state ()) { - possibly_splice_unlocked (); - } + if (!holding_state ()) { + /* layers get assigned from XML state, and are not reset during undo/redo */ + relayer (); + } - maybe_save_state (_("replace region")); -} + /* we need to notify the existence of new region before checking dependents. Ick. */ -void -Playlist::remove_region (Region *region) -{ - RegionLock rlock (this); - remove_region_internal (region); + notify_region_added (region); - if (!holding_state ()) { - possibly_splice_unlocked (); - } - maybe_save_state (_("remove region")); -} + if (!holding_state ()) { -int -Playlist::remove_region_internal (Region *region, bool delay_sort) -{ - RegionList::iterator i; - jack_nframes_t old_length = 0; + check_dependents (region, false); - // cerr << "removing region " << region->name() << endl; + if (old_length != _get_extent().second) { + notify_length_changed (); + } + } - if (!holding_state()) { - old_length = _get_maximum_extent(); - } + region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr (region))); - for (i = regions.begin(); i != regions.end(); ++i) { - if (*i == region) { + return true; + } - regions.erase (i); + void + Playlist::replace_region (boost::shared_ptr old, boost::shared_ptr newr, framepos_t pos) + { + RegionLock rlock (this); - if (!holding_state ()) { - relayer (); - remove_dependents (*region); - - if (old_length != _get_maximum_extent()) { - notify_length_changed (); - } - } + bool old_sp = _splicing; + _splicing = true; - notify_region_removed (region); - return 0; - } - } - return -1; -} + remove_region_internal (old); + add_region_internal (newr, pos); -void -Playlist::get_equivalent_regions (const Region& other, vector& results) -{ - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if (Config->get_use_overlap_equivalency()) { - if ((*i)->overlap_equivalent (other)) { - results.push_back ((*i)); - } else if ((*i)->equivalent (other)) { - results.push_back ((*i)); - } - } - } -} + _splicing = old_sp; -void -Playlist::get_region_list_equivalent_regions (const Region& other, vector& results) -{ - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + possibly_splice_unlocked (pos, old->length() - newr->length()); + } - if ((*i) && (*i)->region_list_equivalent (other)) { - results.push_back (*i); - } - } -} + void + Playlist::remove_region (boost::shared_ptr region) + { + RegionLock rlock (this); + remove_region_internal (region); + } -void -Playlist::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level) -{ - RegionList thawlist; + int + Playlist::remove_region_internal (boost::shared_ptr region) + { + RegionList::iterator i; + framecnt_t old_length = 0; - partition_internal (start, end, false, thawlist); + if (!holding_state()) { + old_length = _get_extent().second; + } - for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { - (*i)->thaw ("separation"); - } + if (!in_set_state) { + /* unset playlist */ + region->set_playlist (boost::weak_ptr()); + } - maybe_save_state (_("separate")); -} + /* XXX should probably freeze here .... */ -void -Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist) -{ - RegionLock rlock (this); - Region *region; - Region *current; - string new_name; - RegionList::iterator tmp; - OverlapType overlap; - jack_nframes_t pos1, pos2, pos3, pos4; - RegionList new_regions; + for (i = regions.begin(); i != regions.end(); ++i) { + if (*i == region) { - in_partition = true; + framepos_t pos = (*i)->position(); + framecnt_t distance = (*i)->length(); - /* need to work from a copy, because otherwise the regions we add during the process - get operated on as well. - */ + regions.erase (i); - RegionList copy = regions; + possibly_splice_unlocked (pos, -distance); - for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) { - - tmp = i; - ++tmp; + if (!holding_state ()) { + relayer (); + remove_dependents (region); - current = *i; - - if (current->first_frame() == start && current->last_frame() == end) { - if (cutting) { - remove_region_internal (current); - } - continue; - } - - if ((overlap = current->coverage (start, end)) == OverlapNone) { - continue; - } - - pos1 = current->position(); - pos2 = start; - pos3 = end; - pos4 = current->last_frame(); + if (old_length != _get_extent().second) { + notify_length_changed (); + } + } - 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 - SPLIT: - ---------------*****++++++++++++++++====------------ - CUT - ---------------*****----------------====------------ - - */ + notify_region_removed (region); + break; + } + } - if (!cutting) { - - /* "middle" ++++++ */ - - _session.region_name (new_name, current->name(), false); - region = createRegion (*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); - new_regions.push_back (region); - } - - /* "end" ====== */ - - _session.region_name (new_name, current->name(), false); - region = createRegion (*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" ***** */ - - current->freeze (); - thawlist.push_back (current); - current->trim_end (pos2, this); - - } else if (overlap == OverlapEnd) { - - /* - start end - ---------------*************************------------ - P1 P2 P4 P3 - SPLIT: - ---------------**************+++++++++++------------ - CUT: - ---------------**************----------------------- + return -1; + } - */ + void + Playlist::get_equivalent_regions (boost::shared_ptr other, vector >& results) + { + 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 { + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->equivalent (other)) { + results.push_back ((*i)); + } + } + } + } - if (!cutting) { - - /* end +++++ */ - - _session.region_name (new_name, current->name(), false); - region = createRegion (*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); - } + void + Playlist::get_region_list_equivalent_regions (boost::shared_ptr other, vector >& results) + { + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - /* front ****** */ + if ((*i) && (*i)->region_list_equivalent (other)) { + results.push_back (*i); + } + } + } + + void + 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)->resume_property_changes (); + } + } - current->freeze (); - thawlist.push_back (current); - current->trim_end (pos2, this); + void + Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist) + { + RegionList new_regions; + + { + RegionLock rlock (this); + + boost::shared_ptr region; + boost::shared_ptr current; + string new_name; + RegionList::iterator tmp; + OverlapType overlap; + framepos_t pos1, pos2, pos3, pos4; - } else if (overlap == OverlapStart) { + in_partition = true; + + /* need to work from a copy, because otherwise the regions we add during the process + get operated on as well. + */ - /* 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 - - SPLIT: - ---------------****+++++++++++++++++++++------------ - CUT: - -------------------*********************------------ - - */ + RegionList copy = regions.rlist(); - if (!cutting) { - - /* front **** */ - _session.region_name (new_name, current->name(), false); - region = createRegion (*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); + for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) { - } else if (overlap == OverlapExternal) { + tmp = i; + ++tmp; - /* split: no split required. - cut: remove the region. - */ - - /* - start end - ---------------*************************------------ - P2 P1 P3 P4 - - SPLIT: - ---------------*************************------------ - CUT: - ---------------------------------------------------- - - */ + current = *i; - if (cutting) { - remove_region_internal (current); - } - new_regions.push_back (current); - } - } + if (current->first_frame() >= start && current->last_frame() < end) { - in_partition = false; + if (cutting) { + remove_region_internal (current); + } + + 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. + */ + + 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 + SPLIT: + ---------------*****++++++++++++++++====------------ + CUT + ---------------*****----------------====------------ - 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) -{ - Playlist* ret; - Playlist* pl; - jack_nframes_t start; + if (!cutting) { + /* "middle" ++++++ */ - if (ranges.empty()) { - return 0; - } + RegionFactory::region_name (new_name, current->name(), false); - start = ranges.front().start; + PropertyList plist; + 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); - for (list::iterator i = ranges.begin(); i != ranges.end(); ++i) { + region = RegionFactory::create (current, plist); + add_region_internal (region, start); + new_regions.push_back (region); + } - 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. - */ + /* "end" ====== */ - ret->paste (*pl, (*i).start - start, 1.0f); - delete pl; - } - } + RegionFactory::region_name (new_name, current->name(), false); - if (ret) { - /* manually notify session of new playlist here - because the playlists were constructed without notifying - */ - PlaylistCreated (ret); - } - - return ret; -} + PropertyList plist; -Playlist* -Playlist::cut (list& ranges, bool result_is_hidden) -{ - Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::cut; - return cut_copy (pmf, ranges, result_is_hidden); -} + 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); -Playlist* -Playlist::copy (list& ranges, bool result_is_hidden) -{ - Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::copy; - return cut_copy (pmf, ranges, result_is_hidden); -} + region = RegionFactory::create (current, plist); -Playlist * -Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden) -{ - Playlist *the_copy; - RegionList thawlist; - char buf[32]; + add_region_internal (region, end); + new_regions.push_back (region); - snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt); - string new_name = _name; - new_name += '.'; - new_name += buf; + /* "front" ***** */ - if ((the_copy = copyPlaylist (*this, start, cnt, new_name, result_is_hidden)) == 0) { - return 0; - } + current->suspend_property_changes (); + thawlist.push_back (current); + current->cut_end (pos2 - 1); - partition_internal (start, start+cnt-1, true, thawlist); - possibly_splice (); + } else if (overlap == OverlapEnd) { - for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { - (*i)->thaw ("playlist cut"); - } + /* + start end + ---------------*************************------------ + P1 P2 P4 P3 + SPLIT: + ---------------**************+++++++++++------------ + CUT: + ---------------**************----------------------- + */ - maybe_save_state (_("cut")); + if (!cutting) { - return the_copy; -} + /* end +++++ */ -Playlist * -Playlist::copy (jack_nframes_t start, jack_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; + RegionFactory::region_name (new_name, current->name(), false); - cnt = min (_get_maximum_extent() - start, cnt); - return copyPlaylist (*this, start, cnt, new_name, result_is_hidden); -} + PropertyList plist; -int -Playlist::paste (Playlist& other, jack_nframes_t position, float times) -{ - times = fabs (times); - jack_nframes_t old_length; + 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); - { - RegionLock rl1 (this); - RegionLock rl2 (&other); - - old_length = _get_maximum_extent(); - - int itimes = (int) floor (times); - jack_nframes_t pos = position; - jack_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) { - Region *copy_of_region = createRegion (**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; - } + region = RegionFactory::create (current, plist); - possibly_splice_unlocked (); + add_region_internal (region, start); + new_regions.push_back (region); + } - /* XXX shall we handle fractional cases at some point? */ + /* front ****** */ - if (old_length != _get_maximum_extent()) { - notify_length_changed (); - } + current->suspend_property_changes (); + thawlist.push_back (current); + current->cut_end (pos2 - 1); - - } + } else if (overlap == OverlapStart) { - maybe_save_state (_("paste")); + /* split: we need 2 regions: the front and the end. + cut: just trim current to skip the cut area + */ - return 0; -} + /* + start end + ---------------*************************------------ + P2 P1 P3 P4 + SPLIT: + ---------------****+++++++++++++++++++++------------ + CUT: + -------------------*********************------------ -void -Playlist::duplicate (Region& region, jack_nframes_t position, float times) -{ - times = fabs (times); + */ - RegionLock rl (this); - int itimes = (int) floor (times); - jack_nframes_t pos = position; + if (!cutting) { + /* front **** */ + RegionFactory::region_name (new_name, current->name(), false); - while (itimes--) { - Region *copy = createRegion (region); - add_region_internal (copy, pos, true); - pos += region.length(); - } + PropertyList plist; - if (floor (times) != times) { - jack_nframes_t length = (jack_nframes_t) floor (region.length() * (times - floor (times))); - string name; - _session.region_name (name, region.name(), false); - Region *sub = createRegion (region, 0, length, name, region.layer(), region.flags()); - add_region_internal (sub, pos, true); - } + 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); - maybe_save_state (_("duplicate")); -} + region = RegionFactory::create (current, plist); -void -Playlist::split_region (Region& region, jack_nframes_t playlist_position) -{ - RegionLock rl (this); + add_region_internal (region, pos1); + new_regions.push_back (region); + } - if (!region.covers (playlist_position)) { - return; - } + /* end */ - if (region.position() == playlist_position || - region.last_frame() == playlist_position) { - return; - } + current->suspend_property_changes (); + thawlist.push_back (current); + current->trim_front (pos3); + } else if (overlap == OverlapExternal) { - Region *left; - Region *right; - jack_nframes_t before; - jack_nframes_t after; - string before_name; - string after_name; + /* split: no split required. + cut: remove the region. + */ - before = playlist_position - region.position(); - after = region.length() - before; - - - _session.region_name (before_name, region.name(), false); - left = createRegion (region, 0, before, before_name, region.layer(), Region::Flag (region.flags()|Region::LeftOfSplit)); + /* + start end + ---------------*************************------------ + P2 P1 P3 P4 - _session.region_name (after_name, region.name(), false); - right = createRegion (region, before, after, after_name, region.layer(), Region::Flag (region.flags()|Region::RightOfSplit)); + SPLIT: + ---------------*************************------------ + CUT: + ---------------------------------------------------- - add_region_internal (left, region.position(), true); - 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++; + if (cutting) { + remove_region_internal (current); + } - finalize_split_region (®ion, left, right); - - if (remove_region_internal (®ion, true)) { - return; - } + new_regions.push_back (current); + } + } - maybe_save_state (_("split")); -} + in_partition = false; + } -void -Playlist::possibly_splice () -{ - if (_edit_mode == Splice) { - splice_locked (); - } -} + for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) { + check_dependents (*i, false); + } + } -void -Playlist::possibly_splice_unlocked () -{ - if (_edit_mode == Splice) { - splice_unlocked (); - } -} + boost::shared_ptr + 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; + framepos_t start; -void -Playlist::splice_locked () -{ - { - RegionLock rl (this); - core_splice (); - } + if (ranges.empty()) { + return boost::shared_ptr(); + } - notify_length_changed (); -} + start = ranges.front().start; -void -Playlist::splice_unlocked () -{ - core_splice (); - notify_length_changed (); -} + for (list::iterator i = ranges.begin(); i != ranges.end(); ++i) { + + pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden); -void -Playlist::core_splice () -{ - _splicing = true; - - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - - RegionList::iterator next; - - next = i; - ++next; - - if (next == regions.end()) { - break; - } - - (*next)->set_position ((*i)->last_frame() + 1, this); - } - - _splicing = false; -} + if (i == ranges.begin()) { + ret = pl; + } else { -void -Playlist::region_bounds_changed (Change what_changed, Region *region) -{ - if (in_set_state || _splicing || _nudging) { - return; - } + /* paste the next section into the nascent playlist, + offset to reflect the start of the first range we + chopped. + */ - if (what_changed & ARDOUR::PositionChanged) { + ret->paste (pl, (*i).start - start, 1.0f); + } + } - /* remove it from the list then add it back in - the right place again. - */ - - RegionSortByPosition cmp; + return ret; + } - 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; - return; - } + boost::shared_ptr + Playlist::cut (list& ranges, bool result_is_hidden) + { + boost::shared_ptr (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::cut; + return cut_copy (pmf, ranges, result_is_hidden); + } - regions.erase (i); - regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), - region); + boost::shared_ptr + Playlist::copy (list& ranges, bool result_is_hidden) + { + 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 (framepos_t start, framecnt_t cnt, bool result_is_hidden) + { + boost::shared_ptr the_copy; + RegionList thawlist; + char buf[32]; - if (what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) { - - if (holding_state ()) { - pending_bounds.push_back (region); - } else { - if (_session.get_layer_model() == Session::MoveAddHigher) { - /* it moved or changed length, so change the timestamp */ - timestamp_layer_op (*region); - } - - possibly_splice (); - check_dependents (*region, false); - notify_length_changed (); - relayer (); - } - } -} + snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt); + string new_name = _name; + new_name += '.'; + new_name += buf; -void -Playlist::region_changed_proxy (Change what_changed, Region* region) -{ - /* this makes a virtual call to the right kind of playlist ... */ + if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) { + return boost::shared_ptr(); + } - region_changed (what_changed, region); -} + partition_internal (start, start+cnt-1, true, thawlist); -bool -Playlist::region_changed (Change what_changed, Region* region) -{ - Change our_interests = Change (Region::MuteChanged|Region::LayerChanged|Region::OpacityChanged); - bool save = false; + for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) { + (*i)->resume_property_changes(); + } + + return the_copy; + } - if (in_set_state || in_flush) { - return false; - } + boost::shared_ptr + Playlist::copy (framepos_t start, framecnt_t cnt, bool result_is_hidden) + { + char buf[32]; - { - 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; - } - } + snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt); + string new_name = _name; + new_name += '.'; + new_name += buf; - return save; -} + 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, framepos_t position, float times) + { + times = fabs (times); + + { + RegionLock rl1 (this); + RegionLock rl2 (other.get()); + + framecnt_t const old_length = _get_extent().second; + + int itimes = (int) floor (times); + 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, true); + + /* put these new regions on top of all existing ones, but preserve + the ordering they had in the original playlist. + */ -void -Playlist::clear (bool with_delete, bool with_save) -{ - RegionList::iterator i; - RegionList tmp; + copy_of_region->set_layer (copy_of_region->layer() + top_layer); + add_region_internal (copy_of_region, (*i)->position() + pos); + } + pos += shift; + } + + + /* XXX shall we handle fractional cases at some point? */ + + if (old_length != _get_extent().second) { + notify_length_changed (); + } + + + } + + return 0; + } + + + void + Playlist::duplicate (boost::shared_ptr region, framepos_t position, float times) + { + times = fabs (times); + + RegionLock rl (this); + int itimes = (int) floor (times); + framepos_t pos = position + 1; + + while (itimes--) { + boost::shared_ptr copy = RegionFactory::create (region, true); + add_region_internal (copy, pos); + pos += region->length(); + } + + if (floor (times) != times) { + framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times))); + string name; + RegionFactory::region_name (name, region->name(), false); + + { + PropertyList plist; + + plist.add (Properties::start, region->start()); + plist.add (Properties::length, length); + plist.add (Properties::name, name); + + boost::shared_ptr sub = RegionFactory::create (region, plist); + add_region_internal (sub, pos); + } + } + } + + void + Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue) + { + RegionLock rlock (this); + RegionList copy (regions.rlist()); + 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)->position_lock_style() != AudioTime) { + fixup.push_back (*r); + continue; + } + + (*r)->set_position ((*r)->position() + distance); + } + + for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) { + (*r)->recompute_position_from_lock_style (); + } + } - { - RegionLock rl (this); - tmp = regions; - regions.clear (); - } - - for (i = tmp.begin(); i != tmp.end(); ++i) { - notify_region_removed (*i); - if (with_delete) { - delete *i; - } - } + void + Playlist::split (framepos_t at) + { + RegionLock rlock (this); + RegionList copy (regions.rlist()); + + /* use a copy since this operation can modify the region list + */ - if (with_save) { - maybe_save_state (_("clear")); - } -} + for (RegionList::iterator r = copy.begin(); r != copy.end(); ++r) { + _split_region (*r, at); + } + } -/*********************************************************************** - FINDING THINGS - **********************************************************************/ + void + 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, framepos_t playlist_position) + { + if (!region->covers (playlist_position)) { + return; + } + + if (region->position() == playlist_position || + region->last_frame() == playlist_position) { + return; + } + + boost::shared_ptr left; + boost::shared_ptr right; + 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; + + 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); + + 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); + + remove_region_internal (region); + + _splicing = old_sp; + } + + void + 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 */ + return; + } + + if (_edit_mode == Splice) { + splice_locked (at, distance, exclude); + } + } + + void + 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 */ + return; + } + + if (_edit_mode == Splice) { + splice_unlocked (at, distance, exclude); + } + } + + void + Playlist::splice_locked (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) + { + { + RegionLock rl (this); + core_splice (at, distance, exclude); + } + } + + void + Playlist::splice_unlocked (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) + { + core_splice (at, distance, exclude); + } + + void + Playlist::core_splice (framepos_t at, framecnt_t distance, boost::shared_ptr exclude) + { + _splicing = true; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + + if (exclude && (*i) == exclude) { + continue; + } + + if ((*i)->position() >= at) { + framepos_t new_pos = (*i)->position() + distance; + if (new_pos < 0) { + new_pos = 0; + } else if (new_pos >= max_framepos - (*i)->length()) { + new_pos = max_framepos - (*i)->length(); + } + + (*i)->set_position (new_pos); + } + } + + _splicing = false; + + notify_length_changed (); + } + + void + Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr region) + { + if (in_set_state || _splicing || _nudging || _shuffling) { + return; + } + + 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()) { + /* 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; + } + + regions.erase (i); + regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region); + } + + 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); + } + + if (holding_state ()) { + pending_bounds.push_back (region); + } else { + 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); + } + } + } + + void + Playlist::region_changed_proxy (const PropertyChange& 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); + } + + bool + Playlist::region_changed (const PropertyChange& what_changed, boost::shared_ptr region) + { + PropertyChange our_interests; + PropertyChange bounds; + PropertyChange pos_and_length; + bool save = false; + + if (in_set_state || in_flush) { + return false; + } + + 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.contains (our_interests) && !what_changed.contains (pos_and_length)) { + check_dependents (region, false); + } + + 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); + } + + /* 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; + } + + return save; + } + + void + Playlist::drop_regions () + { + RegionLock rl (this); + regions.clear (); + 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); + + region_state_changed_connections.drop_connections (); + + 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_contents_change = false; + ContentsChanged (); + } -Playlist::RegionList * -Playlist::regions_at (jack_nframes_t frame) + } -{ - RegionLock rlock (this); - return find_regions_at (frame); -} + /*********************************************************************** + FINDING THINGS + **********************************************************************/ -Region * -Playlist::top_region_at (jack_nframes_t frame) + Playlist::RegionList * + Playlist::regions_at (framepos_t frame) -{ - RegionLock rlock (this); - RegionList *rlist = find_regions_at (frame); - Region *region = 0; + { + 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 (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(); ) { - if (rlist->size()) { - RegionSortByLayer cmp; - rlist->sort (cmp); - region = rlist->back(); - } + RegionList::iterator tmp = i; + ++tmp; - delete rlist; - return region; -} + if ((*i)->muted()) { + rlist->erase (i); + } -Playlist::RegionList * -Playlist::find_regions_at (jack_nframes_t frame) -{ - RegionList *rlist = new RegionList; + i = tmp; + } - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->covers (frame)) { - rlist->push_back (*i); - } - } + boost::shared_ptr region; - return rlist; -} + if (rlist->size()) { + RegionSortByLayer cmp; + rlist->sort (cmp); + region = rlist->back(); + } -Playlist::RegionList * -Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end) -{ - RegionLock rlock (this); - RegionList *rlist = new RegionList; + delete rlist; + return region; + } - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - if ((*i)->coverage (start, end) != OverlapNone) { - rlist->push_back (*i); - } - } + Playlist::RegionList* + Playlist::regions_to_read (framepos_t start, framepos_t end) + { + /* Caller must hold lock */ - return rlist; -} + RegionList covering; + set to_check; + set > unique; + to_check.insert (start); + to_check.insert (end); -Region* + DEBUG_TRACE (DEBUG::AudioPlayback, ">>>>> REGIONS TO READ\n"); -Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir) -{ - RegionLock rlock (this); - Region* ret = 0; - jack_nframes_t closest = max_frames; + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { - for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + /* find all/any regions that span start+end */ - jack_nframes_t distance; - Region* r = (*i); - jack_nframes_t pos = 0; + switch ((*i)->coverage (start, end)) { + case OverlapNone: + break; - switch (point) { - case Start: - pos = r->first_frame (); - break; - case End: - pos = r->last_frame (); - break; - case SyncPoint: - pos = r->adjust_to_sync (r->first_frame()); - break; - } + case OverlapInternal: + covering.push_back (*i); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("toread: will cover %1 (OInternal)\n", (*i)->name())); + break; - switch (dir) { - case 1: /* forwards */ + 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; - if (pos > frame) { - if ((distance = pos - frame) < closest) { - closest = distance; - ret = r; - } - } + 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; - 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; + } - default: /* backwards */ + /* don't go too far */ - if (pos < frame) { - if ((distance = frame - pos) < closest) { - closest = distance; - ret = r; - } - } - break; - } - } + if ((*i)->position() > end) { + break; + } + } - return ret; -} + RegionList* rlist = new RegionList; -/***********************************************************************/ + /* find all the regions that cover each position .... */ + if (covering.size() == 1) { + rlist->push_back (covering.front()); + DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("Just one covering region (%1)\n", covering.front()->name())); -void -Playlist::mark_session_dirty () -{ - if (!in_set_state && !holding_state ()) { - _session.set_dirty(); - } -} + } else { -int -Playlist::set_state (const XMLNode& node) -{ - in_set_state = true; + 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))); + } + + } - XMLNode *child; - XMLNodeList nlist; - XMLNodeConstIterator niter; - XMLPropertyList plist; - XMLPropertyConstIterator piter; - XMLProperty *prop; - Region *region; - string region_name; + RegionSortByLayer cmp; + here.sort (cmp); - clear (false, false); + /* ... and get the top/transparent regions at "here" */ - if (node.name() != "Playlist") { - in_set_state = false; - return -1; - } + for (RegionList::reverse_iterator c = here.rbegin(); c != here.rend(); ++c) { + + unique.insert (*c); - plist = node.properties(); + 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 (framepos_t frame) + { + /* Caller must hold lock */ + + RegionList *rlist = new RegionList; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->covers (frame)) { + rlist->push_back (*i); + } + } + + return rlist; + } + + Playlist::RegionList * + Playlist::regions_touched (framepos_t start, framepos_t end) + { + RegionLock rlock (this); + RegionList *rlist = new RegionList; - for (piter = plist.begin(); piter != plist.end(); ++piter) { + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->coverage (start, end) != OverlapNone) { + rlist->push_back (*i); + } + } + + return rlist; + } - 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")); - } - } + framepos_t + Playlist::find_next_transient (framepos_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 (framepos_t frame, RegionPoint point, int dir) + { + RegionLock rlock (this); + boost::shared_ptr ret; + framepos_t closest = max_framepos; + + bool end_iter = false; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + + if(end_iter) break; + + frameoffset_t distance; + boost::shared_ptr r = (*i); + framepos_t pos = 0; + + switch (point) { + case Start: + pos = r->first_frame (); + break; + case End: + pos = r->last_frame (); + break; + case SyncPoint: + pos = r->sync_position (); + break; + } + + switch (dir) { + case 1: /* forwards */ - nlist = node.children(); + if (pos > frame) { + if ((distance = pos - frame) < closest) { + closest = distance; + ret = r; + end_iter = true; + } + } - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + break; - child = *niter; - - if (child->name() == "Region") { + default: /* backwards */ - if ((region = createRegion (_session, *child, true)) == 0) { - error << _("Playlist: cannot create region from state file") << endmsg; - continue; - } + if (pos < frame) { + if ((distance = frame - pos) < closest) { + closest = distance; + ret = r; + } + } + else { + end_iter = true; + } + + break; + } + } + + return ret; + } + + framepos_t + Playlist::find_next_region_boundary (framepos_t frame, int dir) + { + RegionLock rlock (this); + + 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); + frameoffset_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); + frameoffset_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 () + { + if (!in_set_state && !holding_state ()) { + _session.set_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 (); + } + + int + Playlist::set_state (const XMLNode& node, int version) + { + XMLNode *child; + XMLNodeList nlist; + XMLNodeConstIterator niter; + XMLPropertyList plist; + XMLPropertyConstIterator piter; + XMLProperty *prop; + boost::shared_ptr region; + string region_name; + bool seen_region_nodes = false; + int ret = 0; + + in_set_state++; + + if (node.name() != "Playlist") { + in_set_state--; + return -1; + } + + freeze (); + + plist = node.properties(); + + set_id (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_("orig-diskstream-id")) { + _orig_diskstream_id = prop->value (); + } else if (prop->name() == X_("frozen")) { + _frozen = string_is_affirmative (prop->value()); + } else if (prop->name() == X_("combine-ops")) { + _combine_ops = atoi (prop->value()); + } + } + + clear (true); + + nlist = node.children(); + + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + + child = *niter; + + if (child->name() == "Region") { + + seen_region_nodes = true; - add_region (*region, region->position(), 1.0, false); + 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))) { + + region->suspend_property_changes (); + + if (region->set_state (*child, version)) { + region->resume_property_changes (); + continue; + } + + } else if ((region = RegionFactory::create (_session, *child, true)) != 0) { + region->suspend_property_changes (); + } else { + error << _("Playlist: cannot create region from XML") << endmsg; + return -1; + } + 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 (); - } + } } - - /* update dependents, which was not done during add_region_internal - due to in_set_state being true - */ + if (seen_region_nodes && regions.empty()) { + ret = -1; + } else { - for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) { - check_dependents (**r, false); + /* 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; + + thaw (); + notify_contents_changed (); - return 0; + in_set_state--; + first_set_state = false; + return ret; } 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()); - _orig_diskstream_id.print (buf); - node->add_property (X_("orig_diskstream_id"), 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); + snprintf (buf, sizeof (buf), "%u", _combine_ops); + node->add_property ("combine-ops", buf); + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { node->add_child_nocopy ((*i)->get_state()); } @@ -1449,66 +2343,59 @@ Playlist::state (bool full_state) bool Playlist::empty() const { + RegionLock rlock (const_cast(this), false); return regions.empty(); } -jack_nframes_t -Playlist::get_maximum_extent () const +uint32_t +Playlist::n_regions() const +{ + RegionLock rlock (const_cast(this), false); + return regions.size(); +} + +pair +Playlist::get_extent () const { - RegionLock rlock (const_cast(this)); - return _get_maximum_extent (); + RegionLock rlock (const_cast(this), false); + return _get_extent (); } -jack_nframes_t -Playlist::_get_maximum_extent () const +pair +Playlist::_get_extent () const { - RegionList::const_iterator i; - jack_nframes_t max_extent = 0; - jack_nframes_t end = 0; + pair ext (max_framepos, 0); + + if (regions.empty()) { + ext.first = 0; + return ext; + } - 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 = Playlist::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; } -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 @@ -1535,124 +2422,232 @@ 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. - */ + /* never compute layers when changing state for undo/redo or setting from XML */ - freeze (); - - if (_session.get_layer_model() == Session::MoveAddHigher || - _session.get_layer_model() == Session::AddHigher) { - - RegionSortByLastLayerOp cmp; - RegionList copy = regions; + if (in_update || in_set_state) { + return; + } - copy.sort (cmp); + bool changed = false; - for (i = copy.begin(); i != copy.end(); ++i) { - (*i)->set_layer (layer++); - } + /* 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 */ - } else { - - /* Session::LaterHigher model */ + /* how many pieces to divide this playlist's time up into */ + int const divisions = 512; - for (i = regions.begin(); i != regions.end(); ++i) { - (*i)->set_layer (layer++); - } + /* 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()); } - /* sending Modified means that various kinds of layering - models operate correctly at the GUI - level. slightly inefficient, but only slightly. + /* hence the size of each time division */ + double const division_size = (end - start) / double (divisions); + + vector > layers; + layers.push_back (vector (divisions)); - We force a Modified signal here in case no layers actually - changed. + /* we want to go through regions from desired lowest to desired highest layer, + which depends on the layer model */ - notify_modified (); + RegionList copy = regions.rlist(); - thaw (); -} + /* sort according to the model and the layering mode that we're in */ -/* XXX these layer functions are all deprecated */ + if (_explicit_relayering) { -void -Playlist::raise_region (Region& region) -{ - uint32_t rsz = regions.size(); - layer_t target = region.layer() + 1U; + copy.sort (RegionSortByLayerWithPending ()); - if (target >= rsz) { - /* its already at the effective top */ - return; - } + } else if (_session.config.get_layer_model() == MoveAddHigher || _session.config.get_layer_model() == AddHigher) { - move_region_to_layer (target, region, 1); -} + copy.sort (RegionSortByLastLayerOp ()); -void -Playlist::lower_region (Region& region) -{ - if (region.layer() == 0) { - /* its already at the bottom */ - return; } - layer_t target = region.layer() - 1U; - move_region_to_layer (target, region, -1); -} + 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 + */ + + 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); + } + + if ((*i)->layer() != j) { + changed = true; + } + + (*i)->set_layer (j); + } + + if (changed) { + notify_layering_changed (); + } +} + +/* XXX these layer functions are all deprecated */ void -Playlist::raise_region_to_top (Region& region) +Playlist::raise_region (boost::shared_ptr region) +{ + uint32_t top = regions.size() - 1; + layer_t target = region->layer() + 1U; + + if (target >= top) { + /* its already at the effective top */ + return; + } + + move_region_to_layer (target, region, 1); +} + +void +Playlist::lower_region (boost::shared_ptr region) +{ + if (region->layer() == 0) { + /* its already at the bottom */ + return; + } + + layer_t target = region->layer() - 1U; + + move_region_to_layer (target, region, -1); +} + +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)) { - 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 (Region& region) +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)) { - 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 -Playlist::move_region_to_layer (layer_t target_layer, Region& region, int dir) +Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr region, int dir) { RegionList::iterator i; - typedef pair LayerInfo; + typedef pair,layer_t> LayerInfo; list layerinfo; - layer_t dest; { RegionLock rlock (const_cast (this)); - + for (i = regions.begin(); i != regions.end(); ++i) { - - if (®ion == *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) { + + if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) { dest = (*i)->layer() - 1; } else { /* not affected */ @@ -1664,7 +2659,7 @@ Playlist::move_region_to_layer (layer_t target_layer, Region& region, int dir) up 1 */ - if ((*i)->layer() < region.layer() && (*i)->layer() >= target_layer) { + if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) { dest = (*i)->layer() + 1; } else { /* not affected */ @@ -1673,59 +2668,65 @@ Playlist::move_region_to_layer (layer_t target_layer, Region& region, int dir) } 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) { x->first->set_layer (x->second); } - region.set_layer (target_layer); + region->set_layer (target_layer); - /* 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 (x->first, false); } - + check_dependents (region, false); - + notify_layering_changed (); + + thaw (); + return 0; } void -Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards) +Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards) { RegionList::iterator i; - jack_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 { @@ -1733,7 +2734,7 @@ Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwa } } - (*i)->set_position (new_pos, this); + (*i)->set_position (new_pos); moved = true; } } @@ -1741,39 +2742,73 @@ Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwa if (moved) { _nudging = false; - maybe_save_state (_("nudged")); notify_length_changed (); } } -Region* +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 { RegionLock rlock (const_cast (this)); - RegionList::const_iterator i; - - 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) { - return (*i); + return *i; } } - return 0; + return boost::shared_ptr (); } - -void -Playlist::save_state (std::string why) + +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 (const ID& id) const { - 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 Playlist::dump () const { - Region *r; + boost::shared_ptr r; cerr << "Playlist \"" << _name << "\" " << endl << regions.size() << " regions " @@ -1781,9 +2816,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 () @@ -1798,20 +2833,557 @@ Playlist::set_frozen (bool yn) } void -Playlist::timestamp_layer_op (Region& region) +Playlist::timestamp_layer_op (boost::shared_ptr region) { -// struct timeval tv; -// gettimeofday (&tv, 0); - region.set_last_layer_op (++layer_op_counter); + 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; + + 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; + } + + 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. + */ + 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()); + region->set_position (new_pos); + + /* 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; + } + + 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. + */ + 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()); + (*prev)->set_position (new_pos); + + /* 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_contents_changed(); + } + +} + +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.rlist()); + + freeze (); + + 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; +} + +boost::shared_ptr +Playlist::combine (const RegionList& r) +{ + PropertyList plist; + uint32_t channels = 0; + uint32_t layer = 0; + framepos_t earliest_position = max_framepos; + vector old_and_new_regions; + vector > originals; + vector > copies; + string parent_name; + string child_name; + uint32_t max_level = 0; + + /* find the maximum depth of all the regions we're combining */ + + for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + max_level = max (max_level, (*i)->max_source_level()); + } + + parent_name = RegionFactory::compound_region_name (name(), combine_ops(), max_level, true); + child_name = RegionFactory::compound_region_name (name(), combine_ops(), max_level, false); + + boost::shared_ptr pl = PlaylistFactory::create (_type, _session, parent_name, true); + + for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + earliest_position = min (earliest_position, (*i)->position()); + } + + /* 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)); + originals.push_back (original_region); + copies.push_back (copied_region); + + RegionFactory::add_compound_association (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; + + pre_combine (copies); + + /* add any dependent regions to the new playlist */ + + copy_dependents (old_and_new_regions, pl.get()); + + /* 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, id(), parent_name, chn, 0, extent.second, false, false)); + + } + + /* now a new whole-file region using the list of sources */ + + plist.add (Properties::start, 0); + plist.add (Properties::length, extent.second); + plist.add (Properties::name, parent_name); + plist.add (Properties::whole_file, true); + + boost::shared_ptr parent_region = RegionFactory::create (sources, plist, true); + + /* now the non-whole-file region that we will actually use in the + * playlist + */ + + plist.clear (); + plist.add (Properties::start, 0); + plist.add (Properties::length, extent.second); + plist.add (Properties::name, child_name); + plist.add (Properties::layer, layer+1); + + boost::shared_ptr compound_region = RegionFactory::create (parent_region, plist, true); + + /* remove all the selected regions from the current playlist + */ + + freeze (); + + for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) { + remove_region (*i); + } + + /* do type-specific stuff with the originals and the new compound + region + */ + + post_combine (originals, compound_region); + + /* add the new region at the right location */ + + add_region (compound_region, earliest_position); + + _combine_ops++; + + thaw (); + + return compound_region; +} + +void +Playlist::uncombine (boost::shared_ptr target) +{ + boost::shared_ptr pls; + boost::shared_ptr pl; + vector > originals; + vector old_and_new_regions; + + // (1) check that its really a compound region + + if ((pls = boost::dynamic_pointer_cast(target->source (0))) == 0) { + return; } + + pl = pls->playlist(); + + framepos_t adjusted_start = 0; // gcc isn't smart enough + framepos_t adjusted_end = 0; // gcc isn't smart enough + + /* the leftmost (earliest) edge of the compound region + starts at zero in its source, or larger if it + has been trimmed or content-scrolled. + + the rightmost (latest) edge of the compound region + relative to its source is the starting point plus + the length of the region. + */ + + // (2) get all the original regions + + const RegionList& rl (pl->region_list().rlist()); + RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations()); + frameoffset_t move_offset = 0; + + /* there are two possibilities here: + 1) the playlist that the playlist source was based on + is us, so just add the originals (which belonged to + us anyway) back in the right place. + + 2) the playlist that the playlist source was based on + is NOT us, so we need to make copies of each of + the original regions that we find, and add them + instead. + */ + bool same_playlist = (pls->original() == id()); + + for (RegionList::const_iterator i = rl.begin(); i != rl.end(); ++i) { + + boost::shared_ptr current (*i); + + RegionFactory::CompoundAssociations::iterator ca = cassocs.find (*i); + + if (ca == cassocs.end()) { + continue; + } + + boost::shared_ptr original (ca->second); + bool modified_region; + + if (i == rl.begin()) { + move_offset = (target->position() - original->position()) - target->start(); + adjusted_start = original->position() + target->start(); + adjusted_end = adjusted_start + target->length(); + } + + if (!same_playlist) { + framepos_t pos = original->position(); + /* make a copy, but don't announce it */ + original = RegionFactory::create (original, false); + /* the pure copy constructor resets position() to zero, + so fix that up. + */ + original->set_position (pos); + } + + /* check to see how the original region (in the + * playlist before compounding occured) overlaps + * with the new state of the compound region. + */ + + original->clear_changes (); + modified_region = false; + + switch (original->coverage (adjusted_start, adjusted_end)) { + case OverlapNone: + /* original region does not cover any part + of the current state of the compound region + */ + continue; + + case OverlapInternal: + /* overlap is just a small piece inside the + * original so trim both ends + */ + original->trim_to (adjusted_start, adjusted_end - adjusted_start); + modified_region = true; + break; + + case OverlapExternal: + /* overlap fully covers original, so leave it + as is + */ + break; + + case OverlapEnd: + /* overlap starts within but covers end, + so trim the front of the region + */ + original->trim_front (adjusted_start); + modified_region = true; + break; + + case OverlapStart: + /* overlap covers start but ends within, so + * trim the end of the region. + */ + original->trim_end (adjusted_end); + modified_region = true; + break; + } + + if (move_offset) { + /* fix the position to match any movement of the compound region. + */ + original->set_position (original->position() + move_offset); + modified_region = true; + } + + if (modified_region) { + _session.add_command (new StatefulDiffCommand (original)); + } + + /* and add to the list of regions waiting to be + * re-inserted + */ + + originals.push_back (original); + old_and_new_regions.push_back (TwoRegions (*i, original)); + } + + pre_uncombine (originals, target); + + in_partition = true; + freeze (); + + // (3) remove the compound region + + remove_region (target); + + // (4) add the constituent regions + + for (vector >::iterator i = originals.begin(); i != originals.end(); ++i) { + add_region ((*i), (*i)->position()); + } + + /* now move dependent regions back from the compound to this playlist */ + + pl->copy_dependents (old_and_new_regions, this); + + in_partition = false; + 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; }