X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fregion.cc;h=dcca313c7921fcbb406f7e69520b99509d2fcae1;hb=a4b8955f3eb87405ceafe5c8680d9439f441458e;hp=037c84432470ef068e5d79d71cd7be922ad472e2;hpb=6f4a92f740b2fd75794489ce58f9348f8adf6bf4;p=ardour.git

diff --git a/libs/ardour/region.cc b/libs/ardour/region.cc
index 037c844324..dcca313c79 100644
--- a/libs/ardour/region.cc
+++ b/libs/ardour/region.cc
@@ -15,23 +15,31 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #include <iostream>
 #include <cmath>
 #include <climits>
 #include <algorithm>
+#include <sstream>
 
 #include <sigc++/bind.h>
 #include <sigc++/class_slot.h>
 
 #include <glibmm/thread.h>
-#include <pbd/xml++.h>
-
-#include <ardour/region.h>
-#include <ardour/playlist.h>
-#include <ardour/session.h>
+#include "pbd/xml++.h"
+#include "pbd/stacktrace.h"
+#include "pbd/enumwriter.h"
+
+#include "ardour/region.h"
+#include "ardour/playlist.h"
+#include "ardour/session.h"
+#include "ardour/source.h"
+#include "ardour/tempo.h"
+#include "ardour/region_factory.h"
+#include "ardour/filter.h"
+#include "ardour/profile.h"
+#include "ardour/utils.h"
 
 #include "i18n.h"
 
@@ -47,212 +55,443 @@ Change Region::LockChanged       = ARDOUR::new_change ();
 Change Region::LayerChanged      = ARDOUR::new_change ();
 Change Region::HiddenChanged     = ARDOUR::new_change ();
 
-sigc::signal<void,Region *> Region::CheckNewRegion;
+sigc::signal<void,boost::shared_ptr<ARDOUR::Region> > Region::RegionPropertyChanged;
+
+/* derived-from-derived constructor (no sources in constructor) */
+Region::Region (Session& s, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
+	: SessionObject(s, name)
+	, _type(type)
+	, _flags(flags)
+	, _start(start) 
+	, _length(length) 
+	, _position(0) 
+	, _last_position(0) 
+	, _positional_lock_style(AudioTime)
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _stretch(1.0)
+	, _shift(1.0)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
+{
+	/* no sources at this point */
+}
+
+/** Basic Region constructor (single source) */
+Region::Region (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
+	: SessionObject(src->session(), name)
+	, _type(type)
+	, _flags(flags)
+	, _start(start) 
+	, _length(length) 
+	, _position(0) 
+	, _last_position(0) 
+	, _positional_lock_style(AudioTime)
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _ancestral_start (0)
+	, _ancestral_length (0)
+	, _stretch (1.0)
+	, _shift (1.0)
+	, _valid_transients(false)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
 
-Region::Region (jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Region::Flag flags)
 {
-	/* basic Region constructor */
+	_sources.push_back (src);
+	_master_sources.push_back (src);
 
-	_flags = flags;
-	_playlist = 0;
-	_read_data_count = 0;
-	_frozen = 0;
-	pending_changed = Change (0);
+	src->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), src));
 
-	_name = name;
-	_start = start; 
-	_sync_position = _start;
-	_length = length; 
-	_position = 0; 
-	_layer = layer;
-	_current_state_id = 0;
-	_read_data_count = 0;
-	_first_edit = EditChangesNothing;
-	_last_layer_op = 0;
+	assert(_sources.size() > 0);
+	_positional_lock_style = AudioTime;
 }
 
