X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=239622a38c3252e3242dcd9e2ddbd37ff81f5edb;hb=fa73112f081ee38bc5c9752f900c9c5dccb68141;hp=390f9fdaaddc0a879dd3fbe4b4eae9f57143994f;hpb=6fa6514cfdb0ce38d93b51197f599dfd091bad1d;p=ardour.git

diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 390f9fdaad..239622a38c 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -47,9 +47,9 @@ using namespace ARDOUR;
 using namespace PBD;
 
 namespace ARDOUR {
-namespace Properties {
-PBD::PropertyDescriptor<bool> regions;
-}
+	namespace Properties {
+		PBD::PropertyDescriptor<bool> regions;
+	}
 }
 
 struct ShowMeTheList {
@@ -172,6 +172,7 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, boo
 	in_set_state--;
 
 	_splicing  = other->_splicing;
+	_rippling  = other->_rippling;
 	_nudging   = other->_nudging;
 	_edit_mode = other->_edit_mode;
 
@@ -250,11 +251,15 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, f
 		plist.add (Properties::layer, region->layer());
 		plist.add (Properties::layering_index, region->layering_index());
 
-		new_region = RegionFactory::RegionFactory::create (region, plist);
+		new_region = RegionFactory::create (region, plist);
 
 		add_region_internal (new_region, position);
 	}
 
+	//keep track of any dead space at end (for pasting into Ripple or Splice mode)
+	//at the end of construction, any length of cnt beyond the extents of the regions is end_space
+	_end_space = cnt - (get_extent().second - get_extent().first);
+
 	in_set_state--;
 	first_set_state = false;
 }
@@ -284,7 +289,7 @@ Playlist::copy_regions (RegionList& newlist) const
 	RegionReadLock rlock (const_cast<Playlist *> (this));
 
 	for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
-		newlist.push_back (RegionFactory::RegionFactory::create (*i, true));
+		newlist.push_back (RegionFactory::create (*i, true));
 	}
 }
 
@@ -302,6 +307,7 @@ Playlist::init (bool hide)
 	_refcnt = 0;
 	_hidden = hide;
 	_splicing = false;
+	_rippling = false;
 	_shuffling = false;
 	_nudging = false;
 	in_set_state = 0;
@@ -311,7 +317,9 @@ Playlist::init (bool hide)
 	in_partition = false;
 	subcnt = 0;
 	_frozen = false;
+	_capture_insertion_underway = false;
 	_combine_ops = 0;
+	_end_space = 0;
 
 	_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));
@@ -549,6 +557,7 @@ Playlist::notify_region_added (boost::shared_ptr<Region> r)
 		pending_contents_change = false;
 		RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
 		ContentsChanged (); /* EMIT SIGNAL */
+
 	}
 }
 
@@ -594,7 +603,7 @@ Playlist::flush_notifications (bool from_undo)
 		remove_dependents (*s);
 		RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
 	}
-	
+
 	for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
 		crossfade_ranges.push_back ((*s)->range ());
 		/* don't emit RegionAdded signal until relayering is done,
@@ -603,37 +612,41 @@ Playlist::flush_notifications (bool from_undo)
 		*/
 	}
 
-	if (((regions_changed || pending_contents_change) && !in_set_state) || pending_layering) {
-		relayer ();
+	/* notify about contents/region changes first so that layering changes
+	 * in a UI will take place on the new contents.
+	 */
+
+	if (regions_changed || pending_contents_change) {
+		pending_layering = true;
+		ContentsChanged (); /* EMIT SIGNAL */
 	}
 
-	 if (regions_changed || pending_contents_change) {
-		 pending_contents_change = false;
-		 ContentsChanged (); /* EMIT SIGNAL */
-	 }
+	for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+		(*s)->clear_changes ();
+		RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+	}
 
-	 for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
-		 (*s)->clear_changes ();
-		 RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
-	 }
+	if ((regions_changed && !in_set_state) || pending_layering) {
+		relayer ();
+	}
 
-	 coalesce_and_check_crossfades (crossfade_ranges);
+	coalesce_and_check_crossfades (crossfade_ranges);
 
