X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fregion.cc;h=1f4d6f0f912221d78d3fc4739ea8840a82d13af4;hb=7d96960b162d25da87c388a3083775e8770bba56;hp=e8353ac52909ffa41edd77aee266175a47803d9b;hpb=21d85f1854461ab6209d23e278fe289505cd106c;p=ardour.git diff --git a/libs/ardour/region.cc b/libs/ardour/region.cc index e8353ac529..1f4d6f0f91 100644 --- a/libs/ardour/region.cc +++ b/libs/ardour/region.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2003 Paul Davis + Copyright (C) 2000-2003 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,24 +15,30 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #include #include #include #include +#include -#include -#include #include -#include - -#include -#include -#include -#include +#include "pbd/xml++.h" +#include "pbd/stacktrace.h" +#include "pbd/enumwriter.h" + +#include "ardour/debug.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" @@ -48,63 +54,215 @@ Change Region::LockChanged = ARDOUR::new_change (); 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) +PBD::Signal1 > 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(Flag (flags|DoNotSendPropertyChanges)) + , _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) + , _read_data_count(0) + , _pending_changed(Change (0)) + , _last_layer_op(0) + , _pending_explicit_relayer (false) { - /* 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 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(Flag (flags|DoNotSendPropertyChanges)) + , _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) + , _pending_explicit_relayer (false) +{ + _sources.push_back (src); + _master_sources.push_back (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; + src->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr(src))); + + assert(_sources.size() > 0); + _positional_lock_style = AudioTime; } -Region::Region (boost::shared_ptr 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(Flag (flags|DoNotSendPropertyChanges)) + , _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) + , _read_data_count(0) + , _pending_changed(Change (0)) + , _last_layer_op(0) + , _pending_explicit_relayer (false) { - /* create a new Region from part of an existing one */ + use_sources (srcs); + assert(_sources.size() > 0); +} - _frozen = 0; - pending_changed = Change (0); - _playlist = 0; - _read_data_count = 0; +/** Create a new Region from part of an existing one */ +Region::Region (boost::shared_ptr other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags) + : SessionObject(other->session(), name) + , _type (other->data_type()) + , _pending_explicit_relayer (false) - _start = other->_start + offset; - if (other->_sync_position < offset) { - _sync_position = other->_sync_position; +{ + _start = other->_start + offset; + copy_stuff (other, offset, length, name, layer, flags); + + _flags = Flag (_flags | DoNotSendPropertyChanges); + + /* 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 other) +Region::Region (boost::shared_ptr other, nframes_t length, const string& name, layer_t layer, Flag flags) + : SessionObject(other->session(), name) + , _type (other->data_type()) + , _pending_explicit_relayer (false) { - /* 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); + + _flags = Flag (_flags | DoNotSendPropertyChanges); + + /* 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; +} + +/** Pure copy constructor */ +Region::Region (boost::shared_ptr 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) + , _pending_explicit_relayer (false) +{ + _flags = Flag (_flags | DoNotSendPropertyChanges); - _first_edit = EditChangesID; other->_first_edit = EditChangesName; if (other->_extra_xml) { @@ -113,148 +271,154 @@ Region::Region (boost::shared_ptr other) _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; + use_sources (other->_sources); + 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(DoNotSendPropertyChanges) + , _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) + , _pending_explicit_relayer (false) { - _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; + use_sources (srcs); - if (set_state (node)) { + if (set_state (node, Stateful::loading_state_version)) { throw failed_constructor(); } + + assert(_type != DataType::NIL); + assert(_sources.size() > 0); } -Region::~Region () +Region::Region (boost::shared_ptr src, const XMLNode& node) + : SessionObject(src->session(), X_("error: XML did not reset this")) + , _type(DataType::NIL) + , _flags(DoNotSendPropertyChanges) + , _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) + , _pending_explicit_relayer (false) { - notify_callbacks (); + _sources.push_back (src); + + if (set_state (node, Stateful::loading_state_version)) { + throw failed_constructor(); + } - /* derived classes must emit GoingAway */ + assert(_type != DataType::NIL); + assert(_sources.size() > 0); } -void -Region::set_playlist (Playlist* pl) +Region::~Region () { - _playlist = pl; + DEBUG_TRACE (DEBUG::Destruction, string_compose ("Region %1 destructor @ %2\n", _name, this)); } void -Region::store_state (RegionState& state) const +Region::copy_stuff (boost::shared_ptr other, nframes_t /*offset*/, nframes_t length, const string& name, layer_t layer, Flag flags) { - 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; -} - -Change -Region::restore_and_return_flags (RegionState& state) -{ - Change what_changed = Change (0); - - { - 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; - } - - 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); - } - if ((old_flags ^ state._flags) & Locked) { - what_changed = Change (what_changed|LockChanged); - } + _frozen = 0; + _pending_changed = Change (0); + _read_data_count = 0; + _valid_transients = false; - _first_edit = state._first_edit; - } + _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; - return what_changed; + use_sources (other->_sources); } void -Region::set_name (string str) +Region::set_playlist (boost::weak_ptr wpl) +{ + _playlist = wpl.lock(); +} +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); @@ -269,20 +433,44 @@ Region::maybe_uncopy () void Region::first_edit () { - if (_first_edit != EditChangesNothing && _playlist) { + boost::shared_ptr pl (playlist()); + + if (_first_edit != EditChangesNothing && pl) { - _name = _playlist->session().new_region_name (_name); + _name = _session.new_region_name (_name); _first_edit = EditChangesNothing; - send_change (NameChanged); + send_change (ARDOUR::NameChanged); RegionFactory::CheckNewRegion (shared_from_this()); } } +bool +Region::at_natural_position () const +{ + boost::shared_ptr pl (playlist()); + + if (!pl) { + return false; + } + + boost::shared_ptr 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 pl (playlist()); + + if (!pl) { return; } @@ -292,32 +480,82 @@ Region::move_to_natural_position (void *src) set_position (whole_file_region->position() + _start, 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 + /* 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 pl (playlist()); + + if (!pl) { + return; + } + + _positional_lock_style = ps; + + if (_positional_lock_style == MusicTime) { + _session.tempo_map().bbt_time (_position, _bbt_time); + } + +} + +void +Region::update_position_after_tempo_map_change () +{ + boost::shared_ptr pl (playlist()); + + if (!pl || _positional_lock_style != MusicTime) { + return; + } + + TempoMap& map (_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 @@ -328,33 +566,40 @@ 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 (boost::shared_ptr(this)); + boost::shared_ptr 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. */ - + send_change (PositionChanged); } void -Region::nudge_position (long n, void *src) +Region::recompute_position_from_lock_style () +{ + if (_positional_lock_style == MusicTime) { + _session.tempo_map().bbt_time (_position, _bbt_time); + } +} + +void +Region::nudge_position (nframes64_t n, void* /*src*/) { if (_flags & Locked) { return; @@ -363,7 +608,9 @@ Region::nudge_position (long n, void *src) if (n == 0) { return; } - + + _last_position = _position; + if (n > 0) { if (_position > max_frames - n) { _position = max_frames; @@ -371,26 +618,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 @@ -407,26 +657,21 @@ 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) { start_shift = new_position - _position; } else { @@ -447,7 +692,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; @@ -459,29 +704,23 @@ Region::trim_start (jack_nframes_t new_position, void *src) if (new_start == _start) { return; } - + _start = new_start; _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; @@ -490,20 +729,20 @@ 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 */ - + new_position = max (new_position, source_zero); - - + + if (new_position > _position) { newlen = _length - (new_position - _position); } else { newlen = _length + (_position - new_position); } - + trim_to_internal (new_position, newlen, src); if (!_frozen) { recompute_at_start (); @@ -511,15 +750,19 @@ Region::trim_front (jack_nframes_t new_position, void *src) } } +/** @param new_endpoint New region end point, such that, for example, + * a region at 0 of length 10 has an endpoint of 9. + */ + void -Region::trim_end (jack_nframes_t new_endpoint, void *src) +Region::trim_end (nframes_t new_endpoint, void */*src*/) { if (_flags & Locked) { return; } if (new_endpoint > _position) { - trim_to_internal (_position, new_endpoint - _position, this); + trim_to_internal (_position, new_endpoint - _position + 1, this); if (!_frozen) { recompute_at_end (); } @@ -527,7 +770,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; @@ -542,10 +785,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; @@ -568,7 +811,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; @@ -588,31 +831,30 @@ 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); } - + _flags = Region::Flag (_flags & ~WholeFile); if (what_changed & (StartChanged|LengthChanged)) { first_edit (); - } + } 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); } -} +} void Region::set_hidden (bool yn) @@ -640,16 +882,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); } } @@ -658,16 +890,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); } @@ -677,38 +903,40 @@ 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_sync_position (jack_nframes_t absolute_pos) +Region::set_position_locked (bool yn) { - jack_nframes_t file_pos; + if (position_locked() != yn) { + if (yn) { + _flags = Flag (_flags|PositionLocked); + } else { + _flags = Flag (_flags & ~PositionLocked); + } + send_change (LockChanged); + } +} - file_pos = _start + (absolute_pos - _position); +void +Region::set_sync_position (nframes_t absolute_pos) +{ + nframes_t const file_pos = _start + (absolute_pos - _position); if (file_pos != _sync_position) { - + _sync_position = file_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); } @@ -722,13 +950,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 */ @@ -736,7 +963,7 @@ Region::sync_offset (int& dir) const if (_flags & SyncMarked) { if (_sync_position > _start) { dir = 1; - return _sync_position - _start; + return _sync_position - _start; } else { dir = -1; return _start - _sync_position; @@ -747,77 +974,74 @@ 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) { - return _sync_position; + return _sync_position; } else { return _start; } } - void Region::raise () { - if (_playlist == 0) { - return; + boost::shared_ptr pl (playlist()); + if (pl) { + pl->raise_region (shared_from_this ()); } - - _playlist->raise_region (boost::shared_ptr(this)); } void Region::lower () { - if (_playlist == 0) { - return; + boost::shared_ptr pl (playlist()); + if (pl) { + pl->lower_region (shared_from_this ()); } - - _playlist->lower_region (boost::shared_ptr(this)); } + void Region::raise_to_top () { - - if (_playlist == 0) { - return; + boost::shared_ptr pl (playlist()); + if (pl) { + pl->raise_region_to_top (shared_from_this()); } - - _playlist->raise_region_to_top (boost::shared_ptr(this)); } void Region::lower_to_bottom () { - if (_playlist == 0) { - return; + boost::shared_ptr pl (playlist()); + if (pl) { + pl->lower_region_to_bottom (shared_from_this()); } - - _playlist->lower_region_to_bottom (boost::shared_ptr(this)); } void @@ -825,40 +1049,68 @@ 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); } } XMLNode& -Region::state (bool full_state) +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; } @@ -869,68 +1121,197 @@ Region::get_state () } int -Region::set_state (const XMLNode& node) +Region::set_live_state (const XMLNode& node, int /*version*/, 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); + cerr << _name << " start changed\n"; + _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); + cerr << _name << " length changed\n"; + _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); + cerr << _name << " position changed\n"; + _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); + cerr << _name << " layer changed\n"; + _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); + cerr << _name << " sync changed\n"; + _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 = strtoll (prop->value().c_str(), 0, 10); + } else { + _ancestral_start = _start; + } + + if ((prop = node.property ("ancestral-length")) != 0) { + _ancestral_length = strtoll (prop->value().c_str(), 0, 10); + } 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) { + cerr << _name << ": final change to be sent: " << hex << what_changed << dec << endl; + send_change (what_changed); + } + + return 0; +} + +int +Region::set_state (const XMLNode& node, int version) +{ + 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, version, what_changed, true); + return 0; } @@ -938,23 +1319,25 @@ void Region::freeze () { _frozen++; + _last_length = _length; + _last_position = _position; } void -Region::thaw (const string& why) +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); } } @@ -965,26 +1348,45 @@ Region::thaw (const string& why) if (what_changed & LengthChanged) { if (what_changed & PositionChanged) { recompute_at_start (); - } + } recompute_at_end (); } - - save_state (why); - StateChanged (what_changed); + + send_change (what_changed); } 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; - } + } + } + + cerr << _name << " actually sends " << hex << what_changed << dec << " @" << get_microseconds() << endl; + StateChanged (what_changed); + cerr << _name << " done with " << hex << what_changed << dec << " @" << get_microseconds() << endl; + + if (!(_flags & DoNotSendPropertyChanges)) { + + /* Try and send a shared_pointer unless this is part of the constructor. + If so, do nothing. + */ + + try { + boost::shared_ptr rptr = shared_from_this(); + cerr << _name << " actually sends prop change " << hex << what_changed << dec << " @ " << get_microseconds() << endl; + RegionPropertyChanged (rptr); + cerr << _name << " done with prop change @ " << get_microseconds() << endl; + } catch (...) { + /* no shared_ptr available, relax; */ + } } - StateManager::send_state_changed (what_changed); } void @@ -1019,3 +1421,200 @@ Region::region_list_equivalent (boost::shared_ptr other) const { return size_equivalent (other) && source_equivalent (other) && _name == other->_name; } + +void +Region::source_deleted (boost::weak_ptr) +{ + _sources.clear (); + + if (!_session.deletion_in_progress()) { + /* this is a very special case: at least one of the region's + sources has bee deleted, so invalidate all references to + ourselves. Do NOT do this during session deletion, because + then we run the risk that this will actually result + in this object being deleted (as refcnt goes to zero) + while emitting DropReferences. + */ + + drop_references (); + } +} + +vector +Region::master_source_names () +{ + SourceList::iterator i; + + vector 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; + assert (_sources.size() == _master_sources.size()); +} + +bool +Region::source_equivalent (boost::shared_ptr 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::uses_source (boost::shared_ptr source) const +{ + for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) { + if (*i == source) { + return true; + } + } + return false; +} + +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::get_parent() const +{ + boost::shared_ptr pl (playlist()); + + if (pl) { + boost::shared_ptr r; + boost::shared_ptr grrr2 = boost::dynamic_pointer_cast (shared_from_this()); + + if (grrr2 && (r = _session.find_whole_file_parent (grrr2))) { + return boost::static_pointer_cast (r); + } + } + + return boost::shared_ptr(); +} + +int +Region::apply (Filter& filter) +{ + return filter.run (shared_from_this()); +} + + +void +Region::invalidate_transients () +{ + _valid_transients = false; + _transients.clear (); +} + + +void +Region::use_sources (SourceList const & s) +{ + set > unique_srcs; + + for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) { + _sources.push_back (*i); + (*i)->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr(*i))); + unique_srcs.insert (*i); + } + + for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) { + _master_sources.push_back (*i); + if (unique_srcs.find (*i) == unique_srcs.end()) { + (*i)->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr(*i))); + } + } +} +