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 <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 "i18n.h"
Change Region::LayerChanged = ARDOUR::new_change ();
Change Region::HiddenChanged = ARDOUR::new_change ();
-Region::Region (jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Region::Flag flags)
+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)
{
- /* basic Region constructor */
+ /* no sources at this point */
+}
- _flags = flags;
- _playlist = 0;
- _read_data_count = 0;
- _frozen = 0;
- pending_changed = Change (0);
+/** 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)
- _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;
+{
+ _sources.push_back (src);
+ _master_sources.push_back (src);
+
+ src->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), src));
+
+ assert(_sources.size() > 0);
+ _positional_lock_style = AudioTime;
}
-Region::Region (boost::shared_ptr<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 (boost::shared_ptr<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);
+
+ /* 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.
+
+ 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;
+}
- _first_edit = EditChangesID;
+/** 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 = 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 ()
{
- notify_callbacks ();
+ boost::shared_ptr<Playlist> pl (playlist());
- /* derived classes must emit GoingAway */
+ 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);
void
Region::first_edit ()
{
- if (_first_edit != EditChangesNothing && _playlist) {
+ boost::shared_ptr<Playlist> pl (playlist());
+
+ if (_first_edit != EditChangesNothing && pl) {
- _name = _playlist->session().new_region_name (_name);
+ _name = pl->session().new_region_name (_name);
_first_edit = EditChangesNothing;
- send_change (NameChanged);
- /// XXX CheckNewRegion (boost::shared_ptr<Region>(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;
}
-
+
boost::shared_ptr<Region> whole_file_region = get_parent();
if (whole_file_region) {
}
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
}
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 (boost::shared_ptr<Region>(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.
}
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;
return;
}
+ _last_position = _position;
+
if (n > 0) {
if (_position > max_frames - n) {
_position = max_frames;
_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
_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) {
} 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;
_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;
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 */
}
void
-Region::trim_end (jack_nframes_t new_endpoint, void *src)
+Region::trim_end (nframes_t new_endpoint, void *src)
{
if (_flags & Locked) {
return;
}
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;
}
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;
} 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;
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);
}
}
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);
}
}
_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);
}
}
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);
}
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);
_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);
}
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 */
}
}
-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) {
}
}
-
void
Region::raise ()
{
- if (_playlist == 0) {
- return;
+ boost::shared_ptr<Playlist> pl (playlist());
+ if (pl) {
+ pl->raise_region (shared_from_this ());
}
-
- _playlist->raise_region (boost::shared_ptr<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 (boost::shared_ptr<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 (boost::shared_ptr<Region>(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 (boost::shared_ptr<Region>(this));
}
void
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);
}
}
{
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;
}
}
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;
}
}
+ 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;
}
Region::freeze ()
{
_frozen++;
+ _last_length = _length;
+ _last_position = _position;
}
void
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);
}
}
recompute_at_end ();
}
- save_state (why);
StateChanged (what_changed);
}
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
{
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;
+}
+
+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, _sources[n]->length() - _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, _sources[n]->length() - 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 > _sources[n]->length() - _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 > _sources[n]->length() - _length) {
+ new_start = _sources[n]->length() - _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 ();
+}
+
projects / ardour.git / blobdiff