-	 if (!pending_range_moves.empty ()) {
-		 /* We don't need to check crossfades for these as pending_bounds has
-		    already covered it.
-		 */
-		 RangesMoved (pending_range_moves, from_undo);
-	 }
+	if (!pending_range_moves.empty ()) {
+		/* We don't need to check crossfades for these as pending_bounds has
+		   already covered it.
+		*/
+		RangesMoved (pending_range_moves, from_undo);
+	}
 
-	 if (!pending_region_extensions.empty ()) {
-		 RegionsExtended (pending_region_extensions);
-	 }
+	if (!pending_region_extensions.empty ()) {
+		RegionsExtended (pending_region_extensions);
+	}
 
-	 clear_pending ();
+	clear_pending ();
 
-	 in_flush = false;
- }
+	in_flush = false;
+}
 
  void
  Playlist::clear_pending ()
@@ -705,7 +718,7 @@ Playlist::flush_notifications (bool from_undo)
 		 }
 	 }
 
-	 possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
+	 possibly_splice_unlocked (position, (pos + length) - position, region);
  }
 
  void
@@ -750,10 +763,6 @@ Playlist::flush_notifications (bool from_undo)
 
 	 notify_region_added (region);
 
-	 if (!holding_state ()) {
-		 check_crossfades (region->range ());
-	 }
-
 	 region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
 
 	 return true;
@@ -847,6 +856,17 @@ Playlist::flush_notifications (bool from_undo)
 	 }
  }
 
+ void
+ Playlist::get_source_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+ {
+	 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+		 if ((*i) && (*i)->any_source_equivalent (other)) {
+			 results.push_back (*i);
+		 }
+	 }
+ }
+
  void
  Playlist::partition (framepos_t start, framepos_t end, bool cut)
  {
@@ -1095,7 +1115,9 @@ Playlist::flush_notifications (bool from_undo)
 		 in_partition = false;
 	 }
 
-	 check_crossfades (Evoral::Range<framepos_t> (start, end));
+	//keep track of any dead space at end (for pasting into Ripple or Splice mode)
+	framepos_t wanted_length = end-start;
+	_end_space = wanted_length - get_extent().second-get_extent().first;
  }
 
  boost::shared_ptr<Playlist>
@@ -1180,7 +1202,8 @@ Playlist::flush_notifications (bool from_undo)
 	 new_name += '.';
 	 new_name += buf;
 
-	 cnt = min (_get_extent().second - start, cnt);
+	// cnt = min (_get_extent().second - start, cnt);  (We need the full range length when copy/pasting in Ripple.  Why was this limit here?  It's not in CUT... )
+
 	 return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
  }
 
@@ -1202,11 +1225,11 @@ Playlist::flush_notifications (bool from_undo)
 			 while (itimes--) {
 				 for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
 					 boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
-					 
+
 					 /* put these new regions on top of all existing ones, but preserve
 					    the ordering they had in the original playlist.
 					 */
-					 
+
 					 add_region_internal (copy_of_region, (*i)->position() + pos);
 					 set_layer (copy_of_region, copy_of_region->layer() + top);
 				 }
@@ -1221,18 +1244,24 @@ Playlist::flush_notifications (bool from_undo)
 
  void
  Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
+ {
+	 duplicate(region, position, region->length(), times);
+ }
+
+/** @param gap from the beginning of the region to the next beginning */
+ void
+ Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, float times)
  {
 	 times = fabs (times);
 
 	 RegionWriteLock rl (this);
 	 int itimes = (int) floor (times);
-	 framepos_t pos = position + 1;
 
 	 while (itimes--) {
 		 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
-		 add_region_internal (copy, pos);
+		 add_region_internal (copy, position);
 		 set_layer (copy, DBL_MAX);
-		 pos += region->length();
+		 position += gap;
 	 }
 
 	 if (floor (times) != times) {
@@ -1248,12 +1277,78 @@ Playlist::flush_notifications (bool from_undo)
 			 plist.add (Properties::name, name);
 
 			 boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
-			 add_region_internal (sub, pos);
+			 add_region_internal (sub, position);
 			 set_layer (sub, DBL_MAX);
 		 }
 	 }
  }
 