-Region::Region (const Region& other, jack_nframes_t offset, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
+/** Basic Region constructor (many sources) */
+Region::Region (const SourceList& srcs, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
+	: SessionObject(srcs.front()->session(), name)
+	, _type(type)
+	, _flags(flags)
+	, _start(start) 
+	, _length(length) 
+	, _position(0) 
+	, _last_position(0) 
+	, _positional_lock_style(AudioTime)
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _stretch(1.0)
+	, _shift(1.0)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
 {
-	/* create a new Region from part of an existing one */
+	
+	set<boost::shared_ptr<Source> > unique_srcs;
 
-	_frozen = 0;
-	pending_changed = Change (0);
-	_playlist = 0;
-	_read_data_count = 0;
+	for (SourceList::const_iterator i=srcs.begin(); i != srcs.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::const_iterator i = srcs.begin(); i != srcs.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+	
+	assert(_sources.size() > 0);
+}
 
-	_start = other._start + offset; 
-	if (other._sync_position < offset) {
-		_sync_position = other._sync_position;
+/** Create a new Region from part of an existing one */
+Region::Region (boost::shared_ptr<const Region> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: SessionObject(other->session(), name)
+	, _type (other->data_type())
+
+{
+	_start = other->_start + offset;
+	copy_stuff (other, offset, length, name, layer, flags);
+
+	/* if the other region had a distinct sync point
+	   set, then continue to use it as best we can.
+	   otherwise, reset sync point back to start.
+	*/
+
+	if (other->flags() & SyncMarked) {
+		if (other->_sync_position < _start) {
+			_flags = Flag (_flags & ~SyncMarked);
+			_sync_position = _start;
+		} else {
+			_sync_position = other->_sync_position;
+		}
 	} else {
+		_flags = Flag (_flags & ~SyncMarked);
 		_sync_position = _start;
 	}
-	_length = length; 
-	_name = name;
-	_position = 0; 
-	_layer = layer; 
-	_flags = Flag (flags & ~(Locked|WholeFile|Hidden));
-	_current_state_id = 0;
-	_first_edit = EditChangesNothing;
-	_last_layer_op = 0;
+
+	if (Profile->get_sae()) {
+		/* reset sync point to start if its ended up
+		   outside region bounds.
+		*/
+
+		if (_sync_position < _start || _sync_position >= _start + _length) {
+			_flags = Flag (_flags & ~SyncMarked);
+			_sync_position = _start;
+		}
+	}
 }
 
-Region::Region (const Region &other)
+Region::Region (boost::shared_ptr<const Region> other, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: SessionObject(other->session(), name)
+	, _type (other->data_type())
 {
-	/* Pure copy constructor */
+	/* create a new Region exactly like another but starting at 0 in its sources */
 
-	_frozen = 0;
-	pending_changed = Change (0);
-	_playlist = 0;
-	_read_data_count = 0;
+	_start = 0;
+	copy_stuff (other, 0, length, name, layer, flags);
 
-	_first_edit = EditChangesID;
-	other._first_edit = EditChangesName;
+	/* sync pos is relative to start of file. our start-in-file is now zero,
+	   so set our sync position to whatever the the difference between
+	   _start and _sync_pos was in the other region. 
 
-	if (other._extra_xml) {
-		_extra_xml = new XMLNode (*other._extra_xml);
+	   result is that our new sync pos points to the same point in our source(s) 
+	   as the sync in the other region did in its source(s).
+
+	   since we start at zero in our source(s), it is not possible to use a sync point that
+	   is before the start. reset it to _start if that was true in the other region.
+	*/
+	
+	if (other->flags() & SyncMarked) {
+		if (other->_start < other->_sync_position) {
+			/* sync pos was after the start point of the other region */
+			_sync_position = other->_sync_position - other->_start;
+		} else {
+			/* sync pos was before the start point of the other region. not possible here. */
+			_flags = Flag (_flags & ~SyncMarked);
+			_sync_position = _start;
+		}
+	} else {
+		_flags = Flag (_flags & ~SyncMarked);
+		_sync_position = _start;
+	}
+		
+	if (Profile->get_sae()) {
+		/* reset sync point to start if its ended up
+		   outside region bounds.
+		*/
+
+		if (_sync_position < _start || _sync_position >= _start + _length) {
+			_flags = Flag (_flags & ~SyncMarked);
+			_sync_position = _start;
+		}
+	}
+
+	/* reset a couple of things that copy_stuff() gets wrong in this particular case */
+
+	_positional_lock_style = other->_positional_lock_style;
+	_first_edit = other->_first_edit;
+}
+
+/** Pure copy constructor */
+Region::Region (boost::shared_ptr<const Region> other)
+	: SessionObject(other->session(), other->name())
+	, _type(other->data_type())
+	, _flags(Flag(other->_flags & ~(Locked|PositionLocked)))
+	, _start(other->_start) 
+	, _length(other->_length) 
+	, _position(other->_position) 
+	, _last_position(other->_last_position) 
+	, _positional_lock_style(other->_positional_lock_style)
+	, _sync_position(other->_sync_position)
+	, _layer(other->_layer)
+	, _first_edit(EditChangesID)
+	, _frozen(0)
+	, _ancestral_start (other->_ancestral_start)
+	, _ancestral_length (other->_ancestral_length)
+	, _stretch (other->_stretch)
+	, _shift (other->_shift)
+	, _valid_transients(false)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(other->_last_layer_op)
+{
+	other->_first_edit = EditChangesName;
+
+	if (other->_extra_xml) {
+		_extra_xml = new XMLNode (*other->_extra_xml);
 	} else {
 		_extra_xml = 0;
 	}
 
-	_start = other._start;
-	_sync_position = other._sync_position;
-	_length = other._length; 
-	_name = other._name;
-	_position = other._position; 
-	_layer = other._layer; 
-	_flags = Flag (other._flags & ~Locked);
-	_current_state_id = 0;
-	_last_layer_op = other._last_layer_op;
+	set<boost::shared_ptr<Source> > unique_srcs;
+
+	for (SourceList::const_iterator i = other->_sources.begin(); i != other->_sources.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::const_iterator i = other->_master_sources.begin(); i != other->_master_sources.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+	
+	assert(_sources.size() > 0);
 }
 
-Region::Region (const XMLNode& node)
+Region::Region (const SourceList& srcs, const XMLNode& node)
+	: SessionObject(srcs.front()->session(), X_("error: XML did not reset this"))
+	, _type(DataType::NIL) // to be loaded from XML
+	, _flags(Flag(0))
+	, _start(0) 
+	, _length(0) 
+	, _position(0) 
+	, _last_position(0) 
+	, _positional_lock_style(AudioTime)
+	, _sync_position(_start)
+	, _layer(0)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _stretch(1.0)
+	, _shift(1.0)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(0)
 {
-	_frozen = 0;
-	pending_changed = Change (0);
-	_playlist = 0;
-	_read_data_count = 0;
-	_start = 0; 
-	_sync_position = _start;
-	_length = 0;
-	_name = X_("error: XML did not reset this");
-	_position = 0; 
-	_layer = 0;
-	_flags = Flag (0);
-	_current_state_id = 0;
-	_first_edit = EditChangesNothing;
+	set<boost::shared_ptr<Source> > unique_srcs;
+
+	for (SourceList::const_iterator i=srcs.begin(); i != srcs.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::const_iterator i = srcs.begin(); i != srcs.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+
+	if (set_state (node)) {
+		throw failed_constructor();
+	}
+
+	assert(_type != DataType::NIL);
+	assert(_sources.size() > 0);
+}
+
+Region::Region (boost::shared_ptr<Source> src, const XMLNode& node)
+	: SessionObject(src->session(), X_("error: XML did not reset this"))
+	, _type(DataType::NIL)
+	, _flags(Flag(0))
+	, _start(0) 
+	, _length(0) 
+	, _position(0) 
+	, _last_position(0) 
+	, _positional_lock_style(AudioTime)
+	, _sync_position(_start)
+	, _layer(0)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _stretch(1.0)
+	, _shift(1.0)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(0)
+{
+	_sources.push_back (src);
 
 	if (set_state (node)) {
 		throw failed_constructor();
 	}
+	
+	assert(_type != DataType::NIL);
+	assert(_sources.size() > 0);
 }
 
 Region::~Region ()
 {
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (pl) {
+		for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+			(*i)->remove_playlist (pl);
+		}
+		for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+			(*i)->remove_playlist (pl);
+		}
+	}
+	
+	notify_callbacks ();
+	GoingAway (); /* EMIT SIGNAL */
 }
 
 void
-Region::set_playlist (Playlist* pl)
+Region::copy_stuff (boost::shared_ptr<const Region> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
 {
-	_playlist = pl;
+	_frozen = 0;
+	_pending_changed = Change (0);
+	_read_data_count = 0;
+	_valid_transients = false;
+
+	_length = length; 
+	_last_length = length; 
+	_sync_position = other->_sync_position;
+	_ancestral_start = other->_ancestral_start;
+	_ancestral_length = other->_ancestral_length; 
+	_stretch = other->_stretch;
+	_shift = other->_shift;
+	_name = name;
+	_last_position = 0; 
+	_position = 0; 
+	_layer = layer; 
+	_flags = Flag (flags & ~(Locked|WholeFile|Hidden));
+	_first_edit = EditChangesNothing;
+	_last_layer_op = 0;
+	_positional_lock_style = AudioTime;
 }
 
 void
-Region::store_state (RegionState& state) const
+Region::set_playlist (boost::weak_ptr<Playlist> wpl)
 {
-	state._start = _start;
-	state._length = _length;
-	state._position = _position;
-	state._flags = _flags;
-	state._sync_position = _sync_position;
-	state._layer = _layer;
-	state._name = _name;
-	state._first_edit = _first_edit;
-}	
+	boost::shared_ptr<Playlist> old_playlist = (_playlist.lock());
 
-Change
-Region::restore_and_return_flags (RegionState& state)
-{
-	Change what_changed = Change (0);
+	boost::shared_ptr<Playlist> pl (wpl.lock());
 
-	{
-		Glib::Mutex::Lock lm (lock);
-		
-		if (_start != state._start) {
-			what_changed = Change (what_changed|StartChanged);	
-			_start = state._start;
-		}
-		if (_length != state._length) {
-			what_changed = Change (what_changed|LengthChanged);
-			_length = state._length;
-		}
-		if (_position != state._position) {
-			what_changed = Change (what_changed|PositionChanged);
-			_position = state._position;
-		} 
-		if (_sync_position != state._sync_position) {
-			_sync_position = state._sync_position;
-			what_changed = Change (what_changed|SyncOffsetChanged);
-		}
-		if (_layer != state._layer) {
-			what_changed = Change (what_changed|LayerChanged);
-			_layer = state._layer;
-		}
+	if (old_playlist == pl) {
+		return;
+	}
 
-		uint32_t old_flags = _flags;
-		_flags = Flag (state._flags);
-		
-		if ((old_flags ^ state._flags) & Muted) {
-			what_changed = Change (what_changed|MuteChanged);
-		}
-		if ((old_flags ^ state._flags) & Opaque) {
-			what_changed = Change (what_changed|OpacityChanged);
+	_playlist = pl;
+
+	if (pl) {
+		if (old_playlist) {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->remove_playlist (_playlist);	
+				(*i)->add_playlist (pl);
+			}
+			for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+				(*i)->remove_playlist (_playlist);	
+				(*i)->add_playlist (pl);
+			}
+		} else {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->add_playlist (pl);
+			}
+			for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+				(*i)->add_playlist (pl);
+			}
 		}
-		if ((old_flags ^ state._flags) & Locked) {
-			what_changed = Change (what_changed|LockChanged);
+	} else {
+		if (old_playlist) {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->remove_playlist (old_playlist);
+			}
+			for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+				(*i)->remove_playlist (old_playlist);
+			}
 		}
-
-		_first_edit = state._first_edit;
 	}
-
-	return what_changed;
 }
 
-void
-Region::set_name (string str)
-
+bool
+Region::set_name (const std::string& str)
 {
 	if (_name != str) {
-		_name = str; 
-		send_change (NameChanged);
+		SessionObject::set_name(str); // EMIT SIGNAL NameChanged()
+		assert(_name == str); 
+		send_change (ARDOUR::NameChanged);
 	}
+
+	return true;
 }
 
 void
-Region::set_length (jack_nframes_t len, void *src)
+Region::set_length (nframes_t len, void *src)
 {
+	//cerr << "Region::set_length() len = " << len << endl;
 	if (_flags & Locked) {
 		return;
 	}
 
 	if (_length != len && len != 0) {
 
+		/* check that the current _position wouldn't make the new 
+		   length impossible.
+		*/
+
+		if (max_frames - len < _position) {
+			return;
+		}
+
 		if (!verify_length (len)) {
 			return;
 		}
 		
+
+		_last_length = _length;
 		_length = len;
 
 		_flags = Region::Flag (_flags & ~WholeFile);
 
 		first_edit ();
 		maybe_uncopy ();
+		invalidate_transients ();
 
 		if (!_frozen) {
 			recompute_at_end ();
-
-			char buf[64];
-			snprintf (buf, sizeof (buf), "length set to %u", len);
-			save_state (buf);
 		}
 
 		send_change (LengthChanged);
@@ -267,24 +506,48 @@ Region::maybe_uncopy ()
 void
 Region::first_edit ()
 {
-	if (_first_edit != EditChangesNothing && _playlist) {
+	boost::shared_ptr<Playlist> pl (playlist());
 
-		_name = _playlist->session().new_region_name (_name);
+	if (_first_edit != EditChangesNothing && pl) {
+
+		_name = pl->session().new_region_name (_name);
 		_first_edit = EditChangesNothing;
 
-		send_change (NameChanged);
-		CheckNewRegion (this);
+		send_change (ARDOUR::NameChanged);
+		RegionFactory::CheckNewRegion (shared_from_this());
+	}
+}
+
+bool
+Region::at_natural_position () const
+{
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (!pl) {
+		return false;
+	}
+	
+	boost::shared_ptr<Region> whole_file_region = get_parent();
+
+	if (whole_file_region) {
+		if (_position == whole_file_region->position() + _start) {
+			return true;
+		}
 	}
+
+	return false;
 }
 
 void
 Region::move_to_natural_position (void *src)
 {
-	if (!_playlist) {
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (!pl) {
 		return;
 	}
-
-	Region* whole_file_region = get_parent();
+	
+	boost::shared_ptr<Region> whole_file_region = get_parent();
 
 	if (whole_file_region) {
 		set_position (whole_file_region->position() + _start, src);
@@ -292,30 +555,80 @@ Region::move_to_natural_position (void *src)
 }
 	
 void
-Region::special_set_position (jack_nframes_t pos)
+Region::special_set_position (nframes_t pos)
 {
 	/* this is used when creating a whole file region as 
 	   a way to store its "natural" or "captured" position.
 	*/
 
+	_position = _position;
 	_position = pos;
 }
 
 void
-Region::set_position (jack_nframes_t pos, void *src)
+Region::set_position_lock_style (PositionLockStyle ps)
 {
-	if (_flags & Locked) {
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (!pl) {
 		return;
 	}
 
+	_positional_lock_style = ps;
+
+	if (_positional_lock_style == MusicTime) {
+		pl->session().tempo_map().bbt_time (_position, _bbt_time);
+	}
+	
+}
+
+void
+Region::update_position_after_tempo_map_change ()
+{
+	boost::shared_ptr<Playlist> pl (playlist());
+	
+	if (!pl || _positional_lock_style != MusicTime) {
+		return;
+	}
+
+	TempoMap& map (pl->session().tempo_map());
+	nframes_t pos = map.frame_time (_bbt_time);
+	set_position_internal (pos, false);
+}
+
+void
+Region::set_position (nframes_t pos, void *src)
+{
+	if (!can_move()) {
+		return;
+	}
+
+	set_position_internal (pos, true);
+}
+
+void
+Region::set_position_internal (nframes_t pos, bool allow_bbt_recompute)
+{
 	if (_position != pos) {
+		_last_position = _position;
 		_position = pos;
 
-		if (!_frozen) {
-			char buf[64];
-			snprintf (buf, sizeof (buf), "position set to %u", pos);
-			save_state (buf);
+		/* check that the new _position wouldn't make the current
+		   length impossible - if so, change the length. 
+
+		   XXX is this the right thing to do?
+		*/
+
+		if (max_frames - _length < _position) {
+			_last_length = _length;
+			_length = max_frames - _position;
 		}
+
+		if (allow_bbt_recompute) {
+			recompute_position_from_lock_style ();
+		}
+
+		invalidate_transients ();
 	}
 
 	/* do this even if the position is the same. this helps out
@@ -326,23 +639,22 @@ Region::set_position (jack_nframes_t pos, void *src)
 }
 
 void
-Region::set_position_on_top (jack_nframes_t pos, void *src)
+Region::set_position_on_top (nframes_t pos, void *src)
 {
 	if (_flags & Locked) {
 		return;
 	}
 
 	if (_position != pos) {
+		_last_position = _position;
 		_position = pos;
-
-		if (!_frozen) {
-			char buf[64];
-			snprintf (buf, sizeof (buf), "position set to %u", pos);
-			save_state (buf);
-		}
 	}
 
-	_playlist->raise_region_to_top (*this);
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (pl) {
+		pl->raise_region_to_top (shared_from_this ());
+	}
 
 	/* do this even if the position is the same. this helps out
 	   a GUI that has moved its representation already.
@@ -352,7 +664,18 @@ Region::set_position_on_top (jack_nframes_t pos, void *src)
 }
 
 void
-Region::nudge_position (long n, void *src)
+Region::recompute_position_from_lock_style ()
+{
+	if (_positional_lock_style == MusicTime) {
+		boost::shared_ptr<Playlist> pl (playlist());
+		if (pl) {
+			pl->session().tempo_map().bbt_time (_position, _bbt_time);
+		}
+	}
+}
+		
+void
+Region::nudge_position (nframes64_t n, void *src)
 {
 	if (_flags & Locked) {
 		return;
@@ -362,6 +685,8 @@ Region::nudge_position (long n, void *src)
 		return;
 	}
 	
+	_last_position = _position;
+
 	if (n > 0) {
 		if (_position > max_frames - n) {
 			_position = max_frames;
@@ -369,26 +694,29 @@ Region::nudge_position (long n, void *src)
 			_position += n;
 		}
 	} else {
-		if (_position < (jack_nframes_t) -n) {
+		if (_position < (nframes_t) -n) {
 			_position = 0;
 		} else {
 			_position += n;
 		}
 	}
 
-	if (!_frozen) {
-		char buf[64];
-		snprintf (buf, sizeof (buf), "position set to %u", _position);
-		save_state (buf);
-	}
-
 	send_change (PositionChanged);
 }
 
 void
-Region::set_start (jack_nframes_t pos, void *src)
+Region::set_ancestral_data (nframes64_t s, nframes64_t l, float st, float sh)
 {
-	if (_flags & Locked) {
+	_ancestral_length = l;
+	_ancestral_start = s;
+	_stretch = st;
+	_shift = sh;
+}
+
+void
+Region::set_start (nframes_t pos, void *src)
+{
+	if (_flags & (Locked|PositionLocked)) {
 		return;
 	}
 	/* This just sets the start, nothing else. It effectively shifts
@@ -405,24 +733,19 @@ Region::set_start (jack_nframes_t pos, void *src)
 		_start = pos;
 		_flags = Region::Flag (_flags & ~WholeFile);
 		first_edit ();
-
-		if (!_frozen) {
-			char buf[64];
-			snprintf (buf, sizeof (buf), "start set to %u", pos);
-			save_state (buf);
-		}
+		invalidate_transients ();
 
 		send_change (StartChanged);
 	}
 }
 
 void
-Region::trim_start (jack_nframes_t new_position, void *src)
+Region::trim_start (nframes_t new_position, void *src)
 {
-	if (_flags & Locked) {
+	if (_flags & (Locked|PositionLocked)) {
 		return;
 	}
-	jack_nframes_t new_start;
+	nframes_t new_start;
 	int32_t start_shift;
 	
 	if (new_position > _position) {
@@ -445,7 +768,7 @@ Region::trim_start (jack_nframes_t new_position, void *src)
 
 	} else if (start_shift < 0) {
 
-		if (_start < (jack_nframes_t) -start_shift) {
+		if (_start < (nframes_t) -start_shift) {
 			new_start = 0;
 		} else {
 			new_start = _start + start_shift;
@@ -462,24 +785,18 @@ Region::trim_start (jack_nframes_t new_position, void *src)
 	_flags = Region::Flag (_flags & ~WholeFile);
 	first_edit ();
 
-	if (!_frozen) {
-		char buf[64];
-		snprintf (buf, sizeof (buf), "slipped start to %u", _start);
-		save_state (buf);
-	}
-
 	send_change (StartChanged);
 }
 
 void
-Region::trim_front (jack_nframes_t new_position, void *src)
+Region::trim_front (nframes_t new_position, void *src)
 {
 	if (_flags & Locked) {
 		return;
 	}
 
-	jack_nframes_t end = _position + _length - 1;
-	jack_nframes_t source_zero;
+	nframes_t end = last_frame();
+	nframes_t source_zero;
 
 	if (_position > _start) {
 		source_zero = _position - _start;
@@ -489,7 +806,7 @@ Region::trim_front (jack_nframes_t new_position, void *src)
 
 	if (new_position < end) { /* can't trim it zero or negative length */
 		
-		jack_nframes_t newlen;
+		nframes_t newlen;
 
 		/* can't trim it back passed where source position zero is located */
 		
@@ -510,7 +827,7 @@ Region::trim_front (jack_nframes_t new_position, void *src)
 }
 
 void
-Region::trim_end (jack_nframes_t new_endpoint, void *src)
+Region::trim_end (nframes_t new_endpoint, void *src)
 {
 	if (_flags & Locked) {
 		return;
@@ -525,7 +842,7 @@ Region::trim_end (jack_nframes_t new_endpoint, void *src)
 }
 
 void
-Region::trim_to (jack_nframes_t position, jack_nframes_t length, void *src)
+Region::trim_to (nframes_t position, nframes_t length, void *src)
 {
 	if (_flags & Locked) {
 		return;
@@ -540,10 +857,10 @@ Region::trim_to (jack_nframes_t position, jack_nframes_t length, void *src)
 }
 
 void
-Region::trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *src)
+Region::trim_to_internal (nframes_t position, nframes_t length, void *src)
 {
 	int32_t start_shift;
-	jack_nframes_t new_start;
+	nframes_t new_start;
 
 	if (_flags & Locked) {
 		return;
@@ -566,7 +883,7 @@ Region::trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *
 
 	} else if (start_shift < 0) {
 
-		if (_start < (jack_nframes_t) -start_shift) {
+		if (_start < (nframes_t) -start_shift) {
 			new_start = 0;
 		} else {
 			new_start = _start + start_shift;
@@ -586,10 +903,16 @@ Region::trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *
 		what_changed = Change (what_changed|StartChanged);
 	}
 	if (_length != length) {
+		if (!_frozen) {
+			_last_length = _length;
+		}
 		_length = length;
 		what_changed = Change (what_changed|LengthChanged);
 	}
 	if (_position != position) {
+		if (!_frozen) {
+			_last_position = _position;
+		}
 		_position = position;
 		what_changed = Change (what_changed|PositionChanged);
 	}
@@ -601,13 +924,6 @@ Region::trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *
 	} 
 
 	if (what_changed) {
-		
-		if (!_frozen) {
-			char buf[64];
-			snprintf (buf, sizeof (buf), "trimmed to %u-%u", _position, _position+_length-1);
-			save_state (buf);
-		}
-
 		send_change (what_changed);
 	}
 }	
@@ -638,16 +954,6 @@ Region::set_muted (bool yn)
 			_flags = Flag (_flags & ~Muted);
 		}
 
-		if (!_frozen) {
-			char buf[64];
-			if (yn) {
-				snprintf (buf, sizeof (buf), "muted");
-			} else {
-				snprintf (buf, sizeof (buf), "unmuted");
-			}
-			save_state (buf);
-		}
-
 		send_change (MuteChanged);
 	}
 }
@@ -656,16 +962,10 @@ void
 Region::set_opaque (bool yn)
 {
 	if (opaque() != yn) {
-		if (!_frozen) {
-			char buf[64];
-			if (yn) {
-				snprintf (buf, sizeof (buf), "opaque");
-				_flags = Flag (_flags|Opaque);
-			} else {
-				snprintf (buf, sizeof (buf), "translucent");
-				_flags = Flag (_flags & ~Opaque);
-			}
-			save_state (buf);
+		if (yn) {
+			_flags = Flag (_flags|Opaque);
+		} else {
+			_flags = Flag (_flags & ~Opaque);
 		}
 		send_change (OpacityChanged);
 	}
@@ -675,25 +975,32 @@ void
 Region::set_locked (bool yn)
 {
 	if (locked() != yn) {
-		if (!_frozen) {
-			char buf[64];
-			if (yn) {
-				snprintf (buf, sizeof (buf), "locked");
-				_flags = Flag (_flags|Locked);
-			} else {
-				snprintf (buf, sizeof (buf), "unlocked");
-				_flags = Flag (_flags & ~Locked);
-			}
-			save_state (buf);
+		if (yn) {
+			_flags = Flag (_flags|Locked);
+		} else {
+			_flags = Flag (_flags & ~Locked);
+		}
+		send_change (LockChanged);
+	}
+}
+
+void
+Region::set_position_locked (bool yn)
+{
+	if (position_locked() != yn) {
+		if (yn) {
+			_flags = Flag (_flags|PositionLocked);
+		} else {
+			_flags = Flag (_flags & ~PositionLocked);
 		}
 		send_change (LockChanged);
 	}
 }
 
 void
-Region::set_sync_position (jack_nframes_t absolute_pos)
+Region::set_sync_position (nframes_t absolute_pos)
 {
-	jack_nframes_t file_pos;
+	nframes_t file_pos;
 
 	file_pos = _start + (absolute_pos - _position);
 
@@ -703,10 +1010,7 @@ Region::set_sync_position (jack_nframes_t absolute_pos)
 		_flags = Flag (_flags|SyncMarked);
 
 		if (!_frozen) {
-			char buf[64];
 			maybe_uncopy ();
-			snprintf (buf, sizeof (buf), "sync point set to %u", _sync_position);
-			save_state (buf);
 		}
 		send_change (SyncOffsetChanged);
 	}
@@ -720,13 +1024,12 @@ Region::clear_sync_position ()
 
 		if (!_frozen) {
 			maybe_uncopy ();
-			save_state ("sync point removed");
 		}
 		send_change (SyncOffsetChanged);
 	}
 }
 
-jack_nframes_t
+nframes_t
 Region::sync_offset (int& dir) const
 {
 	/* returns the sync point relative the first frame of the region */
@@ -745,28 +1048,30 @@ Region::sync_offset (int& dir) const
 	}
 }
 
-jack_nframes_t 
-Region::adjust_to_sync (jack_nframes_t pos)
+nframes_t 
+Region::adjust_to_sync (nframes_t pos) const
 {
 	int sync_dir;
-	jack_nframes_t offset = sync_offset (sync_dir);
+	nframes_t offset = sync_offset (sync_dir);
+
+	// cerr << "adjusting pos = " << pos << " to sync at " << _sync_position << " offset = " << offset << " with dir = " << sync_dir << endl;
 	
 	if (sync_dir > 0) {
-		if (max_frames - pos > offset) {
-			pos += offset;
-		}
-	} else {
 		if (pos > offset) {
 			pos -= offset;
 		} else {
 			pos = 0;
 		}
+	} else {
+		if (max_frames - pos > offset) {
+			pos += offset;
+		}
 	}
 
 	return pos;
 }
 
-jack_nframes_t
+nframes_t
 Region::sync_position() const
 {
 	if (_flags & SyncMarked) {
@@ -776,46 +1081,41 @@ Region::sync_position() const
 	}
 }
 
-
 void
 Region::raise ()
 {
-	if (_playlist == 0) {
-		return;
+	boost::shared_ptr<Playlist> pl (playlist());
+	if (pl) {
+		pl->raise_region (shared_from_this ());
 	}
-
-	_playlist->raise_region (*this);
 }
 
 void
 Region::lower ()
 {
-	if (_playlist == 0) {
-		return;
+	boost::shared_ptr<Playlist> pl (playlist());
+	if (pl) {
+		pl->lower_region (shared_from_this ());
 	}
-
-	_playlist->lower_region (*this);
 }
 
+
 void
 Region::raise_to_top ()
 {
-
-	if (_playlist == 0) {
-		return;
+	boost::shared_ptr<Playlist> pl (playlist());
+	if (pl) {
+		pl->raise_region_to_top (shared_from_this());
 	}
-
-	_playlist->raise_region_to_top (*this);
 }
 
 void
 Region::lower_to_bottom ()
 {
-	if (_playlist == 0) {
-		return;
+	boost::shared_ptr<Playlist> pl (playlist());
+	if (pl) {
+		pl->lower_region_to_bottom (shared_from_this());
 	}
-
-	_playlist->lower_region_to_bottom (*this);
 }
 
 void
@@ -824,12 +1124,6 @@ Region::set_layer (layer_t l)
 	if (_layer != l) {
 		_layer = l;
 		
-		if (!_frozen) {
-			char buf[64];
-			snprintf (buf, sizeof (buf), "layer set to %" PRIu32, _layer);
-			save_state (buf);
-		}
-		
 		send_change (LayerChanged);
 	}
 }
@@ -839,24 +1133,58 @@ Region::state (bool full_state)
 {
 	XMLNode *node = new XMLNode ("Region");
 	char buf[64];
-	
-	_id.print (buf);
+	const char* fe = NULL;
+
+	_id.print (buf, sizeof (buf));
 	node->add_property ("id", buf);
 	node->add_property ("name", _name);
+	node->add_property ("type", _type.to_string());
 	snprintf (buf, sizeof (buf), "%u", _start);
 	node->add_property ("start", buf);
 	snprintf (buf, sizeof (buf), "%u", _length);
 	node->add_property ("length", buf);
 	snprintf (buf, sizeof (buf), "%u", _position);
 	node->add_property ("position", buf);
+	snprintf (buf, sizeof (buf), "%" PRIi64, _ancestral_start);
+	node->add_property ("ancestral-start", buf);
+	snprintf (buf, sizeof (buf), "%" PRIi64, _ancestral_length);
+	node->add_property ("ancestral-length", buf);
+	snprintf (buf, sizeof (buf), "%.12g", _stretch);
+	node->add_property ("stretch", buf);
+	snprintf (buf, sizeof (buf), "%.12g", _shift);
+	node->add_property ("shift", buf);
+	
+	switch (_first_edit) {
+	case EditChangesNothing:
+		fe = X_("nothing");
+		break;
+	case EditChangesName:
+		fe = X_("name");
+		break;
+	case EditChangesID:
+		fe = X_("id");
+		break;
+	default: /* should be unreachable but makes g++ happy */
+		fe = X_("nothing");
+		break;
+	}
+
+	node->add_property ("first-edit", fe);
 
 	/* note: flags are stored by derived classes */
 
 	snprintf (buf, sizeof (buf), "%d", (int) _layer);
 	node->add_property ("layer", buf);
-	snprintf (buf, sizeof (buf), "%u", _sync_position);
+	snprintf (buf, sizeof (buf), "%" PRIu32, _sync_position);
 	node->add_property ("sync-position", buf);
 
+	if (_positional_lock_style != AudioTime) {
+		node->add_property ("positional-lock-style", enum_2_string (_positional_lock_style));
+		stringstream str;
+		str << _bbt_time;
+		node->add_property ("bbt-position", str.str());
+	}
+
 	return *node;
 }
 
@@ -867,67 +1195,190 @@ Region::get_state ()
 }
 
 int
-Region::set_state (const XMLNode& node)
+Region::set_live_state (const XMLNode& node, Change& what_changed, bool send)
 {
 	const XMLNodeList& nlist = node.children();
 	const XMLProperty *prop;
+	nframes_t val;
 
-	if (_extra_xml) {
-		delete _extra_xml;
-		_extra_xml = 0;
-	}
-
-	if ((prop = node.property ("id")) == 0) {
-		error << _("Session: XMLNode describing a Region is incomplete (no id)") << endmsg;
-		return -1;
-	}
-
-	_id = prop->value();
+	/* this is responsible for setting those aspects of Region state 
+	   that are mutable after construction.
+	*/
 
 	if ((prop = node.property ("name")) == 0) {
-		error << _("Session: XMLNode describing a Region is incomplete (no name)") << endmsg;
+		error << _("XMLNode describing a Region is incomplete (no name)") << endmsg;
 		return -1;
 	}
 
 	_name = prop->value();
+	
+	if ((prop = node.property ("type")) == 0) {
+		_type = DataType::AUDIO;
+	} else {
+		_type = DataType(prop->value());
+	}
 
 	if ((prop = node.property ("start")) != 0) {
-		_start = (jack_nframes_t) atoi (prop->value().c_str());
+		sscanf (prop->value().c_str(), "%" PRIu32, &val);
+		if (val != _start) {
+			what_changed = Change (what_changed|StartChanged);	
+			_start = val;
+		}
+	} else {
+		_start = 0;
 	}
 
 	if ((prop = node.property ("length")) != 0) {
-		_length = (jack_nframes_t) atoi (prop->value().c_str());
+		sscanf (prop->value().c_str(), "%" PRIu32, &val);
+		if (val != _length) {
+			what_changed = Change (what_changed|LengthChanged);
+			_last_length = _length;
+			_length = val;
+		}
+	} else {
+		_last_length = _length;
+		_length = 1;
 	}
 
 	if ((prop = node.property ("position")) != 0) {
-		_position = (jack_nframes_t) atoi (prop->value().c_str());
+		sscanf (prop->value().c_str(), "%" PRIu32, &val);
+		if (val != _position) {
+			what_changed = Change (what_changed|PositionChanged);
+			_last_position = _position;
+			_position = val;
+		}
+	} else {
+		_last_position = _position;
+		_position = 0;
 	}
 
 	if ((prop = node.property ("layer")) != 0) {
-		_layer = (layer_t) atoi (prop->value().c_str());
+		layer_t x;
+		x = (layer_t) atoi (prop->value().c_str());
+		if (x != _layer) {
+			what_changed = Change (what_changed|LayerChanged);
+			_layer = x;
+		}
+	} else {
+		_layer = 0;
 	}
 
-	/* note: derived classes set flags */
-
 	if ((prop = node.property ("sync-position")) != 0) {
-		_sync_position = (jack_nframes_t) atoi (prop->value().c_str());
+		sscanf (prop->value().c_str(), "%" PRIu32, &val);
+		if (val != _sync_position) {
+			what_changed = Change (what_changed|SyncOffsetChanged);
+			_sync_position = val;
+		}
 	} else {
 		_sync_position = _start;
 	}
+
+	if ((prop = node.property ("positional-lock-style")) != 0) {
+		_positional_lock_style = PositionLockStyle (string_2_enum (prop->value(), _positional_lock_style));
+
+		if (_positional_lock_style == MusicTime) {
+			if ((prop = node.property ("bbt-position")) == 0) {
+				/* missing BBT info, revert to audio time locking */
+				_positional_lock_style = AudioTime;
+			} else {
+				if (sscanf (prop->value().c_str(), "%d|%d|%d", 
+					    &_bbt_time.bars,
+					    &_bbt_time.beats,
+					    &_bbt_time.ticks) != 3) {
+					_positional_lock_style = AudioTime;
+				}
+			}
+		}
+			
+	} else {
+		_positional_lock_style = AudioTime;
+	}
+
+	/* XXX FIRST EDIT !!! */
 	
+	/* these 3 properties never change as a result of any editing */
+
+	if ((prop = node.property ("ancestral-start")) != 0) {
+		_ancestral_start = atoi (prop->value());
+	} else {
+		_ancestral_start = _start;
+	}
+
+	if ((prop = node.property ("ancestral-length")) != 0) {
+		_ancestral_length = atoi (prop->value());
+	} else {
+		_ancestral_length = _length;
+	}
+
+	if ((prop = node.property ("stretch")) != 0) {
+		_stretch = atof (prop->value());
+
+		/* fix problem with old sessions corrupted by an impossible
+		   value for _stretch
+		*/
+		if (_stretch == 0.0) {
+			_stretch = 1.0;
+		}
+	} else {
+		_stretch = 1.0;
+	}
+
+	if ((prop = node.property ("shift")) != 0) {
+		_shift = atof (prop->value());
+
+		/* fix problem with old sessions corrupted by an impossible
+		   value for _shift
+		*/
+		if (_shift == 0.0) {
+			_shift = 1.0;
+		}
+	} else {
+		_shift = 1.0;
+	}
+
+
+	/* note: derived classes set flags */
+
+	delete _extra_xml;
+	_extra_xml = 0;
+
 	for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
 		
 		XMLNode *child;
 		
 		child = (*niter);
 		
-		if (child->name () == "extra") {
+		if (child->name () == "Extra") {
 			_extra_xml = new XMLNode (*child);
 			break;
 		}
 	}
 
+	if (send) {
+		send_change (what_changed);
+	}
+
+	return 0;
+}
+
+int
+Region::set_state (const XMLNode& node)
+{
+	const XMLProperty *prop;
+	Change what_changed = Change (0);
+
+	/* ID is not allowed to change, ever */
+
+	if ((prop = node.property ("id")) == 0) {
+		error << _("Session: XMLNode describing a Region is incomplete (no id)") << endmsg;
+		return -1;
+	}
+
+	_id = prop->value();
+	
 	_first_edit = EditChangesNothing;
+	
+	set_live_state (node, what_changed, true);
 
 	return 0;
 }
@@ -936,6 +1387,8 @@ void
 Region::freeze ()
 {
 	_frozen++;
+	_last_length = _length;
+	_last_position = _position;
 }
 
 void
@@ -944,15 +1397,15 @@ Region::thaw (const string& why)
 	Change what_changed = Change (0);
 
 	{
-		Glib::Mutex::Lock lm (lock);
+		Glib::Mutex::Lock lm (_lock);
 
 		if (_frozen && --_frozen > 0) {
 			return;
 		}
 
-		if (pending_changed) {
-			what_changed = pending_changed;
-			pending_changed = Change (0);
+		if (_pending_changed) {
+			what_changed = _pending_changed;
+			_pending_changed = Change (0);
 		}
 	}
 
@@ -967,7 +1420,6 @@ Region::thaw (const string& why)
 		recompute_at_end ();
 	}
 		
-	save_state (why);
 	StateChanged (what_changed);
 }
 
@@ -975,14 +1427,29 @@ void
 Region::send_change (Change what_changed)
 {
 	{
-		Glib::Mutex::Lock lm (lock);
+		Glib::Mutex::Lock lm (_lock);
 		if (_frozen) {
-			pending_changed = Change (pending_changed|what_changed);
+			_pending_changed = Change (_pending_changed|what_changed);
 			return;
 		} 
 	}
 
-	StateManager::send_state_changed (what_changed);
+	StateChanged (what_changed);
+	
+	if (!(_flags & DoNotSaveState)) {
+		
+		/* Try and send a shared_pointer unless this is part of the constructor.
+		   If so, do nothing.
+		*/
+		
+		try {
+			boost::shared_ptr<Region> rptr = shared_from_this();
+			RegionPropertyChanged (rptr);
+		} catch (...) {
+			/* no shared_ptr available, relax; */
+		}
+	}
+	
 }
 
 void
@@ -992,28 +1459,182 @@ Region::set_last_layer_op (uint64_t when)
 }
 
 bool
-Region::overlap_equivalent (const Region& other) const
+Region::overlap_equivalent (boost::shared_ptr<const Region> other) const
 {
-	return coverage (other.first_frame(), other.last_frame()) != OverlapNone;
+	return coverage (other->first_frame(), other->last_frame()) != OverlapNone;
 }
 
 bool
-Region::equivalent (const Region& other) const
+Region::equivalent (boost::shared_ptr<const Region> other) const
 {
-	return _start == other._start &&
-		_position == other._position &&
-		_length == other._length;
+	return _start == other->_start &&
+		_position == other->_position &&
+		_length == other->_length;
 }
 
 bool
-Region::size_equivalent (const Region& other) const
+Region::size_equivalent (boost::shared_ptr<const Region> other) const
 {
-	return _start == other._start &&
-		_length == other._length;
+	return _start == other->_start &&
+		_length == other->_length;
 }
 
 bool
-Region::region_list_equivalent (const Region& other) const
+Region::region_list_equivalent (boost::shared_ptr<const Region> other) const
 {
-	return size_equivalent (other) && source_equivalent (other) && _name == other._name;
+	return size_equivalent (other) && source_equivalent (other) && _name == other->_name;
 }
+
+void
+Region::source_deleted (boost::shared_ptr<Source>)
+{
+	_sources.clear ();
+	drop_references ();
+}
+
+vector<string>
+Region::master_source_names ()
+{
+	SourceList::iterator i;
+
+	vector<string> names;
+	for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+		names.push_back((*i)->name());
+	}
+
+	return names;
+}
+
+void
+Region::set_master_sources (const SourceList& srcs)
+{
+	_master_sources = srcs;
+}
+
+bool
+Region::source_equivalent (boost::shared_ptr<const Region> other) const
+{
+	if (!other)
+		return false;
+
+	SourceList::const_iterator i;
+	SourceList::const_iterator io;
+
+	for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
+		if ((*i)->id() != (*io)->id()) {
+			return false;
+		}
+	}
+
+	for (i = _master_sources.begin(), io = other->_master_sources.begin(); i != _master_sources.end() && io != other->_master_sources.end(); ++i, ++io) {
+		if ((*i)->id() != (*io)->id()) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+sframes_t
+Region::source_length(uint32_t n) const
+{
+	return _sources[n]->length(_position - _start);
+}
+
+bool
+Region::verify_length (nframes_t len)
+{
+	if (source() && (source()->destructive() || source()->length_mutable())) {
+		return true;
+	}
+
+	nframes_t maxlen = 0;
+
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		maxlen = max (maxlen, (nframes_t)source_length(n) - _start);
+	}
+	
+	len = min (len, maxlen);
+	
+	return true;
+}
+
+bool
+Region::verify_start_and_length (nframes_t new_start, nframes_t& new_length)
+{
+	if (source() && (source()->destructive() || source()->length_mutable())) {
+		return true;
+	}
+
+	nframes_t maxlen = 0;
+
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		maxlen = max (maxlen, (nframes_t)source_length(n) - new_start);
+	}
+
+	new_length = min (new_length, maxlen);
+
+	return true;
+}
+
+bool
+Region::verify_start (nframes_t pos)
+{
+	if (source() && (source()->destructive() || source()->length_mutable())) {
+		return true;
+	}
+
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (pos > source_length(n) - _length) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool
+Region::verify_start_mutable (nframes_t& new_start)
+{
+	if (source() && (source()->destructive() || source()->length_mutable())) {
+		return true;
+	}
+
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (new_start > source_length(n) - _length) {
+			new_start = source_length(n) - _length;
+		}
+	}
+	return true;
+}
+
+boost::shared_ptr<Region>
+Region::get_parent() const
+{
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (pl) {
+		boost::shared_ptr<Region> r;
+		boost::shared_ptr<Region const> grrr2 = boost::dynamic_pointer_cast<Region const> (shared_from_this());
+		
+		if (grrr2 && (r = pl->session().find_whole_file_parent (grrr2))) {
+			return boost::static_pointer_cast<Region> (r);
+		}
+	}
+	
+	return boost::shared_ptr<Region>();
+}
+
+int
+Region::apply (Filter& filter)
+{
+	return filter.run (shared_from_this());
+}
+
+
+void
+Region::invalidate_transients ()
+{
+	_valid_transients = false;
+	_transients.clear ();
+}
+