#include "pbd/enumwriter.h"
#include "ardour/debug.h"
-#include "ardour/region.h"
+#include "ardour/file_source.h"
+#include "ardour/filter.h"
#include "ardour/playlist.h"
+#include "ardour/playlist_source.h"
+#include "ardour/profile.h"
+#include "ardour/region.h"
+#include "ardour/region_factory.h"
#include "ardour/session.h"
#include "ardour/source.h"
+#include "ardour/source_factory.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"
using namespace ARDOUR;
using namespace PBD;
-namespace ARDOUR {
+namespace ARDOUR {
namespace Properties {
PBD::PropertyDescriptor<bool> muted;
PBD::PropertyDescriptor<bool> opaque;
PBD::PropertyDescriptor<float> stretch;
PBD::PropertyDescriptor<float> shift;
PBD::PropertyDescriptor<PositionLockStyle> position_lock_style;
+ PBD::PropertyDescriptor<uint64_t> layering_index;
}
}
-
+
PBD::Signal2<void,boost::shared_ptr<ARDOUR::Region>,const PropertyChange&> Region::RegionPropertyChanged;
void
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for shift = %1\n", Properties::shift.property_id));
Properties::position_lock_style.property_id = g_quark_from_static_string (X_("positional-lock-style"));
DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for position_lock_style = %1\n", Properties::position_lock_style.property_id));
+ Properties::layering_index.property_id = g_quark_from_static_string (X_("layering-index"));
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for layering_index = %1\n", Properties::layering_index.property_id));
}
void
add_property (_length);
add_property (_position);
add_property (_sync_position);
- add_property (_layer);
add_property (_ancestral_start);
add_property (_ancestral_length);
add_property (_stretch);
add_property (_shift);
add_property (_position_lock_style);
+ add_property (_layering_index);
}
#define REGION_DEFAULT_STATE(s,l) \
- _muted (Properties::muted, false) \
+ _sync_marked (Properties::sync_marked, false) \
+ , _left_of_split (Properties::left_of_split, false) \
+ , _right_of_split (Properties::right_of_split, false) \
+ , _valid_transients (Properties::valid_transients, false) \
+ , _start (Properties::start, (s)) \
+ , _length (Properties::length, (l)) \
+ , _position (Properties::position, 0) \
+ , _sync_position (Properties::sync_position, (s)) \
+ , _muted (Properties::muted, false) \
, _opaque (Properties::opaque, true) \
, _locked (Properties::locked, false) \
, _automatic (Properties::automatic, false) \
, _whole_file (Properties::whole_file, false) \
, _import (Properties::import, false) \
, _external (Properties::external, false) \
- , _sync_marked (Properties::sync_marked, false) \
- , _left_of_split (Properties::left_of_split, false) \
- , _right_of_split (Properties::right_of_split, false) \
, _hidden (Properties::hidden, false) \
, _position_locked (Properties::position_locked, false) \
- , _valid_transients (Properties::valid_transients, false) \
- , _start (Properties::start, (s)) \
- , _length (Properties::length, (l)) \
- , _position (Properties::position, 0) \
- , _sync_position (Properties::sync_position, (s)) \
- , _layer (Properties::layer, 0) \
, _ancestral_start (Properties::ancestral_start, (s)) \
, _ancestral_length (Properties::ancestral_length, (l)) \
, _stretch (Properties::stretch, 1.0) \
, _shift (Properties::shift, 1.0) \
- , _position_lock_style (Properties::position_lock_style, _type == DataType::AUDIO ? AudioTime : MusicTime)
+ , _position_lock_style (Properties::position_lock_style, _type == DataType::AUDIO ? AudioTime : MusicTime) \
+ , _layering_index (Properties::layering_index, 0)
#define REGION_COPY_STATE(other) \
- _muted (Properties::muted, other->_muted) \
+ _sync_marked (Properties::sync_marked, other->_sync_marked) \
+ , _left_of_split (Properties::left_of_split, other->_left_of_split) \
+ , _right_of_split (Properties::right_of_split, other->_right_of_split) \
+ , _valid_transients (Properties::valid_transients, other->_valid_transients) \
+ , _start(Properties::start, other->_start) \
+ , _length(Properties::length, other->_length) \
+ , _position(Properties::position, other->_position) \
+ , _sync_position(Properties::sync_position, other->_sync_position) \
+ , _muted (Properties::muted, other->_muted) \
, _opaque (Properties::opaque, other->_opaque) \
, _locked (Properties::locked, other->_locked) \
, _automatic (Properties::automatic, other->_automatic) \
, _whole_file (Properties::whole_file, other->_whole_file) \
, _import (Properties::import, other->_import) \
, _external (Properties::external, other->_external) \
- , _sync_marked (Properties::sync_marked, other->_sync_marked) \
- , _left_of_split (Properties::left_of_split, other->_left_of_split) \
- , _right_of_split (Properties::right_of_split, other->_right_of_split) \
, _hidden (Properties::hidden, other->_hidden) \
, _position_locked (Properties::position_locked, other->_position_locked) \
- , _valid_transients (Properties::valid_transients, other->_valid_transients) \
- , _start(Properties::start, other->_start) \
- , _length(Properties::length, other->_length) \
- , _position(Properties::position, other->_position) \
- , _sync_position(Properties::sync_position, other->_sync_position) \
- , _layer (Properties::layer, other->_layer) \
, _ancestral_start (Properties::ancestral_start, other->_ancestral_start) \
, _ancestral_length (Properties::ancestral_length, other->_ancestral_length) \
, _stretch (Properties::stretch, other->_stretch) \
, _shift (Properties::shift, other->_shift) \
- , _position_lock_style (Properties::position_lock_style, other->_position_lock_style)
+ , _position_lock_style (Properties::position_lock_style, other->_position_lock_style) \
+ , _layering_index (Properties::layering_index, other->_layering_index)
/* derived-from-derived constructor (no sources in constructor) */
Region::Region (Session& s, framepos_t start, framecnt_t length, const string& name, DataType type)
, _last_length (length)
, _last_position (0)
, _first_edit (EditChangesNothing)
- , _read_data_count(0)
- , _last_layer_op(0)
- , _pending_explicit_relayer (false)
+ , _layer (0)
{
register_properties ();
, _last_length (0)
, _last_position (0)
, _first_edit (EditChangesNothing)
- , _read_data_count(0)
- , _last_layer_op (0)
- , _pending_explicit_relayer (false)
+ , _layer (0)
{
register_properties ();
assert (_type == srcs.front()->type());
}
-/** Create a new Region from part of an existing one, starting at one of two places:
-
- if \a offset_relative is true, then the start within \a other is given by \a offset
- (i.e. relative to the start of \a other's sources, the start is \a offset + \a other.start()
-
- if @param offset_relative is false, then the start within the source is given \a offset.
-*/
-Region::Region (boost::shared_ptr<const Region> other, frameoffset_t offset, bool offset_relative)
+/** Create a new Region from an existing one */
+Region::Region (boost::shared_ptr<const Region> other)
: SessionObject(other->session(), other->name())
, _type (other->data_type())
, REGION_COPY_STATE (other)
, _last_length (other->_last_length)
, _last_position(other->_last_position) \
, _first_edit (EditChangesNothing)
- , _read_data_count(0)
- , _last_layer_op (0)
- , _pending_explicit_relayer (false)
-
+ , _layer (other->_layer)
{
register_properties ();
use_sources (other->_sources);
- if (!offset_relative) {
+ _position_lock_style = other->_position_lock_style;
+ _first_edit = other->_first_edit;
- /* not sure why we do this, but its a hangover from ardour before
- property lists. this would be nice to remove.
- */
+ _start = 0; // It seems strange _start is not inherited here?
- _position_lock_style = other->_position_lock_style;
- _first_edit = other->_first_edit;
-
- if (offset == 0) {
-
- _start = 0;
-
- /* 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->sync_marked()) {
- 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. */
- _sync_marked = false;
- _sync_position = _start;
- }
- } else {
- _sync_marked = false;
- _sync_position = _start;
- }
+ /* 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->sync_marked()) {
+ 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 {
- /* XXX do something else ! */
- fatal << string_compose (_("programming error: %1"), X_("Region+offset constructor used with illegal combination of offset+relative"))
- << endmsg;
- /*NOTREACHED*/
+ /* sync pos was before the start point of the other region. not possible here. */
+ _sync_marked = false;
+ _sync_position = _start;
}
-
} else {
+ _sync_marked = false;
+ _sync_position = _start;
+ }
- _start = other->_start + offset;
-
- /* 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 (Profile->get_sae()) {
+ /* reset sync point to start if its ended up
+ outside region bounds.
*/
-
- if (other->sync_marked()) {
- if (other->_sync_position < _start) {
- _sync_marked = false;
- _sync_position = _start;
- } else {
- _sync_position = other->_sync_position;
- }
- } else {
+
+ if (_sync_position < _start || _sync_position >= _start + _length) {
_sync_marked = false;
_sync_position = _start;
}
}
+ assert (_type == other->data_type());
+}
+
+/** Create a new Region from part of an existing one.
+
+ the start within \a other is given by \a offset
+ (i.e. relative to the start of \a other's sources, the start is \a offset + \a other.start()
+*/
+Region::Region (boost::shared_ptr<const Region> other, frameoffset_t offset)
+ : SessionObject(other->session(), other->name())
+ , _type (other->data_type())
+ , REGION_COPY_STATE (other)
+ , _last_length (other->_last_length)
+ , _last_position(other->_last_position) \
+ , _first_edit (EditChangesNothing)
+ , _layer (other->_layer)
+{
+ register_properties ();
+
+ /* override state that may have been incorrectly inherited from the other region
+ */
+
+ _position = 0;
+ _locked = false;
+ _whole_file = false;
+ _hidden = false;
+
+ use_sources (other->_sources);
+
+ _start = other->_start + offset;
+
+ /* 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->sync_marked()) {
+ if (other->_sync_position < _start) {
+ _sync_marked = false;
+ _sync_position = _start;
+ } else {
+ _sync_position = other->_sync_position;
+ }
+ } else {
+ _sync_marked = false;
+ _sync_position = _start;
+ }
+
if (Profile->get_sae()) {
/* reset sync point to start if its ended up
outside region bounds.
, _last_length (other->_last_length)
, _last_position (other->_last_position)
, _first_edit (EditChangesID)
- , _read_data_count (0)
- , _last_layer_op (other->_last_layer_op)
- , _pending_explicit_relayer (false)
+ , _layer (other->_layer)
{
register_properties ();
if (_name != str) {
SessionObject::set_name(str); // EMIT SIGNAL NameChanged()
assert(_name == str);
+
send_change (Properties::name);
}
}
void
-Region::set_length (framecnt_t len, void */*src*/)
+Region::set_length (framecnt_t len)
{
//cerr << "Region::set_length() len = " << len << endl;
if (locked()) {
_first_edit = EditChangesNothing;
send_change (Properties::name);
+
RegionFactory::CheckNewRegion (shared_from_this());
}
}
}
void
-Region::move_to_natural_position (void *src)
+Region::move_to_natural_position ()
{
boost::shared_ptr<Playlist> pl (playlist());
boost::shared_ptr<Region> whole_file_region = get_parent();
if (whole_file_region) {
- set_position (whole_file_region->position() + _start, src);
+ set_position (whole_file_region->position() + _start);
}
}
if (_position_lock_style != ps) {
boost::shared_ptr<Playlist> pl (playlist());
-
- if (!pl) {
- return;
- }
-
+
_position_lock_style = ps;
-
+
if (_position_lock_style == MusicTime) {
- _session.tempo_map().bbt_time (_position, _bbt_time);
+ _session.bbt_time (_position, _bbt_time);
}
send_change (Properties::position_lock_style);
}
void
-Region::update_position_after_tempo_map_change ()
+Region::update_after_tempo_map_change ()
{
boost::shared_ptr<Playlist> pl (playlist());
}
void
-Region::set_position (framepos_t pos, void* /*src*/)
+Region::set_position (framepos_t pos)
{
if (!can_move()) {
return;
a GUI that has moved its representation already.
*/
send_change (Properties::position);
-
+
}
void
Region::set_position_internal (framepos_t pos, bool allow_bbt_recompute)
{
+ /* We emit a change of Properties::position even if the position hasn't changed
+ (see Region::set_position), so we must always set this up so that
+ e.g. Playlist::notify_region_moved doesn't use an out-of-date last_position.
+ */
+ _last_position = _position;
+
if (_position != pos) {
- _last_position = _position;
_position = pos;
/* check that the new _position wouldn't make the current
}
}
-void
-Region::set_position_on_top (framepos_t pos, void* /*src*/)
-{
- if (locked()) {
- return;
- }
-
- if (_position != pos) {
- set_position_internal (pos, true);
- }
-
- 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.
- */
-
- send_change (Properties::position);
-}
-
void
Region::recompute_position_from_lock_style ()
{
if (_position_lock_style == MusicTime) {
- _session.tempo_map().bbt_time (_position, _bbt_time);
+ _session.bbt_time (_position, _bbt_time);
}
}
void
-Region::nudge_position (frameoffset_t n, void* /*src*/)
+Region::nudge_position (frameoffset_t n)
{
if (locked()) {
return;
}
void
-Region::set_start (framepos_t pos, void* /*src*/)
+Region::set_start (framepos_t pos)
{
if (locked() || position_locked()) {
return;
}
void
-Region::trim_start (framepos_t new_position, void */*src*/)
+Region::trim_start (framepos_t new_position)
{
if (locked() || position_locked()) {
return;
} else {
new_start = _start + start_shift;
}
-
+
} else {
return;
}
}
void
-Region::trim_front (framepos_t new_position, void *src)
+Region::trim_front (framepos_t new_position)
{
- modify_front (new_position, false, src);
+ modify_front (new_position, false);
}
void
-Region::cut_front (framepos_t new_position, void *src)
+Region::cut_front (framepos_t new_position)
{
- modify_front (new_position, true, src);
+ modify_front (new_position, true);
}
void
-Region::cut_end (framepos_t new_endpoint, void *src)
+Region::cut_end (framepos_t new_endpoint)
{
- modify_end (new_endpoint, true, src);
+ modify_end (new_endpoint, true);
}
void
-Region::modify_front (framepos_t new_position, bool reset_fade, void *src)
+Region::modify_front (framepos_t new_position, bool reset_fade)
{
if (locked()) {
return;
}
if (new_position < end) { /* can't trim it zero or negative length */
-
+
framecnt_t newlen = 0;
framepos_t delta = 0;
/* can't trim it back past where source position zero is located */
new_position = max (new_position, source_zero);
}
-
+
if (new_position > _position) {
newlen = _length - (new_position - _position);
delta = -1 * (new_position - _position);
newlen = _length + (_position - new_position);
delta = _position - new_position;
}
-
- trim_to_internal (new_position, newlen, src);
-
+
+ trim_to_internal (new_position, newlen);
+
if (reset_fade) {
_right_of_split = true;
}
-
+
if (!property_changes_suspended()) {
recompute_at_start ();
}
-
+
if (_transients.size() > 0){
adjust_transients(delta);
}
}
void
-Region::modify_end (framepos_t new_endpoint, bool reset_fade, void* /*src*/)
+Region::modify_end (framepos_t new_endpoint, bool reset_fade)
{
if (locked()) {
return;
}
if (new_endpoint > _position) {
- trim_to_internal (_position, new_endpoint - _position +1, this);
+ trim_to_internal (_position, new_endpoint - _position);
if (reset_fade) {
_left_of_split = true;
}
*/
void
-Region::trim_end (framepos_t new_endpoint, void* src)
+Region::trim_end (framepos_t new_endpoint)
{
- modify_end (new_endpoint, false, src);
+ modify_end (new_endpoint, false);
}
void
-Region::trim_to (framepos_t position, framecnt_t length, void *src)
+Region::trim_to (framepos_t position, framecnt_t length)
{
if (locked()) {
return;
}
- trim_to_internal (position, length, src);
+ trim_to_internal (position, length);
if (!property_changes_suspended()) {
recompute_at_start ();
}
void
-Region::trim_to_internal (framepos_t position, framecnt_t length, void */*src*/)
+Region::trim_to_internal (framepos_t position, framecnt_t length)
{
framepos_t new_start;
_start = new_start;
what_changed.add (Properties::start);
}
- if (_length != length) {
- if (!property_changes_suspended()) {
- _last_length = _length;
- }
- set_length_internal (length);
- what_changed.add (Properties::length);
- }
+
+ /* Set position before length, otherwise for MIDI regions this bad thing happens:
+ * 1. we call set_length_internal; length in beats is computed using the region's current
+ * (soon-to-be old) position
+ * 2. we call set_position_internal; position is set and length in frames re-computed using
+ * length in beats from (1) but at the new position, which is wrong if the region
+ * straddles a tempo/meter change.
+ */
+
if (_position != position) {
if (!property_changes_suspended()) {
_last_position = _position;
what_changed.add (Properties::position);
}
+ if (_length != length) {
+ if (!property_changes_suspended()) {
+ _last_length = _length;
+ }
+ set_length_internal (length);
+ what_changed.add (Properties::length);
+ }
+
_whole_file = false;
PropertyChange start_and_length;
if (!property_changes_suspended()) {
maybe_uncopy ();
}
+
send_change (Properties::sync_position);
}
}
if (!property_changes_suspended()) {
maybe_uncopy ();
}
+
send_change (Properties::sync_position);
}
}
void
Region::set_layer (layer_t l)
{
- if (_layer != l) {
- _layer = l;
-
- send_change (Properties::layer);
- }
+ _layer = l;
}
XMLNode&
add_properties (*node);
- _id.print (buf, sizeof (buf));
+ id().print (buf, sizeof (buf));
node->add_property ("id", buf);
node->add_property ("type", _type.to_string());
node->add_property (buf2, buf);
}
+ /* Only store nested sources for the whole-file region that acts
+ as the parent/root of all regions using it.
+ */
+
+ if (_whole_file && max_source_level() > 0) {
+
+ XMLNode* nested_node = new XMLNode (X_("NestedSource"));
+
+ /* region is compound - get its playlist and
+ store that before we list the region that
+ needs it ...
+ */
+
+ for (SourceList::const_iterator s = _sources.begin(); s != _sources.end(); ++s) {
+ nested_node->add_child_nocopy ((*s)->get_state ());
+ }
+
+ if (nested_node) {
+ node->add_child_nocopy (*nested_node);
+ }
+ }
+
if (_extra_xml) {
node->add_child_copy (*_extra_xml);
}
{
const XMLProperty* prop;
+ Stateful::save_extra_xml (node);
+
what_changed = set_values (node);
- if ((prop = node.property (X_("id")))) {
- _id = prop->value();
- }
+ set_id (node);
if (_position_lock_style == MusicTime) {
if ((prop = node.property ("bbt-position")) == 0) {
if (_stretch == 0.0f) {
_stretch = 1.0f;
}
-
+
if (_shift == 0.0f) {
_shift = 1.0f;
}
- const XMLNodeList& nlist = node.children();
-
- for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
- XMLNode *child;
-
- child = (*niter);
-
- if (child->name () == "Extra") {
- delete _extra_xml;
- _extra_xml = new XMLNode (*child);
- break;
- }
- }
-
if (send) {
send_change (what_changed);
}
-
+
/* Quick fix for 2.x sessions when region is muted */
if ((prop = node.property (X_("flags")))) {
if (string::npos != prop->value().find("Muted")){
set_muted (true);
}
}
-
+
return 0;
}
Stateful::send_change (what_changed);
- if (!Stateful::frozen()) {
-
+ if (!Stateful::property_changes_suspended()) {
+
/* Try and send a shared_pointer unless this is part of the constructor.
If so, do nothing.
*/
}
}
-void
-Region::set_last_layer_op (uint64_t when)
-{
- _last_layer_op = when;
-}
-
bool
Region::overlap_equivalent (boost::shared_ptr<const Region> other) const
{
{
if (!other)
return false;
-
+
if ((_sources.size() != other->_sources.size()) ||
(_master_sources.size() != other->_master_sources.size())) {
return false;
return true;
}
+std::string
+Region::source_string () const
+{
+ //string res = itos(_sources.size());
+
+ stringstream res;
+ res << _sources.size() << ":";
+
+ SourceList::const_iterator i;
+
+ for (i = _sources.begin(); i != _sources.end(); ++i) {
+ res << (*i)->id() << ":";
+ }
+
+ for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+ res << (*i)->id() << ":";
+ }
+
+ return res.str();
+}
+
bool
Region::uses_source (boost::shared_ptr<const Source> source) const
{
if (*i == source) {
return true;
}
+
+ boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource> (*i);
+
+ if (ps) {
+ if (ps->playlist()->uses_source (source)) {
+ return true;
+ }
+ }
}
+
return false;
}
{
_valid_transients = false;
_transients.clear ();
-
+
send_change (PropertyChange (Properties::valid_transients));
}
return ct;
}
- /* if not locked, we can always move the front later, and the end earlier
+ /* if not locked, we can always move the front later, and the end earlier
*/
ct = CanTrim (ct | FrontTrimLater | EndTrimEarlier);
return ct;
}
-
+
+uint32_t
+Region::max_source_level () const
+{
+ uint32_t lvl = 0;
+
+ for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+ lvl = max (lvl, (*i)->level());
+ }
+
+ return lvl;
+}
+
+bool
+Region::is_compound () const
+{
+ return max_source_level() > 0;
+}
+
+void
+Region::post_set (const PropertyChange& pc)
+{
+ if (pc.contains (Properties::position)) {
+ recompute_position_from_lock_style ();
+ }
+}
+
projects / ardour.git / blobdiff