+/** @param gap from the beginning of the region to the next beginning */
+/** @param end the first frame that does _not_ contain a duplicated frame */
+void
+Playlist::duplicate_until (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, framepos_t end)
+{
+	 RegionWriteLock rl (this);
+
+	 while (position + region->length() - 1 < end) {
+		 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+		 add_region_internal (copy, position);
+		 set_layer (copy, DBL_MAX);
+		 position += gap;
+	 }
+
+	 if (position < end) {
+		 framecnt_t length = min (region->length(), end - position);
+		 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<Region> sub = RegionFactory::create (region, plist);
+			 add_region_internal (sub, position);
+			 set_layer (sub, DBL_MAX);
+		 }
+	 }
+}
+
+void
+Playlist::duplicate_range (AudioRange& range, float times)
+{
+	boost::shared_ptr<Playlist> pl = copy (range.start, range.length(), true);
+	framecnt_t offset = range.end - range.start;
+	paste (pl, range.start + offset, times);
+}
+
+void
+Playlist::duplicate_ranges (std::list<AudioRange>& ranges, float /* times */)
+{
+	if (ranges.empty()) {
+		return;
+	}
+
+	framepos_t min_pos = max_framepos;
+	framepos_t max_pos = 0;
+
+	for (std::list<AudioRange>::const_iterator i = ranges.begin();
+	     i != ranges.end();
+	     ++i) {
+		min_pos = min (min_pos, (*i).start);
+		max_pos = max (max_pos, (*i).end);
+	}
+
+	framecnt_t offset = max_pos - min_pos;
+
+	for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+		boost::shared_ptr<Playlist> pl = copy ((*i).start, (*i).length(), true);
+		paste (pl, (*i).start + offset, 1.0f); // times ??
+	}
+}
+
  void
  Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
  {
@@ -1346,7 +1441,6 @@ Playlist::flush_notifications (bool from_undo)
 	 {
 		 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);
@@ -1365,7 +1459,6 @@ Playlist::flush_notifications (bool from_undo)
 	 {
 		 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);
@@ -1450,12 +1543,63 @@ Playlist::flush_notifications (bool from_undo)
 	 _splicing = false;
 
 	 notify_contents_changed ();
- }
+}
 
- void
- Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
- {
-	 if (in_set_state || _splicing || _nudging || _shuffling) {
+void
+Playlist::ripple_locked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+	{
+		RegionWriteLock rl (this);
+		core_ripple (at, distance, exclude);
+	}
+}
+
+void
+Playlist::ripple_unlocked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+	core_ripple (at, distance, exclude);
+}
+
+void
+Playlist::core_ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+	if (distance == 0) {
+		return;
+	}
+
+	_rippling = true;
+	RegionListProperty copy = regions;
+	for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+		assert (i != copy.end());
+
+		if (exclude) {
+			if (std::find(exclude->begin(), exclude->end(), (*i)) != exclude->end()) {
+				continue;
+			}
+		}
+
+		if ((*i)->position() >= at) {
+			framepos_t new_pos = (*i)->position() + distance;
+			framepos_t limit = max_framepos - (*i)->length();
+			if (new_pos < 0) {
+				new_pos = 0;
+			} else if (new_pos >= limit ) {
+				new_pos = limit;
+			}
+
+			(*i)->set_position (new_pos);
+		}
+	}
+
+	_rippling = false;
+	notify_contents_changed ();
+}
+
+
+void
+Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
+{
+	 if (in_set_state || _splicing || _rippling || _nudging || _shuffling) {
 		 return;
 	 }
 
@@ -1552,10 +1696,6 @@ Playlist::flush_notifications (bool from_undo)
 		 save = !(_splicing || _nudging);
 	 }
 
-	 if (what_changed.contains (our_interests) && !what_changed.contains (pos_and_length)) {
-		 check_crossfades (region->range ());
-	 }
-
 	 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)) {
@@ -1572,6 +1712,8 @@ Playlist::flush_notifications (bool from_undo)
 		 save = true;
 	 }
 
+	 mark_session_dirty ();
+
 	 return save;
  }
 
@@ -1627,7 +1769,7 @@ Playlist::flush_notifications (bool from_undo)
 
  }
 
- /***********************************************************************
+ /* *********************************************************************
   FINDING THINGS
   **********************************************************************/
 
@@ -1704,15 +1846,15 @@ boost::shared_ptr<RegionList>
 Playlist::find_regions_at (framepos_t frame)
 {
 	/* Caller must hold lock */
-	
+
 	boost::shared_ptr<RegionList> rlist (new RegionList);
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		if ((*i)->covers (frame)) {
 			rlist->push_back (*i);
 		}
 	}
-	
+
 	return rlist;
 }
 
@@ -1761,13 +1903,13 @@ boost::shared_ptr<RegionList>
 Playlist::regions_touched_locked (framepos_t start, framepos_t end)
 {
 	boost::shared_ptr<RegionList> rlist (new RegionList);
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		if ((*i)->coverage (start, end) != Evoral::OverlapNone) {
 			rlist->push_back (*i);
 		}
 	}
-	
+
 	return rlist;
 }
 
@@ -1777,7 +1919,7 @@ Playlist::find_next_transient (framepos_t from, int dir)
 	RegionReadLock 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) {
@@ -1788,30 +1930,30 @@ Playlist::find_next_transient (framepos_t from, int dir)
 				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;
 			}
@@ -1821,13 +1963,13 @@ Playlist::find_next_transient (framepos_t from, int dir)
 			if ((*x) <= from) {
 				reached = true;
 			}
-			
+
 			if (reached && (*x) < from) {
 				return *x;
 			}
 		}
 	}
-	
+
 	return -1;
 }
 
@@ -1837,17 +1979,17 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 	RegionReadLock rlock (this);
 	boost::shared_ptr<Region> 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<Region> r = (*i);
 		framepos_t pos = 0;
-		
+
 		switch (point) {
 		case Start:
 			pos = r->first_frame ();
@@ -1859,10 +2001,10 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			pos = r->sync_position ();
 			break;
 		}
-		
+
 		switch (dir) {
 		case 1: /* forwards */
-			
+
 			if (pos > frame) {
 				if ((distance = pos - frame) < closest) {
 					closest = distance;
@@ -1870,11 +2012,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 					end_iter = true;
 				}
 			}
-			
+
 			break;
-			
+
 		default: /* backwards */
-			
+
 			if (pos < frame) {
 				if ((distance = frame - pos) < closest) {
 					closest = distance;
@@ -1883,11 +2025,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			} else {
 				end_iter = true;
 			}
-			
+
 			break;
 		}
 	}
-	
+
 	return ret;
 }
 
@@ -1995,11 +2137,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 
 	 freeze ();
 	 /* add the added regions */
-	 for (RegionListProperty::ChangeContainer::iterator i = change.added.begin(); i != change.added.end(); ++i) {
+	 for (RegionListProperty::ChangeContainer::const_iterator i = change.added.begin(); i != change.added.end(); ++i) {
 		 add_region_internal ((*i), (*i)->position());
 	 }
 	 /* remove the removed regions */
-	 for (RegionListProperty::ChangeContainer::iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
+	 for (RegionListProperty::ChangeContainer::const_iterator i = change.removed.begin(); i != change.removed.end(); ++i) {
 		 remove_region (*i);
 	 }
 
@@ -2091,7 +2233,7 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 				 RegionWriteLock rlock (this);
 				 add_region_internal (region, region->position());
 			 }
-			
+
 			region->resume_property_changes ();
 
 		}
@@ -2099,17 +2241,8 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 
 	if (seen_region_nodes && regions.empty()) {
 		ret = -1;
-	} else {
-
-		/* 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_crossfades ((*r)->range ());
-		}
 	}
-		
+
 	thaw ();
 	notify_contents_changed ();
 
@@ -2179,6 +2312,16 @@ Playlist::n_regions() const
 	return regions.size();
 }
 
+/** @return true if the all_regions list is empty, ie this playlist
+ *  has never had a region added to it.
+ */
+bool
+Playlist::all_regions_empty() const
+{
+	RegionReadLock rl (const_cast<Playlist *> (this));
+	return all_regions.empty();
+}
+
 pair<framepos_t, framepos_t>
 Playlist::get_extent () const
 {
@@ -2186,6 +2329,14 @@ Playlist::get_extent () const
 	return _get_extent ();
 }
 
+pair<framepos_t, framepos_t>
+Playlist::get_extent_with_endspace () const
+{
+	pair<framepos_t, framepos_t> l = get_extent();
+	l.second += _end_space;
+	return l;
+}
+
 pair<framepos_t, framepos_t>
 Playlist::_get_extent () const
 {
@@ -2254,7 +2405,10 @@ struct RelayerSort {
 void
 Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
 {
-	/* Remove the layer we are setting from our region list, and sort it */
+	/* Remove the layer we are setting from our region list, and sort it
+	*  using the layer indeces.
+	*/
+
 	RegionList copy = regions.rlist();
 	copy.remove (region);
 	copy.sort (RelayerSort ());
@@ -2267,7 +2421,7 @@ Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
 		}
 		++i;
 	}
-	
+
 	copy.insert (i, region);
 
 	setup_layering_indices (copy);
@@ -2277,13 +2431,18 @@ void
 Playlist::setup_layering_indices (RegionList const & regions)
 {
 	uint64_t j = 0;
-	list<Evoral::Range<framepos_t> > xf;
 
 	for (RegionList::const_iterator k = regions.begin(); k != regions.end(); ++k) {
 		(*k)->set_layering_index (j++);
 	}
 }
 
+struct LaterHigherSort {
+	bool operator () (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
+		return a->position() < b->position();
+	}
+};
+
 /** Take the layering indices of each of our regions, compute the layers
  *  that they should be on, and write the layers back to the regions.
  */
@@ -2318,9 +2477,16 @@ Playlist::relayer ()
 	vector<vector<RegionList> > layers;
 	layers.push_back (vector<RegionList> (divisions));
 
-	/* Sort our regions into layering index order */
+	/* Sort our regions into layering index order (for manual layering) or position order (for later is higher)*/
 	RegionList copy = regions.rlist();
-	copy.sort (RelayerSort ());
+	switch (Config->get_layer_model()) {
+		case LaterHigher:
+			copy.sort (LaterHigherSort ());
+			break;
+		case Manual:
+			copy.sort (RelayerSort ());
+			break;
+	}
 
 	DEBUG_TRACE (DEBUG::Layering, "relayer() using:\n");
 	for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
@@ -2410,7 +2576,6 @@ Playlist::raise_region (boost::shared_ptr<Region> region)
 {
 	set_layer (region, region->layer() + 1.5);
 	relayer ();
-	check_crossfades (region->range ());
 }
 
 void
@@ -2418,7 +2583,6 @@ Playlist::lower_region (boost::shared_ptr<Region> region)
 {
 	set_layer (region, region->layer() - 1.5);
 	relayer ();
-	check_crossfades (region->range ());
 }
 
 void
@@ -2426,7 +2590,6 @@ Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
 {
 	set_layer (region, DBL_MAX);
 	relayer ();
-	check_crossfades (region->range ());
 }
 
 void
@@ -2434,7 +2597,6 @@ Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
 {
 	set_layer (region, -0.5);
 	relayer ();
-	check_crossfades (region->range ());
 }
 
 void
@@ -2489,7 +2651,7 @@ Playlist::uses_source (boost::shared_ptr<const Source> src) const
 {
 	RegionReadLock rlock (const_cast<Playlist*> (this));
 
-	for (set<boost::shared_ptr<Region> >::iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
+	for (set<boost::shared_ptr<Region> >::const_iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
 		if ((*r)->uses_source (src)) {
 			return true;
 		}
@@ -2526,6 +2688,29 @@ Playlist::region_use_count (boost::shared_ptr<Region> r) const
 		}
 	}
 
+	RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
+	for (RegionFactory::CompoundAssociations::iterator it = cassocs.begin(); it != cassocs.end(); ++it) {
+		/* check if region is used in a compound */
+		if (it->second == r) {
+			/* region is referenced as 'original' of a compound */
+			++cnt;
+			break;
+		}
+		if (r->whole_file() && r->max_source_level() > 0) {
+			/* region itself ia a compound.
+			 * the compound regions are not referenced -> check regions inside compound
+			 */
+			const SourceList& sl = r->sources();
+			for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+				boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource>(*s);
+				if (!ps) continue;
+				if (ps->playlist()->region_use_count(it->first)) {
+					// break out of both loops
+					return ++cnt;
+				}
+			}
+		}
+	}
 	return cnt;
 }
 
@@ -2534,7 +2719,7 @@ Playlist::region_by_id (const ID& id) const
 {
 	/* searches all regions ever added to this playlist */
 
-	for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+	for (set<boost::shared_ptr<Region> >::const_iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
 		if ((*i)->id() == id) {
 			return *i;
 		}
@@ -2695,6 +2880,12 @@ Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
 	return false;
 }
 
+void
+Playlist::ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+	ripple_locked (at, distance, exclude);
+}
+
 void
 Playlist::update_after_tempo_map_change ()
 {
@@ -2713,7 +2904,7 @@ Playlist::update_after_tempo_map_change ()
 void
 Playlist::foreach_region (boost::function<void(boost::shared_ptr<Region>)> s)
 {
-	RegionWriteLock rl (this, false);
+	RegionReadLock rl (this);
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		s (*i);
 	}
@@ -2810,7 +3001,14 @@ Playlist::combine (const RegionList& r)
 
 	pl->in_partition = true;
 
-	for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+	/* sort by position then layer.
+	 * route_time_axis passes 'selected_regions' - which is not sorted.
+	 * here we need the top-most first, then every layer's region sorted by position.
+	 */
+	RegionList sorted(r);
+	sorted.sort(RegionSortByLayerAndPosition());
+
+	for (RegionList::const_iterator i = sorted.begin(); i != sorted.end(); ++i) {
 
 		/* copy the region */
 
@@ -2826,6 +3024,7 @@ Playlist::combine (const RegionList& r)
 		/* make position relative to zero */
 
 		pl->add_region (copied_region, original_region->position() - earliest_position);
+		copied_region->set_layer (original_region->layer ());
 
 		/* use the maximum number of channels for any region */
 
@@ -2954,6 +3153,7 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 		}
 
 		boost::shared_ptr<Region> original (ca->second);
+		cassocs.erase(ca);
 		bool modified_region;
 
 		if (i == rl.begin()) {
@@ -2973,7 +3173,7 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 		}
 
 		/* check to see how the original region (in the
-		 * playlist before compounding occured) overlaps
+		 * playlist before compounding occurred) overlaps
 		 * with the new state of the compound region.
 		 */
 
@@ -3050,12 +3250,26 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 
 	for (vector<boost::shared_ptr<Region> >::iterator i = originals.begin(); i != originals.end(); ++i) {
 		add_region ((*i), (*i)->position());
+		set_layer((*i), (*i)->layer());
+		if (!RegionFactory::region_by_id((*i)->id())) {
+			RegionFactory::map_add(*i);
+		}
 	}
 
 	in_partition = false;
 	thaw ();
 }
 
+void
+Playlist::fade_range (list<AudioRange>& ranges)
+{
+	 for (list<AudioRange>::iterator r = ranges.begin(); r != ranges.end(); ++r) {
+		 for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+			 (*i)->fade_range ((*r).start, (*r).end);
+		 }
+	 }
+}
+
 uint32_t
 Playlist::max_source_level () const
 {
@@ -3095,6 +3309,7 @@ restart:
 				continue;
 			}
 
+			// XXX i->from can be > i->to - is this right? coverage() will return OverlapNone in this case
 			if (Evoral::coverage (i->from, i->to, j->from, j->to) != Evoral::OverlapNone) {
 				i->from = min (i->from, j->from);
 				i->to = max (i->to, j->to);
@@ -3103,8 +3318,10 @@ restart:
 			}
 		}
 	}
+}
 
-	for (list<Evoral::Range<framepos_t> >::iterator i = ranges.begin(); i != ranges.end(); ++i) {
-		check_crossfades (*i);
-	}
+void
+Playlist::set_capture_insertion_in_progress (bool yn)
+{
+	_capture_insertion_underway = yn;
 }